This version of the reference manual corresponds to version 3.07 of GNAT.
(C) Copyright 1995-1996, Ada Core Technologies - All Rights Reserved
GNAT is free software; you can redistribute it and/or modify it under terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNAT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANT ABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNAT; see file COPYING. If not, write to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
This manual contains useful information in writing programs using the GNAT compiler. It includes information on implementation dependent characteristics of GNAT, including all the information required by Annex M of the standard.
Ada 95 is designed to be highly portable,and guarantees that, for most programs, Ada 95 compilers behave in exactly the same manner on different machines. However, since Ada 95 is designed to be used in a wide variety of applications, it also contains a number of system dependent features to be used in interfacing to the external world.
Note: Any program that makes use of implementation-dependent features may be non-portable. You should follow good programming practice and isolate and clearly document any sections of your program that make use of these features in a non-portable manner.
This reference manual contains the following chapters:
This reference manual assumes that you are familiar with Ada 95 language, as described in the International Standard ANSI/ISO/IEC-8652:1995, Jan 1995.
See the following documents for further information on GNAT .
Ada 95 defines a set of pragmas that can be used to supply additional information to the compiler. These language defined pragmas are implemented in GNAT and work as described in the Ada 95 Reference Manual.
In addition, Ada 95 allows implementations to define additional pragmas whose meaning is defined by the implementation. GNAT provides a number of these implementation-dependent pragmas which can be used to extend and enhance the functionality of the compiler. This section of the GNAT Reference Manual describes these additional pragmas.
Note that any program using these pragmas may not be portable to other compilers (although GNAT implements this set of pragmas on all platforms). Therefore if portability to other compilers is an important consideration, the use of these pragmas should be minimized.
pragma Abort_Defer
begin). It has
the effect of deferring aborts for the sequence of statements (but not
for the declarations or handlers, if any, associated with this statement
sequence).
pragma Ada_83
pragma Ada_95
Ada and System
packages and their children, so you need not specify it in these
contexts. This pragma is useful when writing a reusable component that
itself uses Ada 95 features, but which is intended to be usable from
either Ada 83 or Ada 95 programs.
pragma Annotate (identifier {, arg})
Standard.String. Names of entities are simply analyzed as entity
names. All other expressions are analyzed as expressions, and must be
unambiguous.
The analyzed pragma is retained in the tree, but not otherwise processed
by any part of the GNAT compiler. This pragma is intended for use by
external tools.
pragma Assert (boolean_expression, [ , static_string_expression])
if not Boolean_EXPRESSION then System.Assertions.Raise_Assert_Failure (string_EXPRESSION); end if;The effect of the call is to raise
System.Assertions.Assert_Failure. The string argument, if given,
is the message associated with the exception occurrence. If no second
argument is given, the default message is `file:nnn',
where file is the name of the source file containing the assert,
and nnn is the line number of the assert. A pragma is not a
statement, so if a statement sequence contains nothing but a pragma
assert, then a null statement is required in addition, as in:
... if J > 3 then pragma (Assert (K > 3, "Bad value for K")); null; end if;If the boolean expression has side effects, these side effects will turn on and off with the setting of the assertions mode, resulting in assertions that have an effect on the program. You should generally avoid side effects in the expression of this pragma.
pragma C_Pass_By_Copy ([Max_Size =>] static_integer_expression)
C_Pass_By_Copy to change
this default, by requiring that record formal parameters be passed by
copy if all of the following conditions are met:
Convention C.
C_Pass_By_Copy for the record type, or by using the extended
Import and Export pragmas, which allow specification of
passing mechanisms on a parameter by parameter basis.
pragma Common_Object ...
pragma Common_Object
[Internal =>] local_name,
[, [External =>] external_symbol]
[, [Size =>] size]
This pragma enables the shared use of variables stored in overlaid
linker areas corresponding to the use of COMMON in Fortran. The single
object local_name is assigned to the area designated by
external_symbol. You may define a record to correspond to a series
of fields. size is syntax checked in GNAT, but otherwise ignored.
pragma Component_Alignment ([Form =>] alignment [, [Name =>] type_local_name]);
Component_Size
Component_Size_4
Storage_Unit
System.Storage_Unit.
Default
Default choice is the same as
the Storage_Unit choice (byte alignment). For all other systems,
the Default choice is the same as Component_Size (natural
alignment).
Name parameter is present, type_local_name must
refer to a local record or array type, and the specified alignment
choice applies to the specified type. The use of
Component_Alignment together with a pragma Pack causes the
Component_Alignment pragma to be ignored. The use of
Component_Alignment together with a record representation clause
is only effective for fields not specified by the representation clause.
If the Name parameter is absent, the pragma can be used as either
a configuration pragma, in which case it applies to one or more units in
accordance with the normal rules for configuration pragmas, or it can be
used within a declarative part, in which case it applies to types that
are declared within this declarative part, or within any nested scope
within this declarative part. In either case it specifies the alignment
to be applied to any record or array type which has otherwise standard
representation.
If the alignment for a record or array type is not specified (using
pragma Pack, pragma Component_Alignment, or a record rep
clause), the GNAT uses the default alignment as described previously.
pragma CPP_Class ([Entity =>] local_name)
Interfaces.CPP.Vtable_Ptr, corresponding
to the C++ Vtable (or Vtables in the case of multiple inheritance) used
for dispatching.
Types for which CPP_Class is specified do not have assignment or
equality operators defined (such operations can be imported or declared
as subprograms as required). Initialization is allowed only by
constructor functions (see pragma CPP_Constructor).
Pragma CPP_Class is usually generated automatically using the C++
binding generator tool; See section Interfacing to C++ for more details.
pragma CPP_Constructor ([Entity =>] local_name)
function Fname return T'Class
function Fname (...) return T'Class
CPP_Class applies.
The first form is the default constructor, used when an object of type
T is created on the Ada side with no explicit constructor. Other
constructors (including the copy constructor, which is simply a special
case of the second form in which the one and only argument is of type
T), can only appear in two contexts:
New_Object : Derived_T
New_Object : Derived_T := (constructor-function-call with ...)
CPP_Constructor is usually constructed automatically using
the C++ binding generator tool; See section Interfacing to C++ for more details.
pragma CPP_Destructor ([Entity =>] local_name)
Import with Convention CPP, and be of the following form:
procedure Fname (obj : in out T'Class);where T is a tagged type to which pragma
CPP_Class
applies. This procedure will be called automatically on scope exit if
any objects of T are created on the Ada side.
Pragma CPP_Destructor is usually constructed automatically using
the C++ binding generator tool; See section Interfacing to C++ for more details.
pragma CPP_Virtual ...
pragma CPP_Virtual
[Entity =>] entity
[ [Vtable_Ptr =>] vtable,
[Position =>] pos])
This pragma serves the same function as pragma Import in that
case of a virtual function imported from C++. entity must be a a
primitive subprogram of a tagged type to which pragma CPP_Class
applies. vtable is the Vtable_Ptr component which contains the
entry for this virtual function. pos is the sequential number
counting virtual functions for this Vtable starting at 1.
The Vtable_Ptr and Position arguments may be omitted if
there is one Vtable_Ptr present (single inheritance case) and all
virtual functions are imported. In that case the compiler can deduce both
these values.
No External_Name or Link_Name arguments are required for a
virtual function, since it is always accessed indirectly via the
appropriate Vtable entry.
Pragma CPP_Virtual is usually constructed automatically using the
C++ binding generator tool; See section Interfacing to C++ for more details.
pragma CPP_Vtable ...
pragma CPP_Vtable (
[Entity =>] entity
[Vtable_Ptr =>] vtable
[Entry_Count =>] static_count)
You may specify CPP_Vtable pragma for each component of type
CPP.Interfaces.Vtable_Ptr in a record to which pragma
CPP_Class applies. entity is the tagged type, vtable
is the record field of type Vtable_Ptr, and static_count is
the number of virtual functions on the C++ side. Not all of these
functions need to be imported on the Ada side.
You may omit the CPP_Vtable pragma if there is only one
Vtable_Ptr component in the record and all virtual functions are
imported on the Ada side (the default value for the entry count in this
case is simply the total number of virtual functions).
Pragma CPP_Vtable is usually constructed automatically using the
C++ binding generator tool; See section Interfacing to C++ for more details.
pragma Debug (procedure_call_statement)
Debug to intersperse calls to
debug procedures in the middle of declarations.
pragma Error_Monitoring (ON | OFF [, string_literal])
ON to start the section, and another with argument OFF to
end the section. Within the monitored section of code, GNAT will
consider any error message issued as a warning from the point of view of
the return code issued by the compilation. Furthermore, at least one
such error must occur within each monitored region. If no error occurs,
a fatal (non-warning) message is issued. The use of the pragma
Error_Monitoring causes code generation to be turned off (since
there really are errors in the program).
If a second argument is given there is an additional check that the
first error issued in the monitored region exactly matches
string_literal. The second argument is only relevant for the ON
case and is ignored for the OFF case.
This pragma is provided to allow easy automation of error message
generation, e.g. in ACVC B tests, and is primarily intended for compiler
testing purposes.
pragma Export_Function ...
pragma Export_Function (
[Internal =>] internal_name,
[, [External =>] external_name,]
[, [Parameter_Types =>] (parameter_types)]
[, [Result_Type =>] result_subtype_name]
[, [Mechanism =>] MECHANISM]
[, [Result_Mechanism =>] MECHANISM_NAME]);
PARAMETER_TYPES ::=
null
| subtype_mark {, subtype_mark}
MECHANISM ::=
MECHANISM_NAME
| (MECHANISM_ASSOCIATION {, MECHANISM_ASSOCIATION})
MECHANISM_ASSOCIATION ::=
[formal_parameter_name =>] MECHANISM_NAME
MECHANISM_NAME ::=
Value
| Reference
| Descriptor [([Class =>] CLASS_NAME)]
CLASS_NAME ::= ubs | ubsb | uba | s | sb | a | nca
Use this pragma to make a function externally callable and optinally
provide information on mechanisms to be used for passing parameter and
result values. We recommend, for the purposes of improving portability,
this pragma always be used in conjunction with a separate pragma
Export, which must precede the pragma Export_Function.
GNAT does not require a separate pragma Export, but if none is
present, it assumes Convention C. Pragma Export_Function
(and Export, if present) must appear in the same declarative
region as the function to which they apply.
internal_name must uniquely designate the function to which the
pragma applies. If more than one function name exists of this name in
the declarative part you must use the Parameter_Types and
Result_Type parameters is mandatory to achieve the required
unique designation. subtype_ marks in these parameters must
exactly match the subtypes in the corresponding function specification,
using positional notation to match parameters with subtype marks.
Passing by descriptor is supported only on the OpenVMS ports of GNAT.
pragma Export_Object ...
pragma Export_Object
[Internal =>] local_name,
[, [External =>] external_name]
[, [Size =>] size]
This pragma designates an object as exported, and apart from the
extended rules for exernal symbols, is identical in effect to the use of
the normal Export pragma applied to an object. You may use a
separate Export pragma (and you probably should from the point of view
of portability), but it is not required. size is syntax checked,
but otherwise ignored by GNAT.
pragma Export_Procedure ...
pragma Export_Procedure (
[Internal =>] local_name
[, [External =>] external_symbol]
[, [Parameter_Types =>] (parameter_types)]
[, [Mechanism =>] MECHANISM]);
This pragma is identical to Export_Function except that it
applies to a procedure rather than a function and the parameters
Result_Type and Result_Mechanism are not permitted.
pragma Export_Valued_Procedure
pragma Export_Valued_Procedure (
[Internal =>] local_name
[, [External =>] external_symbol]
[, [Parameter_Types =>] (parameter_types)]
[, [Mechanism =>] MECHANISM]);
This pragma is identical to Export_Procedure except that the
first parameter of local_name, which must be present, must be of
mode OUT, and externally the subprogram is treated as a function
with this parameter as the result of the function. GNAT provides for
this capability to allow the use of OUT and IN OUT
parameters in interfacing to external functions (which are not permitted
in Ada functions).
pragma Extend_System ([Name =>] identifier)
System. In
GNAT, System contains only the definitions that are present in
the Ada 95 RM. However, other implementations, notably the DEC Ada 83
implementation, provide many extensions to package System.
For each such implementation accomodated by this pragma, GNAT provides a
package Aux_xxx, e.g. Aux_DEC for the DEC Ada 83
implementation, which provides the required additional definitions. You
can use this package in two ways. You can with it in the normal
way and access entities either by selection or using a use
clause. In this case no special processing is required.
However, if existing code contains references such as
System.xxx where xxx is an entity in the extended
definitions provided in package System, you may use this pragma
to extend visibility in System in a non-standard way that
provides greater compatibility with the existing code. Pragma
Extend_System is a configuration pragma whose single argument is
the name of the package containing the extended definition
(e.g. Aux_DEC for the DEC Ada case). A unit compiled under
control of this pragma will be processed using special visibility
processing that looks in package System.Aux_xxx where
Aux_xxx is the pragma argument for any entity referenced in
package System, but not found in package System.
Import_Function ...
pragma Import_Function (
[Internal =>] local_name,
[, [External =>] external_symbol]
[, [Parameter_Types =>] (PARAMETER_TYPES)]
[, [Result_Type =>] subtype_mark]
[, [Mechanism =>] MECHANISM]
[, [Result_Mechanism =>] MECHANISM_NAME]
[, [First_Optional_Parameter =>] identifier]);
PARAMETER_TYPES ::=
null
| subtype_mark {, subtype_mark}
MECHANISM ::=
MECHANISM_NAME
| (MECHANISM_ASSOCIATION {, MECHANISM_ASSOCIATION})
MECHANISM_ASSOCIATION ::=
[formal_parameter_name =>] MECHANISM_NAME
MECHANISM_NAME ::=
Value
| Reference
| Descriptor [([Class =>] CLASS_NAME)]
CLASS_NAME ::= ubs | ubsb | uba | s | sb | a | nca
This pragma is used in conjunction with a pragma Import to
specify additional information for an imported function. The pragma
Import (or equivalent pragma Interface) must precede the
Import_Function pragma and both must appear in the same
declarative part as the function specification.
local_name must uniquely designate the function to which the
pragma applies. If more than one function name exists of this name in
the declarative part you must use the Parameter_Types and
Result_Type parameters to achieve the required unique
designation. Subtype marks in these parameters must exactly match the
subtypes in the corresponding function specification, using positional
notation to match parameters with subtype marks.
You may optionally use the Mechanism and Result_Mechanism
parameters may optionally to specify passing mechanisms for the
parameters and result. If you specify a single mechanism name, it
applies to all parameters. Otherwise you may specify a mechanism on a
parameter by parameter basis using either positional or named
notation. If the mechanism is not specified, the default mechanism
is used.
Passing by descriptor is supported only on the to OpenVMS ports of GNAT
First_Optional_Parameter applies only to OpenVMS ports of GNAT.
It specifies that the designated parameter and all following parameters
are optional, meaning that they are not passed at the generated code
level (this is distinct from the notion of optional parameters in Ada
where the parameters are passed anyway with the designated optional
parameters). All optional parameters must be of mode IN and have
default parameter values that are either known at compile time
expressions, or uses of the 'Null_Parameter attribute.
pragma Import_Object ...
pragma Import_Object
[Internal =>] local_name,
[, [External =>] external_symbol]
[, [Size =>] size]
This pragma designates an object as imported, and apart from the
extended rules for exernal symbols, is identical in effect to the use of
the normal Import pragma applied to an object. Unlike the
subprogram case, you need not use a separate Import pragma,
although you may do so (and probably should do so from a portability
point of view). size is syntax checked, but otherwise ignored by
GNAT.
pragma Import_Procedure ...
pragma Import_Procedure (
[Internal =>] local_name,
[, [External =>] external_symbol]
[, [Parameter_Types =>] (parameter_types)]
[, [Mechanism =>] MECHANISM]
[, [First_Optional_Parameter =>] identifier]);
This pragma is identical to Import_Function except that it
applies to a procedure rather than a function and the parameters
Result_Type and Result_Mechanism are not permitted.
pragma Import_Valued_Procedure ...
pragma Import_Valued_Procedure (
[Internal =>] local_name,
[, [External =>] external_symbol]
[, [Parameter_Types =>] (parameter_types)]
[, [Mechanism =>] MECHANISM]
[, [First_Optional_Parameter =>] IDENTIFIER]);
This pragma is identical to import_procedure except that the
first parameter of local_name, which must be present, must be of
mode OUT, and externally the subprogram is treated as a function
with this parameter as the result of the function. The reason for this
capability is to allow the use of OUT and IN OUT
parameters in interfacing to external functions (which are not permitted
in Ada functions).
pragma Inline_Generic (generic_package_name)
pragma Interface_Name ...
pragma Interface_Name (
[Entity =>] local_name
[, [External_Name =>] external_name]]
[, [Link_Name =>] link_name]] )
This pragma provides an alternative way of specifying the interface name
for an interfaced subprogram, and is provided for compatibility with Ada
83 compilers that use the pragma for this purpose. You must provide at
least one of external_name or link_name.
pragma Machine_Attribute ...
pragma Machine_Attribute (
[Attribute_Name =>] string_expression
, [Entity =>] local_name )
Machine dependent attributes can be specified for types and/or
declarations. Currently only subprogram entities are supported. This
pragma is semantically equivalent to __attribute__((
string_expression)) in GNU C, where string_expression> is
recognized by the GNU C macros VALID_MACHINE_TYPE_ATTRIBUTE and
VALID_MACHINE_DECL_ATTRIBUTE which are defined in the
configuration header file `tm.h' for each machine. See the GCC
manual for further information.
pragma No_Return (procedure_local_name)
return statements,
and also may not contain any implicit return statements from falling off
the end of a statement sequence. One use of this pragma is to identify
procedures whose only purpose is to raise an exception.
Another use of this pragma is to suppress incorrect warnings about
missing returns in functions, where the last statement of a function
statement sequence is a call to such a procedure.
pragma Passive [Semaphore | No]
Semaphore is present, or no argument is omitted, then DEC Ada
treats the pragma as an assertion that the containing task is passive
and that optimization of context switch with this task is permitted and
desired. If the argument No is present, the task must not be
optimized. GNAT does not attempt to optimize any tasks in this manner
(since protected objects are available in place of passive tasks).
pragma Psect_Object ...
pragma Psect_Object
[Internal =>] local_name,
[, [External =>] external_symbol]
[, [Size =>] size]
This pragma is identical in effect to pragma Common_Object.
pragma Share_Generic
pragma Source_File_Name ...
pragma Source_File_Name (
[UNIT_NAME =>] unit_name,
BODY_FILE_NAME | SPEC_FILE_NAME => file_name_literal)
Use this to override the normal naming convention. It is a configuration
pragma, and so has the usual applicability of configuration pragmas
(i.e. it applies to either an entire partition, or to all units in a
compilation, or to a single unit, depending on how it is used.
unit_name is mapped to file_name_literal. The identifier for
the second argument is required, and indicates whether this is the file
name for the spec or for the body.
pragma Source_Reference (integer_literal [, string_literal])
gnatchop
with the `-r' switch, to make sure that the original unchopped
source file is the one referred to.
The second argument must be a string literal, it cannot be a static
string expression other than a string literal. This is because its value
is needed for error messages issued by all phases of the compiler.
pragma Subtitle
pragma Suppress_All
Suppress (All_Checks) to the unit
which it follows. This pragma is implemented for compatibility with DEC
Ada 83 usage. The use of pragma Suppress (All_Checks) as a normal
configuration pragma is preferred the usage in GNAT.
pragma Task_Info (Task_Info_Type)
Priority) and applies to the task in which it appears. The
argument must be of type System.Task_Info.Task_Info_Type.
pragma Task_Storage (...)
[Task_Type =>] local_name,
[Top_Guard =>] static_integer_expression);
This pragma specifies the length of the guard area for tasks. The guard
area is an additional storage area allocated to a task. A value of zero
means that either no guard area is created or a minimal guard area is
created, depending on the target. This pragma can appear anywhere a
Storage_Size attribute definition clause is allowed for a task
type.
pragma Title ...
pragma Title (TITLING_OPTION [, TITLING OPTION]); TITLING_OPTION ::= [Title =>] title_string_literal | [Subtitle =>] subtitle_string_literalSyntax checked but otherwise ignored by GNAT. This is a listing control pragma used in DEC Ada implementations to provide a title and/or subtitle for the program listing. The program listing generated by GNAT does not have titles or subtitles. Unlike other pragmas, the full flexibility of named notation is allowed for this pragma, i.e. the parameters may be given in any order if named notation is used, and named and positional notation can be mixed following the normal rules for procedure calls in Ada.
pragma Unchecked_Union (first_subtype_local_name)
unchecked_unions are not
available, since there is no discriminant to compare and the compiler
does not even know how many bits to compare. It is implementation
dependent whether this is detected at compile time as an illegality or
whether it is undetected and considered to be an erroneous construct. In
GNAT, a direct comparison is illegal, but GNAT does not attempt to catch
the composite case (where two composites are compared that contain an
unchecked union component), so such comparisons are simply considered
erroneous.
The layout of the resulting type corresponds exactly to a C union, where
each branch of the union corresponds to a single variant in the Ada
record. The semantics of the Ada program is not changed in any way by
the pragma, i.e. provided the above restrictions are followed, and no
erroneous incorrect references to fields or erroneous comparisons occur,
the semantics is exactly as described by the Ada reference manual.
Pragma Suppress (Discriminant_Check) applies implicitly to the
type and the default convention is C
pragma Unimplemented_Unit
pragma Unsuppress (identifier [, [On =>] name])
Suppress. If
there is no corresponding pragma Suppress in effect, it has no
effect. The range of the effect is the same as for pragma
Suppress. The meaning of the arguments is identical to that used
in pragma Suppress.
One important application is to ensure that checks are on in cases where
code depends on the checks for its correct functioning, so that the code
will compile correctly even if the compiler switches are set to suppress
checks.
pragma Warnings (On | Off, [local_name])
Off) turns off generation of
warnings until a Warnings (On) is encountered or the end of the
current unit. If generation of warnings is turned off using this
pragma, then no warning messages are output, regardless of the
setting of the command line switches.
The form with a single argument is a configuration pragma.
If local_name parameter is present, warnings are suppressed for
the local_name. This suppression is effective from the point where
it occurs till the end of the extended scope of the variable (similar to
the scope of Suppress).
Ada 95 defines (throughout the reference manual, summarized in annex K), a set of attributes that provide useful additional functionality in all areas of the language. These language defined attributes are implemented in GNAT and work as described in the Ada 95 Reference Manual.
In addition, Ada 95 allows implementations to define additional attributes whose meaning is defined by the implementation. GNAT provides a number of these implementation-dependent attributes which can be used to extend and enhance the functionality of the compiler. This section of the reference manual describes these additional attributes.
Note that any program using these attributes may not be portable to other compilers (although GNAT implements this set of attributes on all platforms). Therefore if portability to other compilers is an important consideration, you should minimize the use of these attributesa.
Abort_Signal
Standard'Abort_Signal (Standard is the only allowed
prefix) provides the entity for the special exception used to signal
task abort or asynchronous transfer of control. Normally this attribute
should only be used in the tasking runtime (it is highly peculiar, and
completely outside the normal semantics of Ada, for a user program to
intercept the abort exception).
Address_Size
Standard'Address_Size (Standard is the only allowed
prefix) is a static constant giving the number of bits in an
Address. It is used primarily for constructing the definition of
Memory_Size in package Standard, but may be freely used in user
programs.
Bit
obj'Bit, where obj is any object, yields the bit
offset within the storage unit (byte) that contains the first bit of
storage allocated for the object. The value of this attribute is of the
type Universal_Integer, and is always a non-negative number not
exceeding the value of System.Storage_Unit.
For an object that is a variable or a constant allocated in a register,
the value is zero. (The use of this attribute does not force the
allocation of a variable to memory).
For an object that is a formal parameter, this attribute applies
to either the matching actual parameter or to a copy of the
matching actual parameter.
For an access object the value is zero. Note that
obj.all'Bit is subject to an Access_Check for the
designated object. Similarly for a record component
X.C'Bit is subject to a discriminant check and
X(I).Bit and X(I1..I2)'Bit
are subject to index checks.
This attribute is designed to be compatible with the DEC Ada definition
and implementation of the Bit attribute.
Default_Bit_Order
Standard'Default_Bit_Order (Standard is the only
permissible prefix), provides the value System.Default_Bit_Order
as a Pos value (0 for High_Order_First, 1 for
Low_Order_First). This is used to construct the definition of
Default_Bit_Order in package System.
Elab_Body
Elab_Spec
Enum_Rep
S'Enum_Rep denotes a
function with the following specification:
function S'Enum_Rep (Arg : S'Base) return Universal_Integer;The function returns the representation value for the given enumeration value. This will be equal to value of the
Pos attribute in the
absence of an enumeration representation clause. This is a static
attribute (i.e. the result is static if the argument is static).
Fixed_Value
S'Fixed_Value denotes a
function with the following specification:
function S'Fixed_Value (Arg : Universal_Integer) return S;The value returned is the fixed-point value V such that
V = Arg * S'SmallThe effect is thus equivalent to first converting the argument to the integer type used to represent S, and then doing an unchecked conversion to the fixed-point type. This attribute is primarily intended for use in implementation of the input-output functions for fixed-point values.
Img
Img attribute differs from Image in that it may be
applied to objects as well as types, in which case it gives the
Image for the subtype of the object. This is convenient for
debugging:
Put_Line ("X = " & X'Img);
has the same meaning as the more verbose:
Put_Line ("X = " & type'Image (X));
where type is the subtype of the object X.
Integer_Value
S'Integer_Value denotes a
function with the following specification:
function S'Integer_Value (Arg : Universal_Fixed) return S;The value returned is the integer value V, such that
Arg = V * type'SmallThe effect is thus equivalent to first doing an unchecked convert from the fixed-point type to its corresponding implementation type, and then converting the result to the target integer type. This attribute is primarily intended for use in implementation of the standard input-output functions for fixed-point values.
Machine_Size
Object_Size attribute. It is
provided for compatibility with the DEC attribute of this name.
Max_Interrupt_Priority
Standard'Max_Interrupt_Priority (Standard is the only
permissible prefix), provides the value
System.Max_Interrupt_Priority and is intended primarily for
constructing this definition in package System.
Max_Priority
Standard'Max_Priority (Standard is the only permissible
prefix) provides the value System.Max_Priority and is intended
primarily for constructing this definition in package System.
Maximum_Alignment
Standard'Maximum_Alignment (Standard is the only
permissible prefix) provides the maximum useful alignment value for the
target. This is a static value that can be used to specify the alignment
for an object, guaranteeing that it is properly aligned in all
cases. This is useful when an external object is imported and its
alignment requirements are unknown.
Mechanism_Code
function'Mechanism_Code yields an integer code for the
mechanism used for the result of function, and
subprogram'Mechanism_Code (n) yields the mechanism
used for formal parameter number n (a static integer value with 1
meaningthe first parameter) of subprogram. The code returned is:
Null_Parameter
T'Null_Parameter denotes an imaginary object of
type or subtype T allocated at machine address zero. The attribute
is allowed only as the default expression of a formal parameter, or as
an actual expression of a subporgram call. In either case, the
subprogram must be imported.
The identity of the object is represented by the address zero in the
argument list, independent of the passing mechanism (explicit or
default).
This capability is needed to specify that a zero address should be
passed for a record or other composite object passed by reference.
There is no way of indicating this without the Null_Parameter
attribute.
Object_Size
type'Object_Size is the same as type'Size for
all types except fixed-point types and discrete types. For fixed-point
types and discrete types, this attribute gives the size used for default
allocation of objects and components of the size.
Passed_By_Reference
type'Passed_By_Reference for any subtype type returns
a value of type Boolean value that is True if the type is
normally passed by reference and False if the type is normally
passed by copy in calls. For scalar types, the result is always False
and is static. For non-scalar types, the result is non-static.
Range_Length
type'Range_Length for any discrete type type yields
the number of values represented by the subtype (zero for a null
range). The result is static for static subtypes. Range_Length
applied to the index subtype of a one dimensional array always gives the
same result as Range applied to the array itself.
Storage_Unit
Standard'Storage_Unit (Standard is the only permissible
prefix) provides the value System.Storage_Unit and is intended
primarily for constructing this definition in package System.
Tick
Standard'Tick (Standard is the only permissible prefix)
provides the value of System.Tick and is intended primarily for
constructing this definition in package System.
Type_Class
type'Type_Class for any type or subtype type yields
the value of the type class for the full type of type. If
type is a generic formal type, the value is the value for the
corresponding actual subtype. The value of this attribute is of type
System.Aux_DEC.Type_Class, which has the following definition:
type Type_Class is
(Type_Class_Enumeration,
Type_Class_Integer,
Type_Class_Fixed_Point,
Type_Class_Floating_Point,
Type_Class_Array,
Type_Class_Record,
Type_Class_Access,
Type_Class_Task,
Type_Class_Address);
Protected types yield the value Type_Class_Task, which thus
applies to all concurrent types. This attribute is designed to
be compatible with the DEC Ada attribute of the same name.
Universal_Literal_String
Universal_Literal_String must be a named
number. The static result is the string consisting of the characters of
the number as defined in the original source. This allows the user
program to access the actual text of named numbers without intermediate
conversions and without the need to enclose the strings in quotes (which
would preclude their use as numbers). This is used internally for the
construction of values of the floating-point attributes from the file
`ttypef.ads', but may also be used by user programs.
Unrestricted_Access
Unrestricted_Access attribute is similar to Access
except that all accessibility and aliased view checks are omitted. This
is very much a user-beware attribute. It is very similar to
Address, for which it is a desirable replacement where the value
desired is an access type. In other words, its effect is identical to
first applying the Address attribute and then doing an unchecked
conversion to a desired access type. In GNAT, but not necessarily in
other implementations, the use of static chains for inner level
subprograms means that Unrestricted_Access applied to a
subprogram yields a value that can be called as long as the subprogram
is in scope (normal Ada 95 accessibility rules restrict this usage).
Value_Size
type'Value_Size is the number of bits required to represent
a value of the given subtype. It is the same as type'Size,
but, unlike Size, may be set for non-first subtypes.
Word_Size
Standard'Word_Size (Standard is the only permissible
prefix) provides the value System.Word_Size and is intended
primarily for constructing this definition in package System.
The main text of the Ada 95 Reference Manual describes the required behavior of all Ada 95 compilers, and the GNAT compiler conforms to these requirements.
In addition, there are sections throughout the reference manual headed by the phrase "implementation advice". These sections are not normative, i.e. they do not specify requirements that all compilers must follow. Rather they provide advice on generally desirable behavior. You may wonder why they are not requirements. The most typical answer is that they describe behavior that seems generally desirable, but cannot be provided on all systems, or which may be undesirable on some systems.
As far as practical, GNAT follows the implementation advice sections in the Ada 95 Reference Manual. This chapter contains a table giving the reference manual section number, paragraph number and several keywords for each advice. Each entry consists of the txt of the advice followed by the GNAT interpretation of this advice. Most often, this simply says "followed", which means that GNAT follows the advice. However, in a number of cases, GNAT deliberately deviates from this advice, in which case the text describes what GNAT does and why.
If an implementation detects the use of an unsupported Specialized Needs
Annex feature at run time, it should raise Program_Error if
feasible.
Not relevant. All specialized needs annex features are either supported,
or diagnosed at compile time.
If an implementation wishes to provide implementation-defined extensions to the functionality of a language-defined library unit, it should normally do so by adding children to the library unit. Followed.
If an implementation detects a bounded error or erroneous
execution, it should raise Program_Error.
Followed in all cases in which the implementation detects a bounded
error or erroneous execution. Not all such situations are detected at
runtime.
Normally, implementation-defined pragmas should have no semantic effect for error-free programs; that is, if the implementation-defined pragmas are removed from a working program, the program should still be legal, and should still have the same semantics. The following implementation defined pragmas are exceptions to this rule:
Abort_Defer
Ada_83
Assert
CPP_Class
CPP_Constructor
CPP_Destructor
CPP_Virtual
CPP_Vtable
Debug
Interface_Name
Machine_Attribute
Unimplemented_Unit
Unchecked_Union
Normally, an implementation should not define pragmas that can make an illegal program legal, except as follows:
A pragma used to complete a declaration, such as a pragma Import;
A pragma used to configure the environment by adding, removing, or
replacing library_items.
See response to paragraph 16 of this same section.
If an implementation supports a mode with alternative interpretations
for Character and Wide_Character, the set of graphic
characters of Character should nevertheless remain a proper
subset of the set of graphic characters of Wide_Character. Any
character set "localizations" should be reflected in the results of
the subprograms defined in the language-defined package
Characters.Handling (see A.3) available in such a mode. In a mode with
an alternative interpretation of Character, the implementation should
also support a corresponding change in what is a legal
identifier_letter.
Not all wide character modes follow this advice, in particular the JIS
and IEC modes reflect standard usage in Japan, and in these encoding,
the upper half of the Latin-1 set is not part of the wide-character
subset, since the most significant bit is used for wide character
encoding. However, this only applies to the external forms. Internally
there is no such restriction.
An implementation should support Long_Integer in addition to
Integer if the target machine supports 32-bit (or longer)
arithmetic. No other named integer subtypes are recommended for package
Standard. Instead, appropriate named integer subtypes should be
provided in the library package Interfaces (see B.2).
Long_Integer is supported. Other integer types are also supported
in Standard, so this advice is not fully followed. These types
are supported for convenient interface to C, and so that all hardware
types of the machine are easily available.
An implementation for a two's complement machine should support
modular types with a binary modulus up to System.Max_Int*2+2. An
implementation should support a nonbinary modules up to Integer'Last.
Followed.
For the evaluation of a call on S'Pos for an enumeration
subtype, if the value of the operand does not correspond to the internal
code for any enumeration literal of its type (perhaps due to an
un-initialized variable), then the implementation should raise
Program_Error. This is particularly important for enumeration
types with noncontiguous internal codes specified by an
enumeration_representation_clause.
Followed.
An implementation should support Long_Float in addition to
Float if the target machine supports 11 or more digits of
precision. No other named floating point subtypes are recommended for
package Standard. Instead, appropriate named floating point subtypes
should be provided in the library package Interfaces (see B.2).
Short_Float and Long_Long_Float are also provided. The
former provides improved compatibility with other implementations
supporting this type. The latter corresponds to the highest precision
floating-point type supported by the hardware. On most machines, this
will be the same as Long_Float, but on some machines, it will
correspond to the IEEE extended form. On the Silicon Graphics
processors, which do not support IEEE extended form,
Long_Long_Float is the same as Long_Float.
An implementation should normally represent multidimensional arrays in
row-major order, consistent with the notation used for multidimensional
array aggregates (see 4.3.3). However, if a pragma Convention
(Fortran, ...) applies to a multidimensional array type, then
column-major order should be used instead (see B.5, "Interfacing with
Fortran").
Followed.
Whenever possible in an implementation, the value of Duration'Small
should be no greater than 100 microseconds.
Followed. (Duration'Small = 10**(-9)).
The time base for delay_relative_statements should be monotonic;
it need not be the same time base as used for Calendar.Clock.
Followed.
In an implementation, a type declared in a pre-elaborated package should have the same representation in every elaboration of a given version of the package, whether the elaborations occur in distinct executions of the same program, or in executions of distinct programs or partitions that include the given version. Followed.
Exception_Message by default and Exception_Information
should produce information useful for
debugging. Exception_Message should be short, about one
line. Exception_Information can be long. Exception_Message
should not include the
Exception_Name. Exception_Information should include both
the Exception_Name and the Exception_Message.
Followed.
The implementation should minimize the code executed for checks that have been suppressed. Followed.
The recommended level of support for all representation items is qualified as follows:
An implementation need not support representation items containing non-static expressions, except that an implementation should support a representation item for a given entity if each non-static expression in the representation item is a name that statically denotes a constant declared before the entity. Followed. GNAT does not support non-static expressions in representation clauses unless they are constants declared before the entity. For example:
X : typ;
for X'Address use To_address (16#2000#);
will be rejected, since the To_Address expression is non-static. Instead
write:
X_Address : constant Address : =
To_Address ((16#2000#);
X : typ;
for X'Address use X_Address;
An implementation need not support a specification for the Size
for a given composite subtype, nor the size or storage place for an
object (including a component) of a given composite subtype, unless the
constraints on the subtype and its composite subcomponents (if any) are
all static constraints.
Followed. Size Clauses are not permitted on non-static components, as
described above.
An aliased component, or a component whose type is by-reference, should always be allocated at an addressable location. Followed.
If a type is packed, then the implementation should try to minimize storage allocated to objects of the type, possibly at the expense of speed of accessing components, subject to reasonable complexity in addressing calculations.
The recommended level of support pragma Pack is:
For a packed record type, the components should be packed as tightly as
possible subject to the Sizes of the component subtypes, and subject to
any record_representation_clause that applies to the type; the
mplementation may, but need not, reorder components or cross aligned
word boundaries to improve the packing. A component whose Size is
greater than the word size may be allocated an integral number of words.
Followed. Tight packing of arrays is supported for all component sizes
up to 32-bits, which is the word size on typical implementations of GNAT.
An implementation should support Address clauses for imported subprograms. Followed
For an array X, X'Address should point at the first
component of the array, and not at the array bounds.
Followed.
The recommended level of support for the Address attribute is:
X'Address should produce a useful result if X is an
object that is aliased or of a by-reference type, or is an entity whose
Address has been specified.
Followed.
An implementation should support Address clauses for imported
subprograms.
Followed.
Objects (including subcomponents) that are aliased or of a by-reference type should be allocated on storage element boundaries. Followed.
If the Address of an object is specified, or it is imported or exported,
then the implementation should not perform optimizations based on
assumptions of no aliases.
Followed.
The recommended level of support for the Alignment attribute for
subtypes is:
An implementation should support specified Alignments that are factors and multiples of the number of storage elements per word, subject to the following: Followed.
An implementation need not support specified Alignments for
combinations of Sizes and Alignments that cannot be easily
loaded and stored by available machine instructions.
Followed.
An implementation need not support specified Alignments that are
greater than the maximum Alignment the implementation ever returns by
default.
Followed.
The recommended level of support for the Alignment attribute for
objects is:
Same as above, for subtypes, but in addition: Followed.
For stand-alone library-level objects of statically constrained
subtypes, the implementation should support all Alignments
supported by the target linker. For example, page alignment is likely to
be supported for such objects, but not for subtypes.
Followed.
The recommended level of support for the Size attribute of
objects is:
A Size clause should be supported for an object if the specified
Size is at least as large as its subtype's Size, and
corresponds to a size in storage elements that is a multiple of the
object's Alignment (if the Alignment is nonzero).
Followed.
If the Size of a subtype is specified, and allows for efficient
independent addressability (see 9.10) on the target architecture, then
the Size of the following objects of the subtype should equal the
Size of the subtype:
Aliased objects (including components). Followed.
Size clause on a composite subtype should not affect the
internal layout of components.
Followed.
The recommended level of support for the Size attribute of subtypes is:
The Size (if not specified) of a static discrete or fixed point
subtype should be the number of bits needed to represent each value
belonging to the subtype using an unbiased representation, leaving space
for a sign bit only if the subtype contains negative values. If such a
subtype is a first subtype, then an implementation should support a
specified Size for it that reflects this representation.
Followed.
For a subtype implemented with levels of indirection, the Size
should include the size of the pointers, but not the size of what they
point at.
Followed.
The recommended level of support for the Component_Size
attribute is:
An implementation need not support specified Component_Sizes that are
less than the Size of the component subtype.
Followed.
An implementation should support specified Component_Sizes that
are factors and multiples of the word size. For such
Component_Sizes, the array should contain no gaps between
components. For other Component_Sizes (if supported), the array
should contain no gaps between components when packing is also
specified; the implementation should forbid this combination in cases
where it cannot support a no-gaps representation.
Followed.
The recommended level of support for enumeration representation clauses is:
An implementation need not support enumeration representation clauses
for boolean types, but should at minium support the internal codes in
the range System.Min_Int.System.Max_Int.
Followed.
The recommended level of support for
record_representation_clauses is:
An implementation should support storage places that can be extracted with a load, mask, shift sequence of machine code, and set with a load, shift, mask, store sequence, given the available machine instructions and run-time model. Followed.
A storage place should be supported if its size is equal to the
Size of the component subtype, and it starts and ends on a
boundary that obeys the Alignment of the component subtype.
Followed.
If the default bit ordering applies to the declaration of a given type,
then for a component whose subtype's Size is less than the word
size, any storage place that does not cross an aligned word boundary
should be supported.
Followed.
An implementation may reserve a storage place for the tag field of a tagged type, and disallow other components from overlapping that place. Followed.
An implementation need not support a component_clause for a
component of an extension part if the storage place is not after the
storage places of all components of the parent type, whether or not
those storage places had been specified.
Followed. The above advice on record representation clauses is followed,
and all mentioned features are implemented.
If a component is represented using some form of pointer (such as an offset) to the actual data of the component, and this data is contiguous with the rest of the object, then the storage place attributes should reflect the place of the actual data, not the pointer. If a component is allocated discontinuously from the rest of the object, then a warning should be generated upon reference to one of its storage place attributes. Followed. There are no such components in GNAT.
The recommended level of support for the non-default bit ordering is:
If Word_Size = Storage_Unit, then the implementation
should support the non-default bit ordering in addition to the default
bit ordering.
Followed. Word size does not equal storage size in this implementation.
Thus non-default bit ordering is not supported.
Operations in System and its children should reflect the target
environment semantics as closely as is reasonable. For example, on most
machines, it makes sense for address arithmetic to "wrap around."
Operations that do not make sense should raise Program_Error.
Followed. Address arithmetic is modular arithmetic that wraps around. No
operation raises Program_Error, since all operations make sense.
The Size of an array object should not include its bounds; hence,
the bounds should not be part of the converted data.
Followed.
The implementation should not generate unnecessary run-time checks to ensure that the representation of S is a representation of the target type. It should take advantage of the permission to return by reference when possible. Restrictions on unchecked conversions should be avoided unless required by the target environment. Followed. There are no restrictions on unchecked conversion. A warning is generated if the soure and target types do not have the same size since the semantics in this case may be target dependent.
The recommended level of support for unchecked conversions is:
Unchecked conversions should be supported and should be reversible in the cases where this clause defines the result. To enable meaningful use of unchecked conversion, a contiguous representation should be used for elementary subtypes, for statically constrained array subtypes whose component subtype is one of the subtypes described in this paragraph, and for record subtypes without discriminants whose component subtypes are described in this paragraph. Followed.
An implementation should document any cases in which it dynamically allocates heap storage for a purpose other than the evaluation of an allocator. Followed, the only other points at which heap storage is dynamically allocated are as follows:
A default (implementation-provided) storage pool for an access-to- constant type should not have overhead to support de-allocation of individual objects. Followed.
A storage pool for an anonymous access type should be created at the point of an allocator for the type, and be reclaimed when the designated object becomes inaccessible. Followed.
For a standard storage pool, Free should actually reclaim the
storage.
Followed.
If a stream element is the same size as a storage element, then the
normal in-memory representation should be used by Read and
Write for scalar objects. Otherwise, Read and Write
should use the smallest number of stream elements needed to represent
all values in the base range of the scalar type.
Followed.
If an implementation provides additional named predefined integer types, then the names should end with `Integer' as in `Long_Integer'. If an implementation provides additional named predefined floating point types, then the names should end with `Float' as in `Long_Float'. Followed.
Ada.Characters.Handling
If an implementation provides a localized definition of Character
or Wide_Character, then the effects of the subprograms in
Characters.Handling should reflect the localizations. See also
3.5.2.
Followed. GNAT provides no such localized definitions.
Bounded string objects should not be implemented by implicit pointers and dynamic allocation. Followed. No implicit pointers or dynamic allocation are used.
Any storage associated with an object of type Generator should be
reclaimed on exit from the scope of the object.
Followed.
If the generator period is sufficiently long in relation to the number
of distinct initiator values, then each possible value of
Initiator passed to Reset should initiate a sequence of
random numbers that does not, in a practical sense, overlap the sequence
initiated by any other value. If this is not possible, then the mapping
between initiator values and generator states should be a rapidly
varying function of the initiator value.
Followed. The generator period is sufficiently long for the first
condition here to hold true.
Get_Immediate
The Get_Immediate procedures should be implemented with
unbuffered input. For a device such as a keyboard, input should be
available if a key has already been typed, whereas for a disk
file, input should always be available except at end of file. For a file
associated with a keyboard-like device, any line-editing features of the
underlying operating system should be disabled during the execution of
Get_Immediate.
Followed.
Export
If an implementation supports pragma Export to a given language,
then it should also allow the main subprogram to be written in that
language. It should support some mechanism for invoking the elaboration
of the Ada library units included in the system, and for invoking the
finalization of the environment task. On typical systems, the
recommended mechanism is to provide two subprograms whose link names are
adainit and adafinal. adainit should contain the
elaboration code for library units. adafinal should contain the
finalization code. These subprograms should have no effect the second
and subsequent time they are called.
Followed.
Automatic elaboration of pre-elaborated packages should be
provided when pragma Export is supported.
Followed when the main program is in Ada. If the main program is in a
foreign language, then
adainit must be called to elaborate pre-elaborated
packages.
For each supported convention L other than Intrinsic, an
implementation should support Import and Export pragmas
for objects of L-compatible types and for subprograms, and pragma
Convention for L-eligible types and for subprograms,
presuming the other language has corresponding features. Pragma
Convention need not be supported for scalar types.
Followed.
Interfaces
For each implementation-defined convention identifier, there should be a
child package of package Interfaces with the corresponding name. This
package should contain any declarations that would be useful for
interfacing to the language (implementation) represented by the
convention. Any declarations useful for interfacing to any language on
the given hardware architecture should be provided directly in
Interfaces.
Followed. An additional package not defined
in the Ada 95 Reference Manual is Interfaces.CPP, used
for interfacing to C++.
An implementation supporting an interface to C, COBOL, or Fortran should provide the corresponding package or packages described in the following clauses. Followed. GNAT provides all the packages described in this section.
An implementation should support the following interface correspondences between Ada and C. Followed.
An Ada procedure corresponds to a void-returning C function. Followed.
An Ada function corresponds to a non-void C function. Followed.
An Ada in scalar parameter is passed as a scalar argument to a C
function.
Followed.
An Ada in parameter of an access-to-object type with designated
type T is passed as a t* argument to a C function,
where t is the C type corresponding to the Ada type T.
Followed.
An Ada access T parameter, or an Ada out or in out
parameter of an elementary type T, is passed as a t*
argument to a C function, where t is the C type corresponding to
the Ada type T. In the case of an elementary out or
in out parameter, a pointer to a temporary copy is used to
preserve by-copy semantics.
Followed.
An Ada parameter of a record type T, of any mode, is passed as a
t* argument to a C function, where t is the C
structure corresponding to the Ada type T.
Followed. This convention may be overridden by the use of the C_Pass_By_Copy
pragma, or Convention, or by explicitly specifying the mechanism for a given
call using an extended import or export pragma.
An Ada parameter of an array type with component type T, of any
mode, is passed as a t* argument to a C function, where
t is the C type corresponding to the Ada type T.
Followed.
An Ada parameter of an access-to-subprogram type is passed as a pointer to a C function whose prototype corresponds to the designated subprogram's specification. Followed.
An Ada implementation should support the following interface correspondences between Ada and COBOL. Followed.
An Ada access T parameter is passed as a "BY REFERENCE" data item of the COBOL type corresponding to T. Followed.
An Ada in scalar parameter is passed as a "BY CONTENT" data item of the corresponding COBOL type. Followed.
Any other Ada parameter is passed as a "BY REFERENCE" data item of the COBOL type corresponding to the Ada parameter type; for scalars, a local copy is used if necessary to ensure by-copy semantics. Followed.
An Ada implementation should support the following interface correspondences between Ada and Fortran: Followed.
An Ada procedure corresponds to a Fortran subroutine. Followed.
An Ada function corresponds to a Fortran function. Followed.
An Ada parameter of an elementary, array, or record type T is passed as a T argument to a Fortran procedure, where T is the Fortran type corresponding to the Ada type T, and where the INTENT attribute of the corresponding dummy argument matches the Ada formal parameter mode; the Fortran implementation's parameter passing conventions are used. For elementary types, a local copy is used if necessary to ensure by-copy semantics. Followed.
An Ada parameter of an access-to-subprogram type is passed as a reference to a Fortran procedure whose interface corresponds to the designated subprogram's specification. Followed.
The machine code or intrinsic support should allow access to all operations normally available to assembly language programmers for the target environment, including privileged instructions, if any. Followed.
The interfacing pragmas (see Annex B) should support interface to
assembler; the default assembler should be associated with the
convention identifier Assembler.
Followed.
If an entity is exported to assembly language, then the implementation should allocate it at an addressable location, and should ensure that it is retained by the linking process, even if not otherwise referenced from the Ada code. The implementation should assume that any call to a machine code or assembler subprogram is allowed to read or update every object that is specified as exported. Followed.
The implementation should ensure that little or no overhead is associated with calling intrinsic and machine-code subprograms. Followed for both intrinsics and machine-code subprograms.
It is recommended that intrinsic subprograms be provided for convenient access to any machine operations that provide special capabilities or efficiency and that are not otherwise available through the language constructs. Followed. A full set of machine operation intrinsic subprograms is provided.
Atomic read-modify-write operations -- e.g., test and set, compare and swap, decrement and test, enqueue/dequeue. Followed on any target supporting such operations.
Standard numeric functions -- e.g., sin, log. Followed on any target supporting such operations.
String manipulation operations -- e.g., translate and test. Followed on any target supporting such operations.
Vector operations -- e.g., compare vector against thresholds. Followed on any target supporting such operations.
Direct operations on I/O ports. Followed on any target supporting such operations.
If the Ceiling_Locking policy is not in effect, the
implementation should provide means for the application to specify which
interrupts are to be blocked during protected actions, if the underlying
system allows for a finer-grain control of interrupt blocking.
Followed. The underlying system does not allow for finer-grain control
of interrupt blocking.
Whenever possible, the implementation should allow interrupt handlers to be called directly by the hardware. Followed on any target where the underlying operating system permits such direct calls.
Whenever practical, the implementation should detect violations of any implementation-defined restrictions before run time. Followed. Compile time warnings are given when possible.
Interrupts
If implementation-defined forms of interrupt handler procedures are
supported, such as protected procedures with parameters, then for each
such form of a handler, a type analogous to Parameterless_Handler
should be specified in a child package of Interrupts, with the
same operations as in the predefined package Interrupts.
Followed.
It is recommended that pre-elaborated packages be implemented in such a way that there should be little or no code executed at run time for the elaboration of entities not already covered by the Implementation Requirements. Followed. Executable code is generated in some cases, e.g. loops to initialize large arrays.
Discard_Names
If the pragma applies to an entity, then the implementation should reduce the amount of storage used for storing names associated with that entity. Followed.
Some implementations are targeted to domains in which memory use at run time must be completely deterministic. For such implementations, it is recommended that the storage for task attributes will be pre-allocated statically and not from the heap. This can be accomplished by either placing restrictions on the number and the size of the task's attributes, or by using the pre-allocated storage for the first N attribute objects, and the heap for the others. In the latter case, N should be documented. Not followed. This implementation is not targeted to such a domain.
The implementation should use names that end with `_Locking' for implementation-defined locking policies. Followed. No such implementation-defined locking policies exist.
The implementation should use names that end with `_Queuing' for implementation-defined queuing policies. Followed. No such implementation-defined queueing policies exist.
Even though the abort_statement is included in the list of
potentially blocking operations (see 9.5.1), it is recommended that this
statement be implemented in a way that never requires the task executing
the abort_statement to block.
Followed.
On a multi-processor, the delay associated with aborting a task on another processor should be bounded; the implementation should use periodic polling, if necessary, to achieve this. Followed.
When feasible, the implementation should take advantage of the specified restrictions to produce a more efficient implementation. Not followed. GNAT does not currently take advantage of any specified restrictions.
When appropriate, implementations should provide configuration
mechanisms to change the value of Tick.
Such configuration mechanisms are not appropriate to this implementation
and are thus not supported.
It is recommended that Calendar.Clock and Real_Time.Clock
be implemented as transformations of the same time base.
Followed.
It is recommended that the best time base which exists in
the underlying system be available to the application through
Clock. Best may mean highest accuracy or largest range.
Followed.
Whenever possible, the PCS on the called partition should allow for multiple tasks to call the RPC-receiver with different messages and should allow them to block until the corresponding subprogram body returns. Followed by GLADE, a separately supplied PCS that can be used with GNAT. For information on GLADE, contact Ada Core Technologies.
The Write operation on a stream of type Params_Stream_Type
should raise Storage_Error if it runs out of space trying to
write the Item into the stream.
Followed by GLADE, a separately supplied PCS that can be used with
GNAT. For information on GLADE, contact Ada Core Technologies.
If COBOL (respectively, C) is widely supported in the target
environment, implementations supporting the Information Systems Annex
should provide the child package Interfaces.COBOL (respectively,
Interfaces.C) specified in Annex B and should support a
convention_identifier of COBOL (respectively, C) in the interfacing
pragmas (see Annex B), thus allowing Ada programs to interface with
programs written in that language.
Followed.
Packed decimal should be used as the internal representation for objects of subtype S when S'Machine_Radix = 10. Not followed. GNAT ignores S'Machine_Radix and always uses binary representations.
If Fortran (respectively, C) is widely supported in the target
environment, implementations supporting the Numerics Annex
should provide the child package Interfaces.Fortran (respectively,
Interfaces.C) specified in Annex B and should support a
convention_identifier of Fortran (respectively, C) in the interfacing
pragmas (see Annex B), thus allowing Ada programs to interface with
programs written in that language.
Followed.
Because the usual mathematical meaning of multiplication of a complex operand and a real operand is that of the scaling of both components of the former by the latter, an implementation should not perform this operation by first promoting the real operand to complex type and then performing a full complex multiplication. In systems that, in the future, support an Ada binding to IEC 559:1989, the latter technique will not generate the required result when one of the components of the complex operand is infinite. (Explicit multiplication of the infinite component by the zero component obtained during promotion yields a NaN that propagates into the final result.) Analogous advice applies in the case of multiplication of a complex operand and a pure-imaginary operand, and in the case of division of a complex operand by a real or pure-imaginary operand. Not followed.
Similarly, because the usual mathematical meaning of addition of a
complex operand and a real operand is that the imaginary operand remains
unchanged, an implementation should not perform this operation by first
promoting the real operand to complex type and then performing a full
complex addition. In implementations in which the Signed_Zeros
attribute of the component type is True (and which therefore
conform to IEC 559:1989 in regard to the handling of the sign of zero in
predefined arithmetic operations), the latter technique will not
generate the required result when the imaginary component of the complex
operand is a negatively signed zero. (Explicit addition of the negative
zero to the zero obtained during promotion yields a positive zero.)
Analogous advice applies in the case of addition of a complex operand
and a pure-imaginary operand, and in the case of subtraction of a
complex operand and a real or pure-imaginary operand.
Not followed.
Implementations in which Real'Signed_Zeros is True should
attempt to provide a rational treatment of the signs of zero results and
result components. As one example, the result of the Argument
function should have the sign of the imaginary component of the
parameter X when the point represented by that parameter lies on
the positive real axis; as another, the sign of the imaginary component
of the Compose_From_Polar function should be the same as
(respectively, the opposite of) that of the Argument parameter when that
parameter has a value of zero and the Modulus parameter has a
nonnegative (respectively, negative) value.
Followed.
Implementations in which Complex_Types.Real'Signed_Zeros is
True should attempt to provide a rational treatment of the signs
of zero results and result components. For example, many of the complex
elementary functions have components that are odd functions of one of
the parameter components; in these cases, the result component should
have the sign of the parameter component at the origin. Other complex
elementary functions have zero components whose sign is opposite that of
a parameter component at the origin, or is always positive or always
negative.
Followed.
The versions of the forward trigonometric functions without a
Cycle parameter should not be implemented by calling the
correspondingg version with a Cycle parameter of
2.0*Numerics.Pi, since this will not provide the required
accuracy in some portions of the domain. For the same reason, the
version of Log without a Base parameter should not be
implemented by calling the corresponding version with a Base
parameter of Numerics.e.
Followed.
The version of the Compose_From_Polar function without a
Cycle parameter should not be implemented by calling the
corresponding version with a Cycle parameter of
2.0*Numerics.Pi, since this will not provide the required
accuracy in some portions of the domain.
Followed.
In addition to the implementation dependent pragmas and attributes, and the implementation advice, there are a number of other features of Ada 95 that are potentially implementation dependent. These are mentioned throughout the Ada 95 Reference Manual, and are summarized in annex M.
A requirement for conforming Ada compilers is that they provide documentation describing how the implementation deals with each of these issues. In this chapter, you will find each point in annex M listed followed by a description in italic font of how GNAT handles the implementation dependence.
You can use this chapter as a guide to minimizing implementation dependent features in your programs if portability to other compilers and other operating systems is an important consideration. The numbers in each section below correspond to the paragraph number in the Ada 95 Reference Manual.
2. Whether or not each recommendation given in Implementation Advice is followed. See 1.1.2(37). See section Implementation Advice.
3. Capacity limitations of the implementation. See 1.1.3(3). The complexity of programs that can be processed is limited only by the total amount of available virtual memory, and disk space for the generated object files.
4. Variations from the standard that are impractical to avoid given the implementation's execution environment. See 1.1.3(6). There are no variations from the standard.
5. Which code_statements cause external
interactions. See 1.1.3(10).
Any code_statement can potentially cause external interactions.
6. The coded representation for the text of an Ada program. See 2.1(4). See separate section on source representation.
7. The control functions allowed in comments. See 2.1(14). See separate section on source representation.
8. The representation for an end of line. See 2.2(2). See separate section on source representation.
9. Maximum supported line length and lexical element length. See 2.2(15). The maximum line length is 255 characters an the maximum length of a lexical element is also 255 characters.
10. Implementation defined pragmas. See 2.8(14).
See section Implementation Defined Pragmas.
11. Effect of pragma Optimize. See 2.8(27).
Pragma Optimize, if given with a Time or Space
parameter, checks that the optimization flag is set, and aborts if it is
not.
12. The sequence of characters of the value returned by
S'Image when some of the graphic characters of
S'Wide_Image are not defined in Character. See
3.5(37).
The sequence of characters is as defined by the wide character encoding
method used for the source. See section on source representation for
further details.
13. The predefined integer types declared in
Standard. See 3.5.4(25).
Short_Short_Integer
Short_Integer
Integer
Long_Integer
Long_Long_Integer
14. Any nonstandard integer types and the operators defined for them. See 3.5.4(26). There are no nonstandard integer types.
15. Any nonstandard real types and the operators defined for them. See 3.5.6(8). There are no nonstandard real types.
16. What combinations of requested decimal precision and range are supported for floating point types. See 3.5.7(7). The precision and range is as defined by the IEEE standard.
17. The predefined floating point types declared in
Standard. See 3.5.7(16).
Short_Float
Float
Long_Float
Long_Long_Float
18. The small of an ordinary fixed point type. See 3.5.9(8).
Fine_Delta is 2**(-63)
19. What combinations of small, range, and digits are
supported for fixed point types. See 3.5.9(10).
Any combinations are permitted that do not result in a small less than
Fine_Delta and do not result in a mantissa larger than 63 bits.
20. The result of Tags.Expanded_Name for types declared
within an unnamed block_statement. See 3.9(10).
Block numbers of the form Bnnn, where nnn is a
decimal integer are allocated.
21. Implementation-defined attributes. See 4.1.4(12). See section Implementation Defined Attributes.
22. Any implementation-defined time types. See 9.6(6). There are no implementation-defined time types.
23. The time base associated with relative delays.
See 9.6(20). The time base used is that provided by the C library
function gettimeofday.
24. The time base of the type Calendar.Time. See
9.6(23).
The time base used is that provided by the C library function
gettimeofday.
25. The timezone used for package Calendar
operations. See 9.6(24).
The timezone used by package Calendar is the current system timezone
setting for local time, as accessed by the C library function
localtime.
26. Any limit on delay_until_statements of
select_statements. See 9.6(29).
There are no such limits.
27. Whether or not two nonoverlapping parts of a composite
object are independently addressable, in the case where packing, record
layout, or Component_Size is specified for the object. See
9.10(1).
Separate components are independently addressable if they do not share
overlapping storage units.
28. The representation for a compilation. See 10.1(2). A compilation is represented by a sequence of files presented to the compiler in a single invocation of the `gcc' command.
29. Any restrictions on compilations that contain multiple compilation_units. See 10.1(4). No single file can contain more than one compilation unit, but any sequence of files can be presented to the compiler as a single compilation.
30. The mechanisms for creating an environment and for adding and replacing compilation units. See 10.1.4(3). See separate section on compilation model.
31. The manner of explicitly assigning library units to a partition. See 10.2(2). See separate section on binding and linking programs.
32. The implementation-defined means, if any, of specifying which compilation units are needed by a given compilation unit. See 10.2(2). See separate section on compilation unit.
33. The manner of designating the main subprogram of a partition. See 10.2(7). The main program is designated by providing the name of the corresponding ali file as the input parameter to the binder.
34. The order of elaboration of library_items. See
10.2(18).
The first constraint on ordering is that it meets the requirements of
chapter 10 of the Ada 95 Reference Manual. This still leaves some
implementation dependent choices, which are resolved by first
elaborating bodies as early as possible (i.e. in preference to specs
where there is a choice), and second by evaluating the immediate with
clauses of a unit to determine the probably best choice, and
third by elaborating in alphabetical order of unit names
where a choice still remains.
35. Parameter passing and function return for the main subprogram. See 10.2(21). The main program has no parameters. It may be a procedure, or a function returning an integer type. In the latter case, the returned integer value is the return code of the program.
36. The mechanisms for building and running partitions. See 10.2(24). GNAT itself supports programs with only a single partition. The GNATDIST tool provided with the GLADE package (which also includes an implementation of the PCS) provides a completely flexible method for building and running programs consisting of multiple partitions. See the separate GLADE manual for details.
37. The details of program execution, including program termination. See 10.2(25). See separate section on compilation model.
38. The semantics of any nonactive partitions supported by the implementation. See 10.2(28). Passive partitions are supported on targets where shared memory is provided by the operating system. See the GLADE reference manual for further details.
39. The information returned by Exception_Message. See
11.4.1(10).
Exception message returns the null string unless a specific message has
been passed by the program.
40. The result of Exceptions.Exception_Name for types
declared within an unnamed block_statement. See 11.4.1(12).
Blocks have implementation defined names of the form Bnnn
where nnn is an integer.
41. The information returned by
Exception_Information. See 11.4.1(13).
Exception_Information contains the expanded name of the exception
in upper case, and no other information.
42. Implementation-defined check names. See 11.5(27). No implementation-defined check names are supported.
43. The interpretation of each aspect of representation. See 13.1(20). See separate section on data representations.
44. Any restrictions placed upon representation items. See 13.1(20). See separate section on data representations.
45. The meaning of Size for indefinite subtypes. See
13.3(48).
Size for an indefinite subtype is the maximum possible size, except that
for the case of a subprogram parameter, the size of the parameter object
is the actual size.
46. The default external representation for a type tag. See 13.3(75). The default external representation for a type tag is the fully expanded name of the type in upper case letters.
47. What determines whether a compilation unit is the same in two different partitions. See 13.3(76). A compilation unit is the same in two different partitions if and only if it derives from the same source file.
48. Implementation-defined components. See 13.5.1(15). The only implementation defined component is the tag for a tagged type, which contains a pointer to the dispatching table.
49. If Word_Size = Storage_Unit, the default bit
ordering. See 13.5.3(5).
Word_Size (32) is not the same as Storage_Unit (8) for this
implementation, so no non-default bit ordering is supported. The default
bit ordering corresponds to the natural endianness of the target architecture.
50. The contents of the visible part of package System
and its language-defined children. See 13.7(2).
See the definition of these packages in files `system.ads' and
`s-stoele.ads'.
51. The contents of the visible part of package
System.Machine_Code, and the meaning of
code_statements. See 13.8(7).
See the definition and documentation in file `s-maccod.ads'.
52. The effect of unchecked conversion. See 13.9(11). Unchecked conversion between types of the same size and results in an uninterpreted transmission of the bits from one type to the other. If the types are of unequal sizes, then in the case of discrete types, a shorter source is first zero or sign extended as necessary, and a shorter target is simply truncated on the left. For all non-discrete types, the source is first copied if necessary to ensure that the alignment requirements of the target are met, then a pointer is constructed to the source value, and the result is obtained by dereferencing this pointer after converting it to be a pointer to the target type.
53. The manner of choosing a storage pool for an access type
when Storage_Pool is not specified for the type. See 13.11(17).
See documentation in the runtime library unit System.GNAT_Pools
in library file `s-gnapoo.ads' for full details on the default
pools used.
54. Whether or not the implementation provides user-accessible
names for the standard pool type(s). See 13.11(17).
See documentation in the runtime library unit System.GNAT_Pools
in library file `s-gnapoo.ads' for full details on the names for
standard pool types. All these pools are accessible by means of
with'ing this unit.
55. The meaning of Storage_Size. See 13.11(18).
Storage_Size is measured in storage units, and refers to the
total space available for an access type collection, or to the primary
stack space for a task.
56. Implementation-defined aspects of storage pools. See
13.11(22).
See documentation in the runtime library unit System.GNAT_Pools
in library file `s-gnapoo.ads' for details on GNAT-defined aspects
of storage pools.
57. The set of restrictions allowed in a pragma
Restrictions. See 13.12(7).
All RM defined Restriction identifiers are implemented, and in addition
the restrictions No_Implementation_Attributes and No_Implementation_Pragmas,
which provide compile time checking that, respectively, no
GNAT-defined attributes or GNAT-defined pragmas are permitted.
58. The consequences of violating limitations on
Restrictions pragmas. See 13.12(9).
Restrictions that can be checked at compile time result in illegalities
if violated. Currently there are no other consequences of violating
restrictions.
59. The representation used by the Read and
Write attributes of elementary types in terms of stream
elements. See 13.13.2(9).
The representation is the in-memory representation of the base type of
the type, using the number of bits corresponding to the
type'Size value, and the natural ordering of the machine.
60. The names and characteristics of the numeric subtypes
declared in the visible part of package Standard. See A.1(3).
See items describing the integer and floating-point types supported.
61. The accuracy actually achieved by the elementary functions. See A.5.1(1). The elementary functions correspond to the functions available in the C library. Only fast math mode is implemented.
62. The sign of a zero result from some of the operators or
functions in Numerics.Generic_Elementary_Functions, when
Float_Type'Signed_Zeros is True. See A.5.1(46).
The sign of zeroes follows the requirements of the IEEE 754 standard on
floating-point.
63. The value of
Numerics.Float_Random.Max_Image_Width. See A.5.2(27).
Maximum image width is 649, see library file `a-numran.ads'.
64. The value of
Numerics.Discrete_Random.Max_Image_Width. See A.5.2(27).
Maximum image width is 80, see library file `a-nudira.ads'.
65. The algorithms for random number generation. See A.5.2(32). The algorithm is documented in the source files `a-numran.ads' and `a-numran.adb'.
66. The string representation of a random number generator's state. See A.5.2(38). See the documentation contained in the file `a-numran.adb'.
67. The minimum time interval between calls to the time-dependent Reset procedure that are guaranteed to initiate different random number sequences. See A.5.2(45). The minimum period between reset calls to guarantee distinct series of random numbers is one microsecond.
68. The values of the Model_Mantissa,
Model_Emin, Model_Epsilon, Model,
Safe_First, and Safe_Last attributes, if the Numerics
Annex is not supported. See A.5.3(72).
See the source file `ttypef.ads' for the values of all numeric
attributes.
69. Any implementation-defined characteristics of the input-output packages. See A.7(14). There are no special implementation defined characteristics for these packages.
70. The value of Buffer_Size in Storage_IO. See
A.9(10).
All type representations are contiguous, and the Buffer_Size is
the value of type'Size rounded up to the next storage unit
boundary.
71. External files for standard input, standard output, and standard error See A.10(5). These files are mapped onto the files provided by the C streams libraries. See source file `i-cstrea.ads' for further details.
72. The accuracy of the value produced by Put. See
A.10.9(36).
If more digits are requested in the output than are represented by the
precision of the value, zeroes are output in the corresponding least
significant digit positions.
73. The meaning of Argument_Count, Argument, and
Command_Name. See A.15(1).
These are mapped onto the argv and argc parameters of the
main program in the natural manner.
74. Implementation-defined convention names. See B.1(11). The following convention names are supported
Ada
Asm
Assembler
C
C_Pass_By_Copy
COBOL
CPP
Default
External
Fortran
Intrinsic
Stdcall
In addition, all otherwise unrecognized convention names are also treated as being synonymous with convention C. In all implementations except for VMS, use of such other names results in a warning. In VMS implementations, these names are accepted silently.
75. The meaning of link names. See B.1(36). Link names are the actual names used by the linker.
76. The manner of choosing link names when neither the link name nor the address of an imported or exported entity is specified. See B.1(36). The default linker name is that which would be assigned by the relevant external language, interpreting the Ada name as being in all lower case letters.
77. The effect of pragma Linker_Options. See B.1(37).
The string passed to Linker_Options is presented uninterpreted as
an argument to the link command.
78. The contents of the visible part of package
Interfaces and its language-defined descendants. See B.2(1).
See files with prefix `i-' in the distributed library.
79. Implementation-defined children of package
Interfaces. The contents of the visible part of package
Interfaces. See B.2(11).
See files with prefix `i-' in the distributed library.
80. The types Floating, Long_Floating,
Binary, Long_Binary, Decimal_ Element, and
COBOL_Character; and the initialization of the variables
Ada_To_COBOL and COBOL_To_Ada, in
Interfaces.COBOL. See B.4(50).
Floating
Long_Floating
Binary
Long_Binary
Decimal_Element
COBOL_Character
For initialization, see the file `i-cobol.ads' in the distributed library.
81. Support for access to machine instructions. See C.1(1). See documentation in file `s-maccod.ads' in the distributed library.
82. Implementation-defined aspects of access to machine operations. See C.1(9). See documentation in file `s-maccod.ads' in the distributed library.
83. Implementation-defined aspects of interrupts. See C.3(2).
Interrupts are mapped to Unix signals. See definition of unit
Ada.Interrupt_Names in source file `a-intnam.ads'.
84. Implementation-defined aspects of pre-elaboration. See C.4(13). GNAT does not permit a partition to be restarted without reloading, except under control of the debugger.
85. The semantics of pragma Discard_Names. See C.5(7).
Pragma Discard_Names is currently ignored.
86. The result of the Task_Identification.Image
attribute. See C.7.1(7).
The result of this attribute is an 8-digit hexadecimal string
representing the virtual address of the task control block.
87. The value of Current_Task when in a protected entry
or interrupt handler. See C.7.1(17).
Protected entries or interrupt handlers can be executed by any
convenient thread,