DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download
Index: ┃ T V

⟦26cab3043⟧ TextFile

    Length: 35598 (0x8b0e)
    Types: TextFile
    Names: »V«

Derivation

└─⟦5829e5ed5⟧ Bits:30000534 8mm tape, Rational 1000, RCI 2_0_5
    └─ ⟦c9a165082⟧ »DATA« 
        └─⟦c3895f76e⟧ 
            └─⟦this⟧ 

TextFile

with Compilation;
package Rci is

    -- The following routines are RCI extensions to the Environment's
    -- compilation command set.


    --| NON-ADA OPERATIONS |--

    -- The RCI supports the use of non-Ada text units as well as Ada units.
    -- These non-Ada units, also known as secondary text files, can be
    -- maintained on an R1000 and downloaded and built on a remote machine.
    -- Each such non-Ada unit is associated with an Ada unit, called a Primary,
    -- through an associated file called the secondary referencer.  A primary
    -- can have several secondary referencers and hence can be associated with
    -- several secondary text files.  The RCI will use the Primary's
    -- dependencies to determine the compilation ordering for the secondary
    -- text files.
    --
    -- Whenever a Primary which has a Secondary is promoted to the Coded state,
    -- the RCI will send the secondary text file to the remote machine, and the
    -- secondary will be built there using the build command string that is
    -- associated with the Secondary.  The Primary will be downloaded and
    -- processed only if the Process_Primary flag associated with it is set to
    -- True.  If the Secondary is subsequently edited (using the Edit_Secondary
    -- command) on the R1000, the associated Primary will first be demoted to
    -- the installed state.  This means that the changed secondary unit will be
    -- downloaded to the remote machine and compiled there as soon as the
    -- Primary is re-Coded.
    --
    -- To make inadvertent changes to secondary text units more difficult, they
    -- will be frozen in the R1000 library whenever their Primary is promoted
    -- to the Coded state.  All secondary commands operate on the secondary
    -- referencer file instead of the secondary text file.
    --
    -- The following restrictions apply:
    --   . A secondary text file cannot be associated with more than one
    --     primary.
    --   . A primary unit cannot be an Ada subunit.


    procedure Create_Secondary (Primary_Unit    : String  := "<CURSOR>";
                                Command         : String  := "";
                                Secondary_Text  : String  := "";
                                Remote_Name     : String  := "<DEFAULT>";
                                Process_Primary : Boolean := False;
                                Response        : String  := "<PROFILE>");

    -- Create_Secondary associates a specified Secondary_Text file with an Ada
    -- Primary_Unit.  The Secondary_Text file will be created if it does not
    -- already exist.
    --
    -- The primary unit points to the secondary text file using a pointy file
    -- called the "secondary referencer".  The secondary referencer will be of
    -- the form
    --      "primary_unit_name.<secondary_text_file_name>".
    --
    -- The secondary referencer file will contain the following information:
    --   1. Name of the Secondary_Text file that is to be associated with the
    --      primary.
    --   2. Command that is to be executed on the remote machine after
    --      the secondary text file is downloaded.
    --   3. Remote_Name of the unit into which the secondary text file is to be
    --      downloaded.
    --   4. Download time of the secondary text file to the remote machine.
    --
    -- If an Ada unit has a secondary, that Primary_Unit will not normally be
    -- processed on the remote machine, but it will be downloaded and processed
    -- if the Process_Primary flag associated with it is set to True.
    --
    -- If Primary_Unit is in the coded state, it will be demoted to installed
    -- before its secondary referencer is created.
    --
    -- For example:
    --         Create_Secondary (Primary_Unit     => "tulip'body",
    --                           Command          => "cc -c open.c",
    --                           Secondary_Text   => "open_c";
    --                           Remote_Name      => "open.c";
    --                           Process_Primary  => False;
    --
    -- will result in:
    --
    --        Open_C                :   File (Text)
    --        Tulip'Body            : I Ada         ==> Primary
    --          .<Secondary_Open_C> :   File (Text) ==> Secondary referencer
    --
    -- When Tulip'Body is promoted to the coded state, the secondary text file
    -- Open_C will be downloaded into "open.c" on the remote machine, and the
    -- command "cc -c open.c" will be executed there.


    procedure Remove_Secondary (Secondary_Referencer : String := "<CURSOR>";
                                Response             : String := "<PROFILE>");

    -- Removes the specified Secondary_Referencer, thus breaking the
    -- association between the primary and a secondary unit.  If the primary
    -- unit is in the coded state, it will be demoted to installed before its
    -- secondary referencer is removed.  The secondary text file that was
    -- associated with the secondary referencer will not be deleted.  No
    -- changes will be made on the the remote machine; in particular, the copy
    -- of the secondary unit will not be removed from the remote machine, so a
    -- recompilation of Primary_Unit will be necessary to make it consistent
    -- with its correct associated remote unit.


    procedure Show_Secondary (Primary_Unit : String := "<CURSOR>";
                              Response     : String := "<PROFILE>");

    -- If an Ada unit is a Primary, this command displays the information about
    -- the secondaries that are associated with it.  The following information
    -- is displayed:
    --      1. Process_Primary flag, which determines whether the primary will
    --         be processed
    --      2. Names of the Secondary_Text units associated with the primary
    --      3. Remote_Names of the secondary text files
    --      4. Remote Commands associated with the secondary text files
    -- The Primary_Unit parameter can be a naming expression that refers to
    -- more than one unit in a view, so the display will include all of the
    -- named units (which must be Ada units).


    procedure Edit_Secondary (Secondary_Referencer : String  := "<CURSOR>";
                              In_Place             : Boolean := False;
                              Visible              : Boolean := True;
                              Response             : String  := "<PROFILE>");

    -- Allows the user to edit a secondary text file that is associated with a
    -- Primary_Unit.  The secondary text file on the R1000 will be opened for
    -- editing and brought up in a window on the screen.
    --
    -- If the Primary is coded, it will be demoted to Installed before the Edit
    -- begins.  If so, the secondary text unit is expected to be in the frozen
    -- state, and it will be unfrozen so the Edit can proceed.  When the
    -- Primary is promoted back to the Coded state, the RCI downloads the
    -- changed Secondary file to the remote machine, compiles it there, and
    -- then re-freezes its copy on the R1000.
    --
    -- Note that a secondary text file is edited by selecting its referencer.


    procedure Set_Process_Primary (Primary_Unit : String  := "<CURSOR>";
                                   Value        : Boolean := False;
                                   Response     : String  := "<PROFILE>");

    -- Sets the Process_Primary flag to Value for the specified Primary_Unit.
    -- Setting this flag to True will cause the primary to be downloaded and
    -- processed on the remote machine in addition to its secondaries.


    procedure Set_Secondary_Command
                 (Command              : String := "";
                  Secondary_Referencer : String := "<CURSOR>";
                  Response             : String := "<PROFILE>");

    -- Associates the given Command string with a secondary by specifying its
    -- Secondary_Referencer.  The Command will be executed on the remote
    -- machine when the associated secondary text file is downloaded.



    --| CONSISTENCY MANAGEMENT OPERATIONS |--

    -- The following operations provide minimal support for management of
    -- consistency between units in views on the R1000 host and the
    -- corresponding objects on remote targets.  Users are allowed to make
    -- changes, at will, to remote source.  Such changes are not, however,
    -- monitored by the RCI system, so it is the responsibility of the user to
    -- make sure that host and remote source remain consistent.
    --
    -- Check_Consistency checks whether a unit has been edited remotely since
    -- it was last downloaded.
    --
    -- Accept_Remote_Changes uploads changes made remotely, making host units
    -- consistent with their remote counterparts.  Note that in order to
    -- overwrite changes made remotely, the user simply needs to recompile the
    -- corresponding host unit, which will cause a new copy of the host unit to
    -- be downloaded to the remote machine.
    --
    -- Upload_Unit and Upload_Units transfer one or more units from the remote
    -- system to the host system.  These are to be used on objects that don't
    -- currently reside in the host view.  The purpose of these routines is to
    -- allow the migration of remotely maintained/created code to a Rational
    -- view.


    procedure Check_Consistency (Unit            : String  := "<CURSOR>";
                                 Compare_Objects : Boolean := False;
                                 Response        : String  := "<PROFILE>");

    -- Given a naming expression describing some number of units from a single
    -- view, or an entire view, this checks the consistency of these units
    -- against the corresponding units in the remote directory.
    --
    -- Consistency checking between a host unit and the associated remote unit
    -- is governed by the Compare_Objects parameter. If this parameter is set
    -- to False, consistency is checked by comparing the host's download time
    -- with the edit time of the remote unit.  If Compare_Objects is set to
    -- True, the remote unit is uploaded and its text is then compared with
    -- that of the host unit for consistency.
    --
    -- Only Ada units and secondary text files are checked for consistency.
    --
    -- This routine does not check whether a host unit has changed since it was
    -- last downloaded.


    procedure Accept_Remote_Changes
                 (Unit : String := "<CURSOR>";
                  Allow_Demotion : Boolean := False;
                  Compare_Objects : Boolean := False;
                  Remake_Demoted_Units : Boolean := True;
                  Goal : Compilation.Unit_State := Compilation.Coded;
                  Response : String := "<PROFILE>");

    -- Given a naming expression specifying some number of host units from a
    -- single RCI view, or an entire RCI view, this uploads any changes from
    -- the associated remote units into the host units (to make the host units
    -- consistent with their associated remote copies).  Only units that have
    -- changed remotely since they were last downloaded will be uploaded.
    --
    -- If Compare_Objects is True, consistency is checked by comparing the text
    -- in the host and remote objects.  Otherwise only their time stamps will
    -- be compared.
    --
    -- Host units must be checked out (by CMVC) in order for changes to be
    -- uploaded into them.  They must also be demoted to source, and they will
    -- be demoted automatically unless Allow_Demotion is False.  Uploaded units
    -- will be re-promoted to the specified Goal state if Remake_Demoted_Units
    -- is True.


    procedure Upload_Unit (Remote_Unit_Name : String := ">>REMOTE UNIT NAME<<";
                           Into_View : String := "<CURSOR>";  
                           Upload_To_Text_File : Boolean := False;
                           Host_Text_File_Name : String := "";
                           Response : String := "<PROFILE>");

    -- Uploads a remote unit into a host view.  This should only be used to
    -- upload new units, which were created on the remote machine and don't
    -- exist on the host, into the host view.
    --
    -- If Upload_To_Text_File = False, the host unit name will be the name of
    -- the Ada compilation unit.  If Upload_To_Text_File = True, a non-null
    -- Host_Text_File_Name must be supplied, and the remote unit will be
    -- uploaded to the given text unit, with no attempt being made to parse the
    -- remote object into an Ada unit.


    procedure Upload_Units (Upload_Specification_File : String := "";
                            Into_View                 : String := "<CURSOR>";  
                            Response                  : String := "<PROFILE>");

    -- Uploads remote units into host units as specified by the named
    -- Upload_Specification_File.  This should only be used to upload new
    -- units, which were created on the remote machine and don't exist on the
    -- host, into the host view.
    --
    -- Each line of the upload specification file must contain the following
    -- two fields separated by blanks:
    --        1. Remote unit name           (string)
    --        2. Host text file name        (string)
    --
    -- If no host text file name is specified, an attempt is made to upload the
    -- remote unit into an Ada unit on the host.
    --
    --    For example, a file containing the lines:
    --             x.c      x_c
    --             y.ada
    --
    -- specifies that the remote unit "x.c" is to be copied to the host text
    -- file "x_c", and remote unit "y.ada" is to be copied to host Ada unit
    -- "y'spec".



    --| UNIT OPERATIONS |--

    procedure Link (Main_Unit          : String  := "<CURSOR>";
                    Make_Uncoded_Units : Boolean := False;
                    Executable_Name    : String  := "";
                    Response           : String  := "<PROFILE>");

    -- Links one or more Main_Units on the remote system.  If
    -- Make_Uncoded_Units = True, all uncoded units that Main_Unit needs will
    -- be downloaded and promoted to the coded state before the link operation
    -- is executed.

    -- If Executable_Name specifies a non-null string, that name will be used
    -- as the name of the executable module on the remote machine, instead of
    -- the default name, which will be the name of Main_Unit.  Only one
    -- Main_Unit may be specified if an Executable_Name is non-null.


    procedure Set_Remote_Unit_Name (Remote_Name : String := ">>REMOTE NAME<<";
                                    Unit : String := "<CURSOR>";
                                    Allow_Demotion : Boolean := True;
                                    Response : String := "<PROFILE>");

    -- Unit must specify an Ada unit or a secondary referencer.  This sets the
    -- remote unit name for the given Ada or secondary unit pointed to by the
    -- secondary referencer.  In the case of an Ada unit, when the unit is
    -- downloaded it will be copied into a remote unit with the specified
    -- remote unit name.  For secondary referencers the secondary text file
    -- associated with the primary will be downloaded into the remote unit with
    -- the specified name.
    --
    -- If the host unit is in the coded state, it will normally be demoted to
    -- installed when its remote name is changed, but this demotion can be
    -- circumvented if Allow_Demotion is set to False.


    procedure Show_Remote_Unit_Name (Unit     : String := "<CURSOR>";
                                     Response : String := "<PROFILE>");

    -- Shows the remote name associated with the host Unit.  For Ada units the
    -- RCI assigns a unique default remote name to each host unit, but the
    -- remote name can be changed if necessary.  For secondary referencers the
    -- default remote name is the same as the name of the secondary text file.
    -- It is then the user's responsibility to make sure that the remote name
    -- is unique.


    procedure Show_Units (Unit        : String  := "<CURSOR>";
                          Remote_Name : Boolean := True;
                          Consistency : Boolean := False;
                          Response    : String  := "<PROFILE>");

    -- Given a naming expression describing some number of units in a single
    -- view, or an entire view, displays relevant information about the state
    -- or configuration of each specified unit.
    --
    -- If Remote_Name = True, the remote name(s) of the unit(s) will be
    -- displayed.  It a unit has a Secondary referencer, the displayed remote
    -- name will be that of the Secondary text file.
    --
    -- If Consistency = True, checks whether each remote unit has changed since
    -- it was last downloaded.



    --| UNIT OPTIONS |--

    -- The RCI allows compiler options to be specified on a unit-by-unit basis,
    -- overriding for those units what appears in the switch file.


    procedure Set_Unit_Option (Option_Switch : String := ">>OPTION<<";
                               Switch_Value  : Boolean;
                               Units         : String := "<CURSOR>";
                               Response      : String := "<PROFILE>");
    procedure Set_Unit_Option (Option_Switch : String := ">>OPTION<<";
                               Switch_Value  : String;
                               Units         : String := "<CURSOR>";
                               Response      : String := "<PROFILE>");

    -- For the given Units, sets the value of the specified option.  The RCI
    -- will ignore the value in the switch file for units that have that option
    -- set.  The option value will stay "hard-wired" until it is removed with
    -- Remove_Unit_Option.


    procedure Display_Unit_Options (Units    : String := "<CURSOR>";
                                    Response : String := "<PROFILE>");

    -- For each unit specified, displays the options that are "hard-wired" for
    -- that unit and don't depend on the switch-file value.


    procedure Remove_Unit_Option (Option_Switch : String := "<ALL>";
                                  Units         : String := "<CURSOR>";
                                  Response      : String := "<PROFILE>");

    -- For each unit specified, don't "hard-wire" the specified option, but get
    -- it from the switch-file (undo the Set_Unit_Option).



    --| LIBRARY OPERATIONS |--

    procedure Refresh_View (View           : String  := "<CURSOR>";
                            Retain_History : Boolean := True;
                            Response       : String  := "<PROFILE>");

    -- The purpose of Refresh_View is to refresh RCI state information that is
    -- believed to be corrupted or inconsistent.  This will result in errors if
    -- the view is not an RCI view.
    --
    -- If Retain_History = True then all information about remote names,
    -- timestamps, and unit options will be retained.  The operation will fail
    -- if Retain_History = True and there is no existing state information.  In
    -- this case, Retain_History must be set to False.
    --
    -- If Retain_History = False then this operation destroys all of the local
    -- information about remote names, timestamps, and unit options.


    procedure Refresh_Remote_Imports (View     : String := "<CURSOR>";
                                      Response : String := "<PROFILE>");

    -- Refreshes the remote imports to match the host imports.  This directly
    -- calls Import_Preprocess and Import_Postprocess.


    procedure Build_Remote_Library (View             : String := "<CURSOR>";
                                    Remote_Machine   : String := "<DEFAULT>";
                                    Remote_Directory : String := "<DEFAULT>";
                                    Response         : String := "<PROFILE>");

    -- Given an existing RCI view, builds the remote library.  The remote
    -- library consists of both the remote directory, where source will be
    -- stored, and the program library into which it will be compiled.
    --
    -- If the defaults are given for the Remote_Machine and Remote_Directory,
    -- their values will be be taken from the view's compiler switches.  If
    -- these values do not exist in the view's compiler switches, they must be
    -- provided here.
    --
    -- This routine assumes that the "Make_Path_Postprocess" RCI extension has
    -- been implemented.  This extension may or may not be implemented from one
    -- RCI customization to another.


    procedure Rebuild_Remote_Library (View : String := "<CURSOR>";
                                      Remake_Demoted_Units : Boolean := True;
                                      Remote_Machine : String := "<DEFAULT>";
                                      Remote_Directory : String := "<DEFAULT>";
                                      Response : String := "<PROFILE>");

    -- In the event that a remote library becomes corrupt, this routine
    -- facilitates rebuilding it.  It first destroys View's current remote
    -- library, demoting all units in View and their dependents.  It then
    -- rebuilds the remote library.  If Remake_Demoted_Units = True then all
    -- units and their dependents will be recoded.


    procedure Destroy_Remote_Library (View     : String := "<CURSOR>";
                                      Response : String := "<PROFILE>");

    -- Destroys the remote library associated with View.  The effect is to
    -- destroy View's remote program library, remote Ada source, and remote
    -- working directory.
    --
    -- This routine assumes that the "Destroy_View_Postprocess" RCI extension
    -- has been implemented.  This extension may or may not be implemented from
    -- one RCI customization to another.


    procedure Show_Remote_Information (View     : String := "<CURSOR>";
                                       Response : String := "<PROFILE>");

    -- Shows the remote machine name and remote directory associated with a
    -- host View.  The same effect can be accomplished by displaying the
    -- Ftp.Remote_Machine and Ftp.Remote_Directory switches in the View's
    -- Compiler_Switches.


    procedure Execute_Remote_Command (Remote_Command   : String := "";  
                                      Remote_Machine   : String := "<DEFAULT>";
                                      Remote_Username  : String := "<DEFAULT>";
                                      Remote_Password  : String := "<DEFAULT>";
                                      Remote_Directory : String := "<DEFAULT>";
                                      The_Key          : String := "<DEFAULT>";
                                      Response         : String := "<PROFILE>");

    -- Executes the specified Remote_Command on the specified target.  If the
    -- defaults are specified for Remote_Machine, Remote_Username,
    -- Remote_Password, or Remote_Directory, the actual values are picked up
    -- from the switch file associated with the enclosing library.  If a
    -- default target key is specified, the target key of the enclosing world
    -- is used.  The target key must be a valid RCI target key.  The output of
    -- the remote command is displayed in an R1000 window.


    procedure Collapse_Secondary_Referencers (Directory : String := "<CURSOR>";
                                              Response : String := "<PROFILE>");

    -- Collapses the text files within the specified directory and the
    -- subdirectories below it to secondary referencer (pointy) files.  Since
    -- "Archive.Copy" cannot copy secondary referencers, you must
    --    1. Convert secondary referencers to text files using
    --       "Expand_Secondary_Referencers".
    --    2. Archive.Copy these text files.
    --    3. Convert text files back to secondary referencers using this
    --       command.


    procedure Expand_Secondary_Referencers (Directory : String := "<CURSOR>";
                                            Response  : String := "<PROFILE>");

    -- Expands secondary referencer (pointy) files to text files in the
    -- specified directory and all subdirectories within it.  Since
    -- "Archive.Copy" cannot copy secondary referencers, you must
    --    1. Convert secondary referencers to text files using this command.
    --    2. Archive.Copy these text files.
    --    3. Convert text files back to secondary referencers using
    --       "Collapse_Secondary_Referencers".



    --| BATCH OPERATIONS |--

    -- The following commands provide RCI operations for batch compilation.
    -- These commands will have effect only if one of the following is true:
    --    1) The customization has set the operation mode to Batch.
    --    2) The "Operation_Mode" library switch for the units is set to True.
    -- In all other cases the batch commands will succeed with warnings.


    procedure Build_Script (Host_Units            : String  := "<IMAGE>";
                            Link_Main_Units       : Boolean := True;
                            Transfer_To_Target    : Boolean := True;
                            Host_Script_File      : String  := "<DEFAULT>";
                            Remote_Script_File    : String  :=
                               ">> FULL REMOTE NAME <<";
                            Build_List_File       : String  := "<DEFAULT>";
                            Execute_Script        : Boolean := False;
                            Effort_Only           : Boolean := False;
                            Minimal_Recompilation : Boolean := True;
                            Make_Units            : Boolean := False;
                            Response              : String  := "<PROFILE>");

    -- Selects units from the execution closure of "Host_Units" that need to be
    -- built on the target, and then generates and downloads to the target a
    -- script file which can be executed to compile these units.  Only coded
    -- units whose coding times are more recent than their build times are
    -- selected for the build.  Once a unit is entered into the compilation
    -- script it is considered to have been built.

    -- The parameter Host_Units specifies units (and their execution closure)
    -- to be selected for a build.  Units can be specified through an indirect
    -- file.

    -- The parameter Link_Main_Units, if set to True, will cause the generated
    -- script to include commands to link units that contain "pragma Main",
    -- after they are compiled on the target.

    -- The parameter Transfer_To_Target, if set to True, will cause units
    -- selected for the build to be downloaded to the target before the batch
    -- script file is downloaded.

    -- The parameter Host_Script_File specifies the name of the batch script
    -- file that will be created on the host R1000 for a particular target.
    -- The default value is "Batch_Script".  Any existing file with this name
    -- will not be overwritten and will cause the build to fail.

    -- The parameter Remote_Script_File specifies the name of the remote file
    -- into which Host_Script_File is to be downloaded.  Any failure to
    -- download this file will cause warnings to be generated, but the build
    -- command will still succeed.

    -- The parameter Build_List_File contains the name of the host file that
    -- will be created to contain a list of the host units selected by the
    -- current build.  The default file name is "Units_To_Build".

    -- The parameter Execute_Script, if set to True, will cause the target
    -- script to be executed.  Any failures in executing this script on the
    -- remote machine will produce warnings but will not cause the build to
    -- fail.

    -- If Effort_Only is True, the host script is generated, but the build
    -- operation is not recorded in the RCI state file.  No units will be
    -- promoted or transferred, and the host script will not be downloaded to
    -- the target.

    -- The parameter Minimal_Recompilation, if set to False, will cause all
    -- units in the execution closure of Host_Units to be included in the
    -- build.  The default value of True will include only obsolete units.

    -- The parameter Make_Units, if set to True, will cause any host units in
    -- the closure that are installed or sourced to be promoted to coded if
    -- necessary.  If Effort_Only is True, no units will be promoted.


    procedure Build_Script_Via_Tape
                 (Host_Units            : String  := "<IMAGE>";
                  Link_Main_Units       : Boolean := True;
                  Host_Script_File      : String  := "<DEFAULT>";
                  Remote_Script_File    : String  := ">> FULL REMOTE NAME <<";
                  Build_List_File       : String  := "<DEFAULT>";
                  Format                : String  := "R1000";
                  Volume                : String  := "";
                  Label                 : String  := "rci_build";
                  Logical_Device        : String  := "rci";
                  Effort_Only           : Boolean := False;
                  Minimal_Recompilation : Boolean := True;
                  Make_Units            : Boolean := False;
                  Response              : String  := "<PROFILE>");

    -- Selects units from the execution closure of "Host_Units" that need to be
    -- built on the target and generates a tape in ANSII format which will
    -- contain the target compilation script, the units to be built, and a
    -- script to move the units to the right place on the target.

    -- Only coded units whose coding time is more recent than their build times
    -- are selected for the build.  Once a unit is entered into the compilation
    -- script it is considered to have been built.

    -- The parameter Host_Units specifies the units (and their execution
    -- closure) to be selected for a build.  Units can also be specified
    -- through an indirect file.

    -- The parameter Link_Main_Units, if set to True, will cause units that
    -- have "pragma Main" in them to be linked.

    -- The parameter Host_Script_File specifies the name of the batch script
    -- file that will be created on the host R1000 for a particular target.
    -- The default value is "Batch_Script".  Any existing file with this name
    -- will not be overwritten and will cause the build to fail.

    -- The parameter Remote_Script_File specifies the name of the remote file
    -- into which Host_Script_File is to be downloaded.  Any failure to
    -- download this file will cause warnings to be generated, but the build
    -- command will still succeed.

    -- The parameter Build_List_File specifies the name of the file that will
    -- be created on the host R1000 to contain the list of host units selected
    -- by the current build.  The default name is "Units_To_Build".  Failure to
    -- create this file will generate warnings but will not cause the build to
    -- fail.

    -- The parameter Format specifies how objects are written into the tape.

    -- The parameter Label specifies a string which will be written in front of
    -- the data on the tape.

    -- Tha parameter Logical_Device specifies a logical name for the tape
    -- device.

    -- If Effort_Only is True, the host script is generated, but the build
    -- operation is not recorded in the RCI state file and no tape will be
    -- generated.

    -- The parameter Minimal_Recompilation, if set to False, will cause all
    -- units in the execution closure of Host_Units to be included in the
    -- build.  The default value of True will include only obsolete units.

    -- The parameter Make_Units, if set to True, will cause any units in the
    -- closure that are installed or sourced to be promoted to coded if
    -- necessary.  If Effort_Only is True, no units will be promoted.


    procedure Upload_Associated_Files (Units       : String  := "<CURSOR>";
                                       Effort_Only : Boolean := False;
                                       Response    : String  := "<PROFILE>");

    -- Uploads the associated files for the specified Units.  If Effort_Only is
    -- True, the names of the files that would be uploaded will be listed, but
    -- none of them will actually be moved to the host R1000.


    procedure Show_Build_State (Host_Units          : String  := "<CURSOR>";
                                Execution_Closure   : Boolean := False;
                                Obsolete_Units_Only : Boolean := False;
                                Response            : String  := "<PROFILE>");

    -- Displays the last coding time and the last build time for the specified
    -- Host_Units.  If Execution_Closure is set to True, the times will be
    -- displayed for all units in the execution closure of the specified
    -- Host_Units.  If Obsolete_Units_Only is set to True, the times will be
    -- displayed only for obsolete units.


    procedure Execute_Script (Host_Script_File        : String  := "<IMAGE>";
                              Remote_Script_File      : String  :=
                                 ">> FULL REMOTE NAME <<";
                              Remote_Machine          : String  := "<DEFAULT>";
                              Remote_Username         : String  := "<DEFAULT>";
                              Remote_Password         : String  := "<DEFAULT>";
                              Remote_Directory        : String  := "";
                              Effort_Only             : Boolean := False;
                              Display_Remote_Commands : Boolean := False;
                              The_Key                 : String  := "<DEFAULT>";
                              Response                : String  := "<PROFILE>");

    -- Downloads the specified Host_Script_File to the specified
    -- Remote_Script_File on the target machine specified by Remote_Machine,
    -- etc., and executes the script.  If Effort_Only is True, the name of the
    -- script file will be displayed, but the file will not be downloaded or
    -- executed.  If Display_Remote_Commands is set to True, the commands that
    -- are in the script will be displayed as they are executed on the target
    -- machine.  If a default target key is specified, the target key of the
    -- enclosing world is used.  The target key must be a valid RCI target key.


    procedure Transfer_Units (Units          : String  := "<CURSOR>";
                              Remote_Machine : String  := "";
                              Effort_Only    : Boolean := False;
                              Response       : String  := "<PROFILE>");

    -- Transfers the Ada units and any secondaries specified by "Units" to the
    -- machine specified by "Remote_Machine".  If Effort_Only is True, the
    -- names of the files that would be downloaded will be listed, but none of
    -- them will actually be moved to the Remote_Machine.


    procedure Display_Default_Naming (Potential_View : String := "";
                                      Target_Key     : String := "";
                                      Response       : String := "<PROFILE>");

    -- Displays the remote machine and the directory name that would be chosen
    -- by CMVC if Potential_View were to be created with the given Target_Key.


    pragma Module_Name (4, 4133);
    pragma Bias_Key (32);

end Rci;