/* ++									      */
/* Nom                                                                        */
/*		INSTALL_UTIL.CDCL                                             */
/*                                                                            */
/* Description                                                                */
/*	Procédure de controle de l'existance de l'arborescence ULT$...        */
/*	Si celle-ci n'existe pas, elle propose sa création. Si l'utilisateur  */
/*	refuse cette création, il a encore la ressource de redéfinir les noms */
/*	logiques UTL$... utilisés.                                            */
/*	Cette redéfinition peut etre faite au niveau de l'utilisateur ou du   */
/*	système.                                                              */
/*                                                                            */
/* Utilisation                                                                */
/* 	@INSTALL_UTIL                                                         */
/*	Cette procedure est lancee par les procedures d'installation des      */
/*	logiciels LAL							      */
/*                                                                            */
/* Priviléges éventuels                                                       */
/*	Création de directories.                                              */
/*	Définition de noms logiques.                                          */
/*	Copie des fichiers dans les directories de receptions.                */
/*                                                                            */
/* Parametres                                                                 */
/*	La procedure n'attent pas de parametre en entree.                     */
/*	En sortie, elle definie un status de sortie                           */
/*		Ce status est 1, si le nom logique UTL$SYSTEM a pu etre       */
/*		definie                                                       */
/*		Le status est 0, si l'utilisateur ne veut pas creer	      */
/*		l'arborescence						      */
/*		En cas d'erreur, le code d'erreur est retourne		      */
/*                                                                            */
/* Création                                                                   */
/*	22 Avril 1986 : JN Albert - LAL                                       */
/*                                                                            */
/* Modification                                                               */
/* --                                                                         */

/* Existance des noms logiques UTL$SYSROOT, UTL$SYSTEM                        */

   utl_sysroot = F$Edit(F$Logical("UTL$SYSROOT"), "TRIM")
   utl_system  = F$Edit(F$Logical("UTL$SYSTEM"),  "TRIM")

   /* Le nom logique existe - Pas de probleme   */

   if (utl_sysroot .nes. "" .and. utl_system .nes. "")
         Exit 1


/* Noms logiques non définis						*/

   Type SYS$INPUT
#
# 	Les noms logiques UTL$SYSROOT ou UTL$SYSTEM ne sont pas definis.
#
# La structure des directories UTL$... est :
#
#		Disque --->  [Racine]		: UTL$SYSROOT
#			---------+---------
#			|        |        |
#		     [sysmgr] [sysexe] [syshlp] : UTL$MANAGER
#						  UTL$SYSTEM
#						  UTL$HELP
#
# Il est possible de :
#
#	Definir le nom logique UTL$SYSROOT au niveau SYSTEM
#
#	Definir le nom logique UTL$SYSROOT au niveau PROCESS
#
#            Attention, dans ces deux derniers cas, le directory destine a
#         contenir la racine UTL$SYSROOT doit deja exister
#

   inquire create_dir "Voulez-vous creer l'arborescence UTL$... (Y/N) "
                                                     
   if (create_dir)
      {                                                   

/*	Creation de l'arborescence   */

         Type Sys$Input
#
#   Par defaut, l'arborescence est definie par :
#
#            disque         ---      SYS$SYSDEVICE
#            racine         ---      [UTIL]

         for (;;)
            {               
               Inquire Disque "Nom du disque (SYS$SYSDEVICE) "
               if (Disque .eqs. "")
                  {
                     Disque = "SYS$SYSDEVICE"
                     break
                  }
               else
		  {
			if (F$Getdvi(Disque,"EXISTS"))
			   {
				Flg_Avl = F$Getdvi(Disque,"AVL")
				Flg_Dir = F$Getdvi(Disque,"DIR")
				if (Flg_Avl .and. Flg_Dir) 
							  break
			   }
                        write sys$output "Disque non utilisable !"
		  }
            }
         Inquire Racine "Nom directory de la racine UTL$SYSROOT (UTIL) "
         if (Racine .eqs. "")
            Racine = "UTIL"

         Option = "SYSTEM"

      }
   else
      {
         inquire Def_Sys "Voulez-vous definir UTL$SYSROOT au niveau SYSTEM (Y/N) "
         if (Def_Sys)
               Option = "SYSTEM"
         else
            {
               inquire Def_Prc \
                  "Voulez-vous definir UTL$SYSROOT au niveau PROCESS (Y/N) "
               if (Def_Prc)
                     Option = "PROCESS"
               else
                  {
			/************************************************/
			/*	Impossible de definir UTL$SYSROOT	*/
			/*						*/
			/*		Sortie avec STATUS d'erreur	*/
			/************************************************/

                     Write Sys$Output "Impossible d'installer UTL$..."
                     Exit 0
                  }  
            }
         for (;;)
            {
               if (Def_Sys)
                  {
                     Inquire Disque "Nom du disque (SYS$SYSDEVICE) "
                     if (Disque .eqs. "")
                           Disque = "SYS$SYSDEVICE"
                  }
               else
                  {
                     Inquire Disque "Nom du disque (SYS$DISK) "
                     if (Disque .eqs. "")
                           Disque = "SYS$DISK"
                  }
		if (F$Getdvi(Disque,"EXISTS"))
		   {
			Flg_Avl = F$Getdvi(Disque,"AVL")
			Flg_Dir = F$Getdvi(Disque,"DIR")
			if (Flg_Avl .and. Flg_Dir) 
						  break
		   }
                       write sys$output "Disque non utilisable !"
            }

	for (;;)
	    {
	         do
	            {
	               Inquire Racine \
				"Nom du directory UTL$SYSROOT [Pas de defaut] "
	            }
	         while (Racine .eqs. "")
		 Racine = Racine - "[" - "]"
		 Disque = Disque - ":"
		 Open/Write/Error=Direct_err Tst 'disque':['racine']TEST.TMP
		 Close Tst
		 Delete 'disque':['racine']TEST.TMP;
	     	 break
DIRECT_ERR:
		 Write Sys$Output ""
		 Write Sys$Output "Nom de directory incorrect"
		 Write Sys$Output ""
	    }
      }

   Type SYS$INPUT
#
#   Deux procedures de commandes peuvent etre placees dans UTL$SYSTEM pour
#   faciliter la manipulation des utilitaires.
#
#   UTIL.COM   - Definit un symbole permettant d'utiliser l'utilitaire comme
#                une commande.
#            Ex:
#               UTIL @Edit_fontes
#                     Definie le symbole 'EDIT_FONTES'
#
#               On peut ensuite taper 
#                           EDIT_FONTES 
#               au lieu de 
#                           @UTL$SYSTEM:EDIT_FONTES
#
#   EXECUTE.COM - Lance directement l'execution d'un utilitaire
#            Ex:
#               EXECUTE Edit_Fontes
#

      inquire procedure_utl \
            "Voulez-vous la copie de ces procedures dans UTL$SYSTEM (Y/N) "


   /*   Creation de l'arborescence et definition des noms logiques   */

   on error then Exit $Status

   write sys$output "Fin des choix"

   disque = disque - ":"
   racine = racine - "[" - "]"    

   Write sys$output "Creation des directories et des noms logiques"

   if (create_dir)
         create/directory 'disque':['racine']

   Assign/'Option'/Translate=(Concealed,Terminal) \
                              'disque':['racine'.]   UTL$SYSROOT:

   Create/directory  UTL$SYSROOT:[SYSMGR]
   Assign/'Option'   UTL$SYSROOT:[SYSMGR]   UTL$MANAGER

   Create/directory  UTL$SYSROOT:[SYSEXE]
   Assign/'Option'   UTL$SYSROOT:[SYSEXE]   UTL$SYSTEM

   Create/directory  UTL$SYSROOT:[SYSHLP]
   Assign/'Option'   UTL$SYSROOT:[SYSHLP]   UTL$HELP


   /* Creation du fichier de definition   */

   write sys$output "Creation du fichier de Startup"

   Open/Write utl Utlstartup.com
   Write utl "$!"
   Write utl "$! Nom"
   Write utl "$!         UTLSTARTUP.COM"
   Write utl "$! Description"
   Write utl "$!   Definition des noms logiques UTL$..."
   Write utl "$!"
   Write utl "$! Creation "
   Write utl "$!    ", F$Cvtime("TODAY","ABSOLUTE","DATE"), " : ",\
                              F$Getjpi("","USERNAME")
   Write utl "$!"
   Write utl "$ Assign/",Option,"/Translate=(Concealed,Terminal) ",\
                              disque, ":[", racine, ".]   UTL$SYSROOT:"
   Write utl "$ Assign/",Option,"    UTL$SYSROOT:[SYSMGR]   UTL$MANAGER"
   Write utl "$ Assign/",Option,"    UTL$SYSROOT:[SYSEXE]   UTL$SYSTEM"
   Write utl "$ Assign/",Option,"    UTL$SYSROOT:[SYSHLP]   UTL$HELP"
   Write utl "$ Exit"
   Close Utl

   /* Copie des procedures de definition  */

   write sys$output "Copie des procedures de definition"

   Copy/log utlstartup.com UTL$MANAGER:
   manager = racine + ".SYSMGR"
   
   if (option .eqs. "SYSTEM")
      {
         Type SYS$INPUT
#
#   Le fichier UTL$MANAGER:UTLSTARTUP.COM contient les definitions des noms 
#   logiques UTL$... Il peut etre appelle depuis la procedure
#   SYS$MANAGER:SYSTARTUP.COM pour etre pris en compte a chaque demarrage
#   du VAX par la ligne :
#
      }
   else
      {
         Type SYS$INPUT
#
#   Le fichier UTL$MANAGER:UTLSTARTUP.COM contient les definitions des noms 
#   logiques UTL$... Il peut etre appelle dans votre LOGIN.COM pour
#   etre pris en compte a chaque login par la ligne :
#
      }

   write sys$output "		$  @",disque,":[",manager,"]UTLSTARTUP.COM"

   if (procedure_utl)
      {
         Copy util.com,execute.com UTL$SYSTEM
         Type Sys$Input
#
#   Les procedures UTIL.COM et EXECUTE.COM sont copiees dans UTL$SYSTEM.
#   Elles peuvent etre definie a chaque login par les lignes ajoutees au
         if (option .eqs. "SYSTEM")
            {
               write sys$output "   fichier SYS$MANAGER:SYLOGIN.COM"
            }
         else
            {
               write sys$output "   fichier SYS$LOGIN:LOGIN.COM"
            }

      write sys$output ""
      write sys$output "	$ UTIL == ""@ UTL$SYSTEM:UTIL"" "
      write sys$output "	$ EXE*CUTE == ""@ UTL$SYSTEM:EXECUTE"" "

      }

   write sys$output ""
   write sys$output "Fin de l'installation des UTL$..."

   Exit 1