HP OpenVMS Systems

One of the key features of Ada is its strong type definition. Given that a type is a collection of objects (values) together with the operations used to manipulate them, for each Ada object, the DEC Ada compiler determines the following:

• How much storage is required
• Where and when that storage is allocated and deallocated
• How the different values of the object are represented

In general, the compiler chooses storage sizes and representations that make the best compromise between CPU time, the amount of memory required for the generated code, and the amount of memory required for the objects.

Types can be predefined (language-defined), implementation-defined, or user-defined.

DEC Ada provides the following types:

• Scalar types (integer, real, and types defined by the enumeration of their values)
• Composite types (array and record)
• Access types
• Private types
• Task types

DEC Ada provides the predefined integer types shown in Table 2-1.

Additional integer types are declared in the package SYSTEM for convenience in working with hardware-oriented storage.

On OpenVMS Alpha systems, the value of LONG_INTEGER is 64 bits. User-defined integer types can be 64 bits, provided that their range is large enough. On OpenVMS VAX systems, the maximum integer size is 32 bits. These sizes are defined in the package STANDARD.

OpenVMS VAX, OpenVMS Alpha, and DIGITAL UNIX systems define the following types:

• INTEGER_8
• INTEGER_16
• INTEGER_32

OpenVMS Alpha and DIGITAL UNIX systems also define the type INTEGER_64.

Values for objects of all four integer types are represented as signed, two's complement (binary) numbers.

Unsigned representation for integer objects can be achieved by declaring an integer type with a length representation clause. However, because of the way the Ada language defined integer operations, operations on these unsigned objects involve signed intermediate values.

Data representation depends on the properties of the underlying hardware and/or operating system. DEC Ada represents integer and enumeration types as follows:

• On OpenVMS VAX and on ULTRIX systems, signed and unsigned 8-bit (byte), 16-bit (word), and 32-bit (longword) quantities are used.
• On OpenVMS Alpha and DIGITAL UNIX systems, signed and unsigned 8-bit (byte), 16-bit (word), 32-bit (longword), and 64-bit (quadword) quantities are used.

These can optionally be packed and bit-aligned within records and arrays.

For a size specification for a discrete type, the given size must not exceed the maximum size (in bits) for the given type. On OpenVMS VAX systems, the maximum size is 32 bits. On OpenVMS Alpha, DIGITAL UNIX, and ULTRIX systems, the maximum size is 64 bits for integer and enumeration types.

2.2 Floating-Point Types

Floating-point types provide approximations to the real numbers (with relative bounds on the errors). For each floating-point type (predefined and nonpredefined), the compiler chooses a hardware floating-point representation depending on:

• Required range and accuracy of the floating-point type
• Value of the pragma FLOAT_REPRESENTATION
• Value of the pragma LONG_FLOAT

On OpenVMS VAX systems, the following floating-point representations are possible:

• F-floating
• D-floating
• G-floating
• H-floating

On OpenVMS Alpha systems, the following floating-point representations are possible:

• F-floating
• D-floating
• G-floating
• IEEE single float
• IEEE double float

On OpenVMS Alpha systems, data is stored as D-floating and is converted to G-floating for operations (such as addition). G-floating instructions involve loss of precision.

On DIGITAL UNIX systems, the following floating-point representations are possible:

• IEEE single float
• IEEE double float

The compiler uses chosen representation and size for all objects of the type, regardless of the objects' subtypes and regardless of whether or not the objects are themselves part of packed array or record objects.

DEC Ada provides the floating-point types declared in the package STANDARD as shown in Table 2-2.

DEC Ada provides additional floating-point types declared in the package SYSTEM as shown in Table 2-3.

DEC Ada supports user-defined floating-point types. The choice of representation for nonpredefined floating-point types that are not explicitly derived depends on the precision (digits) and the range specified. The compiler chooses the first of the types FLOAT, LONG_FLOAT, and LONG_LONG_FLOAT (OpenVMS VAX systems only) that has adequate precision and range and uses it as the parent type from which the new type is derived.

The type SHORT_FLOAT is not supported by the DEC Ada compiler.

2.2.1 Pragma FLOAT_REPRESENTATION

DEC Ada provides the pragma FLOAT_REPRESENTATION, which acts as a program library switch to allow control over the internal representation chosen for the predefined floating-point types declared in the packages STANDARD and SYSTEM. The format of this pragma is as follows:

pragma FLOAT_REPRESENTATION(VAX_FLOAT | IEEE_FLOAT);

This pragma controls the representation of floating-point types as follows:

• If the value VAX_FLOAT is specified, then floating-point types are represented with the VAX hardware types F-floating, D-floating, G-floating, and H-floating. H-floating is available on OpenVMS VAX systems only.
  If the value is VAX_FLOAT, the default representation of the predefined type LONG_FLOAT is G-floating. The representation can be changed with the pragma LONG_FLOAT.
• If the value IEEE_FLOAT is specified, then floating-point types are represented with the IEEE single and double floating-point types.

On OpenVMS VAX systems, VAX_FLOAT is the default and only allowable value for the pragma.

On OpenVMS Alpha systems, the values allowed are VAX_FLOAT and IEEE_FLOAT. The predefined library is compiled with VAX_FLOAT specified for the pragma FLOAT_REPRESENTATION, and VAX_FLOAT is required for interface to system routine calls. System service calls expect VAX floating-point format, not IEEE format. Therefore, it is not advisable to change the format of floating-point numbers passed to system calls. An explicit type conversion may be necessary to use the predefined library.

On DIGITAL UNIX systems, IEEE_FLOAT is the only allowable and default value for the pragma.

Table 2-4 summarizes these choices.

Use of the pragma FLOAT_REPRESENTATION is interpreted as an explicit recompilation of the predefined STANDARD environment. Therefore, if the value of the pragma FLOAT_REPRESENTATION changes, all units that depend on the value must be recompiled.

2.2.2 Pragma LONG_FLOAT (OpenVMS Systems Only)

On OpenVMS systems, DEC Ada provides the pragma LONG_FLOAT to allow control over the internal representation chosen for the predefined type LONG_FLOAT and for floating-point type declarations with digits specified in the range 7 .. 15. The format of this pragma is as follows:

pragma LONG_FLOAT(D_FLOAT | G_FLOAT);

This pragma is allowed only at the start of a compilation before the first compilation unit (if any). For this pragma to have an effect, the pragma FLOAT_REPRESENTATION must also have a value of VAX_FLOAT.

If the value D_FLOAT is specified and the range is adequate, then a D-floating representation is used for the predefined type LONG_FLOAT and for floating-point types declared with digits in the range 7 .. 9.

Similarly, if the value G_FLOAT is specified and the range is adequate, then a G-floating representation is used for the predefined type LONG_FLOAT and for floating-point types declared with digits in the range 7 .. 15.

F-floating and H-floating representations are used for floating-point types with digits in other ranges as follows:

Use of the pragma LONG_FLOAT is interpreted as an implicit recompilation of the predefined STANDARD environment. Therefore, if the value of the pragma LONG_FLOAT changes, all units that depend on the value must be recompiled. Whenever a program library is reinitialized, the G-floating representation is established by default.

When the value of the pragma FLOAT_REPRESENTATION is VAX_FLOAT, the choice of floating-point representation is not affected by the pragma LONG_FLOAT in the cases as shown in the following cases:

The values of the representation attributes for floating-point types are summarized in Table 2-5.

For both floating-point and fixed-point types, T'MACHINE_ROUNDS yields the value TRUE if every predefined arithmetic operation on values of the base type of T either returns an exact result or performs rounding. It yields the value FALSE otherwise. The value of this attribute is of the predefined type BOOLEAN.

On all systems, this value is TRUE for floating-point types.

T'MACHINE_MANTISSA yields the number of digits in the mantissa for the machine representation of the base type of T. The digits are extended digits in the range 0 to T'MACHINE_RADIX - 1. The value of this attribute is of the type universal_integer.

T'MACHINE_EMAX yields the largest value of exponent for the machine representation of the base type of T. The value of this attribute is of the type universal_integer.

T'MACHINE_EMIN yields the smallest (most negative) value of exponent for the machine representation of the base type of T. The value of this attribute is of the type universal_integer.

2.2.4 Model Numbers for Floating-Point Types

Table 2-6 lists the model numbers for each underlying floating-point type (and, therefore, for each DEC Ada floating-point type). The ranges in the table are approximate. Exact ranges can be found by evaluating language-defined attributes T'SMALL and T'LARGE, where T is the floating-point type.

For both predefined and nonpredefined types, the Ada language rules about safe numbers also apply.

For each hardware floating-point type, there are representable numbers that are not safe numbers, and there is a small set of numbers that are outside the range of safe numbers.

The representation of a literal can be different on different platforms. A literal that is not a safe number can be represented by the safe number above or below the universal-real value.

The safe number for a floating-point literal computed at compile time is not guaranteed to be the same as the safe number computed at run time.

Table 2-7 lists the safe numbers for each underlying floating-point type (and, thereby, for each DEC Ada floating-point type). The ranges in the table are approximate. Exact ranges can be found by evaluating language-defined attributes T'SMALL and T'LARGE, where T is the floating-point type.

The results of floating-point computations on OpenVMS Alpha and DIGITAL UNIX systems do not compare exactly to the results on OpenVMS VAX systems. The floating-point representations on these systems are entirely different one from the other.

The binary mantissa for a floating-point number must use enough bits to ensure that the guaranteed number of significant digits can be represented accurately. The extra bits that do not affect the value of the number within the guaranteed accuracy may differ between platforms and between values computed at compile time and those computed at run time.

Because a comparison for equality of two floating-point numbers takes these extra bits into account, such a comparison may fail, depending on the source of the two numbers. For example if a text representation of a floating-point number converted at run time is compared for equality with a text representation converted at compile time, the comparison may fail.

2.3 Fixed-Point Types

Fixed-point types provide approximations to the real numbers with absolute bounds on errors determined by the value of T'SMALL, where T is the fixed-point type. T'SMALL is defined to be less than or equal to the delta specified in the type declaration.

To implement fixed point numbers, DEC Ada uses a set of anonymous predefined fixed point types of the form:

Where S is a value in the range 2.0^-62 .. 2.0³¹, L = 2.0³¹*S, and
U = (2.0³¹ - 1)*S.

Each fixed-point type has a storage size determined by its delta and range, rounded up to an 8-, 16-, or 32-bit boundary. The size may be changed by a representation clause.

For a size specification for a discrete type, the given size must not exceed the maximum size (in bits) for the given type. For fixed-point types, the maximum size is 32 bits. Unless the language specifies otherwise, operations on fixed-point types are handled as follows:

• On OpenVMS VAX systems, rounding is towards zero for negative numbers and away from zero for positive numbers. Therefore, +0.5 rounds to 1 and -0.5 rounds to zero.
• On OpenVMS Alpha and DIGITAL UNIX systems, rounding is away from zero for both positive and negative numbers. Therefore, +0.5 rounds to 1 and -0.5 rounds to -1.

Both model numbers and model intervals are used to define the permissible legal values for the results of operations on real (in this case, fixed-point) types. Any value that falls in the defined model interval for an operation is a legal result value for that operation.

For any fixed-point type where the value of T'SMALL is a power of two, T'MACHINE_ROUNDS yields the value FALSE. The value is TRUE for all other fixed-point types.

Data representation depends on the properties of the underlying hardware and/or operating system. DEC Ada represents fixed-point types as signed 8-bit (byte), 16-bit (word), or 32-bit (longword) quantities with an implicit binary scale factor.