![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
RCI Man Pages Summary This appendix consists of the UNIX man pages that are supplied with the Rational Compilation Integrator (RCI). The following commands are covered:
- actc - accept changes from a target file into a host unit
- check_rci_specification - check specification
- cmpt - compare host and target units
- cpto - transfers host units to the target
- crscr - create batch compilation script
- crtlib - create target Ada library
- deltlib - delete target library
- rci - introduction to compilation integrator commands
- rftimp - refresh target imports
actc - accept changes from a target file into a host unit
Syntax
actc [ -s ] program_unit...actc [ -s ] view
Description
Compares each specified program_unit with its corresponding file on the target and transfers each target file that has been changed into its corresponding host program_unit. actc checks only files that the RCI has recorded in the RCI target names file.
By default, actc determines that a target file has changed by comparing the host unit's edit timestamp with its corresponding target file's edit timestamp. Enabling the -s option forces actc to instead do a character-by-character comparison of the contents of the host unit and the target file. Irrespective of the method used for comparison, if any differences are found actc assumes that the target file has been changed and transfers it to the host.
In the second form of the command, actc checks each unit within view that has been registered with the RCI and transfers to the host each target file that has been changed.
Your customizer can modify the method that the RCI uses to determine that a file has been changed. This method may not rely on timestamps as outlined in this page.
Options
- -s
Compare source. The RCI determines that a target file has changed by performing a character-by-character comparison of that file's contents with the contents of the corresponding host unit.
See Also
check_rci_specification - check specification
Syntax
check_rci_specification -directory compiler_key_view [-rci_prevent_build]
Description
Parses the RCI Specification files in the compiler key view (rci_op.spec, rci_predef.spec, rci_attrib.spec and rci_pragma.spec) and outputs diagnostics if syntax errors are present. If rci_op.spec successfully parses, the compiler and linker options files (comp_option_line, comp_option_symbol, link_option_line, link_option_symbol) are generated in the compiler key view unless the -rci_prevent_build option is specified.
Options
- -directory compiler_key_view
- -rci_prevent_build
cmpt - compare host and target units
Syntax
cmpt [ -s ] program_unit...cmpt [ -s ] view
Description
Compares each specified program_unit with its corresponding file on the target and displays a message about the file. For each specified file, the message indicates whether or not the host file has a corresponding target file, and if so, whether the host and target files match. cmpt only checks units that the RCI has recorded in the RCI target names file.
By default, cmpt determines that a host unit and target file do not match by comparing the host unit's edit timestamp with the target file's edit timestamp. If the target file's timestamp is later than that of the host unit, the units do not match. Enabling the -s option forces cmpt to instead do a character-by-character comparison of the contents of the host unit and the target file. The two files do not match if any differences are found.
In the second form, cmpt checks each unit within a view that has been registered with the RCI and displays a message about the file. For each file in the view, the message indicates whether or not the host file has a corresponding target file, and if so, whether the host and target files match.
Your customizer can modify the method that the RCI uses to determine that a file has been changed. This method may not rely on timestamps as outlined in this page.
Options
- -s
Compare source. The RCI determines that a host unit does not match its corresponding target file by doing a character-by-character comparison of the host unit's contents with the contents of the corresponding target file.
See Also
cpto - transfers host units to the target
Syntax
cpto [ program_unit... ] [ buildlist... ]cpto view...
Description
In RCI batch mode, cpto transfers each host Ada program_unit (and each program unit named in each buildlist) from a batch view into the target directory that is associated with that host view. The RCI creates the target name for each transferred Ada unit based on the host unit name, using the naming scheme that your customizer has defined for your RCI customization.
In the second form of the command, cpto transfers all program units from view to the target directory.
Your customizer can modify the method that the RCI uses to transfer files (through use of the same file, copies, or symbolic links). Check your customization documentation for additional information.
Examples
To transfer all Ada units from the current view (but not its subdirectories) to the corresponding directory on the target associated with that view, use the following command:
example% cpto *.ada
To transfer all units that are listed in the buildlist file named "main_unit.bl", use the following command:
example% cpto main_unit.bl
See Also
crscr - create batch compilation script
Syntax
crscr [ -al ] [ -f filename ] program_unit...crscr [ -al ] [ -f filename ] view
Description
Creates a batch compilation script file, which contains commands to compile (and optionally link) each specified program_unit (and those units in the closure of the specified units) using the target compilation platform.
All specified units must be from a single view, not an arbitrary set of views.
Each program unit in the execution closure of the specified units must have been coded on the host. If any of the units are not coded, the RCI creates the script for the coded units, and it issues a warning for, but does not include, those that are not.
crscr will not overwrite an existing batch script file of the same name.
The RCI takes the following steps to construct the list of units to be compiled by the batch script:
- 1 . Start with the list of specified units, or all units in the specified host view.
- 2 . Remove the uncoded units.
- 3 . Add to the list those units that constitute the execution closure of the specified units.
- 4 . If the -a option has not been specified, remove from the list all units that are not obsolete, that is, those units that have not been coded since they were last included in a script.
The -a option causes all the units in the execution closure of program_unit to be included in the batch compilation script, rather than only the obsolete units (those units which have been coded since the last time a script was created). The -l option causes the RCI to include link commands for all procedure bodies in the specified list of program units.
The default name of the batch compilation script is batch.scr. You can specify the name of the script file with the -f option, which creates the filename filename.scr.
The default name of the batch compilation script is batch.scr. You can specify another name for the script file by providing a simple name to the -f option, which creates the filename filename and appends the extension ".scr". (If you specify filename.scr, the command does not add the extension.)
The crscr command also creates a buildlist file which contains an ordered list of the selected units to compile in the batch compilation script. The RCI creates the name for this file from the name of the script file (batch.scr by default, or the name specified by the -f option). The buildlist filename ends in the extension ".bl". You can use this file as indirect input for transferring associated files from the target or host units to multiple targets.
The second form of the command creates a batch compilation script for all units in the specified view.
After you have built the batch compilation script, you can transfer program units to the target compilation directory with the cpto command (if they were not copied during compilation).
The RCI assumes that after you generate a batch script you will immediately execute that script, compiling each unit in the script on the target. Unless you execute every script you generate, the RCI state information for the units in the host view may not reflect the actual state of the target library, and subsequently-generated batch scripts may fail when executed on the target.
Options
- -a
All. This causes the RCI to enter all the units in the execution closure (rather than only the obsolete units) into the batch compilation script. You should use this option if you want to recompile the entire system on the target. Note that creating scripts with this option can lead to inconsistencies; if a view is built, but not its clients, those clients will become obsolete on the target.
- -f filename
Names the file in the host view into which the RCI writes the batch compilation script. Unless the filename you provide ends with ".scr", the RCI appends the extension ".scr" to the name. (The RCI also uses this name to create the buildlist filename, but it appends the extension ".bl" instead of ".scr".) The default name is batch.scr; the RCI uses this name if you do not specify the -f option.
crscr will not overwrite an existing batch script. If the file specified with the -f option already exists, the RCI generates an error message and does not create a batch script.
- -l
Link main units. With this option, the RCI includes commands to link the main unit or units in the batch compilation script. Without this option, the batch script compiles, but does not link, the specified units when you execute it. In any case, the RCI does not generate link commands for those units that are not main units.
Examples
To generate a batch script to compile all obsolete Ada units in the current view (but not its subdirectories), use the following command:
example% crscr *.ada
To generate a script that forces compilation of all units in the closure of main_unit (in main_unit.scr) and generate a file containing all of the names of those units (in main_unit.bl), use the following command:
example% crscr -a -f main_unit main_unit.2.ada
See Also
crtlib - create target Ada library
Syntax
crtlib [ -d ] [ -D directory ] [ -M machine ] view
Description
Creates the target Ada library that corresponds to the specified view. (Depending on your RCI customization, the command builds the elements of the Ada library required by your target compiler, including the Ada program library and import information.)
If directory does not already exist on the target machine, crtlib creates it and associates it with view. If directory does exist on the target but is not an Ada library, crtlib converts it into an Ada library before associating it with view. If directory exists on the target and is already an Ada library, crtlib just associates it with view. In any case, crtlib then marks all Ada units in the host view as requiring recompilation.
Be careful not to assign two views from the same subsystem to the same target library. (Use the same target library only if your target compilation system requires it. Check your customization documentation for more information.)
When you create a target library for a view that is imported by others, the importing view's imports are made obsolete. Before you compile units in one of the importing views, you must refresh its imports (use the -refresh option with the import command).
The first time you create a target library, either with this command or with an Apex view creation command, you must specify the target directory. You should also specify the target machine, if different from the host, when you initially create a target library. When rebuilding an existing target library, you can use either or both of these fields to override the current settings (which are contained in the view's switch file).
The target library specified by directory must not be nested within an Apex view.
crtlib may or may not be implemented from one RCI extension to another. Also, your customizer can modify the operation of crtlib. For additional information, check the documentation for your RCI customization.
Options
- -d
Destroy. This causes the RCI to first destroy any existing target library associated with view, then create the new library. This calls the pre_delete_view and post_delete_view Summit/CM extensions.
If you do not use this option, and the new target library is in a different location from the existing target library, the existing target library associated with the host view is "orphaned;" that is, the RCI no longer has information about its existence.
- -D directory
Directory. If it does not already exist, crtlib creates the named directory, in which the RCI will create the target Ada library. If you do not specify this option, the RCI uses the value of the RCI_TARGET_DIRECTORY switch in the view's switch file. If no directory information is available, the command fails. Note that you may need to enclose directory in single quotes (') to prevent the UNIX shell from interpreting any embedded special characters, such as $ or space, before directory is passed to the target. Depending on your customization, the RCI may build multiple level directories. For example, if you specify the target directory .../a/b/c, the RCI builds the intermediate directories a and b, as well as c.
- -M machine
Machine. Specifies the target compilation platform machine, on which the RCI executes commands for the target library. If you do not specify this option, and the specified view currently exists, the RCI takes the target compilation platform name from the RCI_COMPILATION_PLATFORM switch in the view's switch file. If the view does not exist or has no target compilation platform specified in the switch file, the RCI uses the host machine to execute commands in the target library.
Files
See Also
deltlib - delete target library
Syntax
deltlib view...
Description
Deletes the target library, including both the Ada library and the target directory, corresponding to each specified host view. Prior to deleting a target library, deltlib deletes all Ada source files and any working directories that reside in the target library.
deltlib may or may not be implemented from one RCI extension to another. Also, your customizer can modify the operation of deltlib. Check your customization documentation for additional information.
See Also
rci - introduction to compilation integrator commands
Description
The Rational Compilation Integrator (RCI) is a tool which allows you to use Rational Apex to control compilation using third-party compilers and linkers. The tool provides semantic checking which enforces the rules used by the target compiler. It offers a common user interface to a variety of third-party compilers. The RCI can operate in either interactive or batch mode.
The RCI is customizable; that is, you can extend operations for your specific target compilation system.
Rational Apex automatically handles many RCI operations. Apex commands that create, delete, and copy views and files, control imports, and compile and link program units take additional action with RCI units and views.
RCI-specific commands perform operations in three areas:
- Library Management: the RCI provides commands that create target libraries (crtlib), delete target libraries (deltlib), and update, or refresh, target library imports to match those imports used by the corresponding host view (rftimp).
- Consistency Management: the RCI provides commands to compare host and target files (cmpt) and accept changes from target files (actc).
- Batch Compilation Operations: the RCI provides a method to create a batch compilation script, which allows you to compile and link multiple units on the target in a single batch operation (crscr). You can also transfer units to a target machine and directory (cpto).
The Apex switches that control RCI behavior for a view are found in ...view_name/Policy/Switches. The RCI uses the default value if it does not find the switch in the file. The RCI uses the following switches:
- RCI_AUTO_TRANSFER:
Value: True/False
Default: False
The value of this switch is meaningful only if the RCI_COMPILATION_MODE switch is set to batch. In batch mode, this switch controls whether or not units are automatically copied to the target when they are coded.- RCI_COMPILATION_MODE:
Value: batch/interactive
Default: interactive
If RCI operations in this view are to take place in batch mode, this switch should be set to batch.- RCI_COMPILATION_PLATFORM:
Value: compilation platform name
This switch identifies the machine used to perform operations (such as compilation) in the target directory.- RCI_HOST_ONLY:
Value: True/False
Default: False
If set to True, this switch indicates that the view has no target directory or platform associated with it, and that the RCI takes no action on the compilation platform. Its value is taken from the setting of the HOST_ONLY option when Apex view creation commands are used to create an RCI view.- RCI_TARGET_DIRECTORY:
Value: full pathname
This switch identifies the target directory corresponding to the RCI view.The RCI is a separately-licensed Rational layered product. If the RCI is not installed on your system, contact your Rational representative for more information.
See Also
- cpvw(1)
- crwrk(1)
- del(1)
rftimp - refresh target imports
Syntax
rftimp view...
Description
Updates the imports for the target library that corresponds to each named host view so that the target imports are consistent with those of the named view.
rftimp may or may not be implemented from one RCI extension to another. Also, your customizer can modify the operation of rftimp. Check your customization documentation for additional information.
See Also
List of RCI Commands
Rational Software Corporation http://www.rational.com support@rational.com techpubs@rational.com Copyright © 1993-2002, Rational Software Corporation. All rights reserved. |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |