Rational Apex Release Notes

Release 4.0.0 B

Thank you for choosing Rational Apex!

Please read this document to learn about known product issues, important tips, and other Apex product information. The Release Notes are also available online in HTML format from the Help > Manuals command.

The online Release Notes are guaranteed to be the latest version of this document. If you find discrepancies between the hard-copy and online versions of the Release Note, please assume that the online document contains the most current information.

---

Objectives

These release notes provide information critical to installing and using Rational Apex, including supported platforms and known issues with this release.

---

Scope - Product Definition

This document applies to Release 4.0.0 B of Rational Apex for Sun Solaris, HP-UX, True64 UNIX, SGI Irix, and IBM AIX. These release notes describe:

• Hardware and software requirements for installing and running Apex and its add-ins
• New features and enhancements
• Any defects fixed since the last release
• Currently known defects and defect workarounds.

Before installing Rational Apex, be sure to read the Hardware/Software Information and Getting Started sections of this document. These sections contain important information for a smooth and successful installation.

---

Hardware/Software Information

This section provides basic information on the platforms supported and the hardware and software requirements for installing and running Rational Apex and its add-ins.

Supported Platforms

This document uses the following terms to designated the various platforms on which Rational Apex 4.0.0 B runs.

Table 1 Supported Platforms

Term	Platform
Solaris	Sun SPARC workstation running Solaris 2.6 or 2.7
AIX	IBM RS/6000 or PowerPC workstations running AIX 4.3.3
Alpha, OSF/1, Tru64 UNIX	Digital Alpha workstations running release 4.0d and 4.0e (formerly known as OSF/1).
HP-UX or HP	HP PA workstations running release 11.0 of HP-UX (with and without threads)
IRIX	SGI workstations running IRIX 6.5 N32

Hardware Requirements

Hardware requirements are outlined in Installing Rational Apex.

If you wish to generate and/or execute SPARC V9 64-bit binaries, a Solaris 7 machine with the 64-bit Kernel is required. More information on determining if your Solaris 7 system has the 64-bit Kernel can be found in SPARC V9 Solaris 64-bit Support.

Software Requirements

Software requirements are outlined in Installing Rational Apex.

To use the Apex/ClearCase integration, Rational ClearCase 3.2 or higher must also be installed.

To use the Apex Web interface, the JDK 1.2.2 plug-in and the "appletviewer" tool (shipped with JDK 1.2.2) must be installed.

---

Getting Started

This section provides information about pre-installation and licensing issues for Apex.

Getting Announcements from Rational

New Apex products, layered products, new releases, patches, and critical technical information about these products are now announced through e-mail.

To sign up for automatic notification, send an e-mail message to majordomo@rational.com with the words subscribe apex-announcements in the body of the message.

If you already subscribe to this list and wish to be removed, send an e-mail message to majordomo@rational.com with the words unsubscribe apex-announcements in the body of the message.

We do not advertise on this list.

Installation Information

Installation instructions for Rational Apex are available in Installing Rational Apex.

Licensing

The license key for this release is 4.0. You must upgrade to this license key to use this version of Apex.

All Apex products require the following base license features:

• env_base.host
• summit_base.host
• summit_cm.host

Each of the following products requires both the base license features and the additional license features listed after it:

• Apex Ada 95/83 (ada.host, asis)

The components described below are included with the Apex product but require additional license features:

• RCI (rci.host)
• Summit/TM (summit_tm.host)*

  * Installation of only Summit/TM requires the base license features (env_base.host, summit_base.host, summit_cm.host), as well as the Summit/TM license (summit_tm.host).

The host part of the name is one of alpha, hppa, mips, rs6k, sun4, or any.

• The alpha license is good for Digital UNIX.
• The hppa license is good for HP-UX.
• The mips license is good for SGI/IRIX. [Not in this release]
• The rs6k license is good for AIX.
• The sun4 license is good for Solaris.
• The any license is good for any O.S.

Note: Once Apex is purchased for two or more O.S.'s, an any key is provided.

The licenses held by an Apex session can be viewed using the Tools > Session > Show Licenses command from a Jobs, Server or Output window.

Upgrading from Previous Releases

This release note applies to Release 4.0.0 B of Rational Apex. If you are upgrading from a previous release, after the installation is complete, upgrade your subsystems and views using the apex_ugrade command. This command is described in detail in the Command Reference.

If you are doing just a patch install, it is not necessary to run apex_upgrade. Installing a patch to an existing release is described in Installing Rational Apex.

Installation Issues

Required Operating System Patches

For Apex to run successfully, there may be additional patches which must be installed on your system. To view the current list of patches produced by Rational for the Apex products, visit the ftp://ftp.rational.com/patch_info/index.html patch information page on our FTP server.

The latest information on patches for each of the Apex platforms can be found at the following URLs:

• Sun Solaris:

  http://sunsolve.sun.com/pub-cgi/show.pl?target=patches/patch-access

  We recommend that users take Sun's recommended patches for each OS version. These patches are incorporated into the OS by Sun. There are no patches required specifically for Apex.

• SGI Irix

  http://support.sgi.com/surfzone/patches/

  Site requires registration for access.

• HP-PA HP-UX

  http://us-support.external.hp.com/

  Patch information can be reached through the support pages. Site requires registration for access.

• Digital UNIX:

  http://www.service.digital.com.patches

  At this time, Apex requires no patches on this platform. Site requires registration for access.

To view the current list of patches produced by Rational for the Apex products, visit the ftp://ftp.rational.com/patch_info/index.html patch information page on our FTP server.

Product Documentation

Rational Software Corporation provides a full set of online documentation with this release. These documents can be accessed through the Help > Manuals command from any directory viewer or the Doc List button in the navigation bar at the top of each HTML document. A subset of these documents is provided in hard-copy.

A specific discussion of online help using Netscape can also be found in the Getting Started manual.

Postscript Versions

Postscript versions of most of the manuals are also provided and can be printed using the Help > Print Manuals command.

In some cases, you may note discrepancies between the printed documentation and the online documentation. In these cases, the online documentation is the most up-to-date and should be followed.

Man Pages

For a list of available manual pages, enter the following command in an Apex xterm window:

man apex

An Apex xterm window is an xterm window generated from an Apex window using Tools > Shell.

---

Compatibility Issues

Reserved Words

Apex locates executables based on standard UNIX searchlist mechanisms. The following are words you should avoid using as names for scripts to be invoked in shell windows spawned from Apex:

apex
apex_display
apex_action
apex_output
visit
visit_ada
rada

Of special notice in this list is apex, which is the central command for shell usage. Because Apex provides multiple ways to invoke shell operations, problems caused by overloading the term apex might seem to occur in inconsistent ways.

In addition, avoid any name that begins with Apex_ (case is important). No specific names are provided because the list is subject to change.

---

New and Changed Features

This section outlines the changes, enhancements, and new features available in this release of Apex. The following are included in this section:

• Apex/ClearCase Integration
• SPARC V9 Solaris 64-bit Support
• Ada Compilation System
• Ada Object Editor
• Runtime
• User Interface
• Apex Shadowing
• Summit/CM
• Tools
• Documentation
• RCI

Apex/ClearCase Integration

This release introduces the Apex and ClearCase Integration. Apex/ClearCase provides the Apex development environment while using ClearCase, for configuration management and version control. When using Apex/ClearCase, the following is provided:

• Support for common ClearCase development operations like check in, check out, attaching labels, and displaying cleartool ls information.
• Access to ClearCase support for branching and merging versions.
• Access to ClearCase CLI (command line interface) cleartool via Apex shell.
• Running of Apex sessions inside of a ClearCase view context.
• Use of Rational subsystems for Ada and C++ development. When Rational subsystems, are created within a ClearCase VOB, they can be made elements (can be controlled). The Rational subsystem characteristic files (Imports, Switches etc) are also controlled. Once Rational subsystems are controlled, they can be shared across ClearCase views.
• Support for creation and winkin of ClearCase derived objects.
• Support for UCM based development via activity management.
• Support for migration of Summit (CMVC) subsystems and views to Rational Subsystems inside ClearCase VOBs.
• Support for keyword replacement including special ClearCase attributes like wdview and labels.
• Support for layered products: TestMate, RCI, SoDA and Rose/Ada.
• Server-controlled access and ability to use ClearCase Multisite.

Requirements

To use Apex/ClearCase, the following is required to be installed:

• ClearCase 3.2 or higher

There are no special licensing requirements beyond those imposed by Apex 4.0 and ClearCase 3.2 or higher.

Recommended Documentation

For Installation

• ClearCase Product Family Installation Notes (UNIX only)
• Rational Apex Release Notes (this document)
• Installing Rational Apex

For Usage

• Getting Starting with Apex
• Apex Concepts Guide
• Apex Command Line Reference
• Introduction to ClearCase Manual (ClearCase 4.0 and higher)
• Developing Software with ClearCase (ClearCase version 4.0 and higher)
• Building Software with ClearCase (ClearCase version 4.0 and higher)
• Managing Software with ClearCase (ClearCase version 4.0 and higher)
• ClearCase Concepts Manual (ClearCase 3.2)
• ClearCase User's Manual (ClearCase 3.2)

For Maintenance

• Administrating ClearCase (ClearCase 4.0 and higher)
• ClearCase Administrator's Manual (ClearCare 3.2)

SPARC V9 Solaris 64-bit Support

Note: SPARC V9 Solaris 64-bit support is not currently included as part of Rational Apex. It will be included in a patch release that should be available shortly. Please check with your Rational representative as to the status of Solaris 64-bit support.

This release provides the tool set that helps Apex users to develop and deploy SPARC V9 64-bit programs (Ada, C, C++) on 64-bit Solaris machines.

No new license is required as long as the Solaris Apex 4.0.0 license is valid.

Basic System Requirement

In addition to the system requirements for installing Apex, a Solaris 7 machine with the 64-bit Kernel is required to generate and/or execute SPARC V9 64-bit binaries. All Solaris 7 machines don't have the 64-bit Kernel installed. The command to identify a Solaris 7 machine capable of generating and running 64-bit programs is: isainfo -v. The output of this command on a Solaris 7 machine with 64-bit kernel is:

host% isainfo -v
64-bit sparcv9 applications
32-bit sparc applications

Data Model - LP64

The fundamental difference between SPARC 32-bit model and SPARC V9 64-bit model is in the Data Model. The former supports the ILP32 model, where the integer type (int in C/C++ and Integer in Ada), long integer types (long in C/C++ and Long_Integer in Ada) and pointer/address type (pointers in C/C++ and Access/System.Address type in Ada), are all 32-bit. The object file format is ELF-32. The latter supports the LP64 model, where long integer types (long in C/C++ and Long_Integer in Ada) and pointer/address type (pointers in C/C++ and Access/System.Address type in Ada), are 64-bit, but integer type (int in C/C++ and Integer in Ada) is 32-bit. The object file format is ELF-64.

One major cause of worry when moving from ILP32 to LP64 is that the size of pointers and integers are no longer the same. This poses major problems for C programs written in K&R mode (where it is not mandatory to specify function prototypes) if prototypes for functions returning pointers are missing. The default return type is integer which is not the same size as pointers in LP64 model.

SPARC V9 64-bit Programming

In Apex, the key to generating a SPARC V9 64-bit Ada/C/C++ object is modeling your view with the appropriate model. Any model whose name starts with "sun4_solaris_64 " models your view to use the SPARC V9 64-bit compiler.

There is no static linking in SPARC V9 64-bit mode since the standard system libraries are available only as shared objects (there are no static archives). Given that, in any Ada view, even if the value of the link mode switch (LINK_CONTRIBUTION_DEFAULT_MODE) is set to static, the system libraries are linked in dynamically.

One cannot mix and match 32-bit objects and 64-bit objects. That is, a 32-bit object cannot be linked into a 64-bit object and vice-versa.

Ada Compilation System

The following have been implemented for this release of the Apex Ada compiler and runtimes.

• Alignment of Types and Objects
• Address Clause Alignment Check
• Elaboration Order
• Subprogram Addresses
• System Address
• Interface to ANSI C and K&R C - Change in Default
• Single Rada and COMPILER_TOOLS_PATH
• COMPILER_TOOLS_PATH Switch
• Miscellaneous Changes

Alignment of Types and Objects

The default alignment of types and objects has changed. In the absence of representation clauses specifying the alignment of a type or object, the compiler is free to choose the alignment it wants, in order to obtain the best performance.

In all cases, the default alignment of an object is the alignment of its type.

In this release, the default alignment for a composite type is the smallest power of two that is larger than the size, subject to architecture-dependent limits. This is, in general, the approach that results in the best performance, notably on RISC processors. However, it causes data structures to become larger, and this effect is especially noticeable for small composite types. This is a change from previous Apex releases, where the alignment of a composite type was the LCM of the alignments of the components. If the additional storage consumption is undesirable, the alignment of the type should be explicitly specified.

Alignment of types and objects is described in detail in the Appendix F and Annex M chapters of the Ada Compiler Reference.

Address Clause Alignment Check

The code generated for an address clause now includes a runtime check that the alignment of the specified address satisfies the alignment requirement of the specified object. Program_Error is raised if the check fails, as per RM95 1.1.5(12).

For example, a call to the following procedure will raise Program_Error:

with System.Storage_Elements;
procedure Raise_Program_Error is
Buffer : String (1 .. 10);

function Odd_Address return System.Address is
Result : System.Address := Buffer (1)'Address;
use System.Storage_Elements;
begin
if Result mod 2 = 0 then
 Result := Result + 1;
end if;
return Result;
end Odd_Address;

X : Integer;
for X'Address use Odd_Address; -- raises Program_Error
begin
 null;
end Raise_Program_Error;

Elaboration Order

The Apex compiler now takes subsystem/view importing information into account when choosing the elaboration order for the units in the closure of the main program. If view A imports view B, then all units of view B which need to be elaborated are elaborated before any units of view A are elaborated (excluding mutual imports and preelaborated units).

The following example formerly raised Program_Error because Text_Io.Put_Line was called after Text_Io had been finalized (in particular, after Standard_Output had been closed):

with Ada.Finalization;
package Eo is
 type T is new Ada.Finalization.Controlled with null record;

 procedure Finalize (X : in out T);
  X : T;
 end Eo;

package body Eo is
 procedure Finalize (X : in out T) is
 begin
  Text_Io.Put_Line ("Eo.Finalize called");
 end Finalize;
 end Eo;

 with Eo;
 procedure Eo_Main is
 begin
  null;
end Eo_Main;

The elaboration order was

1 . Eo'Spec

2 . Text_Io and all of its friends and relations.

3 . Eo'Body

4 . Eo_Main

This new prelinker now selects the order and the execution proceeds correctly.

1 . Text_Io and all of its friends and relations.

2 . Eo'Spec

3 . Eo'Body

4 . Eo_Main

The decision about whether elaboration checking is to be suppressed for a two-part subprogram is now made when processing the compilation unit containing the first part of the subprogram.

If the spec and body of a subprogram occur in two different compilation units, then any elaboration-check suppression pragmas which occur in the compilation unit of the body have no effect on this decision.

Subprogram Addresses

<<IBM only>>

For any subprogram Foo, the attibute Foo'Address, now yields a value which can be passed to C code so that the routine Foo can be called from C. On IBM RS6000 systems, this means that the Address attribute of a subprogram now unconditionally yields the address of the ..DESCR subprogram descriptor object associated with the routine. In previous releases, the code address of the subprograms was produced, at least in some contexts.

On IBM systems, for any access-to-subprogram value Ptr, the attibute, Ptr.all'Address yields a null value. On other targets, the code address of the designated subprogram is produced, just as in the case of a statically named subprogram.

System Address

In this release, System.Address is now a private type implemented as an access type. In previous releases, it was a private type implemented as a modular type.

This means that default initialization is now performed in cases where it was not previously performed. For example,

X : System.Address;

X will now be initialized to null whereas before it would have been uninitialized.

One place where this can make a difference is when using address clauses. In this example

type R is
 record
  F1 : Integer;
  F2 : Float;
  F3 : System.Address;
 end record;

procedure P (X : System.Address) is
 R_Var : R;
 for R_Var'Address use X;
begin
 ...
end P;

R_Var.F3 will be set to null. To suppress this default initialization, it is necessary to add

pragma Import (Ada, R_Var);

either after the declaration of R_Var or after the address clause.

Time Type Configuration

Apex represents the values of the types Ada.Real_Time.Time and Ada.Calendar.Time as 64-bit counts of Ada.Real_Time.Time_Unit. On 32-bit platforms, arithmetic on these types is done using software implementations off 64-bit operations. THese operations are much slower than integer operations provided by the hardware, particularly 64-bit multiplication and division. This reduces the performance of Time arithmetic and other operations that use it.

Some conversion operations in Ada.Real_Time are particularly slow, since they are implemented with 64-bit multiplication and division: Split, Time_Of, To_Duration, and To_Time_Span. These may be used implicitly, as when using the Calendar."-" operation to subtract two time values to obtain a duration value. The 64-bit subtraction is relatively fast, but it produces a Time_Span value; this must then be converted to Duration, which is much slower.

None of these conversion operator produce 64-bit results, and so do not need the full 64-bit arithmetic. The 56 bits of precision provided by double precision floating point is adequate. All the native platforms supported by Apex provide hardware which implements floating point operations that are much faster than 64-bit software integer operations. Apex now reimplements the Ada.Real_Time conversions listed above using floating point operations. This results in greatly increased performance for them and other Time operations that use them.

Note: This does not affect Apex embedded products since they cannot assume floating point hardware on the target platform.

Thread Concurrency

Most implementations of POSIX threads provide an extension allowing applications to provide the OS with a "hint" regarding the desired level of concurrency. This usually influences the mapping of threads to underlying kernel entities (e.g. Solaris LWP, SGI sproc) which control the actual allocation of hardware processing resources.

The Apex runtime provides several interfaces to specify the desired concurrency for threads used to implement Ada tasks. For Solaris, one of these is the environment variable ADA_CONCURRENCY_LEVEL. The value of this variable is interpreted as a number and passed to the OS interface thr_setconcurrency().

In Apex 3.2.0b, the code interpreting ADA_CONCURRENCY_LEVEL was left out, so the Apex runtime ignored the environment variable. It has been restored in this release.

This mechanism was developed for Solaris threads when it was the only threads platform supported by Apex that provided this interface. Most of the newer POSIX threads implementations now supported provide this interface, so it is now available for most threaded platforms.

Multithreaded Ada Mutex Locking Policy Emulation

The Apex multithreaded Ada runtime, implemented over POSIX threads, provides an emulation of the POSIX_THREADS_PRIO_PROTECT (priority ceiling) mutex locking policy if it is not implemented by the operating system. This provides support for the Ada Ceiling_Locking polity defined in the Real Time Annex (Annex D). In Apex 3.2.0b, this emulation was implemented incorrectly. When a priority ceiling mutex was unlocked, for example, when leaving a protected object compiled with pragma Locking_Policy (Ceiling_Locking), the priority of the calling task was reset to its active priority at the time the mutex was locked. This is not necessarily correct. If the base priority of the task had been changed in the meantime, and if the mutex being unlocked is the last priority ceiling mutex held by the task, then the new base priority should become the active priority, not the base priority at the time that the mutex was originally locked. This is what currently occurs.

Interface to ANSI C and K&R C - Change in Default

The interface to both ANSI: and K&R C is now supported. In previous releases, Apex supported whichever was the standard for the system .h files.

The ANSI dialect is now the default. To specify otherwise, use pragma Import_Directive. This pragma can be included in pragma.1.ada to set the default to K&R.

pragma Import_Directive (Pre_Ansi).

It is also possible to control individual references. For example,

procedure P;
pragma Import (C, P);
pragma Import_Directive (P, Pre_Ansi);

Single Rada and COMPILER_TOOLS_PATH

Apex 4.0.0 uses a unified rada. This means that the rada executable supplied with the native Apex product is the same one used to code files under the embedded Apex product. Implementing this change resulted in several changes that may effect customers.

How to Invoke rada

Under normal circumstances, rada is not invoked directly. Instead, users should invoke the specific rada functionality: analyze, clean, code, disassemble, link, migrate, parse, or pretty_print. For example,

% apex code ...

Passing special options to rada

In general, options specified in the Apex documentation are known to the command interpreter (apex), and can be used directly on the command line. For example,

% apex code -option

In rare cases, you may need to pass a special option to rada that the command interpreter does not recognize. In these cases, you will need to preface the option with -cmd_options. For example

% apex code -cmd_options -special_option ...

Determining what tools rada is using

Starting with Apex 4.0.0, the target-specific tools used by rada (for example, apex_ada_cg_phase, apex_ada_optim_phase) are no longer on your path. Instead Ada views contain a COMPILER_TOOLS_PATH switch (in the Policy/Switches file). By default, this switch is set to a single directory containing target-specific tools.

The COMPILER_TOOLS_PATH value is not normally on the user's path. When rada is invoked, it prepends the COMPILER_TOOLS_PATH value to the $path before invoking tools.

To determine which tools rada is using, the user can invoke rada indirectly from an Ada view with the -show_tools option. For example,

% apex code -show_tools
/full/path/to/rada
/full/path/to/apex_ada_optim_phase
/full/path/to/apex_ada_cg_phase

COMPILER_TOOLS_PATH Switch

The COMPILER_TOOLS_PATH switch is used by the Ada compiler and other Apex tools to locate target-specific versions of each tools. It can be specified on the command line as -compiler_tools_path <list of filesystem directory pathnames> the Policy/Switches file as COMPILER_TOOLS_PATH: <list of filesystem directory pathnames>. The list of pathnames must be separated by ":"s (same conventions as $PATH.)

The COMPILER_TOOLS_PATH switch is specified in the Ada model. It is copied from the model into the Ada view a view creation and any time an apex remodel -update or -replace_switches command is invoked on the Ada view.

The default value is set by the Ada model being used.

Creating C/C++ Executables Linked with Ada Subroutines

It is now possible to create a C/C++ executable that is linked with Ada subroutines. This is described in Programming with Apex.

Miscellaneous Changes

The following additional changes have been made to the Ada compiler.

• Improved Implementation of controlled types

  The compiler now eliminates certain finalize/adjust pairs as per AI95-00083. The compiler is able to transform dispatching calls into direct calls in more cases than it could before, resulting in more efficient code.

• Improved stream operator performance

  See AI95-00195, item #9.

  The RM states that the predefined streaming operations of a structured type must handle each component separately. For example, calling Standard.String'Write with a value of length 10 must result in 10 dispatching calls to Ada.Streams.Write. AI95-00195, item #9, relaxed this requirement and the compiler now takes advantage of this freedom. When it is possible, Stream operations on structured types now treat the structured object as a whole instead of decomposing it into its components.

• Support for package Simple_Io.

Ada Object Editor

Coloring

The default Ada object editor now does both language coloring and "as you type casing". These can be turned off by setting the APEX_NO_ADA_LANGUAGE_MARKS and APEX_NO_AS_YOU_TYPE_CASING environment variables to true.

The casing is consistent with the pretty printer switches. Currently only the Ada object editor does language coloring. The C/C++ editor does not do this.

The new color scheme is consistent with the color scheme used with Apex NT and with other environments such as MSVC++. Language constructs (keywords, strings, comments, etc.) have a foreground color with a white background while messages and prompts have a background color and a white foreground.

Here are the default settings for the common constructs:

Messages and Prompts	white foreground
Error Messages	red background
Warning Messages	orange background
Text Messages	blue background
Prompts	dark grey background (as before)
Language Colors	white background
Comments	darkgreen foreground
Keywords	blue foreground
Strings	brown foreground
Character Constants	brown foreground (same as strings)
Number Constants	DarkKhaki foreground (not implemented for Ada)
Braces	CadetBlue foreground (not implemented for Ada)
Preprocessor Lines	red foreground (not implemented for Ada)

Semantic Completion Dialog

Semantic completion in the Ada object editor can now be configured using the Completion Options dialog box. This dialog is displayed if the Control key is depressed while selecting Compile > Complete. The discussion of semantic description in Programming Using Apex has been improved and the new dialog is described in detail in the Online Reference.

Runtime

For Apex Solaris 4.0.0b native, the Ada runtime now checks for insufficient stack space to meet the requirements for stack space size as requested by either "pragma Main(Stack_Size => ...);" or by the configuration table parameter V_Usr_Conf.Configuration_Table(Main_Task_Stack_Size). Solaris does not allow a process to change its own stack size limit, so the solution we chose is to emit the following warning when the current stack space is insufficient:

Ada runtime warning:
This program has been configured to request xxx bytes of stack space 
either via V_Usr_Conf.Configuration_Table.Main_Task_Stack_Size, or 
via pragma Main (Stack_Size => ...).  However, the current stack 
size cannot be increased beyond what was set by the parent process, 
which is currently xxx bytes.

If you are invoking this program from the shell, use the command 
`limit stacksize yyy' to increase the stack limit before running 
this program.

Otherwise, in the parent process, before invoking this program, use 
the system call setrlimit(2) as follows: setrlimit(RLIMIT_STACK, 
xxx);

(Where xxx is the number of bytes, and yyy is the number of kbytes)

Note that this message tells you the csh or tcsh command to use, not the sh, ksh, or bash command, which would be "ulimit -s yyy"

When assigning a priority to a task in the threaded runtime, Ada priorities are translated to POSIX priorities by transposing the Ada priority range into that of the scheduling policy of the underlying thread. However, this is not done when assigning a ceiling priority to a PTHREAD_PRIO_PROTECT mutex. This leads to unexpected behavior.

User Interface

The File > Run and File > Debug dialogs have been combined into one dialog. The new unified dialog has pages to select between running and debugging. Use the Run page to run a program. Use the Debug page to debug a program. The menu items have not changed. For example, selecting File > Debug will bring up the new dialog with the Debug page selected.

The Debugger Tasks window contains three new buttons: Default, Full, and Stack Usage. You can select all tasks, or a single task, then one of these buttons to change the format of the Task window display. Default corresponds to the simple lt case. Full corresponds to the lt all | <task number> (lt all or lt 5). Stack Usage corresponds to lt use or lt use 5.

The Debugger Session check box has been removed from the File > Debug dialog.

The descriptions of the options from the Print dialog have been corrected The Raw option has been added and Postscript has been changed to Formatted to match the actual entries on the dialog.

The Show Unused and Show Usage dialogs have changed extensively. These changes are also reflected in a new set of options for the show_unused and show_usage commands. These commands are documented in the Command Reference.

Apex Shadowing

A new context switch, REMOTE_CONTEXT_COMPLETION, is used when shadowing is enabled. It allows the view to specify a remote context relative path.

Currently the remote context is either specified directly in the shadow switches, or if USE_CONTEXT_AS_BASE is set, then the <subsystem_path>/<view_name> is append to the remote context.

Both switches are supported, but the new switch takes precedence over the old switch (the new switch can achieve the same thing as the old switch "<view>:s:r/<view>:t:r")

Summit/CM

Bill of Materials Command

A new command, apex_BOM, enables you to obtain a bill of materials from an Apex build if the Summit/CM configuration management system is being used. This command supports the generation of a Version Description Document. This command is described in detail in the Command Reference.

New Command Options

The abandon, control, set_history, and set_version commands now accept the -no_artifacts option. This option specifies that compilation artifacts should not be [abandoned, controlled, or set] with the source files. The default value is false.

The -goal <goal_state> option has been added to the copy command. The new objects will be copied along with artifacts appropriate  to the goal state.Units in the new views are compiled to the requested state as required, except in the case of preserve, which preserves the original state but does not perform any recompilation. The default value is preserve.

Tools

Reporting Problems to Apex Technical Support

A new version of the rreport tool is included in this release. This tool enables Apex customers to more easily and quickly report problems and suggestions to Apex Technical Support.

The rreport tool asks the customer for the problem description and automatically includes required Apex data (version, patches, installation log) to the report sent to Apex support. In addition, a case in Vantive is automatically created when rreport is used to report problems/make suggestions to Rational.

Apex Disassemble

The apex disassemble command has changed where it puts the assembly files. The new default location is in the source directory next to the .ada files. Two switches can modify this new default behavior.

• APEX_DISASSEMBLY_HIDDEN=True

  Reverts to the default behavior for previous releases. The.asm file is placed in the corresponding subdirectory of .Rational/Compilation.

• APEX_DISASSEMBLY_DIRECTORY=<pathname>

  Places the .asm file in the named directory. This switch overrides APEX_DISASSEMBLY_HIDDEN.

Documentation

Changes in Hard-Copy Documentation

The Rational Apex documentation set has been simplified. No longer are there separate manuals for each variant of Apex (Ada, C/C++, Duo). Where there is information that is specific to only a single variant, it is clearly labelled in the documentation.

Many of the titles of the Apex manuals have been changed to adhere to the Rational standards for manual titles. In addition, the manuals are now formatted using the standard Rational templates.

User Interface Changes in Help Files

In the online help system, a link to the Technical Support Tech Notes has been added to the HTML help files. The Tech Notes provide additional, in depth information on the Rational Apex product.

The Version button has been removed from the online help files. To view Version information, click Help > On Version.

RCI

ClearCase support

• RCI is supported by Apex/Clearcase

  In such a context, Rational (.rss) subsystems may be created with an RCI model, and have an associated RCI target directory.

  The File > New Subsystem dialog has an RCI tab, which allows specification of the usual RCI options (host-only view, target machine name, target directory context and name) for creation of the RCI target directory.

• An RCI .rss subsystem may be controlled under ClearCase, just like any other .rss subsystem.

  RCI itself has no provision for controlling the associated target directory, which will typically be managed as a non-controlled, view-private object.

  If the target directory is to be controlled, this will have to be managed explicitly by the user, or by the RCI customization scripts (which will have to be adapted to handle the ClearCase actions associated to the creation/deletion of a target library or target unit).

• When operating on .rss subsystems, the RCI > Create Target Library and RCI > Delete Target Library dialogs have, in the same manner as other Apex dialogs (Remodel, Add Import), a button Check out/in Artifact files, to perform checkout/checkin of the subsystem's Policy/Switches file.

  This allows the target library creation/deletion process to update the RCI specific switches in the switch file.

  RCI also has a provision for managing the RCI specific switches in a separate, view-private file, rather than in the controlled default switch file:

  The RCI model view for the customization should then be set up so that:

  • The RCI switches are moved from its Policy/Switches file to a Policy/RCI.sw file;
  • The Policy/Switches file does an `INCLUDE: RCI.sw'.

  This setup will then be automatically propagated to any RCI subsystem created from this model.

  Note: To support this usage model, the RCI customization scripts should be updated to take into account the Policy/RCI.sw file, if it exists. This is the case for the sample customizations provided with this release.

Changes that may affect existing customizations

Existing RCI customizations, that work with previous releases of Apex, will have to be slightly adapted, to take into account the following changes in Apex 4.0.0b:

• OMS/CMVC version

  The value of the OMS/CMVC version parameter that is passed to most RCI customization scripts, has changed from 1.0 to 1.2. This value is typically tested in the test_version script, that should be adapted to accept the new value.

• Clean operation

  The clean customization script should no longer use the rada_clean command. It should instead call rada -clean.

• Post_Create_View parameters

  The post_create_view customization script should now handle, in addition to the existing -rci_target_directory parameter, the new parameters -rci_target_context, -rci_default_target_context and -rci_default_target_directory.

  This interface change was needed to support the new scheme introduced in this release for handling target library specifications (see below).

Please refer to the sample customizations provided with this release for examples of the updated test_version, clean and post_create_view scripts.

Handling of target library specifications

In previous Apex releases, in the File > New View, File > Copy (View) and RCI > Create Target Library dialogs, the RCI target "context" and "library name" specified by the user were combined by the dialog itself to generate a target directory pathname which was passed to the underlying Apex or RCI command.

This scheme had serious drawbacks when the target system was not the same as the host system, especially if the target system was not a UNIX system.

Starting with this release, the context and directory name specified by the user are passed unmodified from the dialog, through the underlying Apex or RCI command, all the way to the RCI post_create_view script, which may then interpret its -rci_target_directory and -rci_target_context parameters and compose them according to the target OS file naming rules, to generate the resulting RCI_TARGET_DIRECTORY name.

Also, when a "default" context or library name is selected by the user, this information is passed to the post_create_view script (-rci_default_target context and -rci_default_target_directory boolean parameters), which may then synthesize default values as appropriate for the customization.

Upgraded sample customizations

The Ada83 VADSself and Ada95 GNAT sample customizations delivered with RCI have been upgraded in various aspects in this release.

Support for new versions of target compilers

The VADSself customization now targets version 6.2.3d of VADSself Solaris.

The GNAT customization now targets version 3.12p of GNAT Solaris.

New setup for predefined views

The mapping of predefined units for the target environment to the $APEX_BASE/ada/xxxx.ss subsystem views for the sample customization has been reorganized, to have a setup similar to that of the standard Apex predefined views.

• VADSself customization

  The VADS predefined units (from the VADS standard library) are now distributed across an lrm.ss view and a (new) predefined.ss view (the lrm.ss view contains the minimal set of units required by Apex).

  The units from the VADS verdixlib library remain in the VADS specific verdixlib.ss view.

• GNAT customization

  The GNAT predefined units (from the GNAT adainclude directory) are now distributed across an lrm.ss view, a predefined.ss view, and views in the standard Apex subsystems for Ada95 annexes: distributed_systems.ss, information_systems.ss, numerics.ss, realtime_systems.ss, and systems_programming.ss.

  The lrm.ss view contains the minimal set of units required by Apex, and the Ada95 annex subsystem views contain the relevant units, according to the distribution outlined in RM 95 A (2).

Revised customization scripts

The scripts provided in the $APEX_BASE/ada/keys/rci_xxx compiler key directories for the sample VADS and GNAT customizations have been extensively rewritten:

• to be more suitable for `as is' usage of the sample customizations.
• to provide a more robust and complete reference base to build other customizations.

RCI customizers are strongly encouraged to study these sample scripts and use this new base for evolutions of their own customizations.

The scripts now have a more homogeneous format and coding style.

Comments have been revised, to better document the purpose of the scripts and the conditions where they get called.

Areas of the scripts that may need to be adapted for a new customization ("CUSTOMIZABLE CODE" boxes) have been more systematically identified and documented.

To encapsulate actions repeatedly performed by customization scripts, a number of utility scripts have been added, among which:

• get_switch and set_switch, to get/set the value of a RCI view switch. These scripts transparently handle the case where a RCI view has an RCI-specific switch file.

  The set_switch script replaces the previous set_state_value script.

• get_op_spec, to get the value of an operational characteristic from the rci_op.spec specification file.
• download and upload, to perform file transfer operations between the Apex host and the target compilation host.
• build_comp_command and build_link_command, to generate target compile or link command lines, based on the compiler key xxx_option_line and xxx_option_symbol templates and the view's xxx_option_file. The rci_post_build_script script, to generate batch mode scripts, now uses these utility scripts.

As a result, most of the scripts are now common between the VADS and GNAT sample customizations,

The sample customizations now come with an interactive setup script, which may be used to automate the setup of the customization for the local installation of the target compilation system (see the README file provided in the customizations' compiler key directory for details).

---

Guidelines and Restrictions on Using Rational Apex

The known limitations of Apex 4.0.0b are described below. Workarounds are included where applicable.

Ada Compilation System

Running Apex binaries compiled on Solaris 2.7 under Solaris 2.6

New releases of operating systems usually provide several forms of backward compatibility. In particular, it is often possible to run binaries compiled for an older version of the OS on a new release. Running binaries compiled for the newer version of the OS on the older version may also be possible, though it is not usually supported and may cause problems.

Solaris 2.7 binaries in particular can often be run using Solaris 2.6 with varying degrees of success. However, binaries that make use of POSIX 1003.1b Real-Time Extensions will fail immediately for lack of the shared librt.so library with a message like:

swift% driver_900042
ld.so.1: driver_900042: fatal: librt.so.1: open failed: No such file 
or director
Killed

Here librt.so.1 is the particular version of librt.so on this machine. A soft link from librt.so to librt.so.1 is provided in /usr/lib to direct the linker to the latest version of this library. Note that the linker looks through the soft link, including the name of the actual library file rather than the link in the resulting application binary. The Solaris 2.6 equivalent to this library is libposix4.so. Solaris 2.6 binaries using libposix4.so will work on Solaris 2.7, since a soft link from libposix4.so to librt.so is provided in /usr/lib. Apex always links against the name libposix4.so to support Ada.Calendar and other time related features, but again the linker looks past the soft link to the name of the library binary itself. Those linked on Solaris 2.7 will therefore attempt to load librt.so when executed. Under Solaris 2.6 this will fail since there is no library of that name.

In general it is best to avoid running Solaris 2.7 binaries on 2.6. However, this particular problem can be avoided by providing a link visible to the loader from the name needed by the binary to /usr/lib/libposix4.so. The easiest way to do this is to add the appropriate link in /usr/lib. For the example above:

cd /usr/lib
ln -s libposix4.so librt.so.1

This requires superuser privileges. In the absence of such privileges, any directory can be used by adding it to the LD_LIBRARY_PATH environment variable:

cd $HOME
mkdir lib.2.7
cd lib.2.7
ln -s /usr/lib/libposix4.so librt.so.1

To make this visible to the loader, execute

setenv LD_LIBRARY_PATH $LD_LIBRARY_PATH\:$HOME/lib.2.7

If you are attempting to run the application outside of an Apex shell,
LD_LIBRARY_PATH may not be defined, in which case you should substitute:

setenv LD_LIBRARY_PATH $HOME/lib.2.7

Ada 95 Unimplemented Features

The following Ada95 features are not implemented in the Apex 4.0.0 B compiler:

• Discriminant-dependent entry families for tasks (RM95 3.7.1) and protected records (RM95 9.4):

  task type T (D : Natural) is
  entry Nyi (1 .. D);  -- Not yet implemented.
  entry Ok (1 .. 10);  -- Ok, not discriminant-
  -- dependent.
  end T;
  

• Bit_Order attribute (RM95 13.5.3).
• Annex B
  • Interface to COBOL (RM95 B.4)
  • Interface to FORTRAN (RM95 B.5)

    Fortran-convention multi-dimensional array types are represented in column-major format instead of the usual row-major. The predefined type Interfaces.Fortran is provided, although the package Interfaces.Fortran.Logical is not declared.

• Annex E: Distributed Systems
  • Not supported.
• Annex F: Information Systems
  • BCD decimal types (RM95 F.1)
  • Package Ada.Decimal (RM95 F.2)
  • Package Ada.(Wide_)Text_Io.Editing (RM95 F.3)
• Annex H: Safety and Security
  • Pragma Normalize_Scalars (RM95 H.1)
  • Pragma Reviewable (RM95 H.3.1)
  • Pragma Inspection_Point (RM95 H.3.2)
  • (Note: Most restrictions in H.4 are implemented)

Ada 95 Known Limitations

• Atomic/Volatile pragmas (RM95 C.6) are only supported for scalar types.
• Volatile/Volatile_Components pragmas (RM95 C.6) do not necessarily force every read/write of a volatile object to be performed to memory.
• Optimize (Off) pragma does not disable all optimization of a subprogram when the enclosing view has an optimization level greater than zero.
• Discard_Names pragma (RM95 C.6) has no effect.
• Initialization and exceptions (RM95 7.6.1).

  When the initialization of an object of a controlled type (or one containing controlled components) is abandoned due to an exception or an abort, the already initialized subcomponents are not finalized. (Any top-level object that has been completely initialized WILL be properly finalized when an exception or abort causes the scope to be exited).

  procedure P is
  type T is record
   F1 : A_Controlled_Type;
   F2 : Natural := -1;
   F3 : A_Controlled_Type;
  end record;
  
  X : A_Controlled_Type;
  Y : T;
  Z : T;
  
  begin
  
  -- Execution does not reach this point
  -- because an exception is raised during the 
  -- initialization of the field Y.F2. 
  -- The object X (which has been completely 
  -- initialized) will be finalized. 
  -- The field Y.F1 (which was successfully
  -- initialized) will not be finalized.
  
  end P;
  

• Initialization and elaboration (RM95 7.6.1).

  When the elaboration of a main program is abandoned due to an exception (or an abort), any units that were successfully initialized will not be finalized. Once the main program has been fully elaborated, if its execution is abandoned, then all of the units in the closure will be properly finalized.

• Streams (RM95 13.13).
  • Objects of type Ada.Exceptions.Exception_Occurrence cannot be streamed.
  • Objects of an access-to-subprogram type cannot in general be streamed using the default compiler-generated stream routines. When the access type is declared at static scope (not nested within a subprogram) then compiler-generated routines will work on platforms other than IBM.
  • When using a representation clause to override the default compiler-generated streaming routines for a tagged type, it is necessary to override all four ('Read, 'Write, 'Input, and 'Output).
• Data validity (RM95 13.9.1).

  In some cases the compiler erroneously assumes that the value of an object lies within the bounds of its subtype. For example, the value of an uninitialized scalar object may not be a valid representation for an object of that type. In the Ada95 standard this is a bounded error that is not always caught by the current Apex implementation.

• When using a user-defined storage pool for access type, the alignment parameter passed to the storage pool's Allocate procedure will always be "double-word aligned" (that is to say, 8 bytes on most architectures) instead of the alignment of the designated type as specified by the LRM. The Apex storage management routines require that the user Allocate procedure honor the alignment passed (8 bytes).
• "Per object" alignment and size clauses are not supported for objects of floating point, access, or task types.

SPARC V9 Solaris 64-bit C/C++ Profiling

For Sol64, prof is not supported; only gprof is supported by Sun. In order to be able to profile a C/C++ program using the Apex C/C++ compiler, RCC, you must obtain the64-bit version oft he gprof run-ime object gcrt1.o and copy it over to the sol64 RCC area (CPP_COMPILER_HOME/self/lib). If you do not do this, the link will fail. Once the 64-bit version of gprof is in place, profiling support via gprof is complete for the Sol64 product.

This also applies to profiling mixed Ada/C/C++ programs with Ada/C++ as main (where RCC is doing the final link.) You must obtain the 64-bit "gcrt1.o" for the link to be successful.

AXI

HP-UX 11 requires a number of patches to link correctly. Most of the following, if not all, are required:

• PHCO_19182 cumulative 10.20 libc compatibility support
• PHCO_19391 libc cumulative patch
• PHSS_16849 LIBCL patch
• PHSS_16931 milli.a cumulative patch
• PHSS_17327 X/Motif2.1 Dev Kit Mar99 Periodic Patch
• PHSS_18013 X/Motif2.1 Runtime Apr99 Cumulative Patch
• PHSS_18072 ld(1) and linker tools cumulative patch
• PHSS_18300 ANSI C compiler cumulative patch
• PHSS_19178 +O4/PBO compiler cumulative patch

Note: HP is updating patches for HP-UX 11 so fast that some may be out-of- date by the time you read this.

Apex threaded views don't cause the pthreads library to be linked by default. This library needs to be linked explicitly on HP-UX 11. Workaround: Add -lpthread to the NON_ADA_LINKAGE line in the AXI threaded views.

The Apex threaded runtime calls pthread_setschedparam(). Non-root users need a special privilege to call this function on HP-UX 11; the privilege is RTSCHED. Workaround: On HP-UX, privileges like this are granted to groups, with setprivgrp(1M). As root, run the command setprivgrp gks RTSCHED ("gks" being your usual group). Now one may put group privileges in the file /etc/privgroup to cause them to be set at boot time, as well.

Apex forces the static version of libc to be linked. The static libc has a broken gethostbyname() function, which corrupts X Windows and almost any network-aware software. Judging from HP's documentation (see the manpage for gethostbyname), they don't intend for resolver functions to work properly from the static libc. Workaround: Add the arguments -Wl,-a,shared -lc to the end of the linker arguments for HP-UX 11 (only) in the apex_ada_link_phase script.

HP has bundled the X11 and Motif development libraries with their extra-cost C compiler in HP-UX 11 (This was previously in their bundle at no extra cost). HP is now charging for a C compiler to get X11 and Motif libraries you can link with. Even if you want to use Apex, you must buy HP's C compiler.

Runtime

After setting the UNIX signal mask using V_Interrupts, executing a DELAY statement will corrupt the signal mask. Workaround: Remove the DELAY statement.

The following session switches are not supported:

APEX_TASK_PRIORITY_DEFAULT
APEX_TASK_STACK_SIZE_DEFAULT
AEPX_TIME_SLICE
APEX_STACK_SIZE
APEX_SIGNAL_STACK_SIZE

The Rational Ada runtimes do no support the fork() system call as a mechanism for creating a process. The posix.ss subsystem supports the industry standard bindings to POSIX which includes Posix_Process_Primitives.Start_Process, as the recommended way to create a new process from an Ada program.

Libraries

The multiplication function in the complex arithmetic package in $APEX_BASE/vads_compatibility.ss/.../verdixlib is incorrect. It incorrectly assumes that values of equal magnitude are equal, even if the signs are not. This results in incorrect values. Therefore (2,2) * (2,-2) yields (0,8) when it should yield (8,0). In Ada 95, Rational strongly recommends that you use the complex arithmetic implementation in $APEX_BASE/ada/numerics.ss.

The return code from procedure $APEX_BASE/vads_compatibility.ss/.../verdixlib/unix_calls.open is documented backwards. The routine returns True if there is an error and False if it succeeds.

Interfacing with C

When generating code for a function with a 32-bit floating point result, the Rational C compiler promotes the result to a 64-bit representation.

On targets which support 32-bit floating point registers, for example, Sun and SGI, this is incompatible with the conventions of the platform vendor's C compiler. On other targets, such as Dec Alpha, this promotion has no effect because all floating point results are returned in 64-bit registers.

The Rational Ada compiler expects C functions to follow the conventions of the platform vendor's C compiler. This means that the following example executes correctly if the .c file is compiled with the vendor's C compiler and fails on targets such as Sun and SGI if it is compiled with the Rational C compiler.

float foo () { return 3.0 ;}

procedure Maine is
 function Foo return Float;
 pragma Import (C, Foo, External_Name => "foo"):
begin
 if Foo /= 3.0 then
  raise Program_Error;
 end if;
end Maine;

Workaround: Use 64-bit floats instead of 32-bit floats on those platforms for which this is a problem.

ASIS

The test install of ASIS is very slow. Link time takes up the bulk of the test install time. Link time can be reduced by a factor of 10 if the link is performed on the same machine that owns the disks on which the ASIS views are installed.

Optimizer

The optimizer assumes infinite precision for floating point operations. This is a problem in some cases. For example, if you have the expression

while x + 1.0 /= 1.0 loop

and x is continually reduced towards zero, the expected result is that when the value of x drops below float_type'EPSILON, the comparison will become false (i.e., x + 1.0 will equal 1.0). The optimizer assumes an infinite precision for x, such that even float_type'SMALL +1.0 /= 1.0. This is incorrect per LRM 4.5.7 and 3.5.6. The workaround is to turn off optimization.

(RS/6000 AIX only) If you are running the Ada compiler at optimization level 1 or 2, the optimizer can sometimes fail on very large units because there is insufficient memory on the system. The optimizer tries to recover by simply not optimizing, but this will be unsuccessful due to idiosyncrasies of AIX. The entire compilation will then fail. Workaround: Set the ulimit to a low number (so you run out of memory, and not the system). When the optimizer runs out of memory, it will simply use the unoptimized intermediate, and the compilation will succeed. See your system administrator for guidance on what to set the ulimit to as it is dependent on the system resources. In general, it should be less than the total swap space in the system, allowing for other users.

Debugger

• The debugger cannot be attached to a running process if the process's executable file is on an NFS mounted file system that's not mounted "nointr". The debugger dynamically checks for this and issues an error message at the time of the attach. Workaround: Mount the disk as "nointr" or place the executable on a locally mounted disk. (HP Only)
• The debugger takes an excessively long time to single-step over Ada statements that call the run-time kernel (e.g. an array of task type elements).
• The raise command should not be used from inside the prolog of a procedure because its behavior will be unpredictable.
• The watchpoint mechanism takes advantage of hardware or software support when it is available. If this support is not available, the debugger uses single stepping to watch objects. If single stepping is used, watchpoint execution will be slow. At the current time, watchpoints are slow on all targets except SGI and PowerPC.
• When a breakpoint is set on a call to a task entry, the debugger sometimes gets confused and hangs when an advance/step over command is entered, or skips to a faulty line upon issuing a step command.
• The following error:

  a.db error: spec of ex_raise not found in searched libraries
  

  is sometimes reported when a program which is executing in the debugger raises an exception and a break on exception with command block is set.

• Modify data in the debugger only supports the modification of scalars, strings, and pointers.
• When you kill a program using the File > Kill command from the debugger GUI, then run another program, one or two of the following messages will be displayed in the debugger's log window:

  can only handle init messages from hi
  

  These messages should be ignored. Debugging is not affected.

• The debugger prints an error message when trying to display a parameter whose type is tagged.
• The debugger prints bad values for protected object entry parameters.
• The Emacs editor does not work with the GUI debugger. Workarounds:
  • Use the Ada Object Editor with the GUI debugger
  • Use the debugger in Source Mode (display source code in the debugger window with the View > Show Source command)
  • Use the command-line debugger (rdb or a_db).
• The debugger is currently unable to call a task entry. A CASE_ERROR is generated if this attempted.
• The Ada95 debugger cannot set breakpoints within a protected entry.
• The Ada95 debugger cannot display discriminants of a task.
• User procedure calls of protected functions and procedures from within the debugger are not supported.
• The debugger cannot display protected entry parameters correctly.
• The debugger cannot display tasks or protected objects with discriminants.
• The multi-exe debugger does not support multiple dbrc files well. In particular, the debugger does not read in the dbrc file for exec'd files correctly.
• The following are known limitations of the Object Display Window:
  • Deleting objects causes unnecessary reevaluation of remaining objects.
  • Inactive objects and some other evaluation errors aren't handled very well; they may result in blanks in the Object Display Window and extraneous messages in the Log window.
• Messages are displayed indicating that the debugger cannot access the memory of the program being debugged. These are due to a problem with disassembly of a program that uses shared libraries. (DEC Alpha OSF/1 only)

Ada Object Editor

Functionality of Basic Keys in Apex Editor under Solaris 6 or later7

The Home, End, PageUp, and PageDown keys do not work as expected in the Apex Editor on Solaris 6 and Solaris 7. The problem is that the Motif setup on Solaris 2.6 or later is incompatible with Motif applications like Apex. Solaris is defining osfBeginLine twice, once for the Home key and once for the "7" key on the numeric keypad. When the Motif library code in Apex reads two bindings for the same osfKeysym, it only accepts the second one, that is, for the "7" key.

The workaround is to create a file called $HOME/.motifbind containing this text:

osfActivate:    <Key>KP_Enter
osfCancel:      <Key>Escape
osfHelp:        <Key>Help
osfMenu:         Shift<Key>F10
osfMenuBar:     <Key>F10
osfLeft:        <Key>Left
osfUp:          <Key>Up
osfRight:       <Key>Right
osfDown:        <Key>Down
osfBeginLine:   <Key>F27
osfEndLine:     <Key>F33
osfBeginLine:   <Key>Home
osfEndLine:     <Key>End
osfPageUp:      <Key>F29
osfPageDown:    <Key>F35
osfPageUp:      <Key>Prior
osfPageDown:    <Key>Next
osfBackSpace:   <Key>BackSpace
osfDelete:      <Key>Delete
osfInsert:      <Key>KP_Insert
osfInsert:      <Key>Insert
osfUndo:        <Key>Undo
osfAddMode:      Shift<Key>F8
osfCopy:        <Key>SunCopy
osfCut:         <Key>SunCut
osfPaste:        <Key>SunPaste

When you log in again (or when you restart the window manager), the _MOTIF_DEFAULT_BINDINGS root property will be initialized from this file instead of the Solaris defaults. Apex will then bind the Home, End, PageUp and PageDown keys as expected. You can also change the motif bindings without restarting X or the window manager by running "xmbind bindings_file", but you'll have to restart Apex afterwards to see the new bindings.

If you use the Sun desktop, you can copy this file to /usr/dt/lib/bindings/sun, which makes these bindings the default for all users.

Apex/ClearCase Integration

Command-line Interface

In release 4.0.0 B of Apex migrate_diff and migrate_view are currently not supported. They will be supported in an upcoming patch release. Please check with your Rational Sales Representative for more information.

Configuration Management System (Summit/CM)

Set Location for Remote Storage Directory

If you remotely store a view in another directory outside a subsystem, you should first execute Control > Maintenance > Permanent Name on that directory to establish a permanent name for it. This avoids possible automounter problems.

Recovering File Locks from Remote Machines

When an Apex command runs on a machine (machine A), it attempts to acquire a lock for a file. If it finds the file locked on a remote machine (machine B), machine A checks machine B to see whether the process that acquired the lock is still active. If the process is not running, machine A recovers the file lock for itself. If the process is still running, the command running on machine B retains the file lock.

For this to work correctly, the remote machine must be running the remote execution demon (rexd).

To see whether rexd is running on the remote machine, enter the following command in an xterm window, where remote_machine is the hostname of the remote machine:

on remote_machine ps 1

If a status line is returned, the remote machine is running rexd.

You can also set APEX_LOCKING to 'rsh' or 'on' depending on how you want locking to query the remote machine.

If you cannot run rexd, contact your Rational technical representative for alternative workarounds.

Version Description Files and Obsolescence

Introduction of new VDF files does not cause imports to be considered to be obsolete.

Any changes to included VDF files or VDF files in export directories do not cause obsolescence of client import information.

Task Management System (Summit/TM)

Task Editor Naming

The Task Editor dialogs for different task kinds must have different names.

Controlled Tasks

A task file can be made a controlled object under the Summit/CM system, although this is not recommended. A controlled task must be checked out when the task is modified via a task editor or the modify_task command, when the task is associated with or disassociated from an object via a Summit/CM command (such as check_out), and when a child of the task is created, since a checked in task cannot be modified.

Updating Existing Task Management Domains

Incompatibilities between older versions (pre 2.4.0) of Summit/TM and newer versions (2.4.0 or later) may cause problems when updating existing  task management domains

This is an issue that may arise at installation time when the Summit/TM installation tests are performed, or it may occur later when a user tries to create a new task in some existing old task domain. In either case, an error of the form:

*** missing kind field for task template /xyz/.../abc.task

is generated from the create_task command. Task templates used by the create_task command must always identify their task kind via the "Kind" field.

There are two ways to solve this problem depending on which task kind is being used to create the new task. The task kind can be determined by examining the KIND_PATH switch in the Policy/Taskmgmt.sw switch file of the given task domain subsystem.

Workarounds:

1 . If one of the older versions of the standard task kinds is being used, such as:

$APEX_BASE/task/task_kinds.ss/share.1.0.4.rel/change

replace the old standard task kind in the KIND_PATH switch with the respective new one, such as

$APEX_BASE/task/task_kinds.ss/share.1.0.7.rel/change.

2 . If a user-customized task kind is being used (with the simple name, "my_kind", for example), add the following line to the task template that was used to create the new task:

Kind: my_kind

User Interface

Delete Object Confirming Dialog

The behavior of the Delete Object command in terms of confirming dialogues is inconsistent. If a single subsystem in the directory viewer is selected the Delete Object command is executed, a confirming dialog is displayed. To delete the subsystem and all its contents, the user must click Yes for the action to continue.

If a directory, which contains a subsystem, is selected and the Delete Object command is executed, no confirming dialog is displayed and the action is carried out.

White Foreground

On some systems, most notably CDE, an X resource gets loaded of the form:

*foreground: #FFFFFFFF

This results in the default foreground color being white in every possible place. Apex's X defaults set up background colors for everything but only sets foreground colors for error messages and warnings. Directory viewers have a background that is almost white so things are just about invisible. Workaround: Place the following in your .Xdefaults or Rational file:

Rational*forground: black

Or, from the command line, enter:

% xrdb -merge -nocpp Rational*forground: black ^D %

Note that you need the -nocpp to get it to work interactively.

Failure to Open Xterm Window (AIX Only)

Opening an xterm window with the Tool > Shell menu item sometimes fails and does not generate an error message.

When either IBM's xterm or aixterm starts, it resets its LIBPATH environment variable and the process running inside the xterm/aixterm does not inherit the LIBPATH value passed by the program or shell that launched the xterm/aixterm. The Tools > Shell command in the Apex GUI may not work correctly because of this problem.

Symptom: The xterm/aixterm window appears, prints a message about missing runtime symbols, and then disappears.

Workaround: Always set LIBPATH if it is not already set in your .cshrc file. For example,

if (! $?LIBPATH) then
 setenv LIBPATH /usr/lpp/X11/lib/R5:/usr/lib:/lib
endif

If your shell is /bin/sh, this workaround cannot be used because sh does not have a per-shell initialization file. Other shells may or may not have an init file like .cshrc. Similar workarounds can be installed using the scripting language for those shells.

Note that this problem also exists in previous releases.

Clearing Output Windows

Output windows become slower as they acquire large amounts of information. To speed up the output, occasionally clear the window by selecting File > Clear.

Documentation

Manpages

If you are having problems displaying an Apex man page because there is a system command man page with the same name (such as the link command), use the following man command format from an Apex shell window:

%man -F -M  $APEX_HOME/doc/En_US/man/ada link

Difficulties Starting Online Help

If you have problems initially accessing the online help system in Apex, invoke Netscape outside of Apex, then attempt to access the help system again. This time the desired documentation will be displayed in the Netscape window.

If the Netscape session begins, but the correct help page is not displayed, repeat your help request. The online help page will now be displayed. This may happen the first time the help system is invoked.

Dancing Colors

When using Apex and viewing the online help system using the default Netscape, your display colors may change as you shift from Apex windows to the Netscape window. To eliminate these "dancing colors", you must edit the value of the APEX_HELP_BROWSER switch. Do this using the Tools > Session > Environment command to change the value of this switch to "netscape" (from "netscape-install").

Note that, while the dancing colors will stop, poor color mappings for the Apex dialogs could result.

Java Browser/Web Interface

Co-hosting Apex and Web Servers

If you plan to use the Apex/Java Interface, the Web server and the Apex server must be the same machine. This is a Java restriction.

The Apex Web interface includes a Java applet. One unchangeable characteristic of a Java applet is that it can communicate only with the Web server from which it comes. This means that the Web server applet cannot make a connection to some arbitrary Apex server. It can connect only to the Web server itself.

Using Web Browsers

The Apex Java source has been ported to Swing technology. For any browser to be able to use the Apex Web Interface, the JDK 1.2.2 plug-in is required. Note that both JDK 1.2.2 and the "appletviewer" tool shipped with JDK 1.2.2 are required.

Pressing Icon Buttons and Selecting Tabs

The Apex/Java Interface icon buttons (navigate, alternatives, history, and completion) will respond to a mouse click only if the mouse does not move before the mouse button is release. The slightest movement will cause the click to be ignored.

If an icon button appears to pop out instantly as the mouse button is released, the click has probably been ignored.

The same problem occurs in tabbed dialogs when a tab is selected. The selection is ignored if the mouse moves.

Groups/Associated Groups Display

HP Only: In order for the groups command or the Associated Groups field in the File:New:New View and File:Copy Object:Copy View dialogs to correctly display available groups, the HP machine must be configured properly. Otherwise, the group list is not correctly initialized for each user at login time. Details on doing this can be found on the initgroups(3C) manpage. One way to accomplish this is to execute the following command as root:

In -s /etc/group /etc/logingroup 

Note that doing this soft link results in the possibility of the login operation to hang until the NIS server responds.

To see the effect of this change, you will need to login again, but the machine does not need to be rebooted.

Installation and Licensing

For several of the Apex platforms, there are known limitations pertaining to the installation of Apex. These are described in detail in the Installing Rational Apex.

Not all FlexLM features described in the online FlexLM documentation are supported. Most notable of these is the TIMEOUT feature, which is not supported by Apex.

RCI

Setup of sample customizations

Before they are used, the sample RCI customizations for VADSself and GNAT need to be setup for the local installation of the target compilation system (see the README file provided in the customization's compiler key directory for details).

This process may be automated by using the setup script provided in the customizations' compiler key directory. This interactive script should be run within an Apex session, by the user who `owns' the Apex/RCI installation.

Compiler_Properties File

An RCI customization's Compiler_Properties file (in the compiler key directory) must include the property RCI_VERSION. If it is missing, Apex will treat dependent views as non-RCI views, and such operations as building standard or semantic checking will use the attributes of the native Apex compiler.

Remodelling non-RCI views

If remodelling a non-RCI view with an RCI model partially fails during the post-import phase, that is an indication that the RCI compiler key for this model may lack an appropriate set_key script.

Refer to the sample customizations for an example.

Mutual imports

The RCI itself does not have any restrictions or specific handling for mutual imports: RCI host views may belong to a mutual import set; this will result in similar mutual imports being established between the target libraries for these views.

This may not work if the target compilation system does not support such mutual imports. Then, the customization should be adapted to handle this case (for example, by imposing a single common target library for a mutual import set).

Target Compilation

Killing an Apex RCI compilation operation may not kill the spawned target compilation, which is generally running on a different machine.

Attributes

• Static attributes cannot be defined in RCI. (Defect 1341)
• Types returned by attributes must be declared inside of package System. The RCI customization thus requires a new package system to be declared. (Defect 0627)

RCI Batch Mode

When one or both of the operational characteristics REQUIRE_BODY_AND_GENERIC_IN_SAME_COMPILATION or REQUIRES_SUBUNITS_AND_GENERIC_IN_SAME_COMPILATION are set to true, compilation ordering generated in RCI batch mode may be incorrect.

Profiling

Solaris Only: The platform C compiler must be installed to use the Apex profiling capability.

---

Defects/Change Requests

The defects described in this section have been resolved in Apex 4.0.0.

Table 2 Ada Compiler Defects Fixed

Defect #	Description
72	Semantic completion for pragmas has been implemented. When you complete a pragma of a specific name, Apex now fills in the valid arguments for that pragma.
235	The Complete function is now able to complete a declaration that includes a function spec.
1201	If you attempt to visit an implicitly declared "+" operator, the error message displayed was confusing. In Apex 4.0, visiting an implicitly-declared operator brings you to the declaration of the corresponding type.
1314	An assertion RANGE error is no longer raised after doing searches in the Message Window and pressing the Done button. The search marks are now cleared so Done does not try to change highlights on a non-existent position.
2112	IDENTIFIER_CASE="Unchanged" now preserves the case with the Compile > Complete command.
2211	Build Body now works creates bodies whenever required.
2643	The function File_Names.Find_File in the vads_compatibility.ss subsystem is implemented using readdir() in previous releases. Since readdir() is not reentrant, this makes Find_File unsafe for use with threaded runtimes. This has been corrected by substituting the POSIX readdir_r(), a reentrant substitute for readdir(), in Find_File.
2939	The Compile > Semanticize command was reporting no semantics errors even when syntax errors existed. Now, if a unit has a syntax error, Apex does not even try to semanticize it.
3505	The build_bodies command now works correctly with child package
3545	The build_bodies command now works correctly with child package
3791	The Annex H restrictions No_Fixed_Point and No_Floating_Point are now enforced.
3797	The build_bodies command now works correctly with child package
4013	Any name produced by Completion is now qualified, as needed.
4294	The user-specified size for a top-level object must now be a multiple of 8 bits. The following is rejected: This_Is_Going_To_Fail: Boolean; for This_Is_Going_To_Fail'SIze use 1; The following compiles successfully: Type Fixed_Type is delta 1.0 range 0.0 .. 1.; For Fixed_Type'Size use 32;
4546	Inherited component names are now being made directly visible when semanticizing a type extensions.
4683	Signal_Handler is now supported in all runtime archives. In Apex 3.2.0b, the Signal_Handler pragma, an Apex extension, did not work in applications linked against the non-tasking runtime archive libada.ts0 since that runtime archive did not implement the appropriate Ada tasking layer support.
5097	The compiler no longer raises Constraint_Error when performing incremental compilation of statements or declarations within the body of a child library subprogram.
5141	A meaningful error message is now generated when semantic errors are detected.
5151	The following package body no longer generates erroneous semantic errors: Called_Address : Bcd_Encoded_X25_Address_Type; for Called_Address use at Data.Ip_Address_Acquisition_Reposnse.user_Field Called_Address_Position)'Address;
5214	The Ada 95 runtime no longer generates a Constraint_Error when using "ada.float_text_io.get" to get the value of a numeric_literal. In Ada 83, the relaxed formats are illegal, so raising the error is correct. However, the situation in Ada 95 is different.
5225	Completion of function calls now works correctly.
5350	Apex now properly regenerates object code for some derived types. If the package specification contained a derived type, the definition of the type is updated in the spec and the program is relinked, Apex was not recoding the appropriate object files. This resulted in the platform linker issuing error messages about missing symbols.
5374	The Ada 95 compiler no longer raises Ada.Io_Exceptions.Data_Error when integer literals are used as the input format for real types.
5549	Get Immediate no longer requires carriage return before values are read.
5585	Problems with tagged private types causing an Assertion_Error have been fixed.
5655	Problem with the STACK_OBJECT_SIZE_LIMIT switch has been fixed. This switch was causing errors with the redefinition of constant objects. When a variable object is declared of a record type, with initialization, pas as an in param, then as an out param, the compiler would complain of a "multiple redefinition of constant object". When examined with the debugger, the contents of this object was garbage.
5668	Rational Apex Ada no longer raises a constraint error while coding 'Image of generic.
5683	The SIGCHLD signal is no loner ignored by the threaded Ada runtimes. This has been fixed by attaching a dummy signal handler to SIGCHLD. This allows SIGCHLD to be caught by handlers attached using V_Interrupts.Attach_Isr, the Attach_Handler pragma, and Ada.Interrupts.Attach_Handler.
5690	The compiler used to fail with an Assertion_Error when instantiating a generic with an actual parameter that didn't fulfill the promises of the actual parameter. This would happen if the generic had a formal derived type with ancestor T, the actual type was derived from T, and some of the primitive operations of T were declared after the actual type but before the generic. The instantiation is now correctly rejected.
5725	Problems with the Semanticize function which resulted in errors on every other run have been fixed.
5727	The View > Goto command now works correctly if the target line is a blank line. Blank lines cannot be targeted by a Goto command. Goto'ing to a blank line now undoes the last selection but does not make a new selection.
5783	Code Rule Checker no longer fails partway through files.
5804	Spelling Error (compatibility) corrected in multiple Info messages
5858	The floating point constraint error caused by binding the result during the prologue has been fixed. The new gasket for the 4.0 release binds only the in and in-out mode parameters in the prologue and binds only the out and in-out mode parameters in the epilogue. In previous releases, the compiler bound parameters of all modes in both the prologue and the epilogue.
5925	The ADA_CONCURRENCY_LEVEL switch is now recognized.
5940	The problem with units listed as Unparsed when their true compilation status is Coded has been fixed.
6039	The standard Ada models now import the appropriate view from posix.ss. Now only the portable views do not import the posix views.
6082	The Apex compiler now flags type mismatch with access types and discriminant records
6138	ASIS can now handle named associations for tagged types
6172	Apex Ada Editor now performs the completion operation on inherited methods.
6185	Direct IO no longer returns an erroneous END_OF_FILE=true after the file is reset.
6255	The configuration of the Ada Real_Time.Time type, including the value of Ada Real_Time.Time_Unit, Ada.Real_Time.Tick, their relationship to the underlying hardware time base, and the granularity of delay clauses, has been streamlined for this release. Details are provided in Using the Ada Runtime. Note that Time is not configurable for native versions of Apex or for Apex Embedded for LynxOS.
6292	The Apex compiler error messages dealing with ambiguous calls have been improved to indicate possible locations of the call. This should help in situations where there are many overloaded names.
6294	For a file opened in Out_Mode, the function Ada.Streams.Stream_IO.Size used to return the number of bytes written to the _external_file_. Because buffering may take place, this number may be smaller than the number of bytes written to the _file_object_. This function has been fixed so that it now returns the number of bytes written to the file object.
6307	The vads_compatibility_static.ss view is missing the libvads_compatibility.a.lcs file.
6382	The compiler used to fail with a Constraint_Error when processing a use_clause for the base subtype of a (scalar) type. Such use_clauses are now accepted.
6440	'Value now correctly raises constraint_error instead of exiting with the following message "Error in Ada RTS::protected entry queue not empty"
6458	Use cases in context clauses are now being handled correctly. Previously, the package body was unaffected by the removal of use clauses in the specification.
6473	Confusion as to how to determine if a system is big endian or little endian has been resolved. In this release of Apex, package System is automatically generated.
6516	A legal requeue statement in the body of a protected type in a generic package no longer causes a constraint error during the instantiation of the package.
6519	Direct_IO with discriminated record no longer tries to access nonexistent memory. This produced a Device_Error.
6525	A problem with Stream_IO buffering has been fixed. This problem resulted in the last 1024 bytes of a program being missing if the program terminated without closing or flushing.
6531	A problem with pragma Checking has been fixed. Apex was ignoring pragma Initialize which was causing record components to not be initialized.
6546	The compiler no longer fails with an Unexpected_Diana error when instantiating a generic which has a formal subprogram with an access parameter.
6557	Ada.Streams.Stream_Io.Form now returns a full specification including default options.
6564	The compiler no longer fails with an Assertion_Error when coding an instantiation in some complicated cases involving formal derived types, overriding of primitive operations inherited from the ancestor types, and private types.
6577	In previous versions of Apex, the Allocate operations of storage pools were called with an alignment of twice the size of an address type. On 32-bit machines, this was 128 bits. The actual requirement is alignment to the size of the maximum scaler type, usually that of Long_Float, which is 64 bits on all platforms supported by Apex. Apex has been modified to call Allocate operations with this less stringent 64 bit alignment
6592	The Ada.Streams.Stream_Io buffering algorithm has been improved to improve performance for reads and writes above approximately 100 bytes. Reads and writes of records larger than the buffer size now call read(2) and write(2) directly, bypassing the buffer.
6605	Erroneous conversions from a text to float have been corrected. This occurred when the float_io get was from a string and resulted in a Storage_Error.
6606	A programmer-specified confirming size clause now has no effect. In previous releases, the argument of a 4 or 2 bit modular type `Image function got sign extended (from 8 to 32 bits) when the `Size of its type was specified by the programmer. This did not occur when the `Size was compiler-specified.
6634	The erroneous warning issued by the compiler when or'ing a new boolean that has a rep spec no longer occurs.
6681	The compiler no longer fails with an Assertion_Error when instantiating a generic which has a formal derived type whose ancestor is limited, with an actual type which is itself limited and has no inherited operations whatsoever.
6691	The correct Ada LRM is now pointed to when performing an Explain command on Ada code in an Ada 95 view. Previously, the Ada 83 LRM was referenced in the error message instead of the Ada 95 LRM.
6724	The emulation of POSIX_THREAD_PRIO_PROTECT is now done correctly.
6728	The problem with generics when matching the primitive operation of a formal derived type when that type's parent is a generic formal package have been fixed.
6729	WITH Private_Main; is no longer WITHable as per RM 10.1.2(8).
6738	The erroneous End_Error exception raised by Ada.Streams.StreamIio.Read call no longer occurs. The LRM identifies that Last has a value less than Buffer_Size only when the end-of-file is encountered. This implies that normal execution should continue, rather than an exception being raised.
6745	Apex releases prior to 4.0.0 did not support Ada.Synchronous_Task_Control in libada.ts0, the runtime archive linked with non-tasking programs. Ada.Synchronous_Task_Control is useful even in the absence of tasks other than the environment task, since the environment task can suspend using Suspend_Until_True and be awakened by a protected interrupt handler calling Set_True. This is now supported in the Apex 4.0.0 version of libada.ts0.
6759	Dependant files are now correctly being recompiled when adding/subtracting the word "aliased" to them.
6766	Non conformance to ARM 7.3(12..13) has been corrected. The compiler no longer claims that this sections states that partial view and full view of private extensions should have the same discriminants.
6772	In some cases, Ada.Streams.Stream_IO.Set_Mode used to keep a pointer to a deallocated piece of memory. This problem has been known to cause the exception Registration_Error to be raised, although it could also have other failure modes.
6778	Problems with the Build Body command have been fixed. Adding a new item to a package specification, reanalyzing, and then reapplying the Compile > Build Body command now correctly expands the package body with the newly added item.
6800	In Apex 3.2.0b for AIX, defining a Storage_Management_Callout routine would cause the runtime to fail during initialization. This has been corrected. See Memory Management in Using the Ada Runtime, for more information on Storage_Management_Callout_Routines.
6821	The correct Ada LRM is now pointed to when performing an Explain command on Ada code in an Ada 95 view. Previously, the Ada 83 LRM was referenced in the error message instead of the Ada 95 LRM.
6833	The compiler no longer fails with an Assertion_Error when instantiating a generic with an actual expression of the form A'First(N), A'Last(N) or A'Length(N).
6838	Visibility problems in public/private tagged types have been fixed.
6870	Inheritance with discriminants in Ada 95 is now correctly done. Previously, Apex would fail private extensions and incorrectly pass full type definitions.
6890	Ada Start Runtimes no longer incorrectly fails. This would happen every-other time a command server did a start() and then a finalize() outside a child process. The unused routines were doing the finalize in the server, so the next command that does a start would fail. Note that this command will always work from the command line.
6898	The `Caller attribute no longer fails in lower (ts1, ts2) runtimes. Note that the runtime archive supporting all Ada 95 tasking features, libada.ts3 was not affected by this problem.
6942	Conversion from fixed to long_float is now done correctly for composite types with representation specifications
6920	Inheritance with discriminants in Ada 95 is now correctly done. Previously, Apex would fail private extensions and incorrectly pass full type definitions.
6988	The code generator now emits a conditional call for dynamic stack allocation checks, instead of a conditional trap as used in prologue code. This permits the runtimes to differentiate between the two cases (stack overflow in the prologue or in the body) and perform proper stack checking.
7030	Child bodies can now see parent private types.
7032	The compiler now correctly catches the error where the data denotes no defined value or object.
7100	In some cases the Ada compiler cannot determine whether an application will define tasks at code generation time. In such cases code is generated to perform necessary task activation should it be necessary. The non-tasking runtime archive provides dummy implementations of task activation operations so that these calls will succeed in the absence of task support code should the application ultimately be found free of tasks. One of these operations, Ts_Activation_Exceptions, must return a flag indicating whether there were problems activating tasks. The non-tasking version of this operation is defined as a procedure and so does not return this flag. This can cause the compiler generated application code to raise Tasking_Error or Program_Error unpredictably. The non-tasking implementation of Ts_Activation_Exceptions has been modified to return Ts.Act_Ok unconditionally, indicating that there were no activation problems (since there are no tasks to be activated).
7175	Performance of operations in package Calendar have been improved.
7180	A check error resulting from unmatched representation type has been fixed.

Table 3 C/C++ Defects Fixed

Defect #	Description
4953	Moving a C/C++ main program did not result in the removal of the original main file. For example, if you moved foo.C to bar.C, then tried to link the view, nothing was linked because bar.C was not registered and foo.C no longer existed. The Move command now works correctly and the registered set of main programs is updated.
6547	Apex is now able to acquire a C++ license if the LC_ALL, LC_NUMERIC, or LANG environment variable is set to a non-English locale.

Table 4 Debugger Defects Fixed

Defect #	Description
5623	Problems with running multiple debugger sessions from a single Apex session have been fixed.
5839	Multiple problems with the debugger have been fixed. The debugger no longer closes after switching between the source and disassembled code a few times. The size of the Source window is now saved. Selecting File > Exit Debugger now works the first time it is invoked. The cursor now changes to a watch when the debugger is executing.
5878	The debugger Task window now displays task details. The new items, Default, Full, and Stack Usage are included in the menus/buttons for this window.
5929	Navigate > Visit in the debugger's source window now takes you to the correct line in the destination file. This command was centering the target line in the middle of the window but positioning the cursor on the first line of source shown in the window.
6941	Apex no longer hangs when the Debug > Kill command is invoked. This would happen when a delay command was included in the program.
6967	The Catch All command now works correctly in the debugger when debugging C programs. Previously it would terminate prematurely.

Table 5 Configuration Management Defects Fixed

Defect #	Description
5421	Users are now able to control whether some command copy artifacts. A -no_artifacts option has been added to the set_version, set_history, abandon, and control commands. Artifact copies are now done in one place, the relationship between the artifacts is considered and old artifacts are eliminated.
5543	The copy_view command now correctly preserves permissions on uncontrolled files that are not in Apex-managed directories. Note that the maintain command will still modify permissions based on the access category of the view.
5814	It is now possible to freeze views which import one or more of the lrm or predefined views. Previously, the process would fail during the attempt to update one of the import artifacts in the frozen supplier views.
6264	Multiple users trying to control a Rational subsystem (rss) at the same time now have a better interface. Note that it is still not possible for two users to control rss's inside the same directory simultaneously.
6449	The directory window is now automatically refreshed if the File > New >New Subsystem command is used to create a new Apex/ClearCase subsystem.
7158	The problem of making a list into ClearCase elements has been simplified. A dialog provides the means to easily check in/out parent directories of listed objects.
7163	The discard_export_set command now works properly in the Apex/ClearCase integration.

Table 6 User Interface Defects Fixed

Defect #	Description
1517	View: > Filter > Show All no longer fails if an empty view is selected.
5952	When a username is long, it would run together with the group name and cause the uninstall script to abort. This is alleviated by including the "o" option in the uninstall script so that just the owner is listed. The uninstall script now tells the user to use the -force option to uninstall if they think the user check is incorrect.
6224	Apex Link Dialog box icons now correctly respond to the mouse buttons
6274	Compile > Maintenance > Clean dialog box no longer comes up empty the first time, even if files are selected.
6405	The History pop-up now works in the Text Editor
6463	The apexinit -info command no longer includes erroneous patch error information in the middle of the output.
6523	The Compile > Show Usage command now works correctly.
6670	The Compile > Show Unused command no longer returns Program_Error when invoked on Ada.Sequential_Io or Ada.Direct_Io.
6771	No confirmation dialogues displayed when deleting a directory containing a subsystem. This behavior has been included in the Limitations sections of the Notes.
6789	The Usage/Unused features have been enhanced. The various Usage/Unused queries now automatically Analyze the units that they are going to search before they search them. There is a toggle on the dialog box to turn that off for those cases where the overhead is large and the user knows that the Analyze is unnecessary.
6947	The File > New > New History command no longer displays an error message indicating that it failed to exec a child process. This error message was being erroneously displayed.
6973	Control-LeftMouseButton now generates a buffer list.
6998	Problems with drag and drop have been fixed. Previously, if you selected a portion of text by holding down the left mouse button and dragging, the selection would be lost if the drag was paused for more than approximately 0.5 seconds. At other times, the selection would be lost when the left button was released.

Table 7 Documentation Defects Fixed

Defect #	Description
5259	The Apex installation guide has been updated to say Rose is not on the Apex layered products CD.
5699	The Release Note no longer incorrectly states that the Rose/Apex integration is not part of the product.
5931	The compilation states documentation has been updated to include the a description of the Unparsed state.
5996	The Apex Installation Guide has been updated with the correct versions of AIX supported.
6050	Additional information has been added to Installing Apex which more clearly informs the user that they must run the apex_upgrade command if they are upgrading Apex to a new release.
6087	The documentation for Help > Master_Index > Print formats has been updated with the correct Format options.
6122	The documentation of pragma Convention C has been improved. New material has been added to the Ada Compiler Reference and Using the Ada Runtime.
6123	Documentation of the -nosienna option has been improved.
6128	Documentation has been added describing how to customize the debugger I/O window.
6271	The Migrating from VADS to Apex manual was updated to remove references to rts_configuration.ss and rts_interface.ss, which no longer are present in the Apex product.
6395	Erroneous technical support information concerning fax on demand, email, and address changes has been fixed.
6460	Documentation on how to get colors in emacs has been added to Programming in Apex.
6466	The Rose Developer Tutorial is no longer missing from the "List of all docs" page
6483	Unclear documentation describing the Update Objects dialog box has been fixed.
6559	CPP_COMPILE_TEMPLATE_INSTANTIATIONS and CPP_LIBRARY_INCLUDE_TEMPLATE_INSTANTIATIONS have both been added to the Compilation Switches section in the online reference and indexed.
6572	The documentation for Printing an Object in Using and Customizing the Apex GUI has been corrected. The list of formats has been updated.
6603	The Migrating from VADS to Apex manual was updated to remove references to rts_configuration.ss and rts_interface.ss, which no longer are present in the Apex product.
6706	Documentation on how to generate a link map on Apex has been added to the command reference. The option -keep_load_map always is now included in the apex link documentation.
6717	The documentation has been updated to explicitly state that you cannot import Ada views into C++ views.

Table 8 RCI Defects Fixed

Defect #	Description
613	Problems in the VADS_SELF customization post_delete_unit have been fixed. It assumed a flat directory structure
614	The VADS_SELF customization post_import.do_imports now correctly uses imports_status
1333	Link options in RCI are now picked up in batch mode. Previously, options specified in compile_options_file and link_options_file were included in interactive compilation but not in batch compilation
1340	Long_Long_Integer'Size is now static.
1407	Long_Long_Integer'Size is now static.
1787	It is now possible to make VADS -A options work with Apex RCI. The solution to this problem (handling options which must not be blank-separated from their argument(s) in generated command line is to set OPTION_ARGUMENT_SEPARATOR to ""(nullstring), rather than " " for the customization.
4954	Ada 83 pragmas supported by an Ada 95 customization are now correctly accepted.
5532	Rep specs for System. Address components now work correctly. Target-dependent checks for rep specs are no longer performed in an RCI view and the switches IGNORE_* are used when emitting messages.
5604	RCI > Create Target Library now operates correctly on a tower of views, and has a behavior similar to File > Copy (View).
5909	Help on Create Target Library dialog has been corrected. Additional buttons have been documented and screen shots retaken.
5917	The File > New View and File > Copy (View) dialogs have been fixed so that the behavior is consistent with that of the RCI > Create Target Library dialog, when the "Target library name is automatically generated" option is chosen for a RCI view: The name of the target library will be same as the name of the view, with extension (.wrk or .rel) replaced by .rciwrk or .rcirel, depending on whether the view is a Working or Release view. This will occur whether the view extension is explicitly provided by the user in the dialog or not.
5971	The use of brackets in [] no longer causes problem in RCI > Create Target Library.
6433	The sample GNAT customization now has views in the Apex 'Ada95 annexes' subsystems: distributed_systems.ss, information_systems.ss, numerics.ss, realtime_systems.ss and systems.programming.ss - and the relevant GNAT units are in the subsystems where the Apex compiler 'expects' to find them.
6737	The erroneous message for RCI > Delete Target Library is no longer emitted.

---

Contacting Rational Technical Support

If you have questions about installing, using, or maintaining this product, contact Rational Technical Support as follows:

Your Location	Telephone	Facsimile	E-mail
North America	(800) 433-5444 (toll free) (408) 863-4000 Cupertino, CA	(781) 676-2460 Lexington, MA	support@rational.com
Europe, Middle East, Africa	+31 (0) 20-4546-200 Netherlands	+31 (0) 20-4545-201 Netherlands	support@europe.rational.com
Asia Pacific	+61-2-9419-0111 Australia	+61-2-9419-0123 Australia	support@apac.rational.com

For up-to-date contact numbers and addresses visit the support contacts web page at www.rational.com/support/contact.

Note: When you contact Rational Technical Support, please be prepared to supply the following information:

• Your name, telephone number, and company name
• Your computer's make and model
• Your operating system and version number
• Product release number and serial number
• Your case ID number (if you are following up on a previously-reported problem)