HP OpenVMS Systems

Both VADS and DEC Ada provide packages beyond the minimum required by the Ada language standard.

The following packages are available on VADS:

• BIT_FLG_FIX, HEX, V_BITS (operations on predefined types)
• MATH, GENERIC_ELEMENTARY_FUNCTIONS (math packages)
• ORDERING (sort routines)
• A_STRINGS, VSTRINGS (variable-length strings)
• UNSIGNED_TYPES, COMPLEX_ARITH (unsigned integers, complex numbers)
• CLOSE_ALL, COMMAND_LINE, CURRENT EXCEPTION, LANGUAGE, MEMORY, RAW_DUMP, SHARED_IO
• CURSES, ERRNO, FACNTL, IFACE_INTR, IOCTL, IOCTL_FMT, LIBC, PERROR, STATUS, TTY, TTY_SIZES, UNIX, UNIX_CALLS, UNIX_DIR, UNIX_LIMITS, UNIX_PRCS, U_ENV, U_RAND (UNIX packages)

Package UNSIGNED_TYPES is supplied to illustrate the definition of and services for the unsigned types supplied. It is given with no warranty, expressed or implied, for the effectiveness or legality of the package. UNSIGNED_TYPES is used at the user's own risk.

The following packages are available on DEC Ada:

• ADDRESS_OPERATIONS
• ASSERT, ASSERT_EXCEPTIONS, ASSERT_GENERIC
• C_TYPES
• CURRENT_EXCEPTION
• ELEMENTARY_FUNCTIONS_EXCEPTIONS
• ERRNO
• GET_TASK_INFO
• HEAP_SORT
• MAIN_PROGRAM_ARGUMENT_LIST
• MATH_LIB
• POSIX
• SET_TASK_PRIORITY
• SYNCHRONIZE_NONREENTRANT_ACCESS
• TIME_CONVERSION

The following lists differences regarding packages as implemented on VADS:

• On VADS, the package LANGUAGE has the following constants:
  • C_PREFIX
  • C_SUBP_PREFIX
  • FORTRAN_PREFIX
  • FORTRAN_SUFFIX
  • OBJECT_EXTENSION
  • LIBRARY_EXTENSION
  • EXECUTABLE_EXTENSION

VADS supports packages to interface to every facility in UNIX, sometimes with several different interfaces. DEC Ada has minimal interfaces to the command line and to signals.

VADS provides the packages MACHINE_TYPES and MACHINE_CODE. Also provided are the V_* packages designed for customizing the run-time system and the kernel run-time system.

C.10 Bindings

DEC Ada provides the following strongly typed bindings:

• X Window System Version 11R4, 11R5, and 11R6 (X, XLIB interface)
• X Windows Toolkit (XT interface)
• Motif Version 1.1.3 and 1.2 (XM interface)

On DIGITAL UNIX, DEC Ada also provides support for the POSIX Ada Language Interface bindings as required by IEEE Standard 1003.5-1992 (IEEE Standard for Information Technology, POSIX Ada Language Interfaces.

These bindings are compatible with VADS.

C.10.1 Interfaces to C

Both VADS and DEC Ada recognize the importance of interfacing to C and provide Ada types and operations, as shown in Table C-9.

VADS does not require that a generic declaration and the corresponding body be part of the same compilation, and they are not required to exist in the same VADS library.

The VADS compiler generates code for a generic instantiation that can be shared by other instantiations of the same generic which reduces the size of the generated code and increases compilation speed. There is an overhead associated with the use of shared code instantiations because the generic actual parameters must be accessed indirectly and, in the case of a generic package instantiation, declarations in the package are also accessed indirectly. Greater optimization is possible for unshared instantiations because exact actual parameters are known. It is the responsibility of the programmer to decide whether space or time is the most critical in a specific application.

The compiler and other large dynamic compiled programs occasionally give problems due to the shell's stack limit. Altering the stack size and recompiling or re-executing is sometime necessary. A process inherits its stack limit from the invoking process (usually the shell).

The C shell allows the default stack size to be reset usually up to the limit of the process size. Most Bourne shell implementations do not permit the stack size to be altered.

On VADS, the following restrictions are in effect:

• An error occurs if one compilation has two versions of the same unit.
• Strings by default have 2 bytes per character. If the pragma PACK applies, then 1 byte per character is the default.

Other differences between VADS and DEC Ada are as follows:

• VADS allows the following type declaration. Whereas, on DEC Ada, it is diagnosed as an error.

  type T16 is new SHORT_INTEGER range -32768 .. 32767

  
  In this declaration, DEC Ada interprets the numeric literals in the range of the declaration as having constraints that are of type SHORT_INTEGER. Therefore, it considers positive value 32768 to be of type SHORT_INTEGER. The intention is to apply a hyphen (-) to it, but instead the compiler generates a constraint error. VADS as allowed by LRM 11.6(6), uses a larger type as the base type for the operation.
  On DEC Ada, the user can use attributes (such as SHORT_INTEGER'FIRST), create a nonderived type, or use an integer conversion. For example:

  type T16 is new SHORT_INTEGER range SHORT_INTEGER'FIRST .. SHORT_INTEGER'LAST

• DEC Ada has restrictions on 'SIZE, 'STORAGE_SIZE, 'SMALL.
• On DEC Ada, unchecked conversion does not work between machine addresses and access types that point to unconstrained arrays.
• Record types having discriminants with default expressions are implemented on DEC Ada as described in the following:
  On DEC Ada, the storage size for an unconstrained record object is large enough for any value that could be assigned to that object. This size is calculated using the lower and upper bounds of the subtypes of the discriminants. Assignment simply moves the value into the variable's storage.
  This approach can cause unnecessarily large amounts of storage to be used or even for STORAGE_ERROR to be raised. This might occur if the subtype of a discriminant is INTEGER and the discriminant is used within the record as a bound of an array. This would make the largest possible value very large.
  The workaround is to define a new subtype of INTEGER that has bounds that are smaller but large enough to hold the actual sizes encountered in your program.
• Use of the VADS pragma EXTERNAL (C, subprogram_name) can be converted to DEC Ada by using a pragma EXPORT_FUNCTION or EXPORT_PROCEDURE and specifying mechanisms for parameters and results.
• In DEC Ada, the subprogram 'ADDRESS is supported only for imported or exported subprograms. There are restrictions on the placement of exported subprograms. See the DEC Ada Language Reference Manual for more information.
• On VADS, the type DURATION supports longer periods.
• Alignment restrictions for records are as follows:
  • On VADS, power of 2 up to 2⁴
  • On DEC Ada, power of 2 up to 2³
• Address clauses are supported for objects and entries on both implementations; unnamed imported subprograms are supported on DEC Ada only.

The following lists differences in the definition of a main program on VADS and DEC Ada:

• On VADS, main programs are defined as follows:
  • Must be a non-generic, parameter-less subprogram that is either a procedure or function returning an Ada STANDARD.INTEGER (the predefined type)
  • Cannot be a generic subprogram or an instantiation of a generic subprogram
• On DEC Ada (DIGITAL UNIX), main programs are defined to meet the following conditions:
  • Procedure with no formal parameters (returns 0 upon normal completion)
  • Procedure with no formal parameters (returns 42 when unhandled exceptions are raised)
  • Function with no formal parameters whose returned value is of a discrete type
  • Procedure with one OUT formal of a discrete type for which a pragma EXPORT_VALUED_PROCEDURE is specified
  
  When a main function or main procedure declared with the pragma EXPORT_VALUED_PROCEDURE returns a discrete value whose size is less than 64 bits (on Alpha systems), the value is zero- or sign-extended as appropriate.

VADS provides the implementation-defined attributes shown and briefly described in Table C-10.

DEC Ada provides the implementation-defined attributes shown and briefly described in Table C-11.

To pass options to the linker, VADS provides the pragma LINK_WITH. DEC Ada provides the following ways to pass options to the linker:

• Enter the ald -l command specifying the options to be passed to the linker.
• Define the environment variable LDFLAGS to provide the equivalent features.
• Enter the aimport -a ldargs command to associate linker arguments with a library package or subprogram body that can later be linked.

DEC Ada supplies the following pragmas to control optimization:

• OPTIMIZE
• INLINE
• INLINE_GENERIC
• SUPPRESS_ALL
• PASSIVE
• Several command options

VADS supplies the following pragmas to control optimization:

• INLINE_ONLY
• NO_IMAGE
• NON_REENTRANT
• OPTIMIZE_CODE
• PASSIVE
• SHARE_CODE

Optimization on both implementations can be controlled at the command-line level.

C.13 User Interface

VADS and DEC Ada provide a comparable set of commands to build programs and manage the program library. Table C-12 lists the VADS and DEC Ada commands and points out any differences as appropriate.

VADS implementations supply optional products ( a.cvt and a.prof ), which are not listed in Table C-12.

Table C-13 briefly describes some of the features of the user interface.

The VADS Ada I/O system is implemented using DIGITAL UNIX I/O. Both formatted and binary I/O are available. There are no restrictions on the types with which DIRECT_IO and SEQUENTIAL_IO can be instantiated except that the element size must be less than a maximum given by the variable SYSTEM.MAX_REC_SIZE. This variable can be set to any value prior to the generic instantiation. Therefore, you can use any element size.

DIRECT_IO can be instantiated with unconstrained types, but each element is padded out to the maximum possible for that type or to SYSTEM.MAX_REC_SIZE, whichever is smaller. No checking (other than normal static Ada type checking) is done to ensure that values from files are into correctly sized and typed objects.

VADS file and terminal input-output are identical in most respects and differ only in the frequency of buffer flushing. Output is buffered (buffer size is 1024 bytes). The buffer is always flushed after each write request if the destination is a terminal. The procedure FILE_SUPPORT.ALWAYS_FLUSH (file_ptr) causes flushing of the buffer associated with file_ptr after all subsequent output requests.

Instantiations of DIRECT_IO use the value MAX_REC_SIZE as the record size (expressed in STORAGE_UNITs) when the size of ELEMENT_TYPE exceeds that value. MAX_REC_SIZE is defined in package SYSTEM and can be changed before instantiating DIRECT_IO to provide an upper limit on the record size. The maximum record size supported is 1024*1024*STORAGE_UNIT bits.

Instantiations of SEQUENTIAL_IO use the value MAX_REC_SIZE as the record size (expressed in STORAGE_UNITs) when the size of ELEMENT_TYPE exceeds that value. MAX_REC_SIZE is defined in package SYSTEM and can be changed by a program before instantiating SEQUENTIAL_IO to provide an upper limit on the record size. SEQUENTIAL_IO imposes no limit on MAX_REC_SIZE.

On DIGITAL UNIX systems, DEC Ada predefined input-output packages and their operations are implemented using systems calls, which provide read sharing for the sequential and direct packages. DEC Ada provides no additional input-output packages specifically related to DIGITAL UNIX systems.

DEC Ada predefines the following input-output packages on DIGITAL UNIX:

• DIRECT_IO
• DIRECT_MIXED_IO
• SEQUENTIAL_IO
• TEXT_IO
• IO_EXCEPTIONS

The packages DIRECT_IO, SEQUENTIAL_IO, AND TEXT_IO are predefined by the Ada language. The remaining packages are predefined by the Ada implementation.

To make the use of the generic TEXT_IO operations more convenient, DEC Ada provides predefined library packages that instantiate the integer and floating-point operations for the predefined integer and floating-point types as shown in Table C-14.

The DEC Ada predefined packages and their operations are implemented using DIGITAL UNIX files and input-output facilities. DEC Ada supports asynchronous input-output on DIGITAL UNIX. Familiarity with the following is recommended:

• DIGITAL UNIX files
• DIGITAL UNIX input-output facilities

On DIGITAL UNIX, the value of the FORM parameter conforms to the description of the FORM parameter in IEEE Standard 1003.5-1992, IEEE Standard for Information Technology, POSIX Ada Language Interfaces.

VADS also provides shareable generic instantiations of TEXT_IO packages for common data types in standard/shared_io.a . This package improves disk usage by ensuring that only one instantiation of the I/O packages exists for each VADS installation.

Shared generics cause a slight execution-time penalty because all type attributes must be referenced indirectly (as if an extra calling argument were added). However, it reduces compilation time substantially in most circumstances and it reduces program size.

C.15 Implementation Limits

The following table lists implementation limits for DEC Ada on DIGITAL UNIX systems.