![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
Key Concepts This chapter provides an overview of the Rational Compilation Integrator (RCI), its components, and the methods used to customize the product. It gives the reader an understanding of the basic uses and structure of the RCI and its customization.
The chapter is organized as follows:
- What Is the Rational Compilation Integrator?
- What Is a Customization?
- Customization Process Overview
Note: Rational may be able to provide additional information to help with customization for a particular target compilation platform or vendor compiler. Before you begin customization, contact your Rational representative for more information.
What Is the Rational Compilation Integrator?The Rational Compilation Integrator is a tool that allows you to integrate and control compilation on networked platforms. Integrated compilation is the process of controlling a compiler running on one machine (the compilation platform) from another machine (the development platform). The development and compilation platforms can be the same physical hardware platform. This single machine or a host Apex platform and remote compilation machine share the same files through Network File Server (NFS). RCI provides the tools that a developer needs when developing Ada code on an Apex development platform which is to be compiled on some other machine (the compilation platform). The third-party compiler running on the compilation platform is the target compiler. The compiler generates code for the target platform, either the same machine as the compilation platform, or a platform of another architecture for which the (cross) compiler generates executable code. Figure 1 shows the basic components of RCI.
Figure 1 Basic RCI
![]()
RCI provides a means to develop programs using Apex for a variety of targets, taking advantage of Apex's specially-designed software engineering support environment. Users can develop a large portion of a project's software in the host environment. They can develop and integrate target-dependent software on the host, then test it on the compilation platform.
RCI takes action on the target compilation platform when it transfers units for compilation and linking, and it handles target library management.
What is a Customization?
A customization is an addition to the basic RCI to support a specific third-party compilation system. You modify the product through links to predefined libraries, specification files and scripts to provide integrated-development support. An RCI customization is the result of customizing the base product with values for your selected compiler. Each different compiler requires its own unique customization.
Customizations have common features based on target architecture, remote operating system, and compiler vendor, so you can use similar customizations as a basis for creating new customizations. Apex/RCI provides two sample customizations (one for an Ada83 target compiler, and one for an Ada95 target compiler).
Understanding the User's Environment
The developers who use the customized version of RCI should not need to read this manual. Instead, there is the RCI User's Guide which explains how to develop software using the final, customized version of RCI.
You, as the customizer, should familiarize yourself with that manual so that you can better understand how your customization affects your user's environment. You will need to provide documentation that describes operations using your customization.
At a very high level, the following table describes what the user sees and what the customizer does to create the environment.
What Is a Customization?This section provides an introduction to the basic components and methods that you use to create an RCI customization.
Building A Basic Customization contains a detailed description of where to find RCI software components on your host platform.
Why Customize?
Customizing RCI provides the following advantages:
- Access to an unlimited number of third-party compilers, thus providing access to an unlimited number of targets.
- Access to the specialized development features of Apex while using a third-party compiler.
- A common interface and tool set, so users are not forced to learn new syntax for the target compiler and remote operating systems.
- Different methods of compilation, interactive or batch, for improved resource management.
What to Customize
This section provides an overview of all of the customizable components of RCI:
- What can be Customized: Lists each customizable component of RCI according to its user-visible functional category.
- How to Customize: Describes each major method of customizing RCI components.
What can be Customized
The following general areas of RCI can be customized. The associated paragraphs provide more detailed descriptions of each of these areas.
- Predefined libraries
- Target compiler and operating system characteristics
- Target-dependent semantic checking
- Apex and RCI operations
Predefined Libraries
A predefined library is a library or directory that contains Ada specifications or interfaces that are provided (predefined) by the vendor of a compiler. Predefined libraries are customized by placing the Ada specs of the routines in RCI views on the host and their bodies in a location on the compilation platform known to the target compiler. Details of this process are provided in Building Host Library Views.
Target Compiler and Operating System Characteristics
To communicate appropriately with the target compiler and the compilation platform's operating system, RCI needs to know such things as:
- Compiler characteristics: such things as whether the target compiler macro-expands generics, supports inlining, and/or requires that a body and a generic be present in the same compilation.
- Remote command names: the remote commands for such things as invoking the compiler and linker.
- Target compiler and linker options: the valid target compiler options and their placement in the remote command.
- Compilation platform naming conventions: information used to build remote filenames for Ada source files.
The process for customizing these operations is described in Building A Basic Customization.
Target-Dependent Semantic Checking
Semantic checking is provided for all standard Ada constructs, including LRM-defined representation specifications. In addition, you can customize semantic checking for:
- Package Standard
- Pragmas
- Attributes
- Representation clauses
Customize these by creating a specification as described in Building A Basic Customization, Defining Basic Characteristics, and Building Semantic Characteristics.
Apex and RCI Operations
You can extend Apex and RCI operations for your specific compiler.
- Target Library Management Operations
Apex's Object Management System (OMS) controls the library-management operations for host views. RCI needs to take corresponding actions on the compilation platform during these operations. For example, when you create an RCI view, customization scripts should create a corresponding target library automatically. When you delete a view, you can optionally delete the target library.
This process is described in Managing Target Libraries and Compilation.
- Target Compilation Operations
You can extend the basic Apex compilation and linking operations to perform the appropriate target compiler operations during remote compilation.
This process is described in Compilation Management.
- RCI-Specific Operations
You can extend RCI-specific operations to take additional action during batch operations, remote compilation, and consistency management.
This process is described in RCI Extensions and Utilities.
How to Customize
You will use different methods to customize different components of the RCI. There are three basic approaches:
- Copying Ada specifications into a predetermined location
- Creating specification files
- Programming extended command operations in shell scripts
Placing Ada Specifications
By entering Ada specifications for LRM-predefined subprograms contained in the target compiler's predefined library (and provided in text in the compiler's LRM, Appendix F) into predetermined views on the host, you provide semantic checking information for the RCI. (You do not copy package Standard; Apex creates it through a separate operation during analysis of some unit that depends on Standard).
Creating Specification Files
The specification files are data files which are input to the compiler during compilation and linking. Starting in Apex 3.0 the files are written in a simple language called RCI Spec Language. A formal grammar is provided for RCI Spec Language.
Five specification files are used to specify the following kinds of information:
- Package Standard
- Pragmas
- Attributes
- Representation clauses
- Operating system characteristics
- Target compiler properties
- Target compiler and linker options
Programming Extensions
Customization by programming means providing UNIX shell scripts, either by creating them or by copying them from other similar customizations, to perform the tasks needed for certain operations. Apex looks in the compiler key for specific customization scripts during host operations. You may wish to review the online document "Using and Customizing Summit CM" for additional information about the script calling conventions that RCI customization scripts are based on.
Things that are customized by programming include:
- Target library operations
- Target compilation operations
- RCI-specific operations
- Batch operations
- Custom tools
Customization Process OverviewThis section outlines the steps to use to create a customized RCI. Building A Basic Customization provides detailed instructions for building your customization. The following chapters describe each process in detail.
- 1 . Collect documentation for your customization: vendor compiler and operating system manuals, vendor LRM, Rational manuals and specs.
- 2 . Choose a compiler key name for your customization. This name should identify the target platform, operating system, and compiler vendor.
- 3 . Create the compiler key directory for your customization. This directory will contain the customization specification files, the compiler and linker options, and the scripts for compilation and library management for your specific customization.
- 4 . Create target specification files in the compiler key directory. There are three methods available:
- a .
Edit the specification files directly (use the example customizations as a guide). A utility is provided to parse the specification files and provide diagnostics.- b .
If you have an existing RCI Customization (pre-Apex 3.0): translate the characteristics files produced for an older version into the specification files used by post-Apex 3.0 releases. A utility is provided for that purpose. From time to time the characteristics known to the API are expected to change, and the translate routine will choose default values for customizations which are being translated, so you may wish to hand edit the specification files generated by this method.- c .
Create an Ada unit which links against the RCI API and which declares the characteristics and calls the API routines to build the characteristics data structures and output the specification files. This method is no longer described in this manual, so you may need to consult a prior edition of this manual. Contact Apex Technical Support if you need copies of a pre-Apex 3.0 version of the RCI Customizer's Guide.
Note: existing customizations that were created prior to Apex 3.0 can continue to be upgraded using this method; the RCI API will continue to contain the necessary build and output routines, and the specification files will be output in the new format.
From time to time the characteristics known to the RCI API are expected to change, although the RCI API interface that supports this method will remain constant so as not to break existing customizations. The default values for newly introduced characteristics may not be what you want, so some hand editing of specification files may be required if you choose this method.- 5 . Populate the compiler key view. Do this by copying existing sample shell scripts and by generating the options files.
- 6 . Create the LRM view for your customization.
- a .
Create package System.- b .
Stock the LRM library (copy units with your target-compiler vendor's permission; type in units from the LRM) with the Ada specifications for Apex-required LRM-predefined units for the selected target machine, and code them. Some predefined routines are required; others are optional.- 7 . Create predefined views for your customization and stock them with any additional target libraries (not already defined in the LRM library).
- 8 . Create the model with the compiler key for your customization.
- 9 . Edit the Compiler_Properties in your customization's compiler key view.
- 10 . Create or update the README file for your customization.
Rational Software Corporation http://www.rational.com support@rational.com techpubs@rational.com Copyright © 1993-2002, Rational Software Corporation. All rights reserved. |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |