|
DataMuseum.dkPresents historical artifacts from the history of: Rational R1000/400 Tapes |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Rational R1000/400 Tapes Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - downloadIndex: ┃ T V ┃
Length: 35598 (0x8b0e)
Types: TextFile
Names: »V«
└─⟦5829e5ed5⟧ Bits:30000534 8mm tape, Rational 1000, RCI 2_0_5
└─ ⟦c9a165082⟧ »DATA«
└─⟦c3895f76e⟧
└─⟦this⟧
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;