TOC PREV NEXT INDEX DOC LIST MASTER INDEX



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:

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.

Table 1 User/Customizer Environment
The User
The Customizer
Creates a subsystem and view using an RCI model and compiler key.
Defines the model with the specific compiler key during the customization process.
Creates a view...
Using RCI target library integration scripts in the RCI customization compiler key, Apex creates a library structure on the compilation platform to match the view on the development platform.

Creates scripts which invoke the target compilation system to create a target directory and perform import operations, using predefined hooks associated with host library management operations.
Creates Ada source code in the host RCI view. When the user analyzes the Ada unit, Apex uses the target-specific semantic information in the customization compiler key to check the syntax and semantics of the code.
Provides semantic information about the target compilation system.
Codes and links the Ada unit...
Apex looks for RCI options files and switches in <view>/Policy/Switches. The values that the user has assigned to RCI switches indicate such things as which machine to compile on. Compiler options define what options should be used when invoking the target compiler.

Determines and defines the names of the allowed compiler and linker options and their valid values. Sets the default RCI switches for the compiler key model.
Checks consistency...
The user compares host and target files for consistency.

Customizes scripts to check consistency between copied files.
Builds a batch script...
This allows the RCI to use batch compilation on the target compilation platform.

Customizes scripts to support batch operations.


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:

What to Customize

This section provides an overview of all of the customizable components of RCI:

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

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:

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:

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.

How to Customize

You will use different methods to customize different components of the RCI. There are three basic approaches:

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:

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:


Customization Process Overview

This 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.
TOC PREV NEXT INDEX DOC LIST MASTER INDEX TECHNOTES APEX TIPS