@setfilename gnat_rm.info
@documentencoding UTF-8
@ifinfo
-@*Generated by Sphinx 4.3.2.@*
+@*Generated by Sphinx 5.3.0.@*
@end ifinfo
@settitle GNAT Reference Manual
@defindex ge
* gnat_rm: (gnat_rm.info). gnat_rm
@end direntry
-@definfoenclose strong,`,'
-@definfoenclose emph,`,'
@c %**end of header
@copying
@quotation
-GNAT Reference Manual , Dec 14, 2023
+GNAT Reference Manual , Dec 21, 2023
AdaCore
@c %**start of body
@anchor{gnat_rm doc}@anchor{0}
-@emph{GNAT, The GNU Ada Development Environment}
+`GNAT, The GNU Ada Development Environment'
@include gcc-common.texi
* Pragma Ada_2022::
* Pragma Aggregate_Individually_Assign::
* Pragma Allow_Integer_Address::
+* Pragma Always_Terminates::
* Pragma Annotate::
* Pragma Assert::
* Pragma Assert_And_Cut::
Implementation Defined Aspects
* Aspect Abstract_State::
+* Aspect Always_Terminates::
* Aspect Annotate::
* Aspect Async_Readers::
* Aspect Async_Writers::
By default, GNAT assumes Ada 2012,
but you can override with a compiler switch
to explicitly specify the language version.
-(Please refer to the @emph{GNAT User’s Guide} for details on these switches.)
+(Please refer to the `GNAT User’s Guide' for details on these switches.)
Throughout this manual, references to ‘Ada’ without a year suffix
apply to all the Ada versions of the language.
@code{Variables}
@item
-@emph{Emphasis}
+`Emphasis'
@item
[optional information or parameters]
* Pragma Ada_2022::
* Pragma Aggregate_Individually_Assign::
* Pragma Allow_Integer_Address::
+* Pragma Always_Terminates::
* Pragma Annotate::
* Pragma Assert::
* Pragma Assert_And_Cut::
this behavior so that record aggregates are instead always converted into
individual assignment statements.
-@node Pragma Allow_Integer_Address,Pragma Annotate,Pragma Aggregate_Individually_Assign,Implementation Defined Pragmas
+@node Pragma Allow_Integer_Address,Pragma Always_Terminates,Pragma Aggregate_Individually_Assign,Implementation Defined Pragmas
@anchor{gnat_rm/implementation_defined_pragmas pragma-allow-integer-address}@anchor{27}
@section Pragma Allow_Integer_Address
rather than rejected to allow common sets of sources to be used
in the two situations.
-@node Pragma Annotate,Pragma Assert,Pragma Allow_Integer_Address,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id3}@anchor{28}@anchor{gnat_rm/implementation_defined_pragmas pragma-annotate}@anchor{29}
+@node Pragma Always_Terminates,Pragma Annotate,Pragma Allow_Integer_Address,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id3}@anchor{28}@anchor{gnat_rm/implementation_defined_pragmas pragma-always-terminates}@anchor{29}
+@section Pragma Always_Terminates
+
+
+Syntax:
+
+@example
+pragma Always_Terminates [ (boolean_EXPRESSION) ];
+@end example
+
+For the semantics of this pragma, see the entry for aspect @code{Always_Terminates}
+in the SPARK 2014 Reference Manual, section 7.1.2.
+
+@node Pragma Annotate,Pragma Assert,Pragma Always_Terminates,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id4}@anchor{2a}@anchor{gnat_rm/implementation_defined_pragmas pragma-annotate}@anchor{2b}
@section Pragma Annotate
a configuration pragma.
@node Pragma Assert,Pragma Assert_And_Cut,Pragma Annotate,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-assert}@anchor{2a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assert}@anchor{2c}
@section Pragma Assert
from this standard type.
Assert checks can be either checked or ignored. By default they are ignored.
-They will be checked if either the command line switch @emph{-gnata} is
+They will be checked if either the command line switch `-gnata' is
used, or if an @code{Assertion_Policy} or @code{Check_Policy} pragma is used
to enable @code{Assert_Checks}.
addition.
@node Pragma Assert_And_Cut,Pragma Assertion_Policy,Pragma Assert,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-assert-and-cut}@anchor{2b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assert-and-cut}@anchor{2d}
@section Pragma Assert_And_Cut
documentation.
@node Pragma Assertion_Policy,Pragma Assume,Pragma Assert_And_Cut,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-assertion-policy}@anchor{2c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assertion-policy}@anchor{2e}
@section Pragma Assertion_Policy
the corresponding pragma or aspect is activated.
If the policy is @code{IGNORE}, then assertions are ignored, i.e.
the corresponding pragma or aspect is deactivated.
-This pragma overrides the effect of the @emph{-gnata} switch on the
+This pragma overrides the effect of the `-gnata' switch on the
command line.
If the policy is @code{SUPPRESSIBLE}, then assertions are enabled by default,
-however, if the @emph{-gnatp} switch is specified all assertions are ignored.
+however, if the `-gnatp' switch is specified all assertions are ignored.
The implementation defined policy @code{DISABLE} is like
@code{IGNORE} except that it completely disables semantic
@code{Assume}, @code{Loop_Invariant}, and @code{Loop_Variant}.
@node Pragma Assume,Pragma Assume_No_Invalid_Values,Pragma Assertion_Policy,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-assume}@anchor{2d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assume}@anchor{2f}
@section Pragma Assume
reference to information outside the program.
@node Pragma Assume_No_Invalid_Values,Pragma Async_Readers,Pragma Assume,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-assume-no-invalid-values}@anchor{2e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assume-no-invalid-values}@anchor{30}
@section Pragma Assume_No_Invalid_Values
case, and it is recommended that these two options not be used together.
@node Pragma Async_Readers,Pragma Async_Writers,Pragma Assume_No_Invalid_Values,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id4}@anchor{2f}@anchor{gnat_rm/implementation_defined_pragmas pragma-async-readers}@anchor{30}
+@anchor{gnat_rm/implementation_defined_pragmas id5}@anchor{31}@anchor{gnat_rm/implementation_defined_pragmas pragma-async-readers}@anchor{32}
@section Pragma Async_Readers
the SPARK 2014 Reference Manual, section 7.1.2.
@node Pragma Async_Writers,Pragma Attribute_Definition,Pragma Async_Readers,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id5}@anchor{31}@anchor{gnat_rm/implementation_defined_pragmas pragma-async-writers}@anchor{32}
+@anchor{gnat_rm/implementation_defined_pragmas id6}@anchor{33}@anchor{gnat_rm/implementation_defined_pragmas pragma-async-writers}@anchor{34}
@section Pragma Async_Writers
the SPARK 2014 Reference Manual, section 7.1.2.
@node Pragma Attribute_Definition,Pragma C_Pass_By_Copy,Pragma Async_Writers,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-attribute-definition}@anchor{33}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-attribute-definition}@anchor{35}
@section Pragma Attribute_Definition
compilable with earlier compilers.
@node Pragma C_Pass_By_Copy,Pragma Check,Pragma Attribute_Definition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-c-pass-by-copy}@anchor{34}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-c-pass-by-copy}@anchor{36}
@section Pragma C_Pass_By_Copy
passing mechanisms on a parameter by parameter basis.
@node Pragma Check,Pragma Check_Float_Overflow,Pragma C_Pass_By_Copy,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-check}@anchor{35}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-check}@anchor{37}
@section Pragma Check
refers to the normal set of pragma @code{Assert} statements.
Checks introduced by this pragma are normally deactivated by default. They can
-be activated either by the command line option @emph{-gnata}, which turns on
+be activated either by the command line option `-gnata', which turns on
all checks, or individually controlled using pragma @code{Check_Policy}.
The identifiers @code{Assertions} and @code{Statement_Assertions} are not
pragmas, where they are used to refer to sets of assertions.
@node Pragma Check_Float_Overflow,Pragma Check_Name,Pragma Check,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-check-float-overflow}@anchor{36}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-check-float-overflow}@anchor{38}
@section Pragma Check_Float_Overflow
In Ada, the predefined floating-point types (@code{Short_Float},
@code{Float}, @code{Long_Float}, @code{Long_Long_Float}) are
-defined to be @emph{unconstrained}. This means that even though each
+defined to be `unconstrained'. This means that even though each
has a well-defined base range, an operation that delivers a result
outside this base range is not required to raise an exception.
This implementation permission accommodates the notion
exception is raised if the result is out of range.
This mode can also be set by use of the compiler
-switch @emph{-gnateF}.
+switch `-gnateF'.
@node Pragma Check_Name,Pragma Check_Policy,Pragma Check_Float_Overflow,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-check-name}@anchor{37}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-check-name}@anchor{39}
@section Pragma Check_Name
switches (in particular -gnatp) in the usual manner.
@node Pragma Check_Policy,Pragma Comment,Pragma Check_Name,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-check-policy}@anchor{38}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-check-policy}@anchor{3a}
@section Pragma Check_Policy
The check policy is @code{OFF} to turn off corresponding checks, and @code{ON}
to turn on corresponding checks. The default for a set of checks for which no
@code{Check_Policy} is given is @code{OFF} unless the compiler switch
-@emph{-gnata} is given, which turns on all checks by default.
+`-gnata' is given, which turns on all checks by default.
The check policy settings @code{CHECK} and @code{IGNORE} are recognized
as synonyms for @code{ON} and @code{OFF}. These synonyms are provided for
@code{Check} pragma to be completely ignored and not analyzed.
@node Pragma Comment,Pragma Common_Object,Pragma Check_Policy,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-comment}@anchor{39}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-comment}@anchor{3b}
@section Pragma Comment
is used, all comments are retained.
@node Pragma Common_Object,Pragma Compile_Time_Error,Pragma Comment,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-common-object}@anchor{3a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-common-object}@anchor{3c}
@section Pragma Common_Object
pragma is not available.
@node Pragma Compile_Time_Error,Pragma Compile_Time_Warning,Pragma Common_Object,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas compile-time-error}@anchor{3b}@anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-error}@anchor{3c}
+@anchor{gnat_rm/implementation_defined_pragmas compile-time-error}@anchor{3d}@anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-error}@anchor{3e}
@section Pragma Compile_Time_Error
embedded ASCII.LF characters to break the message into multiple lines.
@node Pragma Compile_Time_Warning,Pragma Complete_Representation,Pragma Compile_Time_Error,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-warning}@anchor{3d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-warning}@anchor{3f}
@section Pragma Compile_Time_Warning
@end example
Same as pragma Compile_Time_Error, except a warning is issued instead
-of an error message. If switch @emph{-gnatw_C} is used, a warning is only issued
+of an error message. If switch `-gnatw_C' is used, a warning is only issued
if the value of the expression is known to be True at compile time, not when
the value of the expression is not known at compile time.
Note that if this pragma is used in a package that
with a first parameter of True is to warn a client about use of a package,
for example that it is not fully implemented.
-In previous versions of the compiler, combining @emph{-gnatwe} with
+In previous versions of the compiler, combining `-gnatwe' with
Compile_Time_Warning resulted in a fatal error. Now the compiler always emits
-a warning. You can use @ref{3b,,Pragma Compile_Time_Error} to force the generation of
+a warning. You can use @ref{3d,,Pragma Compile_Time_Error} to force the generation of
an error.
@node Pragma Complete_Representation,Pragma Complex_Representation,Pragma Compile_Time_Warning,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-complete-representation}@anchor{3e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-complete-representation}@anchor{40}
@section Pragma Complete_Representation
added to the record in the future.
@node Pragma Complex_Representation,Pragma Component_Alignment,Pragma Complete_Representation,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-complex-representation}@anchor{3f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-complex-representation}@anchor{41}
@section Pragma Complex_Representation
this type in floating-point registers.
@node Pragma Component_Alignment,Pragma Constant_After_Elaboration,Pragma Complex_Representation,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-component-alignment}@anchor{40}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-component-alignment}@anchor{42}
@section Pragma Component_Alignment
@table @asis
-@item @emph{Component_Size}
+@item `Component_Size'
Aligns scalar components and subcomponents of the array or record type
on boundaries appropriate to their inherent size (naturally
@geindex Component_Size_4 (in pragma Component_Alignment)
-@item @emph{Component_Size_4}
+@item `Component_Size_4'
Naturally aligns components with a size of four or fewer
bytes. Components that are larger than 4 bytes are placed on the next
@geindex Storage_Unit (in pragma Component_Alignment)
-@item @emph{Storage_Unit}
+@item `Storage_Unit'
Specifies that array or record components are byte aligned, i.e.,
aligned on boundaries determined by the value of the constant
@geindex Default (in pragma Component_Alignment)
-@item @emph{Default}
+@item `Default'
Specifies that array or record components are aligned on default
boundaries, appropriate to the underlying hardware or operating system or
clause), the GNAT uses the default alignment as described previously.
@node Pragma Constant_After_Elaboration,Pragma Contract_Cases,Pragma Component_Alignment,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id6}@anchor{41}@anchor{gnat_rm/implementation_defined_pragmas pragma-constant-after-elaboration}@anchor{42}
+@anchor{gnat_rm/implementation_defined_pragmas id7}@anchor{43}@anchor{gnat_rm/implementation_defined_pragmas pragma-constant-after-elaboration}@anchor{44}
@section Pragma Constant_After_Elaboration
@code{Constant_After_Elaboration} in the SPARK 2014 Reference Manual, section 3.3.1.
@node Pragma Contract_Cases,Pragma Convention_Identifier,Pragma Constant_After_Elaboration,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id7}@anchor{43}@anchor{gnat_rm/implementation_defined_pragmas pragma-contract-cases}@anchor{44}
+@anchor{gnat_rm/implementation_defined_pragmas id8}@anchor{45}@anchor{gnat_rm/implementation_defined_pragmas pragma-contract-cases}@anchor{46}
@section Pragma Contract_Cases
returns.
@node Pragma Convention_Identifier,Pragma CPP_Class,Pragma Contract_Cases,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-convention-identifier}@anchor{45}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-convention-identifier}@anchor{47}
@section Pragma Convention_Identifier
would be used system-wide.
@node Pragma CPP_Class,Pragma CPP_Constructor,Pragma Convention_Identifier,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-class}@anchor{46}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-class}@anchor{48}
@section Pragma CPP_Class
limited if not explicitly declared as limited or derived from a limited
type, and an error is issued in that case.
-See @ref{47,,Interfacing to C++} for related information.
+See @ref{49,,Interfacing to C++} for related information.
Note: Pragma @code{CPP_Class} is currently obsolete. It is supported
for backward compatibility but its functionality is available
using pragma @code{Import} with @code{Convention} = @code{CPP}.
@node Pragma CPP_Constructor,Pragma CPP_Virtual,Pragma CPP_Class,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-constructor}@anchor{48}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-constructor}@anchor{4a}
@section Pragma CPP_Constructor
@itemize *
@item
-@strong{function} @code{Fname} @strong{return} T`
+`function' @code{Fname} `return' T`
@item
-@strong{function} @code{Fname} @strong{return} T’Class
+`function' @code{Fname} `return' T’Class
@item
-@strong{function} @code{Fname} (…) @strong{return} T`
+`function' @code{Fname} (…) `return' T`
@item
-@strong{function} @code{Fname} (…) @strong{return} T’Class
+`function' @code{Fname} (…) `return' T’Class
@end itemize
where @code{T} is a limited record type imported from C++ with pragma
Pragma @code{CPP_Constructor} is intended primarily for automatic generation
using an automatic binding generator tool (such as the @code{-fdump-ada-spec}
GCC switch).
-See @ref{47,,Interfacing to C++} for more related information.
+See @ref{49,,Interfacing to C++} for more related information.
Note: The use of functions returning class-wide types for constructors is
currently obsolete. They are supported for backward compatibility. The
that is, they never return an object whose type is a descendant of type T.
@node Pragma CPP_Virtual,Pragma CPP_Vtable,Pragma CPP_Constructor,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-virtual}@anchor{49}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-virtual}@anchor{4b}
@section Pragma CPP_Virtual
is no longer required for that purpose because GNAT generates
the same object layout as the G++ compiler by default.
-See @ref{47,,Interfacing to C++} for related information.
+See @ref{49,,Interfacing to C++} for related information.
@node Pragma CPP_Vtable,Pragma CPU,Pragma CPP_Virtual,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-vtable}@anchor{4a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-vtable}@anchor{4c}
@section Pragma CPP_Vtable
is no longer required for that purpose because GNAT generates
the same object layout as the G++ compiler by default.
-See @ref{47,,Interfacing to C++} for related information.
+See @ref{49,,Interfacing to C++} for related information.
@node Pragma CPU,Pragma Deadline_Floor,Pragma CPP_Vtable,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-cpu}@anchor{4b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpu}@anchor{4d}
@section Pragma CPU
See Ada 2012 Reference Manual for details.
@node Pragma Deadline_Floor,Pragma Debug,Pragma CPU,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-deadline-floor}@anchor{4c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-deadline-floor}@anchor{4e}
@section Pragma Deadline_Floor
It is effective only when the EDF scheduling policy is used.
@node Pragma Debug,Pragma Debug_Policy,Pragma Deadline_Floor,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-debug}@anchor{4d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-debug}@anchor{4f}
@section Pragma Debug
corresponding to the argument with a terminating semicolon. Pragmas are
permitted in sequences of declarations, so you can use pragma @code{Debug} to
intersperse calls to debug procedures in the middle of declarations. Debug
-pragmas can be enabled either by use of the command line switch @emph{-gnata}
+pragmas can be enabled either by use of the command line switch `-gnata'
or by use of the pragma @code{Check_Policy} with a first argument of
@code{Debug}.
@node Pragma Debug_Policy,Pragma Default_Initial_Condition,Pragma Debug,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-debug-policy}@anchor{4e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-debug-policy}@anchor{50}
@section Pragma Debug_Policy
compatibility reasons.
@node Pragma Default_Initial_Condition,Pragma Default_Scalar_Storage_Order,Pragma Debug_Policy,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id8}@anchor{4f}@anchor{gnat_rm/implementation_defined_pragmas pragma-default-initial-condition}@anchor{50}
+@anchor{gnat_rm/implementation_defined_pragmas id9}@anchor{51}@anchor{gnat_rm/implementation_defined_pragmas pragma-default-initial-condition}@anchor{52}
@section Pragma Default_Initial_Condition
@code{Default_Initial_Condition} in the SPARK 2014 Reference Manual, section 7.3.3.
@node Pragma Default_Scalar_Storage_Order,Pragma Default_Storage_Pool,Pragma Default_Initial_Condition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-default-scalar-storage-order}@anchor{51}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-default-scalar-storage-order}@anchor{53}
@section Pragma Default_Scalar_Storage_Order
end DSSO1;
@end example
-In this example record types with names starting with @emph{L} have @cite{Low_Order_First} scalar
-storage order, and record types with names starting with @emph{H} have @code{High_Order_First}.
+In this example record types with names starting with `L' have @cite{Low_Order_First} scalar
+storage order, and record types with names starting with `H' have @code{High_Order_First}.
Note that in the case of @code{H4a}, the order is not inherited
from the parent type. Only an explicitly set @code{Scalar_Storage_Order}
gets inherited on type derivation.
the default scalar storage order ought to be changed only on a local basis.
@node Pragma Default_Storage_Pool,Pragma Depends,Pragma Default_Scalar_Storage_Order,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-default-storage-pool}@anchor{52}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-default-storage-pool}@anchor{54}
@section Pragma Default_Storage_Pool
See Ada 2012 Reference Manual for details.
@node Pragma Depends,Pragma Detect_Blocking,Pragma Default_Storage_Pool,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id9}@anchor{53}@anchor{gnat_rm/implementation_defined_pragmas pragma-depends}@anchor{54}
+@anchor{gnat_rm/implementation_defined_pragmas id10}@anchor{55}@anchor{gnat_rm/implementation_defined_pragmas pragma-depends}@anchor{56}
@section Pragma Depends
SPARK 2014 Reference Manual, section 6.1.5.
@node Pragma Detect_Blocking,Pragma Disable_Atomic_Synchronization,Pragma Depends,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-detect-blocking}@anchor{55}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-detect-blocking}@anchor{57}
@section Pragma Detect_Blocking
if that happens.
@node Pragma Disable_Atomic_Synchronization,Pragma Dispatching_Domain,Pragma Detect_Blocking,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-disable-atomic-synchronization}@anchor{56}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-disable-atomic-synchronization}@anchor{58}
@section Pragma Disable_Atomic_Synchronization
the action applies only to that entity.
@node Pragma Dispatching_Domain,Pragma Effective_Reads,Pragma Disable_Atomic_Synchronization,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-dispatching-domain}@anchor{57}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-dispatching-domain}@anchor{59}
@section Pragma Dispatching_Domain
See Ada 2012 Reference Manual for details.
@node Pragma Effective_Reads,Pragma Effective_Writes,Pragma Dispatching_Domain,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id10}@anchor{58}@anchor{gnat_rm/implementation_defined_pragmas pragma-effective-reads}@anchor{59}
+@anchor{gnat_rm/implementation_defined_pragmas id11}@anchor{5a}@anchor{gnat_rm/implementation_defined_pragmas pragma-effective-reads}@anchor{5b}
@section Pragma Effective_Reads
the SPARK 2014 Reference Manual, section 7.1.2.
@node Pragma Effective_Writes,Pragma Elaboration_Checks,Pragma Effective_Reads,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id11}@anchor{5a}@anchor{gnat_rm/implementation_defined_pragmas pragma-effective-writes}@anchor{5b}
+@anchor{gnat_rm/implementation_defined_pragmas id12}@anchor{5c}@anchor{gnat_rm/implementation_defined_pragmas pragma-effective-writes}@anchor{5d}
@section Pragma Effective_Writes
in the SPARK 2014 Reference Manual, section 7.1.2.
@node Pragma Elaboration_Checks,Pragma Eliminate,Pragma Effective_Writes,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-elaboration-checks}@anchor{5c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-elaboration-checks}@anchor{5e}
@section Pragma Elaboration_Checks
This is a configuration pragma which specifies the elaboration model to be
used during compilation. For more information on the elaboration models of
-GNAT, consult the chapter on elaboration order handling in the @emph{GNAT User’s
-Guide}.
+GNAT, consult the chapter on elaboration order handling in the `GNAT User’s
+Guide'.
The pragma may appear in the following contexts:
is in effect.
@node Pragma Eliminate,Pragma Enable_Atomic_Synchronization,Pragma Elaboration_Checks,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-eliminate}@anchor{5d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-eliminate}@anchor{5f}
@section Pragma Eliminate
@end quotation
@node Pragma Enable_Atomic_Synchronization,Pragma Export_Function,Pragma Eliminate,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-enable-atomic-synchronization}@anchor{5e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-enable-atomic-synchronization}@anchor{60}
@section Pragma Enable_Atomic_Synchronization
the action applies only to that entity.
@node Pragma Export_Function,Pragma Export_Object,Pragma Enable_Atomic_Synchronization,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-export-function}@anchor{5f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-export-function}@anchor{61}
@section Pragma Export_Function
still allows the specification of parameter mechanisms.
@node Pragma Export_Object,Pragma Export_Procedure,Pragma Export_Function,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-export-object}@anchor{60}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-export-object}@anchor{62}
@section Pragma Export_Object
but otherwise ignored by GNAT.
@node Pragma Export_Procedure,Pragma Export_Valued_Procedure,Pragma Export_Object,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-export-procedure}@anchor{61}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-export-procedure}@anchor{63}
@section Pragma Export_Procedure
still allows the specification of parameter mechanisms.
@node Pragma Export_Valued_Procedure,Pragma Extend_System,Pragma Export_Procedure,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-export-valued-procedure}@anchor{62}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-export-valued-procedure}@anchor{64}
@section Pragma Export_Valued_Procedure
still allows the specification of parameter mechanisms.
@node Pragma Extend_System,Pragma Extensions_Allowed,Pragma Export_Valued_Procedure,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-extend-system}@anchor{63}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-extend-system}@anchor{65}
@section Pragma Extend_System
implementation, provide many extensions to package @code{System}.
For each such implementation accommodated by this pragma, GNAT provides a
-package @code{Aux_@emph{xxx}}, e.g., @code{Aux_DEC} for the DEC Ada 83
+package @code{Aux_@var{xxx}}, e.g., @code{Aux_DEC} for the DEC Ada 83
implementation, which provides the required additional definitions. You
can use this package in two ways. You can @code{with} it in the normal
way and access entities either by selection or using a @code{use}
clause. In this case no special processing is required.
However, if existing code contains references such as
-@code{System.@emph{xxx}} where @emph{xxx} is an entity in the extended
+@code{System.@var{xxx}} where `xxx' is an entity in the extended
definitions provided in package @code{System}, you may use this pragma
to extend visibility in @code{System} in a non-standard way that
provides greater compatibility with the existing code. Pragma
the name of the package containing the extended definition
(e.g., @code{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 @code{System.Aux_@emph{xxx}} where
-@code{Aux_@emph{xxx}} is the pragma argument for any entity referenced in
+processing that looks in package @code{System.Aux_@var{xxx}} where
+@code{Aux_@var{xxx}} is the pragma argument for any entity referenced in
package @code{System}, but not found in package @code{System}.
You can use this pragma either to access a predefined @code{System}
you can construct your own extension unit following the above
definition. Note that such a package is a child of @code{System}
and thus is considered part of the implementation.
-To compile it you will have to use the @emph{-gnatg} switch
+To compile it you will have to use the `-gnatg' switch
for compiling System units, as explained in the
GNAT User’s Guide.
@node Pragma Extensions_Allowed,Pragma Extensions_Visible,Pragma Extend_System,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id12}@anchor{64}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-allowed}@anchor{65}
+@anchor{gnat_rm/implementation_defined_pragmas id13}@anchor{66}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-allowed}@anchor{67}
@section Pragma Extensions_Allowed
If an argument of @code{"On"} is specified, the latest version of the Ada language
is implemented (currently Ada 2022) and, in addition, a curated set of GNAT
specific extensions are recognized. (See the list here
-@ref{66,,here})
+@ref{68,,here})
An argument of @code{"All"} has the same effect except that some extra
experimental extensions are enabled (See the list here
-@ref{67,,here})
+@ref{69,,here})
@node Pragma Extensions_Visible,Pragma External,Pragma Extensions_Allowed,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id13}@anchor{68}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-visible}@anchor{69}
+@anchor{gnat_rm/implementation_defined_pragmas id14}@anchor{6a}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-visible}@anchor{6b}
@section Pragma Extensions_Visible
in the SPARK 2014 Reference Manual, section 6.1.7.
@node Pragma External,Pragma External_Name_Casing,Pragma Extensions_Visible,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-external}@anchor{6a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-external}@anchor{6c}
@section Pragma External
@code{Export} before the latter was standardized.
@node Pragma External_Name_Casing,Pragma Fast_Math,Pragma External,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-external-name-casing}@anchor{6b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-external-name-casing}@anchor{6d}
@section Pragma External_Name_Casing
to enforce the upper casing of all external symbols.
@node Pragma Fast_Math,Pragma Favor_Top_Level,Pragma External_Name_Casing,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-fast-math}@anchor{6c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-fast-math}@anchor{6e}
@section Pragma Fast_Math
@table @asis
-@item @emph{Complex Multiplication}
+@item `Complex Multiplication'
The normal simple formula for complex multiplication can result in intermediate
overflows for numbers near the end of the range. The Ada standard requires that
@end table
@node Pragma Favor_Top_Level,Pragma Finalize_Storage_Only,Pragma Fast_Math,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id14}@anchor{6d}@anchor{gnat_rm/implementation_defined_pragmas pragma-favor-top-level}@anchor{6e}
+@anchor{gnat_rm/implementation_defined_pragmas id15}@anchor{6f}@anchor{gnat_rm/implementation_defined_pragmas pragma-favor-top-level}@anchor{70}
@section Pragma Favor_Top_Level
targets for nested subprograms. See restriction @code{No_Implicit_Dynamic_Code}.
@node Pragma Finalize_Storage_Only,Pragma Float_Representation,Pragma Favor_Top_Level,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-finalize-storage-only}@anchor{6f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-finalize-storage-only}@anchor{71}
@section Pragma Finalize_Storage_Only
heap-allocated objects (see pragma @code{No_Heap_Finalization}).
@node Pragma Float_Representation,Pragma Ghost,Pragma Finalize_Storage_Only,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-float-representation}@anchor{70}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-float-representation}@anchor{72}
@section Pragma Float_Representation
@end itemize
@node Pragma Ghost,Pragma Global,Pragma Float_Representation,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id15}@anchor{71}@anchor{gnat_rm/implementation_defined_pragmas pragma-ghost}@anchor{72}
+@anchor{gnat_rm/implementation_defined_pragmas id16}@anchor{73}@anchor{gnat_rm/implementation_defined_pragmas pragma-ghost}@anchor{74}
@section Pragma Ghost
2014 Reference Manual, section 6.9.
@node Pragma Global,Pragma Ident,Pragma Ghost,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id16}@anchor{73}@anchor{gnat_rm/implementation_defined_pragmas pragma-global}@anchor{74}
+@anchor{gnat_rm/implementation_defined_pragmas id17}@anchor{75}@anchor{gnat_rm/implementation_defined_pragmas pragma-global}@anchor{76}
@section Pragma Global
SPARK 2014 Reference Manual, section 6.1.4.
@node Pragma Ident,Pragma Ignore_Pragma,Pragma Global,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ident}@anchor{75}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ident}@anchor{77}
@section Pragma Ident
for compatibility with other Ada compilers providing this pragma.
@node Pragma Ignore_Pragma,Pragma Implementation_Defined,Pragma Ident,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ignore-pragma}@anchor{76}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ignore-pragma}@anchor{78}
@section Pragma Ignore_Pragma
mode, or during porting of legacy code.
@node Pragma Implementation_Defined,Pragma Implemented,Pragma Ignore_Pragma,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-implementation-defined}@anchor{77}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-implementation-defined}@anchor{79}
@section Pragma Implementation_Defined
restriction.
@node Pragma Implemented,Pragma Implicit_Packing,Pragma Implementation_Defined,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-implemented}@anchor{78}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-implemented}@anchor{7a}
@section Pragma Implemented
the target’s overriding subprogram kind.
@node Pragma Implicit_Packing,Pragma Import_Function,Pragma Implemented,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-implicit-packing}@anchor{79}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-implicit-packing}@anchor{7b}
@section Pragma Implicit_Packing
declaration to compile without an explicit pragma Pack.
@node Pragma Import_Function,Pragma Import_Object,Pragma Implicit_Packing,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-import-function}@anchor{7a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-function}@anchor{7c}
@section Pragma Import_Function
is used.
@node Pragma Import_Object,Pragma Import_Procedure,Pragma Import_Function,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-import-object}@anchor{7b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-object}@anchor{7d}
@section Pragma Import_Object
GNAT.
@node Pragma Import_Procedure,Pragma Import_Valued_Procedure,Pragma Import_Object,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-import-procedure}@anchor{7c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-procedure}@anchor{7e}
@section Pragma Import_Procedure
@code{Result_Type} and @code{Result_Mechanism} are not permitted.
@node Pragma Import_Valued_Procedure,Pragma Independent,Pragma Import_Procedure,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-import-valued-procedure}@anchor{7d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-valued-procedure}@anchor{7f}
@section Pragma Import_Valued_Procedure
default convention is Ada, which is almost certainly not what is required.
@node Pragma Independent,Pragma Independent_Components,Pragma Import_Valued_Procedure,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-independent}@anchor{7e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-independent}@anchor{80}
@section Pragma Independent
tight packing).
@node Pragma Independent_Components,Pragma Initial_Condition,Pragma Independent,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-independent-components}@anchor{7f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-independent-components}@anchor{81}
@section Pragma Independent_Components
tight packing).
@node Pragma Initial_Condition,Pragma Initialize_Scalars,Pragma Independent_Components,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id17}@anchor{80}@anchor{gnat_rm/implementation_defined_pragmas pragma-initial-condition}@anchor{81}
+@anchor{gnat_rm/implementation_defined_pragmas id18}@anchor{82}@anchor{gnat_rm/implementation_defined_pragmas pragma-initial-condition}@anchor{83}
@section Pragma Initial_Condition
in the SPARK 2014 Reference Manual, section 7.1.6.
@node Pragma Initialize_Scalars,Pragma Initializes,Pragma Initial_Condition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-initialize-scalars}@anchor{82}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-initialize-scalars}@anchor{84}
@section Pragma Initialize_Scalars
Note that pragma @code{Initialize_Scalars} is particularly useful in conjunction
with the enhanced validity checking that is now provided in GNAT, which checks
for invalid values under more conditions. Using this feature (see description
-of the @emph{-gnatV} flag in the GNAT User’s Guide) in conjunction with pragma
+of the `-gnatV' flag in the GNAT User’s Guide) in conjunction with pragma
@code{Initialize_Scalars} provides a powerful new tool to assist in the detection
of problems caused by uninitialized variables.
GNAT User’s Guide) when using this pragma.
@node Pragma Initializes,Pragma Inline_Always,Pragma Initialize_Scalars,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id18}@anchor{83}@anchor{gnat_rm/implementation_defined_pragmas pragma-initializes}@anchor{84}
+@anchor{gnat_rm/implementation_defined_pragmas id19}@anchor{85}@anchor{gnat_rm/implementation_defined_pragmas pragma-initializes}@anchor{86}
@section Pragma Initializes
SPARK 2014 Reference Manual, section 7.1.5.
@node Pragma Inline_Always,Pragma Inline_Generic,Pragma Initializes,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id19}@anchor{85}@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-always}@anchor{86}
+@anchor{gnat_rm/implementation_defined_pragmas id20}@anchor{87}@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-always}@anchor{88}
@section Pragma Inline_Always
Similar to pragma @code{Inline} except that inlining is unconditional.
Inline_Always instructs the compiler to inline every direct call to the
subprogram or else to emit a compilation error, independently of any
-option, in particular @emph{-gnatn} or @emph{-gnatN} or the optimization level.
+option, in particular `-gnatn' or `-gnatN' or the optimization level.
It is an error to take the address or access of @code{NAME}. It is also an error to
apply this pragma to a primitive operation of a tagged type. Thanks to such
restrictions, the compiler is allowed to remove the out-of-line body of @code{NAME}.
@node Pragma Inline_Generic,Pragma Interface,Pragma Inline_Always,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-generic}@anchor{87}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-generic}@anchor{89}
@section Pragma Inline_Generic
generic instances.
@node Pragma Interface,Pragma Interface_Name,Pragma Inline_Generic,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-interface}@anchor{88}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interface}@anchor{8a}
@section Pragma Interface
Ada 83 compilers.
@node Pragma Interface_Name,Pragma Interrupt_Handler,Pragma Interface,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-interface-name}@anchor{89}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interface-name}@anchor{8b}
@section Pragma Interface_Name
least one of @code{External_Name} or @code{Link_Name}.
@node Pragma Interrupt_Handler,Pragma Interrupt_State,Pragma Interface_Name,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-handler}@anchor{8a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-handler}@anchor{8c}
@section Pragma Interrupt_Handler
as described in Annex C of the Ada Reference Manual.
@node Pragma Interrupt_State,Pragma Invariant,Pragma Interrupt_Handler,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-state}@anchor{8b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-state}@anchor{8d}
@section Pragma Interrupt_State
and in the case of the signal used to implement the @code{abort} statement.
@node Pragma Invariant,Pragma Keep_Names,Pragma Interrupt_State,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id20}@anchor{8c}@anchor{gnat_rm/implementation_defined_pragmas pragma-invariant}@anchor{8d}
+@anchor{gnat_rm/implementation_defined_pragmas id21}@anchor{8e}@anchor{gnat_rm/implementation_defined_pragmas pragma-invariant}@anchor{8f}
@section Pragma Invariant
of the Type_Invariant aspect.
@node Pragma Keep_Names,Pragma License,Pragma Invariant,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-keep-names}@anchor{8e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-keep-names}@anchor{90}
@section Pragma Keep_Names
want to retain the names for specific enumeration types.
@node Pragma License,Pragma Link_With,Pragma Keep_Names,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-license}@anchor{8f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-license}@anchor{91}
@section Pragma License
run time, and is therefore licensed under the modified GPL.
@node Pragma Link_With,Pragma Linker_Alias,Pragma License,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-link-with}@anchor{90}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-link-with}@anchor{92}
@section Pragma Link_With
multiple arguments, with the same effect as successive pragmas.
@node Pragma Linker_Alias,Pragma Linker_Constructor,Pragma Link_With,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-alias}@anchor{91}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-alias}@anchor{93}
@section Pragma Linker_Alias
@end example
@node Pragma Linker_Constructor,Pragma Linker_Destructor,Pragma Linker_Alias,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-constructor}@anchor{92}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-constructor}@anchor{94}
@section Pragma Linker_Constructor
to the use of this pragma.
@node Pragma Linker_Destructor,Pragma Linker_Section,Pragma Linker_Constructor,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-destructor}@anchor{93}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-destructor}@anchor{95}
@section Pragma Linker_Destructor
because of these specific contexts.
@node Pragma Linker_Section,Pragma Lock_Free,Pragma Linker_Destructor,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id21}@anchor{94}@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-section}@anchor{95}
+@anchor{gnat_rm/implementation_defined_pragmas id22}@anchor{96}@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-section}@anchor{97}
@section Pragma Linker_Section
@end example
@node Pragma Lock_Free,Pragma Loop_Invariant,Pragma Linker_Section,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id22}@anchor{96}@anchor{gnat_rm/implementation_defined_pragmas pragma-lock-free}@anchor{97}
+@anchor{gnat_rm/implementation_defined_pragmas id23}@anchor{98}@anchor{gnat_rm/implementation_defined_pragmas pragma-lock-free}@anchor{99}
@section Pragma Lock_Free
unit is executed.
@node Pragma Loop_Invariant,Pragma Loop_Optimize,Pragma Lock_Free,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-invariant}@anchor{98}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-invariant}@anchor{9a}
@section Pragma Loop_Invariant
pragma. For full details, see documentation of attribute @code{Loop_Entry}.
@node Pragma Loop_Optimize,Pragma Loop_Variant,Pragma Loop_Invariant,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-optimize}@anchor{99}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-optimize}@anchor{9b}
@section Pragma Loop_Optimize
These hints do not remove the need to pass the appropriate switches to the
compiler in order to enable the relevant optimizations, that is to say
-@emph{-funroll-loops} for unrolling and @emph{-ftree-vectorize} for
+`-funroll-loops' for unrolling and `-ftree-vectorize' for
vectorization.
@node Pragma Loop_Variant,Pragma Machine_Attribute,Pragma Loop_Optimize,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-variant}@anchor{9a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-variant}@anchor{9c}
@section Pragma Loop_Variant
@code{Loop_Variant} pragma to refer to values on entry to the loop.
@node Pragma Machine_Attribute,Pragma Main,Pragma Loop_Variant,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-machine-attribute}@anchor{9b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-machine-attribute}@anchor{9d}
@section Pragma Machine_Attribute
Machine-dependent attributes can be specified for types and/or
declarations. This pragma is semantically equivalent to
-@code{__attribute__((@emph{attribute_name}))} (if @code{info} is not
-specified) or @code{__attribute__((@emph{attribute_name(info})))}
-or @code{__attribute__((@emph{attribute_name(info,...})))} in GNU C,
-where @emph{attribute_name} is recognized by the compiler middle-end
+@code{__attribute__((@var{attribute_name}))} (if @code{info} is not
+specified) or @code{__attribute__((@var{attribute_name(info})))}
+or @code{__attribute__((@var{attribute_name(info,...})))} in GNU C,
+where `attribute_name' is recognized by the compiler middle-end
or the @code{TARGET_ATTRIBUTE_TABLE} machine specific macro. Note
that a string literal for the optional parameter @code{info} or the
following ones is transformed by default into an identifier,
For further information see @cite{GNU Compiler Collection (GCC) Internals}.
@node Pragma Main,Pragma Main_Storage,Pragma Machine_Attribute,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-main}@anchor{9c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-main}@anchor{9e}
@section Pragma Main
no effect in GNAT, other than being syntax checked.
@node Pragma Main_Storage,Pragma Max_Queue_Length,Pragma Main,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-main-storage}@anchor{9d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-main-storage}@anchor{9f}
@section Pragma Main_Storage
no effect in GNAT, other than being syntax checked.
@node Pragma Max_Queue_Length,Pragma No_Body,Pragma Main_Storage,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id23}@anchor{9e}@anchor{gnat_rm/implementation_defined_pragmas pragma-max-queue-length}@anchor{9f}
+@anchor{gnat_rm/implementation_defined_pragmas id24}@anchor{a0}@anchor{gnat_rm/implementation_defined_pragmas pragma-max-queue-length}@anchor{a1}
@section Pragma Max_Queue_Length
A value of -1 represents no additional restriction on queue length.
@node Pragma No_Body,Pragma No_Caching,Pragma Max_Queue_Length,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-no-body}@anchor{a0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-body}@anchor{a2}
@section Pragma No_Body
earlier versions of the package body.
@node Pragma No_Caching,Pragma No_Component_Reordering,Pragma No_Body,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id24}@anchor{a1}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-caching}@anchor{a2}
+@anchor{gnat_rm/implementation_defined_pragmas id25}@anchor{a3}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-caching}@anchor{a4}
@section Pragma No_Caching
the SPARK 2014 Reference Manual, section 7.1.2.
@node Pragma No_Component_Reordering,Pragma No_Elaboration_Code_All,Pragma No_Caching,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-no-component-reordering}@anchor{a3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-component-reordering}@anchor{a5}
@section Pragma No_Component_Reordering
that this pragma be used consistently within a partition.
@node Pragma No_Elaboration_Code_All,Pragma No_Heap_Finalization,Pragma No_Component_Reordering,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id25}@anchor{a4}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-elaboration-code-all}@anchor{a5}
+@anchor{gnat_rm/implementation_defined_pragmas id26}@anchor{a6}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-elaboration-code-all}@anchor{a7}
@section Pragma No_Elaboration_Code_All
It may be applied to package or subprogram specs or their generic versions.
@node Pragma No_Heap_Finalization,Pragma No_Inline,Pragma No_Elaboration_Code_All,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-no-heap-finalization}@anchor{a6}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-heap-finalization}@anchor{a8}
@section Pragma No_Heap_Finalization
appear at the library level.
@node Pragma No_Inline,Pragma No_Return,Pragma No_Heap_Finalization,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id26}@anchor{a7}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-inline}@anchor{a8}
+@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{a9}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-inline}@anchor{aa}
@section Pragma No_Inline
This pragma suppresses inlining for the callable entity or the instances of
the generic subprogram designated by @code{NAME}, including inlining that
results from the use of pragma @code{Inline}. This pragma is always active,
-in particular it is not subject to the use of option @emph{-gnatn} or
-@emph{-gnatN}. It is illegal to specify both pragma @code{No_Inline} and
+in particular it is not subject to the use of option `-gnatn' or
+`-gnatN'. It is illegal to specify both pragma @code{No_Inline} and
pragma @code{Inline_Always} for the same @code{NAME}.
@node Pragma No_Return,Pragma No_Strict_Aliasing,Pragma No_Inline,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-no-return}@anchor{a9}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-return}@anchor{ab}
@section Pragma No_Return
pragma.
@node Pragma No_Strict_Aliasing,Pragma No_Tagged_Streams,Pragma No_Return,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-no-strict-aliasing}@anchor{aa}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-strict-aliasing}@anchor{ac}
@section Pragma No_Strict_Aliasing
This pragma currently has no effects on access to unconstrained array types.
@node Pragma No_Tagged_Streams,Pragma Normalize_Scalars,Pragma No_Strict_Aliasing,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{ab}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{ac}
+@anchor{gnat_rm/implementation_defined_pragmas id28}@anchor{ad}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{ae}
@section Pragma No_Tagged_Streams
level but has a negative impact on the debuggability of tagged types.
@node Pragma Normalize_Scalars,Pragma Obsolescent,Pragma No_Tagged_Streams,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-normalize-scalars}@anchor{ad}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-normalize-scalars}@anchor{af}
@section Pragma Normalize_Scalars
@table @asis
-@item @emph{Standard.Character}
+@item `Standard.Character'
Objects whose root type is Standard.Character are initialized to
Character’Last unless the subtype range excludes NUL (in which case
NUL is used). This choice will always generate an invalid value if
one exists.
-@item @emph{Standard.Wide_Character}
+@item `Standard.Wide_Character'
Objects whose root type is Standard.Wide_Character are initialized to
Wide_Character’Last unless the subtype range excludes NUL (in which case
NUL is used). This choice will always generate an invalid value if
one exists.
-@item @emph{Standard.Wide_Wide_Character}
+@item `Standard.Wide_Wide_Character'
Objects whose root type is Standard.Wide_Wide_Character are initialized to
the invalid value 16#FFFF_FFFF# unless the subtype range excludes NUL (in
which case NUL is used). This choice will always generate an invalid value if
one exists.
-@item @emph{Integer types}
+@item `Integer types'
Objects of an integer type are treated differently depending on whether
negative values are present in the subtype. If no negative values are
the largest positive value is used. This choice will always generate
an invalid value if one exists.
-@item @emph{Floating-Point Types}
+@item `Floating-Point Types'
Objects of all floating-point types are initialized to all 1-bits. For
standard IEEE format, this corresponds to a NaN (not a number) which is
indeed an invalid value.
-@item @emph{Fixed-Point Types}
+@item `Fixed-Point Types'
Objects of all fixed-point types are treated as described above for integers,
with the rules applying to the underlying integer value used to represent
the fixed-point value.
-@item @emph{Modular types}
+@item `Modular types'
Objects of a modular type are initialized to all one bits, except in
the special case where zero is excluded from the subtype, in which
case all zero bits are used. This choice will always generate an
invalid value if one exists.
-@item @emph{Enumeration types}
+@item `Enumeration types'
Objects of an enumeration type are initialized to all one-bits, i.e., to
the value @code{2 ** typ'Size - 1} unless the subtype excludes the literal
@end table
@node Pragma Obsolescent,Pragma Optimize_Alignment,Pragma Normalize_Scalars,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id28}@anchor{ae}@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{af}
+@anchor{gnat_rm/implementation_defined_pragmas id29}@anchor{b0}@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{b1}
@section Pragma Obsolescent
argument is present, it must be preceded by @code{Message =>}.
@node Pragma Optimize_Alignment,Pragma Ordered,Pragma Obsolescent,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-optimize-alignment}@anchor{b0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-optimize-alignment}@anchor{b2}
@section Pragma Optimize_Alignment
pragma appears at the start of the file.
@node Pragma Ordered,Pragma Overflow_Mode,Pragma Optimize_Alignment,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ordered}@anchor{b1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ordered}@anchor{b3}
@section Pragma Ordered
For unordered enumeration types, it is generally a good idea if
clients avoid comparisons (other than equality or inequality) and
-explicit ranges. (A @emph{client} is a unit where the type is referenced,
+explicit ranges. (A `client' is a unit where the type is referenced,
other than the unit where the type is declared, its body, and its subunits.)
For example, if code buried in some client says:
if D < Wed then ...
@end example
-The pragma @emph{Ordered} is provided to mark enumeration types that
+The pragma `Ordered' is provided to mark enumeration types that
are conceptually ordered, alerting the reader that clients may depend
on the ordering. GNAT provides a pragma to mark enumerations as ordered
rather than one to mark them as unordered, since in our experience,
pragma @code{Ordered} in package @code{Standard}.
Normally pragma @code{Ordered} serves only as documentation and a guide for
-coding standards, but GNAT provides a warning switch @emph{-gnatw.u} that
+coding standards, but GNAT provides a warning switch `-gnatw.u' that
requests warnings for inappropriate uses (comparisons and explicit
subranges) for unordered types. If this switch is used, then any
enumeration type not marked with pragma @code{Ordered} will be considered
for the case of generic enumerated types.
For additional information please refer to the description of the
-@emph{-gnatw.u} switch in the GNAT User’s Guide.
+`-gnatw.u' switch in the GNAT User’s Guide.
@node Pragma Overflow_Mode,Pragma Overriding_Renamings,Pragma Ordered,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-overflow-mode}@anchor{b2}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-overflow-mode}@anchor{b4}
@section Pragma Overflow_Mode
overflow checking, but does not affect the overflow mode.
@node Pragma Overriding_Renamings,Pragma Part_Of,Pragma Overflow_Mode,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-overriding-renamings}@anchor{b3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-overriding-renamings}@anchor{b5}
@section Pragma Overriding_Renamings
declaration of the overriding operation.
@node Pragma Part_Of,Pragma Partition_Elaboration_Policy,Pragma Overriding_Renamings,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id29}@anchor{b4}@anchor{gnat_rm/implementation_defined_pragmas pragma-part-of}@anchor{b5}
+@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{b6}@anchor{gnat_rm/implementation_defined_pragmas pragma-part-of}@anchor{b7}
@section Pragma Part_Of
SPARK 2014 Reference Manual, section 7.2.6.
@node Pragma Partition_Elaboration_Policy,Pragma Passive,Pragma Part_Of,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-partition-elaboration-policy}@anchor{b6}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-partition-elaboration-policy}@anchor{b8}
@section Pragma Partition_Elaboration_Policy
See Ada 2012 Reference Manual for details.
@node Pragma Passive,Pragma Persistent_BSS,Pragma Partition_Elaboration_Policy,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-passive}@anchor{b7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-passive}@anchor{b9}
@section Pragma Passive
‘Passive Task Optimization’ in the GNAT Users Guide.
@node Pragma Persistent_BSS,Pragma Post,Pragma Passive,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{b8}@anchor{gnat_rm/implementation_defined_pragmas pragma-persistent-bss}@anchor{b9}
+@anchor{gnat_rm/implementation_defined_pragmas id31}@anchor{ba}@anchor{gnat_rm/implementation_defined_pragmas pragma-persistent-bss}@anchor{bb}
@section Pragma Persistent_BSS
then the pragma will be ignored. See also @code{pragma Linker_Section}.
@node Pragma Post,Pragma Postcondition,Pragma Persistent_BSS,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-post}@anchor{ba}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-post}@anchor{bc}
@section Pragma Post
(preceded only by other pragmas).
@node Pragma Postcondition,Pragma Post_Class,Pragma Post,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-postcondition}@anchor{bb}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-postcondition}@anchor{bd}
@section Pragma Postcondition
The postconditions are collected and automatically tested just
before any return (implicit or explicit) in the subprogram body.
A postcondition is only recognized if postconditions are active
-at the time the pragma is encountered. The compiler switch @emph{gnata}
+at the time the pragma is encountered. The compiler switch `gnata'
turns on all postconditions by default, and pragma @code{Check_Policy}
with an identifier of @code{Postcondition} can also be used to
control whether postconditions are active.
compatibility purposes.
@node Pragma Post_Class,Pragma Pre,Pragma Postcondition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-post-class}@anchor{bc}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-post-class}@anchor{be}
@section Pragma Post_Class
@code{Post_Class}.
@node Pragma Pre,Pragma Precondition,Pragma Post_Class,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-pre}@anchor{bd}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-pre}@anchor{bf}
@section Pragma Pre
(preceded only by other pragmas).
@node Pragma Precondition,Pragma Predicate,Pragma Pre,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-precondition}@anchor{be}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-precondition}@anchor{c0}
@section Pragma Precondition
compatibility purposes.
@node Pragma Predicate,Pragma Predicate_Failure,Pragma Precondition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id31}@anchor{bf}@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{c0}
+@anchor{gnat_rm/implementation_defined_pragmas id32}@anchor{c1}@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{c2}
@section Pragma Predicate
use of predicates should be avoided.
@node Pragma Predicate_Failure,Pragma Preelaborable_Initialization,Pragma Predicate,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate-failure}@anchor{c1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate-failure}@anchor{c3}
@section Pragma Predicate_Failure
@code{Predicate_Failure} aspect, and shares its restrictions and semantics.
@node Pragma Preelaborable_Initialization,Pragma Prefix_Exception_Messages,Pragma Predicate_Failure,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-preelaborable-initialization}@anchor{c2}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-preelaborable-initialization}@anchor{c4}
@section Pragma Preelaborable_Initialization
See Ada 2012 Reference Manual for details.
@node Pragma Prefix_Exception_Messages,Pragma Pre_Class,Pragma Preelaborable_Initialization,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-prefix-exception-messages}@anchor{c3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-prefix-exception-messages}@anchor{c5}
@section Pragma Prefix_Exception_Messages
@code{GNAT.Source_Info.Enclosing_Entity} and prepend the string manually.
@node Pragma Pre_Class,Pragma Priority_Specific_Dispatching,Pragma Prefix_Exception_Messages,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-pre-class}@anchor{c4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-pre-class}@anchor{c6}
@section Pragma Pre_Class
@code{Pre_Class}.
@node Pragma Priority_Specific_Dispatching,Pragma Profile,Pragma Pre_Class,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-priority-specific-dispatching}@anchor{c5}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-priority-specific-dispatching}@anchor{c7}
@section Pragma Priority_Specific_Dispatching
See Ada 2012 Reference Manual for details.
@node Pragma Profile,Pragma Profile_Warnings,Pragma Priority_Specific_Dispatching,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-profile}@anchor{c6}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-profile}@anchor{c8}
@section Pragma Profile
@end itemize
@node Pragma Profile_Warnings,Pragma Propagate_Exceptions,Pragma Profile,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-profile-warnings}@anchor{c7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-profile-warnings}@anchor{c9}
@section Pragma Profile_Warnings
of error messages.
@node Pragma Propagate_Exceptions,Pragma Provide_Shift_Operators,Pragma Profile_Warnings,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-propagate-exceptions}@anchor{c8}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-propagate-exceptions}@anchor{ca}
@section Pragma Propagate_Exceptions
a now-obsolete mechanism for implementation of exceptions.
@node Pragma Provide_Shift_Operators,Pragma Psect_Object,Pragma Propagate_Exceptions,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-provide-shift-operators}@anchor{c9}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-provide-shift-operators}@anchor{cb}
@section Pragma Provide_Shift_Operators
with the pragma Import (Intrinsic, …) statements.
@node Pragma Psect_Object,Pragma Pure_Function,Pragma Provide_Shift_Operators,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-psect-object}@anchor{ca}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-psect-object}@anchor{cc}
@section Pragma Psect_Object
This pragma is identical in effect to pragma @code{Common_Object}.
@node Pragma Pure_Function,Pragma Rational,Pragma Psect_Object,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id32}@anchor{cb}@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{cc}
+@anchor{gnat_rm/implementation_defined_pragmas id33}@anchor{cd}@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{ce}
@section Pragma Pure_Function
thus marked is free to @code{with} non-pure units.
@node Pragma Rational,Pragma Ravenscar,Pragma Pure_Function,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-rational}@anchor{cd}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-rational}@anchor{cf}
@section Pragma Rational
@end example
@node Pragma Ravenscar,Pragma Refined_Depends,Pragma Rational,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ravenscar}@anchor{ce}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ravenscar}@anchor{d0}
@section Pragma Ravenscar
which is the preferred method of setting the @code{Ravenscar} profile.
@node Pragma Refined_Depends,Pragma Refined_Global,Pragma Ravenscar,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id33}@anchor{cf}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{d0}
+@anchor{gnat_rm/implementation_defined_pragmas id34}@anchor{d1}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{d2}
@section Pragma Refined_Depends
the SPARK 2014 Reference Manual, section 6.1.5.
@node Pragma Refined_Global,Pragma Refined_Post,Pragma Refined_Depends,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id34}@anchor{d1}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{d2}
+@anchor{gnat_rm/implementation_defined_pragmas id35}@anchor{d3}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{d4}
@section Pragma Refined_Global
the SPARK 2014 Reference Manual, section 6.1.4.
@node Pragma Refined_Post,Pragma Refined_State,Pragma Refined_Global,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id35}@anchor{d3}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{d4}
+@anchor{gnat_rm/implementation_defined_pragmas id36}@anchor{d5}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{d6}
@section Pragma Refined_Post
the SPARK 2014 Reference Manual, section 7.2.7.
@node Pragma Refined_State,Pragma Relative_Deadline,Pragma Refined_Post,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id36}@anchor{d5}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{d6}
+@anchor{gnat_rm/implementation_defined_pragmas id37}@anchor{d7}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{d8}
@section Pragma Refined_State
the SPARK 2014 Reference Manual, section 7.2.2.
@node Pragma Relative_Deadline,Pragma Remote_Access_Type,Pragma Refined_State,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-relative-deadline}@anchor{d7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-relative-deadline}@anchor{d9}
@section Pragma Relative_Deadline
See Ada 2012 Reference Manual for details.
@node Pragma Remote_Access_Type,Pragma Rename_Pragma,Pragma Relative_Deadline,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id37}@anchor{d8}@anchor{gnat_rm/implementation_defined_pragmas pragma-remote-access-type}@anchor{d9}
+@anchor{gnat_rm/implementation_defined_pragmas id38}@anchor{da}@anchor{gnat_rm/implementation_defined_pragmas pragma-remote-access-type}@anchor{db}
@section Pragma Remote_Access_Type
actual type must be a remote access to class-wide type.
@node Pragma Rename_Pragma,Pragma Restricted_Run_Time,Pragma Remote_Access_Type,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-rename-pragma}@anchor{da}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-rename-pragma}@anchor{dc}
@section Pragma Rename_Pragma
compiler; it’s up to you to make sure the semantics are close enough.
@node Pragma Restricted_Run_Time,Pragma Restriction_Warnings,Pragma Rename_Pragma,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-restricted-run-time}@anchor{db}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-restricted-run-time}@anchor{dd}
@section Pragma Restricted_Run_Time
profile.
@node Pragma Restriction_Warnings,Pragma Reviewable,Pragma Restricted_Run_Time,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-restriction-warnings}@anchor{dc}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-restriction-warnings}@anchor{de}
@section Pragma Restriction_Warnings
defined pragmas will cause a warning to be generated.
@node Pragma Reviewable,Pragma Secondary_Stack_Size,Pragma Restriction_Warnings,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-reviewable}@anchor{dd}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-reviewable}@anchor{df}
@section Pragma Reviewable
@itemize *
@item
-@emph{Where compiler-generated run-time checks remain}
+`Where compiler-generated run-time checks remain'
-The switch @emph{-gnatGL}
+The switch `-gnatGL'
may be used to list the expanded code in pseudo-Ada form.
Runtime checks show up in the listing either as explicit
checks or operators marked with @{@} to indicate a check is present.
@item
-@emph{An identification of known exceptions at compile time}
+`An identification of known exceptions at compile time'
-If the program is compiled with @emph{-gnatwa},
+If the program is compiled with `-gnatwa',
the compiler warning messages will indicate all cases where the compiler
detects that an exception is certain to occur at run time.
@item
-@emph{Possible reads of uninitialized variables}
+`Possible reads of uninitialized variables'
The compiler warns of many such cases, but its output is incomplete.
@end itemize
@itemize *
@item
-@emph{Where run-time support routines are implicitly invoked}
+`Where run-time support routines are implicitly invoked'
-In the output from @emph{-gnatGL},
+In the output from `-gnatGL',
run-time calls are explicitly listed as calls to the relevant
run-time routine.
@item
-@emph{Object code listing}
+`Object code listing'
-This may be obtained either by using the @emph{-S} switch,
+This may be obtained either by using the `-S' switch,
or the objdump utility.
@item
-@emph{Constructs known to be erroneous at compile time}
+`Constructs known to be erroneous at compile time'
-These are identified by warnings issued by the compiler (use @emph{-gnatwa}).
+These are identified by warnings issued by the compiler (use `-gnatwa').
@item
-@emph{Stack usage information}
+`Stack usage information'
Static stack usage data (maximum per-subprogram) can be obtained via the
-@emph{-fstack-usage} switch to the compiler.
-Dynamic stack usage data (per task) can be obtained via the @emph{-u} switch
+`-fstack-usage' switch to the compiler.
+Dynamic stack usage data (per task) can be obtained via the `-u' switch
to gnatbind
@end itemize
@itemize *
@item
-@emph{Object code listing of entire partition}
+`Object code listing of entire partition'
-This can be obtained by compiling the partition with @emph{-S},
+This can be obtained by compiling the partition with `-S',
or by applying objdump
to all the object files that are part of the partition.
@item
-@emph{A description of the run-time model}
+`A description of the run-time model'
The full sources of the run-time are available, and the documentation of
these routines describes how these run-time routines interface to the
underlying operating system facilities.
@item
-@emph{Control and data-flow information}
+`Control and data-flow information'
@end itemize
information.
@node Pragma Secondary_Stack_Size,Pragma Share_Generic,Pragma Reviewable,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id38}@anchor{de}@anchor{gnat_rm/implementation_defined_pragmas pragma-secondary-stack-size}@anchor{df}
+@anchor{gnat_rm/implementation_defined_pragmas id39}@anchor{e0}@anchor{gnat_rm/implementation_defined_pragmas pragma-secondary-stack-size}@anchor{e1}
@section Pragma Secondary_Stack_Size
is in effect.
@node Pragma Share_Generic,Pragma Shared,Pragma Secondary_Stack_Size,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-share-generic}@anchor{e0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-share-generic}@anchor{e2}
@section Pragma Share_Generic
generic instances.
@node Pragma Shared,Pragma Short_Circuit_And_Or,Pragma Share_Generic,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id39}@anchor{e1}@anchor{gnat_rm/implementation_defined_pragmas pragma-shared}@anchor{e2}
+@anchor{gnat_rm/implementation_defined_pragmas id40}@anchor{e3}@anchor{gnat_rm/implementation_defined_pragmas pragma-shared}@anchor{e4}
@section Pragma Shared
semantics are identical to pragma Atomic.
@node Pragma Short_Circuit_And_Or,Pragma Short_Descriptors,Pragma Shared,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-short-circuit-and-or}@anchor{e3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-short-circuit-and-or}@anchor{e5}
@section Pragma Short_Circuit_And_Or
There is no requirement that all units in a partition use this option.
@node Pragma Short_Descriptors,Pragma Side_Effects,Pragma Short_Circuit_And_Or,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-short-descriptors}@anchor{e4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-short-descriptors}@anchor{e6}
@section Pragma Short_Descriptors
is recognized but ignored by all current versions of GNAT.
@node Pragma Side_Effects,Pragma Simple_Storage_Pool_Type,Pragma Short_Descriptors,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id40}@anchor{e5}@anchor{gnat_rm/implementation_defined_pragmas pragma-side-effects}@anchor{e6}
+@anchor{gnat_rm/implementation_defined_pragmas id41}@anchor{e7}@anchor{gnat_rm/implementation_defined_pragmas pragma-side-effects}@anchor{e8}
@section Pragma Side_Effects
@code{Side_Effects} in the SPARK Reference Manual, section 6.1.11.
@node Pragma Simple_Storage_Pool_Type,Pragma Source_File_Name,Pragma Side_Effects,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id41}@anchor{e7}@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{e8}
+@anchor{gnat_rm/implementation_defined_pragmas id42}@anchor{e9}@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{ea}
@section Pragma Simple_Storage_Pool_Type
An object of a simple storage pool type can be associated with an access
type by specifying the attribute
-@ref{e9,,Simple_Storage_Pool}. For example:
+@ref{eb,,Simple_Storage_Pool}. For example:
@example
My_Pool : My_Simple_Storage_Pool_Type;
for Acc'Simple_Storage_Pool use My_Pool;
@end example
-See attribute @ref{e9,,Simple_Storage_Pool}
+See attribute @ref{eb,,Simple_Storage_Pool}
for further details.
@node Pragma Source_File_Name,Pragma Source_File_Name_Project,Pragma Simple_Storage_Pool_Type,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id42}@anchor{ea}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{eb}
+@anchor{gnat_rm/implementation_defined_pragmas id43}@anchor{ec}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{ed}
@section Pragma Source_File_Name
be aware of the intended naming conventions. If you are using project files,
file naming is controlled by Source_File_Name_Project pragmas, which are
usually supplied automatically by the project manager. A pragma
-Source_File_Name cannot appear after a @ref{ec,,Pragma Source_File_Name_Project}.
+Source_File_Name cannot appear after a @ref{ee,,Pragma Source_File_Name_Project}.
For more details on the use of the @code{Source_File_Name} pragma, see the
sections on @cite{Using Other File Names} and @cite{Alternative File Naming Schemes}
in the @cite{GNAT User’s Guide}.
@node Pragma Source_File_Name_Project,Pragma Source_Reference,Pragma Source_File_Name,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id43}@anchor{ed}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{ec}
+@anchor{gnat_rm/implementation_defined_pragmas id44}@anchor{ef}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{ee}
@section Pragma Source_File_Name_Project
This pragma has the same syntax and semantics as pragma Source_File_Name.
It is only allowed as a stand-alone configuration pragma.
-It cannot appear after a @ref{eb,,Pragma Source_File_Name}, and
+It cannot appear after a @ref{ed,,Pragma Source_File_Name}, and
most importantly, once pragma Source_File_Name_Project appears,
no further Source_File_Name pragmas are allowed.
known to the project manager).
@node Pragma Source_Reference,Pragma SPARK_Mode,Pragma Source_File_Name_Project,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-source-reference}@anchor{ee}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-source-reference}@anchor{f0}
@section Pragma Source_Reference
information). @code{string_literal} is a static string constant that
specifies the file name to be used in error messages and debugging
information. This is most notably used for the output of @code{gnatchop}
-with the @emph{-r} switch, to make sure that the original unchopped
+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
is needed for error messages issued by all phases of the compiler.
@node Pragma SPARK_Mode,Pragma Static_Elaboration_Desired,Pragma Source_Reference,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id44}@anchor{ef}@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{f0}
+@anchor{gnat_rm/implementation_defined_pragmas id45}@anchor{f1}@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{f2}
@section Pragma SPARK_Mode
the package body.
@node Pragma Static_Elaboration_Desired,Pragma Stream_Convert,Pragma SPARK_Mode,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-static-elaboration-desired}@anchor{f1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-static-elaboration-desired}@anchor{f3}
@section Pragma Static_Elaboration_Desired
choice.)
@node Pragma Stream_Convert,Pragma Style_Checks,Pragma Static_Elaboration_Desired,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-stream-convert}@anchor{f2}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-stream-convert}@anchor{f4}
@section Pragma Stream_Convert
attributes is used instead.
@node Pragma Style_Checks,Pragma Subtitle,Pragma Stream_Convert,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-style-checks}@anchor{f3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-style-checks}@anchor{f5}
@section Pragma Style_Checks
The form with a string literal specifies which style options are to be
activated. These are additive, so they apply in addition to any previously
set style check options. The codes for the options are the same as those
-used in the @emph{-gnaty} switch to @emph{gcc} or @emph{gnatmake}.
+used in the `-gnaty' switch to `gcc' or `gnatmake'.
For example the following two methods can be used to enable
layout checking:
@end example
@node Pragma Subtitle,Pragma Suppress,Pragma Style_Checks,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-subtitle}@anchor{f4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-subtitle}@anchor{f6}
@section Pragma Subtitle
but is ignored by GNAT.
@node Pragma Suppress,Pragma Suppress_All,Pragma Subtitle,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress}@anchor{f5}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress}@anchor{f7}
@section Pragma Suppress
that they will not fail, whether or not checks are suppressed.
@node Pragma Suppress_All,Pragma Suppress_Debug_Info,Pragma Suppress,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-all}@anchor{f6}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-all}@anchor{f8}
@section Pragma Suppress_All
as a normal configuration pragma is the preferred usage in GNAT.
@node Pragma Suppress_Debug_Info,Pragma Suppress_Exception_Locations,Pragma Suppress_All,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id45}@anchor{f7}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{f8}
+@anchor{gnat_rm/implementation_defined_pragmas id46}@anchor{f9}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{fa}
@section Pragma Suppress_Debug_Info
the debugger, and navigating around debugger problems.
@node Pragma Suppress_Exception_Locations,Pragma Suppress_Initialization,Pragma Suppress_Debug_Info,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-exception-locations}@anchor{f9}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-exception-locations}@anchor{fb}
@section Pragma Suppress_Exception_Locations
with this pragma and others compiled in normal mode without it.
@node Pragma Suppress_Initialization,Pragma Task_Name,Pragma Suppress_Exception_Locations,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id46}@anchor{fa}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-initialization}@anchor{fb}
+@anchor{gnat_rm/implementation_defined_pragmas id47}@anchor{fc}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-initialization}@anchor{fd}
@section Pragma Suppress_Initialization
Suppress_Initialization, as described above.
@node Pragma Task_Name,Pragma Task_Storage,Pragma Suppress_Initialization,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-task-name}@anchor{fc}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-task-name}@anchor{fe}
@section Pragma Task_Name
@end example
@node Pragma Task_Storage,Pragma Test_Case,Pragma Task_Name,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-task-storage}@anchor{fd}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-task-storage}@anchor{ff}
@section Pragma Task_Storage
type.
@node Pragma Test_Case,Pragma Thread_Local_Storage,Pragma Task_Storage,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id47}@anchor{fe}@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{ff}
+@anchor{gnat_rm/implementation_defined_pragmas id48}@anchor{100}@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{101}
@section Pragma Test_Case
postcondition of the subprogram should be ignored for this test case.
@node Pragma Thread_Local_Storage,Pragma Time_Slice,Pragma Test_Case,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id48}@anchor{100}@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{101}
+@anchor{gnat_rm/implementation_defined_pragmas id49}@anchor{102}@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{103}
@section Pragma Thread_Local_Storage
then an error message will be generated and the program will be rejected.
@node Pragma Time_Slice,Pragma Title,Pragma Thread_Local_Storage,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-time-slice}@anchor{102}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-time-slice}@anchor{104}
@section Pragma Time_Slice
or if it appears in other than the main program unit.
@node Pragma Title,Pragma Type_Invariant,Pragma Time_Slice,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-title}@anchor{103}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-title}@anchor{105}
@section Pragma Title
following the normal rules for procedure calls in Ada.
@node Pragma Type_Invariant,Pragma Type_Invariant_Class,Pragma Title,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant}@anchor{104}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant}@anchor{106}
@section Pragma Type_Invariant
rather than @code{Invariant}.
@node Pragma Type_Invariant_Class,Pragma Unchecked_Union,Pragma Type_Invariant,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id49}@anchor{105}@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant-class}@anchor{106}
+@anchor{gnat_rm/implementation_defined_pragmas id50}@anchor{107}@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant-class}@anchor{108}
@section Pragma Type_Invariant_Class
not @code{Type_Invariant_Class}.
@node Pragma Unchecked_Union,Pragma Unevaluated_Use_Of_Old,Pragma Type_Invariant_Class,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unchecked-union}@anchor{107}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unchecked-union}@anchor{109}
@section Pragma Unchecked_Union
details, consult the Ada 2012 Reference Manual, section B.3.3.
@node Pragma Unevaluated_Use_Of_Old,Pragma User_Aspect_Definition,Pragma Unchecked_Union,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unevaluated-use-of-old}@anchor{108}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unevaluated-use-of-old}@anchor{10a}
@section Pragma Unevaluated_Use_Of_Old
sequence of package declarations.
@node Pragma User_Aspect_Definition,Pragma Unimplemented_Unit,Pragma Unevaluated_Use_Of_Old,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-user-aspect-definition}@anchor{109}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-user-aspect-definition}@anchor{10b}
@section Pragma User_Aspect_Definition
definitions must agree. A predefined aspect cannot be redefined.
@node Pragma Unimplemented_Unit,Pragma Universal_Aliasing,Pragma User_Aspect_Definition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unimplemented-unit}@anchor{10a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unimplemented-unit}@anchor{10c}
@section Pragma Unimplemented_Unit
specs of unimplemented packages in syntax or semantic checking mode.
@node Pragma Universal_Aliasing,Pragma Unmodified,Pragma Unimplemented_Unit,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id50}@anchor{10b}@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{10c}
+@anchor{gnat_rm/implementation_defined_pragmas id51}@anchor{10d}@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{10e}
@section Pragma Universal_Aliasing
@code{Optimization and Strict Aliasing} in the @cite{GNAT User’s Guide}.
@node Pragma Unmodified,Pragma Unreferenced,Pragma Universal_Aliasing,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id51}@anchor{10d}@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{10e}
+@anchor{gnat_rm/implementation_defined_pragmas id52}@anchor{10f}@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{110}
@section Pragma Unmodified
variables, though it is harmless to do so.
@node Pragma Unreferenced,Pragma Unreferenced_Objects,Pragma Unmodified,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id52}@anchor{10f}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{110}
+@anchor{gnat_rm/implementation_defined_pragmas id53}@anchor{111}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{112}
@section Pragma Unreferenced
regardless of whether they occur in the same unit as the subprogram
declaration, then this pragma should not be used (calls from another
unit would not be flagged); pragma Obsolescent can be used instead
-for this purpose, see @ref{af,,Pragma Obsolescent}.
+for this purpose, see @ref{b1,,Pragma Obsolescent}.
The second form of pragma @code{Unreferenced} is used within a context
clause. In this case the arguments must be unit names of units previously
variables, though it is harmless to do so.
@node Pragma Unreferenced_Objects,Pragma Unreserve_All_Interrupts,Pragma Unreferenced,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id53}@anchor{111}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{112}
+@anchor{gnat_rm/implementation_defined_pragmas id54}@anchor{113}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{114}
@section Pragma Unreferenced_Objects
not being referenced.
@node Pragma Unreserve_All_Interrupts,Pragma Unsuppress,Pragma Unreferenced_Objects,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unreserve-all-interrupts}@anchor{113}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unreserve-all-interrupts}@anchor{115}
@section Pragma Unreserve_All_Interrupts
of the @code{Unreserve_All_Interrupts} pragma.
@node Pragma Unsuppress,Pragma Unused,Pragma Unreserve_All_Interrupts,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unsuppress}@anchor{114}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unsuppress}@anchor{116}
@section Pragma Unsuppress
@code{Suppress} for full details.
@node Pragma Unused,Pragma Use_VADS_Size,Pragma Unsuppress,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id54}@anchor{115}@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{116}
+@anchor{gnat_rm/implementation_defined_pragmas id55}@anchor{117}@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{118}
@section Pragma Unused
variables, though it is harmless to do so.
@node Pragma Use_VADS_Size,Pragma Validity_Checks,Pragma Unused,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-use-vads-size}@anchor{117}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-use-vads-size}@anchor{119}
@section Pragma Use_VADS_Size
attribute for further details.
@node Pragma Validity_Checks,Pragma Volatile,Pragma Use_VADS_Size,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-validity-checks}@anchor{118}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-validity-checks}@anchor{11a}
@section Pragma Validity_Checks
activated. The validity checks are first set to include only the default
reference manual settings, and then a string of letters in the string
specifies the exact set of options required. The form of this string
-is exactly as described for the @emph{-gnatVx} compiler switch (see the
+is exactly as described for the `-gnatVx' compiler switch (see the
GNAT User’s Guide for details). For example the following two
methods can be used to enable validity checking for mode @code{in} and
@code{in out} subprogram parameters:
@end example
@node Pragma Volatile,Pragma Volatile_Full_Access,Pragma Validity_Checks,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id55}@anchor{119}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{11a}
+@anchor{gnat_rm/implementation_defined_pragmas id56}@anchor{11b}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{11c}
@section Pragma Volatile
implementation in DEC Ada 83.
@node Pragma Volatile_Full_Access,Pragma Volatile_Function,Pragma Volatile,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id56}@anchor{11b}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-full-access}@anchor{11c}
+@anchor{gnat_rm/implementation_defined_pragmas id57}@anchor{11d}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-full-access}@anchor{11e}
@section Pragma Volatile_Full_Access
access only part of the object in this case.
@node Pragma Volatile_Function,Pragma Warning_As_Error,Pragma Volatile_Full_Access,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id57}@anchor{11d}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-function}@anchor{11e}
+@anchor{gnat_rm/implementation_defined_pragmas id58}@anchor{11f}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-function}@anchor{120}
@section Pragma Volatile_Function
in the SPARK 2014 Reference Manual, section 7.1.2.
@node Pragma Warning_As_Error,Pragma Warnings,Pragma Volatile_Function,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-warning-as-error}@anchor{11f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-warning-as-error}@anchor{121}
@section Pragma Warning_As_Error
the end of the message, since this is implied).
Another possibility for the static_string_EXPRESSION which works whether
-or not error tags are enabled (@emph{-gnatw.d}) is to use a single
-@emph{-gnatw} tag string, enclosed in brackets,
+or not error tags are enabled (`-gnatw.d') is to use a single
+`-gnatw' tag string, enclosed in brackets,
as shown in the example below, to treat one category of warnings as errors.
Note that if you want to treat multiple categories of warnings as errors,
you can use multiple pragma Warning_As_Error.
The above use of patterns to match the message applies only to warning
messages generated by the front end. This pragma can also be applied to
-warnings provided by the back end and mentioned in @ref{120,,Pragma Warnings}.
-By using a single full @emph{-Wxxx} switch in the pragma, such warnings
+warnings provided by the back end and mentioned in @ref{122,,Pragma Warnings}.
+By using a single full `-Wxxx' switch in the pragma, such warnings
can also be treated as errors.
The pragma can appear either in a global configuration pragma file
which will treat all obsolescent feature warnings as errors, the
following program compiles as shown (compile options here are
-@emph{-gnatwa.d -gnatl -gnatj55}).
+`-gnatwa.d -gnatl -gnatj55').
@example
1. pragma Warning_As_Error ("*never assigned*");
“[warning-as-error]” is appended to the end of the message.
@node Pragma Warnings,Pragma Weak_External,Pragma Warning_As_Error,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id58}@anchor{121}@anchor{gnat_rm/implementation_defined_pragmas pragma-warnings}@anchor{120}
+@anchor{gnat_rm/implementation_defined_pragmas id59}@anchor{123}@anchor{gnat_rm/implementation_defined_pragmas pragma-warnings}@anchor{122}
@section Pragma Warnings
Note if the second argument of @code{DETAILS} is a @code{local_NAME} then the
second form is always understood. If the intention is to use
the fourth form, then you can write @code{NAME & ""} to force the
-interpretation as a @emph{static_string_EXPRESSION}.
+interpretation as a `static_string_EXPRESSION'.
Note: if the first argument is a valid @code{TOOL_NAME}, it will be interpreted
that way. The use of the @code{TOOL_NAME} argument is relevant only to users
front end of the compiler. The GCC back end can provide additional warnings
and they are controlled by the @code{-W} switch. Such warnings can be
identified by the appearance of a string of the form @code{[-W@{xxx@}]} in the
-message which designates the @code{-W@emph{xxx}} switch that controls the message.
-The form with a single @emph{static_string_EXPRESSION} argument also works for these
-warnings, but the string must be a single full @code{-W@emph{xxx}} switch in this
+message which designates the @code{-W`xxx'} switch that controls the message.
+The form with a single `static_string_EXPRESSION' argument also works for these
+warnings, but the string must be a single full @code{-W`xxx'} switch in this
case. The above reference lists a few examples of these additional warnings.
The specified warnings will be in effect until the end of the program
The fourth form, with an @code{On|Off} parameter and a string, is used to
control individual messages, based on their text. The string argument
is a pattern that is used to match against the text of individual
-warning messages (not including the initial â\80\9cwarning: â\80\9c tag).
+warning messages (not including the initial â\80\9cwarning: â\80\9d tag).
The pattern may contain asterisks, which match zero or more characters in
the message. For example, you can use
The above use of patterns to match the message applies only to warning
messages generated by the front end. This form of the pragma with a string
argument can also be used to control warnings provided by the back end and
-mentioned above. By using a single full @code{-W@emph{xxx}} switch in the pragma,
+mentioned above. By using a single full @code{-W`xxx'} switch in the pragma,
such warnings can be turned on and off.
There are two ways to use the pragma in this form. The OFF form can be used
@end example
In this usage, the pattern string must match in the Off and On
-pragmas, and (if @emph{-gnatw.w} is given) at least one matching
+pragmas, and (if `-gnatw.w' is given) at least one matching
warning must be suppressed.
Note: if the ON form is not found, then the effect of the OFF form extends
Warnings with switch @code{-gnatw.w}.
@node Pragma Weak_External,Pragma Wide_Character_Encoding,Pragma Warnings,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-weak-external}@anchor{122}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-weak-external}@anchor{124}
@section Pragma Weak_External
@end example
@node Pragma Wide_Character_Encoding,,Pragma Weak_External,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-wide-character-encoding}@anchor{123}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-wide-character-encoding}@anchor{125}
@section Pragma Wide_Character_Encoding
or subunits.
@node Implementation Defined Aspects,Implementation Defined Attributes,Implementation Defined Pragmas,Top
-@anchor{gnat_rm/implementation_defined_aspects doc}@anchor{124}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{125}@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{126}
+@anchor{gnat_rm/implementation_defined_aspects doc}@anchor{126}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{127}@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{128}
@chapter Implementation Defined Aspects
@menu
* Aspect Abstract_State::
+* Aspect Always_Terminates::
* Aspect Annotate::
* Aspect Async_Readers::
* Aspect Async_Writers::
@end menu
-@node Aspect Abstract_State,Aspect Annotate,,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-abstract-state}@anchor{127}
+@node Aspect Abstract_State,Aspect Always_Terminates,,Implementation Defined Aspects
+@anchor{gnat_rm/implementation_defined_aspects aspect-abstract-state}@anchor{129}
@section Aspect Abstract_State
This aspect is equivalent to @ref{1e,,pragma Abstract_State}.
-@node Aspect Annotate,Aspect Async_Readers,Aspect Abstract_State,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-annotate}@anchor{128}
+@node Aspect Always_Terminates,Aspect Annotate,Aspect Abstract_State,Implementation Defined Aspects
+@anchor{gnat_rm/implementation_defined_aspects aspect-always-terminates}@anchor{12a}
+@section Aspect Always_Terminates
+
+
+@geindex Always_Terminates
+
+This boolean aspect is equivalent to @ref{29,,pragma Always_Terminates}.
+
+@node Aspect Annotate,Aspect Async_Readers,Aspect Always_Terminates,Implementation Defined Aspects
+@anchor{gnat_rm/implementation_defined_aspects aspect-annotate}@anchor{12b}
@section Aspect Annotate
There are three forms of this aspect (where ID is an identifier,
and ARG is a general expression),
-corresponding to @ref{29,,pragma Annotate}.
+corresponding to @ref{2b,,pragma Annotate}.
@table @asis
-@item @emph{Annotate => ID}
+@item `Annotate => ID'
Equivalent to @code{pragma Annotate (ID, Entity => Name);}
-@item @emph{Annotate => (ID)}
+@item `Annotate => (ID)'
Equivalent to @code{pragma Annotate (ID, Entity => Name);}
-@item @emph{Annotate => (ID ,ID @{, ARG@})}
+@item `Annotate => (ID ,ID @{, ARG@})'
Equivalent to @code{pragma Annotate (ID, ID @{, ARG@}, Entity => Name);}
@end table
@node Aspect Async_Readers,Aspect Async_Writers,Aspect Annotate,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-async-readers}@anchor{129}
+@anchor{gnat_rm/implementation_defined_aspects aspect-async-readers}@anchor{12c}
@section Aspect Async_Readers
@geindex Async_Readers
-This boolean aspect is equivalent to @ref{30,,pragma Async_Readers}.
+This boolean aspect is equivalent to @ref{32,,pragma Async_Readers}.
@node Aspect Async_Writers,Aspect Constant_After_Elaboration,Aspect Async_Readers,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-async-writers}@anchor{12a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-async-writers}@anchor{12d}
@section Aspect Async_Writers
@geindex Async_Writers
-This boolean aspect is equivalent to @ref{32,,pragma Async_Writers}.
+This boolean aspect is equivalent to @ref{34,,pragma Async_Writers}.
@node Aspect Constant_After_Elaboration,Aspect Contract_Cases,Aspect Async_Writers,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-constant-after-elaboration}@anchor{12b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-constant-after-elaboration}@anchor{12e}
@section Aspect Constant_After_Elaboration
@geindex Constant_After_Elaboration
-This aspect is equivalent to @ref{42,,pragma Constant_After_Elaboration}.
+This aspect is equivalent to @ref{44,,pragma Constant_After_Elaboration}.
@node Aspect Contract_Cases,Aspect Depends,Aspect Constant_After_Elaboration,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-contract-cases}@anchor{12c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-contract-cases}@anchor{12f}
@section Aspect Contract_Cases
@geindex Contract_Cases
-This aspect is equivalent to @ref{44,,pragma Contract_Cases}, the sequence
+This aspect is equivalent to @ref{46,,pragma Contract_Cases}, the sequence
of clauses being enclosed in parentheses so that syntactically it is an
aggregate.
@node Aspect Depends,Aspect Default_Initial_Condition,Aspect Contract_Cases,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-depends}@anchor{12d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-depends}@anchor{130}
@section Aspect Depends
@geindex Depends
-This aspect is equivalent to @ref{54,,pragma Depends}.
+This aspect is equivalent to @ref{56,,pragma Depends}.
@node Aspect Default_Initial_Condition,Aspect Dimension,Aspect Depends,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-default-initial-condition}@anchor{12e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-default-initial-condition}@anchor{131}
@section Aspect Default_Initial_Condition
@geindex Default_Initial_Condition
-This aspect is equivalent to @ref{50,,pragma Default_Initial_Condition}.
+This aspect is equivalent to @ref{52,,pragma Default_Initial_Condition}.
@node Aspect Dimension,Aspect Dimension_System,Aspect Default_Initial_Condition,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-dimension}@anchor{12f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-dimension}@anchor{132}
@section Aspect Dimension
dimension value must be an integer literal.
@node Aspect Dimension_System,Aspect Disable_Controlled,Aspect Dimension,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-dimension-system}@anchor{130}
+@anchor{gnat_rm/implementation_defined_aspects aspect-dimension-system}@anchor{133}
@section Aspect Dimension_System
Guide for detailed examples of use of the dimension system.
@node Aspect Disable_Controlled,Aspect Effective_Reads,Aspect Dimension_System,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-disable-controlled}@anchor{131}
+@anchor{gnat_rm/implementation_defined_aspects aspect-disable-controlled}@anchor{134}
@section Aspect Disable_Controlled
whether some run-time check is enabled or suppressed.
@node Aspect Effective_Reads,Aspect Effective_Writes,Aspect Disable_Controlled,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-effective-reads}@anchor{132}
+@anchor{gnat_rm/implementation_defined_aspects aspect-effective-reads}@anchor{135}
@section Aspect Effective_Reads
@geindex Effective_Reads
-This aspect is equivalent to @ref{59,,pragma Effective_Reads}.
+This aspect is equivalent to @ref{5b,,pragma Effective_Reads}.
@node Aspect Effective_Writes,Aspect Extensions_Visible,Aspect Effective_Reads,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-effective-writes}@anchor{133}
+@anchor{gnat_rm/implementation_defined_aspects aspect-effective-writes}@anchor{136}
@section Aspect Effective_Writes
@geindex Effective_Writes
-This aspect is equivalent to @ref{5b,,pragma Effective_Writes}.
+This aspect is equivalent to @ref{5d,,pragma Effective_Writes}.
@node Aspect Extensions_Visible,Aspect Favor_Top_Level,Aspect Effective_Writes,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-extensions-visible}@anchor{134}
+@anchor{gnat_rm/implementation_defined_aspects aspect-extensions-visible}@anchor{137}
@section Aspect Extensions_Visible
@geindex Extensions_Visible
-This aspect is equivalent to @ref{69,,pragma Extensions_Visible}.
+This aspect is equivalent to @ref{6b,,pragma Extensions_Visible}.
@node Aspect Favor_Top_Level,Aspect Ghost,Aspect Extensions_Visible,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-favor-top-level}@anchor{135}
+@anchor{gnat_rm/implementation_defined_aspects aspect-favor-top-level}@anchor{138}
@section Aspect Favor_Top_Level
@geindex Favor_Top_Level
-This boolean aspect is equivalent to @ref{6e,,pragma Favor_Top_Level}.
+This boolean aspect is equivalent to @ref{70,,pragma Favor_Top_Level}.
@node Aspect Ghost,Aspect Ghost_Predicate,Aspect Favor_Top_Level,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-ghost}@anchor{136}
+@anchor{gnat_rm/implementation_defined_aspects aspect-ghost}@anchor{139}
@section Aspect Ghost
@geindex Ghost
-This aspect is equivalent to @ref{72,,pragma Ghost}.
+This aspect is equivalent to @ref{74,,pragma Ghost}.
@node Aspect Ghost_Predicate,Aspect Global,Aspect Ghost,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-ghost-predicate}@anchor{137}
+@anchor{gnat_rm/implementation_defined_aspects aspect-ghost-predicate}@anchor{13a}
@section Aspect Ghost_Predicate
in the SPARK Reference Manual, section 3.2.4.
@node Aspect Global,Aspect Initial_Condition,Aspect Ghost_Predicate,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-global}@anchor{138}
+@anchor{gnat_rm/implementation_defined_aspects aspect-global}@anchor{13b}
@section Aspect Global
@geindex Global
-This aspect is equivalent to @ref{74,,pragma Global}.
+This aspect is equivalent to @ref{76,,pragma Global}.
@node Aspect Initial_Condition,Aspect Initializes,Aspect Global,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-initial-condition}@anchor{139}
+@anchor{gnat_rm/implementation_defined_aspects aspect-initial-condition}@anchor{13c}
@section Aspect Initial_Condition
@geindex Initial_Condition
-This aspect is equivalent to @ref{81,,pragma Initial_Condition}.
+This aspect is equivalent to @ref{83,,pragma Initial_Condition}.
@node Aspect Initializes,Aspect Inline_Always,Aspect Initial_Condition,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-initializes}@anchor{13a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-initializes}@anchor{13d}
@section Aspect Initializes
@geindex Initializes
-This aspect is equivalent to @ref{84,,pragma Initializes}.
+This aspect is equivalent to @ref{86,,pragma Initializes}.
@node Aspect Inline_Always,Aspect Invariant,Aspect Initializes,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-inline-always}@anchor{13b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-inline-always}@anchor{13e}
@section Aspect Inline_Always
@geindex Inline_Always
-This boolean aspect is equivalent to @ref{86,,pragma Inline_Always}.
+This boolean aspect is equivalent to @ref{88,,pragma Inline_Always}.
@node Aspect Invariant,Aspect Invariant’Class,Aspect Inline_Always,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-invariant}@anchor{13c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-invariant}@anchor{13f}
@section Aspect Invariant
@geindex Invariant
-This aspect is equivalent to @ref{8d,,pragma Invariant}. It is a
+This aspect is equivalent to @ref{8f,,pragma Invariant}. It is a
synonym for the language defined aspect @code{Type_Invariant} except
that it is separately controllable using pragma @code{Assertion_Policy}.
@node Aspect Invariant’Class,Aspect Iterable,Aspect Invariant,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-invariant-class}@anchor{13d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-invariant-class}@anchor{140}
@section Aspect Invariant’Class
@geindex Invariant'Class
-This aspect is equivalent to @ref{106,,pragma Type_Invariant_Class}. It is a
+This aspect is equivalent to @ref{108,,pragma Type_Invariant_Class}. It is a
synonym for the language defined aspect @code{Type_Invariant'Class} except
that it is separately controllable using pragma @code{Assertion_Policy}.
@node Aspect Iterable,Aspect Linker_Section,Aspect Invariant’Class,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-iterable}@anchor{13e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-iterable}@anchor{141}
@section Aspect Iterable
This aspect is used in the GNAT-defined formal container packages.
@node Aspect Linker_Section,Aspect Local_Restrictions,Aspect Iterable,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-linker-section}@anchor{13f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-linker-section}@anchor{142}
@section Aspect Linker_Section
@geindex Linker_Section
-This aspect is equivalent to @ref{95,,pragma Linker_Section}.
+This aspect is equivalent to @ref{97,,pragma Linker_Section}.
@node Aspect Local_Restrictions,Aspect Lock_Free,Aspect Linker_Section,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-local-restrictions}@anchor{140}
+@anchor{gnat_rm/implementation_defined_aspects aspect-local-restrictions}@anchor{143}
@section Aspect Local_Restrictions
a Local_Restrictions specification).
@node Aspect Lock_Free,Aspect Max_Queue_Length,Aspect Local_Restrictions,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-lock-free}@anchor{141}
+@anchor{gnat_rm/implementation_defined_aspects aspect-lock-free}@anchor{144}
@section Aspect Lock_Free
@geindex Lock_Free
-This boolean aspect is equivalent to @ref{97,,pragma Lock_Free}.
+This boolean aspect is equivalent to @ref{99,,pragma Lock_Free}.
@node Aspect Max_Queue_Length,Aspect No_Caching,Aspect Lock_Free,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-max-queue-length}@anchor{142}
+@anchor{gnat_rm/implementation_defined_aspects aspect-max-queue-length}@anchor{145}
@section Aspect Max_Queue_Length
@geindex Max_Queue_Length
-This aspect is equivalent to @ref{9f,,pragma Max_Queue_Length}.
+This aspect is equivalent to @ref{a1,,pragma Max_Queue_Length}.
@node Aspect No_Caching,Aspect No_Elaboration_Code_All,Aspect Max_Queue_Length,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-caching}@anchor{143}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-caching}@anchor{146}
@section Aspect No_Caching
@geindex No_Caching
-This boolean aspect is equivalent to @ref{a2,,pragma No_Caching}.
+This boolean aspect is equivalent to @ref{a4,,pragma No_Caching}.
@node Aspect No_Elaboration_Code_All,Aspect No_Inline,Aspect No_Caching,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-elaboration-code-all}@anchor{144}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-elaboration-code-all}@anchor{147}
@section Aspect No_Elaboration_Code_All
@geindex No_Elaboration_Code_All
-This aspect is equivalent to @ref{a5,,pragma No_Elaboration_Code_All}
+This aspect is equivalent to @ref{a7,,pragma No_Elaboration_Code_All}
for a program unit.
@node Aspect No_Inline,Aspect No_Tagged_Streams,Aspect No_Elaboration_Code_All,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-inline}@anchor{145}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-inline}@anchor{148}
@section Aspect No_Inline
@geindex No_Inline
-This boolean aspect is equivalent to @ref{a8,,pragma No_Inline}.
+This boolean aspect is equivalent to @ref{aa,,pragma No_Inline}.
@node Aspect No_Tagged_Streams,Aspect No_Task_Parts,Aspect No_Inline,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-tagged-streams}@anchor{146}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-tagged-streams}@anchor{149}
@section Aspect No_Tagged_Streams
@geindex No_Tagged_Streams
-This aspect is equivalent to @ref{ac,,pragma No_Tagged_Streams} with an
+This aspect is equivalent to @ref{ae,,pragma No_Tagged_Streams} with an
argument specifying a root tagged type (thus this aspect can only be
applied to such a type).
@node Aspect No_Task_Parts,Aspect Object_Size,Aspect No_Tagged_Streams,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-task-parts}@anchor{147}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-task-parts}@anchor{14a}
@section Aspect No_Task_Parts
for T’Class, because descendants of T might contain tasks.
@node Aspect Object_Size,Aspect Obsolescent,Aspect No_Task_Parts,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-object-size}@anchor{148}
+@anchor{gnat_rm/implementation_defined_aspects aspect-object-size}@anchor{14b}
@section Aspect Object_Size
@geindex Object_Size
-This aspect is equivalent to @ref{149,,attribute Object_Size}.
+This aspect is equivalent to @ref{14c,,attribute Object_Size}.
@node Aspect Obsolescent,Aspect Part_Of,Aspect Object_Size,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-obsolescent}@anchor{14a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-obsolescent}@anchor{14d}
@section Aspect Obsolescent
@geindex Obsolescent
-This aspect is equivalent to @ref{af,,pragma Obsolescent}. Note that the
+This aspect is equivalent to @ref{b1,,pragma Obsolescent}. Note that the
evaluation of this aspect happens at the point of occurrence, it is not
delayed until the freeze point.
@node Aspect Part_Of,Aspect Persistent_BSS,Aspect Obsolescent,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-part-of}@anchor{14b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-part-of}@anchor{14e}
@section Aspect Part_Of
@geindex Part_Of
-This aspect is equivalent to @ref{b5,,pragma Part_Of}.
+This aspect is equivalent to @ref{b7,,pragma Part_Of}.
@node Aspect Persistent_BSS,Aspect Predicate,Aspect Part_Of,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-persistent-bss}@anchor{14c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-persistent-bss}@anchor{14f}
@section Aspect Persistent_BSS
@geindex Persistent_BSS
-This boolean aspect is equivalent to @ref{b9,,pragma Persistent_BSS}.
+This boolean aspect is equivalent to @ref{bb,,pragma Persistent_BSS}.
@node Aspect Predicate,Aspect Pure_Function,Aspect Persistent_BSS,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-predicate}@anchor{14d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-predicate}@anchor{150}
@section Aspect Predicate
@geindex Predicate
-This aspect is equivalent to @ref{c0,,pragma Predicate}. It is thus
+This aspect is equivalent to @ref{c2,,pragma Predicate}. It is thus
similar to the language defined aspects @code{Dynamic_Predicate}
and @code{Static_Predicate} except that whether the resulting
predicate is static or dynamic is controlled by the form of the
@code{Assertion_Policy}.
@node Aspect Pure_Function,Aspect Refined_Depends,Aspect Predicate,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-pure-function}@anchor{14e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-pure-function}@anchor{151}
@section Aspect Pure_Function
@geindex Pure_Function
-This boolean aspect is equivalent to @ref{cc,,pragma Pure_Function}.
+This boolean aspect is equivalent to @ref{ce,,pragma Pure_Function}.
@node Aspect Refined_Depends,Aspect Refined_Global,Aspect Pure_Function,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-refined-depends}@anchor{14f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-depends}@anchor{152}
@section Aspect Refined_Depends
@geindex Refined_Depends
-This aspect is equivalent to @ref{d0,,pragma Refined_Depends}.
+This aspect is equivalent to @ref{d2,,pragma Refined_Depends}.
@node Aspect Refined_Global,Aspect Refined_Post,Aspect Refined_Depends,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-refined-global}@anchor{150}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-global}@anchor{153}
@section Aspect Refined_Global
@geindex Refined_Global
-This aspect is equivalent to @ref{d2,,pragma Refined_Global}.
+This aspect is equivalent to @ref{d4,,pragma Refined_Global}.
@node Aspect Refined_Post,Aspect Refined_State,Aspect Refined_Global,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-refined-post}@anchor{151}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-post}@anchor{154}
@section Aspect Refined_Post
@geindex Refined_Post
-This aspect is equivalent to @ref{d4,,pragma Refined_Post}.
+This aspect is equivalent to @ref{d6,,pragma Refined_Post}.
@node Aspect Refined_State,Aspect Relaxed_Initialization,Aspect Refined_Post,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-refined-state}@anchor{152}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-state}@anchor{155}
@section Aspect Refined_State
@geindex Refined_State
-This aspect is equivalent to @ref{d6,,pragma Refined_State}.
+This aspect is equivalent to @ref{d8,,pragma Refined_State}.
@node Aspect Relaxed_Initialization,Aspect Remote_Access_Type,Aspect Refined_State,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-relaxed-initialization}@anchor{153}
+@anchor{gnat_rm/implementation_defined_aspects aspect-relaxed-initialization}@anchor{156}
@section Aspect Relaxed_Initialization
Manual, section 6.10.
@node Aspect Remote_Access_Type,Aspect Secondary_Stack_Size,Aspect Relaxed_Initialization,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-remote-access-type}@anchor{154}
+@anchor{gnat_rm/implementation_defined_aspects aspect-remote-access-type}@anchor{157}
@section Aspect Remote_Access_Type
@geindex Remote_Access_Type
-This aspect is equivalent to @ref{d9,,pragma Remote_Access_Type}.
+This aspect is equivalent to @ref{db,,pragma Remote_Access_Type}.
@node Aspect Secondary_Stack_Size,Aspect Scalar_Storage_Order,Aspect Remote_Access_Type,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-secondary-stack-size}@anchor{155}
+@anchor{gnat_rm/implementation_defined_aspects aspect-secondary-stack-size}@anchor{158}
@section Aspect Secondary_Stack_Size
@geindex Secondary_Stack_Size
-This aspect is equivalent to @ref{df,,pragma Secondary_Stack_Size}.
+This aspect is equivalent to @ref{e1,,pragma Secondary_Stack_Size}.
@node Aspect Scalar_Storage_Order,Aspect Shared,Aspect Secondary_Stack_Size,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-scalar-storage-order}@anchor{156}
+@anchor{gnat_rm/implementation_defined_aspects aspect-scalar-storage-order}@anchor{159}
@section Aspect Scalar_Storage_Order
@geindex Scalar_Storage_Order
-This aspect is equivalent to a @ref{157,,attribute Scalar_Storage_Order}.
+This aspect is equivalent to a @ref{15a,,attribute Scalar_Storage_Order}.
@node Aspect Shared,Aspect Side_Effects,Aspect Scalar_Storage_Order,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-shared}@anchor{158}
+@anchor{gnat_rm/implementation_defined_aspects aspect-shared}@anchor{15b}
@section Aspect Shared
@geindex Shared
-This boolean aspect is equivalent to @ref{e2,,pragma Shared}
+This boolean aspect is equivalent to @ref{e4,,pragma Shared}
and is thus a synonym for aspect @code{Atomic}.
@node Aspect Side_Effects,Aspect Simple_Storage_Pool,Aspect Shared,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-side-effects}@anchor{159}
+@anchor{gnat_rm/implementation_defined_aspects aspect-side-effects}@anchor{15c}
@section Aspect Side_Effects
@geindex Side_Effects
-This aspect is equivalent to @ref{e6,,pragma Side_Effects}.
+This aspect is equivalent to @ref{e8,,pragma Side_Effects}.
@node Aspect Simple_Storage_Pool,Aspect Simple_Storage_Pool_Type,Aspect Side_Effects,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool}@anchor{15a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool}@anchor{15d}
@section Aspect Simple_Storage_Pool
@geindex Simple_Storage_Pool
-This aspect is equivalent to @ref{e9,,attribute Simple_Storage_Pool}.
+This aspect is equivalent to @ref{eb,,attribute Simple_Storage_Pool}.
@node Aspect Simple_Storage_Pool_Type,Aspect SPARK_Mode,Aspect Simple_Storage_Pool,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool-type}@anchor{15b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool-type}@anchor{15e}
@section Aspect Simple_Storage_Pool_Type
@geindex Simple_Storage_Pool_Type
-This boolean aspect is equivalent to @ref{e8,,pragma Simple_Storage_Pool_Type}.
+This boolean aspect is equivalent to @ref{ea,,pragma Simple_Storage_Pool_Type}.
@node Aspect SPARK_Mode,Aspect Suppress_Debug_Info,Aspect Simple_Storage_Pool_Type,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-spark-mode}@anchor{15c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-spark-mode}@anchor{15f}
@section Aspect SPARK_Mode
@geindex SPARK_Mode
-This aspect is equivalent to @ref{f0,,pragma SPARK_Mode} and
+This aspect is equivalent to @ref{f2,,pragma SPARK_Mode} and
may be specified for either or both of the specification and body
of a subprogram or package.
@node Aspect Suppress_Debug_Info,Aspect Suppress_Initialization,Aspect SPARK_Mode,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-debug-info}@anchor{15d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-debug-info}@anchor{160}
@section Aspect Suppress_Debug_Info
@geindex Suppress_Debug_Info
-This boolean aspect is equivalent to @ref{f8,,pragma Suppress_Debug_Info}.
+This boolean aspect is equivalent to @ref{fa,,pragma Suppress_Debug_Info}.
@node Aspect Suppress_Initialization,Aspect Test_Case,Aspect Suppress_Debug_Info,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-initialization}@anchor{15e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-initialization}@anchor{161}
@section Aspect Suppress_Initialization
@geindex Suppress_Initialization
-This boolean aspect is equivalent to @ref{fb,,pragma Suppress_Initialization}.
+This boolean aspect is equivalent to @ref{fd,,pragma Suppress_Initialization}.
@node Aspect Test_Case,Aspect Thread_Local_Storage,Aspect Suppress_Initialization,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-test-case}@anchor{15f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-test-case}@anchor{162}
@section Aspect Test_Case
@geindex Test_Case
-This aspect is equivalent to @ref{ff,,pragma Test_Case}.
+This aspect is equivalent to @ref{101,,pragma Test_Case}.
@node Aspect Thread_Local_Storage,Aspect Universal_Aliasing,Aspect Test_Case,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-thread-local-storage}@anchor{160}
+@anchor{gnat_rm/implementation_defined_aspects aspect-thread-local-storage}@anchor{163}
@section Aspect Thread_Local_Storage
@geindex Thread_Local_Storage
-This boolean aspect is equivalent to @ref{101,,pragma Thread_Local_Storage}.
+This boolean aspect is equivalent to @ref{103,,pragma Thread_Local_Storage}.
@node Aspect Universal_Aliasing,Aspect Unmodified,Aspect Thread_Local_Storage,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-universal-aliasing}@anchor{161}
+@anchor{gnat_rm/implementation_defined_aspects aspect-universal-aliasing}@anchor{164}
@section Aspect Universal_Aliasing
@geindex Universal_Aliasing
-This boolean aspect is equivalent to @ref{10c,,pragma Universal_Aliasing}.
+This boolean aspect is equivalent to @ref{10e,,pragma Universal_Aliasing}.
@node Aspect Unmodified,Aspect Unreferenced,Aspect Universal_Aliasing,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-unmodified}@anchor{162}
+@anchor{gnat_rm/implementation_defined_aspects aspect-unmodified}@anchor{165}
@section Aspect Unmodified
@geindex Unmodified
-This boolean aspect is equivalent to @ref{10e,,pragma Unmodified}.
+This boolean aspect is equivalent to @ref{110,,pragma Unmodified}.
@node Aspect Unreferenced,Aspect Unreferenced_Objects,Aspect Unmodified,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced}@anchor{163}
+@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced}@anchor{166}
@section Aspect Unreferenced
@geindex Unreferenced
-This boolean aspect is equivalent to @ref{110,,pragma Unreferenced}.
+This boolean aspect is equivalent to @ref{112,,pragma Unreferenced}.
When using the @code{-gnat2022} switch, this aspect is also supported on formal
parameters, which is in particular the only form possible for expression
functions.
@node Aspect Unreferenced_Objects,Aspect User_Aspect,Aspect Unreferenced,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced-objects}@anchor{164}
+@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced-objects}@anchor{167}
@section Aspect Unreferenced_Objects
@geindex Unreferenced_Objects
-This boolean aspect is equivalent to @ref{112,,pragma Unreferenced_Objects}.
+This boolean aspect is equivalent to @ref{114,,pragma Unreferenced_Objects}.
@node Aspect User_Aspect,Aspect Value_Size,Aspect Unreferenced_Objects,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-user-aspect}@anchor{165}
+@anchor{gnat_rm/implementation_defined_aspects aspect-user-aspect}@anchor{168}
@section Aspect User_Aspect
pragma-defined aspect.
@node Aspect Value_Size,Aspect Volatile_Full_Access,Aspect User_Aspect,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-value-size}@anchor{166}
+@anchor{gnat_rm/implementation_defined_aspects aspect-value-size}@anchor{169}
@section Aspect Value_Size
@geindex Value_Size
-This aspect is equivalent to @ref{167,,attribute Value_Size}.
+This aspect is equivalent to @ref{16a,,attribute Value_Size}.
@node Aspect Volatile_Full_Access,Aspect Volatile_Function,Aspect Value_Size,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-full-access}@anchor{168}
+@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-full-access}@anchor{16b}
@section Aspect Volatile_Full_Access
@geindex Volatile_Full_Access
-This boolean aspect is equivalent to @ref{11c,,pragma Volatile_Full_Access}.
+This boolean aspect is equivalent to @ref{11e,,pragma Volatile_Full_Access}.
@node Aspect Volatile_Function,Aspect Warnings,Aspect Volatile_Full_Access,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-function}@anchor{169}
+@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-function}@anchor{16c}
@section Aspect Volatile_Function
@geindex Volatile_Function
-This boolean aspect is equivalent to @ref{11e,,pragma Volatile_Function}.
+This boolean aspect is equivalent to @ref{120,,pragma Volatile_Function}.
@node Aspect Warnings,,Aspect Volatile_Function,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-warnings}@anchor{16a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-warnings}@anchor{16d}
@section Aspect Warnings
@geindex Warnings
-This aspect is equivalent to the two argument form of @ref{120,,pragma Warnings},
+This aspect is equivalent to the two argument form of @ref{122,,pragma Warnings},
where the first argument is @code{ON} or @code{OFF} and the second argument
is the entity.
@node Implementation Defined Attributes,Standard and Implementation Defined Restrictions,Implementation Defined Aspects,Top
-@anchor{gnat_rm/implementation_defined_attributes doc}@anchor{16b}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{16c}@anchor{gnat_rm/implementation_defined_attributes implementation-defined-attributes}@anchor{8}
+@anchor{gnat_rm/implementation_defined_attributes doc}@anchor{16e}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{16f}@anchor{gnat_rm/implementation_defined_attributes implementation-defined-attributes}@anchor{8}
@chapter Implementation Defined Attributes
@end menu
@node Attribute Abort_Signal,Attribute Address_Size,,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-abort-signal}@anchor{16d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-abort-signal}@anchor{170}
@section Attribute Abort_Signal
intercept the abort exception).
@node Attribute Address_Size,Attribute Asm_Input,Attribute Abort_Signal,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-address-size}@anchor{16e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-address-size}@anchor{171}
@section Attribute Address_Size
is a private type.
@node Attribute Asm_Input,Attribute Asm_Output,Attribute Address_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-asm-input}@anchor{16f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-asm-input}@anchor{172}
@section Attribute Asm_Input
value to be used as the input argument. The possible values for the
constant are the same as those used in the RTL, and are dependent on
the configuration file used to built the GCC back end.
-@ref{170,,Machine Code Insertions}
+@ref{173,,Machine Code Insertions}
@node Attribute Asm_Output,Attribute Atomic_Always_Lock_Free,Attribute Asm_Input,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-asm-output}@anchor{171}
+@anchor{gnat_rm/implementation_defined_attributes attribute-asm-output}@anchor{174}
@section Attribute Asm_Output
the RTL, and are dependent on the configuration file used to build the
GCC back end. If there are no output operands, then this argument may
either be omitted, or explicitly given as @code{No_Output_Operands}.
-@ref{170,,Machine Code Insertions}
+@ref{173,,Machine Code Insertions}
@node Attribute Atomic_Always_Lock_Free,Attribute Bit,Attribute Asm_Output,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-atomic-always-lock-free}@anchor{172}
+@anchor{gnat_rm/implementation_defined_attributes attribute-atomic-always-lock-free}@anchor{175}
@section Attribute Atomic_Always_Lock_Free
supported by the target for the given type.
@node Attribute Bit,Attribute Bit_Position,Attribute Atomic_Always_Lock_Free,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-bit}@anchor{173}
+@anchor{gnat_rm/implementation_defined_attributes attribute-bit}@anchor{176}
@section Attribute Bit
@code{obj'Bit}, where @code{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 @emph{universal_integer} and is always a nonnegative number smaller
+type `universal_integer' and is always a nonnegative number smaller
than @code{System.Storage_Unit}.
For an object that is a variable or a constant allocated in a register,
and implementation of the @code{Bit} attribute.
@node Attribute Bit_Position,Attribute Code_Address,Attribute Bit,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-bit-position}@anchor{174}
+@anchor{gnat_rm/implementation_defined_attributes attribute-bit-position}@anchor{177}
@section Attribute Bit_Position
of the fields of the record type, yields the bit
offset within the record contains the first bit of
storage allocated for the object. The value of this attribute is of the
-type @emph{universal_integer}. The value depends only on the field
+type `universal_integer'. The value depends only on the field
@code{C} and is independent of the alignment of
the containing record @code{R}.
@node Attribute Code_Address,Attribute Compiler_Version,Attribute Bit_Position,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-code-address}@anchor{175}
+@anchor{gnat_rm/implementation_defined_attributes attribute-code-address}@anchor{178}
@section Attribute Code_Address
attribute.
@node Attribute Compiler_Version,Attribute Constrained,Attribute Code_Address,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-compiler-version}@anchor{176}
+@anchor{gnat_rm/implementation_defined_attributes attribute-compiler-version}@anchor{179}
@section Attribute Compiler_Version
being used to compile the unit containing the attribute reference.
@node Attribute Constrained,Attribute Default_Bit_Order,Attribute Compiler_Version,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-constrained}@anchor{177}
+@anchor{gnat_rm/implementation_defined_attributes attribute-constrained}@anchor{17a}
@section Attribute Constrained
compatible with older Ada compilers, including notably DEC Ada.
@node Attribute Default_Bit_Order,Attribute Default_Scalar_Storage_Order,Attribute Constrained,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-default-bit-order}@anchor{178}
+@anchor{gnat_rm/implementation_defined_attributes attribute-default-bit-order}@anchor{17b}
@section Attribute Default_Bit_Order
@code{Default_Bit_Order} in package @code{System}.
@node Attribute Default_Scalar_Storage_Order,Attribute Deref,Attribute Default_Bit_Order,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-default-scalar-storage-order}@anchor{179}
+@anchor{gnat_rm/implementation_defined_attributes attribute-default-scalar-storage-order}@anchor{17c}
@section Attribute Default_Scalar_Storage_Order
@code{System.Bit_Order} value. This is a static attribute.
@node Attribute Deref,Attribute Descriptor_Size,Attribute Default_Scalar_Storage_Order,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-deref}@anchor{17a}
+@anchor{gnat_rm/implementation_defined_attributes attribute-deref}@anchor{17d}
@section Attribute Deref
used on the left side of an assignment.
@node Attribute Descriptor_Size,Attribute Elaborated,Attribute Deref,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-descriptor-size}@anchor{17b}
+@anchor{gnat_rm/implementation_defined_attributes attribute-descriptor-size}@anchor{17e}
@section Attribute Descriptor_Size
which yields a size of 32 bits, i.e. including 16 bits of padding.
@node Attribute Elaborated,Attribute Elab_Body,Attribute Descriptor_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-elaborated}@anchor{17c}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elaborated}@anchor{17f}
@section Attribute Elaborated
elaboration, the value is always False for such units.
@node Attribute Elab_Body,Attribute Elab_Spec,Attribute Elaborated,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-elab-body}@anchor{17d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elab-body}@anchor{180}
@section Attribute Elab_Body
error.
@node Attribute Elab_Spec,Attribute Elab_Subp_Body,Attribute Elab_Body,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-elab-spec}@anchor{17e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elab-spec}@anchor{181}
@section Attribute Elab_Spec
some error.
@node Attribute Elab_Subp_Body,Attribute Emax,Attribute Elab_Spec,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-elab-subp-body}@anchor{17f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elab-subp-body}@anchor{182}
@section Attribute Elab_Subp_Body
otherwise.
@node Attribute Emax,Attribute Enabled,Attribute Elab_Subp_Body,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-emax}@anchor{180}
+@anchor{gnat_rm/implementation_defined_attributes attribute-emax}@anchor{183}
@section Attribute Emax
this attribute.
@node Attribute Enabled,Attribute Enum_Rep,Attribute Emax,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-enabled}@anchor{181}
+@anchor{gnat_rm/implementation_defined_attributes attribute-enabled}@anchor{184}
@section Attribute Enabled
the package or subprogram, controlling whether the check will be present.
@node Attribute Enum_Rep,Attribute Enum_Val,Attribute Enabled,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-enum-rep}@anchor{182}
+@anchor{gnat_rm/implementation_defined_attributes attribute-enum-rep}@anchor{185}
@section Attribute Enum_Rep
may raise @code{Constraint_Error}.
@node Attribute Enum_Val,Attribute Epsilon,Attribute Enum_Rep,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-enum-val}@anchor{183}
+@anchor{gnat_rm/implementation_defined_attributes attribute-enum-val}@anchor{186}
@section Attribute Enum_Val
attribute (i.e., the result is static if the argument is static).
@node Attribute Epsilon,Attribute Fast_Math,Attribute Enum_Val,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-epsilon}@anchor{184}
+@anchor{gnat_rm/implementation_defined_attributes attribute-epsilon}@anchor{187}
@section Attribute Epsilon
this attribute.
@node Attribute Fast_Math,Attribute Finalization_Size,Attribute Epsilon,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-fast-math}@anchor{185}
+@anchor{gnat_rm/implementation_defined_attributes attribute-fast-math}@anchor{188}
@section Attribute Fast_Math
@code{Fast_Math} is active, and False otherwise.
@node Attribute Finalization_Size,Attribute Fixed_Value,Attribute Fast_Math,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-finalization-size}@anchor{186}
+@anchor{gnat_rm/implementation_defined_attributes attribute-finalization-size}@anchor{189}
@section Attribute Finalization_Size
The prefix of attribute @code{Finalization_Size} must be an object or
a non-class-wide type. This attribute returns the size of any hidden data
reserved by the compiler to handle finalization-related actions. The type of
-the attribute is @emph{universal_integer}.
+the attribute is `universal_integer'.
@code{Finalization_Size} yields a value of zero for a type with no controlled
parts, an object whose type has no controlled parts, or an object of a
Note that only heap-allocated objects contain finalization data.
@node Attribute Fixed_Value,Attribute From_Any,Attribute Finalization_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-fixed-value}@anchor{187}
+@anchor{gnat_rm/implementation_defined_attributes attribute-fixed-value}@anchor{18a}
@section Attribute Fixed_Value
input-output functions for fixed-point values.
@node Attribute From_Any,Attribute Has_Access_Values,Attribute Fixed_Value,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-from-any}@anchor{188}
+@anchor{gnat_rm/implementation_defined_attributes attribute-from-any}@anchor{18b}
@section Attribute From_Any
stubs in the context of the Distributed Systems Annex.
@node Attribute Has_Access_Values,Attribute Has_Discriminants,Attribute From_Any,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-has-access-values}@anchor{189}
+@anchor{gnat_rm/implementation_defined_attributes attribute-has-access-values}@anchor{18c}
@section Attribute Has_Access_Values
indicates whether or not the corresponding actual type has access values.
@node Attribute Has_Discriminants,Attribute Has_Tagged_Values,Attribute Has_Access_Values,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-has-discriminants}@anchor{18a}
+@anchor{gnat_rm/implementation_defined_attributes attribute-has-discriminants}@anchor{18d}
@section Attribute Has_Discriminants
indicates whether or not the corresponding actual type has discriminants.
@node Attribute Has_Tagged_Values,Attribute Img,Attribute Has_Discriminants,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-has-tagged-values}@anchor{18b}
+@anchor{gnat_rm/implementation_defined_attributes attribute-has-tagged-values}@anchor{18e}
@section Attribute Has_Tagged_Values
indicates whether or not the corresponding actual type has access values.
@node Attribute Img,Attribute Initialized,Attribute Has_Tagged_Values,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-img}@anchor{18c}
+@anchor{gnat_rm/implementation_defined_attributes attribute-img}@anchor{18f}
@section Attribute Img
in an instantiation as a function parameter.
@node Attribute Initialized,Attribute Integer_Value,Attribute Img,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-initialized}@anchor{18d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-initialized}@anchor{190}
@section Attribute Initialized
Manual, section 6.10.
@node Attribute Integer_Value,Attribute Invalid_Value,Attribute Initialized,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-integer-value}@anchor{18e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-integer-value}@anchor{191}
@section Attribute Integer_Value
standard input-output functions for fixed-point values.
@node Attribute Invalid_Value,Attribute Iterable,Attribute Integer_Value,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-invalid-value}@anchor{18f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-invalid-value}@anchor{192}
@section Attribute Invalid_Value
relevant environment variables at run time.
@node Attribute Iterable,Attribute Large,Attribute Invalid_Value,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-iterable}@anchor{190}
+@anchor{gnat_rm/implementation_defined_attributes attribute-iterable}@anchor{193}
@section Attribute Iterable
Equivalent to Aspect Iterable.
@node Attribute Large,Attribute Library_Level,Attribute Iterable,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-large}@anchor{191}
+@anchor{gnat_rm/implementation_defined_attributes attribute-large}@anchor{194}
@section Attribute Large
this attribute.
@node Attribute Library_Level,Attribute Loop_Entry,Attribute Large,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-library-level}@anchor{192}
+@anchor{gnat_rm/implementation_defined_attributes attribute-library-level}@anchor{195}
@section Attribute Library_Level
@end example
@node Attribute Loop_Entry,Attribute Machine_Size,Attribute Library_Level,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-loop-entry}@anchor{193}
+@anchor{gnat_rm/implementation_defined_attributes attribute-loop-entry}@anchor{196}
@section Attribute Loop_Entry
corresponding pragmas are ignored or disabled.
@node Attribute Machine_Size,Attribute Mantissa,Attribute Loop_Entry,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-machine-size}@anchor{194}
+@anchor{gnat_rm/implementation_defined_attributes attribute-machine-size}@anchor{197}
@section Attribute Machine_Size
provided for compatibility with the DEC Ada 83 attribute of this name.
@node Attribute Mantissa,Attribute Maximum_Alignment,Attribute Machine_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-mantissa}@anchor{195}
+@anchor{gnat_rm/implementation_defined_attributes attribute-mantissa}@anchor{198}
@section Attribute Mantissa
this attribute.
@node Attribute Maximum_Alignment,Attribute Max_Integer_Size,Attribute Mantissa,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-maximum-alignment}@anchor{196}@anchor{gnat_rm/implementation_defined_attributes id2}@anchor{197}
+@anchor{gnat_rm/implementation_defined_attributes attribute-maximum-alignment}@anchor{199}@anchor{gnat_rm/implementation_defined_attributes id2}@anchor{19a}
@section Attribute Maximum_Alignment
cases.
@node Attribute Max_Integer_Size,Attribute Mechanism_Code,Attribute Maximum_Alignment,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-max-integer-size}@anchor{198}
+@anchor{gnat_rm/implementation_defined_attributes attribute-max-integer-size}@anchor{19b}
@section Attribute Max_Integer_Size
the target. The result is a static constant.
@node Attribute Mechanism_Code,Attribute Null_Parameter,Attribute Max_Integer_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-mechanism-code}@anchor{199}
+@anchor{gnat_rm/implementation_defined_attributes attribute-mechanism-code}@anchor{19c}
@section Attribute Mechanism_Code
@code{func'Mechanism_Code} yields an integer code for the
mechanism used for the result of function @code{func}, and
@code{subprog'Mechanism_Code (n)} yields the mechanism
-used for formal parameter number @emph{n} (a static integer value, with 1
+used for formal parameter number `n' (a static integer value, with 1
meaning the first parameter) of subprogram @code{subprog}. The code returned is:
@table @asis
-@item @emph{1}
+@item `1'
by copy (value)
-@item @emph{2}
+@item `2'
by reference
@end table
@node Attribute Null_Parameter,Attribute Object_Size,Attribute Mechanism_Code,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-null-parameter}@anchor{19a}
+@anchor{gnat_rm/implementation_defined_attributes attribute-null-parameter}@anchor{19d}
@section Attribute Null_Parameter
attribute.
@node Attribute Object_Size,Attribute Old,Attribute Null_Parameter,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-object-size}@anchor{149}@anchor{gnat_rm/implementation_defined_attributes id3}@anchor{19b}
+@anchor{gnat_rm/implementation_defined_attributes attribute-object-size}@anchor{14c}@anchor{gnat_rm/implementation_defined_attributes id3}@anchor{19e}
@section Attribute Object_Size
statically matching subtypes.
@node Attribute Old,Attribute Passed_By_Reference,Attribute Object_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-old}@anchor{19c}
+@anchor{gnat_rm/implementation_defined_attributes attribute-old}@anchor{19f}
@section Attribute Old
implementation defined pragma @code{Unevaluated_Use_Of_Old}.
@node Attribute Passed_By_Reference,Attribute Pool_Address,Attribute Old,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-passed-by-reference}@anchor{19d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-passed-by-reference}@anchor{1a0}
@section Attribute Passed_By_Reference
and is static. For non-scalar types, the result is nonstatic.
@node Attribute Pool_Address,Attribute Range_Length,Attribute Passed_By_Reference,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-pool-address}@anchor{19e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-pool-address}@anchor{1a1}
@section Attribute Pool_Address
what is passed to @code{Allocate} and returned from @code{Deallocate}.
@node Attribute Range_Length,Attribute Restriction_Set,Attribute Pool_Address,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-range-length}@anchor{19f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-range-length}@anchor{1a2}
@section Attribute Range_Length
same result as @code{Length} applied to the array itself.
@node Attribute Restriction_Set,Attribute Result,Attribute Range_Length,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-restriction-set}@anchor{1a0}
+@anchor{gnat_rm/implementation_defined_attributes attribute-restriction-set}@anchor{1a3}
@section Attribute Restriction_Set
so they do not have a type.
@node Attribute Result,Attribute Safe_Emax,Attribute Restriction_Set,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-result}@anchor{1a1}
+@anchor{gnat_rm/implementation_defined_attributes attribute-result}@anchor{1a4}
@section Attribute Result
see the description of pragma Postcondition.
@node Attribute Safe_Emax,Attribute Safe_Large,Attribute Result,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-safe-emax}@anchor{1a2}
+@anchor{gnat_rm/implementation_defined_attributes attribute-safe-emax}@anchor{1a5}
@section Attribute Safe_Emax
this attribute.
@node Attribute Safe_Large,Attribute Safe_Small,Attribute Safe_Emax,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-safe-large}@anchor{1a3}
+@anchor{gnat_rm/implementation_defined_attributes attribute-safe-large}@anchor{1a6}
@section Attribute Safe_Large
this attribute.
@node Attribute Safe_Small,Attribute Scalar_Storage_Order,Attribute Safe_Large,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-safe-small}@anchor{1a4}
+@anchor{gnat_rm/implementation_defined_attributes attribute-safe-small}@anchor{1a7}
@section Attribute Safe_Small
this attribute.
@node Attribute Scalar_Storage_Order,Attribute Simple_Storage_Pool,Attribute Safe_Small,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-scalar-storage-order}@anchor{157}@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{1a5}
+@anchor{gnat_rm/implementation_defined_attributes attribute-scalar-storage-order}@anchor{15a}@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{1a8}
@section Attribute Scalar_Storage_Order
pragma @code{Default_Scalar_Storage_Order}.
If a component of @code{T} is itself of a record or array type, the specfied
-@code{Scalar_Storage_Order} does @emph{not} apply to that nested type: an explicit
+@code{Scalar_Storage_Order} does `not' apply to that nested type: an explicit
attribute definition clause must be provided for the component type as well
if desired.
components of a type for which the opposite storage order is specified.
@node Attribute Simple_Storage_Pool,Attribute Small,Attribute Scalar_Storage_Order,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-simple-storage-pool}@anchor{e9}@anchor{gnat_rm/implementation_defined_attributes id5}@anchor{1a6}
+@anchor{gnat_rm/implementation_defined_attributes attribute-simple-storage-pool}@anchor{eb}@anchor{gnat_rm/implementation_defined_attributes id5}@anchor{1a9}
@section Attribute Simple_Storage_Pool
@code{S'Simple_Storage_Pool} as the pool parameter. The detailed
semantics of such allocators is the same as those defined for allocators
in section 13.11 of the @cite{Ada Reference Manual}, with the term
-@emph{simple storage pool} substituted for @emph{storage pool}.
+`simple storage pool' substituted for `storage pool'.
If an access type @code{S} has a specified simple storage pool of type
@code{SSP}, then a call to an instance of the @code{Ada.Unchecked_Deallocation}
for type @code{SSP}, passing @code{S'Simple_Storage_Pool} as the pool
parameter. The detailed semantics of such unchecked deallocations is the same
as defined in section 13.11.2 of the Ada Reference Manual, except that the
-term @emph{simple storage pool} is substituted for @emph{storage pool}.
+term `simple storage pool' is substituted for `storage pool'.
@node Attribute Small,Attribute Small_Denominator,Attribute Simple_Storage_Pool,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-small}@anchor{1a7}
+@anchor{gnat_rm/implementation_defined_attributes attribute-small}@anchor{1aa}
@section Attribute Small
this attribute when applied to floating-point types.
@node Attribute Small_Denominator,Attribute Small_Numerator,Attribute Small,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-small-denominator}@anchor{1a8}
+@anchor{gnat_rm/implementation_defined_attributes attribute-small-denominator}@anchor{1ab}
@section Attribute Small_Denominator
with coprime factors (i.e. as an irreducible fraction).
@node Attribute Small_Numerator,Attribute Storage_Unit,Attribute Small_Denominator,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-small-numerator}@anchor{1a9}
+@anchor{gnat_rm/implementation_defined_attributes attribute-small-numerator}@anchor{1ac}
@section Attribute Small_Numerator
with coprime factors (i.e. as an irreducible fraction).
@node Attribute Storage_Unit,Attribute Stub_Type,Attribute Small_Numerator,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-storage-unit}@anchor{1aa}
+@anchor{gnat_rm/implementation_defined_attributes attribute-storage-unit}@anchor{1ad}
@section Attribute Storage_Unit
prefix) provides the same value as @code{System.Storage_Unit}.
@node Attribute Stub_Type,Attribute System_Allocator_Alignment,Attribute Storage_Unit,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-stub-type}@anchor{1ab}
+@anchor{gnat_rm/implementation_defined_attributes attribute-stub-type}@anchor{1ae}
@section Attribute Stub_Type
an implicit dependency on this unit.
@node Attribute System_Allocator_Alignment,Attribute Target_Name,Attribute Stub_Type,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-system-allocator-alignment}@anchor{1ac}
+@anchor{gnat_rm/implementation_defined_attributes attribute-system-allocator-alignment}@anchor{1af}
@section Attribute System_Allocator_Alignment
alignment request is larger than this value.
@node Attribute Target_Name,Attribute To_Address,Attribute System_Allocator_Alignment,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-target-name}@anchor{1ad}
+@anchor{gnat_rm/implementation_defined_attributes attribute-target-name}@anchor{1b0}
@section Attribute Target_Name
example, GNAT 5.0 on windows yields “i586-pc-mingw32msv”).
@node Attribute To_Address,Attribute To_Any,Attribute Target_Name,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-to-address}@anchor{1ae}
+@anchor{gnat_rm/implementation_defined_attributes attribute-to-address}@anchor{1b1}
@section Attribute To_Address
a 32 bits machine).
@node Attribute To_Any,Attribute Type_Class,Attribute To_Address,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-to-any}@anchor{1af}
+@anchor{gnat_rm/implementation_defined_attributes attribute-to-any}@anchor{1b2}
@section Attribute To_Any
stubs in the context of the Distributed Systems Annex.
@node Attribute Type_Class,Attribute Type_Key,Attribute To_Any,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-type-class}@anchor{1b0}
+@anchor{gnat_rm/implementation_defined_attributes attribute-type-class}@anchor{1b3}
@section Attribute Type_Class
be compatible with the DEC Ada 83 attribute of the same name.
@node Attribute Type_Key,Attribute TypeCode,Attribute Type_Class,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-type-key}@anchor{1b1}
+@anchor{gnat_rm/implementation_defined_attributes attribute-type-key}@anchor{1b4}
@section Attribute Type_Key
other implementations that support this attribute.
@node Attribute TypeCode,Attribute Unconstrained_Array,Attribute Type_Key,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-typecode}@anchor{1b2}
+@anchor{gnat_rm/implementation_defined_attributes attribute-typecode}@anchor{1b5}
@section Attribute TypeCode
stubs in the context of the Distributed Systems Annex.
@node Attribute Unconstrained_Array,Attribute Universal_Literal_String,Attribute TypeCode,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-unconstrained-array}@anchor{1b3}
+@anchor{gnat_rm/implementation_defined_attributes attribute-unconstrained-array}@anchor{1b6}
@section Attribute Unconstrained_Array
generic actual.
@node Attribute Universal_Literal_String,Attribute Unrestricted_Access,Attribute Unconstrained_Array,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-universal-literal-string}@anchor{1b4}
+@anchor{gnat_rm/implementation_defined_attributes attribute-universal-literal-string}@anchor{1b7}
@section Attribute Universal_Literal_String
@end example
@node Attribute Unrestricted_Access,Attribute Update,Attribute Universal_Literal_String,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-unrestricted-access}@anchor{1b5}
+@anchor{gnat_rm/implementation_defined_attributes attribute-unrestricted-access}@anchor{1b8}
@section Attribute Unrestricted_Access
of GNAT to another, so are best avoided if possible.
@node Attribute Update,Attribute Valid_Value,Attribute Unrestricted_Access,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-update}@anchor{1b6}
+@anchor{gnat_rm/implementation_defined_attributes attribute-update}@anchor{1b9}
@section Attribute Update
which changes element (1,2) to 20 and (3,4) to 30.
@node Attribute Valid_Value,Attribute Valid_Scalars,Attribute Update,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-valid-value}@anchor{1b7}
+@anchor{gnat_rm/implementation_defined_attributes attribute-valid-value}@anchor{1ba}
@section Attribute Valid_Value
if and only if @code{T'Value (S)} would not raise Constraint_Error.
@node Attribute Valid_Scalars,Attribute VADS_Size,Attribute Valid_Value,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-valid-scalars}@anchor{1b8}
+@anchor{gnat_rm/implementation_defined_attributes attribute-valid-scalars}@anchor{1bb}
@section Attribute Valid_Scalars
function from multiple places.
@node Attribute VADS_Size,Attribute Value_Size,Attribute Valid_Scalars,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-vads-size}@anchor{1b9}
+@anchor{gnat_rm/implementation_defined_attributes attribute-vads-size}@anchor{1bc}
@section Attribute VADS_Size
the corresponding type.
@node Attribute Value_Size,Attribute Wchar_T_Size,Attribute VADS_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-value-size}@anchor{167}@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1ba}
+@anchor{gnat_rm/implementation_defined_attributes attribute-value-size}@anchor{16a}@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1bd}
@section Attribute Value_Size
but, unlike @code{Size}, may be set for non-first subtypes.
@node Attribute Wchar_T_Size,Attribute Word_Size,Attribute Value_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-wchar-t-size}@anchor{1bb}
+@anchor{gnat_rm/implementation_defined_attributes attribute-wchar-t-size}@anchor{1be}
@section Attribute Wchar_T_Size
package @code{Interfaces.C}. The result is a static constant.
@node Attribute Word_Size,,Attribute Wchar_T_Size,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-word-size}@anchor{1bc}
+@anchor{gnat_rm/implementation_defined_attributes attribute-word-size}@anchor{1bf}
@section Attribute Word_Size
a static constant.
@node Standard and Implementation Defined Restrictions,Implementation Advice,Implementation Defined Attributes,Top
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions doc}@anchor{1bd}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1be}@anchor{gnat_rm/standard_and_implementation_defined_restrictions standard-and-implementation-defined-restrictions}@anchor{9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions doc}@anchor{1c0}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1c1}@anchor{gnat_rm/standard_and_implementation_defined_restrictions standard-and-implementation-defined-restrictions}@anchor{9}
@chapter Standard and Implementation Defined Restrictions
@end menu
@node Partition-Wide Restrictions,Program Unit Level Restrictions,,Standard and Implementation Defined Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions id2}@anchor{1bf}@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1c0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions id2}@anchor{1c2}@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1c3}
@section Partition-Wide Restrictions
@end menu
@node Immediate_Reclamation,Max_Asynchronous_Select_Nesting,,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions immediate-reclamation}@anchor{1c1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions immediate-reclamation}@anchor{1c4}
@subsection Immediate_Reclamation
immediately reclaimed when the object no longer exists.
@node Max_Asynchronous_Select_Nesting,Max_Entry_Queue_Length,Immediate_Reclamation,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-asynchronous-select-nesting}@anchor{1c2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-asynchronous-select-nesting}@anchor{1c5}
@subsection Max_Asynchronous_Select_Nesting
other than zero cause Storage_Error to be raised.
@node Max_Entry_Queue_Length,Max_Protected_Entries,Max_Asynchronous_Select_Nesting,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-entry-queue-length}@anchor{1c3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-entry-queue-length}@anchor{1c6}
@subsection Max_Entry_Queue_Length
warnings on obsolescent features are activated).
@node Max_Protected_Entries,Max_Select_Alternatives,Max_Entry_Queue_Length,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-protected-entries}@anchor{1c4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-protected-entries}@anchor{1c7}
@subsection Max_Protected_Entries
defined by a discriminant of a subtype whose corresponding bound is static.
@node Max_Select_Alternatives,Max_Storage_At_Blocking,Max_Protected_Entries,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-select-alternatives}@anchor{1c5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-select-alternatives}@anchor{1c8}
@subsection Max_Select_Alternatives
[RM D.7] Specifies the maximum number of alternatives in a selective accept.
@node Max_Storage_At_Blocking,Max_Task_Entries,Max_Select_Alternatives,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-storage-at-blocking}@anchor{1c6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-storage-at-blocking}@anchor{1c9}
@subsection Max_Storage_At_Blocking
restriction causes Storage_Error to be raised.
@node Max_Task_Entries,Max_Tasks,Max_Storage_At_Blocking,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-task-entries}@anchor{1c7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-task-entries}@anchor{1ca}
@subsection Max_Task_Entries
corresponding bound is static.
@node Max_Tasks,No_Abort_Statements,Max_Task_Entries,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-tasks}@anchor{1c8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-tasks}@anchor{1cb}
@subsection Max_Tasks
Storage_Error to be raised.
@node No_Abort_Statements,No_Access_Parameter_Allocators,Max_Tasks,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-abort-statements}@anchor{1c9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-abort-statements}@anchor{1cc}
@subsection No_Abort_Statements
no calls to Task_Identification.Abort_Task.
@node No_Access_Parameter_Allocators,No_Access_Subprograms,No_Abort_Statements,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-parameter-allocators}@anchor{1ca}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-parameter-allocators}@anchor{1cd}
@subsection No_Access_Parameter_Allocators
parameter.
@node No_Access_Subprograms,No_Allocators,No_Access_Parameter_Allocators,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-subprograms}@anchor{1cb}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-subprograms}@anchor{1ce}
@subsection No_Access_Subprograms
declarations of access-to-subprogram types.
@node No_Allocators,No_Anonymous_Allocators,No_Access_Subprograms,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-allocators}@anchor{1cc}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-allocators}@anchor{1cf}
@subsection No_Allocators
occurrences of an allocator.
@node No_Anonymous_Allocators,No_Asynchronous_Control,No_Allocators,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-anonymous-allocators}@anchor{1cd}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-anonymous-allocators}@anchor{1d0}
@subsection No_Anonymous_Allocators
occurrences of an allocator of anonymous access type.
@node No_Asynchronous_Control,No_Calendar,No_Anonymous_Allocators,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-asynchronous-control}@anchor{1ce}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-asynchronous-control}@anchor{1d1}
@subsection No_Asynchronous_Control
dependences on the predefined package Asynchronous_Task_Control.
@node No_Calendar,No_Coextensions,No_Asynchronous_Control,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-calendar}@anchor{1cf}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-calendar}@anchor{1d2}
@subsection No_Calendar
dependences on package Calendar.
@node No_Coextensions,No_Default_Initialization,No_Calendar,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-coextensions}@anchor{1d0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-coextensions}@anchor{1d3}
@subsection No_Coextensions
coextensions. See 3.10.2.
@node No_Default_Initialization,No_Delay,No_Coextensions,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-default-initialization}@anchor{1d1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-default-initialization}@anchor{1d4}
@subsection No_Default_Initialization
initializer (including the case of OUT scalar parameters).
@node No_Delay,No_Dependence,No_Default_Initialization,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-delay}@anchor{1d2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-delay}@anchor{1d5}
@subsection No_Delay
delay statements and no semantic dependences on package Calendar.
@node No_Dependence,No_Direct_Boolean_Operators,No_Delay,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dependence}@anchor{1d3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dependence}@anchor{1d6}
@subsection No_Dependence
@end itemize
@node No_Direct_Boolean_Operators,No_Dispatch,No_Dependence,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-direct-boolean-operators}@anchor{1d4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-direct-boolean-operators}@anchor{1d7}
@subsection No_Direct_Boolean_Operators
composite boolean operations.
@node No_Dispatch,No_Dispatching_Calls,No_Direct_Boolean_Operators,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatch}@anchor{1d5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatch}@anchor{1d8}
@subsection No_Dispatch
occurrences of @code{T'Class}, for any (tagged) subtype @code{T}.
@node No_Dispatching_Calls,No_Dynamic_Attachment,No_Dispatch,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatching-calls}@anchor{1d6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatching-calls}@anchor{1d9}
@subsection No_Dispatching_Calls
@end example
@node No_Dynamic_Attachment,No_Dynamic_Priorities,No_Dispatching_Calls,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-attachment}@anchor{1d7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-attachment}@anchor{1da}
@subsection No_Dynamic_Attachment
warnings on obsolescent features are activated).
@node No_Dynamic_Priorities,No_Entry_Calls_In_Elaboration_Code,No_Dynamic_Attachment,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-priorities}@anchor{1d8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-priorities}@anchor{1db}
@subsection No_Dynamic_Priorities
[RM D.7] There are no semantic dependencies on the package Dynamic_Priorities.
@node No_Entry_Calls_In_Elaboration_Code,No_Enumeration_Maps,No_Dynamic_Priorities,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-calls-in-elaboration-code}@anchor{1d9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-calls-in-elaboration-code}@anchor{1dc}
@subsection No_Entry_Calls_In_Elaboration_Code
in a task can be executed at elaboration time.
@node No_Enumeration_Maps,No_Exception_Handlers,No_Entry_Calls_In_Elaboration_Code,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-enumeration-maps}@anchor{1da}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-enumeration-maps}@anchor{1dd}
@subsection No_Enumeration_Maps
to enumeration types).
@node No_Exception_Handlers,No_Exception_Propagation,No_Enumeration_Maps,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-handlers}@anchor{1db}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-handlers}@anchor{1de}
@subsection No_Exception_Handlers
represents the line number in the source program where the raise occurs.
@node No_Exception_Propagation,No_Exception_Registration,No_Exception_Handlers,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-propagation}@anchor{1dc}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-propagation}@anchor{1df}
@subsection No_Exception_Propagation
statements (raise with no operand) are not permitted.
@node No_Exception_Registration,No_Exceptions,No_Exception_Propagation,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-registration}@anchor{1dd}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-registration}@anchor{1e0}
@subsection No_Exception_Registration
of exceptions when they are declared.
@node No_Exceptions,No_Finalization,No_Exception_Registration,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exceptions}@anchor{1de}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exceptions}@anchor{1e1}
@subsection No_Exceptions
generation of language-defined run-time checks.
@node No_Finalization,No_Fixed_Point,No_Exceptions,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-finalization}@anchor{1df}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-finalization}@anchor{1e2}
@subsection No_Finalization
deallocation of a controlled object no longer finalizes its contents.
@node No_Fixed_Point,No_Floating_Point,No_Finalization,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-fixed-point}@anchor{1e0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-fixed-point}@anchor{1e3}
@subsection No_Fixed_Point
occurrences of fixed point types and operations.
@node No_Floating_Point,No_Implicit_Conditionals,No_Fixed_Point,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-floating-point}@anchor{1e1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-floating-point}@anchor{1e4}
@subsection No_Floating_Point
occurrences of floating point types and operations.
@node No_Implicit_Conditionals,No_Implicit_Dynamic_Code,No_Floating_Point,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-conditionals}@anchor{1e2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-conditionals}@anchor{1e5}
@subsection No_Implicit_Conditionals
of composite objects and the Max/Min attributes.
@node No_Implicit_Dynamic_Code,No_Implicit_Heap_Allocations,No_Implicit_Conditionals,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-dynamic-code}@anchor{1e3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-dynamic-code}@anchor{1e6}
@subsection No_Implicit_Dynamic_Code
types.
@node No_Implicit_Heap_Allocations,No_Implicit_Protected_Object_Allocations,No_Implicit_Dynamic_Code,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-heap-allocations}@anchor{1e4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-heap-allocations}@anchor{1e7}
@subsection No_Implicit_Heap_Allocations
[RM D.7] No constructs are allowed to cause implicit heap allocation.
@node No_Implicit_Protected_Object_Allocations,No_Implicit_Task_Allocations,No_Implicit_Heap_Allocations,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-protected-object-allocations}@anchor{1e5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-protected-object-allocations}@anchor{1e8}
@subsection No_Implicit_Protected_Object_Allocations
protected object.
@node No_Implicit_Task_Allocations,No_Initialize_Scalars,No_Implicit_Protected_Object_Allocations,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-task-allocations}@anchor{1e6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-task-allocations}@anchor{1e9}
@subsection No_Implicit_Task_Allocations
[GNAT] No constructs are allowed to cause implicit heap allocation of a task.
@node No_Initialize_Scalars,No_IO,No_Implicit_Task_Allocations,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-initialize-scalars}@anchor{1e7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-initialize-scalars}@anchor{1ea}
@subsection No_Initialize_Scalars
are otherwise generated for some record and array types.
@node No_IO,No_Local_Allocators,No_Initialize_Scalars,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-io}@anchor{1e8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-io}@anchor{1eb}
@subsection No_IO
Text_IO, Wide_Text_IO, Wide_Wide_Text_IO, or Stream_IO.
@node No_Local_Allocators,No_Local_Protected_Objects,No_IO,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-allocators}@anchor{1e9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-allocators}@anchor{1ec}
@subsection No_Local_Allocators
and entry bodies.
@node No_Local_Protected_Objects,No_Local_Tagged_Types,No_Local_Allocators,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-protected-objects}@anchor{1ea}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-protected-objects}@anchor{1ed}
@subsection No_Local_Protected_Objects
only declared at the library level.
@node No_Local_Tagged_Types,No_Local_Timing_Events,No_Local_Protected_Objects,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-tagged-types}@anchor{1eb}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-tagged-types}@anchor{1ee}
@subsection No_Local_Tagged_Types
declared at the library level.
@node No_Local_Timing_Events,No_Long_Long_Integers,No_Local_Tagged_Types,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-timing-events}@anchor{1ec}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-timing-events}@anchor{1ef}
@subsection No_Local_Timing_Events
declared at the library level.
@node No_Long_Long_Integers,No_Multiple_Elaboration,No_Local_Timing_Events,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-long-long-integers}@anchor{1ed}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-long-long-integers}@anchor{1f0}
@subsection No_Long_Long_Integers
Long_Integer’Size.
@node No_Multiple_Elaboration,No_Nested_Finalization,No_Long_Long_Integers,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-multiple-elaboration}@anchor{1ee}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-multiple-elaboration}@anchor{1f1}
@subsection No_Multiple_Elaboration
permitted and will be diagnosed by the binder.
@node No_Nested_Finalization,No_Protected_Type_Allocators,No_Multiple_Elaboration,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-nested-finalization}@anchor{1ef}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-nested-finalization}@anchor{1f2}
@subsection No_Nested_Finalization
[RM D.7] All objects requiring finalization are declared at the library level.
@node No_Protected_Type_Allocators,No_Protected_Types,No_Nested_Finalization,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-type-allocators}@anchor{1f0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-type-allocators}@anchor{1f3}
@subsection No_Protected_Type_Allocators
expressions that attempt to allocate protected objects.
@node No_Protected_Types,No_Recursion,No_Protected_Type_Allocators,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-types}@anchor{1f1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-types}@anchor{1f4}
@subsection No_Protected_Types
declarations of protected types or protected objects.
@node No_Recursion,No_Reentrancy,No_Protected_Types,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-recursion}@anchor{1f2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-recursion}@anchor{1f5}
@subsection No_Recursion
part of its execution.
@node No_Reentrancy,No_Relative_Delay,No_Recursion,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-reentrancy}@anchor{1f3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-reentrancy}@anchor{1f6}
@subsection No_Reentrancy
two tasks at the same time.
@node No_Relative_Delay,No_Requeue_Statements,No_Reentrancy,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-relative-delay}@anchor{1f4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-relative-delay}@anchor{1f7}
@subsection No_Relative_Delay
appearing in source code.
@node No_Requeue_Statements,No_Secondary_Stack,No_Relative_Delay,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-requeue-statements}@anchor{1f5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-requeue-statements}@anchor{1f8}
@subsection No_Requeue_Statements
warnings on oNobsolescent features are activated).
@node No_Secondary_Stack,No_Select_Statements,No_Requeue_Statements,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-secondary-stack}@anchor{1f6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-secondary-stack}@anchor{1f9}
@subsection No_Secondary_Stack
secondary stacks for tasks (excluding the environment task) at run time.
@node No_Select_Statements,No_Specific_Termination_Handlers,No_Secondary_Stack,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-select-statements}@anchor{1f7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-select-statements}@anchor{1fa}
@subsection No_Select_Statements
kind are permitted, that is the keyword @code{select} may not appear.
@node No_Specific_Termination_Handlers,No_Specification_of_Aspect,No_Select_Statements,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specific-termination-handlers}@anchor{1f8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specific-termination-handlers}@anchor{1fb}
@subsection No_Specific_Termination_Handlers
or to Ada.Task_Termination.Specific_Handler.
@node No_Specification_of_Aspect,No_Standard_Allocators_After_Elaboration,No_Specific_Termination_Handlers,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specification-of-aspect}@anchor{1f9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specification-of-aspect}@anchor{1fc}
@subsection No_Specification_of_Aspect
given aspect.
@node No_Standard_Allocators_After_Elaboration,No_Standard_Storage_Pools,No_Specification_of_Aspect,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-allocators-after-elaboration}@anchor{1fa}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-allocators-after-elaboration}@anchor{1fd}
@subsection No_Standard_Allocators_After_Elaboration
is raised.
@node No_Standard_Storage_Pools,No_Stream_Optimizations,No_Standard_Allocators_After_Elaboration,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-storage-pools}@anchor{1fb}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-storage-pools}@anchor{1fe}
@subsection No_Standard_Storage_Pools
user-defined storage pool.
@node No_Stream_Optimizations,No_Streams,No_Standard_Storage_Pools,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-stream-optimizations}@anchor{1fc}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-stream-optimizations}@anchor{1ff}
@subsection No_Stream_Optimizations
compiler performs all IO operations on a per-character basis.
@node No_Streams,No_Tagged_Type_Registration,No_Stream_Optimizations,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-streams}@anchor{1fd}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-streams}@anchor{200}
@subsection No_Streams
though this is not required.
@node No_Tagged_Type_Registration,No_Task_Allocators,No_Streams,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tagged-type-registration}@anchor{1fe}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tagged-type-registration}@anchor{201}
@subsection No_Tagged_Type_Registration
the No_Elaboration_Code restriction.
@node No_Task_Allocators,No_Task_At_Interrupt_Priority,No_Tagged_Type_Registration,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-allocators}@anchor{1ff}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-allocators}@anchor{202}
@subsection No_Task_Allocators
or types containing task subcomponents.
@node No_Task_At_Interrupt_Priority,No_Task_Attributes_Package,No_Task_Allocators,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-at-interrupt-priority}@anchor{200}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-at-interrupt-priority}@anchor{203}
@subsection No_Task_At_Interrupt_Priority
that an interrupt priority.
@node No_Task_Attributes_Package,No_Task_Hierarchy,No_Task_At_Interrupt_Priority,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-attributes-package}@anchor{201}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-attributes-package}@anchor{204}
@subsection No_Task_Attributes_Package
warnings on obsolescent features are activated).
@node No_Task_Hierarchy,No_Task_Termination,No_Task_Attributes_Package,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-hierarchy}@anchor{202}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-hierarchy}@anchor{205}
@subsection No_Task_Hierarchy
directly on the environment task of the partition.
@node No_Task_Termination,No_Tasking,No_Task_Hierarchy,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-termination}@anchor{203}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-termination}@anchor{206}
@subsection No_Task_Termination
[RM D.7] Tasks that terminate are erroneous.
@node No_Tasking,No_Terminate_Alternatives,No_Task_Termination,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tasking}@anchor{204}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tasking}@anchor{207}
@subsection No_Tasking
binder.
@node No_Terminate_Alternatives,No_Unchecked_Access,No_Tasking,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-terminate-alternatives}@anchor{205}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-terminate-alternatives}@anchor{208}
@subsection No_Terminate_Alternatives
[RM D.7] There are no selective accepts with terminate alternatives.
@node No_Unchecked_Access,No_Unchecked_Conversion,No_Terminate_Alternatives,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-access}@anchor{206}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-access}@anchor{209}
@subsection No_Unchecked_Access
occurrences of the Unchecked_Access attribute.
@node No_Unchecked_Conversion,No_Unchecked_Deallocation,No_Unchecked_Access,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-conversion}@anchor{207}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-conversion}@anchor{20a}
@subsection No_Unchecked_Conversion
dependences on the predefined generic function Unchecked_Conversion.
@node No_Unchecked_Deallocation,No_Use_Of_Attribute,No_Unchecked_Conversion,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-deallocation}@anchor{208}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-deallocation}@anchor{20b}
@subsection No_Unchecked_Deallocation
dependences on the predefined generic procedure Unchecked_Deallocation.
@node No_Use_Of_Attribute,No_Use_Of_Entity,No_Unchecked_Deallocation,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-attribute}@anchor{209}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-attribute}@anchor{20c}
@subsection No_Use_Of_Attribute
earlier versions of Ada.
@node No_Use_Of_Entity,No_Use_Of_Pragma,No_Use_Of_Attribute,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-entity}@anchor{20a}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-entity}@anchor{20d}
@subsection No_Use_Of_Entity
@end example
@node No_Use_Of_Pragma,Pure_Barriers,No_Use_Of_Entity,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-pragma}@anchor{20b}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-pragma}@anchor{20e}
@subsection No_Use_Of_Pragma
earlier versions of Ada.
@node Pure_Barriers,Simple_Barriers,No_Use_Of_Pragma,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions pure-barriers}@anchor{20c}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions pure-barriers}@anchor{20f}
@subsection Pure_Barriers
during the evaluation of the barriers.
@node Simple_Barriers,Static_Priorities,Pure_Barriers,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions simple-barriers}@anchor{20d}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions simple-barriers}@anchor{210}
@subsection Simple_Barriers
warnings on obsolescent features are activated).
@node Static_Priorities,Static_Storage_Size,Simple_Barriers,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-priorities}@anchor{20e}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-priorities}@anchor{211}
@subsection Static_Priorities
@code{Ada.Dynamic_Priorities}.
@node Static_Storage_Size,,Static_Priorities,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-storage-size}@anchor{20f}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-storage-size}@anchor{212}
@subsection Static_Storage_Size
in a Storage_Size pragma or attribute definition clause is static.
@node Program Unit Level Restrictions,,Partition-Wide Restrictions,Standard and Implementation Defined Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions id3}@anchor{210}@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{211}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions id3}@anchor{213}@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{214}
@section Program Unit Level Restrictions
@end menu
@node No_Elaboration_Code,No_Dynamic_Accessibility_Checks,,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-elaboration-code}@anchor{212}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-elaboration-code}@anchor{215}
@subsection No_Elaboration_Code
before elaboration and to control multiple elaboration attempts.
@node No_Dynamic_Accessibility_Checks,No_Dynamic_Sized_Objects,No_Elaboration_Code,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-accessibility-checks}@anchor{213}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-accessibility-checks}@anchor{216}
@subsection No_Dynamic_Accessibility_Checks
@end itemize
@node No_Dynamic_Sized_Objects,No_Entry_Queue,No_Dynamic_Accessibility_Checks,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-sized-objects}@anchor{214}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-sized-objects}@anchor{217}
@subsection No_Dynamic_Sized_Objects
with No_Secondary_Stack.
@node No_Entry_Queue,No_Implementation_Aspect_Specifications,No_Dynamic_Sized_Objects,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-queue}@anchor{215}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-queue}@anchor{218}
@subsection No_Entry_Queue
is made to queue a second task on such an entry.
@node No_Implementation_Aspect_Specifications,No_Implementation_Attributes,No_Entry_Queue,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-aspect-specifications}@anchor{216}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-aspect-specifications}@anchor{219}
@subsection No_Implementation_Aspect_Specifications
aspects that can be used are those defined in the Ada Reference Manual.
@node No_Implementation_Attributes,No_Implementation_Identifiers,No_Implementation_Aspect_Specifications,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-attributes}@anchor{217}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-attributes}@anchor{21a}
@subsection No_Implementation_Attributes
Manual.
@node No_Implementation_Identifiers,No_Implementation_Pragmas,No_Implementation_Attributes,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-identifiers}@anchor{218}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-identifiers}@anchor{21b}
@subsection No_Implementation_Identifiers
occur within language-defined packages.
@node No_Implementation_Pragmas,No_Implementation_Restrictions,No_Implementation_Identifiers,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-pragmas}@anchor{219}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-pragmas}@anchor{21c}
@subsection No_Implementation_Pragmas
pragmas that can be used are those defined in the Ada Reference Manual.
@node No_Implementation_Restrictions,No_Implementation_Units,No_Implementation_Pragmas,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-restrictions}@anchor{21a}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-restrictions}@anchor{21d}
@subsection No_Implementation_Restrictions
that can be used are those defined in the Ada Reference Manual.
@node No_Implementation_Units,No_Implicit_Aliasing,No_Implementation_Restrictions,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-units}@anchor{21b}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-units}@anchor{21e}
@subsection No_Implementation_Units
of packages Ada, Interfaces, or System.
@node No_Implicit_Aliasing,No_Implicit_Loops,No_Implementation_Units,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-aliasing}@anchor{21c}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-aliasing}@anchor{21f}
@subsection No_Implicit_Aliasing
the standard attribute Unchecked_Access which is preferable.
@node No_Implicit_Loops,No_Obsolescent_Features,No_Implicit_Aliasing,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-loops}@anchor{21d}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-loops}@anchor{220}
@subsection No_Implicit_Loops
is set in the spec of a package, it will not apply to its body.
@node No_Obsolescent_Features,No_Wide_Characters,No_Implicit_Loops,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-obsolescent-features}@anchor{21e}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-obsolescent-features}@anchor{221}
@subsection No_Obsolescent_Features
features are used, as defined in Annex J of the Ada Reference Manual.
@node No_Wide_Characters,Static_Dispatch_Tables,No_Obsolescent_Features,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-wide-characters}@anchor{21f}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-wide-characters}@anchor{222}
@subsection No_Wide_Characters
type @code{Character}).
@node Static_Dispatch_Tables,SPARK_05,No_Wide_Characters,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-dispatch-tables}@anchor{220}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-dispatch-tables}@anchor{223}
@subsection Static_Dispatch_Tables
associated with dispatch tables can be placed in read-only memory.
@node SPARK_05,,Static_Dispatch_Tables,Program Unit Level Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions spark-05}@anchor{221}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions spark-05}@anchor{224}
@subsection SPARK_05
@end example
@node Implementation Advice,Implementation Defined Characteristics,Standard and Implementation Defined Restrictions,Top
-@anchor{gnat_rm/implementation_advice doc}@anchor{222}@anchor{gnat_rm/implementation_advice id1}@anchor{223}@anchor{gnat_rm/implementation_advice implementation-advice}@anchor{a}
+@anchor{gnat_rm/implementation_advice doc}@anchor{225}@anchor{gnat_rm/implementation_advice id1}@anchor{226}@anchor{gnat_rm/implementation_advice implementation-advice}@anchor{a}
@chapter Implementation Advice
@end menu
@node RM 1 1 3 20 Error Detection,RM 1 1 3 31 Child Units,,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-1-1-3-20-error-detection}@anchor{224}
+@anchor{gnat_rm/implementation_advice rm-1-1-3-20-error-detection}@anchor{227}
@section RM 1.1.3(20): Error Detection
@geindex Child Units
@node RM 1 1 3 31 Child Units,RM 1 1 5 12 Bounded Errors,RM 1 1 3 20 Error Detection,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-1-1-3-31-child-units}@anchor{225}
+@anchor{gnat_rm/implementation_advice rm-1-1-3-31-child-units}@anchor{228}
@section RM 1.1.3(31): Child Units
@geindex Bounded errors
@node RM 1 1 5 12 Bounded Errors,RM 2 8 16 Pragmas,RM 1 1 3 31 Child Units,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-1-1-5-12-bounded-errors}@anchor{226}
+@anchor{gnat_rm/implementation_advice rm-1-1-5-12-bounded-errors}@anchor{229}
@section RM 1.1.5(12): Bounded Errors
@geindex Pragmas
@node RM 2 8 16 Pragmas,RM 2 8 17-19 Pragmas,RM 1 1 5 12 Bounded Errors,Implementation Advice
-@anchor{gnat_rm/implementation_advice id2}@anchor{227}@anchor{gnat_rm/implementation_advice rm-2-8-16-pragmas}@anchor{228}
+@anchor{gnat_rm/implementation_advice id2}@anchor{22a}@anchor{gnat_rm/implementation_advice rm-2-8-16-pragmas}@anchor{22b}
@section RM 2.8(16): Pragmas
@item
-@emph{Abort_Defer}
+`Abort_Defer'
@tab
@item
-@emph{Ada_83}
+`Ada_83'
@tab
@item
-@emph{Assert}
+`Assert'
@tab
@item
-@emph{CPP_Class}
+`CPP_Class'
@tab
@item
-@emph{CPP_Constructor}
+`CPP_Constructor'
@tab
@item
-@emph{Debug}
+`Debug'
@tab
@item
-@emph{Interface_Name}
+`Interface_Name'
@tab
@item
-@emph{Machine_Attribute}
+`Machine_Attribute'
@tab
@item
-@emph{Unimplemented_Unit}
+`Unimplemented_Unit'
@tab
@item
-@emph{Unchecked_Union}
+`Unchecked_Union'
@tab
@ref{7,,Implementation Defined Pragmas}.
@node RM 2 8 17-19 Pragmas,RM 3 5 2 5 Alternative Character Sets,RM 2 8 16 Pragmas,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-2-8-17-19-pragmas}@anchor{229}
+@anchor{gnat_rm/implementation_advice rm-2-8-17-19-pragmas}@anchor{22c}
@section RM 2.8(17-19): Pragmas
@end itemize
@end quotation
-See @ref{228,,RM 2.8(16); Pragmas}.
+See @ref{22b,,RM 2.8(16); Pragmas}.
@geindex Character Sets
@geindex Alternative Character Sets
@node RM 3 5 2 5 Alternative Character Sets,RM 3 5 4 28 Integer Types,RM 2 8 17-19 Pragmas,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-3-5-2-5-alternative-character-sets}@anchor{22a}
+@anchor{gnat_rm/implementation_advice rm-3-5-2-5-alternative-character-sets}@anchor{22d}
@section RM 3.5.2(5): Alternative Character Sets
@geindex Integer types
@node RM 3 5 4 28 Integer Types,RM 3 5 4 29 Integer Types,RM 3 5 2 5 Alternative Character Sets,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-3-5-4-28-integer-types}@anchor{22b}
+@anchor{gnat_rm/implementation_advice rm-3-5-4-28-integer-types}@anchor{22e}
@section RM 3.5.4(28): Integer Types
types of the machine are easily available.
@node RM 3 5 4 29 Integer Types,RM 3 5 5 8 Enumeration Values,RM 3 5 4 28 Integer Types,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-3-5-4-29-integer-types}@anchor{22c}
+@anchor{gnat_rm/implementation_advice rm-3-5-4-29-integer-types}@anchor{22f}
@section RM 3.5.4(29): Integer Types
@geindex Enumeration values
@node RM 3 5 5 8 Enumeration Values,RM 3 5 7 17 Float Types,RM 3 5 4 29 Integer Types,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-3-5-5-8-enumeration-values}@anchor{22d}
+@anchor{gnat_rm/implementation_advice rm-3-5-5-8-enumeration-values}@anchor{230}
@section RM 3.5.5(8): Enumeration Values
@geindex Float types
@node RM 3 5 7 17 Float Types,RM 3 6 2 11 Multidimensional Arrays,RM 3 5 5 8 Enumeration Values,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-3-5-7-17-float-types}@anchor{22e}
+@anchor{gnat_rm/implementation_advice rm-3-5-7-17-float-types}@anchor{231}
@section RM 3.5.7(17): Float Types
@geindex multidimensional
@node RM 3 6 2 11 Multidimensional Arrays,RM 9 6 30-31 Duration’Small,RM 3 5 7 17 Float Types,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-3-6-2-11-multidimensional-arrays}@anchor{22f}
+@anchor{gnat_rm/implementation_advice rm-3-6-2-11-multidimensional-arrays}@anchor{232}
@section RM 3.6.2(11): Multidimensional Arrays
row-major order, consistent with the notation used for multidimensional
array aggregates (see 4.3.3). However, if a pragma @code{Convention}
(@code{Fortran}, …) applies to a multidimensional array type, then
-column-major order should be used instead (see B.5, @emph{Interfacing with Fortran}).”
+column-major order should be used instead (see B.5, `Interfacing with Fortran').”
@end quotation
Followed.
@geindex Duration'Small
@node RM 9 6 30-31 Duration’Small,RM 10 2 1 12 Consistent Representation,RM 3 6 2 11 Multidimensional Arrays,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-9-6-30-31-duration-small}@anchor{230}
+@anchor{gnat_rm/implementation_advice rm-9-6-30-31-duration-small}@anchor{233}
@section RM 9.6(30-31): Duration’Small
Followed.
@node RM 10 2 1 12 Consistent Representation,RM 11 4 1 19 Exception Information,RM 9 6 30-31 Duration’Small,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-10-2-1-12-consistent-representation}@anchor{231}
+@anchor{gnat_rm/implementation_advice rm-10-2-1-12-consistent-representation}@anchor{234}
@section RM 10.2.1(12): Consistent Representation
@geindex Exception information
@node RM 11 4 1 19 Exception Information,RM 11 5 28 Suppression of Checks,RM 10 2 1 12 Consistent Representation,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-11-4-1-19-exception-information}@anchor{232}
+@anchor{gnat_rm/implementation_advice rm-11-4-1-19-exception-information}@anchor{235}
@section RM 11.4.1(19): Exception Information
@geindex suppression of
@node RM 11 5 28 Suppression of Checks,RM 13 1 21-24 Representation Clauses,RM 11 4 1 19 Exception Information,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-11-5-28-suppression-of-checks}@anchor{233}
+@anchor{gnat_rm/implementation_advice rm-11-5-28-suppression-of-checks}@anchor{236}
@section RM 11.5(28): Suppression of Checks
@geindex Representation clauses
@node RM 13 1 21-24 Representation Clauses,RM 13 2 6-8 Packed Types,RM 11 5 28 Suppression of Checks,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-1-21-24-representation-clauses}@anchor{234}
+@anchor{gnat_rm/implementation_advice rm-13-1-21-24-representation-clauses}@anchor{237}
@section RM 13.1 (21-24): Representation Clauses
@geindex Packed types
@node RM 13 2 6-8 Packed Types,RM 13 3 14-19 Address Clauses,RM 13 1 21-24 Representation Clauses,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-2-6-8-packed-types}@anchor{235}
+@anchor{gnat_rm/implementation_advice rm-13-2-6-8-packed-types}@anchor{238}
@section RM 13.2(6-8): Packed Types
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 @emph{record_representation_clause} that applies to the type; the
+any `record_representation_clause' that applies to the type; the
implementation may, but need not, reorder components or cross aligned
word boundaries to improve the packing. A component whose @code{Size} is
greater than the word size may be allocated an integral number of words.”
@geindex Address clauses
@node RM 13 3 14-19 Address Clauses,RM 13 3 29-35 Alignment Clauses,RM 13 2 6-8 Packed Types,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-3-14-19-address-clauses}@anchor{236}
+@anchor{gnat_rm/implementation_advice rm-13-3-14-19-address-clauses}@anchor{239}
@section RM 13.3(14-19): Address Clauses
@geindex Alignment clauses
@node RM 13 3 29-35 Alignment Clauses,RM 13 3 42-43 Size Clauses,RM 13 3 14-19 Address Clauses,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-3-29-35-alignment-clauses}@anchor{237}
+@anchor{gnat_rm/implementation_advice rm-13-3-29-35-alignment-clauses}@anchor{23a}
@section RM 13.3(29-35): Alignment Clauses
@geindex Size clauses
@node RM 13 3 42-43 Size Clauses,RM 13 3 50-56 Size Clauses,RM 13 3 29-35 Alignment Clauses,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-3-42-43-size-clauses}@anchor{238}
+@anchor{gnat_rm/implementation_advice rm-13-3-42-43-size-clauses}@anchor{23b}
@section RM 13.3(42-43): Size Clauses
Followed.
@node RM 13 3 50-56 Size Clauses,RM 13 3 71-73 Component Size Clauses,RM 13 3 42-43 Size Clauses,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-3-50-56-size-clauses}@anchor{239}
+@anchor{gnat_rm/implementation_advice rm-13-3-50-56-size-clauses}@anchor{23c}
@section RM 13.3(50-56): Size Clauses
@geindex Component_Size clauses
@node RM 13 3 71-73 Component Size Clauses,RM 13 4 9-10 Enumeration Representation Clauses,RM 13 3 50-56 Size Clauses,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-3-71-73-component-size-clauses}@anchor{23a}
+@anchor{gnat_rm/implementation_advice rm-13-3-71-73-component-size-clauses}@anchor{23d}
@section RM 13.3(71-73): Component Size Clauses
@geindex enumeration
@node RM 13 4 9-10 Enumeration Representation Clauses,RM 13 5 1 17-22 Record Representation Clauses,RM 13 3 71-73 Component Size Clauses,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-4-9-10-enumeration-representation-clauses}@anchor{23b}
+@anchor{gnat_rm/implementation_advice rm-13-4-9-10-enumeration-representation-clauses}@anchor{23e}
@section RM 13.4(9-10): Enumeration Representation Clauses
@geindex records
@node RM 13 5 1 17-22 Record Representation Clauses,RM 13 5 2 5 Storage Place Attributes,RM 13 4 9-10 Enumeration Representation Clauses,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-5-1-17-22-record-representation-clauses}@anchor{23c}
+@anchor{gnat_rm/implementation_advice rm-13-5-1-17-22-record-representation-clauses}@anchor{23f}
@section RM 13.5.1(17-22): Record Representation Clauses
@quotation
“The recommended level of support for
-@emph{record_representation_clause}s is:
+`record_representation_clause's 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,
@quotation
-“An implementation need not support a @emph{component_clause} for a
+“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.”
@geindex Storage place attributes
@node RM 13 5 2 5 Storage Place Attributes,RM 13 5 3 7-8 Bit Ordering,RM 13 5 1 17-22 Record Representation Clauses,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-5-2-5-storage-place-attributes}@anchor{23d}
+@anchor{gnat_rm/implementation_advice rm-13-5-2-5-storage-place-attributes}@anchor{240}
@section RM 13.5.2(5): Storage Place Attributes
@geindex Bit ordering
@node RM 13 5 3 7-8 Bit Ordering,RM 13 7 37 Address as Private,RM 13 5 2 5 Storage Place Attributes,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-5-3-7-8-bit-ordering}@anchor{23e}
+@anchor{gnat_rm/implementation_advice rm-13-5-3-7-8-bit-ordering}@anchor{241}
@section RM 13.5.3(7-8): Bit Ordering
@geindex as private type
@node RM 13 7 37 Address as Private,RM 13 7 1 16 Address Operations,RM 13 5 3 7-8 Bit Ordering,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-7-37-address-as-private}@anchor{23f}
+@anchor{gnat_rm/implementation_advice rm-13-7-37-address-as-private}@anchor{242}
@section RM 13.7(37): Address as Private
@geindex operations of
@node RM 13 7 1 16 Address Operations,RM 13 9 14-17 Unchecked Conversion,RM 13 7 37 Address as Private,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-7-1-16-address-operations}@anchor{240}
+@anchor{gnat_rm/implementation_advice rm-13-7-1-16-address-operations}@anchor{243}
@section RM 13.7.1(16): Address Operations
@geindex Unchecked conversion
@node RM 13 9 14-17 Unchecked Conversion,RM 13 11 23-25 Implicit Heap Usage,RM 13 7 1 16 Address Operations,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-9-14-17-unchecked-conversion}@anchor{241}
+@anchor{gnat_rm/implementation_advice rm-13-9-14-17-unchecked-conversion}@anchor{244}
@section RM 13.9(14-17): Unchecked Conversion
@geindex implicit
@node RM 13 11 23-25 Implicit Heap Usage,RM 13 11 2 17 Unchecked Deallocation,RM 13 9 14-17 Unchecked Conversion,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-11-23-25-implicit-heap-usage}@anchor{242}
+@anchor{gnat_rm/implementation_advice rm-13-11-23-25-implicit-heap-usage}@anchor{245}
@section RM 13.11(23-25): Implicit Heap Usage
@geindex Unchecked deallocation
@node RM 13 11 2 17 Unchecked Deallocation,RM 13 13 2 1 6 Stream Oriented Attributes,RM 13 11 23-25 Implicit Heap Usage,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-11-2-17-unchecked-deallocation}@anchor{243}
+@anchor{gnat_rm/implementation_advice rm-13-11-2-17-unchecked-deallocation}@anchor{246}
@section RM 13.11.2(17): Unchecked Deallocation
@geindex Stream oriented attributes
@node RM 13 13 2 1 6 Stream Oriented Attributes,RM A 1 52 Names of Predefined Numeric Types,RM 13 11 2 17 Unchecked Deallocation,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-13-13-2-1-6-stream-oriented-attributes}@anchor{244}
+@anchor{gnat_rm/implementation_advice rm-13-13-2-1-6-stream-oriented-attributes}@anchor{247}
@section RM 13.13.2(1.6): Stream Oriented Attributes
@geindex Stream oriented attributes
@node RM A 1 52 Names of Predefined Numeric Types,RM A 3 2 49 Ada Characters Handling,RM 13 13 2 1 6 Stream Oriented Attributes,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-a-1-52-names-of-predefined-numeric-types}@anchor{245}
+@anchor{gnat_rm/implementation_advice rm-a-1-52-names-of-predefined-numeric-types}@anchor{248}
@section RM A.1(52): Names of Predefined Numeric Types
@geindex Ada.Characters.Handling
@node RM A 3 2 49 Ada Characters Handling,RM A 4 4 106 Bounded-Length String Handling,RM A 1 52 Names of Predefined Numeric Types,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-a-3-2-49-ada-characters-handling}@anchor{246}
+@anchor{gnat_rm/implementation_advice rm-a-3-2-49-ada-characters-handling}@anchor{249}
@section RM A.3.2(49): @code{Ada.Characters.Handling}
@geindex Bounded-length strings
@node RM A 4 4 106 Bounded-Length String Handling,RM A 5 2 46-47 Random Number Generation,RM A 3 2 49 Ada Characters Handling,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-a-4-4-106-bounded-length-string-handling}@anchor{247}
+@anchor{gnat_rm/implementation_advice rm-a-4-4-106-bounded-length-string-handling}@anchor{24a}
@section RM A.4.4(106): Bounded-Length String Handling
@geindex Random number generation
@node RM A 5 2 46-47 Random Number Generation,RM A 10 7 23 Get_Immediate,RM A 4 4 106 Bounded-Length String Handling,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-a-5-2-46-47-random-number-generation}@anchor{248}
+@anchor{gnat_rm/implementation_advice rm-a-5-2-46-47-random-number-generation}@anchor{24b}
@section RM A.5.2(46-47): Random Number Generation
@geindex Get_Immediate
@node RM A 10 7 23 Get_Immediate,RM A 18 Containers,RM A 5 2 46-47 Random Number Generation,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-a-10-7-23-get-immediate}@anchor{249}
+@anchor{gnat_rm/implementation_advice rm-a-10-7-23-get-immediate}@anchor{24c}
@section RM A.10.7(23): @code{Get_Immediate}
@geindex Containers
@node RM A 18 Containers,RM B 1 39-41 Pragma Export,RM A 10 7 23 Get_Immediate,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-a-18-containers}@anchor{24a}
+@anchor{gnat_rm/implementation_advice rm-a-18-containers}@anchor{24d}
@section RM A.18: @code{Containers}
@geindex Export
@node RM B 1 39-41 Pragma Export,RM B 2 12-13 Package Interfaces,RM A 18 Containers,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-b-1-39-41-pragma-export}@anchor{24b}
+@anchor{gnat_rm/implementation_advice rm-b-1-39-41-pragma-export}@anchor{24e}
@section RM B.1(39-41): Pragma @code{Export}
@quotation
-“For each supported convention @emph{L} other than @code{Intrinsic}, an
+“For each supported convention `L' other than @code{Intrinsic}, an
implementation should support @code{Import} and @code{Export} pragmas
-for objects of @emph{L}-compatible types and for subprograms, and pragma
-@cite{Convention} for @emph{L}-eligible types and for subprograms,
+for objects of `L'-compatible types and for subprograms, and pragma
+@cite{Convention} for `L'-eligible types and for subprograms,
presuming the other language has corresponding features. Pragma
@code{Convention} need not be supported for scalar types.”
@end quotation
@geindex Interfaces
@node RM B 2 12-13 Package Interfaces,RM B 3 63-71 Interfacing with C,RM B 1 39-41 Pragma Export,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-b-2-12-13-package-interfaces}@anchor{24c}
+@anchor{gnat_rm/implementation_advice rm-b-2-12-13-package-interfaces}@anchor{24f}
@section RM B.2(12-13): Package @code{Interfaces}
@geindex interfacing with
@node RM B 3 63-71 Interfacing with C,RM B 4 95-98 Interfacing with COBOL,RM B 2 12-13 Package Interfaces,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-b-3-63-71-interfacing-with-c}@anchor{24d}
+@anchor{gnat_rm/implementation_advice rm-b-3-63-71-interfacing-with-c}@anchor{250}
@section RM B.3(63-71): Interfacing with C
@geindex interfacing with
@node RM B 4 95-98 Interfacing with COBOL,RM B 5 22-26 Interfacing with Fortran,RM B 3 63-71 Interfacing with C,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-b-4-95-98-interfacing-with-cobol}@anchor{24e}
+@anchor{gnat_rm/implementation_advice rm-b-4-95-98-interfacing-with-cobol}@anchor{251}
@section RM B.4(95-98): Interfacing with COBOL
@geindex interfacing with
@node RM B 5 22-26 Interfacing with Fortran,RM C 1 3-5 Access to Machine Operations,RM B 4 95-98 Interfacing with COBOL,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-b-5-22-26-interfacing-with-fortran}@anchor{24f}
+@anchor{gnat_rm/implementation_advice rm-b-5-22-26-interfacing-with-fortran}@anchor{252}
@section RM B.5(22-26): Interfacing with Fortran
@geindex Machine operations
@node RM C 1 3-5 Access to Machine Operations,RM C 1 10-16 Access to Machine Operations,RM B 5 22-26 Interfacing with Fortran,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-c-1-3-5-access-to-machine-operations}@anchor{250}
+@anchor{gnat_rm/implementation_advice rm-c-1-3-5-access-to-machine-operations}@anchor{253}
@section RM C.1(3-5): Access to Machine Operations
Followed.
@node RM C 1 10-16 Access to Machine Operations,RM C 3 28 Interrupt Support,RM C 1 3-5 Access to Machine Operations,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-c-1-10-16-access-to-machine-operations}@anchor{251}
+@anchor{gnat_rm/implementation_advice rm-c-1-10-16-access-to-machine-operations}@anchor{254}
@section RM C.1(10-16): Access to Machine Operations
@geindex Interrupt support
@node RM C 3 28 Interrupt Support,RM C 3 1 20-21 Protected Procedure Handlers,RM C 1 10-16 Access to Machine Operations,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-c-3-28-interrupt-support}@anchor{252}
+@anchor{gnat_rm/implementation_advice rm-c-3-28-interrupt-support}@anchor{255}
@section RM C.3(28): Interrupt Support
@geindex Protected procedure handlers
@node RM C 3 1 20-21 Protected Procedure Handlers,RM C 3 2 25 Package Interrupts,RM C 3 28 Interrupt Support,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-c-3-1-20-21-protected-procedure-handlers}@anchor{253}
+@anchor{gnat_rm/implementation_advice rm-c-3-1-20-21-protected-procedure-handlers}@anchor{256}
@section RM C.3.1(20-21): Protected Procedure Handlers
@geindex Interrupts
@node RM C 3 2 25 Package Interrupts,RM C 4 14 Pre-elaboration Requirements,RM C 3 1 20-21 Protected Procedure Handlers,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-c-3-2-25-package-interrupts}@anchor{254}
+@anchor{gnat_rm/implementation_advice rm-c-3-2-25-package-interrupts}@anchor{257}
@section RM C.3.2(25): Package @code{Interrupts}
@geindex Pre-elaboration requirements
@node RM C 4 14 Pre-elaboration Requirements,RM C 5 8 Pragma Discard_Names,RM C 3 2 25 Package Interrupts,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-c-4-14-pre-elaboration-requirements}@anchor{255}
+@anchor{gnat_rm/implementation_advice rm-c-4-14-pre-elaboration-requirements}@anchor{258}
@section RM C.4(14): Pre-elaboration Requirements
to initialize large arrays.
@node RM C 5 8 Pragma Discard_Names,RM C 7 2 30 The Package Task_Attributes,RM C 4 14 Pre-elaboration Requirements,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-c-5-8-pragma-discard-names}@anchor{256}
+@anchor{gnat_rm/implementation_advice rm-c-5-8-pragma-discard-names}@anchor{259}
@section RM C.5(8): Pragma @code{Discard_Names}
@geindex Task_Attributes
@node RM C 7 2 30 The Package Task_Attributes,RM D 3 17 Locking Policies,RM C 5 8 Pragma Discard_Names,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-c-7-2-30-the-package-task-attributes}@anchor{257}
+@anchor{gnat_rm/implementation_advice rm-c-7-2-30-the-package-task-attributes}@anchor{25a}
@section RM C.7.2(30): The Package Task_Attributes
@geindex Locking Policies
@node RM D 3 17 Locking Policies,RM D 4 16 Entry Queuing Policies,RM C 7 2 30 The Package Task_Attributes,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-d-3-17-locking-policies}@anchor{258}
+@anchor{gnat_rm/implementation_advice rm-d-3-17-locking-policies}@anchor{25b}
@section RM D.3(17): Locking Policies
@geindex Entry queuing policies
@node RM D 4 16 Entry Queuing Policies,RM D 6 9-10 Preemptive Abort,RM D 3 17 Locking Policies,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-d-4-16-entry-queuing-policies}@anchor{259}
+@anchor{gnat_rm/implementation_advice rm-d-4-16-entry-queuing-policies}@anchor{25c}
@section RM D.4(16): Entry Queuing Policies
@geindex Preemptive abort
@node RM D 6 9-10 Preemptive Abort,RM D 7 21 Tasking Restrictions,RM D 4 16 Entry Queuing Policies,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-d-6-9-10-preemptive-abort}@anchor{25a}
+@anchor{gnat_rm/implementation_advice rm-d-6-9-10-preemptive-abort}@anchor{25d}
@section RM D.6(9-10): Preemptive Abort
@quotation
-“Even though the @emph{abort_statement} is included in the list of
+“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 @emph{abort_statement} to block.”
+the `abort_statement' to block.”
@end quotation
Followed.
@geindex Tasking restrictions
@node RM D 7 21 Tasking Restrictions,RM D 8 47-49 Monotonic Time,RM D 6 9-10 Preemptive Abort,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-d-7-21-tasking-restrictions}@anchor{25b}
+@anchor{gnat_rm/implementation_advice rm-d-7-21-tasking-restrictions}@anchor{25e}
@section RM D.7(21): Tasking Restrictions
@geindex monotonic
@node RM D 8 47-49 Monotonic Time,RM E 5 28-29 Partition Communication Subsystem,RM D 7 21 Tasking Restrictions,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-d-8-47-49-monotonic-time}@anchor{25c}
+@anchor{gnat_rm/implementation_advice rm-d-8-47-49-monotonic-time}@anchor{25f}
@section RM D.8(47-49): Monotonic Time
@geindex PCS
@node RM E 5 28-29 Partition Communication Subsystem,RM F 7 COBOL Support,RM D 8 47-49 Monotonic Time,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-e-5-28-29-partition-communication-subsystem}@anchor{25d}
+@anchor{gnat_rm/implementation_advice rm-e-5-28-29-partition-communication-subsystem}@anchor{260}
@section RM E.5(28-29): Partition Communication Subsystem
@geindex COBOL support
@node RM F 7 COBOL Support,RM F 1 2 Decimal Radix Support,RM E 5 28-29 Partition Communication Subsystem,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-f-7-cobol-support}@anchor{25e}
+@anchor{gnat_rm/implementation_advice rm-f-7-cobol-support}@anchor{261}
@section RM F(7): COBOL Support
@geindex Decimal radix support
@node RM F 1 2 Decimal Radix Support,RM G Numerics,RM F 7 COBOL Support,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-f-1-2-decimal-radix-support}@anchor{25f}
+@anchor{gnat_rm/implementation_advice rm-f-1-2-decimal-radix-support}@anchor{262}
@section RM F.1(2): Decimal Radix Support
@geindex Numerics
@node RM G Numerics,RM G 1 1 56-58 Complex Types,RM F 1 2 Decimal Radix Support,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-g-numerics}@anchor{260}
+@anchor{gnat_rm/implementation_advice rm-g-numerics}@anchor{263}
@section RM G: Numerics
@geindex Complex types
@node RM G 1 1 56-58 Complex Types,RM G 1 2 49 Complex Elementary Functions,RM G Numerics,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-g-1-1-56-58-complex-types}@anchor{261}
+@anchor{gnat_rm/implementation_advice rm-g-1-1-56-58-complex-types}@anchor{264}
@section RM G.1.1(56-58): Complex Types
@geindex Complex elementary functions
@node RM G 1 2 49 Complex Elementary Functions,RM G 2 4 19 Accuracy Requirements,RM G 1 1 56-58 Complex Types,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-g-1-2-49-complex-elementary-functions}@anchor{262}
+@anchor{gnat_rm/implementation_advice rm-g-1-2-49-complex-elementary-functions}@anchor{265}
@section RM G.1.2(49): Complex Elementary Functions
@geindex Accuracy requirements
@node RM G 2 4 19 Accuracy Requirements,RM G 2 6 15 Complex Arithmetic Accuracy,RM G 1 2 49 Complex Elementary Functions,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-g-2-4-19-accuracy-requirements}@anchor{263}
+@anchor{gnat_rm/implementation_advice rm-g-2-4-19-accuracy-requirements}@anchor{266}
@section RM G.2.4(19): Accuracy Requirements
@geindex complex arithmetic
@node RM G 2 6 15 Complex Arithmetic Accuracy,RM H 6 15/2 Pragma Partition_Elaboration_Policy,RM G 2 4 19 Accuracy Requirements,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-g-2-6-15-complex-arithmetic-accuracy}@anchor{264}
+@anchor{gnat_rm/implementation_advice rm-g-2-6-15-complex-arithmetic-accuracy}@anchor{267}
@section RM G.2.6(15): Complex Arithmetic Accuracy
@geindex Sequential elaboration policy
@node RM H 6 15/2 Pragma Partition_Elaboration_Policy,,RM G 2 6 15 Complex Arithmetic Accuracy,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-h-6-15-2-pragma-partition-elaboration-policy}@anchor{265}
+@anchor{gnat_rm/implementation_advice rm-h-6-15-2-pragma-partition-elaboration-policy}@anchor{268}
@section RM H.6(15/2): Pragma Partition_Elaboration_Policy
Not followed.
@node Implementation Defined Characteristics,Intrinsic Subprograms,Implementation Advice,Top
-@anchor{gnat_rm/implementation_defined_characteristics doc}@anchor{266}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{267}@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}
+@anchor{gnat_rm/implementation_defined_characteristics doc}@anchor{269}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{26a}@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}
@chapter Implementation Defined Characteristics
interactions. See 1.1.3(10).”
@end itemize
-Any @emph{code_statement} can potentially cause external interactions.
+Any `code_statement' can potentially cause external interactions.
@itemize *
The maximum line length is 255 characters and the maximum length of
a lexical element is also 255 characters. This is the default setting
-if not overridden by the use of compiler switch @emph{-gnaty} (which
-sets the maximum to 79) or @emph{-gnatyMnn} which allows the maximum
+if not overridden by the use of compiler switch `-gnaty' (which
+sets the maximum to 79) or `-gnatyMnn' which allows the maximum
line length to be specified to be any value up to 32767. The maximum
length of a lexical element is the same as the maximum line length.
@item
-@emph{Short_Short_Integer}
+`Short_Short_Integer'
@tab
@item
-@emph{Short_Integer}
+`Short_Integer'
@tab
@item
-@emph{Integer}
+`Integer'
@tab
@item
-@emph{Long_Integer}
+`Long_Integer'
@tab
@item
-@emph{Long_Long_Integer}
+`Long_Long_Integer'
@tab
@item
-@emph{Long_Long_Long_Integer}
+`Long_Long_Long_Integer'
@tab
@item
-@emph{Short_Float}
+`Short_Float'
@tab
@item
-@emph{Float}
+`Float'
@tab
@item
-@emph{Long_Float}
+`Long_Float'
@tab
@item
-@emph{Long_Long_Float}
+`Long_Long_Float'
@tab
@item
“The result of @code{Tags.Expanded_Name} for types declared
-within an unnamed @emph{block_statement}. See 3.9(10).”
+within an unnamed `block_statement'. See 3.9(10).”
@end itemize
-Block numbers of the form @code{B@emph{nnn}}, where @emph{nnn} is a
+Block numbers of the form @code{B@var{nnn}}, where `nnn' is a
decimal integer are allocated.
“Any extensions of the Default_Initial_Condition aspect. See 7.3.3(11).”
@end itemize
-SPARK allows specifying @emph{null} as the Default_Initial_Condition
+SPARK allows specifying `null' as the Default_Initial_Condition
aspect of a type. See the SPARK reference manual for further details.
@itemize *
@item
-“Any limit on @emph{delay_until_statements} of
-@emph{select_statements}. See 9.6(29).”
+“Any limit on `delay_until_statements' of
+`select_statements'. See 9.6(29).”
@end itemize
There are no such limits.
@end itemize
A compilation is represented by a sequence of files presented to the
-compiler in a single invocation of the @emph{gcc} command.
+compiler in a single invocation of the `gcc' command.
@itemize *
If the partition contains no main program, or if the main program is in
a language other than Ada, then GNAT
-provides the binder options @emph{-z} and @emph{-n} respectively, and in
+provides the binder options `-z' and `-n' respectively, and in
this case a list of units can be explicitly supplied to the binder for
inclusion in the partition (all units needed by these units will also
be included automatically). For full details on the use of these
-options, refer to @emph{GNAT Make Program gnatmake} in the
+options, refer to `GNAT Make Program gnatmake' in the
@cite{GNAT User’s Guide}.
@itemize *
@item
-“The order of elaboration of @emph{library_items}. See 10.2(18).”
+“The order of elaboration of `library_items'. See 10.2(18).”
@end itemize
The first constraint on ordering is that it meets the requirements of
@item
“The result of @code{Exceptions.Exception_Name} for types
-declared within an unnamed @emph{block_statement}. See 11.4.1(12).”
+declared within an unnamed `block_statement'. See 11.4.1(12).”
@end itemize
-Blocks have implementation defined names of the form @code{B@emph{nnn}}
-where @emph{nnn} is an integer.
+Blocks have implementation defined names of the form @code{B@var{nnn}}
+where `nnn' is an integer.
@itemize *
such aspects and the legality rules for such aspects. See 13.1.1(38).”
@end itemize
-See @ref{126,,Implementation Defined Aspects}.
+See @ref{128,,Implementation Defined Aspects}.
@itemize *
@item
“The contents of the visible part of package @code{System.Machine_Code},
-and the meaning of @emph{code_statements}. See 13.8(7).”
+and the meaning of `code_statements'. See 13.8(7).”
@end itemize
See the definition and documentation in file @code{s-maccod.ads}.
Annex is not supported. See A.5.3(72).”
@end itemize
-Running the compiler with @emph{-gnatS} to produce a listing of package
+Running the compiler with `-gnatS' to produce a listing of package
@code{Standard} displays the values of these attributes.
according to the syntax of regular expressions as defined in the
@code{GNAT.Regexp} package.
-See @ref{268,,GNAT.Regexp (g-regexp.ads)}.
+See @ref{26b,,GNAT.Regexp (g-regexp.ads)}.
@itemize *
@item
-@emph{Ada}
+`Ada'
@tab
@item
-@emph{Ada_Pass_By_Copy}
+`Ada_Pass_By_Copy'
@tab
@item
-@emph{Ada_Pass_By_Reference}
+`Ada_Pass_By_Reference'
@tab
@item
-@emph{Assembler}
+`Assembler'
@tab
@item
-@emph{Asm}
+`Asm'
@tab
@item
-@emph{Assembly}
+`Assembly'
@tab
@item
-@emph{C}
+`C'
@tab
@item
-@emph{C_Pass_By_Copy}
+`C_Pass_By_Copy'
@tab
@item
-@emph{COBOL}
+`COBOL'
@tab
@item
-@emph{C_Plus_Plus (or CPP)}
+`C_Plus_Plus (or CPP)'
@tab
@item
-@emph{Default}
+`Default'
@tab
@item
-@emph{External}
+`External'
@tab
@item
-@emph{Fortran}
+`Fortran'
@tab
@item
-@emph{Intrinsic}
+`Intrinsic'
@tab
@item
-@emph{Stdcall}
+`Stdcall'
@tab
@item
-@emph{DLL}
+`DLL'
@tab
@item
-@emph{Win32}
+`Win32'
@tab
@item
-@emph{Stubbed}
+`Stubbed'
@tab
@item
-@emph{Floating}
+`Floating'
@tab
@item
-@emph{Long_Floating}
+`Long_Floating'
@tab
@item
-@emph{Binary}
+`Binary'
@tab
@item
-@emph{Long_Binary}
+`Long_Binary'
@tab
@item
-@emph{Decimal_Element}
+`Decimal_Element'
@tab
@item
-@emph{COBOL_Character}
+`COBOL_Character'
@tab
The result of this attribute is a string that identifies
the object or component that denotes a given task. If a variable @code{Var}
-has a task type, the image for this task will have the form @code{Var_@emph{XXXXXXXX}},
-where the suffix @emph{XXXXXXXX}
+has a task type, the image for this task will have the form @code{Var_@var{XXXXXXXX}},
+where the suffix `XXXXXXXX'
is the hexadecimal representation of the virtual address of the corresponding
task control block. If the variable is an array of tasks, the image of each
task will have the form of an indexed component indicating the position of a
-given task in the array, e.g., @code{Group(5)_@emph{XXXXXXX}}. If the task is a
+given task in the array, e.g., @code{Group(5)_@var{XXXXXXX}}. If the task is a
component of a record, the image of the task will have the form of a selected
component. These rules are fully recursive, so that the image of a task that
is a subcomponent of a composite object corresponds to the expression that
@itemize *
@item
-“Implementation-defined @emph{policy_identifiers} allowed
+“Implementation-defined `policy_identifiers' allowed
in a pragma @code{Locking_Policy}. See D.3(4).”
@end itemize
@item
-@emph{Max_Scale}
+`Max_Scale'
@tab
@item
-@emph{Min_Scale}
+`Min_Scale'
@tab
@item
-@emph{Min_Delta}
+`Min_Delta'
@tab
@item
-@emph{Max_Delta}
+`Max_Delta'
@tab
@item
-@emph{Max_Decimal_Digits}
+`Max_Decimal_Digits'
@tab
Infinite and NaN values are produced as dictated by the IEEE
floating-point standard.
Note that on machines that are not fully compliant with the IEEE
-floating-point standard, such as Alpha, the @emph{-mieee} compiler flag
+floating-point standard, such as Alpha, the `-mieee' compiler flag
must be used for achieving IEEE conforming behavior (although at the cost
of a significant performance penalty), so infinite and NaN values are
properly generated.
@itemize *
@item
-“Conditions on a @emph{universal_real} operand of a fixed
+“Conditions on a `universal_real' operand of a fixed
point multiplication or division for which the result shall be in the
perfect result set. See G.2.3(22).”
@end itemize
Execution is erroneous in that case.
@node Intrinsic Subprograms,Representation Clauses and Pragmas,Implementation Defined Characteristics,Top
-@anchor{gnat_rm/intrinsic_subprograms doc}@anchor{269}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{26a}@anchor{gnat_rm/intrinsic_subprograms intrinsic-subprograms}@anchor{c}
+@anchor{gnat_rm/intrinsic_subprograms doc}@anchor{26c}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{26d}@anchor{gnat_rm/intrinsic_subprograms intrinsic-subprograms}@anchor{c}
@chapter Intrinsic Subprograms
@end menu
@node Intrinsic Operators,Compilation_ISO_Date,,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id2}@anchor{26b}@anchor{gnat_rm/intrinsic_subprograms intrinsic-operators}@anchor{26c}
+@anchor{gnat_rm/intrinsic_subprograms id2}@anchor{26e}@anchor{gnat_rm/intrinsic_subprograms intrinsic-operators}@anchor{26f}
@section Intrinsic Operators
full views are appropriate arithmetic types.
@node Compilation_ISO_Date,Compilation_Date,Intrinsic Operators,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms compilation-iso-date}@anchor{26d}@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{26e}
+@anchor{gnat_rm/intrinsic_subprograms compilation-iso-date}@anchor{270}@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{271}
@section Compilation_ISO_Date
the current compilation (in local time format YYYY-MM-DD).
@node Compilation_Date,Compilation_Time,Compilation_ISO_Date,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms compilation-date}@anchor{26f}@anchor{gnat_rm/intrinsic_subprograms id4}@anchor{270}
+@anchor{gnat_rm/intrinsic_subprograms compilation-date}@anchor{272}@anchor{gnat_rm/intrinsic_subprograms id4}@anchor{273}
@section Compilation_Date
MMM DD YYYY.
@node Compilation_Time,Enclosing_Entity,Compilation_Date,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms compilation-time}@anchor{271}@anchor{gnat_rm/intrinsic_subprograms id5}@anchor{272}
+@anchor{gnat_rm/intrinsic_subprograms compilation-time}@anchor{274}@anchor{gnat_rm/intrinsic_subprograms id5}@anchor{275}
@section Compilation_Time
the current compilation (in local time format HH:MM:SS).
@node Enclosing_Entity,Exception_Information,Compilation_Time,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms enclosing-entity}@anchor{273}@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{274}
+@anchor{gnat_rm/intrinsic_subprograms enclosing-entity}@anchor{276}@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{277}
@section Enclosing_Entity
the current subprogram, package, task, entry, or protected subprogram.
@node Exception_Information,Exception_Message,Enclosing_Entity,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms exception-information}@anchor{275}@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{276}
+@anchor{gnat_rm/intrinsic_subprograms exception-information}@anchor{278}@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{279}
@section Exception_Information
the exception information associated with the current exception.
@node Exception_Message,Exception_Name,Exception_Information,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms exception-message}@anchor{277}@anchor{gnat_rm/intrinsic_subprograms id8}@anchor{278}
+@anchor{gnat_rm/intrinsic_subprograms exception-message}@anchor{27a}@anchor{gnat_rm/intrinsic_subprograms id8}@anchor{27b}
@section Exception_Message
the message associated with the current exception.
@node Exception_Name,File,Exception_Message,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms exception-name}@anchor{279}@anchor{gnat_rm/intrinsic_subprograms id9}@anchor{27a}
+@anchor{gnat_rm/intrinsic_subprograms exception-name}@anchor{27c}@anchor{gnat_rm/intrinsic_subprograms id9}@anchor{27d}
@section Exception_Name
the name of the current exception.
@node File,Line,Exception_Name,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms file}@anchor{27b}@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{27c}
+@anchor{gnat_rm/intrinsic_subprograms file}@anchor{27e}@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{27f}
@section File
file.
@node Line,Shifts and Rotates,File,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id11}@anchor{27d}@anchor{gnat_rm/intrinsic_subprograms line}@anchor{27e}
+@anchor{gnat_rm/intrinsic_subprograms id11}@anchor{280}@anchor{gnat_rm/intrinsic_subprograms line}@anchor{281}
@section Line
source line.
@node Shifts and Rotates,Source_Location,Line,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{27f}@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{280}
+@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{282}@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{283}
@section Shifts and Rotates
number may change its sign bit to positive.
@node Source_Location,,Shifts and Rotates,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id13}@anchor{281}@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{282}
+@anchor{gnat_rm/intrinsic_subprograms id13}@anchor{284}@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{285}
@section Source_Location
source file location.
@node Representation Clauses and Pragmas,Standard Library Routines,Intrinsic Subprograms,Top
-@anchor{gnat_rm/representation_clauses_and_pragmas doc}@anchor{283}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{284}@anchor{gnat_rm/representation_clauses_and_pragmas representation-clauses-and-pragmas}@anchor{d}
+@anchor{gnat_rm/representation_clauses_and_pragmas doc}@anchor{286}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{287}@anchor{gnat_rm/representation_clauses_and_pragmas representation-clauses-and-pragmas}@anchor{d}
@chapter Representation Clauses and Pragmas
@end menu
@node Alignment Clauses,Size Clauses,,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas alignment-clauses}@anchor{285}@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{286}
+@anchor{gnat_rm/representation_clauses_and_pragmas alignment-clauses}@anchor{288}@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{289}
@section Alignment Clauses
@itemize *
@item
-@emph{Elementary Types}.
+`Elementary Types'.
For elementary types, the alignment is the minimum of the actual size of
objects of the type divided by @code{Storage_Unit},
and the maximum alignment supported by the target.
(This maximum alignment is given by the GNAT-specific attribute
-@code{Standard'Maximum_Alignment}; see @ref{196,,Attribute Maximum_Alignment}.)
+@code{Standard'Maximum_Alignment}; see @ref{199,,Attribute Maximum_Alignment}.)
@geindex Maximum_Alignment attribute
aligned.
@item
-@emph{Arrays}.
+`Arrays'.
For arrays, the alignment is equal to the alignment of the component type
for the normal case where no packing or component size is given. If the
31 bits will have an object size of four bytes, and an alignment of 4.
@item
-@emph{Records}.
+`Records'.
For the normal unpacked case, the alignment of a record is equal to
the maximum alignment of any of its components. For tagged records, this
alignments for the subtype @code{RS}.
@node Size Clauses,Storage_Size Clauses,Alignment Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id3}@anchor{287}@anchor{gnat_rm/representation_clauses_and_pragmas size-clauses}@anchor{288}
+@anchor{gnat_rm/representation_clauses_and_pragmas id3}@anchor{28a}@anchor{gnat_rm/representation_clauses_and_pragmas size-clauses}@anchor{28b}
@section Size Clauses
type Integer.
@node Storage_Size Clauses,Size of Variant Record Objects,Size Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id4}@anchor{289}@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{28a}
+@anchor{gnat_rm/representation_clauses_and_pragmas id4}@anchor{28c}@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{28d}
@section Storage_Size Clauses
modified as required. Any tasks requiring stack sizes different from the
default can have an appropriate alternative reference in the pragma.
-You can also use the @emph{-d} binder switch to modify the default stack
+You can also use the `-d' binder switch to modify the default stack
size.
For access types, the @code{Storage_Size} clause specifies the maximum
case of such an access declaration.
@node Size of Variant Record Objects,Biased Representation,Storage_Size Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id5}@anchor{28b}@anchor{gnat_rm/representation_clauses_and_pragmas size-of-variant-record-objects}@anchor{28c}
+@anchor{gnat_rm/representation_clauses_and_pragmas id5}@anchor{28e}@anchor{gnat_rm/representation_clauses_and_pragmas size-of-variant-record-objects}@anchor{28f}
@section Size of Variant Record Objects
variant value.
@node Biased Representation,Value_Size and Object_Size Clauses,Size of Variant Record Objects,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas biased-representation}@anchor{28d}@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{28e}
+@anchor{gnat_rm/representation_clauses_and_pragmas biased-representation}@anchor{290}@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{291}
@section Biased Representation
enumeration types for which a representation clause is given.
@node Value_Size and Object_Size Clauses,Component_Size Clauses,Biased Representation,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id7}@anchor{28f}@anchor{gnat_rm/representation_clauses_and_pragmas value-size-and-object-size-clauses}@anchor{290}
+@anchor{gnat_rm/representation_clauses_and_pragmas id7}@anchor{292}@anchor{gnat_rm/representation_clauses_and_pragmas value-size-and-object-size-clauses}@anchor{293}
@section Value_Size and Object_Size Clauses
@item
The @code{Object_Size} for base subtypes reflect the natural hardware
-size in bits (run the compiler with @emph{-gnatS} to find those values
+size in bits (run the compiler with `-gnatS' to find those values
for numeric types). Enumeration types and fixed-point base subtypes have
8, 16, 32, or 64 bits for this size, depending on the range of values
to be stored.
warning can be turned off using @code{-gnatw.B}.
@node Component_Size Clauses,Bit_Order Clauses,Value_Size and Object_Size Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas component-size-clauses}@anchor{291}@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{292}
+@anchor{gnat_rm/representation_clauses_and_pragmas component-size-clauses}@anchor{294}@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{295}
@section Component_Size Clauses
clauses are given, the pragma Pack will be ignored.
@node Bit_Order Clauses,Effect of Bit_Order on Byte Ordering,Component_Size Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas bit-order-clauses}@anchor{293}@anchor{gnat_rm/representation_clauses_and_pragmas id9}@anchor{294}
+@anchor{gnat_rm/representation_clauses_and_pragmas bit-order-clauses}@anchor{296}@anchor{gnat_rm/representation_clauses_and_pragmas id9}@anchor{297}
@section Bit_Order Clauses
details regarding the issue of byte ordering.
@node Effect of Bit_Order on Byte Ordering,Pragma Pack for Arrays,Bit_Order Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-bit-order-on-byte-ordering}@anchor{295}@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{296}
+@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-bit-order-on-byte-ordering}@anchor{298}@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{299}
@section Effect of Bit_Order on Byte Ordering
an appropriate manner.
@node Pragma Pack for Arrays,Pragma Pack for Records,Effect of Bit_Order on Byte Ordering,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id11}@anchor{297}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{298}
+@anchor{gnat_rm/representation_clauses_and_pragmas id11}@anchor{29a}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{29b}
@section Pragma Pack for Arrays
@geindex Pragma Pack (for arrays)
Pragma @code{Pack} applied to an array has an effect that depends upon whether the
-component type is @emph{packable}. For a component type to be @emph{packable}, it must
+component type is `packable'. For a component type to be `packable', it must
be one of the following cases:
since in this case the programmer intention is clear.
@node Pragma Pack for Records,Record Representation Clauses,Pragma Pack for Arrays,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id12}@anchor{299}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{29a}
+@anchor{gnat_rm/representation_clauses_and_pragmas id12}@anchor{29c}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{29d}
@section Pragma Pack for Records
Pragma @code{Pack} applied to a record will pack the components to reduce
wasted space from alignment gaps and by reducing the amount of space
-taken by components. We distinguish between @emph{packable} components and
-@emph{non-packable} components.
+taken by components. We distinguish between `packable' components and
+`non-packable' components.
Components of the following types are considered packable:
boundary, and takes an integral number of bytes, i.e., 72 bits.
@node Record Representation Clauses,Handling of Records with Holes,Pragma Pack for Records,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id13}@anchor{29b}@anchor{gnat_rm/representation_clauses_and_pragmas record-representation-clauses}@anchor{29c}
+@anchor{gnat_rm/representation_clauses_and_pragmas id13}@anchor{29e}@anchor{gnat_rm/representation_clauses_and_pragmas record-representation-clauses}@anchor{29f}
@section Record Representation Clauses
@end example
@node Handling of Records with Holes,Enumeration Clauses,Record Representation Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas handling-of-records-with-holes}@anchor{29d}@anchor{gnat_rm/representation_clauses_and_pragmas id14}@anchor{29e}
+@anchor{gnat_rm/representation_clauses_and_pragmas handling-of-records-with-holes}@anchor{2a0}@anchor{gnat_rm/representation_clauses_and_pragmas id14}@anchor{2a1}
@section Handling of Records with Holes
@end example
@node Enumeration Clauses,Address Clauses,Handling of Records with Holes,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas enumeration-clauses}@anchor{29f}@anchor{gnat_rm/representation_clauses_and_pragmas id15}@anchor{2a0}
+@anchor{gnat_rm/representation_clauses_and_pragmas enumeration-clauses}@anchor{2a2}@anchor{gnat_rm/representation_clauses_and_pragmas id15}@anchor{2a3}
@section Enumeration Clauses
0 .. System.Max_Binary_Modulus;
@end example
-A @emph{confirming} representation clause is one in which the values range
+A `confirming' representation clause is one in which the values range
from 0 in sequence, i.e., a clause that confirms the default representation
for an enumeration type.
Such a confirming representation
positional values, (i.e., the value delivered by the @code{Pos} attribute).
@node Address Clauses,Use of Address Clauses for Memory-Mapped I/O,Enumeration Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas address-clauses}@anchor{2a1}@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{2a2}
+@anchor{gnat_rm/representation_clauses_and_pragmas address-clauses}@anchor{2a4}@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{2a5}
@section Address Clauses
the output @code{X was not clobbered}.
@node Use of Address Clauses for Memory-Mapped I/O,Effect of Convention on Representation,Address Clauses,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas id17}@anchor{2a3}@anchor{gnat_rm/representation_clauses_and_pragmas use-of-address-clauses-for-memory-mapped-i-o}@anchor{2a4}
+@anchor{gnat_rm/representation_clauses_and_pragmas id17}@anchor{2a6}@anchor{gnat_rm/representation_clauses_and_pragmas use-of-address-clauses-for-memory-mapped-i-o}@anchor{2a7}
@section Use of Address Clauses for Memory-Mapped I/O
pragma @code{Atomic} and will give the additional guarantee.
@node Effect of Convention on Representation,Conventions and Anonymous Access Types,Use of Address Clauses for Memory-Mapped I/O,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-convention-on-representation}@anchor{2a5}@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{2a6}
+@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-convention-on-representation}@anchor{2a8}@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{2a9}
@section Effect of Convention on Representation
@itemize *
@item
-@emph{Convention Fortran and array subtypes}.
+`Convention Fortran and array subtypes'.
If pragma Convention Fortran is specified for an array subtype, then in
accordance with the implementation advice in section 3.6.2(11) of the
column-major manner, instead of the normal default row-major order.
@item
-@emph{Convention C and enumeration types}
+`Convention C and enumeration types'
GNAT normally stores enumeration types in 8, 16, or 32 bits as required
to accommodate all values of the type. For example, for the enumeration
size clause specifying the desired size.
@item
-@emph{Convention C/Fortran and Boolean types}
+`Convention C/Fortran and Boolean types'
In C, the usual convention for boolean values, that is values used for
conditions, is that zero represents false, and nonzero values represent
@end itemize
@node Conventions and Anonymous Access Types,Determining the Representations chosen by GNAT,Effect of Convention on Representation,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas conventions-and-anonymous-access-types}@anchor{2a7}@anchor{gnat_rm/representation_clauses_and_pragmas id19}@anchor{2a8}
+@anchor{gnat_rm/representation_clauses_and_pragmas conventions-and-anonymous-access-types}@anchor{2aa}@anchor{gnat_rm/representation_clauses_and_pragmas id19}@anchor{2ab}
@section Conventions and Anonymous Access Types
@end example
@node Determining the Representations chosen by GNAT,,Conventions and Anonymous Access Types,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas determining-the-representations-chosen-by-gnat}@anchor{2a9}@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{2aa}
+@anchor{gnat_rm/representation_clauses_and_pragmas determining-the-representations-chosen-by-gnat}@anchor{2ac}@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{2ad}
@section Determining the Representations chosen by GNAT
used to answer the second question, but it is often easier to just see
what the compiler does.
-For this purpose, GNAT provides the option @emph{-gnatR}. If you compile
+For this purpose, GNAT provides the option `-gnatR'. If you compile
with this option, then the compiler will output information on the actual
representations chosen, in a format similar to source representation
clauses. For example, if we compile the package:
end q;
@end example
-using the switch @emph{-gnatR} we obtain the following output:
+using the switch `-gnatR' we obtain the following output:
@example
Representation information for unit q
the actual representation to be used.
@node Standard Library Routines,The Implementation of Standard I/O,Representation Clauses and Pragmas,Top
-@anchor{gnat_rm/standard_library_routines doc}@anchor{2ab}@anchor{gnat_rm/standard_library_routines id1}@anchor{2ac}@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}
+@anchor{gnat_rm/standard_library_routines doc}@anchor{2ae}@anchor{gnat_rm/standard_library_routines id1}@anchor{2af}@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}
@chapter Standard Library Routines
@table @asis
-@item @code{Ada} @emph{(A.2)}
+@item @code{Ada} `(A.2)'
This is a parent package for all the standard library packages. It is
usually included implicitly in your program, and itself contains no
useful data or routines.
-@item @code{Ada.Assertions} @emph{(11.4.2)}
+@item @code{Ada.Assertions} `(11.4.2)'
@code{Assertions} provides the @code{Assert} subprograms, and also
the declaration of the @code{Assertion_Error} exception.
-@item @code{Ada.Asynchronous_Task_Control} @emph{(D.11)}
+@item @code{Ada.Asynchronous_Task_Control} `(D.11)'
@code{Asynchronous_Task_Control} provides low level facilities for task
synchronization. It is typically not implemented. See package spec for details.
-@item @code{Ada.Calendar} @emph{(9.6)}
+@item @code{Ada.Calendar} `(9.6)'
@code{Calendar} provides time of day access, and routines for
manipulating times and durations.
-@item @code{Ada.Calendar.Arithmetic} @emph{(9.6.1)}
+@item @code{Ada.Calendar.Arithmetic} `(9.6.1)'
This package provides additional arithmetic
operations for @code{Calendar}.
-@item @code{Ada.Calendar.Formatting} @emph{(9.6.1)}
+@item @code{Ada.Calendar.Formatting} `(9.6.1)'
This package provides formatting operations for @code{Calendar}.
-@item @code{Ada.Calendar.Time_Zones} @emph{(9.6.1)}
+@item @code{Ada.Calendar.Time_Zones} `(9.6.1)'
This package provides additional @code{Calendar} facilities
for handling time zones.
-@item @code{Ada.Characters} @emph{(A.3.1)}
+@item @code{Ada.Characters} `(A.3.1)'
This is a dummy parent package that contains no useful entities
-@item @code{Ada.Characters.Conversions} @emph{(A.3.2)}
+@item @code{Ada.Characters.Conversions} `(A.3.2)'
This package provides character conversion functions.
-@item @code{Ada.Characters.Handling} @emph{(A.3.2)}
+@item @code{Ada.Characters.Handling} `(A.3.2)'
This package provides some basic character handling capabilities,
including classification functions for classes of characters (e.g., test
for letters, or digits).
-@item @code{Ada.Characters.Latin_1} @emph{(A.3.3)}
+@item @code{Ada.Characters.Latin_1} `(A.3.3)'
This package includes a complete set of definitions of the characters
that appear in type CHARACTER. It is useful for writing programs that
will print in an understandable manner even if your environment does not
support these extended characters.
-@item @code{Ada.Command_Line} @emph{(A.15)}
+@item @code{Ada.Command_Line} `(A.15)'
This package provides access to the command line parameters and the name
of the current program (analogous to the use of @code{argc} and @code{argv}
in C), and also allows the exit status for the program to be set in a
system-independent manner.
-@item @code{Ada.Complex_Text_IO} @emph{(G.1.3)}
+@item @code{Ada.Complex_Text_IO} `(G.1.3)'
This package provides text input and output of complex numbers.
-@item @code{Ada.Containers} @emph{(A.18.1)}
+@item @code{Ada.Containers} `(A.18.1)'
A top level package providing a few basic definitions used by all the
following specific child packages that provide specific kinds of
containers.
@end table
-@code{Ada.Containers.Bounded_Priority_Queues} @emph{(A.18.31)}
+@code{Ada.Containers.Bounded_Priority_Queues} `(A.18.31)'
-@code{Ada.Containers.Bounded_Synchronized_Queues} @emph{(A.18.29)}
+@code{Ada.Containers.Bounded_Synchronized_Queues} `(A.18.29)'
-@code{Ada.Containers.Doubly_Linked_Lists} @emph{(A.18.3)}
+@code{Ada.Containers.Doubly_Linked_Lists} `(A.18.3)'
-@code{Ada.Containers.Generic_Array_Sort} @emph{(A.18.26)}
+@code{Ada.Containers.Generic_Array_Sort} `(A.18.26)'
-@code{Ada.Containers.Generic_Constrained_Array_Sort} @emph{(A.18.26)}
+@code{Ada.Containers.Generic_Constrained_Array_Sort} `(A.18.26)'
-@code{Ada.Containers.Generic_Sort} @emph{(A.18.26)}
+@code{Ada.Containers.Generic_Sort} `(A.18.26)'
-@code{Ada.Containers.Hashed_Maps} @emph{(A.18.5)}
+@code{Ada.Containers.Hashed_Maps} `(A.18.5)'
-@code{Ada.Containers.Hashed_Sets} @emph{(A.18.8)}
+@code{Ada.Containers.Hashed_Sets} `(A.18.8)'
-@code{Ada.Containers.Indefinite_Doubly_Linked_Lists} @emph{(A.18.12)}
+@code{Ada.Containers.Indefinite_Doubly_Linked_Lists} `(A.18.12)'
-@code{Ada.Containers.Indefinite_Hashed_Maps} @emph{(A.18.13)}
+@code{Ada.Containers.Indefinite_Hashed_Maps} `(A.18.13)'
-@code{Ada.Containers.Indefinite_Hashed_Sets} @emph{(A.18.15)}
+@code{Ada.Containers.Indefinite_Hashed_Sets} `(A.18.15)'
-@code{Ada.Containers.Indefinite_Holders} @emph{(A.18.18)}
+@code{Ada.Containers.Indefinite_Holders} `(A.18.18)'
-@code{Ada.Containers.Indefinite_Multiway_Trees} @emph{(A.18.17)}
+@code{Ada.Containers.Indefinite_Multiway_Trees} `(A.18.17)'
-@code{Ada.Containers.Indefinite_Ordered_Maps} @emph{(A.18.14)}
+@code{Ada.Containers.Indefinite_Ordered_Maps} `(A.18.14)'
-@code{Ada.Containers.Indefinite_Ordered_Sets} @emph{(A.18.16)}
+@code{Ada.Containers.Indefinite_Ordered_Sets} `(A.18.16)'
-@code{Ada.Containers.Indefinite_Vectors} @emph{(A.18.11)}
+@code{Ada.Containers.Indefinite_Vectors} `(A.18.11)'
-@code{Ada.Containers.Multiway_Trees} @emph{(A.18.10)}
+@code{Ada.Containers.Multiway_Trees} `(A.18.10)'
-@code{Ada.Containers.Ordered_Maps} @emph{(A.18.6)}
+@code{Ada.Containers.Ordered_Maps} `(A.18.6)'
-@code{Ada.Containers.Ordered_Sets} @emph{(A.18.9)}
+@code{Ada.Containers.Ordered_Sets} `(A.18.9)'
-@code{Ada.Containers.Synchronized_Queue_Interfaces} @emph{(A.18.27)}
+@code{Ada.Containers.Synchronized_Queue_Interfaces} `(A.18.27)'
-@code{Ada.Containers.Unbounded_Priority_Queues} @emph{(A.18.30)}
+@code{Ada.Containers.Unbounded_Priority_Queues} `(A.18.30)'
-@code{Ada.Containers.Unbounded_Synchronized_Queues} @emph{(A.18.28)}
+@code{Ada.Containers.Unbounded_Synchronized_Queues} `(A.18.28)'
-@code{Ada.Containers.Vectors} @emph{(A.18.2)}
+@code{Ada.Containers.Vectors} `(A.18.2)'
@table @asis
-@item @code{Ada.Directories} @emph{(A.16)}
+@item @code{Ada.Directories} `(A.16)'
This package provides operations on directories.
-@item @code{Ada.Directories.Hierarchical_File_Names} @emph{(A.16.1)}
+@item @code{Ada.Directories.Hierarchical_File_Names} `(A.16.1)'
This package provides additional directory operations handling
hierarchical file names.
-@item @code{Ada.Directories.Information} @emph{(A.16)}
+@item @code{Ada.Directories.Information} `(A.16)'
This is an implementation defined package for additional directory
operations, which is not implemented in GNAT.
-@item @code{Ada.Decimal} @emph{(F.2)}
+@item @code{Ada.Decimal} `(F.2)'
This package provides constants describing the range of decimal numbers
implemented, and also a decimal divide routine (analogous to the COBOL
verb DIVIDE … GIVING … REMAINDER …)
-@item @code{Ada.Direct_IO} @emph{(A.8.4)}
+@item @code{Ada.Direct_IO} `(A.8.4)'
This package provides input-output using a model of a set of records of
fixed-length, containing an arbitrary definite Ada type, indexed by an
integer record number.
-@item @code{Ada.Dispatching} @emph{(D.2.1)}
+@item @code{Ada.Dispatching} `(D.2.1)'
A parent package containing definitions for task dispatching operations.
-@item @code{Ada.Dispatching.EDF} @emph{(D.2.6)}
+@item @code{Ada.Dispatching.EDF} `(D.2.6)'
Not implemented in GNAT.
-@item @code{Ada.Dispatching.Non_Preemptive} @emph{(D.2.4)}
+@item @code{Ada.Dispatching.Non_Preemptive} `(D.2.4)'
Not implemented in GNAT.
-@item @code{Ada.Dispatching.Round_Robin} @emph{(D.2.5)}
+@item @code{Ada.Dispatching.Round_Robin} `(D.2.5)'
Not implemented in GNAT.
-@item @code{Ada.Dynamic_Priorities} @emph{(D.5)}
+@item @code{Ada.Dynamic_Priorities} `(D.5)'
This package allows the priorities of a task to be adjusted dynamically
as the task is running.
-@item @code{Ada.Environment_Variables} @emph{(A.17)}
+@item @code{Ada.Environment_Variables} `(A.17)'
This package provides facilities for accessing environment variables.
-@item @code{Ada.Exceptions} @emph{(11.4.1)}
+@item @code{Ada.Exceptions} `(11.4.1)'
This package provides additional information on exceptions, and also
contains facilities for treating exceptions as data objects, and raising
exceptions with associated messages.
-@item @code{Ada.Execution_Time} @emph{(D.14)}
+@item @code{Ada.Execution_Time} `(D.14)'
This package provides CPU clock functionalities. It is not implemented on
all targets (see package spec for details).
-@item @code{Ada.Execution_Time.Group_Budgets} @emph{(D.14.2)}
+@item @code{Ada.Execution_Time.Group_Budgets} `(D.14.2)'
Not implemented in GNAT.
-@item @code{Ada.Execution_Time.Timers} @emph{(D.14.1)’}
+@item @code{Ada.Execution_Time.Timers} `(D.14.1)’'
Not implemented in GNAT.
-@item @code{Ada.Finalization} @emph{(7.6)}
+@item @code{Ada.Finalization} `(7.6)'
This package contains the declarations and subprograms to support the
use of controlled types, providing for automatic initialization and
finalization (analogous to the constructors and destructors of C++).
-@item @code{Ada.Float_Text_IO} @emph{(A.10.9)}
+@item @code{Ada.Float_Text_IO} `(A.10.9)'
A library level instantiation of Text_IO.Float_IO for type Float.
-@item @code{Ada.Float_Wide_Text_IO} @emph{(A.10.9)}
+@item @code{Ada.Float_Wide_Text_IO} `(A.10.9)'
A library level instantiation of Wide_Text_IO.Float_IO for type Float.
-@item @code{Ada.Float_Wide_Wide_Text_IO} @emph{(A.10.9)}
+@item @code{Ada.Float_Wide_Wide_Text_IO} `(A.10.9)'
A library level instantiation of Wide_Wide_Text_IO.Float_IO for type Float.
-@item @code{Ada.Integer_Text_IO} @emph{(A.10.9)}
+@item @code{Ada.Integer_Text_IO} `(A.10.9)'
A library level instantiation of Text_IO.Integer_IO for type Integer.
-@item @code{Ada.Integer_Wide_Text_IO} @emph{(A.10.9)}
+@item @code{Ada.Integer_Wide_Text_IO} `(A.10.9)'
A library level instantiation of Wide_Text_IO.Integer_IO for type Integer.
-@item @code{Ada.Integer_Wide_Wide_Text_IO} @emph{(A.10.9)}
+@item @code{Ada.Integer_Wide_Wide_Text_IO} `(A.10.9)'
A library level instantiation of Wide_Wide_Text_IO.Integer_IO for type Integer.
-@item @code{Ada.Interrupts} @emph{(C.3.2)}
+@item @code{Ada.Interrupts} `(C.3.2)'
This package provides facilities for interfacing to interrupts, which
includes the set of signals or conditions that can be raised and
recognized as interrupts.
-@item @code{Ada.Interrupts.Names} @emph{(C.3.2)}
+@item @code{Ada.Interrupts.Names} `(C.3.2)'
This package provides the set of interrupt names (actually signal
or condition names) that can be handled by GNAT.
-@item @code{Ada.IO_Exceptions} @emph{(A.13)}
+@item @code{Ada.IO_Exceptions} `(A.13)'
This package defines the set of exceptions that can be raised by use of
the standard IO packages.
-@item @code{Ada.Iterator_Interfaces} @emph{(5.5.1)}
+@item @code{Ada.Iterator_Interfaces} `(5.5.1)'
This package provides a generic interface to generalized iterators.
-@item @code{Ada.Locales} @emph{(A.19)}
+@item @code{Ada.Locales} `(A.19)'
This package provides declarations providing information (Language
and Country) about the current locale.
defined here, and it is better to use these definitions than rolling
your own.
-@item @code{Ada.Numerics.Complex_Arrays} @emph{(G.3.2)}
+@item @code{Ada.Numerics.Complex_Arrays} `(G.3.2)'
Provides operations on arrays of complex numbers.
@code{Ada.Numerics.Long_Elementary_Functions}
@end itemize
-@item @code{Ada.Numerics.Generic_Real_Arrays} @emph{(G.3.1)}
+@item @code{Ada.Numerics.Generic_Real_Arrays} `(G.3.1)'
Generic operations on arrays of reals
-@item @code{Ada.Numerics.Real_Arrays} @emph{(G.3.1)}
+@item @code{Ada.Numerics.Real_Arrays} `(G.3.1)'
Preinstantiation of Ada.Numerics.Generic_Real_Arrays (Float).
-@item @code{Ada.Real_Time} @emph{(D.8)}
+@item @code{Ada.Real_Time} `(D.8)'
This package provides facilities similar to those of @code{Calendar}, but
operating with a finer clock suitable for real time control. Note that
the GNAT runtime depends is deliberately reset by some external event,
then such a backward jump may occur.
-@item @code{Ada.Real_Time.Timing_Events} @emph{(D.15)}
+@item @code{Ada.Real_Time.Timing_Events} `(D.15)'
Not implemented in GNAT.
-@item @code{Ada.Sequential_IO} @emph{(A.8.1)}
+@item @code{Ada.Sequential_IO} `(A.8.1)'
This package provides input-output facilities for sequential files,
which can contain a sequence of values of a single type, which can be
any Ada type, including indefinite (unconstrained) types.
-@item @code{Ada.Storage_IO} @emph{(A.9)}
+@item @code{Ada.Storage_IO} `(A.9)'
This package provides a facility for mapping arbitrary Ada types to and
from a storage buffer. It is primarily intended for the creation of new
IO packages.
-@item @code{Ada.Streams} @emph{(13.13.1)}
+@item @code{Ada.Streams} `(13.13.1)'
This is a generic package that provides the basic support for the
concept of streams as used by the stream attributes (@code{Input},
@code{Output}, @code{Read} and @code{Write}).
-@item @code{Ada.Streams.Stream_IO} @emph{(A.12.1)}
+@item @code{Ada.Streams.Stream_IO} `(A.12.1)'
This package is a specialization of the type @code{Streams} defined in
package @code{Streams} together with a set of operations providing
sequential access to a file which can contain an arbitrary set of values
of one or more Ada types.
-@item @code{Ada.Strings} @emph{(A.4.1)}
+@item @code{Ada.Strings} `(A.4.1)'
This package provides some basic constants used by the string handling
packages.
-@item @code{Ada.Strings.Bounded} @emph{(A.4.4)}
+@item @code{Ada.Strings.Bounded} `(A.4.4)'
This package provides facilities for handling variable length
strings. The bounded model requires a maximum length. It is thus
somewhat more limited than the unbounded model, but avoids the use of
dynamic allocation or finalization.
-@item @code{Ada.Strings.Bounded.Equal_Case_Insensitive} @emph{(A.4.10)}
+@item @code{Ada.Strings.Bounded.Equal_Case_Insensitive} `(A.4.10)'
Provides case-insensitive comparisons of bounded strings
-@item @code{Ada.Strings.Bounded.Hash} @emph{(A.4.9)}
+@item @code{Ada.Strings.Bounded.Hash} `(A.4.9)'
This package provides a generic hash function for bounded strings
-@item @code{Ada.Strings.Bounded.Hash_Case_Insensitive} @emph{(A.4.9)}
+@item @code{Ada.Strings.Bounded.Hash_Case_Insensitive} `(A.4.9)'
This package provides a generic hash function for bounded strings that
converts the string to be hashed to lower case.
-@item @code{Ada.Strings.Bounded.Less_Case_Insensitive} @emph{(A.4.10)}
+@item @code{Ada.Strings.Bounded.Less_Case_Insensitive} `(A.4.10)'
This package provides a comparison function for bounded strings that works
in a case insensitive manner by converting to lower case before the comparison.
-@item @code{Ada.Strings.Fixed} @emph{(A.4.3)}
+@item @code{Ada.Strings.Fixed} `(A.4.3)'
This package provides facilities for handling fixed length strings.
-@item @code{Ada.Strings.Fixed.Equal_Case_Insensitive} @emph{(A.4.10)}
+@item @code{Ada.Strings.Fixed.Equal_Case_Insensitive} `(A.4.10)'
This package provides an equality function for fixed strings that compares
the strings after converting both to lower case.
-@item @code{Ada.Strings.Fixed.Hash_Case_Insensitive} @emph{(A.4.9)}
+@item @code{Ada.Strings.Fixed.Hash_Case_Insensitive} `(A.4.9)'
This package provides a case insensitive hash function for fixed strings that
converts the string to lower case before computing the hash.
-@item @code{Ada.Strings.Fixed.Less_Case_Insensitive} @emph{(A.4.10)}
+@item @code{Ada.Strings.Fixed.Less_Case_Insensitive} `(A.4.10)'
This package provides a comparison function for fixed strings that works
in a case insensitive manner by converting to lower case before the comparison.
-@item @code{Ada.Strings.Hash} @emph{(A.4.9)}
+@item @code{Ada.Strings.Hash} `(A.4.9)'
This package provides a hash function for strings.
-@item @code{Ada.Strings.Hash_Case_Insensitive} @emph{(A.4.9)}
+@item @code{Ada.Strings.Hash_Case_Insensitive} `(A.4.9)'
This package provides a hash function for strings that is case insensitive.
The string is converted to lower case before computing the hash.
-@item @code{Ada.Strings.Less_Case_Insensitive} @emph{(A.4.10)}
+@item @code{Ada.Strings.Less_Case_Insensitive} `(A.4.10)'
This package provides a comparison function for\strings that works
in a case insensitive manner by converting to lower case before the comparison.
-@item @code{Ada.Strings.Maps} @emph{(A.4.2)}
+@item @code{Ada.Strings.Maps} `(A.4.2)'
This package provides facilities for handling character mappings and
arbitrarily defined subsets of characters. For instance it is useful in
defining specialized translation tables.
-@item @code{Ada.Strings.Maps.Constants} @emph{(A.4.6)}
+@item @code{Ada.Strings.Maps.Constants} `(A.4.6)'
This package provides a standard set of predefined mappings and
predefined character sets. For example, the standard upper to lower case
into account. You should use the mappings in this package (rather than
adding 32 yourself) to do case mappings.
-@item @code{Ada.Strings.Unbounded} @emph{(A.4.5)}
+@item @code{Ada.Strings.Unbounded} `(A.4.5)'
This package provides facilities for handling variable length
strings. The unbounded model allows arbitrary length strings, but
requires the use of dynamic allocation and finalization.
-@item @code{Ada.Strings.Unbounded.Equal_Case_Insensitive} @emph{(A.4.10)}
+@item @code{Ada.Strings.Unbounded.Equal_Case_Insensitive} `(A.4.10)'
Provides case-insensitive comparisons of unbounded strings
-@item @code{Ada.Strings.Unbounded.Hash} @emph{(A.4.9)}
+@item @code{Ada.Strings.Unbounded.Hash} `(A.4.9)'
This package provides a generic hash function for unbounded strings
-@item @code{Ada.Strings.Unbounded.Hash_Case_Insensitive} @emph{(A.4.9)}
+@item @code{Ada.Strings.Unbounded.Hash_Case_Insensitive} `(A.4.9)'
This package provides a generic hash function for unbounded strings that
converts the string to be hashed to lower case.
-@item @code{Ada.Strings.Unbounded.Less_Case_Insensitive} @emph{(A.4.10)}
+@item @code{Ada.Strings.Unbounded.Less_Case_Insensitive} `(A.4.10)'
This package provides a comparison function for unbounded strings that works
in a case insensitive manner by converting to lower case before the comparison.
-@item @code{Ada.Strings.UTF_Encoding} @emph{(A.4.11)}
+@item @code{Ada.Strings.UTF_Encoding} `(A.4.11)'
This package provides basic definitions for dealing with UTF-encoded strings.
-@item @code{Ada.Strings.UTF_Encoding.Conversions} @emph{(A.4.11)}
+@item @code{Ada.Strings.UTF_Encoding.Conversions} `(A.4.11)'
This package provides conversion functions for UTF-encoded strings.
@end table
-@code{Ada.Strings.UTF_Encoding.Strings} @emph{(A.4.11)}
+@code{Ada.Strings.UTF_Encoding.Strings} `(A.4.11)'
-@code{Ada.Strings.UTF_Encoding.Wide_Strings} @emph{(A.4.11)}
+@code{Ada.Strings.UTF_Encoding.Wide_Strings} `(A.4.11)'
@table @asis
-@item @code{Ada.Strings.UTF_Encoding.Wide_Wide_Strings} @emph{(A.4.11)}
+@item @code{Ada.Strings.UTF_Encoding.Wide_Wide_Strings} `(A.4.11)'
These packages provide facilities for handling UTF encodings for
Strings, Wide_Strings and Wide_Wide_Strings.
@end table
-@code{Ada.Strings.Wide_Bounded} @emph{(A.4.7)}
+@code{Ada.Strings.Wide_Bounded} `(A.4.7)'
-@code{Ada.Strings.Wide_Fixed} @emph{(A.4.7)}
+@code{Ada.Strings.Wide_Fixed} `(A.4.7)'
-@code{Ada.Strings.Wide_Maps} @emph{(A.4.7)}
+@code{Ada.Strings.Wide_Maps} `(A.4.7)'
@table @asis
-@item @code{Ada.Strings.Wide_Unbounded} @emph{(A.4.7)}
+@item @code{Ada.Strings.Wide_Unbounded} `(A.4.7)'
These packages provide analogous capabilities to the corresponding
packages without @code{Wide_} in the name, but operate with the types
and @code{Character}. Versions of all the child packages are available.
@end table
-@code{Ada.Strings.Wide_Wide_Bounded} @emph{(A.4.7)}
+@code{Ada.Strings.Wide_Wide_Bounded} `(A.4.7)'
-@code{Ada.Strings.Wide_Wide_Fixed} @emph{(A.4.7)}
+@code{Ada.Strings.Wide_Wide_Fixed} `(A.4.7)'
-@code{Ada.Strings.Wide_Wide_Maps} @emph{(A.4.7)}
+@code{Ada.Strings.Wide_Wide_Maps} `(A.4.7)'
@table @asis
-@item @code{Ada.Strings.Wide_Wide_Unbounded} @emph{(A.4.7)}
+@item @code{Ada.Strings.Wide_Wide_Unbounded} `(A.4.7)'
These packages provide analogous capabilities to the corresponding
packages without @code{Wide_} in the name, but operate with the types
@code{Wide_Wide_String} and @code{Wide_Wide_Character} instead
of @code{String} and @code{Character}.
-@item @code{Ada.Synchronous_Barriers} @emph{(D.10.1)}
+@item @code{Ada.Synchronous_Barriers} `(D.10.1)'
This package provides facilities for synchronizing tasks at a low level
with barriers.
-@item @code{Ada.Synchronous_Task_Control} @emph{(D.10)}
+@item @code{Ada.Synchronous_Task_Control} `(D.10)'
This package provides some standard facilities for controlling task
communication in a synchronous manner.
-@item @code{Ada.Synchronous_Task_Control.EDF} @emph{(D.10)}
+@item @code{Ada.Synchronous_Task_Control.EDF} `(D.10)'
Not implemented in GNAT.
This package contains definitions for manipulation of the tags of tagged
values.
-@item @code{Ada.Tags.Generic_Dispatching_Constructor} @emph{(3.9)}
+@item @code{Ada.Tags.Generic_Dispatching_Constructor} `(3.9)'
This package provides a way of constructing tagged class-wide values given
only the tag value.
-@item @code{Ada.Task_Attributes} @emph{(C.7.2)}
+@item @code{Ada.Task_Attributes} `(C.7.2)'
This package provides the capability of associating arbitrary
task-specific data with separate tasks.
-@item @code{Ada.Task_Identification} @emph{(C.7.1)}
+@item @code{Ada.Task_Identification} `(C.7.1)'
This package provides capabilities for task identification.
-@item @code{Ada.Task_Termination} @emph{(C.7.3)}
+@item @code{Ada.Task_Termination} `(C.7.3)'
This package provides control over task termination.
used in conjunction with pointers to unconstrained objects, since
the bounds information cannot be handled correctly in this case.
-@item @code{Ada.Unchecked_Deallocation} @emph{(13.11.2)}
+@item @code{Ada.Unchecked_Deallocation} `(13.11.2)'
This generic package allows explicit freeing of storage previously
allocated by use of an allocator.
-@item @code{Ada.Wide_Text_IO} @emph{(A.11)}
+@item @code{Ada.Wide_Text_IO} `(A.11)'
This package is similar to @code{Ada.Text_IO}, except that the external
file supports wide character representations, and the internal types are
and @code{String}. The corresponding set of nested packages and child
packages are defined.
-@item @code{Ada.Wide_Wide_Text_IO} @emph{(A.11)}
+@item @code{Ada.Wide_Wide_Text_IO} `(A.11)'
This package is similar to @code{Ada.Text_IO}, except that the external
file supports wide character representations, and the internal types are
available in GNAT, see the Ada 2012 RM for full details.
@node The Implementation of Standard I/O,The GNAT Library,Standard Library Routines,Top
-@anchor{gnat_rm/the_implementation_of_standard_i_o doc}@anchor{2ad}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{2ae}@anchor{gnat_rm/the_implementation_of_standard_i_o the-implementation-of-standard-i-o}@anchor{f}
+@anchor{gnat_rm/the_implementation_of_standard_i_o doc}@anchor{2b0}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{2b1}@anchor{gnat_rm/the_implementation_of_standard_i_o the-implementation-of-standard-i-o}@anchor{f}
@chapter The Implementation of Standard I/O
@end menu
@node Standard I/O Packages,FORM Strings,,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id2}@anchor{2af}@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2b0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id2}@anchor{2b2}@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2b3}
@section Standard I/O Packages
elaborating the Ada code.
@node FORM Strings,Direct_IO,Standard I/O Packages,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o form-strings}@anchor{2b1}@anchor{gnat_rm/the_implementation_of_standard_i_o id3}@anchor{2b2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o form-strings}@anchor{2b4}@anchor{gnat_rm/the_implementation_of_standard_i_o id3}@anchor{2b5}
@section FORM Strings
and not considered invalid.
@node Direct_IO,Sequential_IO,FORM Strings,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o direct-io}@anchor{2b3}@anchor{gnat_rm/the_implementation_of_standard_i_o id4}@anchor{2b4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o direct-io}@anchor{2b6}@anchor{gnat_rm/the_implementation_of_standard_i_o id4}@anchor{2b7}
@section Direct_IO
necessary to accommodate whatever records are written to the file.
@node Sequential_IO,Text_IO,Direct_IO,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id5}@anchor{2b5}@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2b6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id5}@anchor{2b8}@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2b9}
@section Sequential_IO
above program fragment rewritten to use Stream_IO will work correctly.
@node Text_IO,Wide_Text_IO,Sequential_IO,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id6}@anchor{2b7}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io}@anchor{2b8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id6}@anchor{2ba}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io}@anchor{2bb}
@section Text_IO
@end menu
@node Stream Pointer Positioning,Reading and Writing Non-Regular Files,,Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o id7}@anchor{2b9}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning}@anchor{2ba}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id7}@anchor{2bc}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning}@anchor{2bd}
@subsection Stream Pointer Positioning
situations.
@node Reading and Writing Non-Regular Files,Get_Immediate,Stream Pointer Positioning,Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o id8}@anchor{2bb}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2bc}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id8}@anchor{2be}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2bf}
@subsection Reading and Writing Non-Regular Files
file indication, until another end of file indication is entered.
@node Get_Immediate,Treating Text_IO Files as Streams,Reading and Writing Non-Regular Files,Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o get-immediate}@anchor{2bd}@anchor{gnat_rm/the_implementation_of_standard_i_o id9}@anchor{2be}
+@anchor{gnat_rm/the_implementation_of_standard_i_o get-immediate}@anchor{2c0}@anchor{gnat_rm/the_implementation_of_standard_i_o id9}@anchor{2c1}
@subsection Get_Immediate
page mark.
@node Treating Text_IO Files as Streams,Text_IO Extensions,Get_Immediate,Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o id10}@anchor{2bf}@anchor{gnat_rm/the_implementation_of_standard_i_o treating-text-io-files-as-streams}@anchor{2c0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id10}@anchor{2c2}@anchor{gnat_rm/the_implementation_of_standard_i_o treating-text-io-files-as-streams}@anchor{2c3}
@subsection Treating Text_IO Files as Streams
@code{Get_Immediate}.
@node Text_IO Extensions,Text_IO Facilities for Unbounded Strings,Treating Text_IO Files as Streams,Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o id11}@anchor{2c1}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-extensions}@anchor{2c2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id11}@anchor{2c4}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-extensions}@anchor{2c5}
@subsection Text_IO Extensions
@end itemize
@node Text_IO Facilities for Unbounded Strings,,Text_IO Extensions,Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o id12}@anchor{2c3}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2c4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id12}@anchor{2c6}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2c7}
@subsection Text_IO Facilities for Unbounded Strings
@code{Wide_Wide_Text_IO} functionality for unbounded wide wide strings.
@node Wide_Text_IO,Wide_Wide_Text_IO,Text_IO,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id13}@anchor{2c5}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2c6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id13}@anchor{2c8}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2c9}
@section Wide_Text_IO
@item
-@emph{h}
+`h'
@tab
@item
-@emph{u}
+`u'
@tab
@item
-@emph{s}
+`s'
@tab
@item
-@emph{e}
+`e'
@tab
@item
-@emph{8}
+`8'
@tab
@item
-@emph{b}
+`b'
@tab
@table @asis
-@item @emph{Hex Coding}
+@item `Hex Coding'
In this encoding, a wide character is represented by a five character
sequence:
@table @asis
-@item @emph{Upper Half Coding}
+@item `Upper Half Coding'
The wide character with encoding 16#abcd#, where the upper bit is on
(i.e., a is in the range 8-F) is represented as two bytes 16#ab# and
not required to be in the upper half. This method can be also used for
shift-JIS or EUC where the internal coding matches the external coding.
-@item @emph{Shift JIS Coding}
+@item `Shift JIS Coding'
A wide character is represented by a two character sequence 16#ab# and
16#cd#, with the restrictions described for upper half encoding as
conversion. Only characters defined in the JIS code set table can be
used with this encoding method.
-@item @emph{EUC Coding}
+@item `EUC Coding'
A wide character is represented by a two character sequence 16#ab# and
16#cd#, with both characters being in the upper half. The internal
encoding algorithm. Only characters defined in the JIS code set table
can be used with this encoding method.
-@item @emph{UTF-8 Coding}
+@item `UTF-8 Coding'
A wide character is represented using
UCS Transformation Format 8 (UTF-8) as defined in Annex R of ISO
@table @asis
-@item @emph{Brackets Coding}
+@item `Brackets Coding'
In this encoding, a wide character is represented by the following eight
character sequence:
@end menu
@node Stream Pointer Positioning<2>,Reading and Writing Non-Regular Files<2>,,Wide_Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o id14}@anchor{2c7}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2c8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id14}@anchor{2ca}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2cb}
@subsection Stream Pointer Positioning
@code{Ada.Wide_Text_IO} is similar to @code{Ada.Text_IO} in its handling
-of stream pointer positioning (@ref{2b8,,Text_IO}). There is one additional
+of stream pointer positioning (@ref{2bb,,Text_IO}). There is one additional
case:
If @code{Ada.Wide_Text_IO.Look_Ahead} reads a character outside the
can be observed if the wide text file shares a stream with another file.
@node Reading and Writing Non-Regular Files<2>,,Stream Pointer Positioning<2>,Wide_Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o id15}@anchor{2c9}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2ca}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id15}@anchor{2cc}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2cd}
@subsection Reading and Writing Non-Regular Files
it is possible to read beyond an end of file.
@node Wide_Wide_Text_IO,Stream_IO,Wide_Text_IO,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id16}@anchor{2cb}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-wide-text-io}@anchor{2cc}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id16}@anchor{2ce}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-wide-text-io}@anchor{2cf}
@section Wide_Wide_Text_IO
@item
-@emph{h}
+`h'
@tab
@item
-@emph{u}
+`u'
@tab
@item
-@emph{s}
+`s'
@tab
@item
-@emph{e}
+`e'
@tab
@item
-@emph{8}
+`8'
@tab
@item
-@emph{b}
+`b'
@tab
@table @asis
-@item @emph{UTF-8 Coding}
+@item `UTF-8 Coding'
A wide character is represented using
UCS Transformation Format 8 (UTF-8) as defined in Annex R of ISO
@table @asis
-@item @emph{Brackets Coding}
+@item `Brackets Coding'
In this encoding, a wide wide character is represented by the following eight
character sequence if is in wide character range
@end menu
@node Stream Pointer Positioning<3>,Reading and Writing Non-Regular Files<3>,,Wide_Wide_Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o id17}@anchor{2cd}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2ce}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id17}@anchor{2d0}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2d1}
@subsection Stream Pointer Positioning
@code{Ada.Wide_Wide_Text_IO} is similar to @code{Ada.Text_IO} in its handling
-of stream pointer positioning (@ref{2b8,,Text_IO}). There is one additional
+of stream pointer positioning (@ref{2bb,,Text_IO}). There is one additional
case:
If @code{Ada.Wide_Wide_Text_IO.Look_Ahead} reads a character outside the
can be observed if the wide text file shares a stream with another file.
@node Reading and Writing Non-Regular Files<3>,,Stream Pointer Positioning<3>,Wide_Wide_Text_IO
-@anchor{gnat_rm/the_implementation_of_standard_i_o id18}@anchor{2cf}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-2}@anchor{2d0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id18}@anchor{2d2}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-2}@anchor{2d3}
@subsection Reading and Writing Non-Regular Files
it is possible to read beyond an end of file.
@node Stream_IO,Text Translation,Wide_Wide_Text_IO,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id19}@anchor{2d1}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-io}@anchor{2d2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id19}@anchor{2d4}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-io}@anchor{2d5}
@section Stream_IO
@end itemize
@node Text Translation,Shared Files,Stream_IO,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id20}@anchor{2d3}@anchor{gnat_rm/the_implementation_of_standard_i_o text-translation}@anchor{2d4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id20}@anchor{2d6}@anchor{gnat_rm/the_implementation_of_standard_i_o text-translation}@anchor{2d7}
@section Text Translation
@end itemize
@node Shared Files,Filenames encoding,Text Translation,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id21}@anchor{2d5}@anchor{gnat_rm/the_implementation_of_standard_i_o shared-files}@anchor{2d6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id21}@anchor{2d8}@anchor{gnat_rm/the_implementation_of_standard_i_o shared-files}@anchor{2d9}
@section Shared Files
for this purpose (using the stream attributes)
@node Filenames encoding,File content encoding,Shared Files,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o filenames-encoding}@anchor{2d7}@anchor{gnat_rm/the_implementation_of_standard_i_o id22}@anchor{2d8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o filenames-encoding}@anchor{2da}@anchor{gnat_rm/the_implementation_of_standard_i_o id22}@anchor{2db}
@section Filenames encoding
@table @asis
-@item @emph{CP_ACP}
+@item `CP_ACP'
The current system Windows ANSI code page.
-@item @emph{CP_UTF8}
+@item `CP_UTF8'
UTF-8 encoding
@end table
UTF-8 natively.
@node File content encoding,Open Modes,Filenames encoding,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o file-content-encoding}@anchor{2d9}@anchor{gnat_rm/the_implementation_of_standard_i_o id23}@anchor{2da}
+@anchor{gnat_rm/the_implementation_of_standard_i_o file-content-encoding}@anchor{2dc}@anchor{gnat_rm/the_implementation_of_standard_i_o id23}@anchor{2dd}
@section File content encoding
@table @asis
-@item @emph{TEXT}
+@item `TEXT'
Translated text mode
-@item @emph{WTEXT}
+@item `WTEXT'
Translated unicode encoding
-@item @emph{U16TEXT}
+@item `U16TEXT'
Unicode 16-bit encoding
-@item @emph{U8TEXT}
+@item `U8TEXT'
Unicode 8-bit encoding
@end table
This encoding is only supported on the Windows platform.
@node Open Modes,Operations on C Streams,File content encoding,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id24}@anchor{2db}@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2dc}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id24}@anchor{2de}@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2df}
@section Open Modes
@tab
-@strong{OPEN}
+`OPEN'
@tab
-@strong{CREATE}
+`CREATE'
@item
then the file is reopened in @code{r+} mode to permit the required operation.
@node Operations on C Streams,Interfacing to C Streams,Open Modes,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id25}@anchor{2dd}@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2de}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id25}@anchor{2e0}@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2e1}
@section Operations on C Streams
@end example
@node Interfacing to C Streams,,Operations on C Streams,The Implementation of Standard I/O
-@anchor{gnat_rm/the_implementation_of_standard_i_o id26}@anchor{2df}@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2e0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id26}@anchor{2e2}@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2e3}
@section Interfacing to C Streams
existing C file.
@node The GNAT Library,Interfacing to Other Languages,The Implementation of Standard I/O,Top
-@anchor{gnat_rm/the_gnat_library doc}@anchor{2e1}@anchor{gnat_rm/the_gnat_library id1}@anchor{2e2}@anchor{gnat_rm/the_gnat_library the-gnat-library}@anchor{10}
+@anchor{gnat_rm/the_gnat_library doc}@anchor{2e4}@anchor{gnat_rm/the_gnat_library id1}@anchor{2e5}@anchor{gnat_rm/the_gnat_library the-gnat-library}@anchor{10}
@chapter The GNAT Library
@end menu
@node Ada Characters Latin_9 a-chlat9 ads,Ada Characters Wide_Latin_1 a-cwila1 ads,,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-characters-latin-9-a-chlat9-ads}@anchor{2e3}@anchor{gnat_rm/the_gnat_library id2}@anchor{2e4}
+@anchor{gnat_rm/the_gnat_library ada-characters-latin-9-a-chlat9-ads}@anchor{2e6}@anchor{gnat_rm/the_gnat_library id2}@anchor{2e7}
@section @code{Ada.Characters.Latin_9} (@code{a-chlat9.ads})
(RM A.3.3(27)).
@node Ada Characters Wide_Latin_1 a-cwila1 ads,Ada Characters Wide_Latin_9 a-cwila9 ads,Ada Characters Latin_9 a-chlat9 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-1-a-cwila1-ads}@anchor{2e5}@anchor{gnat_rm/the_gnat_library id3}@anchor{2e6}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-1-a-cwila1-ads}@anchor{2e8}@anchor{gnat_rm/the_gnat_library id3}@anchor{2e9}
@section @code{Ada.Characters.Wide_Latin_1} (@code{a-cwila1.ads})
(RM A.3.3(27)).
@node Ada Characters Wide_Latin_9 a-cwila9 ads,Ada Characters Wide_Wide_Latin_1 a-chzla1 ads,Ada Characters Wide_Latin_1 a-cwila1 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-9-a-cwila9-ads}@anchor{2e7}@anchor{gnat_rm/the_gnat_library id4}@anchor{2e8}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-9-a-cwila9-ads}@anchor{2ea}@anchor{gnat_rm/the_gnat_library id4}@anchor{2eb}
@section @code{Ada.Characters.Wide_Latin_9} (@code{a-cwila9.ads})
(RM A.3.3(27)).
@node Ada Characters Wide_Wide_Latin_1 a-chzla1 ads,Ada Characters Wide_Wide_Latin_9 a-chzla9 ads,Ada Characters Wide_Latin_9 a-cwila9 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-1-a-chzla1-ads}@anchor{2e9}@anchor{gnat_rm/the_gnat_library id5}@anchor{2ea}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-1-a-chzla1-ads}@anchor{2ec}@anchor{gnat_rm/the_gnat_library id5}@anchor{2ed}
@section @code{Ada.Characters.Wide_Wide_Latin_1} (@code{a-chzla1.ads})
(RM A.3.3(27)).
@node Ada Characters Wide_Wide_Latin_9 a-chzla9 ads,Ada Containers Bounded_Holders a-coboho ads,Ada Characters Wide_Wide_Latin_1 a-chzla1 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-9-a-chzla9-ads}@anchor{2eb}@anchor{gnat_rm/the_gnat_library id6}@anchor{2ec}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-9-a-chzla9-ads}@anchor{2ee}@anchor{gnat_rm/the_gnat_library id6}@anchor{2ef}
@section @code{Ada.Characters.Wide_Wide_Latin_9} (@code{a-chzla9.ads})
(RM A.3.3(27)).
@node Ada Containers Bounded_Holders a-coboho ads,Ada Command_Line Environment a-colien ads,Ada Characters Wide_Wide_Latin_9 a-chzla9 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-containers-bounded-holders-a-coboho-ads}@anchor{2ed}@anchor{gnat_rm/the_gnat_library id7}@anchor{2ee}
+@anchor{gnat_rm/the_gnat_library ada-containers-bounded-holders-a-coboho-ads}@anchor{2f0}@anchor{gnat_rm/the_gnat_library id7}@anchor{2f1}
@section @code{Ada.Containers.Bounded_Holders} (@code{a-coboho.ads})
Indefinite_Holders that avoids heap allocation.
@node Ada Command_Line Environment a-colien ads,Ada Command_Line Remove a-colire ads,Ada Containers Bounded_Holders a-coboho ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-command-line-environment-a-colien-ads}@anchor{2ef}@anchor{gnat_rm/the_gnat_library id8}@anchor{2f0}
+@anchor{gnat_rm/the_gnat_library ada-command-line-environment-a-colien-ads}@anchor{2f2}@anchor{gnat_rm/the_gnat_library id8}@anchor{2f3}
@section @code{Ada.Command_Line.Environment} (@code{a-colien.ads})
where this concept makes sense.
@node Ada Command_Line Remove a-colire ads,Ada Command_Line Response_File a-clrefi ads,Ada Command_Line Environment a-colien ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-command-line-remove-a-colire-ads}@anchor{2f1}@anchor{gnat_rm/the_gnat_library id9}@anchor{2f2}
+@anchor{gnat_rm/the_gnat_library ada-command-line-remove-a-colire-ads}@anchor{2f4}@anchor{gnat_rm/the_gnat_library id9}@anchor{2f5}
@section @code{Ada.Command_Line.Remove} (@code{a-colire.ads})
will not see the removed argument.
@node Ada Command_Line Response_File a-clrefi ads,Ada Direct_IO C_Streams a-diocst ads,Ada Command_Line Remove a-colire ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-command-line-response-file-a-clrefi-ads}@anchor{2f3}@anchor{gnat_rm/the_gnat_library id10}@anchor{2f4}
+@anchor{gnat_rm/the_gnat_library ada-command-line-response-file-a-clrefi-ads}@anchor{2f6}@anchor{gnat_rm/the_gnat_library id10}@anchor{2f7}
@section @code{Ada.Command_Line.Response_File} (@code{a-clrefi.ads})
than the maximum allowed by the system on the command line.
@node Ada Direct_IO C_Streams a-diocst ads,Ada Exceptions Is_Null_Occurrence a-einuoc ads,Ada Command_Line Response_File a-clrefi ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-direct-io-c-streams-a-diocst-ads}@anchor{2f5}@anchor{gnat_rm/the_gnat_library id11}@anchor{2f6}
+@anchor{gnat_rm/the_gnat_library ada-direct-io-c-streams-a-diocst-ads}@anchor{2f8}@anchor{gnat_rm/the_gnat_library id11}@anchor{2f9}
@section @code{Ada.Direct_IO.C_Streams} (@code{a-diocst.ads})
can be constructed from a stream opened on the C side.
@node Ada Exceptions Is_Null_Occurrence a-einuoc ads,Ada Exceptions Last_Chance_Handler a-elchha ads,Ada Direct_IO C_Streams a-diocst ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-exceptions-is-null-occurrence-a-einuoc-ads}@anchor{2f7}@anchor{gnat_rm/the_gnat_library id12}@anchor{2f8}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-is-null-occurrence-a-einuoc-ads}@anchor{2fa}@anchor{gnat_rm/the_gnat_library id12}@anchor{2fb}
@section @code{Ada.Exceptions.Is_Null_Occurrence} (@code{a-einuoc.ads})
an exception.
@node Ada Exceptions Last_Chance_Handler a-elchha ads,Ada Exceptions Traceback a-exctra ads,Ada Exceptions Is_Null_Occurrence a-einuoc ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-exceptions-last-chance-handler-a-elchha-ads}@anchor{2f9}@anchor{gnat_rm/the_gnat_library id13}@anchor{2fa}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-last-chance-handler-a-elchha-ads}@anchor{2fc}@anchor{gnat_rm/the_gnat_library id13}@anchor{2fd}
@section @code{Ada.Exceptions.Last_Chance_Handler} (@code{a-elchha.ads})
terminating the program. Note that this subprogram never returns.
@node Ada Exceptions Traceback a-exctra ads,Ada Sequential_IO C_Streams a-siocst ads,Ada Exceptions Last_Chance_Handler a-elchha ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-exceptions-traceback-a-exctra-ads}@anchor{2fb}@anchor{gnat_rm/the_gnat_library id14}@anchor{2fc}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-traceback-a-exctra-ads}@anchor{2fe}@anchor{gnat_rm/the_gnat_library id14}@anchor{2ff}
@section @code{Ada.Exceptions.Traceback} (@code{a-exctra.ads})
occurrence.
@node Ada Sequential_IO C_Streams a-siocst ads,Ada Streams Stream_IO C_Streams a-ssicst ads,Ada Exceptions Traceback a-exctra ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-sequential-io-c-streams-a-siocst-ads}@anchor{2fd}@anchor{gnat_rm/the_gnat_library id15}@anchor{2fe}
+@anchor{gnat_rm/the_gnat_library ada-sequential-io-c-streams-a-siocst-ads}@anchor{300}@anchor{gnat_rm/the_gnat_library id15}@anchor{301}
@section @code{Ada.Sequential_IO.C_Streams} (@code{a-siocst.ads})
can be constructed from a stream opened on the C side.
@node Ada Streams Stream_IO C_Streams a-ssicst ads,Ada Strings Unbounded Text_IO a-suteio ads,Ada Sequential_IO C_Streams a-siocst ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-streams-stream-io-c-streams-a-ssicst-ads}@anchor{2ff}@anchor{gnat_rm/the_gnat_library id16}@anchor{300}
+@anchor{gnat_rm/the_gnat_library ada-streams-stream-io-c-streams-a-ssicst-ads}@anchor{302}@anchor{gnat_rm/the_gnat_library id16}@anchor{303}
@section @code{Ada.Streams.Stream_IO.C_Streams} (@code{a-ssicst.ads})
can be constructed from a stream opened on the C side.
@node Ada Strings Unbounded Text_IO a-suteio ads,Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads,Ada Streams Stream_IO C_Streams a-ssicst ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-strings-unbounded-text-io-a-suteio-ads}@anchor{301}@anchor{gnat_rm/the_gnat_library id17}@anchor{302}
+@anchor{gnat_rm/the_gnat_library ada-strings-unbounded-text-io-a-suteio-ads}@anchor{304}@anchor{gnat_rm/the_gnat_library id17}@anchor{305}
@section @code{Ada.Strings.Unbounded.Text_IO} (@code{a-suteio.ads})
with ordinary strings.
@node Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads,Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads,Ada Strings Unbounded Text_IO a-suteio ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-strings-wide-unbounded-wide-text-io-a-swuwti-ads}@anchor{303}@anchor{gnat_rm/the_gnat_library id18}@anchor{304}
+@anchor{gnat_rm/the_gnat_library ada-strings-wide-unbounded-wide-text-io-a-swuwti-ads}@anchor{306}@anchor{gnat_rm/the_gnat_library id18}@anchor{307}
@section @code{Ada.Strings.Wide_Unbounded.Wide_Text_IO} (@code{a-swuwti.ads})
with ordinary wide strings.
@node Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads,Ada Task_Initialization a-tasini ads,Ada Strings Wide_Unbounded Wide_Text_IO a-swuwti ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-strings-wide-wide-unbounded-wide-wide-text-io-a-szuzti-ads}@anchor{305}@anchor{gnat_rm/the_gnat_library id19}@anchor{306}
+@anchor{gnat_rm/the_gnat_library ada-strings-wide-wide-unbounded-wide-wide-text-io-a-szuzti-ads}@anchor{308}@anchor{gnat_rm/the_gnat_library id19}@anchor{309}
@section @code{Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO} (@code{a-szuzti.ads})
with ordinary wide wide strings.
@node Ada Task_Initialization a-tasini ads,Ada Text_IO C_Streams a-tiocst ads,Ada Strings Wide_Wide_Unbounded Wide_Wide_Text_IO a-szuzti ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-task-initialization-a-tasini-ads}@anchor{307}@anchor{gnat_rm/the_gnat_library id20}@anchor{308}
+@anchor{gnat_rm/the_gnat_library ada-task-initialization-a-tasini-ads}@anchor{30a}@anchor{gnat_rm/the_gnat_library id20}@anchor{30b}
@section @code{Ada.Task_Initialization} (@code{a-tasini.ads})
those tasks activated after the handler is set.
@node Ada Text_IO C_Streams a-tiocst ads,Ada Text_IO Reset_Standard_Files a-tirsfi ads,Ada Task_Initialization a-tasini ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-text-io-c-streams-a-tiocst-ads}@anchor{309}@anchor{gnat_rm/the_gnat_library id21}@anchor{30a}
+@anchor{gnat_rm/the_gnat_library ada-text-io-c-streams-a-tiocst-ads}@anchor{30c}@anchor{gnat_rm/the_gnat_library id21}@anchor{30d}
@section @code{Ada.Text_IO.C_Streams} (@code{a-tiocst.ads})
can be constructed from a stream opened on the C side.
@node Ada Text_IO Reset_Standard_Files a-tirsfi ads,Ada Wide_Characters Unicode a-wichun ads,Ada Text_IO C_Streams a-tiocst ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-text-io-reset-standard-files-a-tirsfi-ads}@anchor{30b}@anchor{gnat_rm/the_gnat_library id22}@anchor{30c}
+@anchor{gnat_rm/the_gnat_library ada-text-io-reset-standard-files-a-tirsfi-ads}@anchor{30e}@anchor{gnat_rm/the_gnat_library id22}@anchor{30f}
@section @code{Ada.Text_IO.Reset_Standard_Files} (@code{a-tirsfi.ads})
interactive).
@node Ada Wide_Characters Unicode a-wichun ads,Ada Wide_Text_IO C_Streams a-wtcstr ads,Ada Text_IO Reset_Standard_Files a-tirsfi ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-wide-characters-unicode-a-wichun-ads}@anchor{30d}@anchor{gnat_rm/the_gnat_library id23}@anchor{30e}
+@anchor{gnat_rm/the_gnat_library ada-wide-characters-unicode-a-wichun-ads}@anchor{310}@anchor{gnat_rm/the_gnat_library id23}@anchor{311}
@section @code{Ada.Wide_Characters.Unicode} (@code{a-wichun.ads})
Wide_Character values according to Unicode categories.
@node Ada Wide_Text_IO C_Streams a-wtcstr ads,Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads,Ada Wide_Characters Unicode a-wichun ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-wide-text-io-c-streams-a-wtcstr-ads}@anchor{30f}@anchor{gnat_rm/the_gnat_library id24}@anchor{310}
+@anchor{gnat_rm/the_gnat_library ada-wide-text-io-c-streams-a-wtcstr-ads}@anchor{312}@anchor{gnat_rm/the_gnat_library id24}@anchor{313}
@section @code{Ada.Wide_Text_IO.C_Streams} (@code{a-wtcstr.ads})
can be constructed from a stream opened on the C side.
@node Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads,Ada Wide_Wide_Characters Unicode a-zchuni ads,Ada Wide_Text_IO C_Streams a-wtcstr ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-wide-text-io-reset-standard-files-a-wrstfi-ads}@anchor{311}@anchor{gnat_rm/the_gnat_library id25}@anchor{312}
+@anchor{gnat_rm/the_gnat_library ada-wide-text-io-reset-standard-files-a-wrstfi-ads}@anchor{314}@anchor{gnat_rm/the_gnat_library id25}@anchor{315}
@section @code{Ada.Wide_Text_IO.Reset_Standard_Files} (@code{a-wrstfi.ads})
interactive).
@node Ada Wide_Wide_Characters Unicode a-zchuni ads,Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads,Ada Wide_Text_IO Reset_Standard_Files a-wrstfi ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-wide-wide-characters-unicode-a-zchuni-ads}@anchor{313}@anchor{gnat_rm/the_gnat_library id26}@anchor{314}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-characters-unicode-a-zchuni-ads}@anchor{316}@anchor{gnat_rm/the_gnat_library id26}@anchor{317}
@section @code{Ada.Wide_Wide_Characters.Unicode} (@code{a-zchuni.ads})
Wide_Wide_Character values according to Unicode categories.
@node Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads,Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads,Ada Wide_Wide_Characters Unicode a-zchuni ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-c-streams-a-ztcstr-ads}@anchor{315}@anchor{gnat_rm/the_gnat_library id27}@anchor{316}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-c-streams-a-ztcstr-ads}@anchor{318}@anchor{gnat_rm/the_gnat_library id27}@anchor{319}
@section @code{Ada.Wide_Wide_Text_IO.C_Streams} (@code{a-ztcstr.ads})
can be constructed from a stream opened on the C side.
@node Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads,GNAT Altivec g-altive ads,Ada Wide_Wide_Text_IO C_Streams a-ztcstr ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-reset-standard-files-a-zrstfi-ads}@anchor{317}@anchor{gnat_rm/the_gnat_library id28}@anchor{318}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-reset-standard-files-a-zrstfi-ads}@anchor{31a}@anchor{gnat_rm/the_gnat_library id28}@anchor{31b}
@section @code{Ada.Wide_Wide_Text_IO.Reset_Standard_Files} (@code{a-zrstfi.ads})
redefined to be interactive).
@node GNAT Altivec g-altive ads,GNAT Altivec Conversions g-altcon ads,Ada Wide_Wide_Text_IO Reset_Standard_Files a-zrstfi ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-altivec-g-altive-ads}@anchor{319}@anchor{gnat_rm/the_gnat_library id29}@anchor{31a}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-g-altive-ads}@anchor{31c}@anchor{gnat_rm/the_gnat_library id29}@anchor{31d}
@section @code{GNAT.Altivec} (@code{g-altive.ads})
binding.
@node GNAT Altivec Conversions g-altcon ads,GNAT Altivec Vector_Operations g-alveop ads,GNAT Altivec g-altive ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-altivec-conversions-g-altcon-ads}@anchor{31b}@anchor{gnat_rm/the_gnat_library id30}@anchor{31c}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-conversions-g-altcon-ads}@anchor{31e}@anchor{gnat_rm/the_gnat_library id30}@anchor{31f}
@section @code{GNAT.Altivec.Conversions} (@code{g-altcon.ads})
This package provides the Vector/View conversion routines.
@node GNAT Altivec Vector_Operations g-alveop ads,GNAT Altivec Vector_Types g-alvety ads,GNAT Altivec Conversions g-altcon ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-operations-g-alveop-ads}@anchor{31d}@anchor{gnat_rm/the_gnat_library id31}@anchor{31e}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-operations-g-alveop-ads}@anchor{320}@anchor{gnat_rm/the_gnat_library id31}@anchor{321}
@section @code{GNAT.Altivec.Vector_Operations} (@code{g-alveop.ads})
is common to both bindings.
@node GNAT Altivec Vector_Types g-alvety ads,GNAT Altivec Vector_Views g-alvevi ads,GNAT Altivec Vector_Operations g-alveop ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-types-g-alvety-ads}@anchor{31f}@anchor{gnat_rm/the_gnat_library id32}@anchor{320}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-types-g-alvety-ads}@anchor{322}@anchor{gnat_rm/the_gnat_library id32}@anchor{323}
@section @code{GNAT.Altivec.Vector_Types} (@code{g-alvety.ads})
to AltiVec facilities.
@node GNAT Altivec Vector_Views g-alvevi ads,GNAT Array_Split g-arrspl ads,GNAT Altivec Vector_Types g-alvety ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-views-g-alvevi-ads}@anchor{321}@anchor{gnat_rm/the_gnat_library id33}@anchor{322}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-views-g-alvevi-ads}@anchor{324}@anchor{gnat_rm/the_gnat_library id33}@anchor{325}
@section @code{GNAT.Altivec.Vector_Views} (@code{g-alvevi.ads})
objects.
@node GNAT Array_Split g-arrspl ads,GNAT AWK g-awk ads,GNAT Altivec Vector_Views g-alvevi ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-array-split-g-arrspl-ads}@anchor{323}@anchor{gnat_rm/the_gnat_library id34}@anchor{324}
+@anchor{gnat_rm/the_gnat_library gnat-array-split-g-arrspl-ads}@anchor{326}@anchor{gnat_rm/the_gnat_library id34}@anchor{327}
@section @code{GNAT.Array_Split} (@code{g-arrspl.ads})
to the resulting slices.
@node GNAT AWK g-awk ads,GNAT Binary_Search g-binsea ads,GNAT Array_Split g-arrspl ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-awk-g-awk-ads}@anchor{325}@anchor{gnat_rm/the_gnat_library id35}@anchor{326}
+@anchor{gnat_rm/the_gnat_library gnat-awk-g-awk-ads}@anchor{328}@anchor{gnat_rm/the_gnat_library id35}@anchor{329}
@section @code{GNAT.AWK} (@code{g-awk.ads})
where each record is a line and a field is a data element in this line.
@node GNAT Binary_Search g-binsea ads,GNAT Bind_Environment g-binenv ads,GNAT AWK g-awk ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-binary-search-g-binsea-ads}@anchor{327}@anchor{gnat_rm/the_gnat_library id36}@anchor{328}
+@anchor{gnat_rm/the_gnat_library gnat-binary-search-g-binsea-ads}@anchor{32a}@anchor{gnat_rm/the_gnat_library id36}@anchor{32b}
@section @code{GNAT.Binary_Search} (@code{g-binsea.ads})
the generic does not reference the array directly).
@node GNAT Bind_Environment g-binenv ads,GNAT Branch_Prediction g-brapre ads,GNAT Binary_Search g-binsea ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-bind-environment-g-binenv-ads}@anchor{329}@anchor{gnat_rm/the_gnat_library id37}@anchor{32a}
+@anchor{gnat_rm/the_gnat_library gnat-bind-environment-g-binenv-ads}@anchor{32c}@anchor{gnat_rm/the_gnat_library id37}@anchor{32d}
@section @code{GNAT.Bind_Environment} (@code{g-binenv.ads})
line switch.
@node GNAT Branch_Prediction g-brapre ads,GNAT Bounded_Buffers g-boubuf ads,GNAT Bind_Environment g-binenv ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-branch-prediction-g-brapre-ads}@anchor{32b}@anchor{gnat_rm/the_gnat_library id38}@anchor{32c}
+@anchor{gnat_rm/the_gnat_library gnat-branch-prediction-g-brapre-ads}@anchor{32e}@anchor{gnat_rm/the_gnat_library id38}@anchor{32f}
@section @code{GNAT.Branch_Prediction} (@code{g-brapre.ads})
Provides routines giving hints to the branch predictor of the code generator.
@node GNAT Bounded_Buffers g-boubuf ads,GNAT Bounded_Mailboxes g-boumai ads,GNAT Branch_Prediction g-brapre ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-bounded-buffers-g-boubuf-ads}@anchor{32d}@anchor{gnat_rm/the_gnat_library id39}@anchor{32e}
+@anchor{gnat_rm/the_gnat_library gnat-bounded-buffers-g-boubuf-ads}@anchor{330}@anchor{gnat_rm/the_gnat_library id39}@anchor{331}
@section @code{GNAT.Bounded_Buffers} (@code{g-boubuf.ads})
such as mailboxes.
@node GNAT Bounded_Mailboxes g-boumai ads,GNAT Bubble_Sort g-bubsor ads,GNAT Bounded_Buffers g-boubuf ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-bounded-mailboxes-g-boumai-ads}@anchor{32f}@anchor{gnat_rm/the_gnat_library id40}@anchor{330}
+@anchor{gnat_rm/the_gnat_library gnat-bounded-mailboxes-g-boumai-ads}@anchor{332}@anchor{gnat_rm/the_gnat_library id40}@anchor{333}
@section @code{GNAT.Bounded_Mailboxes} (@code{g-boumai.ads})
Provides a thread-safe asynchronous intertask mailbox communication facility.
@node GNAT Bubble_Sort g-bubsor ads,GNAT Bubble_Sort_A g-busora ads,GNAT Bounded_Mailboxes g-boumai ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-bubsor-ads}@anchor{331}@anchor{gnat_rm/the_gnat_library id41}@anchor{332}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-bubsor-ads}@anchor{334}@anchor{gnat_rm/the_gnat_library id41}@anchor{335}
@section @code{GNAT.Bubble_Sort} (@code{g-bubsor.ads})
access-to-procedure values.
@node GNAT Bubble_Sort_A g-busora ads,GNAT Bubble_Sort_G g-busorg ads,GNAT Bubble_Sort g-bubsor ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-a-g-busora-ads}@anchor{333}@anchor{gnat_rm/the_gnat_library id42}@anchor{334}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-a-g-busora-ads}@anchor{336}@anchor{gnat_rm/the_gnat_library id42}@anchor{337}
@section @code{GNAT.Bubble_Sort_A} (@code{g-busora.ads})
compatibility. Usually @code{GNAT.Bubble_Sort} will be preferable.
@node GNAT Bubble_Sort_G g-busorg ads,GNAT Byte_Order_Mark g-byorma ads,GNAT Bubble_Sort_A g-busora ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-g-busorg-ads}@anchor{335}@anchor{gnat_rm/the_gnat_library id43}@anchor{336}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-g-busorg-ads}@anchor{338}@anchor{gnat_rm/the_gnat_library id43}@anchor{339}
@section @code{GNAT.Bubble_Sort_G} (@code{g-busorg.ads})
multiple instantiations.
@node GNAT Byte_Order_Mark g-byorma ads,GNAT Byte_Swapping g-bytswa ads,GNAT Bubble_Sort_G g-busorg ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-byte-order-mark-g-byorma-ads}@anchor{337}@anchor{gnat_rm/the_gnat_library id44}@anchor{338}
+@anchor{gnat_rm/the_gnat_library gnat-byte-order-mark-g-byorma-ads}@anchor{33a}@anchor{gnat_rm/the_gnat_library id44}@anchor{33b}
@section @code{GNAT.Byte_Order_Mark} (@code{g-byorma.ads})
sequences for various UCS input formats.
@node GNAT Byte_Swapping g-bytswa ads,GNAT Calendar g-calend ads,GNAT Byte_Order_Mark g-byorma ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-byte-swapping-g-bytswa-ads}@anchor{339}@anchor{gnat_rm/the_gnat_library id45}@anchor{33a}
+@anchor{gnat_rm/the_gnat_library gnat-byte-swapping-g-bytswa-ads}@anchor{33c}@anchor{gnat_rm/the_gnat_library id45}@anchor{33d}
@section @code{GNAT.Byte_Swapping} (@code{g-bytswa.ads})
Machine-specific implementations are available in some cases.
@node GNAT Calendar g-calend ads,GNAT Calendar Time_IO g-catiio ads,GNAT Byte_Swapping g-bytswa ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-calendar-g-calend-ads}@anchor{33b}@anchor{gnat_rm/the_gnat_library id46}@anchor{33c}
+@anchor{gnat_rm/the_gnat_library gnat-calendar-g-calend-ads}@anchor{33e}@anchor{gnat_rm/the_gnat_library id46}@anchor{33f}
@section @code{GNAT.Calendar} (@code{g-calend.ads})
C @code{timeval} format.
@node GNAT Calendar Time_IO g-catiio ads,GNAT CRC32 g-crc32 ads,GNAT Calendar g-calend ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-calendar-time-io-g-catiio-ads}@anchor{33d}@anchor{gnat_rm/the_gnat_library id47}@anchor{33e}
+@anchor{gnat_rm/the_gnat_library gnat-calendar-time-io-g-catiio-ads}@anchor{340}@anchor{gnat_rm/the_gnat_library id47}@anchor{341}
@section @code{GNAT.Calendar.Time_IO} (@code{g-catiio.ads})
@geindex GNAT.Calendar.Time_IO (g-catiio.ads)
@node GNAT CRC32 g-crc32 ads,GNAT Case_Util g-casuti ads,GNAT Calendar Time_IO g-catiio ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-crc32-g-crc32-ads}@anchor{33f}@anchor{gnat_rm/the_gnat_library id48}@anchor{340}
+@anchor{gnat_rm/the_gnat_library gnat-crc32-g-crc32-ads}@anchor{342}@anchor{gnat_rm/the_gnat_library id48}@anchor{343}
@section @code{GNAT.CRC32} (@code{g-crc32.ads})
This package implements the CRC-32 algorithm. For a full description
of this algorithm see
-@emph{Computation of Cyclic Redundancy Checks via Table Look-Up},
+`Computation of Cyclic Redundancy Checks via Table Look-Up',
@cite{Communications of the ACM}, Vol. 31 No. 8, pp. 1008-1013,
Aug. 1988. Sarwate, D.V.
@node GNAT Case_Util g-casuti ads,GNAT CGI g-cgi ads,GNAT CRC32 g-crc32 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-case-util-g-casuti-ads}@anchor{341}@anchor{gnat_rm/the_gnat_library id49}@anchor{342}
+@anchor{gnat_rm/the_gnat_library gnat-case-util-g-casuti-ads}@anchor{344}@anchor{gnat_rm/the_gnat_library id49}@anchor{345}
@section @code{GNAT.Case_Util} (@code{g-casuti.ads})
in @code{Ada.Characters.Handling}.
@node GNAT CGI g-cgi ads,GNAT CGI Cookie g-cgicoo ads,GNAT Case_Util g-casuti ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-cgi-g-cgi-ads}@anchor{343}@anchor{gnat_rm/the_gnat_library id50}@anchor{344}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-g-cgi-ads}@anchor{346}@anchor{gnat_rm/the_gnat_library id50}@anchor{347}
@section @code{GNAT.CGI} (@code{g-cgi.ads})
with this table.
@node GNAT CGI Cookie g-cgicoo ads,GNAT CGI Debug g-cgideb ads,GNAT CGI g-cgi ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-cgi-cookie-g-cgicoo-ads}@anchor{345}@anchor{gnat_rm/the_gnat_library id51}@anchor{346}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-cookie-g-cgicoo-ads}@anchor{348}@anchor{gnat_rm/the_gnat_library id51}@anchor{349}
@section @code{GNAT.CGI.Cookie} (@code{g-cgicoo.ads})
cookies (piece of information kept in the Web client software).
@node GNAT CGI Debug g-cgideb ads,GNAT Command_Line g-comlin ads,GNAT CGI Cookie g-cgicoo ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-cgi-debug-g-cgideb-ads}@anchor{347}@anchor{gnat_rm/the_gnat_library id52}@anchor{348}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-debug-g-cgideb-ads}@anchor{34a}@anchor{gnat_rm/the_gnat_library id52}@anchor{34b}
@section @code{GNAT.CGI.Debug} (@code{g-cgideb.ads})
programs written in Ada.
@node GNAT Command_Line g-comlin ads,GNAT Compiler_Version g-comver ads,GNAT CGI Debug g-cgideb ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-command-line-g-comlin-ads}@anchor{349}@anchor{gnat_rm/the_gnat_library id53}@anchor{34a}
+@anchor{gnat_rm/the_gnat_library gnat-command-line-g-comlin-ads}@anchor{34c}@anchor{gnat_rm/the_gnat_library id53}@anchor{34d}
@section @code{GNAT.Command_Line} (@code{g-comlin.ads})
and expand file names using wildcard notations.
@node GNAT Compiler_Version g-comver ads,GNAT Ctrl_C g-ctrl_c ads,GNAT Command_Line g-comlin ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-compiler-version-g-comver-ads}@anchor{34b}@anchor{gnat_rm/the_gnat_library id54}@anchor{34c}
+@anchor{gnat_rm/the_gnat_library gnat-compiler-version-g-comver-ads}@anchor{34e}@anchor{gnat_rm/the_gnat_library id54}@anchor{34f}
@section @code{GNAT.Compiler_Version} (@code{g-comver.ads})
of a partition).
@node GNAT Ctrl_C g-ctrl_c ads,GNAT Current_Exception g-curexc ads,GNAT Compiler_Version g-comver ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-ctrl-c-g-ctrl-c-ads}@anchor{34d}@anchor{gnat_rm/the_gnat_library id55}@anchor{34e}
+@anchor{gnat_rm/the_gnat_library gnat-ctrl-c-g-ctrl-c-ads}@anchor{350}@anchor{gnat_rm/the_gnat_library id55}@anchor{351}
@section @code{GNAT.Ctrl_C} (@code{g-ctrl_c.ads})
Provides a simple interface to handle Ctrl-C keyboard events.
@node GNAT Current_Exception g-curexc ads,GNAT Debug_Pools g-debpoo ads,GNAT Ctrl_C g-ctrl_c ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-current-exception-g-curexc-ads}@anchor{34f}@anchor{gnat_rm/the_gnat_library id56}@anchor{350}
+@anchor{gnat_rm/the_gnat_library gnat-current-exception-g-curexc-ads}@anchor{352}@anchor{gnat_rm/the_gnat_library id56}@anchor{353}
@section @code{GNAT.Current_Exception} (@code{g-curexc.ads})
obtaining information about exceptions provided by Ada 83 compilers.
@node GNAT Debug_Pools g-debpoo ads,GNAT Debug_Utilities g-debuti ads,GNAT Current_Exception g-curexc ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-debug-pools-g-debpoo-ads}@anchor{351}@anchor{gnat_rm/the_gnat_library id57}@anchor{352}
+@anchor{gnat_rm/the_gnat_library gnat-debug-pools-g-debpoo-ads}@anchor{354}@anchor{gnat_rm/the_gnat_library id57}@anchor{355}
@section @code{GNAT.Debug_Pools} (@code{g-debpoo.ads})
See @code{The GNAT Debug_Pool Facility} section in the @cite{GNAT User’s Guide}.
@node GNAT Debug_Utilities g-debuti ads,GNAT Decode_String g-decstr ads,GNAT Debug_Pools g-debpoo ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-debug-utilities-g-debuti-ads}@anchor{353}@anchor{gnat_rm/the_gnat_library id58}@anchor{354}
+@anchor{gnat_rm/the_gnat_library gnat-debug-utilities-g-debuti-ads}@anchor{356}@anchor{gnat_rm/the_gnat_library id58}@anchor{357}
@section @code{GNAT.Debug_Utilities} (@code{g-debuti.ads})
for hexadecimal literals.
@node GNAT Decode_String g-decstr ads,GNAT Decode_UTF8_String g-deutst ads,GNAT Debug_Utilities g-debuti ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-decode-string-g-decstr-ads}@anchor{355}@anchor{gnat_rm/the_gnat_library id59}@anchor{356}
+@anchor{gnat_rm/the_gnat_library gnat-decode-string-g-decstr-ads}@anchor{358}@anchor{gnat_rm/the_gnat_library id59}@anchor{359}
@section @code{GNAT.Decode_String} (@code{g-decstr.ads})
preinstantiation for UTF-8. See next entry.
@node GNAT Decode_UTF8_String g-deutst ads,GNAT Directory_Operations g-dirope ads,GNAT Decode_String g-decstr ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-decode-utf8-string-g-deutst-ads}@anchor{357}@anchor{gnat_rm/the_gnat_library id60}@anchor{358}
+@anchor{gnat_rm/the_gnat_library gnat-decode-utf8-string-g-deutst-ads}@anchor{35a}@anchor{gnat_rm/the_gnat_library id60}@anchor{35b}
@section @code{GNAT.Decode_UTF8_String} (@code{g-deutst.ads})
A preinstantiation of GNAT.Decode_Strings for UTF-8 encoding.
@node GNAT Directory_Operations g-dirope ads,GNAT Directory_Operations Iteration g-diopit ads,GNAT Decode_UTF8_String g-deutst ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-directory-operations-g-dirope-ads}@anchor{359}@anchor{gnat_rm/the_gnat_library id61}@anchor{35a}
+@anchor{gnat_rm/the_gnat_library gnat-directory-operations-g-dirope-ads}@anchor{35c}@anchor{gnat_rm/the_gnat_library id61}@anchor{35d}
@section @code{GNAT.Directory_Operations} (@code{g-dirope.ads})
directory.
@node GNAT Directory_Operations Iteration g-diopit ads,GNAT Dynamic_HTables g-dynhta ads,GNAT Directory_Operations g-dirope ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-directory-operations-iteration-g-diopit-ads}@anchor{35b}@anchor{gnat_rm/the_gnat_library id62}@anchor{35c}
+@anchor{gnat_rm/the_gnat_library gnat-directory-operations-iteration-g-diopit-ads}@anchor{35e}@anchor{gnat_rm/the_gnat_library id62}@anchor{35f}
@section @code{GNAT.Directory_Operations.Iteration} (@code{g-diopit.ads})
for iterating through directories.
@node GNAT Dynamic_HTables g-dynhta ads,GNAT Dynamic_Tables g-dyntab ads,GNAT Directory_Operations Iteration g-diopit ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-dynamic-htables-g-dynhta-ads}@anchor{35d}@anchor{gnat_rm/the_gnat_library id63}@anchor{35e}
+@anchor{gnat_rm/the_gnat_library gnat-dynamic-htables-g-dynhta-ads}@anchor{360}@anchor{gnat_rm/the_gnat_library id63}@anchor{361}
@section @code{GNAT.Dynamic_HTables} (@code{g-dynhta.ads})
@code{GNAT.HTable} creates a single instance of the hash table.
@node GNAT Dynamic_Tables g-dyntab ads,GNAT Encode_String g-encstr ads,GNAT Dynamic_HTables g-dynhta ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-dynamic-tables-g-dyntab-ads}@anchor{35f}@anchor{gnat_rm/the_gnat_library id64}@anchor{360}
+@anchor{gnat_rm/the_gnat_library gnat-dynamic-tables-g-dyntab-ads}@anchor{362}@anchor{gnat_rm/the_gnat_library id64}@anchor{363}
@section @code{GNAT.Dynamic_Tables} (@code{g-dyntab.ads})
@code{GNAT.Table} creates a single instance of the table type.
@node GNAT Encode_String g-encstr ads,GNAT Encode_UTF8_String g-enutst ads,GNAT Dynamic_Tables g-dyntab ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-encode-string-g-encstr-ads}@anchor{361}@anchor{gnat_rm/the_gnat_library id65}@anchor{362}
+@anchor{gnat_rm/the_gnat_library gnat-encode-string-g-encstr-ads}@anchor{364}@anchor{gnat_rm/the_gnat_library id65}@anchor{365}
@section @code{GNAT.Encode_String} (@code{g-encstr.ads})
Note there is a preinstantiation for UTF-8. See next entry.
@node GNAT Encode_UTF8_String g-enutst ads,GNAT Exception_Actions g-excact ads,GNAT Encode_String g-encstr ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-encode-utf8-string-g-enutst-ads}@anchor{363}@anchor{gnat_rm/the_gnat_library id66}@anchor{364}
+@anchor{gnat_rm/the_gnat_library gnat-encode-utf8-string-g-enutst-ads}@anchor{366}@anchor{gnat_rm/the_gnat_library id66}@anchor{367}
@section @code{GNAT.Encode_UTF8_String} (@code{g-enutst.ads})
A preinstantiation of GNAT.Encode_Strings for UTF-8 encoding.
@node GNAT Exception_Actions g-excact ads,GNAT Exception_Traces g-exctra ads,GNAT Encode_UTF8_String g-enutst ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-exception-actions-g-excact-ads}@anchor{365}@anchor{gnat_rm/the_gnat_library id67}@anchor{366}
+@anchor{gnat_rm/the_gnat_library gnat-exception-actions-g-excact-ads}@anchor{368}@anchor{gnat_rm/the_gnat_library id67}@anchor{369}
@section @code{GNAT.Exception_Actions} (@code{g-excact.ads})
can be used for instance to force a core dump to ease debugging.
@node GNAT Exception_Traces g-exctra ads,GNAT Exceptions g-except ads,GNAT Exception_Actions g-excact ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-exception-traces-g-exctra-ads}@anchor{367}@anchor{gnat_rm/the_gnat_library id68}@anchor{368}
+@anchor{gnat_rm/the_gnat_library gnat-exception-traces-g-exctra-ads}@anchor{36a}@anchor{gnat_rm/the_gnat_library id68}@anchor{36b}
@section @code{GNAT.Exception_Traces} (@code{g-exctra.ads})
occurrences.
@node GNAT Exceptions g-except ads,GNAT Expect g-expect ads,GNAT Exception_Traces g-exctra ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-exceptions-g-except-ads}@anchor{369}@anchor{gnat_rm/the_gnat_library id69}@anchor{36a}
+@anchor{gnat_rm/the_gnat_library gnat-exceptions-g-except-ads}@anchor{36c}@anchor{gnat_rm/the_gnat_library id69}@anchor{36d}
@section @code{GNAT.Exceptions} (@code{g-except.ads})
@code{Constraint_Error} with a message from a pure subprogram.
@node GNAT Expect g-expect ads,GNAT Expect TTY g-exptty ads,GNAT Exceptions g-except ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-expect-g-expect-ads}@anchor{36b}@anchor{gnat_rm/the_gnat_library id70}@anchor{36c}
+@anchor{gnat_rm/the_gnat_library gnat-expect-g-expect-ads}@anchor{36e}@anchor{gnat_rm/the_gnat_library id70}@anchor{36f}
@section @code{GNAT.Expect} (@code{g-expect.ads})
implemented for VxWorks or LynxOS.
@node GNAT Expect TTY g-exptty ads,GNAT Float_Control g-flocon ads,GNAT Expect g-expect ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-expect-tty-g-exptty-ads}@anchor{36d}@anchor{gnat_rm/the_gnat_library id71}@anchor{36e}
+@anchor{gnat_rm/the_gnat_library gnat-expect-tty-g-exptty-ads}@anchor{370}@anchor{gnat_rm/the_gnat_library id71}@anchor{371}
@section @code{GNAT.Expect.TTY} (@code{g-exptty.ads})
in particular is not implemented for VxWorks or LynxOS.
@node GNAT Float_Control g-flocon ads,GNAT Formatted_String g-forstr ads,GNAT Expect TTY g-exptty ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-float-control-g-flocon-ads}@anchor{36f}@anchor{gnat_rm/the_gnat_library id72}@anchor{370}
+@anchor{gnat_rm/the_gnat_library gnat-float-control-g-flocon-ads}@anchor{372}@anchor{gnat_rm/the_gnat_library id72}@anchor{373}
@section @code{GNAT.Float_Control} (@code{g-flocon.ads})
in this package can be used to reestablish the required mode.
@node GNAT Formatted_String g-forstr ads,GNAT Generic_Fast_Math_Functions g-gfmafu ads,GNAT Float_Control g-flocon ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-formatted-string-g-forstr-ads}@anchor{371}@anchor{gnat_rm/the_gnat_library id73}@anchor{372}
+@anchor{gnat_rm/the_gnat_library gnat-formatted-string-g-forstr-ads}@anchor{374}@anchor{gnat_rm/the_gnat_library id73}@anchor{375}
@section @code{GNAT.Formatted_String} (@code{g-forstr.ads})
formatted string.
@node GNAT Generic_Fast_Math_Functions g-gfmafu ads,GNAT Heap_Sort g-heasor ads,GNAT Formatted_String g-forstr ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-generic-fast-math-functions-g-gfmafu-ads}@anchor{373}@anchor{gnat_rm/the_gnat_library id74}@anchor{374}
+@anchor{gnat_rm/the_gnat_library gnat-generic-fast-math-functions-g-gfmafu-ads}@anchor{376}@anchor{gnat_rm/the_gnat_library id74}@anchor{377}
@section @code{GNAT.Generic_Fast_Math_Functions} (@code{g-gfmafu.ads})
compiler when auto-vectorization is enabled.
@node GNAT Heap_Sort g-heasor ads,GNAT Heap_Sort_A g-hesora ads,GNAT Generic_Fast_Math_Functions g-gfmafu ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-heasor-ads}@anchor{375}@anchor{gnat_rm/the_gnat_library id75}@anchor{376}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-heasor-ads}@anchor{378}@anchor{gnat_rm/the_gnat_library id75}@anchor{379}
@section @code{GNAT.Heap_Sort} (@code{g-heasor.ads})
that performs approximately N*log(N) comparisons in the worst case.
@node GNAT Heap_Sort_A g-hesora ads,GNAT Heap_Sort_G g-hesorg ads,GNAT Heap_Sort g-heasor ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-heap-sort-a-g-hesora-ads}@anchor{377}@anchor{gnat_rm/the_gnat_library id76}@anchor{378}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-a-g-hesora-ads}@anchor{37a}@anchor{gnat_rm/the_gnat_library id76}@anchor{37b}
@section @code{GNAT.Heap_Sort_A} (@code{g-hesora.ads})
interface, but may be slightly more efficient.
@node GNAT Heap_Sort_G g-hesorg ads,GNAT HTable g-htable ads,GNAT Heap_Sort_A g-hesora ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-g-hesorg-ads}@anchor{379}@anchor{gnat_rm/the_gnat_library id77}@anchor{37a}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-g-hesorg-ads}@anchor{37c}@anchor{gnat_rm/the_gnat_library id77}@anchor{37d}
@section @code{GNAT.Heap_Sort_G} (@code{g-hesorg.ads})
multiple instantiations.
@node GNAT HTable g-htable ads,GNAT IO g-io ads,GNAT Heap_Sort_G g-hesorg ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-htable-g-htable-ads}@anchor{37b}@anchor{gnat_rm/the_gnat_library id78}@anchor{37c}
+@anchor{gnat_rm/the_gnat_library gnat-htable-g-htable-ads}@anchor{37e}@anchor{gnat_rm/the_gnat_library id78}@anchor{37f}
@section @code{GNAT.HTable} (@code{g-htable.ads})
allowing arbitrary dynamic hash tables.
@node GNAT IO g-io ads,GNAT IO_Aux g-io_aux ads,GNAT HTable g-htable ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-io-g-io-ads}@anchor{37d}@anchor{gnat_rm/the_gnat_library id79}@anchor{37e}
+@anchor{gnat_rm/the_gnat_library gnat-io-g-io-ads}@anchor{380}@anchor{gnat_rm/the_gnat_library id79}@anchor{381}
@section @code{GNAT.IO} (@code{g-io.ads})
Standard_Output or Standard_Error.
@node GNAT IO_Aux g-io_aux ads,GNAT Lock_Files g-locfil ads,GNAT IO g-io ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-io-aux-g-io-aux-ads}@anchor{37f}@anchor{gnat_rm/the_gnat_library id80}@anchor{380}
+@anchor{gnat_rm/the_gnat_library gnat-io-aux-g-io-aux-ads}@anchor{382}@anchor{gnat_rm/the_gnat_library id80}@anchor{383}
@section @code{GNAT.IO_Aux} (@code{g-io_aux.ads})
for whether a file exists, and functions for reading a line of text.
@node GNAT Lock_Files g-locfil ads,GNAT MBBS_Discrete_Random g-mbdira ads,GNAT IO_Aux g-io_aux ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-lock-files-g-locfil-ads}@anchor{381}@anchor{gnat_rm/the_gnat_library id81}@anchor{382}
+@anchor{gnat_rm/the_gnat_library gnat-lock-files-g-locfil-ads}@anchor{384}@anchor{gnat_rm/the_gnat_library id81}@anchor{385}
@section @code{GNAT.Lock_Files} (@code{g-locfil.ads})
providing program level synchronization.
@node GNAT MBBS_Discrete_Random g-mbdira ads,GNAT MBBS_Float_Random g-mbflra ads,GNAT Lock_Files g-locfil ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-mbbs-discrete-random-g-mbdira-ads}@anchor{383}@anchor{gnat_rm/the_gnat_library id82}@anchor{384}
+@anchor{gnat_rm/the_gnat_library gnat-mbbs-discrete-random-g-mbdira-ads}@anchor{386}@anchor{gnat_rm/the_gnat_library id82}@anchor{387}
@section @code{GNAT.MBBS_Discrete_Random} (@code{g-mbdira.ads})
a modified version of the Blum-Blum-Shub generator.
@node GNAT MBBS_Float_Random g-mbflra ads,GNAT MD5 g-md5 ads,GNAT MBBS_Discrete_Random g-mbdira ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-mbbs-float-random-g-mbflra-ads}@anchor{385}@anchor{gnat_rm/the_gnat_library id83}@anchor{386}
+@anchor{gnat_rm/the_gnat_library gnat-mbbs-float-random-g-mbflra-ads}@anchor{388}@anchor{gnat_rm/the_gnat_library id83}@anchor{389}
@section @code{GNAT.MBBS_Float_Random} (@code{g-mbflra.ads})
a modified version of the Blum-Blum-Shub generator.
@node GNAT MD5 g-md5 ads,GNAT Memory_Dump g-memdum ads,GNAT MBBS_Float_Random g-mbflra ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-md5-g-md5-ads}@anchor{387}@anchor{gnat_rm/the_gnat_library id84}@anchor{388}
+@anchor{gnat_rm/the_gnat_library gnat-md5-g-md5-ads}@anchor{38a}@anchor{gnat_rm/the_gnat_library id84}@anchor{38b}
@section @code{GNAT.MD5} (@code{g-md5.ads})
FIPS PUB 198.
@node GNAT Memory_Dump g-memdum ads,GNAT Most_Recent_Exception g-moreex ads,GNAT MD5 g-md5 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-memory-dump-g-memdum-ads}@anchor{389}@anchor{gnat_rm/the_gnat_library id85}@anchor{38a}
+@anchor{gnat_rm/the_gnat_library gnat-memory-dump-g-memdum-ads}@anchor{38c}@anchor{gnat_rm/the_gnat_library id85}@anchor{38d}
@section @code{GNAT.Memory_Dump} (@code{g-memdum.ads})
output.
@node GNAT Most_Recent_Exception g-moreex ads,GNAT OS_Lib g-os_lib ads,GNAT Memory_Dump g-memdum ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-most-recent-exception-g-moreex-ads}@anchor{38b}@anchor{gnat_rm/the_gnat_library id86}@anchor{38c}
+@anchor{gnat_rm/the_gnat_library gnat-most-recent-exception-g-moreex-ads}@anchor{38e}@anchor{gnat_rm/the_gnat_library id86}@anchor{38f}
@section @code{GNAT.Most_Recent_Exception} (@code{g-moreex.ads})
Ada 83 implementation dependent extensions.
@node GNAT OS_Lib g-os_lib ads,GNAT Perfect_Hash_Generators g-pehage ads,GNAT Most_Recent_Exception g-moreex ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-os-lib-g-os-lib-ads}@anchor{38d}@anchor{gnat_rm/the_gnat_library id87}@anchor{38e}
+@anchor{gnat_rm/the_gnat_library gnat-os-lib-g-os-lib-ads}@anchor{390}@anchor{gnat_rm/the_gnat_library id87}@anchor{391}
@section @code{GNAT.OS_Lib} (@code{g-os_lib.ads})
and error return codes.
@node GNAT Perfect_Hash_Generators g-pehage ads,GNAT Random_Numbers g-rannum ads,GNAT OS_Lib g-os_lib ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-perfect-hash-generators-g-pehage-ads}@anchor{38f}@anchor{gnat_rm/the_gnat_library id88}@anchor{390}
+@anchor{gnat_rm/the_gnat_library gnat-perfect-hash-generators-g-pehage-ads}@anchor{392}@anchor{gnat_rm/the_gnat_library id88}@anchor{393}
@section @code{GNAT.Perfect_Hash_Generators} (@code{g-pehage.ads})
convenient for use with realtime applications.
@node GNAT Random_Numbers g-rannum ads,GNAT Regexp g-regexp ads,GNAT Perfect_Hash_Generators g-pehage ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-random-numbers-g-rannum-ads}@anchor{391}@anchor{gnat_rm/the_gnat_library id89}@anchor{392}
+@anchor{gnat_rm/the_gnat_library gnat-random-numbers-g-rannum-ads}@anchor{394}@anchor{gnat_rm/the_gnat_library id89}@anchor{395}
@section @code{GNAT.Random_Numbers} (@code{g-rannum.ads})
standard Ada library and are more convenient to use.
@node GNAT Regexp g-regexp ads,GNAT Registry g-regist ads,GNAT Random_Numbers g-rannum ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-regexp-g-regexp-ads}@anchor{268}@anchor{gnat_rm/the_gnat_library id90}@anchor{393}
+@anchor{gnat_rm/the_gnat_library gnat-regexp-g-regexp-ads}@anchor{26b}@anchor{gnat_rm/the_gnat_library id90}@anchor{396}
@section @code{GNAT.Regexp} (@code{g-regexp.ads})
suitable for ‘file globbing’ applications.
@node GNAT Registry g-regist ads,GNAT Regpat g-regpat ads,GNAT Regexp g-regexp ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-registry-g-regist-ads}@anchor{394}@anchor{gnat_rm/the_gnat_library id91}@anchor{395}
+@anchor{gnat_rm/the_gnat_library gnat-registry-g-regist-ads}@anchor{397}@anchor{gnat_rm/the_gnat_library id91}@anchor{398}
@section @code{GNAT.Registry} (@code{g-regist.ads})
package provided with the Win32Ada binding
@node GNAT Regpat g-regpat ads,GNAT Rewrite_Data g-rewdat ads,GNAT Registry g-regist ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-regpat-g-regpat-ads}@anchor{396}@anchor{gnat_rm/the_gnat_library id92}@anchor{397}
+@anchor{gnat_rm/the_gnat_library gnat-regpat-g-regpat-ads}@anchor{399}@anchor{gnat_rm/the_gnat_library id92}@anchor{39a}
@section @code{GNAT.Regpat} (@code{g-regpat.ads})
Henry Spencer (and binary compatible with this C library).
@node GNAT Rewrite_Data g-rewdat ads,GNAT Secondary_Stack_Info g-sestin ads,GNAT Regpat g-regpat ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-rewrite-data-g-rewdat-ads}@anchor{398}@anchor{gnat_rm/the_gnat_library id93}@anchor{399}
+@anchor{gnat_rm/the_gnat_library gnat-rewrite-data-g-rewdat-ads}@anchor{39b}@anchor{gnat_rm/the_gnat_library id93}@anchor{39c}
@section @code{GNAT.Rewrite_Data} (@code{g-rewdat.ads})
this interface usable for large files or socket streams.
@node GNAT Secondary_Stack_Info g-sestin ads,GNAT Semaphores g-semaph ads,GNAT Rewrite_Data g-rewdat ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-secondary-stack-info-g-sestin-ads}@anchor{39a}@anchor{gnat_rm/the_gnat_library id94}@anchor{39b}
+@anchor{gnat_rm/the_gnat_library gnat-secondary-stack-info-g-sestin-ads}@anchor{39d}@anchor{gnat_rm/the_gnat_library id94}@anchor{39e}
@section @code{GNAT.Secondary_Stack_Info} (@code{g-sestin.ads})
secondary stack.
@node GNAT Semaphores g-semaph ads,GNAT Serial_Communications g-sercom ads,GNAT Secondary_Stack_Info g-sestin ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-semaphores-g-semaph-ads}@anchor{39c}@anchor{gnat_rm/the_gnat_library id95}@anchor{39d}
+@anchor{gnat_rm/the_gnat_library gnat-semaphores-g-semaph-ads}@anchor{39f}@anchor{gnat_rm/the_gnat_library id95}@anchor{3a0}
@section @code{GNAT.Semaphores} (@code{g-semaph.ads})
Provides classic counting and binary semaphores using protected types.
@node GNAT Serial_Communications g-sercom ads,GNAT SHA1 g-sha1 ads,GNAT Semaphores g-semaph ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-serial-communications-g-sercom-ads}@anchor{39e}@anchor{gnat_rm/the_gnat_library id96}@anchor{39f}
+@anchor{gnat_rm/the_gnat_library gnat-serial-communications-g-sercom-ads}@anchor{3a1}@anchor{gnat_rm/the_gnat_library id96}@anchor{3a2}
@section @code{GNAT.Serial_Communications} (@code{g-sercom.ads})
port. This is only supported on GNU/Linux and Windows.
@node GNAT SHA1 g-sha1 ads,GNAT SHA224 g-sha224 ads,GNAT Serial_Communications g-sercom ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-sha1-g-sha1-ads}@anchor{3a0}@anchor{gnat_rm/the_gnat_library id97}@anchor{3a1}
+@anchor{gnat_rm/the_gnat_library gnat-sha1-g-sha1-ads}@anchor{3a3}@anchor{gnat_rm/the_gnat_library id97}@anchor{3a4}
@section @code{GNAT.SHA1} (@code{g-sha1.ads})
in RFC 2104 and FIPS PUB 198.
@node GNAT SHA224 g-sha224 ads,GNAT SHA256 g-sha256 ads,GNAT SHA1 g-sha1 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-sha224-g-sha224-ads}@anchor{3a2}@anchor{gnat_rm/the_gnat_library id98}@anchor{3a3}
+@anchor{gnat_rm/the_gnat_library gnat-sha224-g-sha224-ads}@anchor{3a5}@anchor{gnat_rm/the_gnat_library id98}@anchor{3a6}
@section @code{GNAT.SHA224} (@code{g-sha224.ads})
in RFC 2104 and FIPS PUB 198.
@node GNAT SHA256 g-sha256 ads,GNAT SHA384 g-sha384 ads,GNAT SHA224 g-sha224 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-sha256-g-sha256-ads}@anchor{3a4}@anchor{gnat_rm/the_gnat_library id99}@anchor{3a5}
+@anchor{gnat_rm/the_gnat_library gnat-sha256-g-sha256-ads}@anchor{3a7}@anchor{gnat_rm/the_gnat_library id99}@anchor{3a8}
@section @code{GNAT.SHA256} (@code{g-sha256.ads})
in RFC 2104 and FIPS PUB 198.
@node GNAT SHA384 g-sha384 ads,GNAT SHA512 g-sha512 ads,GNAT SHA256 g-sha256 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-sha384-g-sha384-ads}@anchor{3a6}@anchor{gnat_rm/the_gnat_library id100}@anchor{3a7}
+@anchor{gnat_rm/the_gnat_library gnat-sha384-g-sha384-ads}@anchor{3a9}@anchor{gnat_rm/the_gnat_library id100}@anchor{3aa}
@section @code{GNAT.SHA384} (@code{g-sha384.ads})
in RFC 2104 and FIPS PUB 198.
@node GNAT SHA512 g-sha512 ads,GNAT Signals g-signal ads,GNAT SHA384 g-sha384 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-sha512-g-sha512-ads}@anchor{3a8}@anchor{gnat_rm/the_gnat_library id101}@anchor{3a9}
+@anchor{gnat_rm/the_gnat_library gnat-sha512-g-sha512-ads}@anchor{3ab}@anchor{gnat_rm/the_gnat_library id101}@anchor{3ac}
@section @code{GNAT.SHA512} (@code{g-sha512.ads})
in RFC 2104 and FIPS PUB 198.
@node GNAT Signals g-signal ads,GNAT Sockets g-socket ads,GNAT SHA512 g-sha512 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-signals-g-signal-ads}@anchor{3aa}@anchor{gnat_rm/the_gnat_library id102}@anchor{3ab}
+@anchor{gnat_rm/the_gnat_library gnat-signals-g-signal-ads}@anchor{3ad}@anchor{gnat_rm/the_gnat_library id102}@anchor{3ae}
@section @code{GNAT.Signals} (@code{g-signal.ads})
targets.
@node GNAT Sockets g-socket ads,GNAT Source_Info g-souinf ads,GNAT Signals g-signal ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-sockets-g-socket-ads}@anchor{3ac}@anchor{gnat_rm/the_gnat_library id103}@anchor{3ad}
+@anchor{gnat_rm/the_gnat_library gnat-sockets-g-socket-ads}@anchor{3af}@anchor{gnat_rm/the_gnat_library id103}@anchor{3b0}
@section @code{GNAT.Sockets} (@code{g-socket.ads})
the LynxOS cross port.
@node GNAT Source_Info g-souinf ads,GNAT Spelling_Checker g-speche ads,GNAT Sockets g-socket ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-source-info-g-souinf-ads}@anchor{3ae}@anchor{gnat_rm/the_gnat_library id104}@anchor{3af}
+@anchor{gnat_rm/the_gnat_library gnat-source-info-g-souinf-ads}@anchor{3b1}@anchor{gnat_rm/the_gnat_library id104}@anchor{3b2}
@section @code{GNAT.Source_Info} (@code{g-souinf.ads})
C macros @code{__DATE__} and @code{__TIME__})
@node GNAT Spelling_Checker g-speche ads,GNAT Spelling_Checker_Generic g-spchge ads,GNAT Source_Info g-souinf ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-g-speche-ads}@anchor{3b0}@anchor{gnat_rm/the_gnat_library id105}@anchor{3b1}
+@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-g-speche-ads}@anchor{3b3}@anchor{gnat_rm/the_gnat_library id105}@anchor{3b4}
@section @code{GNAT.Spelling_Checker} (@code{g-speche.ads})
near misspelling of another string.
@node GNAT Spelling_Checker_Generic g-spchge ads,GNAT Spitbol Patterns g-spipat ads,GNAT Spelling_Checker g-speche ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-generic-g-spchge-ads}@anchor{3b2}@anchor{gnat_rm/the_gnat_library id106}@anchor{3b3}
+@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-generic-g-spchge-ads}@anchor{3b5}@anchor{gnat_rm/the_gnat_library id106}@anchor{3b6}
@section @code{GNAT.Spelling_Checker_Generic} (@code{g-spchge.ads})
string.
@node GNAT Spitbol Patterns g-spipat ads,GNAT Spitbol g-spitbo ads,GNAT Spelling_Checker_Generic g-spchge ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-spitbol-patterns-g-spipat-ads}@anchor{3b4}@anchor{gnat_rm/the_gnat_library id107}@anchor{3b5}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-patterns-g-spipat-ads}@anchor{3b7}@anchor{gnat_rm/the_gnat_library id107}@anchor{3b8}
@section @code{GNAT.Spitbol.Patterns} (@code{g-spipat.ads})
efficient algorithm developed by Robert Dewar for the SPITBOL system.
@node GNAT Spitbol g-spitbo ads,GNAT Spitbol Table_Boolean g-sptabo ads,GNAT Spitbol Patterns g-spipat ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-spitbol-g-spitbo-ads}@anchor{3b6}@anchor{gnat_rm/the_gnat_library id108}@anchor{3b7}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-g-spitbo-ads}@anchor{3b9}@anchor{gnat_rm/the_gnat_library id108}@anchor{3ba}
@section @code{GNAT.Spitbol} (@code{g-spitbo.ads})
the SNOBOL4 TABLE function.
@node GNAT Spitbol Table_Boolean g-sptabo ads,GNAT Spitbol Table_Integer g-sptain ads,GNAT Spitbol g-spitbo ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-boolean-g-sptabo-ads}@anchor{3b8}@anchor{gnat_rm/the_gnat_library id109}@anchor{3b9}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-boolean-g-sptabo-ads}@anchor{3bb}@anchor{gnat_rm/the_gnat_library id109}@anchor{3bc}
@section @code{GNAT.Spitbol.Table_Boolean} (@code{g-sptabo.ads})
string values.
@node GNAT Spitbol Table_Integer g-sptain ads,GNAT Spitbol Table_VString g-sptavs ads,GNAT Spitbol Table_Boolean g-sptabo ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-integer-g-sptain-ads}@anchor{3ba}@anchor{gnat_rm/the_gnat_library id110}@anchor{3bb}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-integer-g-sptain-ads}@anchor{3bd}@anchor{gnat_rm/the_gnat_library id110}@anchor{3be}
@section @code{GNAT.Spitbol.Table_Integer} (@code{g-sptain.ads})
from string to integer values.
@node GNAT Spitbol Table_VString g-sptavs ads,GNAT SSE g-sse ads,GNAT Spitbol Table_Integer g-sptain ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-vstring-g-sptavs-ads}@anchor{3bc}@anchor{gnat_rm/the_gnat_library id111}@anchor{3bd}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-vstring-g-sptavs-ads}@anchor{3bf}@anchor{gnat_rm/the_gnat_library id111}@anchor{3c0}
@section @code{GNAT.Spitbol.Table_VString} (@code{g-sptavs.ads})
maps from strings to strings.
@node GNAT SSE g-sse ads,GNAT SSE Vector_Types g-ssvety ads,GNAT Spitbol Table_VString g-sptavs ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-sse-g-sse-ads}@anchor{3be}@anchor{gnat_rm/the_gnat_library id112}@anchor{3bf}
+@anchor{gnat_rm/the_gnat_library gnat-sse-g-sse-ads}@anchor{3c1}@anchor{gnat_rm/the_gnat_library id112}@anchor{3c2}
@section @code{GNAT.SSE} (@code{g-sse.ads})
introduction to the binding contents and use.
@node GNAT SSE Vector_Types g-ssvety ads,GNAT String_Hash g-strhas ads,GNAT SSE g-sse ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-sse-vector-types-g-ssvety-ads}@anchor{3c0}@anchor{gnat_rm/the_gnat_library id113}@anchor{3c1}
+@anchor{gnat_rm/the_gnat_library gnat-sse-vector-types-g-ssvety-ads}@anchor{3c3}@anchor{gnat_rm/the_gnat_library id113}@anchor{3c4}
@section @code{GNAT.SSE.Vector_Types} (@code{g-ssvety.ads})
SSE vector types for use with SSE related intrinsics.
@node GNAT String_Hash g-strhas ads,GNAT Strings g-string ads,GNAT SSE Vector_Types g-ssvety ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-string-hash-g-strhas-ads}@anchor{3c2}@anchor{gnat_rm/the_gnat_library id114}@anchor{3c3}
+@anchor{gnat_rm/the_gnat_library gnat-string-hash-g-strhas-ads}@anchor{3c5}@anchor{gnat_rm/the_gnat_library id114}@anchor{3c6}
@section @code{GNAT.String_Hash} (@code{g-strhas.ads})
type and the hash result type are parameters.
@node GNAT Strings g-string ads,GNAT String_Split g-strspl ads,GNAT String_Hash g-strhas ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-strings-g-string-ads}@anchor{3c4}@anchor{gnat_rm/the_gnat_library id115}@anchor{3c5}
+@anchor{gnat_rm/the_gnat_library gnat-strings-g-string-ads}@anchor{3c7}@anchor{gnat_rm/the_gnat_library id115}@anchor{3c8}
@section @code{GNAT.Strings} (@code{g-string.ads})
defines a string access and an array of string access types.
@node GNAT String_Split g-strspl ads,GNAT Table g-table ads,GNAT Strings g-string ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-string-split-g-strspl-ads}@anchor{3c6}@anchor{gnat_rm/the_gnat_library id116}@anchor{3c7}
+@anchor{gnat_rm/the_gnat_library gnat-string-split-g-strspl-ads}@anchor{3c9}@anchor{gnat_rm/the_gnat_library id116}@anchor{3ca}
@section @code{GNAT.String_Split} (@code{g-strspl.ads})
@code{GNAT.Array_Split}.
@node GNAT Table g-table ads,GNAT Task_Lock g-tasloc ads,GNAT String_Split g-strspl ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-table-g-table-ads}@anchor{3c8}@anchor{gnat_rm/the_gnat_library id117}@anchor{3c9}
+@anchor{gnat_rm/the_gnat_library gnat-table-g-table-ads}@anchor{3cb}@anchor{gnat_rm/the_gnat_library id117}@anchor{3cc}
@section @code{GNAT.Table} (@code{g-table.ads})
used to define dynamic instances of the table.
@node GNAT Task_Lock g-tasloc ads,GNAT Time_Stamp g-timsta ads,GNAT Table g-table ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-task-lock-g-tasloc-ads}@anchor{3ca}@anchor{gnat_rm/the_gnat_library id118}@anchor{3cb}
+@anchor{gnat_rm/the_gnat_library gnat-task-lock-g-tasloc-ads}@anchor{3cd}@anchor{gnat_rm/the_gnat_library id118}@anchor{3ce}
@section @code{GNAT.Task_Lock} (@code{g-tasloc.ads})
between tasks is very rarely expected.
@node GNAT Time_Stamp g-timsta ads,GNAT Threads g-thread ads,GNAT Task_Lock g-tasloc ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-time-stamp-g-timsta-ads}@anchor{3cc}@anchor{gnat_rm/the_gnat_library id119}@anchor{3cd}
+@anchor{gnat_rm/the_gnat_library gnat-time-stamp-g-timsta-ads}@anchor{3cf}@anchor{gnat_rm/the_gnat_library id119}@anchor{3d0}
@section @code{GNAT.Time_Stamp} (@code{g-timsta.ads})
routine with minimal code and there are no dependencies on any other unit.
@node GNAT Threads g-thread ads,GNAT Traceback g-traceb ads,GNAT Time_Stamp g-timsta ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-threads-g-thread-ads}@anchor{3ce}@anchor{gnat_rm/the_gnat_library id120}@anchor{3cf}
+@anchor{gnat_rm/the_gnat_library gnat-threads-g-thread-ads}@anchor{3d1}@anchor{gnat_rm/the_gnat_library id120}@anchor{3d2}
@section @code{GNAT.Threads} (@code{g-thread.ads})
environment which then accesses Ada code.
@node GNAT Traceback g-traceb ads,GNAT Traceback Symbolic g-trasym ads,GNAT Threads g-thread ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-traceback-g-traceb-ads}@anchor{3d0}@anchor{gnat_rm/the_gnat_library id121}@anchor{3d1}
+@anchor{gnat_rm/the_gnat_library gnat-traceback-g-traceb-ads}@anchor{3d3}@anchor{gnat_rm/the_gnat_library id121}@anchor{3d4}
@section @code{GNAT.Traceback} (@code{g-traceb.ads})
in various debugging situations.
@node GNAT Traceback Symbolic g-trasym ads,GNAT UTF_32 g-utf_32 ads,GNAT Traceback g-traceb ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-traceback-symbolic-g-trasym-ads}@anchor{3d2}@anchor{gnat_rm/the_gnat_library id122}@anchor{3d3}
+@anchor{gnat_rm/the_gnat_library gnat-traceback-symbolic-g-trasym-ads}@anchor{3d5}@anchor{gnat_rm/the_gnat_library id122}@anchor{3d6}
@section @code{GNAT.Traceback.Symbolic} (@code{g-trasym.ads})
@geindex Trace back facilities
@node GNAT UTF_32 g-utf_32 ads,GNAT UTF_32_Spelling_Checker g-u3spch ads,GNAT Traceback Symbolic g-trasym ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-utf-32-g-utf-32-ads}@anchor{3d4}@anchor{gnat_rm/the_gnat_library id123}@anchor{3d5}
+@anchor{gnat_rm/the_gnat_library gnat-utf-32-g-utf-32-ads}@anchor{3d7}@anchor{gnat_rm/the_gnat_library id123}@anchor{3d8}
@section @code{GNAT.UTF_32} (@code{g-utf_32.ads})
the Ada 2005 rules for identifier equivalence.
@node GNAT UTF_32_Spelling_Checker g-u3spch ads,GNAT Wide_Spelling_Checker g-wispch ads,GNAT UTF_32 g-utf_32 ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-utf-32-spelling-checker-g-u3spch-ads}@anchor{3d6}@anchor{gnat_rm/the_gnat_library id124}@anchor{3d7}
+@anchor{gnat_rm/the_gnat_library gnat-utf-32-spelling-checker-g-u3spch-ads}@anchor{3d9}@anchor{gnat_rm/the_gnat_library id124}@anchor{3da}
@section @code{GNAT.UTF_32_Spelling_Checker} (@code{g-u3spch.ads})
using the UTF_32_String type defined in System.Wch_Cnv.
@node GNAT Wide_Spelling_Checker g-wispch ads,GNAT Wide_String_Split g-wistsp ads,GNAT UTF_32_Spelling_Checker g-u3spch ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-wide-spelling-checker-g-wispch-ads}@anchor{3d8}@anchor{gnat_rm/the_gnat_library id125}@anchor{3d9}
+@anchor{gnat_rm/the_gnat_library gnat-wide-spelling-checker-g-wispch-ads}@anchor{3db}@anchor{gnat_rm/the_gnat_library id125}@anchor{3dc}
@section @code{GNAT.Wide_Spelling_Checker} (@code{g-wispch.ads})
near misspelling of another wide string.
@node GNAT Wide_String_Split g-wistsp ads,GNAT Wide_Wide_Spelling_Checker g-zspche ads,GNAT Wide_Spelling_Checker g-wispch ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-wide-string-split-g-wistsp-ads}@anchor{3da}@anchor{gnat_rm/the_gnat_library id126}@anchor{3db}
+@anchor{gnat_rm/the_gnat_library gnat-wide-string-split-g-wistsp-ads}@anchor{3dd}@anchor{gnat_rm/the_gnat_library id126}@anchor{3de}
@section @code{GNAT.Wide_String_Split} (@code{g-wistsp.ads})
@code{GNAT.Array_Split}.
@node GNAT Wide_Wide_Spelling_Checker g-zspche ads,GNAT Wide_Wide_String_Split g-zistsp ads,GNAT Wide_String_Split g-wistsp ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-wide-wide-spelling-checker-g-zspche-ads}@anchor{3dc}@anchor{gnat_rm/the_gnat_library id127}@anchor{3dd}
+@anchor{gnat_rm/the_gnat_library gnat-wide-wide-spelling-checker-g-zspche-ads}@anchor{3df}@anchor{gnat_rm/the_gnat_library id127}@anchor{3e0}
@section @code{GNAT.Wide_Wide_Spelling_Checker} (@code{g-zspche.ads})
near misspelling of another wide wide string.
@node GNAT Wide_Wide_String_Split g-zistsp ads,Interfaces C Extensions i-cexten ads,GNAT Wide_Wide_Spelling_Checker g-zspche ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-wide-wide-string-split-g-zistsp-ads}@anchor{3de}@anchor{gnat_rm/the_gnat_library id128}@anchor{3df}
+@anchor{gnat_rm/the_gnat_library gnat-wide-wide-string-split-g-zistsp-ads}@anchor{3e1}@anchor{gnat_rm/the_gnat_library id128}@anchor{3e2}
@section @code{GNAT.Wide_Wide_String_Split} (@code{g-zistsp.ads})
@code{GNAT.Array_Split}.
@node Interfaces C Extensions i-cexten ads,Interfaces C Streams i-cstrea ads,GNAT Wide_Wide_String_Split g-zistsp ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id129}@anchor{3e0}@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3e1}
+@anchor{gnat_rm/the_gnat_library id129}@anchor{3e3}@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3e4}
@section @code{Interfaces.C.Extensions} (@code{i-cexten.ads})
to C libraries.
@node Interfaces C Streams i-cstrea ads,Interfaces Packed_Decimal i-pacdec ads,Interfaces C Extensions i-cexten ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id130}@anchor{3e2}@anchor{gnat_rm/the_gnat_library interfaces-c-streams-i-cstrea-ads}@anchor{3e3}
+@anchor{gnat_rm/the_gnat_library id130}@anchor{3e5}@anchor{gnat_rm/the_gnat_library interfaces-c-streams-i-cstrea-ads}@anchor{3e6}
@section @code{Interfaces.C.Streams} (@code{i-cstrea.ads})
on C streams.
@node Interfaces Packed_Decimal i-pacdec ads,Interfaces VxWorks i-vxwork ads,Interfaces C Streams i-cstrea ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id131}@anchor{3e4}@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3e5}
+@anchor{gnat_rm/the_gnat_library id131}@anchor{3e7}@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3e8}
@section @code{Interfaces.Packed_Decimal} (@code{i-pacdec.ads})
mainframes.
@node Interfaces VxWorks i-vxwork ads,Interfaces VxWorks Int_Connection i-vxinco ads,Interfaces Packed_Decimal i-pacdec ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id132}@anchor{3e6}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3e7}
+@anchor{gnat_rm/the_gnat_library id132}@anchor{3e9}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3ea}
@section @code{Interfaces.VxWorks} (@code{i-vxwork.ads})
VxWorks hardware interrupt facilities.
@node Interfaces VxWorks Int_Connection i-vxinco ads,Interfaces VxWorks IO i-vxwoio ads,Interfaces VxWorks i-vxwork ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id133}@anchor{3e8}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-int-connection-i-vxinco-ads}@anchor{3e9}
+@anchor{gnat_rm/the_gnat_library id133}@anchor{3eb}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-int-connection-i-vxinco-ads}@anchor{3ec}
@section @code{Interfaces.VxWorks.Int_Connection} (@code{i-vxinco.ads})
handlers.
@node Interfaces VxWorks IO i-vxwoio ads,System Address_Image s-addima ads,Interfaces VxWorks Int_Connection i-vxinco ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id134}@anchor{3ea}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3eb}
+@anchor{gnat_rm/the_gnat_library id134}@anchor{3ed}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3ee}
@section @code{Interfaces.VxWorks.IO} (@code{i-vxwoio.ads})
to enable the use of Get_Immediate under VxWorks.
@node System Address_Image s-addima ads,System Assertions s-assert ads,Interfaces VxWorks IO i-vxwoio ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id135}@anchor{3ec}@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3ed}
+@anchor{gnat_rm/the_gnat_library id135}@anchor{3ef}@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3f0}
@section @code{System.Address_Image} (@code{s-addima.ads})
string which identifies an address.
@node System Assertions s-assert ads,System Atomic_Counters s-atocou ads,System Address_Image s-addima ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id136}@anchor{3ee}@anchor{gnat_rm/the_gnat_library system-assertions-s-assert-ads}@anchor{3ef}
+@anchor{gnat_rm/the_gnat_library id136}@anchor{3f1}@anchor{gnat_rm/the_gnat_library system-assertions-s-assert-ads}@anchor{3f2}
@section @code{System.Assertions} (@code{s-assert.ads})
is used internally to raise this assertion.
@node System Atomic_Counters s-atocou ads,System Memory s-memory ads,System Assertions s-assert ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id137}@anchor{3f0}@anchor{gnat_rm/the_gnat_library system-atomic-counters-s-atocou-ads}@anchor{3f1}
+@anchor{gnat_rm/the_gnat_library id137}@anchor{3f3}@anchor{gnat_rm/the_gnat_library system-atomic-counters-s-atocou-ads}@anchor{3f4}
@section @code{System.Atomic_Counters} (@code{s-atocou.ads})
x86, and x86_64 platforms.
@node System Memory s-memory ads,System Multiprocessors s-multip ads,System Atomic_Counters s-atocou ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id138}@anchor{3f2}@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{3f3}
+@anchor{gnat_rm/the_gnat_library id138}@anchor{3f5}@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{3f6}
@section @code{System.Memory} (@code{s-memory.ads})
example see the body of @code{GNAT.Tables}).
@node System Multiprocessors s-multip ads,System Multiprocessors Dispatching_Domains s-mudido ads,System Memory s-memory ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id139}@anchor{3f4}@anchor{gnat_rm/the_gnat_library system-multiprocessors-s-multip-ads}@anchor{3f5}
+@anchor{gnat_rm/the_gnat_library id139}@anchor{3f7}@anchor{gnat_rm/the_gnat_library system-multiprocessors-s-multip-ads}@anchor{3f8}
@section @code{System.Multiprocessors} (@code{s-multip.ads})
technically an implementation-defined addition).
@node System Multiprocessors Dispatching_Domains s-mudido ads,System Partition_Interface s-parint ads,System Multiprocessors s-multip ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id140}@anchor{3f6}@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{3f7}
+@anchor{gnat_rm/the_gnat_library id140}@anchor{3f9}@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{3fa}
@section @code{System.Multiprocessors.Dispatching_Domains} (@code{s-mudido.ads})
technically an implementation-defined addition).
@node System Partition_Interface s-parint ads,System Pool_Global s-pooglo ads,System Multiprocessors Dispatching_Domains s-mudido ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id141}@anchor{3f8}@anchor{gnat_rm/the_gnat_library system-partition-interface-s-parint-ads}@anchor{3f9}
+@anchor{gnat_rm/the_gnat_library id141}@anchor{3fb}@anchor{gnat_rm/the_gnat_library system-partition-interface-s-parint-ads}@anchor{3fc}
@section @code{System.Partition_Interface} (@code{s-parint.ads})
with @code{GLADE}.
@node System Pool_Global s-pooglo ads,System Pool_Local s-pooloc ads,System Partition_Interface s-parint ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id142}@anchor{3fa}@anchor{gnat_rm/the_gnat_library system-pool-global-s-pooglo-ads}@anchor{3fb}
+@anchor{gnat_rm/the_gnat_library id142}@anchor{3fd}@anchor{gnat_rm/the_gnat_library system-pool-global-s-pooglo-ads}@anchor{3fe}
@section @code{System.Pool_Global} (@code{s-pooglo.ads})
do any automatic reclamation.
@node System Pool_Local s-pooloc ads,System Restrictions s-restri ads,System Pool_Global s-pooglo ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id143}@anchor{3fc}@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{3fd}
+@anchor{gnat_rm/the_gnat_library id143}@anchor{3ff}@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{400}
@section @code{System.Pool_Local} (@code{s-pooloc.ads})
be freed automatically when the pool is finalized.
@node System Restrictions s-restri ads,System Rident s-rident ads,System Pool_Local s-pooloc ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id144}@anchor{3fe}@anchor{gnat_rm/the_gnat_library system-restrictions-s-restri-ads}@anchor{3ff}
+@anchor{gnat_rm/the_gnat_library id144}@anchor{401}@anchor{gnat_rm/the_gnat_library system-restrictions-s-restri-ads}@anchor{402}
@section @code{System.Restrictions} (@code{s-restri.ads})
are violated by one or more packages in the partition.
@node System Rident s-rident ads,System Strings Stream_Ops s-ststop ads,System Restrictions s-restri ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id145}@anchor{400}@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{401}
+@anchor{gnat_rm/the_gnat_library id145}@anchor{403}@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{404}
@section @code{System.Rident} (@code{s-rident.ads})
package System.Restrictions.
@node System Strings Stream_Ops s-ststop ads,System Unsigned_Types s-unstyp ads,System Rident s-rident ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id146}@anchor{402}@anchor{gnat_rm/the_gnat_library system-strings-stream-ops-s-ststop-ads}@anchor{403}
+@anchor{gnat_rm/the_gnat_library id146}@anchor{405}@anchor{gnat_rm/the_gnat_library system-strings-stream-ops-s-ststop-ads}@anchor{406}
@section @code{System.Strings.Stream_Ops} (@code{s-ststop.ads})
package can be used directly by application programs.
@node System Unsigned_Types s-unstyp ads,System Wch_Cnv s-wchcnv ads,System Strings Stream_Ops s-ststop ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id147}@anchor{404}@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{405}
+@anchor{gnat_rm/the_gnat_library id147}@anchor{407}@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{408}
@section @code{System.Unsigned_Types} (@code{s-unstyp.ads})
used by the compiler in connection with packed array types.
@node System Wch_Cnv s-wchcnv ads,System Wch_Con s-wchcon ads,System Unsigned_Types s-unstyp ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id148}@anchor{406}@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{407}
+@anchor{gnat_rm/the_gnat_library id148}@anchor{409}@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{40a}
@section @code{System.Wch_Cnv} (@code{s-wchcnv.ads})
package @code{System.Wch_Con}.
@node System Wch_Con s-wchcon ads,,System Wch_Cnv s-wchcnv ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id149}@anchor{408}@anchor{gnat_rm/the_gnat_library system-wch-con-s-wchcon-ads}@anchor{409}
+@anchor{gnat_rm/the_gnat_library id149}@anchor{40b}@anchor{gnat_rm/the_gnat_library system-wch-con-s-wchcon-ads}@anchor{40c}
@section @code{System.Wch_Con} (@code{s-wchcon.ads})
the package @code{System.Wch_Cnv}.
@node Interfacing to Other Languages,Specialized Needs Annexes,The GNAT Library,Top
-@anchor{gnat_rm/interfacing_to_other_languages doc}@anchor{40a}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{40b}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-other-languages}@anchor{11}
+@anchor{gnat_rm/interfacing_to_other_languages doc}@anchor{40d}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{40e}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-other-languages}@anchor{11}
@chapter Interfacing to Other Languages
@end menu
@node Interfacing to C,Interfacing to C++,,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id2}@anchor{40c}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{40d}
+@anchor{gnat_rm/interfacing_to_other_languages id2}@anchor{40f}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{410}
@section Interfacing to C
@end itemize
@node Interfacing to C++,Interfacing to COBOL,Interfacing to C,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id3}@anchor{47}@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{40e}
+@anchor{gnat_rm/interfacing_to_other_languages id3}@anchor{49}@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{411}
@section Interfacing to C++
@table @asis
-@item @code{pragma CPP_Class ([Entity =>] @emph{LOCAL_NAME})}
+@item @code{pragma CPP_Class ([Entity =>] @var{LOCAL_NAME})}
The argument denotes an entity in the current declarative region that is
declared as a tagged or untagged record type. It indicates that the type
for backward compatibility but its functionality is available
using pragma @code{Import} with @code{Convention} = @code{CPP}.
-@item @code{pragma CPP_Constructor ([Entity =>] @emph{LOCAL_NAME})}
+@item @code{pragma CPP_Constructor ([Entity =>] @var{LOCAL_NAME})}
This pragma identifies an imported function (imported in the usual way
with pragma @code{Import}) as corresponding to a C++ constructor.
cover a specific C++ exception in an exception handler.
@node Interfacing to COBOL,Interfacing to Fortran,Interfacing to C++,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id5}@anchor{40f}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-cobol}@anchor{410}
+@anchor{gnat_rm/interfacing_to_other_languages id5}@anchor{412}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-cobol}@anchor{413}
@section Interfacing to COBOL
the Ada Reference Manual.
@node Interfacing to Fortran,Interfacing to non-GNAT Ada code,Interfacing to COBOL,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id6}@anchor{411}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-fortran}@anchor{412}
+@anchor{gnat_rm/interfacing_to_other_languages id6}@anchor{414}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-fortran}@anchor{415}
@section Interfacing to Fortran
order as required for convenient interface to Fortran.
@node Interfacing to non-GNAT Ada code,,Interfacing to Fortran,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id7}@anchor{413}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{414}
+@anchor{gnat_rm/interfacing_to_other_languages id7}@anchor{416}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{417}
@section Interfacing to non-GNAT Ada code
types with fixed bounds.
@node Specialized Needs Annexes,Implementation of Specific Ada Features,Interfacing to Other Languages,Top
-@anchor{gnat_rm/specialized_needs_annexes doc}@anchor{415}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{416}@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}
+@anchor{gnat_rm/specialized_needs_annexes doc}@anchor{418}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{419}@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}
@chapter Specialized Needs Annexes
@table @asis
-@item @emph{Systems Programming (Annex C)}
+@item `Systems Programming (Annex C)'
The Systems Programming Annex is fully implemented.
-@item @emph{Real-Time Systems (Annex D)}
+@item `Real-Time Systems (Annex D)'
The Real-Time Systems Annex is fully implemented.
-@item @emph{Distributed Systems (Annex E)}
+@item `Distributed Systems (Annex E)'
Stub generation is fully implemented in the GNAT compiler. In addition,
a complete compatible PCS is available as part of the GLADE system,
a separate product. When the two
products are used in conjunction, this annex is fully implemented.
-@item @emph{Information Systems (Annex F)}
+@item `Information Systems (Annex F)'
The Information Systems annex is fully implemented.
-@item @emph{Numerics (Annex G)}
+@item `Numerics (Annex G)'
The Numerics Annex is fully implemented.
-@item @emph{Safety and Security / High-Integrity Systems (Annex H)}
+@item `Safety and Security / High-Integrity Systems (Annex H)'
The Safety and Security Annex (termed the High-Integrity Systems Annex
in Ada 2005) is fully implemented.
@end table
@node Implementation of Specific Ada Features,Implementation of Ada 2012 Features,Specialized Needs Annexes,Top
-@anchor{gnat_rm/implementation_of_specific_ada_features doc}@anchor{417}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{418}@anchor{gnat_rm/implementation_of_specific_ada_features implementation-of-specific-ada-features}@anchor{13}
+@anchor{gnat_rm/implementation_of_specific_ada_features doc}@anchor{41a}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{41b}@anchor{gnat_rm/implementation_of_specific_ada_features implementation-of-specific-ada-features}@anchor{13}
@chapter Implementation of Specific Ada Features
@end menu
@node Machine Code Insertions,GNAT Implementation of Tasking,,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features id2}@anchor{419}@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{170}
+@anchor{gnat_rm/implementation_of_specific_ada_features id2}@anchor{41c}@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{173}
@section Machine Code Insertions
If there are no input operands, this argument may either be omitted, or
explicitly given as @code{No_Input_Operands}. The fourth argument, not
present in the above example, is a list of register names, called the
-@emph{clobber} argument. This argument, if given, must be a static string
+`clobber' argument. This argument, if given, must be a static string
expression, and is a space or comma separated list of names of registers
that must be considered destroyed as a result of the @code{Asm} call. If
this argument is the null string (the default value), then the code
@code{cc} as described in the GNU C docs are both supported.
The fifth argument, not present in the above example, called the
-@emph{volatile} argument, is by default @code{False}. It can be set to
+`volatile' argument, is by default @code{False}. It can be set to
the literal value @code{True} to indicate to the code generator that all
optimizations with respect to the instruction specified should be
suppressed, and in particular an instruction that has outputs
qualification is required.
@node GNAT Implementation of Tasking,GNAT Implementation of Shared Passive Packages,Machine Code Insertions,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-tasking}@anchor{41a}@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{41b}
+@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-tasking}@anchor{41d}@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{41e}
@section GNAT Implementation of Tasking
@end menu
@node Mapping Ada Tasks onto the Underlying Kernel Threads,Ensuring Compliance with the Real-Time Annex,,GNAT Implementation of Tasking
-@anchor{gnat_rm/implementation_of_specific_ada_features id4}@anchor{41c}@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{41d}
+@anchor{gnat_rm/implementation_of_specific_ada_features id4}@anchor{41f}@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{420}
@subsection Mapping Ada Tasks onto the Underlying Kernel Threads
@geindex Forking a new process
@node Ensuring Compliance with the Real-Time Annex,Support for Locking Policies,Mapping Ada Tasks onto the Underlying Kernel Threads,GNAT Implementation of Tasking
-@anchor{gnat_rm/implementation_of_specific_ada_features ensuring-compliance-with-the-real-time-annex}@anchor{41e}@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{41f}
+@anchor{gnat_rm/implementation_of_specific_ada_features ensuring-compliance-with-the-real-time-annex}@anchor{421}@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{422}
@subsection Ensuring Compliance with the Real-Time Annex
@quotation
-@emph{When the active priority of a ready task that is not running
+`When the active priority of a ready task that is not running
changes, or the setting of its base priority takes effect, the
task is removed from the ready queue for its old active priority
and is added at the tail of the ready queue for its new active
priority, except in the case where the active priority is lowered
due to the loss of inherited priority, in which case the task is
-added at the head of the ready queue for its new active priority.}
+added at the head of the ready queue for its new active priority.'
@end quotation
While most kernels do put tasks at the end of the priority queue when
@c Support_for_Locking_Policies
@node Support for Locking Policies,,Ensuring Compliance with the Real-Time Annex,GNAT Implementation of Tasking
-@anchor{gnat_rm/implementation_of_specific_ada_features support-for-locking-policies}@anchor{420}
+@anchor{gnat_rm/implementation_of_specific_ada_features support-for-locking-policies}@anchor{423}
@subsection Support for Locking Policies
Otherwise, the @code{Ceiling_Locking} policy is ignored.
@node GNAT Implementation of Shared Passive Packages,Code Generation for Array Aggregates,GNAT Implementation of Tasking,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-shared-passive-packages}@anchor{421}@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{422}
+@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-shared-passive-packages}@anchor{424}@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{425}
@section GNAT Implementation of Shared Passive Packages
@table @asis
-@item @emph{Communication between separate programs}
+@item `Communication between separate programs'
This allows separate programs to access the data in passive
partitions, using protected objects for synchronization where
(e.g., different endianness) to communicate via the data in
a passive partition.
-@item @emph{Persistence between program runs}
+@item `Persistence between program runs'
The data in a passive package can persist from one run of a
program to another, so that a later program sees the final
semantics for proper protected object synchronization.
@node Code Generation for Array Aggregates,The Size of Discriminated Records with Default Discriminants,GNAT Implementation of Shared Passive Packages,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features code-generation-for-array-aggregates}@anchor{423}@anchor{gnat_rm/implementation_of_specific_ada_features id7}@anchor{424}
+@anchor{gnat_rm/implementation_of_specific_ada_features code-generation-for-array-aggregates}@anchor{426}@anchor{gnat_rm/implementation_of_specific_ada_features id7}@anchor{427}
@section Code Generation for Array Aggregates
@end menu
@node Static constant aggregates with static bounds,Constant aggregates with unconstrained nominal types,,Code Generation for Array Aggregates
-@anchor{gnat_rm/implementation_of_specific_ada_features id8}@anchor{425}@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{426}
+@anchor{gnat_rm/implementation_of_specific_ada_features id8}@anchor{428}@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{429}
@subsection Static constant aggregates with static bounds
@end example
@node Constant aggregates with unconstrained nominal types,Aggregates with static bounds,Static constant aggregates with static bounds,Code Generation for Array Aggregates
-@anchor{gnat_rm/implementation_of_specific_ada_features constant-aggregates-with-unconstrained-nominal-types}@anchor{427}@anchor{gnat_rm/implementation_of_specific_ada_features id9}@anchor{428}
+@anchor{gnat_rm/implementation_of_specific_ada_features constant-aggregates-with-unconstrained-nominal-types}@anchor{42a}@anchor{gnat_rm/implementation_of_specific_ada_features id9}@anchor{42b}
@subsection Constant aggregates with unconstrained nominal types
@end example
@node Aggregates with static bounds,Aggregates with nonstatic bounds,Constant aggregates with unconstrained nominal types,Code Generation for Array Aggregates
-@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-static-bounds}@anchor{429}@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{42a}
+@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-static-bounds}@anchor{42c}@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{42d}
@subsection Aggregates with static bounds
@end example
@node Aggregates with nonstatic bounds,Aggregates in assignment statements,Aggregates with static bounds,Code Generation for Array Aggregates
-@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-nonstatic-bounds}@anchor{42b}@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{42c}
+@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-nonstatic-bounds}@anchor{42e}@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{42f}
@subsection Aggregates with nonstatic bounds
compatible subtypes.
@node Aggregates in assignment statements,,Aggregates with nonstatic bounds,Code Generation for Array Aggregates
-@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-in-assignment-statements}@anchor{42d}@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{42e}
+@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-in-assignment-statements}@anchor{430}@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{431}
@subsection Aggregates in assignment statements
that temporary will be copied onto the target.
@node The Size of Discriminated Records with Default Discriminants,Image Values For Nonscalar Types,Code Generation for Array Aggregates,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features id13}@anchor{42f}@anchor{gnat_rm/implementation_of_specific_ada_features the-size-of-discriminated-records-with-default-discriminants}@anchor{430}
+@anchor{gnat_rm/implementation_of_specific_ada_features id13}@anchor{432}@anchor{gnat_rm/implementation_of_specific_ada_features the-size-of-discriminated-records-with-default-discriminants}@anchor{433}
@section The Size of Discriminated Records with Default Discriminants
Word : Rec;
@end example
-Such an object is said to be @emph{unconstrained}.
+Such an object is said to be `unconstrained'.
The discriminant of the object
can be modified by a full assignment to the object, as long as it preserves the
relation between the value of the discriminant, and the value of the components
large.
One final wrinkle: if the object is declared to be @code{aliased}, or if it is
-created in the heap by means of an allocator, then it is @emph{not}
+created in the heap by means of an allocator, then it is `not'
unconstrained:
it is constrained by the default values of the discriminants, and those values
cannot be modified by full assignment. This is because in the presence of
remain invariant.
@node Image Values For Nonscalar Types,Strict Conformance to the Ada Reference Manual,The Size of Discriminated Records with Default Discriminants,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features id14}@anchor{431}@anchor{gnat_rm/implementation_of_specific_ada_features image-values-for-nonscalar-types}@anchor{432}
+@anchor{gnat_rm/implementation_of_specific_ada_features id14}@anchor{434}@anchor{gnat_rm/implementation_of_specific_ada_features image-values-for-nonscalar-types}@anchor{435}
@section Image Values For Nonscalar Types
explicitly specified.
@node Strict Conformance to the Ada Reference Manual,,Image Values For Nonscalar Types,Implementation of Specific Ada Features
-@anchor{gnat_rm/implementation_of_specific_ada_features id15}@anchor{433}@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{434}
+@anchor{gnat_rm/implementation_of_specific_ada_features id15}@anchor{436}@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{437}
@section Strict Conformance to the Ada Reference Manual
Strict conformance to the Ada Reference Manual can be achieved by adding two
compiler options for dynamic checks for access-before-elaboration on subprogram
-calls and generic instantiations (@emph{-gnatE}), and stack overflow checking
-(@emph{-fstack-check}).
+calls and generic instantiations (`-gnatE'), and stack overflow checking
+(`-fstack-check').
Note that the result of a floating point arithmetic operation in overflow and
invalid situations, when the @code{Machine_Overflows} attribute of the result
type is @code{False}, is to generate IEEE NaN and infinite values. This is the
case for machines compliant with the IEEE floating-point standard, but on
machines that are not fully compliant with this standard, such as Alpha, the
-@emph{-mieee} compiler flag must be used for achieving IEEE confirming
+`-mieee' compiler flag must be used for achieving IEEE confirming
behavior (although at the cost of a significant performance penalty), so
infinite and NaN values are properly generated.
@node Implementation of Ada 2012 Features,GNAT language extensions,Implementation of Specific Ada Features,Top
-@anchor{gnat_rm/implementation_of_ada_2012_features doc}@anchor{435}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{436}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}
+@anchor{gnat_rm/implementation_of_ada_2012_features doc}@anchor{438}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{439}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}
@chapter Implementation of Ada 2012 Features
This chapter contains a complete list of Ada 2012 features that have been
implemented.
Generally, these features are only
-available if the @emph{-gnat12} (Ada 2012 features enabled) option is set,
+available if the `-gnat12' (Ada 2012 features enabled) option is set,
which is the default behavior,
or if the configuration pragma @code{Ada_2012} is used.
@itemize *
@item
-@emph{AI-0176 Quantified expressions (2010-09-29)}
+`AI-0176 Quantified expressions (2010-09-29)'
Both universally and existentially quantified expressions are implemented.
They use the new syntax for iterators proposed in AI05-139-2, as well as
@itemize *
@item
-@emph{AI-0079 Allow other_format characters in source (2010-07-10)}
+`AI-0079 Allow other_format characters in source (2010-07-10)'
-Wide characters in the unicode category @emph{other_format} are now allowed in
+Wide characters in the unicode category `other_format' are now allowed in
source programs between tokens, but not within a token such as an identifier.
RM References: 2.01 (4/2) 2.02 (7)
@itemize *
@item
-@emph{AI-0091 Do not allow other_format in identifiers (0000-00-00)}
+`AI-0091 Do not allow other_format in identifiers (0000-00-00)'
-Wide characters in the unicode category @emph{other_format} are not permitted
+Wide characters in the unicode category `other_format' are not permitted
within an identifier, since this can be a security problem. The error
message for this case has been improved to be more specific, but GNAT has
never allowed such characters to appear in identifiers.
@itemize *
@item
-@emph{AI-0100 Placement of pragmas (2010-07-01)}
+`AI-0100 Placement of pragmas (2010-07-01)'
This AI is an earlier version of AI-163. It simplifies the rules
for legal placement of pragmas. In the case of lists that allow pragmas, if
@itemize *
@item
-@emph{AI-0163 Pragmas in place of null (2010-07-01)}
+`AI-0163 Pragmas in place of null (2010-07-01)'
A statement sequence may be composed entirely of pragmas. It is no longer
necessary to add a dummy @code{null} statement to make the sequence legal.
@itemize *
@item
-@emph{AI-0080 ‘View of’ not needed if clear from context (0000-00-00)}
+`AI-0080 ‘View of’ not needed if clear from context (0000-00-00)'
This is an editorial change only, described as non-testable in the AI.
@itemize *
@item
-@emph{AI-0183 Aspect specifications (2010-08-16)}
+`AI-0183 Aspect specifications (2010-08-16)'
Aspect specifications have been fully implemented except for pre and post-
conditions, and type invariants, which have their own separate AI’s. All
@itemize *
@item
-@emph{AI-0128 Inequality is a primitive operation (0000-00-00)}
+`AI-0128 Inequality is a primitive operation (0000-00-00)'
If an equality operator (“=”) is declared for a type, then the implicitly
declared inequality operator (“/=”) is a primitive operation of the type.
@itemize *
@item
-@emph{AI-0003 Qualified expressions as names (2010-07-11)}
+`AI-0003 Qualified expressions as names (2010-07-11)'
In Ada 2012, a qualified expression is considered to be syntactically a name,
meaning that constructs such as @code{A'(F(X)).B} are now legal. This is
@itemize *
@item
-@emph{AI-0120 Constant instance of protected object (0000-00-00)}
+`AI-0120 Constant instance of protected object (0000-00-00)'
This is an RM editorial change only. The section that lists objects that are
constant failed to include the current instance of a protected object
@itemize *
@item
-@emph{AI-0008 General access to constrained objects (0000-00-00)}
+`AI-0008 General access to constrained objects (0000-00-00)'
The wording in the RM implied that if you have a general access to a
constrained object, it could be used to modify the discriminants. This was
@itemize *
@item
-@emph{AI-0093 Additional rules use immutably limited (0000-00-00)}
+`AI-0093 Additional rules use immutably limited (0000-00-00)'
This is an editorial change only, to make more widespread use of the Ada 2012
‘immutably limited’.
@itemize *
@item
-@emph{AI-0096 Deriving from formal private types (2010-07-20)}
+`AI-0096 Deriving from formal private types (2010-07-20)'
In general it is illegal for a type derived from a formal limited type to be
nonlimited. This AI makes an exception to this rule: derivation is legal
@itemize *
@item
-@emph{AI-0181 Soft hyphen is a non-graphic character (2010-07-23)}
+`AI-0181 Soft hyphen is a non-graphic character (2010-07-23)'
From Ada 2005 on, soft hyphen is considered a non-graphic character, which
means that it has a special name (@code{SOFT_HYPHEN}) in conjunction with the
@itemize *
@item
-@emph{AI-0182 Additional forms for} @code{Character'Value} @emph{(0000-00-00)}
+`AI-0182 Additional forms for' @code{Character'Value} `(0000-00-00)'
This AI allows @code{Character'Value} to accept the string @code{'?'} where
@code{?} is any character including non-graphic control characters. GNAT has
@itemize *
@item
-@emph{AI-0214 Defaulted discriminants for limited tagged (2010-10-01)}
+`AI-0214 Defaulted discriminants for limited tagged (2010-10-01)'
Ada 2012 relaxes the restriction that forbids discriminants of tagged types
to have default expressions by allowing them when the type is limited. It
@itemize *
@item
-@emph{AI-0102 Some implicit conversions are illegal (0000-00-00)}
+`AI-0102 Some implicit conversions are illegal (0000-00-00)'
It is illegal to assign an anonymous access constant to an anonymous access
variable. The RM did not have a clear rule to prevent this, but GNAT has
@itemize *
@item
-@emph{AI-0158 Generalizing membership tests (2010-09-16)}
+`AI-0158 Generalizing membership tests (2010-09-16)'
This AI extends the syntax of membership tests to simplify complex conditions
that can be expressed as membership in a subset of values of any type. It
@itemize *
@item
-@emph{AI-0173 Testing if tags represent abstract types (2010-07-03)}
+`AI-0173 Testing if tags represent abstract types (2010-07-03)'
The function @code{Ada.Tags.Type_Is_Abstract} returns @code{True} if invoked
with the tag of an abstract type, and @code{False} otherwise.
@itemize *
@item
-@emph{AI-0076 function with controlling result (0000-00-00)}
+`AI-0076 function with controlling result (0000-00-00)'
This is an editorial change only. The RM defines calls with controlling
results, but uses the term ‘function with controlling result’ without an
@itemize *
@item
-@emph{AI-0126 Dispatching with no declared operation (0000-00-00)}
+`AI-0126 Dispatching with no declared operation (0000-00-00)'
This AI clarifies dispatching rules, and simply confirms that dispatching
executes the operation of the parent type when there is no explicitly or
@itemize *
@item
-@emph{AI-0097 Treatment of abstract null extension (2010-07-19)}
+`AI-0097 Treatment of abstract null extension (2010-07-19)'
The RM as written implied that in some cases it was possible to create an
object of an abstract type, by having an abstract extension inherit a non-
@itemize *
@item
-@emph{AI-0203 Extended return cannot be abstract (0000-00-00)}
+`AI-0203 Extended return cannot be abstract (0000-00-00)'
A return_subtype_indication cannot denote an abstract subtype. GNAT has never
permitted such usage.
@itemize *
@item
-@emph{AI-0198 Inheriting abstract operators (0000-00-00)}
+`AI-0198 Inheriting abstract operators (0000-00-00)'
This AI resolves a conflict between two rules involving inherited abstract
operations and predefined operators. If a derived numeric type inherits
@itemize *
@item
-@emph{AI-0073 Functions returning abstract types (2010-07-10)}
+`AI-0073 Functions returning abstract types (2010-07-10)'
This AI covers a number of issues regarding returning abstract types. In
particular generic functions cannot have abstract result types or access
@itemize *
@item
-@emph{AI-0070 Elaboration of interface types (0000-00-00)}
+`AI-0070 Elaboration of interface types (0000-00-00)'
This is an editorial change only, there are no testable consequences short of
checking for the absence of generated code for an interface declaration.
@itemize *
@item
-@emph{AI-0208 Characteristics of incomplete views (0000-00-00)}
+`AI-0208 Characteristics of incomplete views (0000-00-00)'
The wording in the Ada 2005 RM concerning characteristics of incomplete views
was incorrect and implied that some programs intended to be legal were now
@itemize *
@item
-@emph{AI-0162 Incomplete type completed by partial view (2010-09-15)}
+`AI-0162 Incomplete type completed by partial view (2010-09-15)'
Incomplete types are made more useful by allowing them to be completed by
private types and private extensions.
@itemize *
@item
-@emph{AI-0098 Anonymous subprogram access restrictions (0000-00-00)}
+`AI-0098 Anonymous subprogram access restrictions (0000-00-00)'
An unintentional omission in the RM implied some inconsistent restrictions on
the use of anonymous access to subprogram values. These restrictions were not
@itemize *
@item
-@emph{AI-0199 Aggregate with anonymous access components (2010-07-14)}
+`AI-0199 Aggregate with anonymous access components (2010-07-14)'
A choice list in a record aggregate can include several components of
(distinct) anonymous access types as long as they have matching designated
@itemize *
@item
-@emph{AI-0220 Needed components for aggregates (0000-00-00)}
+`AI-0220 Needed components for aggregates (0000-00-00)'
This AI addresses a wording problem in the RM that appears to permit some
complex cases of aggregates with nonstatic discriminants. GNAT has always
@itemize *
@item
-@emph{AI-0147 Conditional expressions (2009-03-29)}
+`AI-0147 Conditional expressions (2009-03-29)'
Conditional expressions are permitted. The form of such an expression is:
@end example
The parentheses can be omitted in contexts where parentheses are present
-anyway, such as subprogram arguments and pragma arguments. If the @strong{else}
-clause is omitted, @strong{else} @emph{True} is assumed;
+anyway, such as subprogram arguments and pragma arguments. If the `else'
+clause is omitted, `else' `True' is assumed;
thus @code{(if A then B)} is a way to conveniently represent
-@emph{(A implies B)} in standard logic.
+`(A implies B)' in standard logic.
RM References: 4.03.03 (15) 4.04 (1) 4.04 (7) 4.05.07 (0) 4.07 (2)
4.07 (3) 4.09 (12) 4.09 (33) 5.03 (3) 5.03 (4) 7.05 (2.1/2)
@itemize *
@item
-@emph{AI-0037 Out-of-range box associations in aggregate (0000-00-00)}
+`AI-0037 Out-of-range box associations in aggregate (0000-00-00)'
This AI confirms that an association of the form @code{Indx => <>} in an
array aggregate must raise @code{Constraint_Error} if @code{Indx}
@itemize *
@item
-@emph{AI-0123 Composability of equality (2010-04-13)}
+`AI-0123 Composability of equality (2010-04-13)'
Equality of untagged record composes, so that the predefined equality for a
composite type that includes a component of some untagged record type
@itemize *
@item
-@emph{AI-0088 The value of exponentiation (0000-00-00)}
+`AI-0088 The value of exponentiation (0000-00-00)'
This AI clarifies the equivalence rule given for the dynamic semantics of
exponentiation: the value of the operation can be obtained by repeated
@itemize *
@item
-@emph{AI-0188 Case expressions (2010-01-09)}
+`AI-0188 Case expressions (2010-01-09)'
Case expressions are permitted. This allows use of constructs such as:
@itemize *
@item
-@emph{AI-0104 Null exclusion and uninitialized allocator (2010-07-15)}
+`AI-0104 Null exclusion and uninitialized allocator (2010-07-15)'
The assignment @code{Ptr := new not null Some_Ptr;} will raise
@code{Constraint_Error} because the default value of the allocated object is
-@strong{null}. This useless construct is illegal in Ada 2012.
+`null'. This useless construct is illegal in Ada 2012.
RM References: 4.08 (2)
@end itemize
@itemize *
@item
-@emph{AI-0157 Allocation/Deallocation from empty pool (2010-07-11)}
+`AI-0157 Allocation/Deallocation from empty pool (2010-07-11)'
Allocation and Deallocation from an empty storage pool (i.e. allocation or
deallocation of a pointer for which a static storage size clause of zero
@itemize *
@item
-@emph{AI-0179 Statement not required after label (2010-04-10)}
+`AI-0179 Statement not required after label (2010-04-10)'
It is not necessary to have a statement following a label, so a label
can appear at the end of a statement sequence without the need for putting a
@itemize *
@item
-@emph{AI-0139-2 Syntactic sugar for iterators (2010-09-29)}
+`AI-0139-2 Syntactic sugar for iterators (2010-09-29)'
The new syntax for iterating over arrays and containers is now implemented.
Iteration over containers is for now limited to read-only iterators. Only
@itemize *
@item
-@emph{AI-0134 Profiles must match for full conformance (0000-00-00)}
+`AI-0134 Profiles must match for full conformance (0000-00-00)'
For full conformance, the profiles of anonymous-access-to-subprogram
parameters must match. GNAT has always enforced this rule.
@itemize *
@item
-@emph{AI-0207 Mode conformance and access constant (0000-00-00)}
+`AI-0207 Mode conformance and access constant (0000-00-00)'
This AI confirms that access_to_constant indication must match for mode
conformance. This was implemented in GNAT when the qualifier was originally
@itemize *
@item
-@emph{AI-0046 Null exclusion match for full conformance (2010-07-17)}
+`AI-0046 Null exclusion match for full conformance (2010-07-17)'
For full conformance, in the case of access parameters, the null exclusion
must match (either both or neither must have @code{not null}).
@itemize *
@item
-@emph{AI-0118 The association of parameter associations (0000-00-00)}
+`AI-0118 The association of parameter associations (0000-00-00)'
This AI clarifies the rules for named associations in subprogram calls and
generic instantiations. The rules have been in place since Ada 83.
@itemize *
@item
-@emph{AI-0196 Null exclusion tests for out parameters (0000-00-00)}
+`AI-0196 Null exclusion tests for out parameters (0000-00-00)'
Null exclusion checks are not made for @code{out} parameters when
evaluating the actual parameters. GNAT has never generated these checks.
@itemize *
@item
-@emph{AI-0015 Constant return objects (0000-00-00)}
+`AI-0015 Constant return objects (0000-00-00)'
-The return object declared in an @emph{extended_return_statement} may be
+The return object declared in an `extended_return_statement' may be
declared constant. This was always intended, and GNAT has always allowed it.
RM References: 6.05 (2.1/2) 3.03 (10/2) 3.03 (21) 6.05 (5/2)
@itemize *
@item
-@emph{AI-0032 Extended return for class-wide functions (0000-00-00)}
+`AI-0032 Extended return for class-wide functions (0000-00-00)'
If a function returns a class-wide type, the object of an extended return
statement can be declared with a specific type that is covered by the class-
@itemize *
@item
-@emph{AI-0103 Static matching for extended return (2010-07-23)}
+`AI-0103 Static matching for extended return (2010-07-23)'
If the return subtype of a function is an elementary type or a constrained
type, the subtype indication in an extended return statement must match
@itemize *
@item
-@emph{AI-0058 Abnormal completion of an extended return (0000-00-00)}
+`AI-0058 Abnormal completion of an extended return (0000-00-00)'
The RM had some incorrect wording implying wrong treatment of abnormal
completion in an extended return. GNAT has always implemented the intended
@itemize *
@item
-@emph{AI-0050 Raising Constraint_Error early for function call (0000-00-00)}
+`AI-0050 Raising Constraint_Error early for function call (0000-00-00)'
The implementation permissions for raising @code{Constraint_Error} early on a function call
when it was clear an exception would be raised were over-permissive and allowed
@itemize *
@item
-@emph{AI-0125 Nonoverridable operations of an ancestor (2010-09-28)}
+`AI-0125 Nonoverridable operations of an ancestor (2010-09-28)'
In Ada 2012, the declaration of a primitive operation of a type extension
or private extension can also override an inherited primitive that is not
@itemize *
@item
-@emph{AI-0062 Null exclusions and deferred constants (0000-00-00)}
+`AI-0062 Null exclusions and deferred constants (0000-00-00)'
A full constant may have a null exclusion even if its associated deferred
constant does not. GNAT has always allowed this.
@itemize *
@item
-@emph{AI-0178 Incomplete views are limited (0000-00-00)}
+`AI-0178 Incomplete views are limited (0000-00-00)'
This AI clarifies the role of incomplete views and plugs an omission in the
RM. GNAT always correctly restricted the use of incomplete views and types.
@itemize *
@item
-@emph{AI-0087 Actual for formal nonlimited derived type (2010-07-15)}
+`AI-0087 Actual for formal nonlimited derived type (2010-07-15)'
The actual for a formal nonlimited derived type cannot be limited. In
particular, a formal derived type that extends a limited interface but which
@itemize *
@item
-@emph{AI-0099 Tag determines whether finalization needed (0000-00-00)}
+`AI-0099 Tag determines whether finalization needed (0000-00-00)'
This AI clarifies that ‘needs finalization’ is part of dynamic semantics,
and therefore depends on the run-time characteristics of an object (i.e. its
@itemize *
@item
-@emph{AI-0064 Redundant finalization rule (0000-00-00)}
+`AI-0064 Redundant finalization rule (0000-00-00)'
This is an editorial change only. The intended behavior is already checked
by an existing ACATS test, which GNAT has always executed correctly.
@itemize *
@item
-@emph{AI-0026 Missing rules for Unchecked_Union (2010-07-07)}
+`AI-0026 Missing rules for Unchecked_Union (2010-07-07)'
Record representation clauses concerning Unchecked_Union types cannot mention
the discriminant of the type. The type of a component declared in the variant
@itemize *
@item
-@emph{AI-0205 Extended return declares visible name (0000-00-00)}
+`AI-0205 Extended return declares visible name (0000-00-00)'
This AI corrects a simple omission in the RM. Return objects have always
been visible within an extended return statement.
@itemize *
@item
-@emph{AI-0042 Overriding versus implemented-by (0000-00-00)}
+`AI-0042 Overriding versus implemented-by (0000-00-00)'
This AI fixes a wording gap in the RM. An operation of a synchronized
interface can be implemented by a protected or task entry, but the abstract
@itemize *
@item
-@emph{AI-0030 Requeue on synchronized interfaces (2010-07-19)}
+`AI-0030 Requeue on synchronized interfaces (2010-07-19)'
Requeue is permitted to a protected, synchronized or task interface primitive
providing it is known that the overriding operation is an entry. Otherwise
@itemize *
@item
-@emph{AI-0201 Independence of atomic object components (2010-07-22)}
+`AI-0201 Independence of atomic object components (2010-07-22)'
If an Atomic object has a pragma @code{Pack} or a @code{Component_Size}
attribute, then individual components may not be addressable by independent
@itemize *
@item
-@emph{AI-0009 Pragma Independent[_Components] (2010-07-23)}
+`AI-0009 Pragma Independent[_Components] (2010-07-23)'
This AI introduces the new pragmas @code{Independent} and
@code{Independent_Components},
@itemize *
@item
-@emph{AI-0072 Task signalling using ‘Terminated (0000-00-00)}
+`AI-0072 Task signalling using ‘Terminated (0000-00-00)'
This AI clarifies that task signalling for reading @code{'Terminated} only
occurs if the result is True. GNAT semantics has always been consistent with
@itemize *
@item
-@emph{AI-0108 Limited incomplete view and discriminants (0000-00-00)}
+`AI-0108 Limited incomplete view and discriminants (0000-00-00)'
This AI confirms that an incomplete type from a limited view does not have
discriminants. This has always been the case in GNAT.
@itemize *
@item
-@emph{AI-0129 Limited views and incomplete types (0000-00-00)}
+`AI-0129 Limited views and incomplete types (0000-00-00)'
This AI clarifies the description of limited views: a limited view of a
package includes only one view of a type that has an incomplete declaration
@itemize *
@item
-@emph{AI-0077 Limited withs and scope of declarations (0000-00-00)}
+`AI-0077 Limited withs and scope of declarations (0000-00-00)'
This AI clarifies that a declaration does not include a context clause,
and confirms that it is illegal to have a context in which both a limited
@itemize *
@item
-@emph{AI-0122 Private with and children of generics (0000-00-00)}
+`AI-0122 Private with and children of generics (0000-00-00)'
This AI clarifies the visibility of private children of generic units within
instantiations of a parent. GNAT has always handled this correctly.
@itemize *
@item
-@emph{AI-0040 Limited with clauses on descendant (0000-00-00)}
+`AI-0040 Limited with clauses on descendant (0000-00-00)'
This AI confirms that a limited with clause in a child unit cannot name
an ancestor of the unit. This has always been checked in GNAT.
@itemize *
@item
-@emph{AI-0132 Placement of library unit pragmas (0000-00-00)}
+`AI-0132 Placement of library unit pragmas (0000-00-00)'
This AI fills a gap in the description of library unit pragmas. The pragma
clearly must apply to a library unit, even if it does not carry the name
@itemize *
@item
-@emph{AI-0034 Categorization of limited views (0000-00-00)}
+`AI-0034 Categorization of limited views (0000-00-00)'
The RM makes certain limited with clauses illegal because of categorization
considerations, when the corresponding normal with would be legal. This is
@itemize *
@item
-@emph{AI-0035 Inconsistencies with Pure units (0000-00-00)}
+`AI-0035 Inconsistencies with Pure units (0000-00-00)'
This AI remedies some inconsistencies in the legality rules for Pure units.
Derived access types are legal in a pure unit (on the assumption that the
@itemize *
@item
-@emph{AI-0219 Pure permissions and limited parameters (2010-05-25)}
+`AI-0219 Pure permissions and limited parameters (2010-05-25)'
This AI refines the rules for the cases with limited parameters which do not
allow the implementations to omit ‘redundant’. GNAT now properly conforms
@itemize *
@item
-@emph{AI-0043 Rules about raising exceptions (0000-00-00)}
+`AI-0043 Rules about raising exceptions (0000-00-00)'
This AI covers various omissions in the RM regarding the raising of
exceptions. GNAT has always implemented the intended semantics.
@itemize *
@item
-@emph{AI-0200 Mismatches in formal package declarations (0000-00-00)}
+`AI-0200 Mismatches in formal package declarations (0000-00-00)'
This AI plugs a gap in the RM which appeared to allow some obviously intended
illegal instantiations. GNAT has never allowed these instantiations.
@itemize *
@item
-@emph{AI-0112 Detection of duplicate pragmas (2010-07-24)}
+`AI-0112 Detection of duplicate pragmas (2010-07-24)'
This AI concerns giving names to various representation aspects, but the
practical effect is simply to make the use of duplicate
@itemize *
@item
-@emph{AI-0106 No representation pragmas on generic formals (0000-00-00)}
+`AI-0106 No representation pragmas on generic formals (0000-00-00)'
The RM appeared to allow representation pragmas on generic formal parameters,
but this was not intended, and GNAT has never permitted this usage.
@itemize *
@item
-@emph{AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)}
+`AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)'
It is now illegal to give an inappropriate component size or a pragma
@code{Pack} that attempts to change the component size in the case of atomic
@itemize *
@item
-@emph{AI-0039 Stream attributes cannot be dynamic (0000-00-00)}
+`AI-0039 Stream attributes cannot be dynamic (0000-00-00)'
The RM permitted the use of dynamic expressions (such as @code{ptr.all})`
for stream attributes, but these were never useful and are now illegal. GNAT
@itemize *
@item
-@emph{AI-0095 Address of intrinsic subprograms (0000-00-00)}
+`AI-0095 Address of intrinsic subprograms (0000-00-00)'
The prefix of @code{'Address} cannot statically denote a subprogram with
convention @code{Intrinsic}. The use of the @code{Address} attribute raises
@itemize *
@item
-@emph{AI-0116 Alignment of class-wide objects (0000-00-00)}
+`AI-0116 Alignment of class-wide objects (0000-00-00)'
This AI requires that the alignment of a class-wide object be no greater
than the alignment of any type in the class. GNAT has always followed this
@itemize *
@item
-@emph{AI-0146 Type invariants (2009-09-21)}
+`AI-0146 Type invariants (2009-09-21)'
Type invariants may be specified for private types using the aspect notation.
Aspect @code{Type_Invariant} may be specified for any private type,
tagged types. The invariant is a boolean expression that is tested for being
true in the following situations: conversions to the private type, object
declarations for the private type that are default initialized, and
-[@strong{in}] @strong{out}
+[`in'] `out'
parameters and returned result on return from any primitive operation for
the type that is visible to a client.
GNAT defines the synonyms @code{Invariant} for @code{Type_Invariant} and
@itemize *
@item
-@emph{AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)}
+`AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)'
In Ada 2012, compilers are required to support unchecked conversion where the
target alignment is a multiple of the source alignment. GNAT always supported
@itemize *
@item
-@emph{AI-0195 Invalid value handling is implementation defined (2010-07-03)}
+`AI-0195 Invalid value handling is implementation defined (2010-07-03)'
The handling of invalid values is now designated to be implementation
defined. This is a documentation change only, requiring Annex M in the GNAT
@itemize *
@item
-@emph{AI-0193 Alignment of allocators (2010-09-16)}
+`AI-0193 Alignment of allocators (2010-09-16)'
This AI introduces a new attribute @code{Max_Alignment_For_Allocation},
analogous to @code{Max_Size_In_Storage_Elements}, but for alignment instead
@itemize *
@item
-@emph{AI-0177 Parameterized expressions (2010-07-10)}
+`AI-0177 Parameterized expressions (2010-07-10)'
The new Ada 2012 notion of parameterized expressions is implemented. The form
is:
@itemize *
@item
-@emph{AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)}
+`AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)'
Neither of these two pragmas may appear within a generic template, because
the generic might be instantiated at other than the library level.
@itemize *
@item
-@emph{AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)}
+`AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)'
A new restriction @code{No_Default_Stream_Attributes} prevents the use of any
of the default stream attributes for elementary types. If this restriction is
@itemize *
@item
-@emph{AI-0194 Value of Stream_Size attribute (0000-00-00)}
+`AI-0194 Value of Stream_Size attribute (0000-00-00)'
The @code{Stream_Size} attribute returns the default number of bits in the
stream representation of the given type.
@itemize *
@item
-@emph{AI-0109 Redundant check in S’Class’Input (0000-00-00)}
+`AI-0109 Redundant check in S’Class’Input (0000-00-00)'
This AI is an editorial change only. It removes the need for a tag check
that can never fail.
@itemize *
@item
-@emph{AI-0007 Stream read and private scalar types (0000-00-00)}
+`AI-0007 Stream read and private scalar types (0000-00-00)'
The RM as written appeared to limit the possibilities of declaring read
attribute procedures for private scalar types. This limitation was not
@itemize *
@item
-@emph{AI-0065 Remote access types and external streaming (0000-00-00)}
+`AI-0065 Remote access types and external streaming (0000-00-00)'
This AI clarifies the fact that all remote access types support external
streaming. This fixes an obvious oversight in the definition of the
@itemize *
@item
-@emph{AI-0019 Freezing of primitives for tagged types (0000-00-00)}
+`AI-0019 Freezing of primitives for tagged types (0000-00-00)'
The RM suggests that primitive subprograms of a specific tagged type are
frozen when the tagged type is frozen. This would be an incompatible change
@itemize *
@item
-@emph{AI-0017 Freezing and incomplete types (0000-00-00)}
+`AI-0017 Freezing and incomplete types (0000-00-00)'
So-called ‘Taft-amendment types’ (i.e., types that are completed in package
bodies) are not frozen by the occurrence of bodies in the
@itemize *
@item
-@emph{AI-0060 Extended definition of remote access types (0000-00-00)}
+`AI-0060 Extended definition of remote access types (0000-00-00)'
This AI extends the definition of remote access types to include access
to limited, synchronized, protected or task class-wide interface types.
@itemize *
@item
-@emph{AI-0114 Classification of letters (0000-00-00)}
+`AI-0114 Classification of letters (0000-00-00)'
The code points 170 (@code{FEMININE ORDINAL INDICATOR}),
181 (@code{MICRO SIGN}), and
@itemize *
@item
-@emph{AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)}
+`AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)'
Two new packages @code{Ada.Wide_[Wide_]Characters.Handling} provide
classification functions for @code{Wide_Character} and
@itemize *
@item
-@emph{AI-0031 Add From parameter to Find_Token (2010-07-25)}
+`AI-0031 Add From parameter to Find_Token (2010-07-25)'
A new version of @code{Find_Token} is added to all relevant string packages,
with an extra parameter @code{From}. Instead of starting at the first
@itemize *
@item
-@emph{AI-0056 Index on null string returns zero (0000-00-00)}
+`AI-0056 Index on null string returns zero (0000-00-00)'
The wording in the Ada 2005 RM implied an incompatible handling of the
@code{Index} functions, resulting in raising an exception instead of
@itemize *
@item
-@emph{AI-0137 String encoding package (2010-03-25)}
+`AI-0137 String encoding package (2010-03-25)'
The packages @code{Ada.Strings.UTF_Encoding}, together with its child
packages, @code{Conversions}, @code{Strings}, @code{Wide_Strings},
@itemize *
@item
-@emph{AI-0038 Minor errors in Text_IO (0000-00-00)}
+`AI-0038 Minor errors in Text_IO (0000-00-00)'
These are minor errors in the description on three points. The intent on
all these points has always been clear, and GNAT has always implemented the
@itemize *
@item
-@emph{AI-0044 Restrictions on container instantiations (0000-00-00)}
+`AI-0044 Restrictions on container instantiations (0000-00-00)'
This AI places restrictions on allowed instantiations of generic containers.
These restrictions are not checked by the compiler, so there is nothing to
@itemize *
@item
-@emph{AI-0127 Adding Locale Capabilities (2010-09-29)}
+`AI-0127 Adding Locale Capabilities (2010-09-29)'
This package provides an interface for identifying the current locale.
@itemize *
@item
-@emph{AI-0002 Export C with unconstrained arrays (0000-00-00)}
+`AI-0002 Export C with unconstrained arrays (0000-00-00)'
The compiler is not required to support exporting an Ada subprogram with
convention C if there are parameters or a return type of an unconstrained
@itemize *
@item
-@emph{AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)}
+`AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)'
It is clearly the intention that @code{No_Task_Hierarchy} is intended to
forbid tasks declared locally within subprograms, or functions returning task
@itemize *
@item
-@emph{AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)}
+`AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)'
The restriction @code{No_Relative_Delays} forbids any calls to the subprogram
@code{Ada.Real_Time.Timing_Events.Set_Handler}.
@itemize *
@item
-@emph{AI-0190 pragma Default_Storage_Pool (2010-09-15)}
+`AI-0190 pragma Default_Storage_Pool (2010-09-15)'
This AI introduces a new pragma @code{Default_Storage_Pool}, which can be
used to control storage pools globally.
In particular, you can force every access
-type that is used for allocation (@strong{new}) to have an explicit storage pool,
+type that is used for allocation (`new') to have an explicit storage pool,
or you can declare a pool globally to be used for all access types that lack
an explicit one.
@itemize *
@item
-@emph{AI-0189 No_Allocators_After_Elaboration (2010-01-23)}
+`AI-0189 No_Allocators_After_Elaboration (2010-01-23)'
This AI introduces a new restriction @code{No_Allocators_After_Elaboration},
which says that no dynamic allocation will occur once elaboration is
@itemize *
@item
-@emph{AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)}
+`AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)'
A new package @code{System.Multiprocessors} is added, together with the
definition of pragma @code{CPU} for controlling task affinity. A new no
@itemize *
@item
-@emph{AI-0210 Correct Timing_Events metric (0000-00-00)}
+`AI-0210 Correct Timing_Events metric (0000-00-00)'
This is a documentation only issue regarding wording of metric requirements,
that does not affect the implementation of the compiler.
@itemize *
@item
-@emph{AI-0206 Remote types packages and preelaborate (2010-07-24)}
+`AI-0206 Remote types packages and preelaborate (2010-07-24)'
Remote types packages are now allowed to depend on preelaborated packages.
This was formerly considered illegal.
@itemize *
@item
-@emph{AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)}
+`AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)'
Restriction @code{No_Anonymous_Allocators} prevents the use of allocators
where the type of the returned value is an anonymous access type.
@end itemize
@node GNAT language extensions,Security Hardening Features,Implementation of Ada 2012 Features,Top
-@anchor{gnat_rm/gnat_language_extensions doc}@anchor{437}@anchor{gnat_rm/gnat_language_extensions gnat-language-extensions}@anchor{438}@anchor{gnat_rm/gnat_language_extensions id1}@anchor{439}
+@anchor{gnat_rm/gnat_language_extensions doc}@anchor{43a}@anchor{gnat_rm/gnat_language_extensions gnat-language-extensions}@anchor{43b}@anchor{gnat_rm/gnat_language_extensions id1}@anchor{43c}
@chapter GNAT language extensions
@end menu
@node How to activate the extended GNAT Ada superset,Curated Extensions,,GNAT language extensions
-@anchor{gnat_rm/gnat_language_extensions how-to-activate-the-extended-gnat-ada-superset}@anchor{43a}
+@anchor{gnat_rm/gnat_language_extensions how-to-activate-the-extended-gnat-ada-superset}@anchor{43d}
@section How to activate the extended GNAT Ada superset
@itemize *
@item
-The @ref{65,,Pragma Extensions_Allowed}. To activate
+The @ref{67,,Pragma Extensions_Allowed}. To activate
the curated set of extensions, you should use
@end itemize
@end cartouche
@node Curated Extensions,Experimental Language Extensions,How to activate the extended GNAT Ada superset,GNAT language extensions
-@anchor{gnat_rm/gnat_language_extensions curated-extensions}@anchor{43b}@anchor{gnat_rm/gnat_language_extensions curated-language-extensions}@anchor{66}
+@anchor{gnat_rm/gnat_language_extensions curated-extensions}@anchor{43e}@anchor{gnat_rm/gnat_language_extensions curated-language-extensions}@anchor{68}
@section Curated Extensions
@end menu
@node Local Declarations Without Block,Conditional when constructs,,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions local-declarations-without-block}@anchor{43c}
+@anchor{gnat_rm/gnat_language_extensions local-declarations-without-block}@anchor{43f}
@subsection Local Declarations Without Block
@end example
@node Conditional when constructs,Case pattern matching,Local Declarations Without Block,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions conditional-when-constructs}@anchor{43d}
+@anchor{gnat_rm/gnat_language_extensions conditional-when-constructs}@anchor{440}
@subsection Conditional when constructs
@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-conditional-when-constructs.rst}
@node Case pattern matching,Fixed lower bounds for array types and subtypes,Conditional when constructs,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions case-pattern-matching}@anchor{43e}
+@anchor{gnat_rm/gnat_language_extensions case-pattern-matching}@anchor{441}
@subsection Case pattern matching
@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-pattern-matching.rst}
@node Fixed lower bounds for array types and subtypes,Prefixed-view notation for calls to primitive subprograms of untagged types,Case pattern matching,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions fixed-lower-bounds-for-array-types-and-subtypes}@anchor{43f}
+@anchor{gnat_rm/gnat_language_extensions fixed-lower-bounds-for-array-types-and-subtypes}@anchor{442}
@subsection Fixed lower bounds for array types and subtypes
@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-fixed-lower-bound.rst}
@node Prefixed-view notation for calls to primitive subprograms of untagged types,Expression defaults for generic formal functions,Fixed lower bounds for array types and subtypes,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions prefixed-view-notation-for-calls-to-primitive-subprograms-of-untagged-types}@anchor{440}
+@anchor{gnat_rm/gnat_language_extensions prefixed-view-notation-for-calls-to-primitive-subprograms-of-untagged-types}@anchor{443}
@subsection Prefixed-view notation for calls to primitive subprograms of untagged types
@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-prefixed-untagged.rst}
@node Expression defaults for generic formal functions,String interpolation,Prefixed-view notation for calls to primitive subprograms of untagged types,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions expression-defaults-for-generic-formal-functions}@anchor{441}
+@anchor{gnat_rm/gnat_language_extensions expression-defaults-for-generic-formal-functions}@anchor{444}
@subsection Expression defaults for generic formal functions
@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-expression-functions-as-default-for-generic-formal-function-parameters.rst}
@node String interpolation,Constrained attribute for generic objects,Expression defaults for generic formal functions,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions string-interpolation}@anchor{442}
+@anchor{gnat_rm/gnat_language_extensions string-interpolation}@anchor{445}
@subsection String interpolation
@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-string-interpolation.rst}
@node Constrained attribute for generic objects,Static aspect on intrinsic functions,String interpolation,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions constrained-attribute-for-generic-objects}@anchor{443}
+@anchor{gnat_rm/gnat_language_extensions constrained-attribute-for-generic-objects}@anchor{446}
@subsection Constrained attribute for generic objects
result indicates whether the corresponding actual is constrained.
@node Static aspect on intrinsic functions,,Constrained attribute for generic objects,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions static-aspect-on-intrinsic-functions}@anchor{444}
+@anchor{gnat_rm/gnat_language_extensions static-aspect-on-intrinsic-functions}@anchor{447}
@subsection @code{Static} aspect on intrinsic functions
particular the @code{Shift_Left} and @code{Shift_Right} intrinsics.
@node Experimental Language Extensions,,Curated Extensions,GNAT language extensions
-@anchor{gnat_rm/gnat_language_extensions experimental-language-extensions}@anchor{67}@anchor{gnat_rm/gnat_language_extensions id2}@anchor{445}
+@anchor{gnat_rm/gnat_language_extensions experimental-language-extensions}@anchor{69}@anchor{gnat_rm/gnat_language_extensions id2}@anchor{448}
@section Experimental Language Extensions
@end menu
@node Pragma Storage_Model,Simpler accessibility model,,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions pragma-storage-model}@anchor{446}
+@anchor{gnat_rm/gnat_language_extensions pragma-storage-model}@anchor{449}
@subsection Pragma Storage_Model
@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-storage-model.rst}
@node Simpler accessibility model,,Pragma Storage_Model,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions simpler-accessibility-model}@anchor{447}
+@anchor{gnat_rm/gnat_language_extensions simpler-accessibility-model}@anchor{44a}
@subsection Simpler accessibility model
@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-simpler-accessibility.md}
@node Security Hardening Features,Obsolescent Features,GNAT language extensions,Top
-@anchor{gnat_rm/security_hardening_features doc}@anchor{448}@anchor{gnat_rm/security_hardening_features id1}@anchor{449}@anchor{gnat_rm/security_hardening_features security-hardening-features}@anchor{15}
+@anchor{gnat_rm/security_hardening_features doc}@anchor{44b}@anchor{gnat_rm/security_hardening_features id1}@anchor{44c}@anchor{gnat_rm/security_hardening_features security-hardening-features}@anchor{15}
@chapter Security Hardening Features
@end menu
@node Register Scrubbing,Stack Scrubbing,,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features register-scrubbing}@anchor{44a}
+@anchor{gnat_rm/security_hardening_features register-scrubbing}@anchor{44d}
@section Register Scrubbing
GNAT can generate code to zero-out hardware registers before returning
from a subprogram.
-It can be enabled with the @code{-fzero-call-used-regs=@emph{choice}}
+It can be enabled with the @code{-fzero-call-used-regs=`choice'}
command-line option, to affect all subprograms in a compilation, and
with a @code{Machine_Attribute} pragma, to affect only specific
subprograms.
@c Stack Scrubbing:
@node Stack Scrubbing,Hardened Conditionals,Register Scrubbing,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features stack-scrubbing}@anchor{44b}
+@anchor{gnat_rm/security_hardening_features stack-scrubbing}@anchor{44e}
@section Stack Scrubbing
end Bar;
@end example
-There are also @code{-fstrub=@emph{choice}} command-line options to
+There are also @code{-fstrub=`choice'} command-line options to
control default settings. For usage and more details on the
command-line options, on the @code{strub} attribute, and their use with
other programming languages, see @cite{Using the GNU Compiler Collection (GCC)}.
@c Hardened Conditionals:
@node Hardened Conditionals,Hardened Booleans,Stack Scrubbing,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features hardened-conditionals}@anchor{44c}
+@anchor{gnat_rm/security_hardening_features hardened-conditionals}@anchor{44f}
@section Hardened Conditionals
@c Hardened Booleans:
@node Hardened Booleans,Control Flow Redundancy,Hardened Conditionals,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features hardened-booleans}@anchor{44d}
+@anchor{gnat_rm/security_hardening_features hardened-booleans}@anchor{450}
@section Hardened Booleans
@c Control Flow Redundancy:
@node Control Flow Redundancy,,Hardened Booleans,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features control-flow-redundancy}@anchor{44e}
+@anchor{gnat_rm/security_hardening_features control-flow-redundancy}@anchor{451}
@section Control Flow Redundancy
can be used with other programming languages supported by GCC.
@node Obsolescent Features,Compatibility and Porting Guide,Security Hardening Features,Top
-@anchor{gnat_rm/obsolescent_features doc}@anchor{44f}@anchor{gnat_rm/obsolescent_features id1}@anchor{450}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{16}
+@anchor{gnat_rm/obsolescent_features doc}@anchor{452}@anchor{gnat_rm/obsolescent_features id1}@anchor{453}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{16}
@chapter Obsolescent Features
@end menu
@node pragma No_Run_Time,pragma Ravenscar,,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features id2}@anchor{451}@anchor{gnat_rm/obsolescent_features pragma-no-run-time}@anchor{452}
+@anchor{gnat_rm/obsolescent_features id2}@anchor{454}@anchor{gnat_rm/obsolescent_features pragma-no-run-time}@anchor{455}
@section pragma No_Run_Time
includes just those features that are to be made accessible.
@node pragma Ravenscar,pragma Restricted_Run_Time,pragma No_Run_Time,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features id3}@anchor{453}@anchor{gnat_rm/obsolescent_features pragma-ravenscar}@anchor{454}
+@anchor{gnat_rm/obsolescent_features id3}@anchor{456}@anchor{gnat_rm/obsolescent_features pragma-ravenscar}@anchor{457}
@section pragma Ravenscar
is part of the new Ada 2005 standard.
@node pragma Restricted_Run_Time,pragma Task_Info,pragma Ravenscar,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features id4}@anchor{455}@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{456}
+@anchor{gnat_rm/obsolescent_features id4}@anchor{458}@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{459}
@section pragma Restricted_Run_Time
this kind of implementation dependent addition.
@node pragma Task_Info,package System Task_Info s-tasinf ads,pragma Restricted_Run_Time,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features id5}@anchor{457}@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{458}
+@anchor{gnat_rm/obsolescent_features id5}@anchor{45a}@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{45b}
@section pragma Task_Info
library.
@node package System Task_Info s-tasinf ads,,pragma Task_Info,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features package-system-task-info}@anchor{459}@anchor{gnat_rm/obsolescent_features package-system-task-info-s-tasinf-ads}@anchor{45a}
+@anchor{gnat_rm/obsolescent_features package-system-task-info}@anchor{45c}@anchor{gnat_rm/obsolescent_features package-system-task-info-s-tasinf-ads}@anchor{45d}
@section package System.Task_Info (@code{s-tasinf.ads})
standard replacement for GNAT’s @code{Task_Info} functionality.
@node Compatibility and Porting Guide,GNU Free Documentation License,Obsolescent Features,Top
-@anchor{gnat_rm/compatibility_and_porting_guide doc}@anchor{45b}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{17}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{45c}
+@anchor{gnat_rm/compatibility_and_porting_guide doc}@anchor{45e}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{17}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{45f}
@chapter Compatibility and Porting Guide
@end menu
@node Writing Portable Fixed-Point Declarations,Compatibility with Ada 83,,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide id2}@anchor{45d}@anchor{gnat_rm/compatibility_and_porting_guide writing-portable-fixed-point-declarations}@anchor{45e}
+@anchor{gnat_rm/compatibility_and_porting_guide id2}@anchor{460}@anchor{gnat_rm/compatibility_and_porting_guide writing-portable-fixed-point-declarations}@anchor{461}
@section Writing Portable Fixed-Point Declarations
types will be portable.
@node Compatibility with Ada 83,Compatibility between Ada 95 and Ada 2005,Writing Portable Fixed-Point Declarations,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-ada-83}@anchor{45f}@anchor{gnat_rm/compatibility_and_porting_guide id3}@anchor{460}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-ada-83}@anchor{462}@anchor{gnat_rm/compatibility_and_porting_guide id3}@anchor{463}
@section Compatibility with Ada 83
@end menu
@node Legal Ada 83 programs that are illegal in Ada 95,More deterministic semantics,,Compatibility with Ada 83
-@anchor{gnat_rm/compatibility_and_porting_guide id4}@anchor{461}@anchor{gnat_rm/compatibility_and_porting_guide legal-ada-83-programs-that-are-illegal-in-ada-95}@anchor{462}
+@anchor{gnat_rm/compatibility_and_porting_guide id4}@anchor{464}@anchor{gnat_rm/compatibility_and_porting_guide legal-ada-83-programs-that-are-illegal-in-ada-95}@anchor{465}
@subsection Legal Ada 83 programs that are illegal in Ada 95
@itemize *
@item
-@emph{Character literals}
+`Character literals'
Some uses of character literals are ambiguous. Since Ada 95 has introduced
@code{Wide_Character} as a new predefined character type, some uses of
@end example
@item
-@emph{New reserved words}
+`New reserved words'
The identifiers @code{abstract}, @code{aliased}, @code{protected},
@code{requeue}, @code{tagged}, and @code{until} are reserved in Ada 95.
use some alternative name.
@item
-@emph{Freezing rules}
+`Freezing rules'
The rules in Ada 95 are slightly different with regard to the point at
which entities are frozen, and representation pragmas and clauses are
declaration must be introduced to which the pragma can be applied.
@item
-@emph{Optional bodies for library packages}
+`Optional bodies for library packages'
In Ada 83, a package that did not require a package body was nevertheless
allowed to have one. This lead to certain surprises in compiling large
since one effect of this pragma is to require the presence of a package body.
@item
-@emph{Numeric_Error is the same exception as Constraint_Error}
+`Numeric_Error is the same exception as Constraint_Error'
In Ada 95, the exception @code{Numeric_Error} is a renaming of @code{Constraint_Error}.
This means that it is illegal to have separate exception handlers for
@code{Constraint_Error} in place of @code{Numeric_Error} in all cases).
@item
-@emph{Indefinite subtypes in generics}
+`Indefinite subtypes in generics'
In Ada 83, it was permissible to pass an indefinite type (e.g, @code{String})
as the actual for a generic formal private type, but then the instantiation
@end itemize
@node More deterministic semantics,Changed semantics,Legal Ada 83 programs that are illegal in Ada 95,Compatibility with Ada 83
-@anchor{gnat_rm/compatibility_and_porting_guide id5}@anchor{463}@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{464}
+@anchor{gnat_rm/compatibility_and_porting_guide id5}@anchor{466}@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{467}
@subsection More deterministic semantics
@itemize *
@item
-@emph{Conversions}
+`Conversions'
Conversions from real types to integer types round away from 0. In Ada 83
the conversion Integer(2.5) could deliver either 2 or 3 as its value. This
when porting code from one vendor to another.
@item
-@emph{Tasking}
+`Tasking'
The Real-Time Annex introduces a set of policies that define the behavior of
features that were implementation dependent in Ada 83, such as the order in
@end itemize
@node Changed semantics,Other language compatibility issues,More deterministic semantics,Compatibility with Ada 83
-@anchor{gnat_rm/compatibility_and_porting_guide changed-semantics}@anchor{465}@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{466}
+@anchor{gnat_rm/compatibility_and_porting_guide changed-semantics}@anchor{468}@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{469}
@subsection Changed semantics
@itemize *
@item
-@emph{Range of type `@w{`}Character`@w{`}}
+`Range of type `@w{`}Character`@w{`}'
The range of @code{Standard.Character} is now the full 256 characters
of Latin-1, whereas in most Ada 83 implementations it was restricted
@end itemize
@node Other language compatibility issues,,Changed semantics,Compatibility with Ada 83
-@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{467}@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{468}
+@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{46a}@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{46b}
@subsection Other language compatibility issues
@itemize *
@item
-@emph{-gnat83} switch
+`-gnat83' switch
All implementations of GNAT provide a switch that causes GNAT to operate
in Ada 83 mode. In this mode, some but not all compatibility problems
@end itemize
@node Compatibility between Ada 95 and Ada 2005,Implementation-dependent characteristics,Compatibility with Ada 83,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide compatibility-between-ada-95-and-ada-2005}@anchor{469}@anchor{gnat_rm/compatibility_and_porting_guide id8}@anchor{46a}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-between-ada-95-and-ada-2005}@anchor{46c}@anchor{gnat_rm/compatibility_and_porting_guide id8}@anchor{46d}
@section Compatibility between Ada 95 and Ada 2005
@itemize *
@item
-@emph{New reserved words.}
+`New reserved words.'
The words @code{interface}, @code{overriding} and @code{synchronized} are
reserved in Ada 2005.
illegal.
@item
-@emph{New declarations in predefined packages.}
+`New declarations in predefined packages.'
A number of packages in the predefined environment contain new declarations:
@code{Ada.Exceptions}, @code{Ada.Real_Time}, @code{Ada.Strings},
packages, the new declarations may cause name clashes.
@item
-@emph{Access parameters.}
+`Access parameters.'
A nondispatching subprogram with an access parameter cannot be renamed
as a dispatching operation. This was permitted in Ada 95.
@item
-@emph{Access types, discriminants, and constraints.}
+`Access types, discriminants, and constraints.'
Rule changes in this area have led to some incompatibilities; for example,
constrained subtypes of some access types are not permitted in Ada 2005.
@item
-@emph{Aggregates for limited types.}
+`Aggregates for limited types.'
The allowance of aggregates for limited types in Ada 2005 raises the
possibility of ambiguities in legal Ada 95 programs, since additional types
now need to be considered in expression resolution.
@item
-@emph{Fixed-point multiplication and division.}
+`Fixed-point multiplication and division.'
Certain expressions involving ‘*’ or ‘/’ for a fixed-point type, which
were legal in Ada 95 and invoked the predefined versions of these operations,
@code{Standard}.
@item
-@emph{Return-by-reference types.}
+`Return-by-reference types.'
The Ada 95 return-by-reference mechanism has been removed. Instead, the user
can declare a function returning a value from an anonymous access type.
@end itemize
@node Implementation-dependent characteristics,Compatibility with Other Ada Systems,Compatibility between Ada 95 and Ada 2005,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide id9}@anchor{46b}@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{46c}
+@anchor{gnat_rm/compatibility_and_porting_guide id9}@anchor{46e}@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{46f}
@section Implementation-dependent characteristics
@end menu
@node Implementation-defined pragmas,Implementation-defined attributes,,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide id10}@anchor{46d}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{46e}
+@anchor{gnat_rm/compatibility_and_porting_guide id10}@anchor{470}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{471}
@subsection Implementation-defined pragmas
relevant in a GNAT context and hence are not otherwise implemented.
@node Implementation-defined attributes,Libraries,Implementation-defined pragmas,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide id11}@anchor{46f}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-attributes}@anchor{470}
+@anchor{gnat_rm/compatibility_and_porting_guide id11}@anchor{472}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-attributes}@anchor{473}
@subsection Implementation-defined attributes
@code{Type_Class}.
@node Libraries,Elaboration order,Implementation-defined attributes,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide id12}@anchor{471}@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{472}
+@anchor{gnat_rm/compatibility_and_porting_guide id12}@anchor{474}@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{475}
@subsection Libraries
@end itemize
@node Elaboration order,Target-specific aspects,Libraries,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide elaboration-order}@anchor{473}@anchor{gnat_rm/compatibility_and_porting_guide id13}@anchor{474}
+@anchor{gnat_rm/compatibility_and_porting_guide elaboration-order}@anchor{476}@anchor{gnat_rm/compatibility_and_porting_guide id13}@anchor{477}
@subsection Elaboration order
@code{Elaborate_All} pragmas where
needed. However, this can lead to the creation of elaboration circularities
and a resulting rejection of the program by gnatbind. This issue is
-thoroughly described in the @emph{Elaboration Order Handling in GNAT} appendix
+thoroughly described in the `Elaboration Order Handling in GNAT' appendix
in the @cite{GNAT User’s Guide}.
In brief, there are several
ways to deal with this situation:
Constrain the elaboration order by including explicit @code{Elaborate_Body} or
@code{Elaborate} pragmas, and then inhibit the generation of implicit
@code{Elaborate_All}
-pragmas either globally (as an effect of the @emph{-gnatE} switch) or locally
+pragmas either globally (as an effect of the `-gnatE' switch) or locally
(by selectively suppressing elaboration checks via pragma
@code{Suppress(Elaboration_Check)} when it is safe to do so).
@end itemize
@node Target-specific aspects,,Elaboration order,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{475}@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{476}
+@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{478}@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{479}
@subsection Target-specific aspects
Ada 2005 and Ada 2012) are sometimes
incompatible with typical Ada 83 compiler practices regarding implicit
packing, the meaning of the Size attribute, and the size of access values.
-GNAT’s approach to these issues is described in @ref{477,,Representation Clauses}.
+GNAT’s approach to these issues is described in @ref{47a,,Representation Clauses}.
@node Compatibility with Other Ada Systems,Representation Clauses,Implementation-dependent characteristics,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-other-ada-systems}@anchor{478}@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{479}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-other-ada-systems}@anchor{47b}@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{47c}
@section Compatibility with Other Ada Systems
@itemize *
@item
-@emph{Ada 83 Pragmas and Attributes}
+`Ada 83 Pragmas and Attributes'
Ada 95 compilers are allowed, but not required, to implement the missing
Ada 83 pragmas and attributes that are no longer defined in Ada 95.
pragmas and attributes.
@item
-@emph{Specialized Needs Annexes}
+`Specialized Needs Annexes'
GNAT implements the full set of special needs annexes. At the
current time, it is the only Ada 95 compiler to do so. This means that
95 compilation systems.
@item
-@emph{Representation Clauses}
+`Representation Clauses'
Some other Ada 95 compilers implement only the minimal set of
representation clauses required by the Ada 95 reference manual. GNAT goes
@end itemize
@node Representation Clauses,Compatibility with HP Ada 83,Compatibility with Other Ada Systems,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide id16}@anchor{47a}@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{477}
+@anchor{gnat_rm/compatibility_and_porting_guide id16}@anchor{47d}@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{47a}
@section Representation Clauses
@itemize *
@item
-@emph{Implicit Packing}
+`Implicit Packing'
Some Ada 83 compilers allowed a Size specification to cause implicit
packing of an array or record. This could cause expensive implicit
a Component_Size clause.
@item
-@emph{Meaning of Size Attribute}
+`Meaning of Size Attribute'
The Size attribute in Ada 95 (and Ada 2005) for discrete types is defined as
the minimal number of bits required to hold values of the type. For example,
some Ada 83 compiler systems.
@item
-@emph{Size of Access Types}
+`Size of Access Types'
A common assumption in Ada 83 code is that an access type is in fact a pointer,
and that therefore it will be the same size as a System.Address value. This
@end itemize
@node Compatibility with HP Ada 83,,Representation Clauses,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-hp-ada-83}@anchor{47b}@anchor{gnat_rm/compatibility_and_porting_guide id17}@anchor{47c}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-hp-ada-83}@anchor{47e}@anchor{gnat_rm/compatibility_and_porting_guide id17}@anchor{47f}
@section Compatibility with HP Ada 83
@itemize *
@item
-@emph{Default floating-point representation}
+`Default floating-point representation'
In GNAT, the default floating-point format is IEEE, whereas in HP Ada 83,
it is VMS format.
@item
-@emph{System}
+`System'
the package System in GNAT exactly corresponds to the definition in the
Ada 95 reference manual, which means that it excludes many of the
@end itemize
@node GNU Free Documentation License,Index,Compatibility and Porting Guide,Top
-@anchor{share/gnu_free_documentation_license doc}@anchor{47d}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{47e}
+@anchor{share/gnu_free_documentation_license doc}@anchor{480}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{481}
@chapter GNU Free Documentation License
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
-@strong{Preamble}
+`Preamble'
The purpose of this License is to make a manual, textbook, or other
functional and useful document “free” in the sense of freedom: to
whether it is published as a printed book. We recommend this License
principally for works whose purpose is instruction or reference.
-@strong{1. APPLICABILITY AND DEFINITIONS}
+`1. APPLICABILITY AND DEFINITIONS'
This License applies to any manual or other work, in any medium, that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License. Such a notice grants a
world-wide, royalty-free license, unlimited in duration, to use that
-work under the conditions stated herein. The @strong{Document}, below,
+work under the conditions stated herein. The `Document', below,
refers to any such manual or work. Any member of the public is a
-licensee, and is addressed as “@strong{you}”. You accept the license if you
+licensee, and is addressed as “`you'”. You accept the license if you
copy, modify or distribute the work in a way requiring permission
under copyright law.
-A “@strong{Modified Version}” of the Document means any work containing the
+A “`Modified Version'” of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.
-A “@strong{Secondary Section}” is a named appendix or a front-matter section of
+A “`Secondary Section'” is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the
publishers or authors of the Document to the Document’s overall subject
(or to related matters) and contains nothing that could fall directly
commercial, philosophical, ethical or political position regarding
them.
-The “@strong{Invariant Sections}” are certain Secondary Sections whose titles
+The “`Invariant Sections'” are certain Secondary Sections whose titles
are designated, as being those of Invariant Sections, in the notice
that says that the Document is released under this License. If a
section does not fit the above definition of Secondary then it is not
Invariant Sections. If the Document does not identify any Invariant
Sections then there are none.
-The “@strong{Cover Texts}” are certain short passages of text that are listed,
+The “`Cover Texts'” are certain short passages of text that are listed,
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
the Document is released under this License. A Front-Cover Text may
be at most 5 words, and a Back-Cover Text may be at most 25 words.
-A “@strong{Transparent}” copy of the Document means a machine-readable copy,
+A “`Transparent'” copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the
general public, that is suitable for revising the document
straightforwardly with generic text editors or (for images composed of
format whose markup, or absence of markup, has been arranged to thwart
or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount
-of text. A copy that is not “Transparent” is called @strong{Opaque}.
+of text. A copy that is not “Transparent” is called `Opaque'.
Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML
machine-generated HTML, PostScript or PDF produced by some word
processors for output purposes only.
-The “@strong{Title Page}” means, for a printed book, the title page itself,
+The “`Title Page'” means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page. For works in
formats which do not have any title page as such, “Title Page” means
the text near the most prominent appearance of the work’s title,
preceding the beginning of the body of the text.
-The “@strong{publisher}” means any person or entity that distributes
+The “`publisher'” means any person or entity that distributes
copies of the Document to the public.
-A section “@strong{Entitled XYZ}” means a named subunit of the Document whose
+A section “`Entitled XYZ'” means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following
text that translates XYZ in another language. (Here XYZ stands for a
-specific section name mentioned below, such as “@strong{Acknowledgements}”,
-“@strong{Dedications}”, “@strong{Endorsements}”, or “@strong{History}”.)
-To “@strong{Preserve the Title}”
+specific section name mentioned below, such as “`Acknowledgements'”,
+“`Dedications'”, “`Endorsements'”, or “`History'”.)
+To “`Preserve the Title'”
of such a section when you modify the Document means that it remains a
section “Entitled XYZ” according to this definition.
implication that these Warranty Disclaimers may have is void and has
no effect on the meaning of this License.
-@strong{2. VERBATIM COPYING}
+`2. VERBATIM COPYING'
You may copy and distribute the Document in any medium, either
commercially or noncommercially, provided that this License, the
You may also lend copies, under the same conditions stated above, and
you may publicly display copies.
-@strong{3. COPYING IN QUANTITY}
+`3. COPYING IN QUANTITY'
If you publish printed copies (or copies in media that commonly have
printed covers) of the Document, numbering more than 100, and the
Document well before redistributing any large number of copies, to give
them a chance to provide you with an updated version of the Document.
-@strong{4. MODIFICATIONS}
+`4. MODIFICATIONS'
You may copy and distribute a Modified Version of the Document under
the conditions of sections 2 and 3 above, provided that you release
give permission to use their names for publicity for or to assert or
imply endorsement of any Modified Version.
-@strong{5. COMBINING DOCUMENTS}
+`5. COMBINING DOCUMENTS'
You may combine the Document with other documents released under this
License, under the terms defined in section 4 above for modified
and any sections Entitled “Dedications”. You must delete all sections
Entitled “Endorsements”.
-@strong{6. COLLECTIONS OF DOCUMENTS}
+`6. COLLECTIONS OF DOCUMENTS'
You may make a collection consisting of the Document and other documents
released under this License, and replace the individual copies of this
License into the extracted document, and follow this License in all
other respects regarding verbatim copying of that document.
-@strong{7. AGGREGATION WITH INDEPENDENT WORKS}
+`7. AGGREGATION WITH INDEPENDENT WORKS'
A compilation of the Document or its derivatives with other separate
and independent documents or works, in or on a volume of a storage or
Otherwise they must appear on printed covers that bracket the whole
aggregate.
-@strong{8. TRANSLATION}
+`8. TRANSLATION'
Translation is considered a kind of modification, so you may
distribute translations of the Document under the terms of section 4.
its Title (section 1) will typically require changing the actual
title.
-@strong{9. TERMINATION}
+`9. TERMINATION'
You may not copy, modify, sublicense, or distribute the Document
except as expressly provided under this License. Any attempt
reinstated, receipt of a copy of some or all of the same material does
not give you any rights to use it.
-@strong{10. FUTURE REVISIONS OF THIS LICENSE}
+`10. FUTURE REVISIONS OF THIS LICENSE'
The Free Software Foundation may publish new, revised versions
of the GNU Free Documentation License from time to time. Such new
version permanently authorizes you to choose that version for the
Document.
-@strong{11. RELICENSING}
+`11. RELICENSING'
“Massive Multiauthor Collaboration Site” (or “MMC Site”) means any
World Wide Web server that publishes copyrightable works and also
under CC-BY-SA on the same site at any time before August 1, 2009,
provided the MMC is eligible for relicensing.
-@strong{ADDENDUM: How to use this License for your documents}
+`ADDENDUM: How to use this License for your documents'
To use this License in a document you have written, include a copy of
the License in the document and put the following copyright and
@setfilename gnat_ugn.info
@documentencoding UTF-8
@ifinfo
-@*Generated by Sphinx 4.3.2.@*
+@*Generated by Sphinx 5.3.0.@*
@end ifinfo
@settitle GNAT User's Guide for Native Platforms
@defindex ge
* gnat_ugn: (gnat_ugn.info). gnat_ugn
@end direntry
-@definfoenclose strong,`,'
-@definfoenclose emph,`,'
@c %**end of header
@copying
@quotation
-GNAT User's Guide for Native Platforms , Dec 14, 2023
+GNAT User's Guide for Native Platforms , Dec 21, 2023
AdaCore
@c %**start of body
@anchor{gnat_ugn doc}@anchor{0}
-@emph{GNAT, The GNU Ada Development Environment}
+`GNAT, The GNU Ada Development Environment'
@include gcc-common.texi
@code{Variables}
@item
-@emph{Emphasis}
+`Emphasis'
@item
[optional information or parameters]
@table @asis
-@item @emph{greetings.ads}
+@item `greetings.ads'
spec of package @code{Greetings}
-@item @emph{greetings.adb}
+@item `greetings.adb'
body of package @code{Greetings}
-@item @emph{gmain.adb}
+@item `gmain.adb'
body of main program
@end table
Each file contains a single Ada compilation unit, including any pragmas
associated with the unit. For example, this means you must place a
-package declaration (a package @emph{spec}) and the corresponding body in
-separate files. An Ada @emph{compilation} (which is a sequence of
+package declaration (a package `spec') and the corresponding body in
+separate files. An Ada `compilation' (which is a sequence of
compilation units) is represented using a sequence of files. Similarly,
you will place each subunit or child unit in a separate file.
@table @asis
-@item @emph{ISO 8859-2 (Latin-2)}
+@item `ISO 8859-2 (Latin-2)'
Latin-2 letters allowed in identifiers, with uppercase and lowercase
equivalence.
@table @asis
-@item @emph{ISO 8859-3 (Latin-3)}
+@item `ISO 8859-3 (Latin-3)'
Latin-3 letters allowed in identifiers, with uppercase and lowercase
equivalence.
@table @asis
-@item @emph{ISO 8859-4 (Latin-4)}
+@item `ISO 8859-4 (Latin-4)'
Latin-4 letters allowed in identifiers, with uppercase and lowercase
equivalence.
@table @asis
-@item @emph{ISO 8859-5 (Cyrillic)}
+@item `ISO 8859-5 (Cyrillic)'
ISO 8859-5 letters (Cyrillic) allowed in identifiers, with uppercase and
lowercase equivalence.
@table @asis
-@item @emph{ISO 8859-15 (Latin-9)}
+@item `ISO 8859-15 (Latin-9)'
ISO 8859-15 (Latin-9) letters allowed in identifiers, with uppercase and
lowercase equivalence.
@table @asis
-@item @emph{IBM PC (code page 437)}
+@item `IBM PC (code page 437)'
This code page is the normal default for PCs in the U.S. It corresponds
to the original IBM PC character set. This set has some, but not all, of
@table @asis
-@item @emph{IBM PC (code page 850)}
+@item `IBM PC (code page 850)'
This code page is a modification of 437 extended to include all the
Latin-1 letters, but still not with the usual Latin-1 encoding. In this
mode, all these letters are allowed in identifiers with uppercase and
lowercase equivalence.
-@item @emph{Full Upper 8-bit}
+@item `Full Upper 8-bit'
Any character in the range 80-FF allowed in identifiers, and all are
considered distinct. In other words, there are no uppercase and lowercase
certain encoding schemes used for some foreign character sets (e.g.,
the typical method of representing Chinese characters on the PC).
-@item @emph{No Upper-Half}
+@item `No Upper-Half'
No upper-half characters in the range 80-FF are allowed in identifiers.
This gives Ada 83 compatibility for identifier names.
@table @asis
-@item @emph{Hex Coding}
+@item `Hex Coding'
In this encoding, a wide character is represented by the following five
character sequence:
@table @asis
-@item @emph{Upper-Half Coding}
+@item `Upper-Half Coding'
The wide character with encoding @code{16#abcd#} where the upper bit is on
(in other words, ‘a’ is in the range 8-F) is represented as two bytes,
@table @asis
-@item @emph{Shift JIS Coding}
+@item `Shift JIS Coding'
A wide character is represented by a two-character sequence,
@code{16#ab#} and
@table @asis
-@item @emph{EUC Coding}
+@item `EUC Coding'
A wide character is represented by a two-character sequence
@code{16#ab#} and
encoding algorithm. Only characters defined in the JIS code set table
can be used with this encoding method.
-@item @emph{UTF-8 Coding}
+@item `UTF-8 Coding'
A wide character is represented using
UCS Transformation Format 8 (UTF-8) as defined in Annex R of ISO
6-byte sequences, and in the following section on wide wide
characters, the use of these sequences is documented).
-@item @emph{Brackets Coding}
+@item `Brackets Coding'
In this encoding, a wide character is represented by the following eight
character sequence:
@table @asis
-@item @emph{UTF-8 Coding}
+@item `UTF-8 Coding'
A wide character is represented using
UCS Transformation Format 8 (UTF-8) as defined in Annex R of ISO
where the @code{xxx} bits correspond to the left-padded bits of the
32-bit character value.
-@item @emph{Brackets Coding}
+@item `Brackets Coding'
In this encoding, a wide wide character is represented by the following ten or
twelve byte character sequence:
If @code{--version} was not used, display usage, then exit disregarding
all other options.
-@item @code{--subdirs=@emph{dir}}
+@item @code{--subdirs=`dir'}
Real object, library or exec directories are subdirectories <dir> of the
specified ones.
@table @asis
-@item @code{-c@emph{filename}}
+@item @code{-c`filename'}
Create a configuration pragmas file @code{filename} (instead of the default
@code{gnat.adc}).
@table @asis
-@item @code{-d@emph{dir}}
+@item @code{-d`dir'}
Look for source files in directory @code{dir}. There may be zero, one or more
spaces between @code{-d} and @code{dir}.
@table @asis
-@item @code{-D@emph{filename}}
+@item @code{-D`filename'}
Look for source files in all directories listed in text file @code{filename}.
There may be zero, one or more spaces between @code{-D}
@geindex -f (gnatname)
-@item @code{-f@emph{pattern}}
+@item @code{-f`pattern'}
Foreign patterns. Using this switch, it is possible to add sources of languages
other than Ada to the list of sources of a project file.
@geindex -P (gnatname)
-@item @code{-P@emph{proj}}
+@item @code{-P`proj'}
Create or update project file @code{proj}. There may be zero, one or more space
between @code{-P} and @code{proj}. @code{proj} may include directory
@geindex -x (gnatname)
-@item @code{-x@emph{pattern}}
+@item @code{-x`pattern'}
Excluded patterns. Using this switch, it is possible to exclude some files
that would match the name patterns. For example,
respectively.
@end itemize
-The @code{-gnatk@emph{nn}}
+The @code{-gnatk`nn'}
switch of the compiler activates a ‘krunching’
circuit that limits file names to nn characters (where nn is a decimal
integer).
configuration pragmas are handled according to strict RM rules. See
previous section for a full description of this mode.
-@item @code{-gnat@emph{xxx}}
+@item @code{-gnat`xxx'}
-This passes the given @code{-gnat@emph{xxx}} switch to @code{gnat} which is
-used to parse the given file. Not all @emph{xxx} options make sense,
+This passes the given @code{-gnat`xxx'} switch to @code{gnat} which is
+used to parse the given file. Not all `xxx' options make sense,
but for example, the use of @code{-gnati2} allows @code{gnatchop} to
process a source file that uses Latin-2 coding for identifiers.
@table @asis
-@item @code{-k@emph{mm}}
+@item @code{-k`mm'}
Limit generated file names to the specified number @code{mm}
of characters.
@table @asis
-@item @code{--GCC=@emph{xxxx}}
+@item @code{--GCC=`xxxx'}
Specify the path of the GNAT parser to be used. When this switch is used,
no attempt is made to add the prefix to the GNAT parser executable.
Restrictions that require partition-wide consistency (like
@code{No_Tasking}) are
recognized wherever they appear
-and can be freely inherited, e.g. from a @emph{with}ed unit to the @emph{with}ing
+and can be freely inherited, e.g. from a `with'ed unit to the `with'ing
unit. This makes sense since the binder will in any case insist on seeing
consistent use, so any unit not conforming to any restrictions that are
anywhere in the partition will be rejected, and you might as well find
Besides @code{gnat.adc}, additional files containing configuration
pragmas may be applied to the current compilation using the switch
-@code{-gnatec=@emph{path}} where @code{path} must designate an existing file that
+@code{-gnatec=`path'} where @code{path} must designate an existing file that
contains only configuration pragmas. These configuration pragmas are
in addition to those found in @code{gnat.adc} (provided @code{gnat.adc}
is present and switch @code{-gnatA} is not used).
@itemize *
@item
-If a file being compiled @emph{with}s a unit @code{X}, the object file
+If a file being compiled `with's a unit @code{X}, the object file
depends on the file containing the spec of unit @code{X}. This includes
-files that are @emph{with}ed implicitly either because they are parents
-of @emph{with}ed child units or they are run-time units required by the
+files that are `with'ed implicitly either because they are parents
+of `with'ed child units or they are run-time units required by the
language constructs used in a particular unit.
@item
The previous two rules meant that for purposes of computing dependencies and
recompilation, a body and all its subunits are treated as an indivisible whole.
-These rules are applied transitively: if unit @code{A} @emph{with}s
+These rules are applied transitively: if unit @code{A} `with's
unit @code{B}, whose elaboration calls an inlined procedure in package
@code{C}, the object file for unit @code{A} will depend on the body of
@code{C}, in file @code{c.adb}.
Categorization information (e.g., use of pragma @code{Pure}).
@item
-Information on all @emph{with}ed units, including presence of
+Information on all `with'ed units, including presence of
@code{Elaborate} or @code{Elaborate_All} pragmas.
@item
This section describes how to build and use libraries with GNAT, and also shows
how to recompile the GNAT run-time library. You should be familiar with the
-Project Manager facility (see the @emph{GNAT_Project_Manager} chapter of the
-@emph{GPRbuild User’s Guide}) before reading this chapter.
+Project Manager facility (see the `GNAT_Project_Manager' chapter of the
+`GPRbuild User’s Guide') before reading this chapter.
@menu
* Introduction to Libraries in GNAT::
an external user to make use of the library. That is to say, the specs
reflecting the library services along with all the units needed to compile
those specs, which can include generic bodies or any body implementing an
-inlined routine. In the case of @emph{stand-alone libraries} those exposed
-units are called @emph{interface units} (@ref{6b,,Stand-alone Ada Libraries}).
+inlined routine. In the case of `stand-alone libraries' those exposed
+units are called `interface units' (@ref{6b,,Stand-alone Ada Libraries}).
All compilation units comprising an application, including those in a library,
need to be elaborated in an order partially defined by Ada’s semantics. GNAT
computes the elaboration order from the @code{ALI} files and this is why they
constitute a mandatory part of GNAT libraries.
-@emph{Stand-alone libraries} are the exception to this rule because a specific
+`Stand-alone libraries' are the exception to this rule because a specific
library elaboration routine is produced independently of the application(s)
using the library.
The easiest way to build a library is to use the Project Manager,
-which supports a special type of project called a @emph{Library Project}
-(see the @emph{Library Projects} section in the @emph{GNAT Project Manager}
-chapter of the @emph{GPRbuild User’s Guide}).
+which supports a special type of project called a `Library Project'
+(see the `Library Projects' section in the `GNAT Project Manager'
+chapter of the `GPRbuild User’s Guide').
A project is considered a library project, when two project-level attributes
are defined in it: @code{Library_Name} and @code{Library_Dir}. In order to
$ chmod -w *.ali
@end example
-Please note that the library must have a name of the form @code{lib@emph{xxx}.a}
-or @code{lib@emph{xxx}.so} (or @code{lib@emph{xxx}.dll} on Windows) in order to
-be accessed by the directive @code{-l@emph{xxx}} at link time.
+Please note that the library must have a name of the form @code{lib`xxx'.a}
+or @code{lib`xxx'.so} (or @code{lib`xxx'.dll} on Windows) in order to
+be accessed by the directive @code{-l`xxx'} at link time.
@node Installing a library,Using a library,Building a library,General Ada Libraries
@anchor{gnat_ugn/the_gnat_compilation_model id39}@anchor{71}@anchor{gnat_ugn/the_gnat_compilation_model installing-a-library}@anchor{72}
@geindex GPR_PROJECT_PATH
If you use project files, library installation is part of the library build
-process (see the @emph{Installing a Library with Project Files} section of the
-@emph{GNAT Project Manager} chapter of the @emph{GPRbuild User’s Guide}).
+process (see the `Installing a Library with Project Files' section of the
+`GNAT Project Manager' chapter of the `GPRbuild User’s Guide').
When project files are not an option, it is also possible, but not recommended,
to install the library so that the sources needed to use the library are on the
Once again, the project facility greatly simplifies the use of
libraries. In this context, using a library is just a matter of adding a
-@emph{with} clause in the user project. For instance, to make use of the
+`with' clause in the user project. For instance, to make use of the
library @code{My_Lib} shown in examples in earlier sections, you can
write:
Even if you have a third-party, non-Ada library, you can still use GNAT’s
Project Manager facility to provide a wrapper for it. For example, the
-following project, when @emph{with}ed by your main project, will link with the
+following project, when `with'ed by your main project, will link with the
third-party library @code{liba.a}:
@example
GNAT’s Project facility provides a simple way of building and installing
-stand-alone libraries; see the @emph{Stand-alone Library Projects} section
-in the @emph{GNAT Project Manager} chapter of the @emph{GPRbuild User’s Guide}.
+stand-alone libraries; see the `Stand-alone Library Projects' section
+in the `GNAT Project Manager' chapter of the `GPRbuild User’s Guide'.
To be a Stand-alone Library Project, in addition to the two attributes
that make a project a Library Project (@code{Library_Name} and
-@code{Library_Dir}; see the @emph{Library Projects} section in the
-@emph{GNAT Project Manager} chapter of the @emph{GPRbuild User’s Guide}),
+@code{Library_Dir}; see the `Library Projects' section in the
+`GNAT Project Manager' chapter of the `GPRbuild User’s Guide'),
the attribute @code{Library_Interface} must be defined. For example:
@example
The @code{Config} package exists in multiple forms for the various targets,
with an appropriate script selecting the version of @code{Config} needed.
-Then any other unit requiring conditional compilation can do a @emph{with}
+Then any other unit requiring conditional compilation can do a `with'
of @code{Config} to make the constants visible.
@node Debugging - A Special Case,Conditionalizing Declarations,Use of Boolean Constants,Modeling Conditional Compilation in Ada
@subsubsection Preprocessing Symbols
-Preprocessing symbols are defined in @emph{definition files} and referenced in the
+Preprocessing symbols are defined in `definition files' and referenced in the
sources to be preprocessed. A preprocessing symbol is an identifier, following
normal Ada (case-insensitive) rules for its syntax, with the restriction that
all characters need to be in the ASCII set (no accented letters).
@table @asis
-@item @emph{switches}
+@item `switches'
is an optional sequence of switches as described in the next section.
@end table
@table @asis
-@item @emph{infile}
+@item `infile'
is the full name of the input file, which is an Ada source
file containing preprocessor directives.
@table @asis
-@item @emph{outfile}
+@item `outfile'
is the full name of the output file, which is an Ada source
in standard Ada form. When used with GNAT, this file name will
@table @asis
-@item @code{-D@emph{symbol}[=@emph{value}]}
+@item @code{-D`symbol'[=`value']}
Defines a new preprocessing symbol with the specified value. If no value is given
on the command line, then symbol is considered to be @code{True}. This switch
in which preprocessing lines have been inserted. However,
instead of using @code{gnatprep} to explicitly preprocess a file as a separate
step before compilation, you can carry out the preprocessing implicitly
-as part of compilation. Such @emph{integrated preprocessing}, which is the common
+as part of compilation. Such `integrated preprocessing', which is the common
style with C, is performed when either or both of the following switches
are passed to the compiler:
@itemize *
@item
-@code{-gnatep}, which specifies the @emph{preprocessor data file}.
+@code{-gnatep}, which specifies the `preprocessor data file'.
This file dictates how the source files will be preprocessed (e.g., which
symbol definition files apply to which sources).
@item
the builder switch @code{-x} should be used if any Ada source is
compiled with @code{gnatep=}, so that the compiler finds the
-@emph{preprocessor data file}.
+`preprocessor data file'.
@item
the preprocessing data file and the symbol definition files should be
@table @asis
-@item @code{-gnatep=@emph{preprocessor_data_file}}
+@item @code{-gnatep=`preprocessor_data_file'}
This switch specifies the file name (without directory
information) of the preprocessor data file. Either place this file
@end example
@end quotation
-A preprocessor data file is a text file that contains @emph{preprocessor
-control lines}. A preprocessor control line directs the preprocessing of
+A preprocessor data file is a text file that contains `preprocessor
+control lines'. A preprocessor control line directs the preprocessing of
either a particular source file, or, analogous to @code{others} in Ada,
all sources not specified elsewhere in the preprocessor data file.
A preprocessor control line
-can optionally identify a @emph{definition file} that assigns values to
+can optionally identify a `definition file' that assigns values to
preprocessor symbols, as well as a list of switches that relate to
preprocessing.
Empty lines and comments (using Ada syntax) are also permitted, with no
by preprocessing to be retained as comments marked
with the special string ‘@cite{–!}’.
-@item @code{-D@emph{symbol}=@emph{new_value}}
+@item @code{-D`symbol'=`new_value'}
Define or redefine @code{symbol} to have @code{new_value} as its value.
The permitted form for @code{symbol} is either an Ada identifier, or any Ada reserved word
@table @asis
-@item @code{-gnateD@emph{symbol}[=@emph{new_value}]}
+@item @code{-gnateD`symbol'[=`new_value']}
Define or redefine @code{symbol} to have @code{new_value} as its value. If no value
is supplied, then the value of @code{symbol} is @code{True}.
can use instead the @code{-fdump-ada-spec-slim} switch.
You can optionally specify a parent unit, of which all generated units will
-be children, using @code{-fada-spec-parent=@emph{unit}}.
+be children, using @code{-fada-spec-parent=`unit'}.
The simple @code{gcc}-based command works only for C headers. For C++ headers
you need to use either the @code{g++} command or the combination @code{gcc -x c++}.
Generating bindings for C++ headers is done using the same options, always
-with the @emph{g++} compiler. Note that generating Ada spec from C++ headers is a
+with the `g++' compiler. Note that generating Ada spec from C++ headers is a
much more complex job and support for C++ headers is much more limited that
support for C headers. As a result, you will need to modify the resulting
bindings by hand more extensively when using C++ headers.
In this mode, C++ classes will be mapped to Ada tagged types, constructors
will be mapped using the @code{CPP_Constructor} pragma, and when possible,
multiple inheritance of abstract classes will be mapped to Ada interfaces
-(see the @emph{Interfacing to C++} section in the @cite{GNAT Reference Manual}
+(see the `Interfacing to C++' section in the @cite{GNAT Reference Manual}
for additional information on interfacing to C++).
For example, given the following C++ header file:
@table @asis
-@item @code{-fada-spec-parent=@emph{unit}}
+@item @code{-fada-spec-parent=`unit'}
Specifies that all files generated by @code{-fdump-ada-spec} are
to be child units of the specified parent unit.
The GNAT model of compilation is close to the C and C++ models. You can
think of Ada specs as corresponding to header files in C. As in C, you
don’t need to compile specs; they are compiled when they are used. The
-Ada @emph{with} is similar in effect to the @code{#include} of a C
+Ada `with' is similar in effect to the @code{#include} of a C
header.
One notable difference is that, in Ada, you may compile specs separately
@itemize *
@item
-When a unit is @emph{with}ed, the unit seen by the compiler corresponds
+When a unit is `with'ed, the unit seen by the compiler corresponds
to the version of the unit most recently compiled into the library.
@item
@itemize *
@item
-When a unit is @emph{with}ed, the unit seen by the compiler corresponds
+When a unit is `with'ed, the unit seen by the compiler corresponds
to the source version of the unit that is currently accessible to the
compiler.
@code{gnatmake}.
Note that for advanced forms of project structure, we recommend creating
-a project file as explained in the @emph{GNAT_Project_Manager} chapter in the
-@emph{GPRbuild User’s Guide}, and using the
+a project file as explained in the `GNAT_Project_Manager' chapter in the
+`GPRbuild User’s Guide', and using the
@code{gprbuild} tool which supports building with project files and works similarly
to @code{gnatmake}.
@table @asis
-@item @code{-P@emph{project}}
+@item @code{-P`project'}
Build GNAT project file @code{project} using GPRbuild. When this switch is
present, all other command-line switches are treated as GPRbuild switches
@table @asis
-@item @code{--GCC=@emph{compiler_name}}
+@item @code{--GCC=`compiler_name'}
Program used for compiling. The default is @code{gcc}. You need to use
quotes around @code{compiler_name} if @code{compiler_name} contains
@table @asis
-@item @code{--GNATBIND=@emph{binder_name}}
+@item @code{--GNATBIND=`binder_name'}
Program used for binding. The default is @code{gnatbind}. You need to
use quotes around @code{binder_name} if @code{binder_name} contains spaces
@table @asis
-@item @code{--GNATLINK=@emph{linker_name}}
+@item @code{--GNATLINK=`linker_name'}
Program used for linking. The default is @code{gnatlink}. You need to
use quotes around @code{linker_name} if @code{linker_name} contains spaces
When linking an executable, create a map file. The name of the map file
has the same name as the executable with extension “.map”.
-@item @code{--create-map-file=@emph{mapfile}}
+@item @code{--create-map-file=`mapfile'}
When linking an executable, create a map file with the specified name.
@end table
@item @code{--create-missing-dirs}
-When using project files (@code{-P@emph{project}}), automatically create
+When using project files (@code{-P`project'}), automatically create
missing object directories, library directories and exec
directories.
Disallow simultaneous compilations in the same object directory when
project files are used.
-@item @code{--subdirs=@emph{subdir}}
+@item @code{--subdirs=`subdir'}
Actual object directory of each project file is the subdirectory subdir of the
object directory specified or defaulted in the project file.
projects. When this switch is used on the command line, this restriction is
relaxed.
-@item @code{--source-info=@emph{source info file}}
+@item @code{--source-info=`source info file'}
Specify a source info file. This switch is active only when project files
are used. If the source info file is specified as a relative path, then it is
@table @asis
-@item @code{-C=@emph{file}}
+@item @code{-C=`file'}
Use a specific mapping file. The file, specified as a path name (absolute or
relative) by this switch, should already exist, otherwise the switch is
@table @asis
-@item @code{-D @emph{dir}}
+@item @code{-D `dir'}
Put all object files and ALI file in directory @code{dir}.
If the @code{-D} switch is not used, all object files
@table @asis
-@item @code{-eI@emph{nnn}}
+@item @code{-eI`nnn'}
Indicates that the main source is a multi-unit source and the rank of the unit
in the source file is nnn. nnn needs to be a positive number and a valid
@table @asis
-@item @code{-j@emph{n}}
+@item @code{-j`n'}
Use @code{n} processes to carry out the (re)compilations. On a multiprocessor
machine compilations will occur in parallel. If @code{n} is 0, then the
the @code{-a} switch,
dependencies of the GNAT internal files are also listed. Note that
dependencies of the objects in external Ada libraries (see
-switch @code{-aL@emph{dir}} in the following list)
+switch @code{-aL`dir'} in the following list)
are never reported.
@end table
@table @asis
-@item @code{-o @emph{exec_name}}
+@item @code{-o `exec_name'}
Output executable name. The name of the final executable program will be
@code{exec_name}. If the @code{-o} switch is omitted the default
Verbosity level High. Equivalent to -v.
-@item @code{-vP@emph{x}}
+@item @code{-vP`x'}
Indicate the verbosity of the parsing of GNAT project files.
See @ref{d1,,Switches Related to Project Files}.
@code{-x} is used, mains specified on the
command line need to be sources of a project file.
-@item @code{-X@emph{name}=@emph{value}}
+@item @code{-X`name'=`value'}
Indicate that external variable @code{name} has the value @code{value}.
The Project Manager will use this value for occurrences of
@table @asis
-@item @code{-aI@emph{dir}}
+@item @code{-aI`dir'}
When looking for source files also look in directory @code{dir}.
The order in which source files search is undertaken is
@table @asis
-@item @code{-aL@emph{dir}}
+@item @code{-aL`dir'}
Consider @code{dir} as being an externally provided Ada library.
Instructs @code{gnatmake} to skip compilation units whose @code{.ALI}
missing bodies for the units in @code{dir} and to ignore out of date bodies
for the same units. You still need to specify
the location of the specs for these units by using the switches
-@code{-aI@emph{dir}} or @code{-I@emph{dir}}.
+@code{-aI`dir'} or @code{-I`dir'}.
Note: this switch is provided for compatibility with previous versions
of @code{gnatmake}. The easier method of causing standard libraries
to be excluded from consideration is to write-protect the corresponding
@table @asis
-@item @code{-aO@emph{dir}}
+@item @code{-aO`dir'}
When searching for library and object files, look in directory
@code{dir}. The order in which library files are searched is described in
@table @asis
-@item @code{-A@emph{dir}}
+@item @code{-A`dir'}
-Equivalent to @code{-aL@emph{dir}} @code{-aI@emph{dir}}.
+Equivalent to @code{-aL`dir'} @code{-aI`dir'}.
@geindex -I (gnatmake)
-@item @code{-I@emph{dir}}
+@item @code{-I`dir'}
-Equivalent to @code{-aO@emph{dir} -aI@emph{dir}}.
+Equivalent to @code{-aO`dir' -aI`dir'}.
@end table
@geindex -I- (gnatmake)
@table @asis
-@item @code{-L@emph{dir}}
+@item @code{-L`dir'}
Add directory @code{dir} to the list of directories in which the linker
will search for libraries. This is equivalent to
-@code{-largs} @code{-L@emph{dir}}.
+@code{-largs} @code{-L`dir'}.
Furthermore, under Windows, the sources pointed to by the libraries path
set in the registry are not searched for.
@end table
@table @asis
-@item @code{--RTS=@emph{rts-path}}
+@item @code{--RTS=`rts-path'}
Specifies the default location of the run-time library. GNAT looks for the
run-time
@itemize *
@item
-@emph{<current directory>/$rts_path}
+`<current directory>/$rts_path'
@item
-@emph{<default-search-dir>/$rts_path}
+`<default-search-dir>/$rts_path'
@item
-@emph{<default-search-dir>/rts-$rts_path}
+`<default-search-dir>/rts-$rts_path'
@item
The selected path is handled like a normal RTS path.
@table @asis
-@item @code{-cargs @emph{switches}}
+@item @code{-cargs `switches'}
Compiler switches. Here @code{switches} is a list of switches
that are valid switches for @code{gcc}. They will be passed on to
@table @asis
-@item @code{-bargs @emph{switches}}
+@item @code{-bargs `switches'}
Binder switches. Here @code{switches} is a list of switches
that are valid switches for @code{gnatbind}. They will be passed on to
@table @asis
-@item @code{-largs @emph{switches}}
+@item @code{-largs `switches'}
Linker switches. Here @code{switches} is a list of switches
that are valid switches for @code{gnatlink}. They will be passed on to
@table @asis
-@item @code{-margs @emph{switches}}
+@item @code{-margs `switches'}
Make switches. The switches are directly interpreted by @code{gnatmake},
regardless of any previous occurrence of @code{-cargs}, @code{-bargs}
@item
@code{gnatmake} has been designed to make the use of Ada libraries
particularly convenient. Assume you have an Ada library organized
-as follows: @emph{obj-dir} contains the objects and ALI files for
+as follows: `obj-dir' contains the objects and ALI files for
of your Ada compilation units,
-whereas @emph{include-dir} contains the
+whereas `include-dir' contains the
specs of these units, but no bodies. Then to compile a unit
stored in @code{main.adb}, which uses this Ada library you would just type:
approach and in particular to understand how it uses the results of
previous compilations without incorrectly depending on them.
-First a definition: an object file is considered @emph{up to date} if the
+First a definition: an object file is considered `up to date' if the
corresponding ALI file exists and if all the source files listed in the
dependency section of this ALI file have time stamps matching those in
the ALI file. This means that neither the source file itself nor any
or generic package that has a body
@end itemize
-You need @emph{not} compile the following files
+You need `not' compile the following files
@itemize *
@item
When you compile a unit, the source files for the specs of all units
-that it @emph{with}s, all its subunits, and the bodies of any generics it
+that it `with's, all its subunits, and the bodies of any generics it
instantiates must be available (reachable by the search-paths mechanism
described above), or you will receive a fatal error message.
@end itemize
@table @asis
-@item @code{-b @emph{target}}
+@item @code{-b `target'}
Compile your program to run on @code{target}, which is the name of a
system configuration. You must have a GNAT cross-compiler built if
@table @asis
-@item @code{-B@emph{dir}}
+@item @code{-B`dir'}
Load compiler executables (for example, @code{gnat1}, the Ada compiler)
from @code{dir} instead of the default location. Only use this switch
@table @asis
-@item @code{-flto[=@emph{n}]}
+@item @code{-flto[=`n']}
Enables Link Time Optimization. This switch must be used in conjunction
with the @code{-Ox} switches (but not with the @code{-gnatn} switch
@table @asis
-@item @code{-gnatec=@emph{path}}
+@item @code{-gnatec=`path'}
Specify a configuration pragma file
(the equal sign is optional)
@table @asis
-@item @code{-gnateDsymbol[=@emph{value}]}
+@item @code{-gnateDsymbol[=`value']}
Defines a symbol, associated with @code{value}, for preprocessing.
(@ref{91,,Integrated Preprocessing}).
@table @asis
-@item @code{-gnatei@emph{nnn}}
+@item @code{-gnatei`nnn'}
Set maximum number of instantiations during compilation of a single unit to
@code{nnn}. This may be useful in increasing the default maximum of 8000 for
@table @asis
-@item @code{-gnateI@emph{nnn}}
+@item @code{-gnateI`nnn'}
Indicates that the source is a multi-unit source and that the index of the
unit to compile is @code{nnn}. @code{nnn} needs to be a positive number and need
@table @asis
-@item @code{-gnatem=@emph{path}}
+@item @code{-gnatem=`path'}
Specify a mapping file
(the equal sign is optional)
@table @asis
-@item @code{-gnatep=@emph{file}}
+@item @code{-gnatep=`file'}
Specify a preprocessing data file
(the equal sign is optional)
@table @asis
-@item @code{-gnatet=@emph{path}}
+@item @code{-gnatet=`path'}
Generate target dependent information. The format of the output file is
described in the section about switch @code{-gnateT}.
@table @asis
-@item @code{-gnateT=@emph{path}}
+@item @code{-gnateT=`path'}
Read target dependent information, such as endianness or sizes and alignments
of base type. If this switch is passed, the default target dependent
@table @asis
-@item @code{-gnati@emph{c}}
+@item @code{-gnati`c'}
Identifier character set (@code{c} = 1/2/3/4/5/9/p/8/f/n/w).
For details of the possible selections for @code{c},
@table @asis
-@item @code{-gnatj@emph{nn}}
+@item @code{-gnatj`nn'}
Reformat error messages to fit on @code{nn} character lines
@end table
@table @asis
-@item @code{-gnatk=@emph{n}}
+@item @code{-gnatk=`n'}
Limit file names to @code{n} (1-999) characters (@code{k} = krunch).
@end table
@table @asis
-@item @code{-gnatm=@emph{n}}
+@item @code{-gnatm=`n'}
Limit number of detected error or warning messages to @code{n}
where @code{n} is in the range 1..999999. The default setting if
@item
-@emph{1}
+`1'
@tab
@item
-@emph{2}
+`2'
@tab
@item
-@emph{3}
+`3'
@tab
@table @asis
-@item @code{-gnatT@emph{nnn}}
+@item @code{-gnatT`nnn'}
All compiler tables start at @code{nnn} times usual starting size.
@end table
@table @asis
-@item @code{-gnatw@emph{xxx}}
+@item @code{-gnatw`xxx'}
Warning mode where
@code{xxx} is a string of option letters that denotes
@table @asis
-@item @code{-gnatW@emph{e}}
+@item @code{-gnatW`e'}
Wide character encoding method
(@code{e}=n/h/u/s/e/8).
@table @asis
-@item @code{-gnatz@emph{m}}
+@item @code{-gnatz`m'}
Distribution stub generation and compilation
(@code{m}=r/c for receiver/caller stubs).
@table @asis
-@item @code{-I@emph{dir}}
+@item @code{-I`dir'}
@geindex RTL
@table @asis
-@item @code{-o @emph{file}}
+@item @code{-o `file'}
This switch is used in @code{gcc} to redirect the generated object file
and its associated ALI file. Beware of this switch with GNAT, because it may
@table @asis
-@item @code{-O[@emph{n}]}
+@item @code{-O[`n']}
@code{n} controls the optimization level:
@multitable {xxxxxxxxx} {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}
@item
-@emph{n}
+`n'
@tab
@item
-@emph{0}
+`0'
@tab
@item
-@emph{1}
+`1'
@tab
@item
-@emph{2}
+`2'
@tab
@item
-@emph{3}
+`3'
@tab
@item
-@emph{s}
+`s'
@tab
@table @asis
-@item @code{--RTS=@emph{rts-path}}
+@item @code{--RTS=`rts-path'}
Specifies the default location of the run-time library. Same meaning as the
equivalent @code{gnatmake} flag (@ref{d0,,Switches for gnatmake}).
@table @asis
-@item @code{-V @emph{ver}}
+@item @code{-V `ver'}
Execute @code{ver} version of the compiler. This is the @code{gcc}
version, not the GNAT version.
@table @asis
-@item @code{-gnatl=@emph{fname}}
+@item @code{-gnatl=`fname'}
This has the same effect as @code{-gnatl} except that the output is
written to a file instead of to standard output. If the given name
@table @asis
-@item @code{-gnatm=@emph{n}}
+@item @code{-gnatm=`n'}
The @code{m} stands for maximum.
@code{n} is a decimal integer in the
Violations of style rules if style checking is enabled
@item
-Unused @emph{with} clauses
+Unused `with' clauses
@item
@code{Bit_Order} usage that does not have any effect
Declaration that is likely to cause storage error
@item
-Internal GNAT unit @emph{with}ed by application unit
+Internal GNAT unit `with'ed by application unit
@item
Values known to be out of range at compile time
@item @code{-gnatwa}
-@emph{Activate most optional warnings.}
+`Activate most optional warnings.'
This switch activates most optional warning messages. See the remaining list
in this section for details on optional warning messages that can be
@item @code{-gnatwA}
-@emph{Suppress all optional errors.}
+`Suppress all optional errors.'
This switch suppresses all optional warning messages, see remaining list
in this section for details on optional warning messages that can be
@item @code{-gnatw.a}
-@emph{Activate warnings on failing assertions.}
+`Activate warnings on failing assertions.'
@geindex Assert failures
@item @code{-gnatw.A}
-@emph{Suppress warnings on failing assertions.}
+`Suppress warnings on failing assertions.'
@geindex Assert failures
@item @code{-gnatw_a}
-@emph{Activate warnings on anonymous allocators.}
+`Activate warnings on anonymous allocators.'
@geindex Anonymous allocators
@item @code{-gnatw_A}
-@emph{Suppress warnings on anonymous allocators.}
+`Suppress warnings on anonymous allocators.'
@geindex Anonymous allocators
@item @code{-gnatwb}
-@emph{Activate warnings on bad fixed values.}
+`Activate warnings on bad fixed values.'
@geindex Bad fixed values
@item @code{-gnatwB}
-@emph{Suppress warnings on bad fixed values.}
+`Suppress warnings on bad fixed values.'
This switch suppresses warnings for static fixed-point expressions whose
value is not an exact multiple of Small.
@item @code{-gnatw.b}
-@emph{Activate warnings on biased representation.}
+`Activate warnings on biased representation.'
@geindex Biased representation
@item @code{-gnatw.B}
-@emph{Suppress warnings on biased representation.}
+`Suppress warnings on biased representation.'
This switch suppresses warnings for representation clauses that force the use
of biased representation.
@item @code{-gnatwc}
-@emph{Activate warnings on conditionals.}
+`Activate warnings on conditionals.'
@geindex Conditionals
@geindex constant
@item @code{-gnatwC}
-@emph{Suppress warnings on conditionals.}
+`Suppress warnings on conditionals.'
This switch suppresses warnings for conditional expressions used in
tests that are known to be True or False at compile time.
@item @code{-gnatw.c}
-@emph{Activate warnings on missing component clauses.}
+`Activate warnings on missing component clauses.'
@geindex Component clause
@geindex missing
@item @code{-gnatw.C}
-@emph{Suppress warnings on missing component clauses.}
+`Suppress warnings on missing component clauses.'
This switch suppresses warnings for record components that are
missing a component clause in the situation described above.
@item @code{-gnatw_c}
-@emph{Activate warnings on unknown condition in Compile_Time_Warning.}
+`Activate warnings on unknown condition in Compile_Time_Warning.'
@geindex Compile_Time_Warning
@item @code{-gnatw_C}
-@emph{Suppress warnings on unknown condition in Compile_Time_Warning.}
+`Suppress warnings on unknown condition in Compile_Time_Warning.'
This switch suppresses warnings on a pragma Compile_Time_Warning
or Compile_Time_Error whose condition has a value that is not
@item @code{-gnatwd}
-@emph{Activate warnings on implicit dereferencing.}
+`Activate warnings on implicit dereferencing.'
If this switch is set, then the use of a prefix of an access type
in an indexed component, slice, or selected component without an
@item @code{-gnatwD}
-@emph{Suppress warnings on implicit dereferencing.}
+`Suppress warnings on implicit dereferencing.'
@geindex Implicit dereferencing
@item @code{-gnatw.d}
-@emph{Activate tagging of warning and info messages.}
+`Activate tagging of warning and info messages.'
If this switch is set, then warning messages are tagged, with one of the
following strings:
@itemize -
@item
-@emph{[-gnatw?]}
+`[-gnatw?]'
Used to tag warnings controlled by the switch @code{-gnatwx} where x
is a letter a-z.
@item
-@emph{[-gnatw.?]}
+`[-gnatw.?]'
Used to tag warnings controlled by the switch @code{-gnatw.x} where x
is a letter a-z.
@item
-@emph{[-gnatel]}
+`[-gnatel]'
Used to tag elaboration information (info) messages generated when the
static model of elaboration is used and the @code{-gnatel} switch is set.
@item
-@emph{[restriction warning]}
+`[restriction warning]'
Used to tag warning messages for restriction violations, activated by use
of the pragma @code{Restriction_Warnings}.
@item
-@emph{[warning-as-error]}
+`[warning-as-error]'
Used to tag warning messages that have been converted to error messages by
use of the pragma Warning_As_Error. Note that such warnings are prefixed by
-the string â\80\9cerror: â\80\9c rather than “warning: “.
+the string â\80\9cerror: â\80\9d rather than “warning: “.
@item
-@emph{[enabled by default]}
+`[enabled by default]'
Used to tag all other warnings that are always given by default, unless
-warnings are completely suppressed using pragma @emph{Warnings(Off)} or
+warnings are completely suppressed using pragma `Warnings(Off)' or
the switch @code{-gnatws}.
@end itemize
@end quotation
@item @code{-gnatw.D}
-@emph{Deactivate tagging of warning and info messages messages.}
+`Deactivate tagging of warning and info messages messages.'
If this switch is set, then warning messages return to the default
mode in which warnings and info messages are not tagged as described above for
@item @code{-gnatwe}
-@emph{Treat warnings and style checks as errors.}
+`Treat warnings and style checks as errors.'
This switch causes warning messages and style check messages to be
treated as errors.
@item @code{-gnatw.e}
-@emph{Activate every optional warning.}
+`Activate every optional warning.'
@geindex Warnings
@geindex activate every optional warning
@item @code{-gnatwE}
-@emph{Treat all run-time exception warnings as errors.}
+`Treat all run-time exception warnings as errors.'
This switch causes warning messages regarding errors that will be raised
during run-time execution to be treated as errors.
@item @code{-gnatwf}
-@emph{Activate warnings on unreferenced formals.}
+`Activate warnings on unreferenced formals.'
@geindex Formals
@geindex unreferenced
@item @code{-gnatwF}
-@emph{Suppress warnings on unreferenced formals.}
+`Suppress warnings on unreferenced formals.'
This switch suppresses warnings for unreferenced formal
parameters. Note that the
@item @code{-gnatwg}
-@emph{Activate warnings on unrecognized pragmas.}
+`Activate warnings on unrecognized pragmas.'
@geindex Pragmas
@geindex unrecognized
@item @code{-gnatwG}
-@emph{Suppress warnings on unrecognized pragmas.}
+`Suppress warnings on unrecognized pragmas.'
This switch suppresses warnings for unrecognized pragmas.
@end table
@item @code{-gnatw.g}
-@emph{Warnings used for GNAT sources.}
+`Warnings used for GNAT sources.'
This switch sets the warning categories that are used by the standard
GNAT style. Currently this is equivalent to
@item @code{-gnatwh}
-@emph{Activate warnings on hiding.}
+`Activate warnings on hiding.'
@geindex Hiding of Declarations
@item @code{-gnatwH}
-@emph{Suppress warnings on hiding.}
+`Suppress warnings on hiding.'
This switch suppresses warnings on hiding declarations.
@end table
@item @code{-gnatw.h}
-@emph{Activate warnings on holes/gaps in records.}
+`Activate warnings on holes/gaps in records.'
@geindex Record Representation (gaps)
@item @code{-gnatw.H}
-@emph{Suppress warnings on holes/gaps in records.}
+`Suppress warnings on holes/gaps in records.'
This switch suppresses warnings on component clauses in record
representation clauses that leave holes (haps) in the record layout.
@item @code{-gnatwi}
-@emph{Activate warnings on implementation units.}
+`Activate warnings on implementation units.'
-This switch activates warnings for a @emph{with} of an internal GNAT
+This switch activates warnings for a `with' of an internal GNAT
implementation unit, defined as any unit from the @code{Ada},
@code{Interfaces}, @code{GNAT},
or @code{System}
hierarchies that is not
documented in either the Ada Reference Manual or the GNAT
Programmer’s Reference Manual. Such units are intended only
-for internal implementation purposes and should not be @emph{with}ed
+for internal implementation purposes and should not be `with'ed
by user programs. The default is that such warnings are generated
@end table
@item @code{-gnatwI}
-@emph{Disable warnings on implementation units.}
+`Disable warnings on implementation units.'
-This switch disables warnings for a @emph{with} of an internal GNAT
+This switch disables warnings for a `with' of an internal GNAT
implementation unit.
@end table
@item @code{-gnatw.i}
-@emph{Activate warnings on overlapping actuals.}
+`Activate warnings on overlapping actuals.'
This switch enables a warning on statically detectable overlapping actuals in
a subprogram call, when one of the actuals is an in-out parameter, and the
@item @code{-gnatw.I}
-@emph{Disable warnings on overlapping actuals.}
+`Disable warnings on overlapping actuals.'
This switch disables warnings on overlapping actuals in a call.
@end table
@item @code{-gnatwj}
-@emph{Activate warnings on obsolescent features (Annex J).}
+`Activate warnings on obsolescent features (Annex J).'
@geindex Features
@geindex obsolescent
@item @code{-gnatwJ}
-@emph{Suppress warnings on obsolescent features (Annex J).}
+`Suppress warnings on obsolescent features (Annex J).'
This switch disables warnings on use of obsolescent features.
@end table
@item @code{-gnatw.j}
-@emph{Activate warnings on late declarations of tagged type primitives.}
+`Activate warnings on late declarations of tagged type primitives.'
This switch activates warnings on visible primitives added to a
tagged type after deriving a private extension from it.
@item @code{-gnatw.J}
-@emph{Suppress warnings on late declarations of tagged type primitives.}
+`Suppress warnings on late declarations of tagged type primitives.'
This switch suppresses warnings on visible primitives added to a
tagged type after deriving a private extension from it.
@item @code{-gnatwk}
-@emph{Activate warnings on variables that could be constants.}
+`Activate warnings on variables that could be constants.'
This switch activates warnings for variables that are initialized but
never modified, and then could be declared constants. The default is that
@item @code{-gnatwK}
-@emph{Suppress warnings on variables that could be constants.}
+`Suppress warnings on variables that could be constants.'
This switch disables warnings on variables that could be declared constants.
@end table
@item @code{-gnatw.k}
-@emph{Activate warnings on redefinition of names in standard.}
+`Activate warnings on redefinition of names in standard.'
This switch activates warnings for declarations that declare a name that
is defined in package Standard. Such declarations can be confusing,
@item @code{-gnatw.K}
-@emph{Suppress warnings on redefinition of names in standard.}
+`Suppress warnings on redefinition of names in standard.'
This switch disables warnings for declarations that declare a name that
is defined in package Standard.
@item @code{-gnatwl}
-@emph{Activate warnings for elaboration pragmas.}
+`Activate warnings for elaboration pragmas.'
@geindex Elaboration
@geindex warnings
@item @code{-gnatwL}
-@emph{Suppress warnings for elaboration pragmas.}
+`Suppress warnings for elaboration pragmas.'
This switch suppresses warnings for possible elaboration problems.
@end table
@item @code{-gnatw.l}
-@emph{List inherited aspects.}
+`List inherited aspects.'
This switch causes the compiler to list inherited invariants,
preconditions, and postconditions from Type_Invariant’Class, Invariant’Class,
@item @code{-gnatw.L}
-@emph{Suppress listing of inherited aspects.}
+`Suppress listing of inherited aspects.'
This switch suppresses listing of inherited aspects.
@end table
@item @code{-gnatwm}
-@emph{Activate warnings on modified but unreferenced variables.}
+`Activate warnings on modified but unreferenced variables.'
This switch activates warnings for variables that are assigned (using
an initialization value or with one or more assignment statements) but
@item @code{-gnatwM}
-@emph{Disable warnings on modified but unreferenced variables.}
+`Disable warnings on modified but unreferenced variables.'
This switch disables warnings for variables that are assigned or
initialized, but never read.
@item @code{-gnatw.m}
-@emph{Activate warnings on suspicious modulus values.}
+`Activate warnings on suspicious modulus values.'
This switch activates warnings for modulus values that seem suspicious.
The cases caught are where the size is the same as the modulus (e.g.
@item @code{-gnatw.M}
-@emph{Disable warnings on suspicious modulus values.}
+`Disable warnings on suspicious modulus values.'
This switch disables warnings for suspicious modulus values.
@end table
@item @code{-gnatwn}
-@emph{Set normal warnings mode.}
+`Set normal warnings mode.'
This switch sets normal warning mode, in which enabled warnings are
issued and treated as warnings rather than errors. This is the default
@item @code{-gnatw.n}
-@emph{Activate warnings on atomic synchronization.}
+`Activate warnings on atomic synchronization.'
This switch actives warnings when an access to an atomic variable
requires the generation of atomic synchronization code. These
@item @code{-gnatw.N}
-@emph{Suppress warnings on atomic synchronization.}
+`Suppress warnings on atomic synchronization.'
@geindex Atomic Synchronization
@geindex warnings
@item @code{-gnatwo}
-@emph{Activate warnings on address clause overlays.}
+`Activate warnings on address clause overlays.'
This switch activates warnings for possibly unintended initialization
effects of defining address clauses that cause one variable to overlap
@item @code{-gnatwO}
-@emph{Suppress warnings on address clause overlays.}
+`Suppress warnings on address clause overlays.'
This switch suppresses warnings on possibly unintended initialization
effects of defining address clauses that cause one variable to overlap
@item @code{-gnatw.o}
-@emph{Activate warnings on modified but unreferenced out parameters.}
+`Activate warnings on modified but unreferenced out parameters.'
This switch activates warnings for variables that are modified by using
them as actuals for a call to a procedure with an out mode formal, where
@item @code{-gnatw.O}
-@emph{Disable warnings on modified but unreferenced out parameters.}
+`Disable warnings on modified but unreferenced out parameters.'
This switch suppresses warnings for variables that are modified by using
them as actuals for a call to a procedure with an out mode formal, where
@item @code{-gnatwp}
-@emph{Activate warnings on ineffective pragma Inlines.}
+`Activate warnings on ineffective pragma Inlines.'
This switch activates warnings for failure of front end inlining
(activated by @code{-gnatN}) to inline a particular call. There are
@item @code{-gnatwP}
-@emph{Suppress warnings on ineffective pragma Inlines.}
+`Suppress warnings on ineffective pragma Inlines.'
This switch suppresses warnings on ineffective pragma Inlines. If the
inlining mechanism cannot inline a call, it will simply ignore the
@item @code{-gnatw.p}
-@emph{Activate warnings on parameter ordering.}
+`Activate warnings on parameter ordering.'
This switch activates warnings for cases of suspicious parameter
ordering when the list of arguments are all simple identifiers that
@item @code{-gnatw.P}
-@emph{Suppress warnings on parameter ordering.}
+`Suppress warnings on parameter ordering.'
This switch suppresses warnings on cases of suspicious parameter
ordering.
@item @code{-gnatw_p}
-@emph{Activate warnings for pedantic checks.}
+`Activate warnings for pedantic checks.'
This switch activates warnings for the failure of certain pedantic checks.
The only case currently supported is a check that the subtype_marks given
@item @code{-gnatw_P}
-@emph{Suppress warnings for pedantic checks.}
+`Suppress warnings for pedantic checks.'
This switch suppresses warnings on violations of pedantic checks.
@end table
@item @code{-gnatwq}
-@emph{Activate warnings on questionable missing parentheses.}
+`Activate warnings on questionable missing parentheses.'
This switch activates warnings for cases where parentheses are not used and
the result is potential ambiguity from a readers point of view. For example
@item @code{-gnatwQ}
-@emph{Suppress warnings on questionable missing parentheses.}
+`Suppress warnings on questionable missing parentheses.'
This switch suppresses warnings for cases where the association is not
clear and the use of parentheses is preferred.
@item @code{-gnatw.q}
-@emph{Activate warnings on questionable layout of record types.}
+`Activate warnings on questionable layout of record types.'
This switch activates warnings for cases where the default layout of
a record type, that is to say the layout of its components in textual
@item @code{-gnatw.Q}
-@emph{Suppress warnings on questionable layout of record types.}
+`Suppress warnings on questionable layout of record types.'
This switch suppresses warnings for cases where the default layout of
a record type would very likely cause inefficiencies.
@item @code{-gnatw_q}
-@emph{Activate warnings for ignored equality operators.}
+`Activate warnings for ignored equality operators.'
This switch activates warnings for a user-defined “=” function that does
not compose (i.e. is ignored for a predefined “=” for a composite type
@item @code{-gnatw_Q}
-@emph{Suppress warnings for ignored equality operators.}
+`Suppress warnings for ignored equality operators.'
@end table
@geindex -gnatwr (gcc)
@item @code{-gnatwr}
-@emph{Activate warnings on redundant constructs.}
+`Activate warnings on redundant constructs.'
This switch activates warnings for redundant constructs. The following
is the current list of constructs regarded as redundant:
@item @code{-gnatwR}
-@emph{Suppress warnings on redundant constructs.}
+`Suppress warnings on redundant constructs.'
This switch suppresses warnings for redundant constructs.
@end table
@item @code{-gnatw.r}
-@emph{Activate warnings for object renaming function.}
+`Activate warnings for object renaming function.'
This switch activates warnings for an object renaming that renames a
function call, which is equivalent to a constant declaration (as
@item @code{-gnatw.R}
-@emph{Suppress warnings for object renaming function.}
+`Suppress warnings for object renaming function.'
This switch suppresses warnings for object renaming function.
@end table
@item @code{-gnatw_r}
-@emph{Activate warnings for out-of-order record representation clauses.}
+`Activate warnings for out-of-order record representation clauses.'
This switch activates warnings for record representation clauses,
if the order of component declarations, component clauses,
@item @code{-gnatw_R}
-@emph{Suppress warnings for out-of-order record representation clauses.}
+`Suppress warnings for out-of-order record representation clauses.'
@end table
@geindex -gnatws (gcc)
@item @code{-gnatws}
-@emph{Suppress all warnings.}
+`Suppress all warnings.'
This switch completely suppresses the
output of all warning messages from the GNAT front end, including
@item @code{-gnatw.s}
-@emph{Activate warnings on overridden size clauses.}
+`Activate warnings on overridden size clauses.'
This switch activates warnings on component clauses in record
representation clauses where the length given overrides that
@item @code{-gnatw.S}
-@emph{Suppress warnings on overridden size clauses.}
+`Suppress warnings on overridden size clauses.'
This switch suppresses warnings on component clauses in record
representation clauses that override size clauses, and similar
@item @code{-gnatw_s}
-@emph{Activate warnings on ineffective predicate tests.}
+`Activate warnings on ineffective predicate tests.'
This switch activates warnings on Static_Predicate aspect
specifications that test for values that do not belong to
@item @code{-gnatw_S}
-@emph{Suppress warnings on ineffective predicate tests.}
+`Suppress warnings on ineffective predicate tests.'
This switch suppresses warnings on Static_Predicate aspect
specifications that test for values that do not belong to
@item @code{-gnatwt}
-@emph{Activate warnings for tracking of deleted conditional code.}
+`Activate warnings for tracking of deleted conditional code.'
This switch activates warnings for tracking of code in conditionals (IF and
CASE statements) that is detected to be dead code which cannot be executed, and
@item @code{-gnatwT}
-@emph{Suppress warnings for tracking of deleted conditional code.}
+`Suppress warnings for tracking of deleted conditional code.'
This switch suppresses warnings for tracking of deleted conditional code.
@end table
@item @code{-gnatw.t}
-@emph{Activate warnings on suspicious contracts.}
+`Activate warnings on suspicious contracts.'
This switch activates warnings on suspicious contracts. This includes
warnings on suspicious postconditions (whether a pragma @code{Postcondition} or a
@item @code{-gnatw.T}
-@emph{Suppress warnings on suspicious contracts.}
+`Suppress warnings on suspicious contracts.'
This switch suppresses warnings on suspicious contracts.
@end table
@item @code{-gnatwu}
-@emph{Activate warnings on unused entities.}
+`Activate warnings on unused entities.'
This switch activates warnings to be generated for entities that
-are declared but not referenced, and for units that are @emph{with}ed
+are declared but not referenced, and for units that are `with'ed
and not
referenced. In the case of packages, a warning is also generated if
no entities in the package are referenced. This means that if a with’ed
package is referenced but the only references are in @code{use}
clauses or @code{renames}
declarations, a warning is still generated. A warning is also generated
-for a generic package that is @emph{with}ed but never instantiated.
+for a generic package that is `with'ed but never instantiated.
In the case where a package or subprogram body is compiled, and there
-is a @emph{with} on the corresponding spec
+is a `with' on the corresponding spec
that is only referenced in the body,
a warning is also generated, noting that the
-@emph{with} can be moved to the body. The default is that
+`with' can be moved to the body. The default is that
such warnings are not generated.
This switch also activates warnings on unreferenced formals
(it includes the effect of @code{-gnatwf}).
@item @code{-gnatwU}
-@emph{Suppress warnings on unused entities.}
+`Suppress warnings on unused entities.'
This switch suppresses warnings for unused entities and packages.
It also turns off warnings on unreferenced formals (and thus includes
@item @code{-gnatw.u}
-@emph{Activate warnings on unordered enumeration types.}
+`Activate warnings on unordered enumeration types.'
This switch causes enumeration types to be considered as conceptually
unordered, unless an explicit pragma @code{Ordered} is given for the type.
The effect is to generate warnings in clients that use explicit comparisons
or subranges, since these constructs both treat objects of the type as
-ordered. (A @emph{client} is defined as a unit that is other than the unit in
+ordered. (A `client' is defined as a unit that is other than the unit in
which the type is declared, or its body or subunits.) Please refer to
the description of pragma @code{Ordered} in the
@cite{GNAT Reference Manual} for further details.
@item @code{-gnatw.U}
-@emph{Deactivate warnings on unordered enumeration types.}
+`Deactivate warnings on unordered enumeration types.'
This switch causes all enumeration types to be considered as ordered, so
that no warnings are given for comparisons or subranges for any type.
@item @code{-gnatwv}
-@emph{Activate warnings on unassigned variables.}
+`Activate warnings on unassigned variables.'
This switch activates warnings for access to variables which
may not be properly initialized. The default is that
@item @code{-gnatwV}
-@emph{Suppress warnings on unassigned variables.}
+`Suppress warnings on unassigned variables.'
This switch suppresses warnings for access to variables which
may not be properly initialized.
@item @code{-gnatw.v}
-@emph{Activate info messages for non-default bit order.}
+`Activate info messages for non-default bit order.'
This switch activates messages (labeled “info”, they are not warnings,
just informational messages) about the effects of non-default bit-order
@item @code{-gnatw.V}
-@emph{Suppress info messages for non-default bit order.}
+`Suppress info messages for non-default bit order.'
This switch suppresses information messages for the effects of specifying
non-default bit order on record components with component clauses.
@item @code{-gnatww}
-@emph{Activate warnings on wrong low bound assumption.}
+`Activate warnings on wrong low bound assumption.'
This switch activates warnings for indexing an unconstrained string parameter
with a literal or S’Length. This is a case where the code is assuming that the
@item @code{-gnatwW}
-@emph{Suppress warnings on wrong low bound assumption.}
+`Suppress warnings on wrong low bound assumption.'
This switch suppresses warnings for indexing an unconstrained string parameter
with a literal or S’Length. Note that this warning can also be suppressed
@item @code{-gnatw.w}
-@emph{Activate warnings on Warnings Off pragmas.}
+`Activate warnings on Warnings Off pragmas.'
This switch activates warnings for use of @code{pragma Warnings (Off, entity)}
where either the pragma is entirely useless (because it suppresses no
@item @code{-gnatw.W}
-@emph{Suppress warnings on unnecessary Warnings Off pragmas.}
+`Suppress warnings on unnecessary Warnings Off pragmas.'
This switch suppresses warnings for use of @code{pragma Warnings (Off, ...)}.
@end table
@item @code{-gnatwx}
-@emph{Activate warnings on Export/Import pragmas.}
+`Activate warnings on Export/Import pragmas.'
This switch activates warnings on Export/Import pragmas when
the compiler detects a possible conflict between the Ada and
@item @code{-gnatwX}
-@emph{Suppress warnings on Export/Import pragmas.}
+`Suppress warnings on Export/Import pragmas.'
This switch suppresses warnings on Export/Import pragmas.
The sense of this is that you are telling the compiler that
@item @code{-gnatw.x}
-@emph{Activate warnings for No_Exception_Propagation mode.}
+`Activate warnings for No_Exception_Propagation mode.'
This switch activates warnings for exception usage when pragma Restrictions
(No_Exception_Propagation) is in effect. Warnings are given for implicit or
@item @code{-gnatw.X}
-@emph{Disable warnings for No_Exception_Propagation mode.}
+`Disable warnings for No_Exception_Propagation mode.'
This switch disables warnings for exception usage when pragma Restrictions
(No_Exception_Propagation) is in effect.
@item @code{-gnatwy}
-@emph{Activate warnings for Ada compatibility issues.}
+`Activate warnings for Ada compatibility issues.'
For the most part, newer versions of Ada are upwards compatible
with older versions. For example, Ada 2005 programs will almost
@item @code{-gnatwY}
-@emph{Disable warnings for Ada compatibility issues.}
+`Disable warnings for Ada compatibility issues.'
This switch suppresses the warnings intended to help in identifying
incompatibilities between Ada language versions.
@item @code{-gnatw.y}
-@emph{Activate information messages for why package spec needs body.}
+`Activate information messages for why package spec needs body.'
There are a number of cases in which a package spec needs a body.
For example, the use of pragma Elaborate_Body, or the declaration
@item @code{-gnatw.Y}
-@emph{Disable information messages for why package spec needs body.}
+`Disable information messages for why package spec needs body.'
This switch suppresses the output of information messages showing why
a package specification needs a body.
@item @code{-gnatwz}
-@emph{Activate warnings on unchecked conversions.}
+`Activate warnings on unchecked conversions.'
This switch activates warnings for unchecked conversions
where the types are known at compile time to have different
@item @code{-gnatwZ}
-@emph{Suppress warnings on unchecked conversions.}
+`Suppress warnings on unchecked conversions.'
This switch suppresses warnings for unchecked conversions
where the types are known at compile time to have different
@item @code{-gnatw.z}
-@emph{Activate warnings for size not a multiple of alignment.}
+`Activate warnings for size not a multiple of alignment.'
This switch activates warnings for cases of array and record types
with specified @code{Size} and @code{Alignment} attributes where the
@item @code{-gnatw.Z}
-@emph{Suppress warnings for size not a multiple of alignment.}
+`Suppress warnings for size not a multiple of alignment.'
This switch suppresses warnings for cases of array and record types
with specified @code{Size} and @code{Alignment} attributes where the
@table @asis
-@item @code{-Wstack-usage=@emph{len}}
+@item @code{-Wstack-usage=`len'}
Warn if the stack usage of a subprogram might be larger than @code{len} bytes.
See @ref{e8,,Static Stack Usage Analysis} for details.
If performance is a consideration, leading to the need to optimize,
then the validity checking options should not be used.
-The other @code{-gnatV@emph{x}} switches below allow finer-grained
+The other @code{-gnatV`x'} switches below allow finer-grained
control; you can enable whichever validity checks you desire. However,
for most debugging purposes, @code{-gnatVa} is sufficient, and the
default @code{-gnatVd} (i.e. standard Ada behavior) is usually
of values is better known at compile time. However, an uninitialized
variable can cause wild jumps and memory corruption in this mode.
-The @code{-gnatV@emph{x}} switch allows control over the validity
+The @code{-gnatV`x'} switch allows control over the validity
checking mode as described below.
The @code{x} argument is a string of letters that
indicate validity checks that are performed or not performed in addition
@item @code{-gnatVa}
-@emph{All validity checks.}
+`All validity checks.'
All validity checks are turned on.
That is, @code{-gnatVa} is
@item @code{-gnatVc}
-@emph{Validity checks for copies.}
+`Validity checks for copies.'
The right-hand side of assignments, and the (explicit) initializing values
of object declarations are validity checked.
@item @code{-gnatVd}
-@emph{Default (RM) validity checks.}
+`Default (RM) validity checks.'
Some validity checks are required by Ada (see RM 13.9.1 (9-11)); these
(and only these) validity checks are enabled by default.
@item @code{-gnatVe}
-@emph{Validity checks for scalar components.}
+`Validity checks for scalar components.'
In the absence of this switch, assignments to scalar components of
enclosing record or array objects are not validity checked, even if
@item @code{-gnatVf}
-@emph{Validity checks for floating-point values.}
+`Validity checks for floating-point values.'
Specifying this switch enables validity checking for floating-point
values in the same contexts where validity checking is enabled for
@item @code{-gnatVi}
-@emph{Validity checks for `@w{`}in`@w{`} mode parameters.}
+`Validity checks for `@w{`}in`@w{`} mode parameters.'
Arguments for parameters of mode @code{in} are validity checked in function
and procedure calls at the point of call.
@item @code{-gnatVm}
-@emph{Validity checks for `@w{`}in out`@w{`} mode parameters.}
+`Validity checks for `@w{`}in out`@w{`} mode parameters.'
Arguments for parameters of mode @code{in out} are validity checked in
procedure calls at the point of call. The @code{'m'} here stands for
@item @code{-gnatVn}
-@emph{No validity checks.}
+`No validity checks.'
This switch turns off all validity checking, including the default checking
for case statements and left hand side subscripts. Note that the use of
@item @code{-gnatVo}
-@emph{Validity checks for operator and attribute operands.}
+`Validity checks for operator and attribute operands.'
Scalar arguments for predefined operators and for attributes are
validity checked.
@item @code{-gnatVp}
-@emph{Validity checks for parameters.}
+`Validity checks for parameters.'
This controls the treatment of formal parameters within a subprogram (as
opposed to @code{-gnatVi} and @code{-gnatVm}, which control validity
@item @code{-gnatVr}
-@emph{Validity checks for function returns.}
+`Validity checks for function returns.'
The expression in simple @code{return} statements in functions is validity
checked.
@item @code{-gnatVs}
-@emph{Validity checks for subscripts.}
+`Validity checks for subscripts.'
All subscript expressions are checked for validity, whatever context
they occur in (in default mode some subscripts are not validity checked;
@item @code{-gnatVt}
-@emph{Validity checks for tests.}
+`Validity checks for tests.'
Expressions used as conditions in @code{if}, @code{while} or @code{exit}
statements are checked, as well as guard expressions in entry calls.
@item @code{-gnaty0}
-@emph{Specify indentation level.}
+`Specify indentation level.'
If a digit from 1-9 appears
in the string after @code{-gnaty}
@item @code{-gnatya}
-@emph{Check attribute casing.}
+`Check attribute casing.'
Attribute names, including the case of keywords such as @code{digits}
used as attributes names, must be written in mixed case, that is, the
@item @code{-gnatyA}
-@emph{Use of array index numbers in array attributes.}
+`Use of array index numbers in array attributes.'
When using the array attributes First, Last, Range,
or Length, the index number must be omitted for one-dimensional arrays
@item @code{-gnatyb}
-@emph{Blanks not allowed at statement end.}
+`Blanks not allowed at statement end.'
Trailing blanks are not allowed at the end of statements. The purpose of this
rule, together with h (no horizontal tabs), is to enforce a canonical format
@item @code{-gnatyB}
-@emph{Check Boolean operators.}
+`Check Boolean operators.'
The use of AND/OR operators is not permitted except in the cases of modular
operands, array operands, and simple stand-alone boolean variables or
@item @code{-gnatyc}
-@emph{Check comments, double space.}
+`Check comments, double space.'
Comments must meet the following set of rules:
@item @code{-gnatyC}
-@emph{Check comments, single space.}
+`Check comments, single space.'
This is identical to @code{c} except that only one space
is required following the @code{--} of a comment instead of two.
@item @code{-gnatyd}
-@emph{Check no DOS line terminators present.}
+`Check no DOS line terminators present.'
All lines must be terminated by a single ASCII.LF
character (in particular the DOS line terminator sequence CR/LF is not
@item @code{-gnatyD}
-@emph{Check declared identifiers in mixed case.}
+`Check declared identifiers in mixed case.'
Declared identifiers must be in mixed case, as in
This_Is_An_Identifier. Use -gnatyr in addition to ensure
@item @code{-gnatye}
-@emph{Check end/exit labels.}
+`Check end/exit labels.'
Optional labels on @code{end} statements ending subprograms and on
@code{exit} statements exiting named loops, are required to be present.
@item @code{-gnatyf}
-@emph{No form feeds or vertical tabs.}
+`No form feeds or vertical tabs.'
Neither form feeds nor vertical tab characters are permitted
in the source text.
@item @code{-gnatyg}
-@emph{GNAT style mode.}
+`GNAT style mode.'
The set of style check switches is set to match that used by the GNAT sources.
This may be useful when developing code that is eventually intended to be
@item @code{-gnatyh}
-@emph{No horizontal tabs.}
+`No horizontal tabs.'
Horizontal tab characters are not permitted in the source text.
Together with the b (no blanks at end of line) check, this
@item @code{-gnatyi}
-@emph{Check if-then layout.}
+`Check if-then layout.'
The keyword @code{then} must appear either on the same
line as corresponding @code{if}, or on a line on its own, lined
@item @code{-gnatyI}
-@emph{check mode IN keywords.}
+`check mode IN keywords.'
Mode @code{in} (the default mode) is not
allowed to be given explicitly. @code{in out} is fine,
@item @code{-gnatyk}
-@emph{Check keyword casing.}
+`Check keyword casing.'
All keywords must be in lower case (with the exception of keywords
such as @code{digits} used as attribute names to which this check
@item @code{-gnatyl}
-@emph{Check layout.}
+`Check layout.'
Layout of statement and declaration constructs must follow the
recommendations in the Ada Reference Manual, as indicated by the
@item @code{-gnatyL}
-@emph{Set maximum nesting level.}
+`Set maximum nesting level.'
The maximum level of nesting of constructs (including subprograms, loops,
blocks, packages, and conditionals) may not exceed the given value
-@emph{nnn}. A value of zero disconnects this style check.
+`nnn'. A value of zero disconnects this style check.
@end table
@geindex -gnatym (gcc)
@item @code{-gnatym}
-@emph{Check maximum line length.}
+`Check maximum line length.'
The length of source lines must not exceed 79 characters, including
any trailing blanks. The value of 79 allows convenient display on an
@item @code{-gnatyM}
-@emph{Set maximum line length.}
+`Set maximum line length.'
The length of lines must not exceed the
-given value @emph{nnn}. The maximum value that can be specified is 32767.
+given value `nnn'. The maximum value that can be specified is 32767.
If neither style option for setting the line length is used, then the
default is 255. This also controls the maximum length of lexical elements,
where the only restriction is that they must fit on a single line.
@item @code{-gnatyn}
-@emph{Check casing of entities in Standard.}
+`Check casing of entities in Standard.'
Any identifier from Standard must be cased
to match the presentation in the Ada Reference Manual (for example,
@item @code{-gnatyN}
-@emph{Turn off all style checks.}
+`Turn off all style checks.'
All style check options are turned off.
@end table
@item @code{-gnatyo}
-@emph{Check order of subprogram bodies.}
+`Check order of subprogram bodies.'
All subprogram bodies in a given scope
(e.g., a package body) must be in alphabetical order. The ordering
@item @code{-gnatyO}
-@emph{Check that overriding subprograms are explicitly marked as such.}
+`Check that overriding subprograms are explicitly marked as such.'
This applies to all subprograms of a derived type that override a primitive
operation of the type, for both tagged and untagged types. In particular,
@item @code{-gnatyp}
-@emph{Check pragma casing.}
+`Check pragma casing.'
Pragma names must be written in mixed case, that is, the
initial letter and any letter following an underscore must be uppercase.
@item @code{-gnatyr}
-@emph{Check references.}
+`Check references.'
All identifier references must be cased in the same way as the
corresponding declaration. No specific casing style is imposed on
@item @code{-gnatys}
-@emph{Check separate specs.}
+`Check separate specs.'
Separate declarations (‘specs’) are required for subprograms (a
body is not allowed to serve as its own declaration). The only
@item @code{-gnatyS}
-@emph{Check no statements after then/else.}
+`Check no statements after then/else.'
No statements are allowed
on the same line as a @code{then} or @code{else} keyword following the
@item @code{-gnatyt}
-@emph{Check token spacing.}
+`Check token spacing.'
The following token spacing rules are enforced:
@item @code{-gnatyu}
-@emph{Check unnecessary blank lines.}
+`Check unnecessary blank lines.'
Unnecessary blank lines are not allowed. A blank line is considered
unnecessary if it appears at the end of the file, or if more than
@item @code{-gnatyx}
-@emph{Check extra parentheses.}
+`Check extra parentheses.'
Unnecessary extra levels of parentheses (C-style) are not allowed
around conditions (or selection expressions) in @code{if}, @code{while},
@item @code{-gnatyy}
-@emph{Set all standard style check options.}
+`Set all standard style check options.'
This is equivalent to @code{gnaty3aAbcefhiklmnprst}, that is all checking
options enabled with the exception of @code{-gnatyB}, @code{-gnatyd},
@item @code{-gnatyz}
-@emph{Check extra parentheses (operator precedence).}
+`Check extra parentheses (operator precedence).'
Extra levels of parentheses that are not required by operator precedence
rules are flagged. See also @code{-gnatyx}.
@item @code{-gnaty-}
-@emph{Remove style check options.}
+`Remove style check options.'
This causes any subsequent options in the string to act as canceling the
corresponding style check option. To cancel maximum nesting level control,
use the @code{L} parameter without any integer value after that, because any
-digit following @emph{-} in the parameter string of the @code{-gnaty}
+digit following `-' in the parameter string of the @code{-gnaty}
option will be treated as canceling the indentation check. The same is true
for the @code{M} parameter. @code{y} and @code{N} parameters are not
-allowed after @emph{-}.
+allowed after `-'.
@end table
@geindex -gnaty+ (gcc)
@item @code{-gnaty+}
-@emph{Enable style check options.}
+`Enable style check options.'
This causes any subsequent options in the string to enable the corresponding
style check option. That is, it cancels the effect of a previous -,
@table @asis
-@item @emph{1 = STRICT}
+@item `1 = STRICT'
In STRICT mode, intermediate operations are always done using the
base type, and overflow checking ensures that the result is within
the base type range.
-@item @emph{2 = MINIMIZED}
+@item `2 = MINIMIZED'
In MINIMIZED mode, overflows in intermediate operations are avoided
where possible by using a larger integer type for the computation
(typically @code{Long_Long_Integer}). Overflow checking ensures that
the result fits in this larger integer type.
-@item @emph{3 = ELIMINATED}
+@item `3 = ELIMINATED'
In ELIMINATED mode, overflows in intermediate operations are avoided
by using multi-precision arithmetic. In this case, overflow checking
Otherwise, the output is simply the error messages, if any. No object file or
ALI file is generated by a syntax-only compilation. Also, no units other
than the one specified are accessed. For example, if a unit @code{X}
-@emph{with}s a unit @code{Y}, compiling unit @code{X} in syntax
+`with's a unit @code{Y}, compiling unit @code{X} in syntax
check only mode does not access the source file containing unit
@code{Y}.
exceptions, Ada 95 and Ada 2005 are upwardly compatible with Ada 83. Thus
a correct Ada 83 program is usually also a correct program
in these later versions of the language standard. For further information
-please refer to the @emph{Compatibility and Porting Guide} chapter in the
+please refer to the `Compatibility and Porting Guide' chapter in the
@cite{GNAT Reference Manual}.
@end table
@table @asis
-@item @code{-gnati@emph{c}}
+@item @code{-gnati`c'}
Normally GNAT recognizes the Latin-1 character set in source program
identifiers, as described in the Ada Reference Manual.
@multitable {xxxxxxxxxxxx} {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}
@item
-@emph{1}
+`1'
@tab
@item
-@emph{2}
+`2'
@tab
@item
-@emph{3}
+`3'
@tab
@item
-@emph{4}
+`4'
@tab
@item
-@emph{5}
+`5'
@tab
@item
-@emph{9}
+`9'
@tab
@item
-@emph{p}
+`p'
@tab
@item
-@emph{8}
+`8'
@tab
@item
-@emph{f}
+`f'
@tab
@item
-@emph{n}
+`n'
@tab
@item
-@emph{w}
+`w'
@tab
@table @asis
-@item @code{-gnatW@emph{e}}
+@item @code{-gnatW`e'}
Specify the method of encoding for wide characters.
@code{e} is one of the following:
@multitable {xxxxxxxxxxxx} {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}
@item
-@emph{h}
+`h'
@tab
@item
-@emph{u}
+`u'
@tab
@item
-@emph{s}
+`s'
@tab
@item
-@emph{e}
+`e'
@tab
@item
-@emph{8}
+`8'
@tab
@item
-@emph{b}
+`b'
@tab
@table @asis
-@item @code{-gnatk@emph{n}}
+@item @code{-gnatk`n'}
Activates file name ‘krunching’. @code{n}, a decimal integer in the range
1-999, indicates the maximum allowable length of a file name (not
@multitable {xxxxxxxxxxxx} {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}
@item
-@emph{5}
+`5'
@tab
@item
-@emph{3}
+`3'
@tab
@item
-@emph{2}
+`2'
@tab
@item
-@emph{0}
+`0'
@tab
@table @asis
-@item @code{-gnatd@emph{x}}
+@item @code{-gnatd`x'}
Activate internal debugging switches. @code{x} is a letter or digit, or
string of letters or digits, which specifies the type of debugging
@table @asis
-@item @code{-gnatG[=@emph{nn}]}
+@item @code{-gnatG[=`nn']}
This switch causes the compiler to generate auxiliary output containing
a pseudo-source listing of the generated expanded code. Like most Ada
@table @asis
-@item @code{new @emph{xxx} [storage_pool = @emph{yyy}]}
+@item @code{new @var{xxx} [storage_pool = @var{yyy}]}
Shows the storage pool being used for an allocator.
-@item @code{at end @emph{procedure-name};}
+@item @code{at end @var{procedure-name};}
Shows the finalization (cleanup) procedure for a scope.
-@item @code{(if @emph{expr} then @emph{expr} else @emph{expr})}
+@item @code{(if @var{expr} then @var{expr} else @var{expr})}
Conditional expression equivalent to the @code{x?y:z} construction in C.
-@item @code{@emph{target}^(@emph{source})}
+@item @code{@var{target}^(@var{source})}
A conversion with floating-point truncation instead of rounding.
-@item @code{@emph{target}?(@emph{source})}
+@item @code{@var{target}?(@var{source})}
A conversion that bypasses normal Ada semantic checking. In particular
enumeration types and fixed-point types are treated simply as integers.
-@item @code{@emph{target}?^(@emph{source})}
+@item @code{@var{target}?^(@var{source})}
Combines the above two cases.
@end table
-@code{@emph{x} #/ @emph{y}}
+@code{@var{x} #/ @var{y}}
-@code{@emph{x} #mod @emph{y}}
+@code{@var{x} #mod @var{y}}
-@code{@emph{x} # @emph{y}}
+@code{@var{x} # @var{y}}
@table @asis
-@item @code{@emph{x} #rem @emph{y}}
+@item @code{@var{x} #rem @var{y}}
A division or multiplication of fixed-point values which are treated as
integers without any kind of scaling.
-@item @code{free @emph{expr} [storage_pool = @emph{xxx}]}
+@item @code{free @var{expr} [storage_pool = @var{xxx}]}
Shows the storage pool associated with a @code{free} statement.
Used to list an equivalent declaration for an internally generated
type that is referenced elsewhere in the listing.
-@item @code{freeze @emph{type-name} [@emph{actions}]}
+@item @code{freeze @var{type-name} [@var{actions}]}
Shows the point at which @code{type-name} is frozen, with possible
associated actions to be performed at the freeze point.
-@item @code{reference @emph{itype}}
+@item @code{reference @var{itype}}
Reference (and hence definition) to internal type @code{itype}.
-@item @code{@emph{function-name}! (@emph{arg}, @emph{arg}, @emph{arg})}
+@item @code{@var{function-name}! (@var{arg}, @var{arg}, @var{arg})}
Intrinsic function call.
-@item @code{@emph{label-name} : label}
+@item @code{@var{label-name} : label}
Declaration of label @code{labelname}.
-@item @code{#$ @emph{subprogram-name}}
+@item @code{#$ @var{subprogram-name}}
An implicit call to a run-time support routine
(to meet the requirement of H.3.1(9) in a
convenient manner).
-@item @code{@emph{expr} && @emph{expr} && @emph{expr} ... && @emph{expr}}
+@item @code{@var{expr} && @var{expr} && @var{expr} ... && @var{expr}}
A multiple concatenation (same effect as @code{expr} & @code{expr} &
@code{expr}, but handled more efficiently).
Raise the @code{Constraint_Error} exception.
-@item @code{@emph{expression}'reference}
+@item @code{@var{expression}'reference}
A pointer to the result of evaluating @{expression@}.
-@item @code{@emph{target-type}!(@emph{source-expression})}
+@item @code{@var{target-type}!(@var{source-expression})}
An unchecked conversion of @code{source-expression} to @code{target-type}.
-@item @code{[@emph{numerator}/@emph{denominator}]}
+@item @code{[@var{numerator}/@var{denominator}]}
Used to represent internal real literals (that) have no exact
representation in base 2-16 (for example, the result of compile time
@table @asis
-@item @code{-gnatem=@emph{path}}
+@item @code{-gnatem=`path'}
A mapping file is a way to communicate to the compiler two mappings:
from unit names to file names (without any directory information) and from
@table @asis
-@item @code{-fuse-ld=@emph{name}}
+@item @code{-fuse-ld=`name'}
Linker to be used. The default is @code{bfd} for @code{ld.bfd}; @code{gold}
(for @code{ld.gold}) and @code{mold} (for @code{ld.mold}) are more
@table @asis
-@item @code{-A[=@emph{filename}]}
+@item @code{-A[=`filename']}
Output ALI list (to standard output or to the named file).
@end table
@table @asis
-@item @code{-d@emph{nn}[k|m]}
+@item @code{-d`nn'[k|m]}
This switch can be used to change the default task stack size value
to a specified size @code{nn}, which is expressed in bytes by default, or
@table @asis
-@item @code{-D@emph{nn}[k|m]}
+@item @code{-D`nn'[k|m]}
Set the default secondary stack size to @code{nn}. The suffix indicates whether
the size is in bytes (no suffix), kilobytes (@code{k} suffix) or megabytes
@table @asis
-@item @code{-f@emph{elab-order}}
+@item @code{-f`elab-order'}
Force elaboration order. For further details see @ref{113,,Elaboration Control}
and @ref{f,,Elaboration Order Handling in GNAT}.
@geindex -L (gnatbind)
-@item @code{-L@emph{xxx}}
+@item @code{-L`xxx'}
Bind the units for library building. In this case the @code{adainit} and
@code{adafinal} procedures (@ref{7e,,Binding with Non-Ada Main Programs})
-are renamed to @code{@emph{xxx}init} and
-@code{@emph{xxx}final}.
+are renamed to @code{@var{xxx}init} and
+@code{@var{xxx}final}.
Implies -n.
(@ref{2a,,GNAT and Libraries}, for more details.)
@geindex -M (gnatbind)
-@item @code{-M@emph{xyz}}
+@item @code{-M`xyz'}
Rename generated main program from main to xyz. This option is
supported on cross environments only.
@geindex -m (gnatbind)
-@item @code{-m@emph{n}}
+@item @code{-m`n'}
Limit number of detected errors or warnings to @code{n}, where @code{n} is
in the range 1..999999. The default value if no switch is
Generate a binder file suitable for space-constrained applications. When
active, binder-generated objects not required for program operation are no
-longer generated. @strong{Warning:} this option comes with the following
+longer generated. `Warning:' this option comes with the following
limitations:
@geindex --RTS (gnatbind)
-@item @code{--RTS=@emph{rts-path}}
+@item @code{--RTS=`rts-path'}
Specifies the default location of the run-time library. Same meaning as the
equivalent @code{gnatmake} flag (@ref{d0,,Switches for gnatmake}).
@geindex -o (gnatbind)
-@item @code{-o @emph{file}}
+@item @code{-o `file'}
Name the output file @code{file} (default is @code{b~`xxx}.adb`).
Note that if this option is used, then linking must be done manually,
@geindex -O (gnatbind)
-@item @code{-O[=@emph{filename}]}
+@item @code{-O[=`filename']}
Output object list (to standard output or to the named file).
@table @asis
-@item @code{-Q@emph{nnn}}
+@item @code{-Q`nnn'}
Generate @code{nnn} additional default-sized secondary stacks.
While the binder sizes this pool to match the number of such tasks defined in
the application, the pool size may need to be increased with the @code{-Q}
switch to accommodate foreign threads registered with the Light run-time. For
-more information, please see the @emph{The Primary and Secondary Stack} chapter in
-the @emph{GNAT User’s Guide Supplement for Cross Platforms}.
+more information, please see the `The Primary and Secondary Stack' chapter in
+the `GNAT User’s Guide Supplement for Cross Platforms'.
@geindex -R (gnatbind)
@geindex -S (gnatbind)
-@item @code{-S@emph{xxx}}
+@item @code{-S`xxx'}
Specifies the value to be used when detecting uninitialized scalar
objects with pragma Initialize_Scalars.
In addition, you can specify @code{-Sev} to indicate that the value is
to be set at run time. In this case, the program will look for an environment
-variable of the form @code{GNAT_INIT_SCALARS=@emph{yy}}, where @code{yy} is one
-of @code{in/lo/hi/@emph{xx}} with the same meanings as above.
+variable of the form @code{GNAT_INIT_SCALARS=@var{yy}}, where @code{yy} is one
+of @code{in/lo/hi/@var{xx}} with the same meanings as above.
If no environment variable is found, or if it does not have a valid value,
then the default is @code{in} (invalid values).
@end table
@geindex -T (gnatbind)
-@item @code{-T@emph{n}}
+@item @code{-T`n'}
Set the time slice value to @code{n} milliseconds. If the system supports
the specification of a specific time slice value, then the indicated value
@geindex -u (gnatbind)
-@item @code{-u@emph{n}}
+@item @code{-u`n'}
Enable dynamic stack usage, with @code{n} results stored and displayed
at program termination. A result is generated when a task
@geindex -V (gnatbind)
-@item @code{-V@emph{key}=@emph{value}}
+@item @code{-V`key'=`value'}
Store the given association of @code{key} to @code{value} in the bind environment.
Values stored this way can be retrieved at run time using
@geindex -w (gnatbind)
-@item @code{-w@emph{x}}
+@item @code{-w`x'}
Warning mode; @code{x} = s/e for suppress/treat as error.
@geindex -Wx (gnatbind)
-@item @code{-Wx@emph{e}}
+@item @code{-Wx`e'}
Override default wide character encoding for standard Text_IO files.
@geindex -Xnnn (gnatbind)
-@item @code{-X@emph{nnn}}
+@item @code{-X`nnn'}
Set default exit status value, normally 0 for POSIX compliance.
@geindex -Wx (gnatbind)
-@item @code{-Wx@emph{e}}
+@item @code{-Wx`e'}
Override default wide character encoding for standard Text_IO files.
Normally the default wide character encoding method used for standard
@geindex -m (gnatbind)
-@item @code{-m@emph{n}}
+@item @code{-m`n'}
Limits the number of error messages to @code{n}, a decimal integer in the
range 1-999. The binder terminates immediately if this limit is reached.
@geindex -M (gnatbind)
-@item @code{-M@emph{xxx}}
+@item @code{-M`xxx'}
Renames the generated main program from @code{main} to @code{xxx}.
This is useful in the case of some cross-building environments, where
@table @asis
-@item @code{-f@emph{elab-order}}
+@item @code{-f`elab-order'}
Force elaboration order.
@geindex -o (gnatbind)
-@item @code{-o @emph{file}}
+@item @code{-o `file'}
Set name of output file to @code{file} instead of the normal
@code{b~`mainprog}.adb` default. Note that @code{file} denote the Ada
the command line for @code{gnatbind}. The normal @code{closure}
calculation is performed for each of the specified units. Calculating
the closure means finding out the set of units involved by tracing
-@emph{with} references. The reason it is necessary to be able to
+`with' references. The reason it is necessary to be able to
specify more than one ALI file is that a given program may invoke two or
more quite separate groups of Ada units.
are declared in one of the GNAT library routines. These variables must
be set from the actual @code{argc} and @code{argv} values passed to the
-main program. With no @emph{n} present, @code{gnatbind}
+main program. With no `n' present, @code{gnatbind}
generates the C main program to automatically set these variables.
-If the @emph{n} switch is used, there is no automatic way to
+If the `n' switch is used, there is no automatic way to
set these variables. If they are not set, the procedures in
@code{Ada.Command_Line} will not be available, and any attempt to use
them will raise @code{Constraint_Error}. If command line access is
source paths only, and @code{-aO}
if you want to specify library paths
only. This means that for the binder
-@code{-I@emph{dir}} is equivalent to
-@code{-aI@emph{dir}}
-@code{-aO`@emph{dir}}.
+@code{-I`dir'} is equivalent to
+@code{-aI`dir'}
+@code{-aO``dir'}.
The binder generates the bind file (a C language source file) in the
current working directory.
@table @asis
-@item @code{-o @emph{exec-name}}
+@item @code{-o `exec-name'}
@code{exec-name} specifies an alternate name for the generated
executable program. If this switch is omitted, the executable has the same
@table @asis
-@item @code{-B@emph{dir}}
+@item @code{-B`dir'}
Load compiler executables (for example, @code{gnat1}, the Ada compiler)
from @code{dir} instead of the default location. Only use this switch
@table @asis
-@item @code{-M=@emph{mapfile}}
+@item @code{-M=`mapfile'}
When linking an executable, create a map file. The name of the map file is
@code{mapfile}.
@table @asis
-@item @code{--GCC=@emph{compiler_name}}
+@item @code{--GCC=`compiler_name'}
Program used for compiling the binder file. The default is
@code{gcc}. You need to use quotes around @code{compiler_name} if
@table @asis
-@item @code{--LINK=@emph{name}}
+@item @code{--LINK=`name'}
@code{name} is the name of the linker to be invoked. This is especially
useful in mixed language programs since languages such as C++ require
If @code{--version} was not used, display usage, then exit disregarding
all other options.
-@item @code{--subdirs=@emph{subdir}}
+@item @code{--subdirs=`subdir'}
Actual object directory of each project file is the subdirectory subdir of the
object directory specified or defaulted in the project file.
@table @asis
-@item @code{-D @emph{dir}}
+@item @code{-D `dir'}
Indicate that ALI and object files should normally be found in directory @code{dir}.
@end table
@table @asis
-@item @code{-P@emph{project}}
+@item @code{-P`project'}
Use project file @code{project}. Only one such switch can be used.
When cleaning a project file, the files produced by the compilation of the
@table @asis
-@item @code{-vP@emph{x}}
+@item @code{-vP`x'}
Indicates the verbosity of the parsing of GNAT project files.
@ref{d1,,Switches Related to Project Files}.
@table @asis
-@item @code{-X@emph{name}=@emph{value}}
+@item @code{-X`name'=`value'}
Indicates that external variable @code{name} has the value @code{value}.
The Project Manager will use this value for occurrences of
@table @asis
-@item @code{-aO@emph{dir}}
+@item @code{-aO`dir'}
When searching for ALI and object files, look in directory @code{dir}.
@end table
@table @asis
-@item @code{-I@emph{dir}}
+@item @code{-I`dir'}
-Equivalent to @code{-aO@emph{dir}}.
+Equivalent to @code{-aO`dir'}.
@end table
@geindex -I- (gnatclean)
@table @asis
-@item @emph{OK (unchanged)}
+@item `OK (unchanged)'
The version of the source file used for the compilation of the
specified unit corresponds exactly to the actual source file.
-@item @emph{MOK (slightly modified)}
+@item `MOK (slightly modified)'
The version of the source file used for the compilation of the
specified unit differs from the actual source file but not enough to
@code{-m} (minimal recompilation), a file marked
MOK will not be recompiled.
-@item @emph{DIF (modified)}
+@item `DIF (modified)'
No version of the source found on the path corresponds to the source
used to build this object.
-@item @emph{??? (file not found)}
+@item `??? (file not found)'
No source file was found for this unit.
-@item @emph{HID (hidden, unchanged version not first on PATH)}
+@item `HID (hidden, unchanged version not first on PATH)'
The version of the source that corresponds exactly to the source used
for compilation has been found on the path but it is hidden by another
@table @asis
-@item @code{-files=@emph{file}}
+@item @code{-files=`file'}
Take as arguments the files listed in text file @code{file}.
Text file @code{file} may contain empty lines that are ignored.
@table @asis
-@item @code{-aO@emph{dir}}, @code{-aI@emph{dir}}, @code{-I@emph{dir}}, @code{-I-}, @code{-nostdinc}
+@item @code{-aO`dir'}, @code{-aI`dir'}, @code{-I`dir'}, @code{-I-}, @code{-nostdinc}
Source path manipulation. Same meaning as the equivalent @code{gnatmake}
flags (@ref{d0,,Switches for gnatmake}).
@table @asis
-@item @code{-aP@emph{dir}}
+@item @code{-aP`dir'}
Add @code{dir} at the beginning of the project search dir.
@end table
@table @asis
-@item @code{--RTS=@emph{rts-path}}
+@item @code{--RTS=`rts-path'}
Specifies the default location of the runtime library. Same meaning as the
equivalent @code{gnatmake} flag (@ref{d0,,Switches for gnatmake}).
@itemize *
@item
-@emph{Preelaborable}: The unit is preelaborable in the Ada sense.
+`Preelaborable': The unit is preelaborable in the Ada sense.
@item
-@emph{No_Elab_Code}: No elaboration code has been produced by the compiler for this unit.
+`No_Elab_Code': No elaboration code has been produced by the compiler for this unit.
@item
-@emph{Pure}: The unit is pure in the Ada sense.
+`Pure': The unit is pure in the Ada sense.
@item
-@emph{Elaborate_Body}: The unit contains a pragma Elaborate_Body.
+`Elaborate_Body': The unit contains a pragma Elaborate_Body.
@item
-@emph{Remote_Types}: The unit contains a pragma Remote_Types.
+`Remote_Types': The unit contains a pragma Remote_Types.
@item
-@emph{Shared_Passive}: The unit contains a pragma Shared_Passive.
+`Shared_Passive': The unit contains a pragma Shared_Passive.
@item
-@emph{Predefined}: This unit is part of the predefined environment and cannot be modified
+`Predefined': This unit is part of the predefined environment and cannot be modified
by the user.
@item
-@emph{Remote_Call_Interface}: The unit contains a pragma Remote_Call_Interface.
+`Remote_Call_Interface': The unit contains a pragma Remote_Call_Interface.
@end itemize
@end table
@code{GDB} contains a large repertoire of commands.
See @cite{Debugging with GDB} for extensive documentation on the use
of these commands, together with examples of their use. Furthermore,
-the command @emph{help} invoked from within GDB activates a simple help
+the command `help' invoked from within GDB activates a simple help
facility which summarizes the available commands and their options.
In this section we summarize a few of the most commonly
used commands to give an idea of what @code{GDB} is about. You should create
@table @asis
-@item @code{set args @emph{arguments}}
+@item @code{set args @var{arguments}}
-The @emph{arguments} list above is a list of arguments to be passed to
+The `arguments' list above is a list of arguments to be passed to
the program on a subsequent run command, just as though the arguments
had been entered on a normal invocation of the program. The @code{set args}
command is not needed if the program does not require arguments.
@table @asis
-@item @code{breakpoint @emph{location}}
+@item @code{breakpoint @var{location}}
The breakpoint command sets a breakpoint, that is to say a point at which
execution will halt and @code{GDB} will await further
-commands. @emph{location} is
+commands. `location' is
either a line number within a file, given in the format @code{file:linenumber},
or it is the name of a subprogram. If you request that a breakpoint be set on
a subprogram that is overloaded, a prompt will ask you to specify on which of
@table @asis
-@item @code{catch exception @emph{name}}
+@item @code{catch exception @var{name}}
This command causes the program execution to stop whenever exception
@code{name} is raised. If @code{name} is omitted, then the execution is
@table @asis
-@item @code{print @emph{expression}}
+@item @code{print @var{expression}}
This will print the value of the given expression. Most simple
Ada expression formats are properly handled by @code{GDB}, so the expression
@table @asis
-@item @code{frame @emph{n}}
+@item @code{frame @var{n}}
Inspect the frame with the given number. The value 0 denotes the frame
of the current breakpoint, that is to say the top of the call stack.
@node Using the next Command in a Function,Stopping When Ada Exceptions Are Raised,Calling User-Defined Subprograms,Running and Debugging Ada Programs
@anchor{gnat_ugn/gnat_and_program_execution id8}@anchor{15a}@anchor{gnat_ugn/gnat_and_program_execution using-the-next-command-in-a-function}@anchor{15b}
-@subsection Using the @emph{next} Command in a Function
+@subsection Using the `next' Command in a Function
When you use the @code{next} command in a function, the current source
@table @asis
-@item @code{catch exception @emph{name}}
+@item @code{catch exception @var{name}}
Set a catchpoint that stops execution whenever (any task in the) program
-raises the exception @emph{name}.
+raises the exception `name'.
@end table
@item
@table @asis
-@item @code{info exceptions}, @code{info exceptions @emph{regexp}}
+@item @code{info exceptions}, @code{info exceptions @var{regexp}}
The @code{info exceptions} command permits the user to examine all defined
-exceptions within Ada programs. With a regular expression, @emph{regexp}, as
-argument, prints out only those exceptions whose name matches @emph{regexp}.
+exceptions within Ada programs. With a regular expression, `regexp', as
+argument, prints out only those exceptions whose name matches `regexp'.
@end table
@end itemize
@itemize *
@item
-@code{break} @emph{linespec} @code{task} @emph{taskid}, @code{break} @emph{linespec} @code{task} @emph{taskid} @code{if} …
+@code{break} `linespec' @code{task} `taskid', @code{break} `linespec' @code{task} `taskid' @code{if} …
@quotation
These commands are like the @code{break ... thread ...}.
-@emph{linespec} specifies source lines.
+`linespec' specifies source lines.
-Use the qualifier @code{task @emph{taskid}} with a breakpoint command
+Use the qualifier @code{task @var{taskid}} with a breakpoint command
to specify that you only want @code{GDB} to stop the program when a
-particular Ada task reaches this breakpoint. @emph{taskid} is one of the
+particular Ada task reaches this breakpoint. `taskid' is one of the
numeric task identifiers assigned by @code{GDB}, shown in the first
column of the @code{info tasks} display.
-If you do not specify @code{task @emph{taskid}} when you set a
-breakpoint, the breakpoint applies to @emph{all} tasks of your
+If you do not specify @code{task @var{taskid}} when you set a
+breakpoint, the breakpoint applies to `all' tasks of your
program.
You can use the @code{task} qualifier on conditional breakpoints as
-well; in this case, place @code{task @emph{taskid}} before the
+well; in this case, place @code{task @var{taskid}} before the
breakpoint condition (before the @code{if}).
@end quotation
@end itemize
@itemize *
@item
-@code{task @emph{taskno}}
+@code{task @var{taskno}}
@quotation
-This command allows switching to the task referred by @emph{taskno}. In
+This command allows switching to the task referred by `taskno'. In
particular, this allows browsing of the backtrace of the specified
task. It is advisable to switch back to the original task before
continuing execution otherwise the scheduling of the program may be
program, in which case the execution of that program is simply suspended
until the connection between the debugger and gdbserver is established.
-For more information on how to use gdbserver, see the @emph{Using the gdbserver Program}
+For more information on how to use gdbserver, see the `Using the gdbserver Program'
section in @cite{Debugging with GDB}.
GNAT provides support for gdbserver on x86-linux, x86-windows and x86_64-linux.
Traceback is a mechanism to display the sequence of subprogram calls that
leads to a specified execution point in a program. Often (but not always)
the execution point is an instruction at which an exception has been raised.
-This mechanism is also known as @emph{stack unwinding} because it obtains
+This mechanism is also known as `stack unwinding' because it obtains
its information by scanning the run-time stack and recovering the activation
records of all active subprograms. Stack unwinding is one of the most
important tools for program debugging.
@table @asis
-@item @code{--demangle[=@emph{style}]}, @code{--no-demangle}
+@item @code{--demangle[=@var{style}]}, @code{--no-demangle}
These options control whether symbol names should be demangled when
printing output. The default is to demangle C++ symbols. The
@table @asis
-@item @code{-e @emph{function_name}}
+@item @code{-e @var{function_name}}
-The @code{-e @emph{function}} option tells @code{gprof} not to print
+The @code{-e @var{function}} option tells @code{gprof} not to print
information about the function @code{function_name} (and its
children…) in the call graph. The function will still be listed
as a child of any functions that call it, but its index number will be
@table @asis
-@item @code{-E @emph{function_name}}
+@item @code{-E @var{function_name}}
-The @code{-E @emph{function}} option works like the @code{-e} option, but
+The @code{-E @var{function}} option works like the @code{-e} option, but
execution time spent in the function (and children who were not called from
anywhere else), will not be used to compute the percentages-of-time for
the call graph. More than one @code{-E} option may be given; only one
@table @asis
-@item @code{-f @emph{function_name}}
+@item @code{-f @var{function_name}}
-The @code{-f @emph{function}} option causes @code{gprof} to limit the
+The @code{-f @var{function}} option causes @code{gprof} to limit the
call graph to the function @code{function_name} and its children (and
their children…). More than one @code{-f} option may be given;
only one @code{function_name} may be indicated with each @code{-f}
@table @asis
-@item @code{-F @emph{function_name}}
+@item @code{-F @var{function_name}}
-The @code{-F @emph{function}} option works like the @code{-f} option, but
+The @code{-F @var{function}} option works like the @code{-f} option, but
only time spent in the function and its children (and their
children…) will be used to determine total-time and
percentages-of-time for the call graph. More than one @code{-F} option
Since the precise set of optimizations done at each level will vary from
release to release (and sometime from target to target), it is best to think
of the optimization settings in general terms.
-See the @emph{Options That Control Optimization} section in
+See the `Options That Control Optimization' section in
@cite{Using the GNU Compiler Collection (GCC)}
for details about
the @code{-O} settings and a number of @code{-f} options that
Unlike some other compilation systems, @code{gcc} has
been tested extensively at all optimization levels. There are some bugs
which appear only with optimization turned on, but there have also been
-bugs which show up only in @emph{unoptimized} code. Selecting a lower
+bugs which show up only in `unoptimized' code. Selecting a lower
level of optimization does not improve the reliability of the code
generator, which in practice is highly reliable at all optimization
levels.
@itemize *
@item
-@emph{The ‘hopping Program Counter’:} Repeated @code{step} or @code{next}
+`The ‘hopping Program Counter’:' Repeated @code{step} or @code{next}
commands show
the PC bouncing back and forth in the code. This may result from any of
the following optimizations:
@itemize -
@item
-@emph{Common subexpression elimination:} using a single instance of code for a
+`Common subexpression elimination:' using a single instance of code for a
quantity that the source computes several times. As a result you
may not be able to stop on what looks like a statement.
@item
-@emph{Invariant code motion:} moving an expression that does not change within a
+`Invariant code motion:' moving an expression that does not change within a
loop, to the beginning of the loop.
@item
-@emph{Instruction scheduling:} moving instructions so as to
+`Instruction scheduling:' moving instructions so as to
overlap loads and stores (typically) with other code, or in
general to move computations of values closer to their uses. Often
this causes you to pass an assignment statement without the assignment
@end itemize
@item
-@emph{The ‘big leap’:} More commonly known as @emph{cross-jumping}, in which
+`The ‘big leap’:' More commonly known as `cross-jumping', in which
two identical pieces of code are merged and the program counter suddenly
jumps to a statement that is not supposed to be executed, simply because
it (and the code following) translates to the same thing as the code
-that @emph{was} supposed to be executed. This effect is typically seen in
+that `was' supposed to be executed. This effect is typically seen in
sequences that end in a jump, such as a @code{goto}, a @code{return}, or
a @code{break} in a C @code{switch} statement.
@item
-@emph{The ‘roving variable’:} The symptom is an unexpected value in a variable.
+`The ‘roving variable’:' The symptom is an unexpected value in a variable.
There are various reasons for this effect:
values (one must apply the procedure recursively to those
other values); or re-running the code and stopping a little earlier
(perhaps before the call) and stepping to better see how the variable obtained
-the value in question; or continuing to step @emph{from} the point of the
+the value in question; or continuing to step `from' the point of the
strange value to see if code motion had simply moved the variable’s
assignments later.
@end itemize
specified; optimization level @code{-O3} is specified.
@end itemize
-Calls to subprograms in @emph{with}ed units are normally not inlined.
+Calls to subprograms in `with'ed units are normally not inlined.
To achieve actual inlining (that is, replacement of the call by the code
in the body of the subprogram), the following conditions must all be true:
and the various target-specific @code{-m} options (in particular, it has
been observed that @code{-march=xxx} can significantly improve performance
on appropriate machines). For full details of these switches, see
-the @emph{Submodel Options} section in the @emph{Hardware Models and Configurations}
+the `Submodel Options' section in the `Hardware Models and Configurations'
chapter of @cite{Using the GNU Compiler Collection (GCC)}.
@node Optimization and Strict Aliasing,Aliased Variables and Optimization,Other Optimization Switches,Performance Considerations
output and standard error files is unbuffered (this provides better
behavior when output statements are used for debugging, or if the
progress of a program is observed by tracking the output, e.g. by
-using the Unix @emph{tail -f} command to watch redirected output).
+using the Unix `tail -f' command to watch redirected output).
If you are generating large volumes of output with @code{Text_IO} and
performance is an important factor, use a designated file instead
@itemize *
@item
-@emph{Use base type for intermediate operations} (@code{STRICT})
+`Use base type for intermediate operations' (@code{STRICT})
In this mode, all intermediate results for predefined arithmetic
operators are computed using the base type, and the result must
This is the normal default mode.
@item
-@emph{Most intermediate overflows avoided} (@code{MINIMIZED})
+`Most intermediate overflows avoided' (@code{MINIMIZED})
In this mode, the compiler attempts to avoid intermediate overflows by
using a larger integer type, typically @code{Long_Long_Integer},
is in range and the precondition is True (from a mathematical point
of view). In such a case, operating in this mode, an overflow occurs
for the intermediate computation (which is why this mode
-says @emph{most} intermediate overflows are avoided). In this case,
+says `most' intermediate overflows are avoided). In this case,
an exception is raised if overflow checks are enabled, and the
execution is erroneous if overflow checks are suppressed.
@item
-@emph{All intermediate overflows avoided} (@code{ELIMINATED})
+`All intermediate overflows avoided' (@code{ELIMINATED})
In this mode, the compiler avoids all intermediate overflows
by using arbitrary precision arithmetic as required. In this
The GNAT-specific aspect @code{Dimension_System}
allows you to define a system of units; the aspect @code{Dimension}
then allows the user to declare dimensioned quantities within a given system.
-(These aspects are described in the @emph{Implementation Defined Aspects}
-chapter of the @emph{GNAT Reference Manual}).
+(These aspects are described in the `Implementation Defined Aspects'
+chapter of the `GNAT Reference Manual').
The major advantage of this model is that it does not require the declaration of
multiple operators for all possible combinations of types: it is only necessary
@geindex Dimensioned subtype
@end quotation
-The type @code{Mks_Type} is said to be a @emph{dimensionable type} since it has a
+The type @code{Mks_Type} is said to be a `dimensionable type' since it has a
@code{Dimension_System} aspect, and the subtypes @code{Length}, @code{Mass}, etc.,
-are said to be @emph{dimensioned subtypes} since each one has a @code{Dimension}
+are said to be `dimensioned subtypes' since each one has a @code{Dimension}
aspect.
@quotation
The @code{Dimension} aspect of a dimensioned subtype @code{S} defines a mapping
from the base type’s Unit_Names to integer (or, more generally, rational)
-values. This mapping is the @emph{dimension vector} (also referred to as the
-@emph{dimensionality}) for that subtype, denoted by @code{DV(S)}, and thus for each
+values. This mapping is the `dimension vector' (also referred to as the
+`dimensionality') for that subtype, denoted by @code{DV(S)}, and thus for each
object of that subtype. Intuitively, the value specified for each
@code{Unit_Name} is the exponent associated with that unit; a zero value
means that the unit is not used. For example:
that help prevent mismatches such as using an @code{Acceleration} where a
@code{Length} is required.
-The dimension vector of the result of an arithmetic expression @emph{expr}, or
-@code{DV(@emph{expr})}, is defined as follows, assuming conventional
+The dimension vector of the result of an arithmetic expression `expr', or
+@code{DV(@var{expr})}, is defined as follows, assuming conventional
mathematical definitions for the vector operations that are used:
@itemize *
@item
-If @emph{expr} is of the type @emph{universal_real}, or is not of a dimensioned subtype,
-then @emph{expr} is dimensionless; @code{DV(@emph{expr})} is the empty vector.
+If `expr' is of the type `universal_real', or is not of a dimensioned subtype,
+then `expr' is dimensionless; @code{DV(@var{expr})} is the empty vector.
@item
-@code{DV(@emph{op expr})}, where @emph{op} is a unary operator, is @code{DV(@emph{expr})}
+@code{DV(@var{op expr})}, where `op' is a unary operator, is @code{DV(@var{expr})}
@item
-@code{DV(@emph{expr1 op expr2})} where @emph{op} is “+” or “-” is @code{DV(@emph{expr1})}
-provided that @code{DV(@emph{expr1})} = @code{DV(@emph{expr2})}.
+@code{DV(@var{expr1 op expr2})} where `op' is “+” or “-” is @code{DV(@var{expr1})}
+provided that @code{DV(@var{expr1})} = @code{DV(@var{expr2})}.
If this condition is not met then the construct is illegal.
@item
-@code{DV(@emph{expr1} * @emph{expr2})} is @code{DV(@emph{expr1})} + @code{DV(@emph{expr2})},
-and @code{DV(@emph{expr1} / @emph{expr2})} = @code{DV(@emph{expr1})} - @code{DV(@emph{expr2})}.
-In this context if one of the @emph{expr}s is dimensionless then its empty
+@code{DV(@var{expr1} * @var{expr2})} is @code{DV(@var{expr1})} + @code{DV(@var{expr2})},
+and @code{DV(@var{expr1} / @var{expr2})} = @code{DV(@var{expr1})} - @code{DV(@var{expr2})}.
+In this context if one of the `expr's is dimensionless then its empty
dimension vector is treated as @code{(others => 0)}.
@item
-@code{DV(@emph{expr} ** @emph{power})} is @emph{power} * @code{DV(@emph{expr})},
-provided that @emph{power} is a static rational value. If this condition is not
+@code{DV(@var{expr} ** @var{power})} is `power' * @code{DV(@var{expr})},
+provided that `power' is a static rational value. If this condition is not
met then the construct is illegal.
@end itemize
is accepted with a warning. Analogously a conditional expression requires the
same dimension vector for each branch (with no exception for literals).
-The dimension vector of a type conversion @code{T(@emph{expr})} is defined
+The dimension vector of a type conversion @code{T(@var{expr})} is defined
as follows, based on the nature of @code{T}:
@itemize *
@item
-If @code{T} is a dimensioned subtype then @code{DV(T(@emph{expr}))} is @code{DV(T)}
-provided that either @emph{expr} is dimensionless or
-@code{DV(T)} = @code{DV(@emph{expr})}. The conversion is illegal
-if @emph{expr} is dimensioned and @code{DV(@emph{expr})} /= @code{DV(T)}.
+If @code{T} is a dimensioned subtype then @code{DV(T(@var{expr}))} is @code{DV(T)}
+provided that either `expr' is dimensionless or
+@code{DV(T)} = @code{DV(@var{expr})}. The conversion is illegal
+if `expr' is dimensioned and @code{DV(@var{expr})} /= @code{DV(T)}.
Note that vector equality does not require that the corresponding
Unit_Names be the same.
converted, for example, to a mass in pounds.
@item
-If @code{T} is the base type for @emph{expr} (and the dimensionless root type of
-the dimension system), then @code{DV(T(@emph{expr}))} is @code{DV(expr)}.
-Thus, if @emph{expr} is of a dimensioned subtype of @code{T}, the conversion may
+If @code{T} is the base type for `expr' (and the dimensionless root type of
+the dimension system), then @code{DV(T(@var{expr}))} is @code{DV(expr)}.
+Thus, if `expr' is of a dimensioned subtype of @code{T}, the conversion may
be regarded as a “view conversion” that preserves dimensionality.
This rule makes it possible to write generic code that can be instantiated
@item
Otherwise (i.e., @code{T} is neither a dimensioned subtype nor a dimensionable
-base type), @code{DV(T(@emph{expr}))} is the empty vector. Thus a dimensioned
+base type), @code{DV(T(@var{expr}))} is the empty vector. Thus a dimensioned
value can be explicitly converted to a non-dimensioned subtype, which
of course then escapes dimensionality analysis.
@end itemize
-The dimension vector for a type qualification @code{T'(@emph{expr})} is the same
-as for the type conversion @code{T(@emph{expr})}.
+The dimension vector for a type qualification @code{T'(@var{expr})} is the same
+as for the type conversion @code{T(@var{expr})}.
An assignment statement
@itemize *
@item
-@emph{Index} is a number associated with each task.
+`Index' is a number associated with each task.
@item
-@emph{Task Name} is the name of the task analyzed.
+`Task Name' is the name of the task analyzed.
@item
-@emph{Stack Size} is the maximum size for the stack.
+`Stack Size' is the maximum size for the stack.
@item
-@emph{Stack Usage} is the measure done by the stack analyzer.
+`Stack Usage' is the measure done by the stack analyzer.
In order to prevent overflow, the stack
is not entirely analyzed, and it’s not possible to know exactly how
much has actually been used.
@itemize *
@item
-@strong{Zero-Cost Exceptions} (“ZCX”),
+`Zero-Cost Exceptions' (“ZCX”),
which uses binder-generated tables that
are interrogated at run time to locate a handler.
@geindex SJLJ (setjmp/longjmp Exception Model)
@item
-@strong{setjmp / longjmp} (‘SJLJ’),
+`setjmp / longjmp' (‘SJLJ’),
which uses dynamically-set data to establish
the set of handlers
@end itemize
below explains the differences between the different libraries in terms of
their thread support.
-The default run-time library (when GNAT is installed) is @emph{rts-native}.
+The default run-time library (when GNAT is installed) is `rts-native'.
This default run-time is selected by the means of soft links.
For example on x86-linux:
(Upper-case names and dotted/dashed arrows represent soft links)
@end example
-If the @emph{rts-sjlj} library is to be selected on a permanent basis,
+If the `rts-sjlj' library is to be selected on a permanent basis,
these soft links can be modified with the following commands:
@quotation
If you are not interested in building PIE binaries, you can simply
turn this feature off by first compiling your code with @code{-fno-pie}
and then by linking with @code{-no-pie} (note the subtle but important
-difference in the names of the options – the linker option does @strong{not}
+difference in the names of the options – the linker option does `not'
have an @cite{f} after the dash!). When using gprbuild, this is
-achieved by updating the @emph{Required_Switches} attribute in package @cite{Compiler}
-and, depending on your type of project, either attribute @emph{Switches}
-or attribute @emph{Library_Options} in package @cite{Linker}.
+achieved by updating the `Required_Switches' attribute in package @cite{Compiler}
+and, depending on your type of project, either attribute `Switches'
+or attribute `Library_Options' in package @cite{Linker}.
On the other hand, if you would like to build PIE binaries and you are
getting the error above, a quick and easy workaround to allow linking
caller) is in charge of cleaning the stack on routine exit. In addition,
the name of a routine with @code{Stdcall} calling convention is mangled by
adding a leading underscore (as for the @code{C} calling convention) and a
-trailing @code{@@@emph{nn}}, where @code{nn} is the overall size (in
+trailing @code{@@@var{nn}}, where @code{nn} is the overall size (in
bytes) of the parameters passed to the routine.
The name to use on the Ada side when importing a C routine with a
@code{Stdcall} calling convention is the name of the C routine. The leading
-underscore and trailing @code{@@@emph{nn}} are added automatically by
+underscore and trailing @code{@@@var{nn}} are added automatically by
the compiler. For instance the Win32 function:
@quotation
then the imported routine is @code{retrieve_val}, that is, there is no
decoration at all. No leading underscore and no Stdcall suffix
-@code{@@@emph{nn}}.
+@code{@@@var{nn}}.
This is especially important as in some special cases a DLL’s entry
-point name lacks a trailing @code{@@@emph{nn}} while the exported
+point name lacks a trailing @code{@@@var{nn}} while the exported
name generated for a call has it.
It is also possible to import variables defined in a DLL by using an
@table @asis
-@item @emph{LIBRARY name}
+@item `LIBRARY name'
This section, which is optional, gives the name of the DLL.
-@item @emph{DESCRIPTION string}
+@item `DESCRIPTION string'
This section, which is optional, gives a description string that will be
embedded in the import library.
-@item @emph{EXPORTS}
+@item `EXPORTS'
This section gives the list of exported symbols (procedures, functions or
variables). For instance in the case of @code{API.dll} the @code{EXPORTS}
@end example
@end table
-Note that you must specify the correct suffix (@code{@@@emph{nn}})
+Note that you must specify the correct suffix (@code{@@@var{nn}})
(see @ref{1d6,,Windows Calling Conventions}) for a Stdcall
calling convention function in the exported symbols list.
@end example
Note that if some routines in the DLL have the @code{Stdcall} convention
-(@ref{1d6,,Windows Calling Conventions}) with stripped @code{@@@emph{nn}}
+(@ref{1d6,,Windows Calling Conventions}) with stripped @code{@@@var{nn}}
suffix then you’ll have to edit @code{api.def} to add it, and specify
@code{-k} to @code{gnatdll} when creating the import library.
-Here are some hints to find the right @code{@@@emph{nn}} suffix.
+Here are some hints to find the right @code{@@@var{nn}} suffix.
@itemize -
@geindex building
There is nothing specific to Windows in the build process.
-See the @emph{Library Projects} section in the @emph{GNAT Project Manager}
-chapter of the @emph{GPRbuild User’s Guide}.
+See the `Library Projects' section in the `GNAT Project Manager'
+chapter of the `GPRbuild User’s Guide'.
Due to a system limitation, it is not possible under Windows to create threads
when inside the @code{DllMain} routine which is used for auto-initialization
binutils tool will not be relocatable anymore. To build a DLL without
debug information pass @code{-largs -s} to @code{gnatdll}. This
restriction does not apply to a DLL built using a Library Project.
-See the @emph{Library Projects} section in the @emph{GNAT Project Manager}
-chapter of the @emph{GPRbuild User’s Guide}.
+See the `Library Projects' section in the `GNAT Project Manager'
+chapter of the `GPRbuild User’s Guide'.
@c Limitations_When_Using_Ada_DLLs_from Ada:
@table @asis
-@item @code{-a[@emph{address}]}
+@item @code{-a[`address']}
Build a non-relocatable DLL at @code{address}. If @code{address} is not
specified the default address @code{0x11000000} will be used. By default,
@geindex -b (gnatdll)
-@item @code{-b @emph{address}}
+@item @code{-b `address'}
Set the relocatable DLL base address. By default the address is
@code{0x11000000}.
@geindex -bargs (gnatdll)
-@item @code{-bargs @emph{opts}}
+@item @code{-bargs `opts'}
Binder options. Pass @code{opts} to the binder.
@geindex -d (gnatdll)
-@item @code{-d @emph{dllfile}}
+@item @code{-d `dllfile'}
@code{dllfile} is the name of the DLL. This switch must be present for
@code{gnatdll} to do anything. The name of the generated import library is
@geindex -e (gnatdll)
-@item @code{-e @emph{deffile}}
+@item @code{-e `deffile'}
@code{deffile} is the name of the definition file.
@geindex -I (gnatdll)
-@item @code{-I@emph{dir}}
+@item @code{-I`dir'}
Direct @code{gnatdll} to search the @code{dir} directory for source and
object files needed to build the DLL.
@item @code{-k}
-Removes the @code{@@@emph{nn}} suffix from the import library’s exported
+Removes the @code{@@@var{nn}} suffix from the import library’s exported
names, but keeps them for the link names. You must specify this
option if you want to use a @code{Stdcall} function in a DLL for which
-the @code{@@@emph{nn}} suffix has been removed. This is the case for most
+the @code{@@@var{nn}} suffix has been removed. This is the case for most
of the Windows NT DLL for example. This option has no effect when
@code{-n} option is specified.
@geindex -l (gnatdll)
-@item @code{-l @emph{file}}
+@item @code{-l `file'}
The list of ALI and object files used to build the DLL are listed in
@code{file}, instead of being given in the command line. Each line in
@geindex -largs (gnatdll)
-@item @code{-largs @emph{opts}}
+@item @code{-largs `opts'}
Linker options. Pass @code{opts} to the linker.
@end table
@table @asis
-@item @code{--base-file @emph{basefile}}
+@item @code{--base-file `basefile'}
Read the base file @code{basefile} generated by the linker. This switch
is used to create a relocatable DLL.
@table @asis
-@item @code{--def @emph{deffile}}
+@item @code{--def `deffile'}
Read the definition file.
@end table
@table @asis
-@item @code{--dllname @emph{name}}
+@item @code{--dllname `name'}
Gives the name of the DLL. This switch is used to embed the name of the
DLL in the static import library generated by @code{dlltool} with switch
@item @code{-k}
-Kill @code{@@@emph{nn}} from exported names
+Kill @code{@@@var{nn}} from exported names
(@ref{1d6,,Windows Calling Conventions}
for a discussion about @code{Stdcall}-style symbols).
@end table
@table @asis
-@item @code{--output-exp @emph{exportfile}}
+@item @code{--output-exp `exportfile'}
Generate an export file @code{exportfile}. The export file contains the
export table (list of symbols in the DLL) and is used to create the DLL.
@table @asis
-@item @code{--output-lib @emph{libfile}}
+@item @code{--output-lib `libfile'}
Generate a static import library @code{libfile}.
@end table
@table @asis
-@item @code{--as @emph{assembler-name}}
+@item @code{--as `assembler-name'}
Use @code{assembler-name} as the assembler. The default is @code{as}.
@end table
@end example
@item
-Use the Windows @emph{Task Manager} to find the process ID. Let’s say
+Use the Windows `Task Manager' to find the process ID. Let’s say
that the process PID for @code{main.exe} is 208.
@item
It is possible to specify the program stack size at link time. On modern
versions of Windows, starting with XP, this is mostly useful to set the size of
the main stack (environment task). The other task stacks are set with pragma
-Storage_Size or with the @emph{gnatbind -d} command.
+Storage_Size or with the `gnatbind -d' command.
Since older versions of Windows (2000, NT4, etc.) do not allow setting the
reserve size of individual tasks, the link-time stack size applies to all
@geindex Binder output (example)
This Appendix displays the source code for the output file
-generated by @emph{gnatbind} for a simple ‘Hello World’ program.
+generated by `gnatbind' for a simple ‘Hello World’ program.
Comments have been added for clarification purposes.
@example
@section Elaboration Code
-Ada defines the term @emph{execution} as the process by which a construct achieves
-its run-time effect. This process is also referred to as @strong{elaboration} for
-declarations and @emph{evaluation} for expressions.
+Ada defines the term `execution' as the process by which a construct achieves
+its run-time effect. This process is also referred to as `elaboration' for
+declarations and `evaluation' for expressions.
The execution model in Ada allows for certain sections of an Ada program to be
executed prior to execution of the program itself, primarily with the intent of
-initializing data. These sections are referred to as @strong{elaboration code}.
+initializing data. These sections are referred to as `elaboration code'.
Elaboration code is executed as follows:
@item
The environment task executes all elaboration code (if available) for all
units within that partition. This code is said to be executed at
-@strong{elaboration time}.
+`elaboration time'.
@item
The environment task executes the Ada program (if available) for that
@itemize *
@item
-@emph{Invocation}
+`Invocation'
The act of calling a subprogram, instantiating a generic, or activating a
task.
@item
-@emph{Scenario}
+`Scenario'
A construct that is elaborated or invoked by elaboration code is referred to
-as an @emph{elaboration scenario} or simply a @strong{scenario}. GNAT recognizes the
+as an `elaboration scenario' or simply a `scenario'. GNAT recognizes the
following scenarios:
@end itemize
@item
-@emph{Target}
+`Target'
-A construct elaborated by a scenario is referred to as @emph{elaboration target}
-or simply @strong{target}. GNAT recognizes the following targets:
+A construct elaborated by a scenario is referred to as `elaboration target'
+or simply `target'. GNAT recognizes the following targets:
@itemize -
@itemize *
@item
-@emph{Library level}
+`Library level'
A scenario appears at the library level when it is encapsulated by a package
[body] compilation unit, ignoring any other package [body] declarations in
the spec of unit @code{Client} is elaborated.
@item
-@emph{Package body statements}
+`Package body statements'
A scenario appears within the statement sequence of a package body when it is
bounded by the region starting from the @code{begin} keyword of the package body
The sequence by which the elaboration code of all units within a partition is
-executed is referred to as @strong{elaboration order}.
+executed is referred to as `elaboration order'.
Within a single unit, elaboration code is executed in sequential order.
@itemize *
@item
-@emph{with}ed units
+`with'ed units
@item
parent units
@end quotation
The following elaboration order exhibits a fundamental problem referred to as
-@emph{access-before-elaboration} or simply @strong{ABE}.
+`access-before-elaboration' or simply `ABE'.
@quotation
Ada states that a total elaboration order must exist, but it does not define
what this order is. A compiler is thus tasked with choosing a suitable
-elaboration order which satisfies the dependencies imposed by @emph{with} clauses,
+elaboration order which satisfies the dependencies imposed by `with' clauses,
unit categorization, elaboration-control pragmas, and invocations performed in
elaboration code. Ideally an order that avoids ABE problems should be chosen,
however a compiler may not always find such an order due to complications with
@itemize *
@item
-@emph{Static semantics}
+`Static semantics'
Static semantic rules restrict the possible choice of elaboration order. For
-instance, if unit Client @emph{with}s unit Server, then the spec of Server is
+instance, if unit Client `with's unit Server, then the spec of Server is
always elaborated prior to Client. The same principle applies to child units
- the spec of a parent unit is always elaborated prior to the child unit.
@item
-@emph{Dynamic semantics}
+`Dynamic semantics'
Dynamic checks are performed at run time, to ensure that a target is
elaborated prior to a scenario that invokes it, thus avoiding ABE problems.
@itemize -
@item
-@emph{Restrictions on calls}
+`Restrictions on calls'
An entry, operator, or subprogram can be called from elaboration code only
when the corresponding body has been elaborated.
@item
-@emph{Restrictions on instantiations}
+`Restrictions on instantiations'
A generic unit can be instantiated by elaboration code only when the
corresponding body has been elaborated.
@item
-@emph{Restrictions on task activation}
+`Restrictions on task activation'
A task can be activated by elaboration code only when the body of the
associated task type has been elaborated.
The restrictions above can be summarized by the following rule:
-@emph{If a target has a body, then this body must be elaborated prior to the
-scenario that invokes the target.}
+`If a target has a body, then this body must be elaborated prior to the
+scenario that invokes the target.'
@item
-@emph{Elaboration control}
+`Elaboration control'
Pragmas are provided for the programmer to specify the desired elaboration
order.
@itemize *
@item
-@emph{Packages without a body}
+`Packages without a body'
A library package which does not require a completing body does not suffer
from ABE problems.
@itemize *
@item
-@emph{pragma Pure}
+`pragma Pure'
Pragma @code{Pure} places sufficient restrictions on a unit to guarantee that no
scenario within the unit can result in an ABE problem.
@itemize *
@item
-@emph{pragma Preelaborate}
+`pragma Preelaborate'
Pragma @code{Preelaborate} is slightly less restrictive than pragma @code{Pure},
but still strong enough to prevent ABE problems within a unit.
@itemize *
@item
-@emph{pragma Elaborate_Body}
+`pragma Elaborate_Body'
Pragma @code{Elaborate_Body} requires that the body of a unit is elaborated
immediately after its spec. This restriction guarantees that no client
@end example
because the spec of @code{Server} must be elaborated prior to @code{Client} by
-virtue of the @emph{with} clause, and in addition the body of @code{Server} must be
+virtue of the `with' clause, and in addition the body of @code{Server} must be
elaborated immediately after the spec of @code{Server}.
Removing pragma @code{Elaborate_Body} could result in the following incorrect
@itemize *
@item
-@emph{pragma Elaborate (Unit)}
+`pragma Elaborate (Unit)'
Pragma @code{Elaborate} can be placed in the context clauses of a unit, after a
-@emph{with} clause. It guarantees that both the spec and body of its argument will
+`with' clause. It guarantees that both the spec and body of its argument will
be elaborated prior to the unit with the pragma. Note that other unrelated
units may be elaborated in between the spec and the body.
@itemize *
@item
-@emph{pragma Elaborate_All (Unit)}
+`pragma Elaborate_All (Unit)'
Pragma @code{Elaborate_All} is placed in the context clauses of a unit, after
-a @emph{with} clause. It guarantees that both the spec and body of its argument
+a `with' clause. It guarantees that both the spec and body of its argument
will be elaborated prior to the unit with the pragma, as well as all units
-@emph{with}ed by the spec and body of the argument, recursively. Note that other
+`with'ed by the spec and body of the argument, recursively. Note that other
unrelated units may be elaborated in between the spec and the body.
@example
All pragmas shown above can be summarized by the following rule:
-@emph{If a client unit elaborates a server target directly or indirectly, then if
+`If a client unit elaborates a server target directly or indirectly, then if
the server unit requires a body and does not have pragma Pure, Preelaborate,
or Elaborate_Body, then the client unit should have pragma Elaborate or
-Elaborate_All for the server unit.}
+Elaborate_All for the server unit.'
If the rule outlined above is not followed, then a program may fall in one of
the following states:
@itemize *
@item
-@emph{No elaboration order exists}
+`No elaboration order exists'
In this case a compiler must diagnose the situation, and refuse to build an
executable program.
@item
-@emph{One or more incorrect elaboration orders exist}
+`One or more incorrect elaboration orders exist'
In this case a compiler can build an executable program, but
@code{Program_Error} will be raised when the program is run.
@item
-@emph{Several elaboration orders exist, some correct, some incorrect}
+`Several elaboration orders exist, some correct, some incorrect'
In this case the programmer has not controlled the elaboration order. As a
result, a compiler may or may not pick one of the correct orders, and the
even another version of the same compiler.
@item
-@emph{One or more correct orders exist}
+`One or more correct orders exist'
In this case a compiler can build an executable program, and the program is
run successfully. This state may be guaranteed by following the outlined
@itemize *
@item
-@emph{Dynamic elaboration model}
+`Dynamic elaboration model'
This is the most permissive of the three elaboration models and emulates the
behavior specified by the Ada Reference Manual. When the dynamic model is in
that invoke internal targets. In addition, GNAT generates run-time checks for
all external targets and for all scenarios that may exhibit ABE problems.
-The elaboration order is obtained by honoring all @emph{with} clauses, purity and
+The elaboration order is obtained by honoring all `with' clauses, purity and
preelaborability of units, and elaboration-control pragmas. The dynamic model
attempts to take all invocations in elaboration code into account. If an
invocation leads to a circularity, GNAT ignores the invocation based on the
@itemize *
@item
-@emph{Static elaboration model}
+`Static elaboration model'
This is the middle ground of the three models. When the static model is in
effect, GNAT makes the following assumptions:
that invoke internal targets. In addition, GNAT generates run-time checks for
all external targets and for all scenarios that may exhibit ABE problems.
-The elaboration order is obtained by honoring all @emph{with} clauses, purity and
+The elaboration order is obtained by honoring all `with' clauses, purity and
preelaborability of units, presence of elaboration-control pragmas, and all
invocations in elaboration code. An order obtained using the static model is
guaranteed to be ABE problem-free, excluding dispatching calls and
@itemize *
@item
-@emph{SPARK elaboration model}
+`SPARK elaboration model'
This is the most conservative of the three models and enforces the SPARK
rules of elaboration as defined in the SPARK Reference Manual, section 7.7.
@itemize *
@item
-@emph{Legacy elaboration models}
+`Legacy elaboration models'
In addition to the three elaboration models outlined above, GNAT provides the
following legacy models:
@itemize *
@item
-A client unit compiled with the dynamic model can only @emph{with} a server unit
+A client unit compiled with the dynamic model can only `with' a server unit
that meets at least one of the following criteria:
execution. The warnings can be suppressed selectively with @code{pragma Warnings
(Off)} or globally with compiler switch @code{-gnatwL}.
-A @emph{guaranteed ABE} arises when the body of a target is not elaborated early
-enough, and causes @emph{all} scenarios that directly invoke the target to fail.
+A `guaranteed ABE' arises when the body of a target is not elaborated early
+enough, and causes `all' scenarios that directly invoke the target to fail.
@quotation
@end example
@end quotation
-A @emph{conditional ABE} arises when the body of a target is not elaborated early
-enough, and causes @emph{some} scenarios that directly invoke the target to fail.
+A `conditional ABE' arises when the body of a target is not elaborated early
+enough, and causes `some' scenarios that directly invoke the target to fail.
@quotation
@section Elaboration Circularities
-An @strong{elaboration circularity} occurs whenever the elaboration of a set of
+An `elaboration circularity' occurs whenever the elaboration of a set of
units enters a deadlocked state, where each unit is waiting for another unit
-to be elaborated. This situation may be the result of improper use of @emph{with}
+to be elaborated. This situation may be the result of improper use of `with'
clauses, elaboration-control pragmas, or invocations in elaboration code.
The following example exhibits an elaboration circularity.
When faced with an elaboration circularity, the programmer should also consider
the tactics given in the suggestions section of the circularity diagnostic.
-Depending on the units involved in the circularity, their @emph{with} clauses,
+Depending on the units involved in the circularity, their `with' clauses,
purity, preelaborability, presence of elaboration-control pragmas and
invocations at elaboration time, the binder may suggest one or more of the
following tactics to eliminate the circularity:
@item
The removal of the pragma will not eliminate the semantic effects of the
-pragma. In other words, the argument of the pragma along with its @emph{with}
+pragma. In other words, the argument of the pragma along with its `with'
closure will still be elaborated prior to the unit containing the pragma.
@item
@itemize -
@item
-@emph{Dynamic model}
+`Dynamic model'
GNAT will indicate missing @code{Elaborate} and @code{Elaborate_All} pragmas for
all library-level scenarios within the partition.
@item
-@emph{Static model}
+`Static model'
GNAT will indicate all scenarios invoked during elaboration. In addition,
it will provide detailed traceback when an implicit @code{Elaborate} or
@code{Elaborate_All} pragma is generated.
@item
-@emph{SPARK model}
+`SPARK model'
GNAT will indicate how an elaboration requirement is met by the context of
a unit. This diagnostic requires compiler switch @code{-gnatd.v}.
@display
-@emph{Register names}@w{ }
+`Register names'@w{ }
@display
gcc / @code{as}: Prefix with ‘%’; for example @code{%eax}@w{ }
Intel: No extra punctuation; for example @code{eax}@w{ }
@display
-@emph{Immediate operand}@w{ }
+`Immediate operand'@w{ }
@display
gcc / @code{as}: Prefix with ‘$’; for example @code{$4}@w{ }
Intel: No extra punctuation; for example @code{4}@w{ }
@display
-@emph{Address}@w{ }
+`Address'@w{ }
@display
gcc / @code{as}: Prefix with ‘$’; for example @code{$loc}@w{ }
Intel: No extra punctuation; for example @code{loc}@w{ }
@display
-@emph{Memory contents}@w{ }
+`Memory contents'@w{ }
@display
gcc / @code{as}: No extra punctuation; for example @code{loc}@w{ }
Intel: Square brackets; for example @code{[loc]}@w{ }
@display
-@emph{Register contents}@w{ }
+`Register contents'@w{ }
@display
gcc / @code{as}: Parentheses; for example @code{(%eax)}@w{ }
Intel: Square brackets; for example @code{[eax]}@w{ }
@display
-@emph{Hexadecimal numbers}@w{ }
+`Hexadecimal numbers'@w{ }
@display
gcc / @code{as}: Leading ‘0x’ (C language syntax); for example @code{0xA0}@w{ }
Intel: Trailing ‘h’; for example @code{A0h}@w{ }
@display
-@emph{Operand size}@w{ }
+`Operand size'@w{ }
@display
gcc / @code{as}: Explicit in op code; for example @code{movw} to move a 16-bit word@w{ }
Intel: Implicit, deduced by assembler; for example @code{mov}@w{ }
@display
-@emph{Instruction repetition}@w{ }
+`Instruction repetition'@w{ }
@display
gcc / @code{as}: Split into two lines; for example@w{ }
@display
@display
-@emph{Order of operands}@w{ }
+`Order of operands'@w{ }
@display
gcc / @code{as}: Source first; for example @code{movw $4, %eax}@w{ }
Intel: Destination first; for example @code{mov eax, 4}@w{ }
@end quotation
@code{Asm} is a procedure declared in package @code{System.Machine_Code};
-here it takes one parameter, a @emph{template string} that must be a static
+here it takes one parameter, a `template string' that must be a static
expression and that will form the generated instruction.
@code{Asm} may be regarded as a compile-time procedure that parses
the template string and additional parameters (none here),
@multitable {xxxxxxxx} {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx}
@item
-@emph{=}
+`='
@tab
@item
-@emph{g}
+`g'
@tab
@item
-@emph{m}
+`m'
@tab
@item
-@emph{I}
+`I'
@tab
@item
-@emph{a}
+`a'
@tab
@item
-@emph{b}
+`b'
@tab
@item
-@emph{c}
+`c'
@tab
@item
-@emph{d}
+`d'
@tab
@item
-@emph{S}
+`S'
@tab
@item
-@emph{D}
+`D'
@tab
@item
-@emph{r}
+`r'
@tab
@item
-@emph{q}
+`q'
@tab
in one constraint string.
You specify the association of an output variable with an assembler operand
-through the @code{%@emph{n}} notation, where @emph{n} is a non-negative
+through the @code{%@var{n}} notation, where `n' is a non-negative
integer. Thus in
@quotation
@end quotation
The Clobber parameter is a static string expression specifying the
-register(s) you are using. Note that register names are @emph{not} prefixed
+register(s) you are using. Note that register names are `not' prefixed
by a percent sign. Also, if more than one register is used then their names
are separated by commas; e.g., @code{"eax, ebx"}
Everyone is permitted to copy and distribute verbatim copies of this
license document, but changing it is not allowed.
-@strong{Preamble}
+`Preamble'
The purpose of this License is to make a manual, textbook, or other
functional and useful document “free” in the sense of freedom: to
whether it is published as a printed book. We recommend this License
principally for works whose purpose is instruction or reference.
-@strong{1. APPLICABILITY AND DEFINITIONS}
+`1. APPLICABILITY AND DEFINITIONS'
This License applies to any manual or other work, in any medium, that
contains a notice placed by the copyright holder saying it can be
distributed under the terms of this License. Such a notice grants a
world-wide, royalty-free license, unlimited in duration, to use that
-work under the conditions stated herein. The @strong{Document}, below,
+work under the conditions stated herein. The `Document', below,
refers to any such manual or work. Any member of the public is a
-licensee, and is addressed as “@strong{you}”. You accept the license if you
+licensee, and is addressed as “`you'”. You accept the license if you
copy, modify or distribute the work in a way requiring permission
under copyright law.
-A “@strong{Modified Version}” of the Document means any work containing the
+A “`Modified Version'” of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with
modifications and/or translated into another language.
-A “@strong{Secondary Section}” is a named appendix or a front-matter section of
+A “`Secondary Section'” is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the
publishers or authors of the Document to the Document’s overall subject
(or to related matters) and contains nothing that could fall directly
commercial, philosophical, ethical or political position regarding
them.
-The “@strong{Invariant Sections}” are certain Secondary Sections whose titles
+The “`Invariant Sections'” are certain Secondary Sections whose titles
are designated, as being those of Invariant Sections, in the notice
that says that the Document is released under this License. If a
section does not fit the above definition of Secondary then it is not
Invariant Sections. If the Document does not identify any Invariant
Sections then there are none.
-The “@strong{Cover Texts}” are certain short passages of text that are listed,
+The “`Cover Texts'” are certain short passages of text that are listed,
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
the Document is released under this License. A Front-Cover Text may
be at most 5 words, and a Back-Cover Text may be at most 25 words.
-A “@strong{Transparent}” copy of the Document means a machine-readable copy,
+A “`Transparent'” copy of the Document means a machine-readable copy,
represented in a format whose specification is available to the
general public, that is suitable for revising the document
straightforwardly with generic text editors or (for images composed of
format whose markup, or absence of markup, has been arranged to thwart
or discourage subsequent modification by readers is not Transparent.
An image format is not Transparent if used for any substantial amount
-of text. A copy that is not “Transparent” is called @strong{Opaque}.
+of text. A copy that is not “Transparent” is called `Opaque'.
Examples of suitable formats for Transparent copies include plain
ASCII without markup, Texinfo input format, LaTeX input format, SGML
machine-generated HTML, PostScript or PDF produced by some word
processors for output purposes only.
-The “@strong{Title Page}” means, for a printed book, the title page itself,
+The “`Title Page'” means, for a printed book, the title page itself,
plus such following pages as are needed to hold, legibly, the material
this License requires to appear in the title page. For works in
formats which do not have any title page as such, “Title Page” means
the text near the most prominent appearance of the work’s title,
preceding the beginning of the body of the text.
-The “@strong{publisher}” means any person or entity that distributes
+The “`publisher'” means any person or entity that distributes
copies of the Document to the public.
-A section “@strong{Entitled XYZ}” means a named subunit of the Document whose
+A section “`Entitled XYZ'” means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following
text that translates XYZ in another language. (Here XYZ stands for a
-specific section name mentioned below, such as “@strong{Acknowledgements}”,
-“@strong{Dedications}”, “@strong{Endorsements}”, or “@strong{History}”.)
-To “@strong{Preserve the Title}”
+specific section name mentioned below, such as “`Acknowledgements'”,
+“`Dedications'”, “`Endorsements'”, or “`History'”.)
+To “`Preserve the Title'”
of such a section when you modify the Document means that it remains a
section “Entitled XYZ” according to this definition.
implication that these Warranty Disclaimers may have is void and has
no effect on the meaning of this License.
-@strong{2. VERBATIM COPYING}
+`2. VERBATIM COPYING'
You may copy and distribute the Document in any medium, either
commercially or noncommercially, provided that this License, the
You may also lend copies, under the same conditions stated above, and
you may publicly display copies.
-@strong{3. COPYING IN QUANTITY}
+`3. COPYING IN QUANTITY'
If you publish printed copies (or copies in media that commonly have
printed covers) of the Document, numbering more than 100, and the
Document well before redistributing any large number of copies, to give
them a chance to provide you with an updated version of the Document.
-@strong{4. MODIFICATIONS}
+`4. MODIFICATIONS'
You may copy and distribute a Modified Version of the Document under
the conditions of sections 2 and 3 above, provided that you release
give permission to use their names for publicity for or to assert or
imply endorsement of any Modified Version.
-@strong{5. COMBINING DOCUMENTS}
+`5. COMBINING DOCUMENTS'
You may combine the Document with other documents released under this
License, under the terms defined in section 4 above for modified
and any sections Entitled “Dedications”. You must delete all sections
Entitled “Endorsements”.
-@strong{6. COLLECTIONS OF DOCUMENTS}
+`6. COLLECTIONS OF DOCUMENTS'
You may make a collection consisting of the Document and other documents
released under this License, and replace the individual copies of this
License into the extracted document, and follow this License in all
other respects regarding verbatim copying of that document.
-@strong{7. AGGREGATION WITH INDEPENDENT WORKS}
+`7. AGGREGATION WITH INDEPENDENT WORKS'
A compilation of the Document or its derivatives with other separate
and independent documents or works, in or on a volume of a storage or
Otherwise they must appear on printed covers that bracket the whole
aggregate.
-@strong{8. TRANSLATION}
+`8. TRANSLATION'
Translation is considered a kind of modification, so you may
distribute translations of the Document under the terms of section 4.
its Title (section 1) will typically require changing the actual
title.
-@strong{9. TERMINATION}
+`9. TERMINATION'
You may not copy, modify, sublicense, or distribute the Document
except as expressly provided under this License. Any attempt
reinstated, receipt of a copy of some or all of the same material does
not give you any rights to use it.
-@strong{10. FUTURE REVISIONS OF THIS LICENSE}
+`10. FUTURE REVISIONS OF THIS LICENSE'
The Free Software Foundation may publish new, revised versions
of the GNU Free Documentation License from time to time. Such new
version permanently authorizes you to choose that version for the
Document.
-@strong{11. RELICENSING}
+`11. RELICENSING'
“Massive Multiauthor Collaboration Site” (or “MMC Site”) means any
World Wide Web server that publishes copyrightable works and also
under CC-BY-SA on the same site at any time before August 1, 2009,
provided the MMC is eligible for relicensing.
-@strong{ADDENDUM: How to use this License for your documents}
+`ADDENDUM: How to use this License for your documents'
To use this License in a document you have written, include a copy of
the License in the document and put the following copyright and
projects / thirdparty / gcc.git / commitdiff
