--- /dev/null
+.. _Implementation_of_Ada_2022_Features:
+
+***********************************
+Implementation of Ada 2022 Features
+***********************************
+
+.. index:: Ada 2022 implementation status
+
+.. index:: -gnat22 option (gcc)
+
+.. index:: pragma Ada_2022
+
+.. index:: configuration pragma Ada_2022
+
+.. index:: Ada_2022 configuration pragma
+
+This chapter contains a complete list of Ada 2022 features that have been
+implemented. Generally, these features are only available if the *-gnat22* (Ada 2022 features enabled) option is set, or if the configuration pragma ``Ada_2022`` is used.
+
+However, new pragmas, attributes, and restrictions are unconditionally available, since the Ada standard allows the addition of new pragmas, attributes, and restrictions (there are exceptions, which are
+documented in the individual descriptions), and also certain packages
+were made available in earlier versions of Ada.
+
+An ISO date (YYYY-MM-DD) appears in parentheses on the description line.
+This date shows the implementation date of the feature. Any wavefront
+subsequent to this date will contain the indicated feature, as will any
+subsequent releases. A date of 0000-00-00 means that GNAT has always
+implemented the feature, or implemented it as soon as it appeared as a
+binding interpretation.
+
+Each feature corresponds to an Ada Issue ('AI') approved by the Ada
+standardization group (ISO/IEC JTC1/SC22/WG9) for inclusion in Ada 2022.
+
+The section "RM references" lists all modified paragraphs in the Ada 2012 reference manual. The details of each modification as well as a complete description of the AIs may be found in
+http://www.ada-auth.org/AI12-SUMMARY.HTML.
+
+.. index:: AI12-0001 (Ada 2022 feature)
+
+* *AI12-0001 Independence and Representation clauses for atomic objects (2019-11-27)*
+
+ The compiler accepts packing clauses in all cases, even if they have effectively no influence on the layout. Types, where packing is essentially infeasible are, for instance atomic, aliased and by-reference types.
+
+ RM references: 13.02 (6.1/2) 13.02 (7) 13.02 (8) 13.02 (9/3) C.06 (8.1/3)
+ C.06 (10) C.06 (11) C.06 (21) C.06 (24)
+
+.. index:: AI12-0003 (Ada 2022 feature)
+
+* *AI12-0003 Specifying the standard storage pool (2020-06-25)*
+
+ Allows the standard storage pool being specified with a ``Default_Storage_Pool`` pragma or aspect.
+
+ RM references: 8.02 (11) 13.11.03 (1/3) 13.11.03 (3.1/3) 13.11.03 (4/3)
+ 13.11.03 (4.1/3) 13.11.03 (5/3) 13.11.03 (6.2/3) 13.11.03
+ (6.3/3)
+
+.. index:: AI12-0004 (Ada 2022 feature)
+
+* *AI12-0004 Normalization and allowed characters for identifiers (2020-06-11)*
+
+ This AI clarifies that Ada identifiers containing characters which are not
+ allowed in Normalization Form KC are illegal.
+
+ RM references: 2.01 (4.1/3) 2.03 (4/3) A.03.02 (4/3) A.03.02 (32.5/3)
+ A.03.05 (18/3) A.03.05 (51/3)
+
+.. index:: AI12-0020 (Ada 2022 feature)
+
+* *AI12-0020 'Image for all types (2020-03-30)*
+
+ Put_Image prints out a human-readable representation of an object. The
+ functionality in Ada2022 RM is fully implemented except the support for
+ types in the ``Remote_Types`` packages.
+
+ RM references: 4.10 (0) 3.05 (27.1/2) 3.05 (27.2/2) 3.05 (27.3/2) 3.05
+ (27.4/2) 3.05 (27.5/2) 3.05 (27.6/2) 3.05 (27.7/2) 3.05 (28) 3.05
+ (29) 3.05 (30/3) 3.05 (31) 3.05 (32) 3.05 (33/3) 3.05 (37.1/2)
+ 3.05 (38) 3.05 (39) 3.05 (43/3) 3.05 (55/3) 3.05 (55.1/5) 3.05
+ (55.2/4) 3.05 (55.3/4) 3.05 (55.4/4) 3.05 (59) H.04 (23) H.04 (23.8/2)
+
+.. index:: AI12-0022 (Ada 2022 feature)
+
+* *AI12-0022 Raise_Expressions (2013-01-27)*
+
+ This feature allows you to write "raise NAME [with STRING]" in an
+ expression to rise given exception. It is particularly useful in the case of
+ assertions such as preconditions allowing to specify which exception a
+ precondition raises if it fails.
+
+ RM references: 4.04 (3/3) 11.02 (6) 11.03 (2/2) 11.03 (3) 11.03 (3.1/2)
+ 11.03 (4/2) 11.04.01 (10.1/3)
+
+.. index:: AI12-0027 (Ada 2022 feature)
+
+* *AI12-0027 Access values should never designate unaliased components (2020-06-15)*
+
+ AI12-0027 adds a requirement for a value conversion that converts from an array of unaliased components to an array of aliased components to make a copy. It defines such conversions to have a local accessibility, effectively preventing the possibility of unsafe accesses to unaliased components.
+
+ RM references: 4.06 (24.17/3) 4.06 (24.21/2) 4.06 (58) 6.02 (10/3) 3.10.02 (10/3)
+
+.. index:: AI12-0028 (Ada 2022 feature)
+
+* *AI12-0028 Import of variadic C functions (2020-03-03)*
+
+ Ada programs can now properly call variadic C functions by means of the
+ conventions C_Variadic_<n>, for small integer values <n>.
+
+ RM references: B.03 (1/3) B.03 (60.15/3) B.03 (75)
+
+.. index:: AI12-0030 (Ada 2022 feature)
+
+* *AI12-0030 Formal derived types and stream attribute availability (2020-08-21)*
+
+ Corner cases involving streaming operations for formal derived limited types
+ that are now defined to raise Program_Error. Before, behavior in these cases
+ was undefined. Stream attribute availability is more precisely computed in cases where a derived type declaration occurs ahead of a streaming attribute specification for the parent type.
+
+ RM references: 12.05.01 (21/3) 13.13.02 (49/2)
+
+.. index:: AI12-0031 (Ada 2022 feature)
+
+* *AI12-0031 All_Calls_Remote and indirect calls (0000-00-00)*
+
+ Remote indirect calls (i.e., calls through a remote access-to-subprogram type)
+ behave the same as remote direct calls.
+
+ RM references: E.02.03 (19/3)
+
+.. index:: AI12-0032 (Ada 2022 feature)
+
+* *AI12-0032 Questions on 'Old (2020-04-24)*
+
+ AI12-0032 resolves several issues related to the 'Old attribute. The GNAT
+ compiler already implemented what the AI requires in most of those cases, but two having to do with static and dynamic checking of the accessibility level of the constant object implicitly declared for an 'Old attribute reference were not yet implemented. Accessibility checking for these constants is now implemented as defined in the AI.
+
+ RM references: 4.01.03 (9/3) 6.01.01 (22/3) 6.01.01 (26/3) 6.01.01 (35/3)
+
+.. index:: AI12-0033 (Ada 2022 feature)
+
+* *AI12-0033 Sets of CPUs when defining dispatching domains (0000-00-00)*
+
+ The set of CPUs associated with a dispatching domain is no longer required
+ to be a contiguous range of CPU values.
+
+ RM references: D.16.01 (7/3) D.16.01 (9/3) D.16.01 (20/3) D.16.01 (23/3)
+ D.16.01 (24/3) D.16.01 (26/3)
+
+.. index:: AI12-0035 (Ada 2022 feature)
+
+* *AI12-0035 Accessibility checks for indefinite elements of containers (0000-00-00)*
+
+ If the element type for an instance of one of the indefinite container generics has an access discriminant, then accessibility checks (at run-time) prevent inserting a value into a container object if the value's discriminant designates an object that is too short-lived (that is, if the designated object has an accessibility level that is deeper than that of the instance). Without this check, dangling references would be possible. GNAT handled this correctly already before this AI was issued.
+
+ RM references: A.18 (5/3) A.18.11 (8/2) A.18.12 (7/2) A.18.13 (8/2)
+ A.18.14 (8/2) A.18.15 (4/2) A.18.16 (4/2) A.18.17 (7/3) A.18.18
+ (39/3) A.18.18 (47/3)
+
+.. index:: AI12-0036 (Ada 2022 feature)
+
+* *AI12-0036 The actual for an untagged formal derived type cannot be tagged (2019-10-21)*
+
+ AI12-0036 is a binding interpretation that adds the following legality rule:
+ The actual type for a formal derived type shall be tagged if and only if the
+ formal derived type is a private extension. The check is implemented for all Ada dialects, not just Ada 2022.
+
+ RM references: 12.05.01 (5.1/3)
+
+.. index:: AI12-0037 (Ada 2022 feature)
+
+* *AI12-0037 New types in Ada.Locales can't be converted to/from strings (2016-09-10)*
+
+ The type definitions for Language_Code and Country_Code are now using dynamic
+ predicates.
+
+ RM references: A.19 (4/3)
+
+.. index:: AI12-0039 (Ada 2022 feature)
+
+* *AI12-0039 Ambiguity in syntax for membership expression removed (0000-00-00)*
+
+ An ambiguity in the syntax for membership expressions was resolved. For example, "A in B and C" can be parsed in only one way because of this AI.
+
+ RM references: 4.04 (3/3) 4.04 (3.2/3) 4.05.02 (3.1/3) 4.05.02 (4) 4.05.02
+ (4.1/3) 4.05.02 (27/3) 4.05.02 (27.1/3) 4.05.02 (28.1/3) 4.05.02
+ (28.2/3) 4.05.02 (29/3) 4.05.02 (30/3) 4.05.02 (30.1/3) 4.05.02
+ (30.2/3) 4.05.02 (30.3/3) 4.09 (11/3) 4.09 (32.6/3) 8.06 (27.1/3)
+ 3.02.04 (17/3)
+
+.. index:: AI12-0040 (Ada 2022 feature)
+
+* *AI12-0040 Resolving the selecting_expression of a case_expression (0000-00-00)*
+
+ The definition of "complete context" is corrected so that selectors of case expressions
+ and of case statements are treated uniformly.
+
+ RM references: 8.06 (9)
+
+.. index:: AI12-0041 (Ada 2022 feature)
+
+* *AI12-0041 Type_Invariant'Class for interface types (2016-12-12)*
+
+ Subprogram calls within class-wide type invariant expressions get resolved
+ as primitive operations instead of being dynamically dispatched.
+
+ RM references: 7.03.02 (1/3) 7.03.02 (3/3)
+
+.. index:: AI12-0042 (Ada 2022 feature)
+
+* *AI12-0042 Type invariant checking rules (2020-06-05)*
+
+ AI12-0042 adds rules for type invariants.
+ Specifically, when inheriting a private dispatching operation when the ancestor operation is visible at the point of the type extension, the operation must be abstract or else overridden. In addition, for a class-wide view conversion from an object of a specific type T to which a type invariant applies, an invariant check is performed when the conversion is within the immediate scope of T.
+
+ RM references: 7.03.02 (6/3) 7.03.02 (17/3) 7.03.02 (18/3) 7.03.02 (19/3)
+ 7.03.02 (20/3)
+
+.. index:: AI12-0043 (Ada 2022 feature)
+
+* *AI12-0043 Details of the storage pool used when Storage_Size is specified (0000-00-00)*
+
+ Clarify that a Storage_Size specification for an access type specifies both an upper bound and a lower bound (not just a lower bound) of the amount of storage allowed for allocated objects.
+
+ RM references: 13.11 (18)
+
+.. index:: AI12-0044 (Ada 2022 feature)
+
+* *AI12-0044 Calling visible functions from type invariant expressions (2020-05-11)*
+
+ AI05-0289-1 extends invariant checking to `in` parameters. However, this makes
+ it impossible to call a public function of the type from an invariant
+ expression, as that public function will attempt to check the invariant,
+ resulting in an infinite recursion.
+
+ This AI specifies, that type-invariant checking is performed on parameters
+ of mode `in` upon return from procedure calls, but not of `in`-mode
+ parameters in functions.
+
+ RM references: 7.03.02 (19/3)
+
+.. index:: AI12-0045 (Ada 2022 feature)
+
+* *AI12-0045 Pre- and Postconditions are allowed on generic subprograms (2015-03-17)*
+
+ The SPARK toolset now supports contracts on generic subprograms, packages and
+ their respective bodies.
+
+ RM references: 6.01.01 (1/3)
+
+.. index:: AI12-0046 (Ada 2022 feature)
+
+* *AI12-0046 Enforcing legality for anonymous access components in record aggregates (0000-00-00)*
+
+ For a record aggregate of the form (X | Y => ....), any relevant legality rules are checked for both for X and Y.
+
+ For example,
+
+ .. code::
+
+ X : aliased constant String := ... ;
+ type R is record
+ F1 : access constant String;
+ F2 : access String;
+ end record;
+ Obj : R := (F1 | F2 => X'Access); -- ok for F1, but illegal for F2
+
+ RM references: 4.03.01 (16/3)
+
+.. index:: AI12-0047 (Ada 2022 feature)
+
+* *AI12-0047 Generalized iterators and discriminant-dependent components (0000-00-00)*
+
+ Iterating over the elements of an array is subject to the same legality checks as renaming the array. For example, if an assignment to an enclosing discriminated object could cause an array object to cease to exist then we don't allow renaming the array. So it is similarly not allowed to iterate over the elements of such an array.
+
+ RM references: 5.05.02 (6/3)
+
+.. index:: AI12-0048 (Ada 2022 feature)
+
+* *AI12-0048 Default behavior of tasks on a multiprocessor with a specified dispatching policy (0000-00-00)*
+
+ Clarify that if the user does not impose requirements about what CPUs a given task might execute on, then the implementation does not get to impose such requirements. This avoids potential problems with priority inversion.
+
+ RM references: D.16.01 (30/3)
+
+.. index:: AI12-0049 (Ada 2022 feature)
+
+* *AI12-0049 Invariants need to be checked on the initialization of deferred constants (0000-00-00)*
+
+ Invariant checking for deferred constants (and subcomponents thereof) is performed. Corrects a clear oversight in the previous RM wording.
+
+ RM references: 7.03.02 (10/3)
+
+.. index:: AI12-0050 (Ada 2022 feature)
+
+* *AI12-0050 Conformance of quantified expressions (2016-07-22)*
+
+ Compiler rejects a subprogram body when an expression for a boolean formal
+ parameter includes a quantified expression, and the subprogram declaration
+ contains a textual copy of the same.
+
+ RM references: 6.03.01 (20) 6.03.01 (21)
+
+.. index:: AI12-0051 (Ada 2022 feature)
+
+* *AI12-0051 The Priority aspect can be specified when Attach_Handler is specified (0000-00-00)*
+
+ Previous RM wording had two contradictory rules for determining (in some cases) the priority of a protected subprogram that is attached to an interrupt. The AI clarifies which one of the rules takes precedence.
+
+ RM references: D.03 (10/3)
+
+.. index:: AI12-0052 (Ada 2022 feature)
+
+* *AI12-0052 Implicit objects are considered overlapping (0000-00-00)*
+
+ Clarify that the rules about unsynchronized concurrent access apply as one would expect in the case of predefined routines that access Text_IO's default input and default output files. There was no compiler changes needed to implement this.
+
+ RM references: A (3/2) A.10.03 (21)
+
+.. index:: AI12-0054-2 (Ada 2022 feature)
+
+* *AI12-0054-2 Aspect Predicate_Failure (0000-00-00)*
+
+ New aspect Predicate_Failure is defined. A solution for the problem that a predicate like
+
+ .. code::
+
+ subtype Open_File is File with Dynamic_Predicate =\> Is_Open (Open_File) or else (raise File_Not_Open);
+
+ does the wrong thing in the case of a membership test.
+
+ RM references: 3.02.04 (14/3) 3.02.04 (31/3) 3.02.04 (35/3)
+
+.. index:: AI12-0055 (Ada 2022 feature)
+
+* *AI12-0055 All properties of a usage profile are defined by pragmas (2020-06-09)*
+
+ AI12-0055 allows the use of the No_Dynamic_CPU_Assignment restriction in pragmas Restrictions and Restrictions_Warnings.
+
+ RM references: D.07 (10/3) D.13 (6/3) D.13 (8/3) D.13 (10/3)
+
+.. index:: AI12-0059 (Ada 2022 feature)
+
+* *AI12-0059 Object_Size attribute (2019-12-02)*
+
+ AI12-0059 brings GNAT-defined attribute Object_Size to Ada standard
+ and clarifies its semantics. Given that the attribute already existed in
+ GNAT compiler, the feature is supported for all language versions.
+
+ RM references: 4.09.01 (2/3) 13.01 (14) 13.01 (23) 13.03 (9/3) 13.03
+ (50/2) 13.03 (51) 13.03 (52) 13.03 (58)
+
+.. index:: AI12-0061 (Ada 2022 feature)
+
+* *AI12-0061 Iterated component associations in array aggregates (2016-09-01)*
+
+ Ada issue AI12-061 introduces a new construct in array aggregates allowing
+ component associations to be parameterized by a loop variable, for example:
+
+ .. code::
+
+ Array (1 .. 10) of Integer :=
+ (for I in 1 .. 10 => I ** 2);
+ type Matrix is
+ array
+ (Positive range <>, Positive range <>) of Float;
+ G : constant Matrix
+ :=
+ (for I in 1 .. 4 =>
+ (for J in 1 .. 4 =>
+ (if I=J then
+ 1.0 else 0.0))); -- Identity matrix
+
+ The expression in such an association can also be a function that returns a
+ limited type, and the range can be specified by the 'others' choice.
+
+ RM references: 4.03.03 (5/2) 4.03.03 (6) 4.03.03 (17/3) 4.03.03 (20)
+ 4.03.03 (23.1/4) 4.03.03 (32/3) 4.03.03 (43) 3.01 (6/3) 3.03 (6)
+ 3.03 (18.1/3) 3.03.01 (23/3) 5.05 (6) 8.01 (2.1/4)
+
+.. index:: AI12-0062 (Ada 2022 feature)
+
+* *AI12-0062 Raise exception with failing string function (0000-00-00)*
+
+ Clarify that if raising exception E1 is accompanied with a String-valued
+ expression whose evaluation raises exception E2, then E2 is what gets propagated.
+
+ RM references: 11.03 (4/2)
+
+.. index:: AI12-0065 (Ada 2022 feature)
+
+* *AI12-0065 Descendants of incomplete views (0000-00-00)*
+
+ This AI is a clarification of potentially confusing wording. GNAT correctly handles the example given in AARM 7.3.1(5.b-5.d), which illustrates the topic of this AI.
+
+ RM references: 7.03.01 (5.2/3)
+
+.. index:: AI12-0067 (Ada 2022 feature)
+
+* *AI12-0067 Accessibility level of explicitly aliased parameters of procedures and entries (0000-00-00)*
+
+ The AI fixes a case where the intent was fairly obvious but the RM wording failed to mention a case (with the result that the accessibility level of an explicitly aliased parameter of a procedure or entry was undefined even though the intent was clear).
+
+ RM references: 3.10.02 (7/3)
+
+.. index:: AI12-0068 (Ada 2022 feature)
+
+* *AI12-0068 Predicates and the current instance of a subtype (2020-05-06)*
+
+ AI12-0068 is a binding interpretation that defines the current instance name in a type or subtype aspect to be a value rather than an object. This affects
+ attributes whose prefix is a current instance in predicates, type invariants, and ``Default_Initial_Condition`` aspects. In particular, in the case of the ``Constrained`` attribute the value will always be True, and formerly legal attributes that require an object as their prefix (such as ``Size``, ``Access``, ``Address``, etc.) are illegal when applied to a current instance in type and subtype aspects.
+
+ RM references: 8.06 (17/3)
+
+.. index:: AI12-0069 (Ada 2022 feature)
+
+* *AI12-0069 Inconsistency in Tree container definition (0000-00-00)*
+
+ The description of how iteration over a Tree container's elements was contradictory in some cases regarding whether a cursor designating the Root node is included in the iteration. This contradiction was resolved. In the "!ACATS Test" section of the AI, it says that if an implementation were to get this wrong then almost any attempt to iterate over any tree would fail at runtime.
+
+ RM references: A.18.10 (153/3) A.18.10 (155/3) A.18.10 (157/3) A.18.10 (159/3)
+
+.. index:: AI12-0070 (Ada 2022 feature)
+
+* *AI12-0070 9.3(2) does not work for anonymous access types (0000-00-00)*
+
+ The RM contained some old wording about the master of an allocated object that only made sense for named access types. The AI clarifies the wording to clearly state the scope of validity and ensures that the paragraph does not contradict 3.10.2's rules for anonymous access types.
+
+ RM references: 3.10.02 (13.1/3) 9.03 (2)
+
+.. index:: AI12-0071 (Ada 2022 feature)
+
+* *AI12-0071 Order of evaluation when multiple predicates apply (2015-08-10)*
+
+ AI12-0071 specifies the semantics of multiple/inherited predicates on a
+ single subtype.
+
+ RM references: 3.02.04 (4/3) 3.02.04 (6/3) 3.02.04 (30/3) 3.02.04 (31/3)
+ 3.02.04 (32/3) 3.02.04 (33/3) 3.02.04 (35/3) 3.05.05 (7.1/3)
+ 3.05.05 (7.2/3) 3.05.05 (7.3/3) 3.08.01 (10.1/3) 3.08.01 (15/3)
+ 4.05.02 (29/3) 4.05.02 (30/3) 4.06 (51/3) 4.09.01 (10/3) 5.04
+ (7/3) 5.05 (9/3) 13.09.02 (3/3) 13.09.02 (12)
+
+.. index:: AI12-0072 (Ada 2022 feature)
+
+* *AI12-0072 Missing rules for Discard_Names aspect (0000-00-00)*
+
+ Clarify that Discard_Names is an aspect, not just a pragma.
+
+ RM references: C.05 (1) C.05 (5) C.05 (7/2) C.05 (8)
+
+.. index:: AI12-0073 (Ada 2022 feature)
+
+* *AI12-0073 Synchronous Barriers are not allowed with Ravenscar (2020-02-24)*
+
+ Ada 2022 adds (as a binding interpretation) a ``No_Dependence =>
+ Ada.Synchronous_Barriers`` restriction to the Ravenscar profile.
+
+ RM references: D.13 (6/3)
+
+.. index:: AI12-0074 (Ada 2022 feature)
+
+* *AI12-0074 View conversions and out parameters passed by copy (2020-03-26)*
+
+ This Ada 2022 AI makes illegal some cases of out parameters whose type has a
+ ``Default_Value`` aspect.
+
+ RM references: 4.06 (56) 6.04.01 (6.25/3) 6.04.01 (13.1/3)
+
+.. index:: AI12-0075 (Ada 2022 feature)
+
+* *AI12-0075 Static expression functions (2020-04-13)*
+
+ Ada 2022 defines a new aspect ``Static`` that can be specified on expression
+ functions. Such an expression function can be called in contexts requiring static expressions when the actual parameters are all static, allowing for greater abstraction in complex static expressions.
+
+ RM references: 4.09 (21) 6.08 (3/4) 6.08 (5/4) 6.08 (6/4) 7.03.02 (8.2/5)
+ 7.03.02 (15/4) 7.03.02 (16/4) 7.03.02 (17/4) 7.03.02 (19/4)
+ 7.03.02 (20/5)
+
+.. index:: AI12-0076 (Ada 2022 feature)
+
+* *AI12-0076 Variable state in pure packages (0000-00-00)*
+
+ Defines an obscure constant-modifying construct to be erroneous. The issue is that the current instance of a type is a variable object, so the following is legal:
+
+ .. code::
+
+ type T;
+ type T_Ref (Access_To_Variable : access T) is null record;
+ type T is limited record
+ Self : T_Ref (T'Access);
+ Int : Integer;
+ end record;
+
+ Obj : constant T := (Self => <>, Int => 123);
+ begin
+ Obj.Self.Access_To_Variable.Int := 456; -- modifying a component of a constant
+
+ In cases where constancy is really needed (e.g., for an object declared in a Pure context), such a case needs to be erroneous.
+
+ RM references: 10.02.01 (17/3) E.02.02 (17/2)
+
+.. index:: AI12-0077 (Ada 2022 feature)
+
+* *AI12-0077 Has_Same_Storage on objects of size zero (2020-03-30)*
+
+ This binding interpretation requires the Has_Same_Storage attribute
+ to return always `false` for objects that have a size of zero.
+
+ RM references: 13.03 (73.4/3)
+
+.. index:: AI12-0078 (Ada 2022 feature)
+
+* *AI12-0078 Definition of node for tree container is confusing (0000-00-00)*
+
+ Clarifies the expected behavior in processing tree containers.
+
+ RM references: A.18.10 (2/3) A.18.10 (3/3)
+
+.. index:: AI12-0081 (Ada 2022 feature)
+
+* *AI12-0081 Real-time aspects need to specify when they are evaluated (0000-00-00)*
+
+ Clarify the point at which Priority and Interrupt_Priority aspect expressions are evaluated.
+
+ RM references: D.01 (17/3) D.16 (9/3)
+
+.. index:: AI12-0084 (Ada 2022 feature)
+
+* *AI12-0084 Box expressions in array aggregates (2014-12-15)*
+
+ This AI addresses an issue where compiler used to fail to initialize
+ components of a multidimensional aggregates with box initialization when
+ scalar components have a specified default value. The AI clarifies that
+ in an array aggregate with box (i.e., ``<>``) component values, the
+ ``Default_Component_Value`` of the array type (if any) should not be ignored.
+
+ RM references: 4.03.03 (23.1/2)
+
+.. index:: AI12-0085 (Ada 2022 feature)
+
+* *AI12-0085 Missing aspect cases for Remote_Types (0000-00-00)*
+
+ A distributed systems annex (Annex E) clarification. Aspect specifications
+ that are forbidden using attribute definition clause syntax are also forbidden
+ using aspect_specification syntax.
+
+ RM references: E.02.02 (17/2)
+
+.. index:: AI12-0086 (Ada 2022 feature)
+
+* *AI12-0086 Aggregates and variant parts (2019-08-14)*
+
+ In Ada 2012, a discriminant value that governs an active variant part in an
+ aggregate had to be static. AI12-0086 relaxes this restriction: If the subtype of the discriminant value is a static subtype all of whose values select the same variant, then the expression for the discriminant is allowed to be nonstatic.
+
+ RM references: 4.03.01 (17/3) 4.03.01 (19/3)
+
+.. index:: AI12-0088 (Ada 2022 feature)
+
+* *AI12-0088 UTF_Encoding.Conversions and overlong characters on input (0000-00-00)*
+
+ Clarify that overlong characters are acceptable on input even if we never generate them as output.
+
+ RM references: A.04.11 (54/3) A.04.11 (55/3)
+
+.. index:: AI12-0089 (Ada 2022 feature)
+
+* *AI12-0089 Accessibility rules need to take into account that a generic function is not a (0000-00-00)*
+
+ Fix cases in RM wording where the accessibility rules for a function failed to take into account the fact that a generic function is not a function. For example, a generic function with an explicitly aliased parameter should be able to return references to that parameter in the same ways that a (non-generic) function can. The previous wording did not allow that.
+
+ RM references: 3.10.02 (7/3) 3.10.02 (19.2/3) 3.10.02 (19.3/3) 6.05 (4/3)
+
+.. index:: AI12-0093 (Ada 2022 feature)
+
+* *AI12-0093 Iterator with indefinite cursor (0000-00-00)*
+
+ A clarification that confirms what GNAT is already doing.
+
+ RM references: 5.05.02 (8/3) 5.05.02 (10/3)
+
+.. index:: AI12-0094 (Ada 2022 feature)
+
+* *AI12-0094 An access_definition should be a declarative region (0000-00-00)*
+
+ Fixes wording omission in the RM, confirming that the behaviour of GNAT is
+ correct.
+
+ RM references: 8.03 (2) 8.03 (26/3)
+
+.. index:: AI12-0095 (Ada 2022 feature)
+
+* *AI12-0095 Generic formal types and constrained partial views (0000-00-00)*
+
+ Deciding whether an actual parameter corresponding to an explicitly aliased formal parameter is legal depends on (among other things) whether the parameter type has a constrained partial view. The AI clarifies how this compile-time checking works in the case of a generic formal type (assume the best in the spec and recheck each instance, assume the worst in a generic body).
+
+ RM references: 3.10.02 (27.2/3) 4.06 (24.16/2) 6.04.01 (6.2/3) 12.05.01 (15)
+
+.. index:: AI12-0096 (Ada 2022 feature)
+
+* *AI12-0096 The exception raised when a subtype conversion fails a predicate check (0000-00-00)*
+
+ Clarify that the Predicate_Failure aspect works the same in a subtype conversion as in any other context.
+
+ RM references: 4.06 (57/3)
+
+.. index:: AI12-0097 (Ada 2022 feature)
+
+* *AI12-0097 Tag of the return object of a simple return expression (0000-00-00)*
+
+ Clarify wording about the tag of a function result in the case of a simple (i.e. not extended) return statement in a function with a class-wide result type.
+
+ RM references: 6.05 (8/3)
+
+.. index:: AI12-0098 (Ada 2022 feature)
+
+* *AI12-0098 Problematic examples for ATC (0000-00-00)*
+
+ The AI clarifies reference manual examples, there is no compiler impact.
+
+ RM references: 9.07.04 (13)
+
+.. index:: AI12-0099 (Ada 2022 feature)
+
+* *AI12-0099 Wording problems with predicates (2020-05-04)*
+
+ When extending a task or protected type from an ancestor interface subtype with a predicate, a link error can occur due to the compiler failing to generate the predicate-checking function. This AI clarifies the requirement for such predicate inheritance for concurrent types.
+
+ RM references: 3.02.04 (4/4) 3.02.04 (12/3) 3.02.04 (20/3)
+
+.. index:: AI12-0100 (Ada 2022 feature)
+
+* *AI12-0100 A qualified expression makes a predicate check (2020-02-17)*
+
+ The compiler now enforces predicate checks on qualified expressions when the
+ qualifying subtype imposes a predicate.
+
+ RM references: 4.07 (4)
+
+.. index:: AI12-0101 (Ada 2022 feature)
+
+* *AI12-0101 Incompatibility of hidden untagged record equality (2019-10-31)*
+
+ AI12-0101 is a binding interpretation that removes a legality rule that
+ prohibited the declaration of a primitive equality function for a private type in the private part of its enclosing package (either before or after the completion of the type) when the type is completed as an untagged record type. Such declarations are now accepted in Ada 2012 and later Ada versions.
+
+ As a consequence of this work, some cases where the implementation of AI05-0123 was incomplete were corrected.
+ More specifically, if a user-defined equality operator is present for an untagged record type in an Ada 2012 program, that user-defined equality operator will be (correctly) executed in some difficult-to-characterize cases where the predefined component-by-component comparison was previously being (incorrectly) executed. This can arise, for example, in the case of the predefined equality operation for an enclosing composite type that has a component of the user-defined primitive equality op's operand type.
+ This correction means that the impact of this change is not limited solely to code that was previously rejected at compile time.
+
+ RM references: 4.05.02 (9.8/3)
+
+.. index:: AI12-0102 (Ada 2022 feature)
+
+* *AI12-0102 Stream_IO.File_Type has Preelaborable_Initialization (0000-00-00)*
+
+ Modifies the declaration of one type in a predefined package. GNAT's version of ``Ada.Streams.Stream_IO`` already had this modification (the ``Preelaborable__Initialization`` pragma).
+
+ RM references: A.12.01 (5)
+
+.. index:: AI12-0103 (Ada 2022 feature)
+
+* *AI12-0103 Expression functions that are completions in package specifications (0000-00-00)*
+
+ Clarifies that expression functions that are completions do not cause "general" freeze-everybody-in-sight freezing like a subprogram body.
+
+ RM references: 13.14 (3/3) 13.14 (5/3)
+
+.. index:: AI12-0104 (Ada 2022 feature)
+
+* *AI12-0104 Overriding an aspect is undefined (0000-00-00)*
+
+ A clarification of the wording in RM, no compiler impact.
+
+ RM references: 4.01.06 (4/3) 4.01.06 (17/3)
+
+.. index:: AI12-0105 (Ada 2022 feature)
+
+* *AI12-0105 Pre and Post are not allowed on any subprogram completion (0000-00-00)*
+
+ Language-defined aspects (e.g., ``Post``) cannot be specified as part of the completion of a subprogram declaration. Fix a hole in the RM wording to clarify that this general rule applies even in the special cases where the completion is either an expression function or a null procedure.
+
+ RM references: 13.01.01 (18/3)
+
+.. index:: AI12-0106 (Ada 2022 feature)
+
+* *AI12-0106 Write'Class aspect (0000-00-00)*
+
+ Clarify that the syntax used in an ACATS test BDD2005 for specifying a class-wide streaming aspect is correct.
+
+ RM references: 13.01.01 (28/3) 13.13.02 (38/3)
+
+.. index:: AI12-0107 (Ada 2022 feature)
+
+* *AI12-0107 A prefixed view of a By_Protected_Procedure interface has convention protected (2020-06-05)*
+
+ A prefixed view of a subprogram with aspect Synchronization set to
+ By_Protected_Procedure has convention protected.
+
+ RM references: 6.03.01 (10.1/2) 6.03.01 (12) 6.03.01 (13)
+
+.. index:: AI12-0109 (Ada 2022 feature)
+
+* *AI12-0109 Representation of untagged derived types (2019-11-12)*
+
+ Ada disallows a nonconforming specification of a type-related representation
+ aspect of an untagged by-reference type. The motivation for this rule is to ensure that a parent type and a later type derived from the parent agree with respect to such aspects. AI12-0109 disallows a construct that otherwise could be used to get around this rule: an aspect specification for the parent type that occurs after the declaration of the derived type.
+
+ RM references: 13.01 (10/3)
+
+.. index:: AI12-0110 (Ada 2022 feature)
+
+* *AI12-0110 Tampering checks are performed first (2020-04-14)*
+
+ AI12-0110 requires tampering checks in the containers library to be
+ performed first, before any other checks.
+
+ RM references: A.18.02 (97.1/3) A.18.03 (69.1/3) A.18.04 (15.1/3) A.18.07
+ (14.1/3) A.18.10 (90/3) A.18.18 (35/3)
+
+.. index:: AI12-0112 (Ada 2022 feature)
+
+* *AI12-0112 Contracts for container operations (0000-00-00)*
+
+ A representation change replacing english descriptions of contracts for
+ operations on predefined container types with pre/post-conditions. No compiler
+ impact.
+
+ RM references: A.18.02 (99/3) 11.04.02 (23.1/3) 11.05 (23) 11.05 (26) A
+ (4) A.18 (10)
+
+.. index:: AI12-0114 (Ada 2022 feature)
+
+* *AI12-0114 Overlapping objects designated by access parameters are not thread-safe (0000-00-00)*
+
+ There are rules saying that concurrent calls to predefined subprograms don't interfere with each other unless actual parameters overlap. The AI clarifies that such an interference is also possible if overlapping objects are reachable via access dereferencing from actual parameters of the two calls.
+
+ RM references: A (3/2)
+
+.. index:: AI12-0116 (Ada 2022 feature)
+
+* *AI12-0116 Private types and predicates (0000-00-00)*
+
+ Clarify that the same aspect cannot be specified twice for the same type. ``Dynamic_Predicate``, for example, can be specified on either the partial view of a type or on the completion in the private part, but not on both.
+
+ RM references: 13.01 (9/3) 13.01 (9.1/3)
+
+.. index:: AI12-0117 (Ada 2022 feature)
+
+* *AI12-0117 Restriction No_Tasks_Unassigned_To_CPU (2020-06-12)*
+
+ This AI adds a restriction No_Tasks_Unassigned_To_CPU to provide safe
+ use of Ravenscar.
+
+ The CPU aspect is specified for the environment task. No CPU aspect is
+ specified to be statically equal to ``Not_A_Specific_CPU``. If aspect CPU
+ is specified (dynamically) to the value ``Not_A_Specific_CPU``, then
+ Program_Error is raised. If Set_CPU or ``Delay_Until_And_Set_CPU`` are called
+ with the CPU parameter equal to ``Not_A_Specific_CPU``, then ``Program_Error`` is raised.
+
+ RM references: D.07 (10.8/3)
+
+.. index:: AI12-0120 (Ada 2022 feature)
+
+* *AI12-0120 Legality and exceptions of generalized loop iteration (0000-00-00)*
+
+ Clarify that the expansion-based definition of generalized loop iteration
+ includes legality checking. If the expansion would be illegal (for example,
+ because of passing a constant actual parameter in a call when the mode of
+ the corresponding formal parameter is in-out), then the loop is illegal too.
+
+ RM references: 5.05.02 (6.1/4) 5.05.02 (10/3) 5.05.02 (13/3)
+
+.. index:: AI12-0121 (Ada 2022 feature)
+
+* *AI12-0121 Stream-oriented aspects (0000-00-00)*
+
+ Clarify that streaming-oriented aspects (e.g., Read) can be specified using
+ aspect_specification syntax, not just via an attribute definition clause.
+
+ RM references: 13.13.02 (38/3)
+
+.. index:: AI12-0124 (Ada 2022 feature)
+
+* *AI12-0124 Add Object'Image (2017-03-24)*
+
+ The corrigendum of Ada 2012 extends attribute ``'Image following`` the syntax for the GNAT ``'Img`` attribute. This AI fixes a gap in the earlier implementation, which did not recognize function calls and attributes that are functions as valid object prefixes.
+
+ RM references: 3.05 (55/3)
+
+.. index:: AI12-0125-3 (Ada 2022 feature)
+
+* *AI12-0125-3 Add @ as an abbreviation for the LHS of an assignment (2016-11-11)*
+
+ This AI introduces the use of the character '@' as an abbreviation for the left-hand side of an assignment statement, usable anywhere within the expression on the right-hand side. To use this feature the compilation flag -gnat2022 must be specified.
+
+ RM references: 5.02.01 (0) 2.02 (9) 3.03 (21.1/3) 4.01 (2/3) 8.06 (9/4)
+
+.. index:: AI12-0127 (Ada 2022 feature)
+
+* *AI12-0127 Partial aggregate notation (2016-10-12)*
+
+ This AI describes a new constructor for aggregates, in terms of an existing record or array object, and a series of component-wise modifications of its value, given by named associations for the modified components. To use this feature the compilation flag ``-gnat2022`` must be specified.
+
+ RM references: 4.03 (2) 4.03 (3/2) 4.03 (4) 4.03.01 (9) 4.03.01 (15/3)
+ 4.03.01 (16/4) 4.03.01 (17/5) 4.03.01 (17.1/2) 4.03.03 (4) 4.03.03
+ (14) 4.03.03 (17/5) 4.03.04 (0) 7.05 (2.6/2)
+
+.. index:: AI12-0128 (Ada 2022 feature)
+
+* *AI12-0128 Exact size access to parts of composite atomic objects (2019-11-24)*
+
+ According to this AI, the compiler generates full access to atomic composite objects even if the access is only partial in the source code. To use this feature the compilation flag ``-gnat2022`` must be specified.
+
+ RM references: C.06 (13.2/3) C.06 (19) C.06 (20) C.06 (22/2) C.06 (25/4)
+
+.. index:: AI12-0129 (Ada 2022 feature)
+
+* *AI12-0129 Make protected objects more protecting (2020-07-01)*
+
+ A new aspect Exclusive_Functions has been added to the language to force the
+ use of read/write locks on protected functions when needed.
+
+ RM references: 9.05.01 (2) 9.05.01 (4) 9.05.01 (5) 9.05.01 (7) 9.05.03
+ (15) 9.05.03 (23)
+
+.. index:: AI12-0130 (Ada 2022 feature)
+
+* *AI12-0130 All I/O packages should have Flush (2016-07-03)*
+
+ The Flush routine has been added for the ``Sequential_IO`` and ``Direct_IO`` standard packages in the Ada 2012 COR.1:2016. The Flush routine here is equivalent to the one found in ``Text_IO``. The ``Flush`` procedure synchronizes the external file with the internal file (by flushing any internal buffers) without closing the file.
+
+ RM references: A.08.01 (10) A.08.02 (28/3) A.08.04 (10) A.10.03 (21)
+ A.12.01 (28/2) A.12.01 (28.6/1)
+
+.. index:: AI12-0131 (Ada 2022 feature)
+
+* *AI12-0131 Inherited Pre'Class when unspecified on initial subprogram (0000-00-00)*
+
+ If T1 is a tagged type with a primitive P that has no class-wide precondition,
+ and if T2 is an extension of T1 which overrides the inherited primitive P, then that overriding P is not allowed to have a class-wide precondition. Allowing it would be ineffective except in corner cases where it would be confusing.
+
+ RM references: 6.01.01 (17/3) 6.01.01 (18/3)
+
+.. index:: AI12-0132 (Ada 2022 feature)
+
+* *AI12-0132 Freezing of renames-as-body (2020-06-13)*
+
+ This AI clarifies that a renames-as-body freezes the expression of any
+ expression function that it renames.
+
+ RM references: 13.14 (5/3)
+
+.. index:: AI12-0133 (Ada 2022 feature)
+
+* *AI12-0133 Type invariants and default initialized objects (0000-00-00)*
+
+ Clarify that invariant checking for a default-initialized object is performed regardless of where the object is declared (in particular, even when the full view of the type is visible).
+
+ RM references: 7.03.02 (10.3/3)
+
+.. index:: AI12-0135 (Ada 2022 feature)
+
+* *AI12-0135 Enumeration types should be eligible for convention C (0000-00-00)*
+
+ Ada previously allowed but did not require supporting specifying convention C for an enumeration type. Now it is required that an implementation shall support it.
+
+ RM references: B.01 (14/3) B.01 (41/3) B.03 (65)
+
+.. index:: AI12-0136 (Ada 2022 feature)
+
+* *AI12-0136 Language-defined packages and aspect Default_Storage_Pool (0000-00-00)*
+
+ Clarify that the effect of specifying Default_Storage_Pool for an instance of a predefined generic is implementation-defined. No compiler impact.
+
+ RM references: 13.11.03 (5/3)
+
+.. index:: AI12-0137 (Ada 2022 feature)
+
+* *AI12-0137 Incomplete views and access to class-wide types (0000-00-00)*
+
+ If the designated type of an access type is incomplete when the access type is declared, then we have rules about whether we get a complete view when a value of the access type is dereferenced. Clarify that analogous rules apply if the designated type is class-wide.
+
+ RM references: 3.10.01 (2.1/2)
+
+.. index:: AI12-0138 (Ada 2022 feature)
+
+* *AI12-0138 Iterators of formal derived types (2021-02-11)*
+
+ AI12-0138 specifies the legality rules for confirming specifications of
+ nonoverridable aspects. This completes the legality checks for aspect ``Implicit_Dereference`` and simplifies the checks for those aspects that are inherited operations.
+
+ RM references: 13.01.01 (18/4) 13.01.01 (34/3) 4.01.05 (6/3) 4.01.06 (5/3)
+ 4.01.06 (6/3) 4.01.06 (7/3) 4.01.06 (8/3) 4.01.06 (9/3) 5.05.01 (11/3)
+
+.. index:: AI12-0140 (Ada 2022 feature)
+
+* *AI12-0140 Access to unconstrained partial view when full view is constrained (0000-00-00)*
+
+ Clarify some confusion about about whether what matters when checking whether designated subtypes statically match is the view of the designated type that is currently available v.s. the view that was available when the access type was declared.
+
+ RM references: 3.02 (7/2) 7.03.01 (5/1)
+
+.. index:: AI12-0143 (Ada 2022 feature)
+
+* *AI12-0143 Using an entry index of a family in a precondition (2022-04-05)*
+
+ Ada 2022 adds the ``Index`` attribute, which allows the use of the entry family index of an entry call within preconditions and post-conditions.
+
+ RM references: 6.01.01 (30/3) 9.05.04 (5/3)
+
+.. index:: AI12-0144 (Ada 2022 feature)
+
+* *AI12-0144 Make Discrete_Random more flexible (2020-01-31)*
+
+ A new function Random with First/Last parameters is provided in the
+ ``Ada.Numerics.Discrete_Random`` package.
+
+ RM references: A.05.02 (20) A.05.02 (32) A.05.02 (41) A.05.02 (42)
+
+.. index:: AI12-0145 (Ada 2022 feature)
+
+* *AI12-0145 Pool_of_Subpool returns null when called too early (0000-00-00)*
+
+ Clarify that if you ask for the pool of a subpool (by calling ``Pool_Of_Subpool``) before ``Set_Pool_of_Subpool`` is called, then the result is null.
+
+ RM references: 13.11.04 (20/3)
+
+.. index:: AI12-0147 (Ada 2022 feature)
+
+* *AI12-0147 Expression functions and null procedures can be declared in a protected_body (2015-03-05)*
+
+ AI12-0147 specifies that null procedures and expression functions are now
+ allowed in protected bodies.
+
+ RM references: 9.04 (8/1)
+
+.. index:: AI12-0149 (Ada 2022 feature)
+
+* *AI12-0149 Type invariants are checked for functions returning access-to-type (0000-00-00)*
+
+ Extend the rule saying that ``Type_Invariant`` checks are performed for access-to-T parameters (where T has a specified ``Type_Invariant``) so that the rule also applies to function results.
+
+ RM references: 7.03.02 (19.3/4)
+
+.. index:: AI12-0150 (Ada 2022 feature)
+
+* *AI12-0150 Class-wide type invariants and statically bound calls (0000-00-00)*
+
+ The same approach used in AI12-0113 to ensure that contract-related calls associated with a call to a subprogram "match" with respect to dispatching also applies to ``Type_Invariant`` checking.
+
+ RM references: 7.03.02 (3/3) 7.03.02 (5/3) 7.03.02 (9/3) 7.03.02 (22/3)
+
+.. index:: AI12-0154 (Ada 2022 feature)
+
+* *AI12-0154 Aspects of library units (0000-00-00)*
+
+ Clarify that an aspect_specification for a library unit is equivalent to a corresponding aspect-specifying pragma.
+
+ RM references: 13.01.01 (32/3)
+
+.. index:: AI12-0156 (Ada 2022 feature)
+
+* *AI12-0156 Use subtype_indication in generalized iterators (0000-00-00)*
+
+ For iterating over an array, we already allow (but do not require) explicitly providing a subtype indication in an iterator_specification. Tee AI generalizes this to handle the case where the element type of the array is of an anonymous access type. This also allows (but does not require) explicitly naming the cursor subtype in a generalized iterator.
+ The main motivation for allowing these new cases is improving readability by making it easy to infer the (sub)type of the iteration object just by looking at the loop.
+
+ RM references: 5.05.02 (2/3) 5.05.02 (5/4) 5.05.02 (7/3) 3.10.02 (11.1/2)
+
+.. index:: AI12-0157 (Ada 2022 feature)
+
+* *AI12-0157 Missing rules for expression functions (0000-00-00)*
+
+ Clarify that an expression function behaves like a single-return-statement
+ function in more cases: it can return an aggregate without extra parens, the expression has an applicable index constraint, and the same accessibility rules apply in both cases.
+
+ For instance, the code below is legal:
+
+ .. code::
+
+ subtype S is String (1 .. 10);
+ function f return S is (others => '?');
+
+ RM references: 3.10.02 (19.2/4) 3.10.02 (19.3/4) 4.03.03 (11/2) 6.08 (2/3)
+ 6.08 (3/3) 6.08 (5/3) 6.08 (6/3) 6.08 (7/3) 7.05 (2.9/3) 13.14
+ (5.1/4) 13.14 (5.2/4) 13.14 (8/3) 13.14 (10.1/3) 13.14 (10.2/3)
+ 13.14 (10.3/3)
+
+.. index:: AI12-0160 (Ada 2022 feature)
+
+* *AI12-0160 Adding an indexing aspect to an indexable container type (0000-00-00)*
+
+ If the parent type of a derived type has exactly one of the two indexing aspects (that is, constant_indexing and variable_indexing) specified, then the derived type cannot have a specification for the other one.
+
+ RM references: 4.01.06 (6/4) 4.01.06 (9/4) 3.06 (22.2/3)
+
+.. index:: AI12-0162 (Ada 2022 feature)
+
+* *AI12-0162 Memberships and Unchecked_Unions (0000-00-00)*
+
+ Clarify that membership tests for unchecked_union types work consistently when
+ testing membership in more than one subtype (X in AA | BB | CC) as when
+ testing for one.
+
+ RM references: B.03.03 (25/2)
+
+.. index:: AI12-0164 (Ada 2022 feature)
+
+* *AI12-0164 Max_Entry_Queue_Length aspect for entries (2019-06-11)*
+
+ AI12-0164 defines pragma and aspect ``Max_Entry_Queue_Length`` in addition
+ to the GNAT-specific equivalents ``Max_Queue_Length`` and ``Max_Entry_Queue_Depth``.
+
+ RM references: D.04 (16)
+
+.. index:: AI12-0165 (Ada 2022 feature)
+
+* *AI12-0165 Operations of class-wide types and formal abstract subprograms (2021-10-19)*
+
+ Ada 2022 specifies that when the controlling type of a formal abstract
+ subprogram declaration is a formal type, and the actual type is a class-wide type T'Class, the actual subprogram can be an implicitly declared subprogram corresponding to a primitive operation of type T.
+
+ RM references: 12.06 (8.5/2)
+
+.. index:: AI12-0166 (Ada 2022 feature)
+
+* *AI12-0166 External calls to protected functions that appear to be internal calls (2016-11-15)*
+
+ According to this AI, the compiler rejects a call to a protected operation when the call appears within a precondition for another protected operation.
+
+ RM references: 6.01.01 (34/3) 9.05 (3/3) 9.05 (7.1/3)
+
+.. index:: AI12-0167 (Ada 2022 feature)
+
+* *AI12-0167 Type_Invariants and tagged-type View Conversions (0000-00-00)*
+
+ This AI clarifies that no invariant check is performed in a case where an invariant-violating value is assigned to a component. This confirms the current compiler behavior.
+
+ RM references: 7.03.02 (9/4)
+
+.. index:: AI12-0168 (Ada 2022 feature)
+
+* *AI12-0168 Freezing of generic instantiations of generics with bodies (0000-00-00)*
+
+ Adjust freezing rules to be compatible with AI12-0103-1. The change confirms the current compiler behavior.
+
+ RM references: 13.14 (3/4)
+
+.. index:: AI12-0169 (Ada 2022 feature)
+
+* *AI12-0169 Aspect specifications for entry bodies (0000-00-00)*
+
+ Change syntax to allow aspect specifications for implementation-defined aspects on entry bodies. The change doesn't influence any of the language-defined aspects and is solely required for SPARK.
+
+ RM references: 9.05.02 (5)
+
+.. index:: AI12-0170 (Ada 2022 feature)
+
+* *AI12-0170 Abstract subprogram calls in class-wide precondition expressions (2020-07-06)*
+
+ This AI specifies rules for calls to abstract functions within class-wide preconditions and postconditions.
+
+ RM references: 3.09.03 (7) 6.01.01 (7/4) 6.01.01 (18/4) 6.01.01 (18.2/4)
+
+.. index:: AI12-0172 (Ada 2022 feature)
+
+* *AI12-0172 Raise expressions in limited contexts (2019-07-29)*
+
+ The compiler has been enhanced to support the use of raise expressions in
+ limited contexts.
+
+ RM references: 7.05 (2.1/3)
+
+.. index:: AI12-0173 (Ada 2022 feature)
+
+* *AI12-0173 Expression of an extended return statement (0000-00-00)*
+
+ Fix the wording related to expression of an extended return statement that was made ambiguous by changes of syntax in other AI's. No compiler changes involved.
+
+ RM references: 6.05 (3/2) 6.05 (5/3)
+
+.. index:: AI12-0174 (Ada 2022 feature)
+
+* *AI12-0174 Aggregates of Unchecked_Unions using named notation (0000-00-00)*
+
+ In many cases, it is illegal to name a discriminant of an unchecked_union type. Relax this rule to allow the use of named notation in an aggregate of an unchecked_union type.
+
+ RM references: B.03.03 (9/3)
+
+.. index:: AI12-0175 (Ada 2022 feature)
+
+* *AI12-0175 Preelaborable packages with address clauses (2020-03-20)*
+
+ The compiler nows accepts calls to certain functions that are essentially unchecked conversions in preelaborated library units. To use this feature the compilation flag ``-gnat2022`` must be specified.
+
+ RM references: 10.02.01 (7)
+
+.. index:: AI12-0179 (Ada 2022 feature)
+
+* *AI12-0179 Failure of postconditions of language-defined units (0000-00-00)*
+
+ A clarification that expressing postconditions for predefined units via RM wording or via ``Post`` aspect specifications are equivalent. In particular, the expression in such a ``Post`` aspect specification should not yield False. No implementation changes needed.
+
+ RM references: 1.01.03 (17/3) 11.04.02 (23.1/3)
+
+.. index:: AI12-0180 (Ada 2022 feature)
+
+* *AI12-0180 Using protected subprograms and entries within an invariant (2020-06-22)*
+
+ AI12-0180 makes entries and protected subprograms directly visible within Invariant aspects of a task or protected type.
+
+ RM references: 13.01.01 (12/3)
+
+.. index:: AI12-0181 (Ada 2022 feature)
+
+* *AI12-0181 Self-referencing representation aspects (0000-00-00)*
+
+ Clarify that a name or expression which freezes an entity cannot occur in an aspect specification for that entity.
+
+ RM references: 13.01 (9/4) 13.01 (9.1/4) 13.14 (19)
+
+.. index:: AI12-0182 (Ada 2022 feature)
+
+* *AI12-0182 Pre'Class and protected operations (0000-00-00)*
+
+ Confirm that Pre'Class and Post'Class cannot be specified for a protected operation. No language change.
+
+ RM references: 13.01.01 (16/3)
+
+.. index:: AI12-0184 (Ada 2022 feature)
+
+* *AI12-0184 Long Long C Data Types (2020-01-30)*
+
+ Two new types ``long_long`` and ``unsigned_long_long`` are introduced in the package ``Interfaces.C``.
+
+ RM references: B.03 (71.3/3)
+
+.. index:: AI12-0185 (Ada 2022 feature)
+
+* *AI12-0185 Resolution of postcondition-specific attributes (0000-00-00)*
+
+ Clarify resolution rules for ``'Old`` and ``'Result`` attribute references to match original intent.
+
+ RM references: 6.01.01 (7/4) 6.01.01 (8/3) 6.01.01 (26.10/4) 6.01.01 (29/3)
+
+.. index:: AI12-0186 (Ada 2022 feature)
+
+* *AI12-0186 Profile freezing for the Access attribute (0000-00-00)*
+
+ Clarify that the use of Some_Subprogram'Access does not freeze the profile of Some_Subprogram.
+
+ RM references: 13.14 (15)
+
+.. index:: AI12-0187 (Ada 2022 feature)
+
+* *AI12-0187 Stable properties of abstract data types (2020-11-04)*
+
+ Ada 2022 defines a new aspect, ``Stable_Properties``, for use in
+ generating additional postcondition checks for subprograms.
+
+ RM references: 7.03.04 (0) 13.01.01 (4/3)
+
+.. index:: AI12-0191 (Ada 2022 feature)
+
+* *AI12-0191 Clarify "part" for type invariants (0000-00-00)*
+
+ Clarify that for purposes of determining whether an invariant check is required for a "part" of an object, we do not look at "parts" which do not correspond to "parts" of the nominal type of the object. For example, if we have a parameter Param of a tagged type T1 (or equivalently of type T1'Class), and type T2 is an extension of T1 which declares a component Foo, and T1'Class (Param)'Tag = T2'Tag, then no invariant check is performed for Param's Foo component (or any subcomponent thereof).
+
+ RM references: 3.03 (23/5) 3.09.01 (4.1/2) 6.08 (5.8/5) 7.03.02 (8.3/5)
+ 7.03.02 (8.4/5) 7.03.02 (8.5/5) 7.03.02 (8.6/5) 7.03.02 (8.7/5)
+ 7.03.02 (8.8/5) 7.03.02 (8.9/5) 7.03.02 (8.10/5) 7.03.02 (8.11/5)
+ 7.03.02 (8.12/5) 7.03.02 (10.1/4) 7.03.02 (15/5) 7.03.02 (17/4)
+ 7.03.02 (18/4) 7.03.02 (19/4) 13.13.02 (9/3)
+
+.. index:: AI12-0192 (Ada 2022 feature)
+
+* *AI12-0192 "requires late initialization" and protected types (2020-03-11)*
+
+ This AI clarifies that components of a protected type require late initialization when their initialization references (implicitly) the current instance of the type.
+
+ RM references: 3.03.01 (8.1/2)
+
+.. index:: AI12-0194 (Ada 2022 feature)
+
+* *AI12-0194 Language-defined aspects and entry bodies (0000-00-00)*
+
+ The AI Includes entry bodies on the list of bodies for which no language-defined aspects can be specified (although specifying an implementation-defined aspect may be allowed).
+
+ A wording change, no implementation impact.
+
+ RM references: 13.01.01 (17/3)
+
+.. index:: AI12-0195 (Ada 2022 feature)
+
+* *AI12-0195 Inheriting body but overriding precondition or postcondition (2021-08-11)*
+
+ Ada 2022 specifies that if a primitive with a class-wide precondition or
+ postcondition is inherited, and some primitive function called in the class-wide precondition or postcondition is overridden, then a dispatching call to the first primitive with a controlling operand that has the tag of the overriding type is required to check both the interpretation using the overriding function and the interpretation using the original overridden function.
+
+ RM references: 6.01.01 (38/4)
+
+.. index:: AI12-0196 (Ada 2022 feature)
+
+* *AI12-0196 Concurrent access to Ada container libraries (0000-00-00)*
+
+ Clarify that parallel execution of operations which use cursors to refer to different elements of the same container does not violate the rules about erroneous concurrent access in some cases. That is, if C1 and C2 are cursors that refer to different elements of some container, then it is ok to concurrently execute an operation that is passed C1 and which accesses one element of the container, with another operation (perhaps the same operation, perhaps not) that is passed C2 and which accesses another element of the container.
+
+ RM references: A.18 (2/2) A.18.02 (125/2) A.18.02 (133/3) A.18.02 (135/3)
+ A.18.03 (81/3) A.18.04 (36/3) A.18.07 (34/2) A.18.10 (116/3)
+
+.. index:: AI12-0198 (Ada 2022 feature)
+
+* *AI12-0198 Potentially unevaluated components of array aggregates (2020-05-13)*
+
+ Ada 2022 enforces the detection of components that belong to a nonstatic or
+ null range of index values of an array aggregate.
+
+ RM references: 6.01.01 (22.1/4)
+
+.. index:: AI12-0199 (Ada 2022 feature)
+
+* *AI12-0199 Abstract subprogram calls in class-wide invariant expressions (0000-00-00)*
+
+ Class-wide type invariants do not apply to abstract types, to avoid various
+ problems. Define the notion of a "corresponding expression" for a class-wide
+ type invariant, replacing references to components as appropriate, taking into
+ account rules for corresponding and specified discriminants when applying them
+ to a nonabstract descendant.
+
+ RM references: 7.03.02 (5/4) 7.03.02 (8/3)
+
+.. index:: AI12-0201 (Ada 2022 feature)
+
+* *AI12-0201 Missing operations of static string types (2020-02-25)*
+
+ Relational operators and type conversions of static string types are now static in Ada 2022.
+
+ RM references: 4.09 (9) 4.09 (19) 4.09 (20) 4.09 (24)
+
+.. index:: AI12-0203 (Ada 2022 feature)
+
+* *AI12-0203 Overriding a nonoverridable aspect (0000-00-00)*
+
+ A corner case wording clarification that has no impact on compilers.
+
+ RM references: 4.01.05 (5.1/4) 4.01.05 (7/3)
+
+.. index:: AI12-0204 (Ada 2022 feature)
+
+* *AI12-0204 Renaming of a prefixed view (2020-02-24)*
+
+ AI12-0204 clarifies that the prefix of a prefixed view that is renamed or
+ passed as a formal subprogram must be renameable as an object.
+
+ RM references: 8.05.04 (5.2/2) 12.06 (8.3/2) 4.01.03 (13.1/2) 4.01.06 (9/5)
+
+.. index:: AI12-0205 (Ada 2022 feature)
+
+* *AI12-0205 Defaults for generic formal types (2021-04-01)*
+
+ AI12-0205 specifies syntax and semantics that provide defaults for formal types of generic units. The legality rules guarantee that the default subtype_mark that is specified for a formal type would be a legal actual in any instantiation of the generic unit.
+
+ RM references: 12.03 (7/3) 12.03 (10) 12.05 (2.1/3) 12.05 (2.2/3) 12.05 (7/2)
+
+.. index:: AI12-0206 (Ada 2022 feature)
+
+* *AI12-0206 Nonoverridable should allow arbitrary kinds of aspects (0000-00-00)*
+
+ A non-overridable aspect can have a value other than a name; for example, ``Max_Entry_Queue_Length`` is non-overridable and it has a scalar value.
+ Part of adding support for ``Max_Entry_Queue_Length`` (which is already supported by GNAT).
+
+ RM references: 13.01.01 (18.2/4) 13.01.01 (18.3/4) 13.01.01 (18.6/4)
+
+.. index:: AI12-0207 (Ada 2022 feature)
+
+* *AI12-0207 Convention of anonymous access types (2020-02-01)*
+
+ The convention of anonymous access elements of arrays now have the same convention as the array instead of convention Ada.
+
+ RM references: 6.03.01 (13.1/3) B.01 (19) B.01 (21/3)
+
+.. index:: AI12-0208 (Ada 2022 feature)
+
+* *AI12-0208 Predefined Big numbers support (0000-00-00)*
+
+ Add predefined package ``Ada.Numerics.Big_Numbers``.
+
+ RM references: A.05.05 (0) A.05.06 (0) A.05.07 (0)
+
+.. index:: AI12-0211 (Ada 2022 feature)
+
+* *AI12-0211 Interface types and inherited nonoverridable aspects (2020-08-24)*
+
+ AI12-0211 introduces two new legality rules for Ada 2022. The first says that
+ if a nonoverridable aspect is explicitly specified for a type that also inherits that aspect from another type (an ancestor or a progenitor), then the explicit aspect specification shall be confirming. The second says that if a type inherits a nonoverridable aspect from two different sources (this can only occur if at least one of the two is an interface type), then the two sources shall agree with respect to the given aspect. This AI is a binding interpretation, so these checks are performed even for earlier Ada versions. Because of compatibility concerns, an escape mechanism for suppressing these legality checks is provided: these new checks always pass if the ``-gnatd.M`` switch (relaxed RM semantics) is specified.
+
+ RM references: 13.01.01 (18.3/5) 13.01.01 (18.4/4)
+
+.. index:: AI12-0212 (Ada 2022 feature)
+
+* *AI12-0212 Container aggregates; generalized array aggregates (0000-00-00)*
+
+ The AI defines a new feature: generalized array aggregates that already exists in GNAT.
+
+ RM references: 4.03.05 (0) 1.01.04 (12) 1.01.04 (13) 2.01 (15) 2.02 (9/5)
+ 3.07.01 (3) 3.08.01 (4) 4.03 (2/5) 4.03 (3/5) 4.03.01 (5) 4.03.03
+ (3/2) 4.03.03 (4/5) 4.03.03 (5.1/5) 4.03.03 (9) 4.03.03 (17/5)
+ 4.03.03 (21) 4.03.03 (23.2/5) 4.03.03 (26) 4.03.03 (27) 4.03.03
+ (31) 4.03.04 (4/5) 4.04 (3.1/3) 11.02 (3) 13.01.01 (5/3)
+ 13.01.01 (7/3) A.18.02 (8/3) A.18.02 (14/2) A.18.02 (47/2) A.18.02
+ (175/2) A.18.03 (6/3) A.18.05 (3/3) A.18.06 (4/3) A.18.08 (3/3)
+ A.18.09 (4/3)
+
+.. index:: AI12-0216 (Ada 2022 feature)
+
+* *AI12-0216 6.4.1(6.16-17/3) should never apply to composite objects (0000-00-00)*
+
+ Fix wording so that parameter passing cases where there isn't really any aliasing problems or evaluation order dependency are classified as acceptable.
+
+ No compiler impact.
+
+ RM references: 6.04.01 (6.17/3)
+
+.. index:: AI12-0217 (Ada 2022 feature)
+
+* *AI12-0217 Rules regarding restrictions on the use of the Old attribute are too strict (2020-03-25)*
+
+ AI12-0217 loosens the rules regarding what is allowed as the prefix of a 'Old
+ attribute reference. In particular, a prefix is now only required to "statically name" (as opposed to the previous "statically denote") an object. This means that components of composite objects that previously would have been illegal are now legal prefixes.
+
+ RM references: 6.01.01 (24/3) 6.01.01 (27/3)
+
+.. index:: AI12-0220 (Ada 2022 feature)
+
+* *AI12-0220 Pre/Post for access-to-subprogram types (2020-04-14)*
+
+ Contract aspects can now be specified for access-to-subprogram types, as
+ defined for Ada 2022 in this AI.
+
+ RM references: 6.01.01 (1/4) 6.01.01 (2/3) 6.01.01 (4/3) 6.01.01 (19/3)
+ 6.01.01 (28/3) 6.01.01 (29/3) 6.01.01 (39/3) 13.01.01 (12/5)
+
+.. index:: AI12-0222 (Ada 2022 feature)
+
+* *AI12-0222 Representation aspects and private types (0000-00-00)*
+
+ Clarify that the rule against specifying a representation aspect for a type before the type is completely defined also applies in the case where aspect_specification syntax is used (not just in the case where a pragma or some other kind of representation item is used).
+
+ GNAT already implements this.
+
+ RM references: 13.01 (9/5) 13.01 (9.1/4) 13.01 (9.2/5)
+
+.. index:: AI12-0225 (Ada 2022 feature)
+
+* *AI12-0225 Prefix of Obj'Image (0000-00-00)*
+
+ Clarify some Object vs. Value corner cases to allow names that do not denote objects in more contexts, such as a qualified expression as a prefix of an Image attribute.
+
+ RM references: 3.05 (55.1/4)
+
+.. index:: AI12-0226 (Ada 2022 feature)
+
+* *AI12-0226 Make objects more consistent (0000-00-00)*
+
+ Allow value conversions as objects. For instance this example becomes legal: ``Long_Integer (Duration'Last)'Image``.
+
+ RM references: 3.03 (11.1/3) 3.03 (21.1/3) 3.03 (23.8/5) 4.06 (58.1/4)
+ 4.06 (58.3/4)
+
+.. index:: AI12-0227 (Ada 2022 feature)
+
+* *AI12-0227 Evaluation of nonstatic universal expressions when no operators are involved (0000-00-00)*
+
+ Nonstatic universal integer expressions are always evaluated at runtime as values of type root_integer; similarly, nonstatic universal real expressions are always evaluated at runtime as values of type root_real.
+ This AI corrects a wording oversight. Previously, the above was only true if a call to operator was involved. With this change it is true in all cases.
+
+ No compiler impact.
+
+ RM references: 4.04 (10) 8.06 (29)
+
+.. index:: AI12-0228 (Ada 2022 feature)
+
+* *AI12-0228 Properties of qualified expressions used as names (2020-02-19)*
+
+ This AI clarifies that properties of a qualified object pass through a
+ qualified expression used as a name. Specifically, "aliased" and "known to be
+ constrained" are not changed by a qualified expression.
+
+ RM references: 3.03 (23.7/3) 3.10 (9/3)
+
+.. index:: AI12-0231 (Ada 2022 feature)
+
+* *AI12-0231 Null_Task_Id and Activation_Is_Complete (0000-00-00)*
+
+ Add ``Activation_Is_Complete`` to the list of functions that raise P_E if passed ``Null_Task_Id``, correcting an oversight.
+
+ RM references: C.07.01 (15)
+
+.. index:: AI12-0232 (Ada 2022 feature)
+
+* *AI12-0232 Rules for pure generic bodies (0000-00-00)*
+
+ Clarify the rules for a generic body nested in a pure library unit.
+
+ RM references: 10.02.01 (9/3) 10.02.01 (15.1/3) 10.02.01 (15.5/3)
+
+.. index:: AI12-0233 (Ada 2022 feature)
+
+* *AI12-0233 Pre'Class for hidden operations of private types (0000-00-00)*
+
+ Clarify how ``Pre'Class`` checking interacts with private-part overriding of inherited subprograms. A class-wide precondition can be checked at runtime even if it is specified in a private part that the caller cannot see into.
+
+ RM references: 6.01.01 (38/4)
+
+.. index:: AI12-0234 (Ada 2022 feature)
+
+* *AI12-0234 Compare-and-swap for atomic objects (0000-00-00)*
+
+ New predefined units for atomic operations (``System.Atomic_Operations`` and child units thereof).
+
+ RM references: C.06.01 (0) C.06.02 (0)
+
+.. index:: AI12-0235 (Ada 2022 feature)
+
+* *AI12-0235 System.Storage_Pools should be pure (0000-00-00)*
+
+ Change the predefined package System.Storage_Pools from preelaborated to pure.
+
+ RM references: 13.11 (5)
+
+.. index:: AI12-0236 (Ada 2022 feature)
+
+* *AI12-0236 declare expressions (2020-04-08)*
+
+ A ``declare expression`` allows constant objects and renamings to be
+ declared within an expression.
+
+ RM references: 2.08 (6) 3.09.02 (3) 3.10.02 (9.1/3) 3.10.02 (16.1/3)
+ 3.10.02 (32.2/3) 4.03.02 (5.4/3) 4.03.03 (15.1/3) 4.04 (7/3)
+ 4.05.09 (0) 6.02 (10/4) 7.05 (2.1/5) 8.01 (2.1/4)
+
+.. index:: AI12-0237 (Ada 2022 feature)
+
+* *AI12-0237 Getting the representation of an enumeration value (2020-01-31)*
+
+ The GNAT-specific attributes ``Enum_Rep`` and ``Enum_Val`` have been standardized and are now also supported as Ada 2022 attributes.
+
+ RM references: 13.04 (10) 13.04 (11/3)
+
+.. index:: AI12-0242 (Ada 2022 feature)
+
+* *AI12-0242 Shorthand Reduction Expressions for Objects (0000-00-00)*
+
+ Allow reduction expressions to iterate over an an array or an iterable object without having to explicitly create a value sequence.
+
+ This allows, for instance, writing ``A'Reduce("+", 0)`` instead of the equivalent (but more verbose) ``[for Value of A => Value]'Reduce("+", 0);``.
+
+ RM references: 4.05.10 (0) 4.01.04 (6)
+
+.. index:: AI12-0247 (Ada 2022 feature)
+
+* *AI12-0247 Potentially Blocking goes too far for Detect_Blocking (0000-00-00)*
+
+ During a protected action, a call on a subprogram that contains a potentially blocking operation is considered a bounded error (so raising P_E is optional).
+ This rule imposed an unreasonable implementation burden.
+ The new rule introduced by this AI allows ignoring (i.e., not detecting) the problem until execution of a potentially blocking operation is actually attempted.
+
+ RM references: 9.05 (55/5) 9.05 (56/5) 9.05.01 (18/5) H.05 (5/2)
+
+.. index:: AI12-0249 (Ada 2022 feature)
+
+* *AI12-0249 User-defined numeric literals (2020-04-07)*
+
+ Compiler support is added for three new aspects (``Integer_Literal``, ``Real_Literal``, and ``String_Literal``) as described in AI12-0249 (for ``Integer_Literal`` and ``Real_Literal``), AI12-0295 (for ``String_Literal``), and in two follow-up AIs (AI12-0325 and AI12-0342). For pre-Ada 2022 versions of Ada, these are treated as implementation-defined
+ aspects. Some implementation work remains, particularly in the interactions between these aspects and tagged types.
+
+ RM references: 4.02 (9) 4.02.01 (0) 4.09 (3)
+
+.. index:: AI12-0250 (Ada 2022 feature)
+
+* *AI12-0250 Iterator Filters (2020-05-19)*
+
+ This AI defines Ada 2022 feature of iterator filters, which can be
+ applied to loop parameter specifications and iterator specifications.
+
+ RM references: 4.03.03 (21) 4.03.03 (26) 4.03.03 (31) 4.03.05 (0) 4.05.10
+ (0) 5.05 (4) 5.05 (7) 5.05 (9/4) 5.05 (9.1/4) 5.05 (10)
+ 5.05.02 (2/3) 5.05.02 (10/3) 5.05.02 (11/3)
+
+.. index:: AI12-0252 (Ada 2022 feature)
+
+* *AI12-0252 Duplicate interrupt handlers under Ravenscar (2018-07-05)*
+
+ Ada Issue AI12-0252 requires that the runtime shall terminate with a
+ Program_Error when more than one interrupt handler is attached to the same interrupt and the restriction No_Dynamic_Attachment is in effect.
+
+ RM references: C.03.01 (13)
+
+.. index:: AI12-0256 (Ada 2022 feature)
+
+* *AI12-0256 Aspect No_Controlled_Parts (2021-01-26)*
+
+ The compiler now supports the Ada 2022 aspect No_Controlled_Parts (see
+ AI12-0256). When specified for a type, this aspect requires that the type and any of its ancestors must not have any controlled parts.
+
+ RM references: H.04.01 (0) 13.01.01 (18.7/5)
+
+.. index:: AI12-0258 (Ada 2022 feature)
+
+* *AI12-0258 Containers and controlled element types (0000-00-00)*
+
+ Most predefined containers are allowed to defer finalization of container elements until the finalization of the container. This allows implementation flexibility but causes problems in some cases. AI12-0258 tightens up the rules for the indefinite containers to say that finalization happens earlier - if a client needs the tighter finalization guarantees, then it can use the indefinite containers (even if the element subtype in question is definite). Other solutions involving the holder generic are also possible.
+
+ GNAT implements these tighter element finalization requirements for instances of the indefinite container generics.
+
+ RM references: A.18 (10/4)
+
+.. index:: AI12-0259 (Ada 2022 feature)
+
+* *AI12-0259 Lower bound of strings returned from Ada.Command_Line (0000-00-00)*
+
+ Specify that the low-bound of a couple of predefined String-valued functions will always be one.
+
+ RM references: A.15 (14) A.15 (16/3)
+
+.. index:: AI12-0260 (Ada 2022 feature)
+
+* *AI12-0260 Functions Is_Basic and To_Basic in Wide_Characters.Handling (2020-04-01)*
+
+ AI12-0260 is implemented for Ada 2022, providing the new functions ``Is_Basic`` and ``To_Basic`` in package ``Ada.Wide_Characters.Handling``.
+
+ RM references: 1.02 (8/3) A.03.05 (8/3) A.03.05 (20/3) A.03.05 (21/3)
+ A.03.05 (33/3) A.03.05 (61/3)
+
+.. index:: AI12-0261 (Ada 2022 feature)
+
+* *AI12-0261 Conflict in "private with" rules (0000-00-00)*
+
+ If a library unit is only visible at some point because of a "private with", there are legality rules about a name denoting that entity. The AI cleans up the wording so that it captures the intent in a corner case involving a private-child library-unit subprogram. The previous wording incorrectly caused this case to be illegal.
+
+ RM references: 10.01.02 (12/3) 10.01.02 (13/2) 10.01.02 (14/2) 10.01.02
+ (15/2) 10.01.02 (16/2)
+
+.. index:: AI12-0262 (Ada 2022 feature)
+
+* *AI12-0262 Map-Reduce attribute (0000-00-00)*
+
+ The AI defines Reduction Expressions to allow the programmer to apply the
+ Map-Reduce paradigm to map/transform a set of values to a new set of values,
+ and then summarize/reduce the transformed values into a single result value.
+
+ RM references: 4.01.04 (1) 4.01.04 (6) 4.01.04 (11) 4.05.10 (0)
+
+.. index:: AI12-0263 (Ada 2022 feature)
+
+* *AI12-0263 Update references to ISO/IEC 10646 (0000-00-00)*
+
+ Change RM references to ISO/IEC 10646:2011 to instead refer to ISO/IEC 10646:2017. No compiler impact.
+
+ RM references: 1.01.04 (14.2/3) 2.01 (1/3) 2.01 (3.1/3) 2.01 (4/3) 2.01
+ (4.1/5) 2.01 (5/3) 2.01 (15/3) 2.01 (4.1/5) 2.01 (5/3) 2.03
+ (4.1/5) 2.03 (5/3) 3.05.02 (2/3) 3.05.02 (3/3) 3.05.02 (4/3) A.01
+ (36.1/3) A.01 (36.2/3) A.03.02 (32.6/5) A.03.05 (51.2/5) A.03.05
+ (55/3) A.03.05 (59/3) A.04.10 (3/3) B.05 (21/5)
+
+.. index:: AI12-0264 (Ada 2022 feature)
+
+* *AI12-0264 Overshifting and overrotating (0000-00-00)*
+
+ Clarify Shift and Rotate op behavior with large shift/rotate amounts.
+
+ RM references: B.02 (9)
+
+.. index:: AI12-0265 (Ada 2022 feature)
+
+* *AI12-0265 Default_Initial_Condition for types (2020-11-13)*
+
+ The aspect ``Default_Initial_Condition``, originally proposed by SPARK and
+ supported in GNAT, is now also included in Ada 2022. One change from the
+ original implementation is that when the aspect is specified on ancestor types of a derived type, the ancestors' check expressions also apply to the derived type.
+ ``Default_Initial_Condition`` checks are also now applied in cases of default
+ initialization of components, allocators, ancestor parts of extension aggregates, and box associations of aggregates.
+
+ RM references: 7.03.03 (0) 1.01.03 (17.1/5) 11.04.02 (23.2/5) 11.04.02 (23.3/5)
+
+.. index:: AI12-0269 (Ada 2022 feature)
+
+* *AI12-0269 Aspect No_Return for functions reprise (2020-03-19)*
+
+ This amendment has been implemented under the ``-gnat2022`` switch, and the
+ compiler now accepts the aspect/pragma No_Return for functions and generic
+ functions.
+
+ RM references: 6.05.01 (0) 6.05.01 (1/3) 6.05.01 (3.1/3) 6.05.01 (3.4/3)
+ 6.05.01 (5/2) 6.05.01 (6/2) 6.05.01 (7/2) J.15.02 (2/3) J.15.02
+ (3/3) J.15.02 (4/3)
+
+.. index:: AI12-0272 (Ada 2022 feature)
+
+* *AI12-0272 (part 1) Pre/Postconditions for formal subprograms (0000-00-00)*
+
+ Pre and Post aspects can be specified for a generic formal subprogram. ``Default_Initial_Condition`` can be specified for a generic formal private type.
+
+ GNAT implements this with an exception of the part related to ``Default_Initial_Condition``.
+
+ RM references: 6.01.01 (1/5) 6.01.01 (39/5) 7.03.03 (1/5) 7.03.03 (2/5)
+ 7.03.03 (8/5) 7.03.04 (5/5) F.01 (1)
+
+.. index:: AI12-0275 (Ada 2022 feature)
+
+* *AI12-0275 Make subtype_mark optional in object renames (2020-01-28)*
+
+ AI12-0275 allows object renamings to be declared without an explicit
+ subtype_mark or access_definition. This feature can be used by compiling
+ with the switch ``-gnat2022``.
+
+ RM references: 8.05.01 (2/3) 8.05.01 (3/2)
+
+.. index:: AI12-0277 (Ada 2022 feature)
+
+* *AI12-0277 The meaning of "accessibility level of the body of F" (0000-00-00)*
+
+ Clarify that the only time that an explicitly aliased formal parameter has different accessibility properties than an aliased part of a "normal" parameter is for the accessibility checking associated with a return statement.
+
+ RM references: 3.10.02 (19.2/4)
+
+.. index:: AI12-0278 (Ada 2022 feature)
+
+* *AI12-0278 Implicit conversions of anonymous return types (0000-00-00)*
+
+ If a call to a function with an anonymous-access-type result is converted to a named access type, it doesn't matter whether the conversion is implicit or explicit. the AI fixes hole where the previous rules didn't cover the implicit conversion case.
+
+ RM references: 3.10.02 (10.3/3)
+
+.. index:: AI12-0279 (Ada 2022 feature)
+
+* *AI12-0279 Nonpreemptive dispatching needs more dispatching points (2020-04-17)*
+
+ Ada 2022 defines a new aspect `Yield` that can be specified in the declaration of a noninstance subprogram (including a generic formal subprogram), a generic subprogram, or an entry, to ensure that the associated subprogram has at least one task dispatching point during each invocation.
+
+ RM references: D.02.01 (1.5/2) D.02.01 (7/5)
+
+.. index:: AI12-0280-2 (Ada 2022 feature)
+
+* *AI12-0280-2 Making 'Old more flexible (2020-07-24)*
+
+ For Ada 2022, AI12-0280-2 relaxes Ada's restrictions on 'Old attribute
+ references whose attribute prefix does not statically name an entity. Previously, it was required that such an attribute reference must be unconditionally evaluated when the postcondition is evaluated; with the new rule, conditional evaluation is permitted if the relevant conditions can be evaluated upon entry to the subprogram with the same results as evaluation at the time of the postcondition's evaluation. In this case, the 'Old attribute prefix is evaluated conditionally (more specifically, the prefix is evaluated only if the result of that evaluation is going to be referenced later when the
+ postcondition is evaluated).
+
+ RM references: 6.01.01 (20/3) 6.01.01 (21/3) 6.01.01 (22/3) 6.01.01
+ (22.1/4) 6.01.01 (22.2/5) 6.01.01 (23/3) 6.01.01 (24/3) 6.01.01
+ (26/4) 6.01.01 (27/5) 6.01.01 (39/5)
+
+.. index:: AI12-0282 (Ada 2022 feature)
+
+* *AI12-0282 Atomic, Volatile, and Independent generic formal types (0000-00-00)*
+
+ The AI specifies that the aspects ``Atomic``, ``Volatile``, ``Independent``, ``Atomic_Components``, ``Volatile_Components``, and ``Independent_Components`` are specifiable for generic formal types. The actual type must have a matching specification.
+
+ RM references: C.06 (6.1/3) C.06 (6.3/3) C.06 (6.5/3) C.06 (6.8/3) C.06
+ (12/3) C.06 (12.1/3) C.06 (21/4)
+
+.. index:: AI12-0285 (Ada 2022 feature)
+
+* *AI12-0285 Syntax for Stable_Properties aspects (0000-00-00)*
+
+ The AI establishes the required named notation for a Stable_Properties aspect specification in order to avoid syntactic ambiguities.
+
+ With the old syntax, an example like
+
+ .. code::
+
+ type Ugh is ...
+ with Stable_Properties =\> Foo, Bar, Nonblocking, Pack;
+
+ was problematic; ``Nonblocking`` and ``Pack`` are other aspects, while ``Foo`` and ``Bar`` are ``Stable_Properties`` functions. With the clarified syntax, the example above shall be written as:
+
+ .. code::
+
+ type Ugh is ...
+ with Stable_Properties => (Foo, Bar), Nonblocking, Pack;
+
+ RM references: 7.03.04 (2/5) 7.03.04 (3/5) 7.03.04 (4/5) 7.03.04 (6/5)
+ 7.03.04 (7/5) 7.03.04 (9/5) 7.03.04 (10/5) 7.03.04 (14/5) 13.01.01 (4/5)
+
+.. index:: AI12-0287 (Ada 2022 feature)
+
+* *AI12-0287 Legality Rules for null exclusions in renaming are too fierce (2020-02-17)*
+
+ The null exclusion legality rules for generic formal object matching and object renaming now only apply to generic formal objects with mode in out.
+
+ RM references: 8.05.01 (4.4/2) 8.05.01 (4.5/2) 8.05.01 (4.6/2) 8.05.04
+ (4.2/2) 12.04 (8.3/2) 12.04 (8.4/2) 12.04 (8.5/2) 12.04 (8.2/5)
+ 12.06 (8.2/5)
+
+.. index:: AI12-0289 (Ada 2022 feature)
+
+* *AI12-0289 Implicitly null excluding anonymous access types and conformance (2020-06-09)*
+
+ AI12-0289 is implemented for Ada 2022, allowing safer use of access parameters
+ when the partial view of the designated type is untagged, but the full view is
+ tagged.
+
+ RM references: 3.10 (26)
+
+.. index:: AI12-0290 (Ada 2022 feature)
+
+* *AI12-0290 Restriction Pure_Barriers (2020-02-18)*
+
+ The GNAT implementation of the Pure_Barriers restriction has
+ been updated to match the Ada RM's definition as specified
+ in this AI. Some constructs that were accepted by the previous
+ implementation are now rejected, and vice versa. In
+ particular, the use of a component of a component of a
+ protected record in a barrier expression, as in "when
+ Some_Component.Another_Component =>", formerly was (at least
+ in some cases) not considered to be a violation of the
+ Pure_Barriers restriction; that is no longer the case.
+
+ RM references: D.07 (2) D.07 (10.10/4)
+
+.. index:: AI12-0291 (Ada 2022 feature)
+
+* *AI12-0291 Jorvik Profile (2020-02-19)*
+
+ The Jorvik profile is now implemented, as defined in this AI.
+ For Ada 2012 and earlier versions of Ada, Jorvik is an implementation-defined
+ profile whose definition matches its Ada 2022 definition.
+
+ RM references: D.13 (0) D.13 (1/3) D.13 (4/3) D.13 (6/4) D.13 (9/3) D.13
+ (10/3) D.13 (11/4) D.13 (12/4)
+
+.. index:: AI12-0293 (Ada 2022 feature)
+
+* *AI12-0293 Add predefined FIFO_Streams packages (0000-00-00)*
+
+ The AI adds ``Ada.Streams.Storage`` and its two subunits ``Bounded`` and ``Unbounded``.
+
+ RM references: 13.13.01 (1) 13.13.01 (9) 13.13.01 (9.1/1)
+
+.. index:: AI12-0295 (Ada 2022 feature)
+
+* *AI12-0295 User-defined string (2020-04-07)*
+
+ Compiler support is added for three new aspects (``Integer_Literal``, ``Real_Literal``, and ``String_Literal``) as described in AI12-0249 (for ``Integer_Literal`` and ``Real_Literal``), AI12-0295 (for ``String_Literal``), and in two follow-up AIs (AI12-0325 and AI12-0342). For pre-Ada 2022 versions of Ada, these are treated as implementation-defined aspects. Some implementation work remains, particularly in the interactions between these aspects and tagged types.
+
+ RM references: 4.02 (6) 4.02 (10) 4.02 (11) 3.06.03 (1) 4.02.01 (0) 4.09 (26/3)
+
+.. index:: AI12-0301 (Ada 2022 feature)
+
+* *AI12-0301 Predicates should be checked like constraints for types with Default_Value (2020-02-25)*
+
+ This AI clarifies that predicate checks apply for objects that are initialized
+ by default and that are of a type that has any components whose subtypes specify ``Default_Value`` or ``Default_Component_Value``.
+
+ RM references: 3.02.04 (31/4)
+
+.. index:: AI12-0304 (Ada 2022 feature)
+
+* *AI12-0304 Image attributes of language-defined types (2020-07-07)*
+
+ According to this AI, ``Put_Image`` (and therefore ``'Image``) is provided for
+ the containers and for unbounded strings.
+
+ RM references: 4.10 (0)
+
+.. index:: AI12-0306 (Ada 2022 feature)
+
+* *AI12-0306 Split null array aggregates from positional array aggregates (0000-00-00)*
+
+ The AI clarifies the wording of the references RM paragraphs without introducing any language changes.
+
+ RM references: 4.03.03 (2) 4.03.03 (3/2) 4.03.03 (9/5) 4.03.03 (26/5)
+ 4.03.03 (26.1/5) 4.03.03 (33/3) 4.03.03 (38) 4.03.03 (39) 4.03.03 (42)
+
+.. index:: AI12-0307 (Ada 2022 feature)
+
+* *AI12-0307 Resolution of aggregates (2020-08-13)*
+
+ The proposed new syntax for aggregates in Ada 2022 uses square brackets as
+ delimiters, and in particular allows ``[]`` as a notation for empty array and container aggregates. This syntax is currently available as an experimental feature under the ``-gnatX`` flag.
+
+ RM references: 4.03 (3/5)
+
+.. index:: AI12-0309 (Ada 2022 feature)
+
+* *AI12-0309 Missing checks for pragma Suppress (0000-00-00)*
+
+ The AI includes some previously overlooked run-time checks in the list of checks that are potentially suppressed via a pragma ``Suppress``. For example, AI12-0251-1 adds a check that the number of chunks in a chunk_specification is not zero or negative. Clarify that suppressing ``Program_Error_Check`` suppresses that check too.
+
+ RM references: 11.05 (10) 11.05 (19) 11.05 (20) 11.05 (22) 11.05 (24)
+
+.. index:: AI12-0311 (Ada 2022 feature)
+
+* *AI12-0311 Suppressing client-side assertions for language-defined units (0000-00-00)*
+
+ The AI defines some new assertion policies that can be given as arguments in a Suppress pragma (e.g., Calendar_Assertion_Check). GNAT recognizes and ignores those new policies, the checks are not implemented.
+
+ RM references: 11.04.02 (23.5/5) 11.05 (23) 11.05 (26)
+
+.. index:: AI12-0315 (Ada 2022 feature)
+
+* *AI12-0315 Image Attributes subclause improvements (0000-00-00)*
+
+ Clarify that a named number or similar can be the prefix of an Image attribute reference.
+
+ RM references: 4.10 (0)
+
+.. index:: AI12-0318 (Ada 2022 feature)
+
+* *AI12-0318 No_IO should apply to Ada.Directories (2020-01-31)*
+
+ The restriction No_IO now applies to and prevents the use of the
+ ``Ada.Directories package``.
+
+ RM references: H.04 (20/2) H.04 (24/3)
+
+.. index:: AI12-0321 (Ada 2022 feature)
+
+* *AI12-0321 Support for Arithmetic Atomic Operations and Test and Set (0000-00-00)*
+
+ The AI adds some predefined atomic operations, e.g. package System.``Atomic_Operations.Test_And_Set``.
+
+ RM references: C.06.03 (0) C.06.04 (0)
+
+.. index:: AI12-0325 (Ada 2022 feature)
+
+* *AI12-0325 Various issues with user-defined literals (2020-04-07)*
+
+ Compiler support is added for three new aspects (``Integer_Literal``, ``Real_Literal``, and ``String_Literal``) as described in AI12-0249 (for ``Integer_Literal`` and ``Real_Literal``), AI12-0295 (for ``String_Literal``), and in two follow-up AIs (AI12-0325 and AI12-0342). For pre-Ada 2022 versions of Ada, these are treated as implementation-defined aspects. Some implementation work remains, particularly in the interactions between these aspects and tagged types.
+
+ RM references: 4.02 (6) 4.02 (10) 4.02 (11) 4.02.01 (0)
+
+.. index:: AI12-0329 (Ada 2022 feature)
+
+* *AI12-0329 Naming of FIFO_Streams packages (0000-00-00)*
+
+ The AI changes the name of predefined package ``Ada.Streams.FIFO_Streams`` to ``Ada.Streams.Storage``.
+
+ RM references: 13.13.01 (9/5) 13.13.01 (9.1/5)
+
+.. index:: AI12-0331 (Ada 2022 feature)
+
+* *AI12-0331 Order of finalization of a subpool (0000-00-00)*
+
+ Clarify that when a subpool is being finalized, objects allocated from that subpool are finalized before (not after) they cease to exist (i.e. object's storage has been reclaimed).
+
+ RM references: 13.11.05 (5/3) 13.11.05 (6/3) 13.11.05 (7/3) 13.11.05
+ (7.1/4) 13.11.05 (8/3) 13.11.05 (9/3)
+
+.. index:: AI12-0333 (Ada 2022 feature)
+
+* *AI12-0333 Predicate checks on out parameters (0000-00-00)*
+
+ If a view conversion is passed as an actual parameter corresponding to an out-mode formal parameter, and if the subtype of the formal parameter has a predicate, then no predicate check associated with the conversion is performed.
+
+ RM references: 3.02.04 (31/5) 4.06 (51/4) 6.04.01 (14)
+
+.. index:: AI12-0335 (Ada 2022 feature)
+
+* *AI12-0335 Dynamic accessibility check needed for some requeue targets (0000-00-00)*
+
+ Define a new runtime accessibility check for a corner case involving requeue statements.
+
+ RM references: 9.05.04 (7/4)
+
+.. index:: AI12-0336 (Ada 2022 feature)
+
+* *AI12-0336 Meaning of Time_Offset (0000-00-00)*
+
+ The AI introduces changes to the predefined package ``Ada.Calendar.Time_Zones``.
+
+ RM references: 9.06.01 (6/2) 9.06.01 (35/2) 9.06.01 (40/2) 9.06.01 (41/2)
+ 9.06.01 (42/3) 9.06.01 (90/2) 9.06.01 (91/2)
+
+.. index:: AI12-0337 (Ada 2022 feature)
+
+* *AI12-0337 Simple_Name("/") in Ada.Directories (0000-00-00)*
+
+ Clarify behavior of subprograms in the predefined package ``Ada.Directories``. In particular, Simple_Name ("/") should return "/" on Unix-like systems.
+
+ RM references: A.16 (47/2) A.16 (74/2) A.16 (82/3)
+
+.. index:: AI12-0338 (Ada 2022 feature)
+
+* *AI12-0338 Type invariant checking and incomplete types (0000-00-00)*
+
+ Clarify that type invariants for type T are not checked for incomplete types whose completion is not available, even if that completion has components of type T.
+
+ RM references: 7.03.02 (20/5)
+
+.. index:: AI12-0339 (Ada 2022 feature)
+
+* *AI12-0339 Empty function for Container aggregates (2020-08-06)*
+
+ To provide uniform support for container aggregates, all standard container
+ libraries have been enhanced with a function Empty, to be used when initializing an aggregate prior to inserting the specified elements in the object being constructed. All products have been updated to remove the ambiguities that may have arisen from previous uses of entities named Empty in our sources, and the expansion of container aggregates uses Empty wherever needed.
+
+ RM references: A.18.02 (8/5) A.18.02 (12.3/5) A.18.02 (78.2/5) A.18.02
+ (98.6/5) A.18.03 (6/5) A.18.03 (10.2/5) A.18.03 (50.2/5) A.18.05
+ (3/5) A.18.05 (7.2/5) A.18.05 (37.3/5) A.18.05 (46/2) A.18.06
+ (4/5) A.18.06 (8.2/5) A.18.06 (51.4/5) A.18.08 (3/5) A.18.08
+ (8.1/5) A.18.08 (59.2/5) A.18.08 (68/2) A.18.09 (4/5) A.18.09
+ (9.1/5) A.18.09 (74.2/5) A.18.10 (15.2/5) A.18.18 (8.1/5) A.18.19
+ (6.1/5) A.18.20 (6/3) A.18.21 (6/3) A.18.22 (6/3) A.18.23 (6/3)
+ A.18.24 (6/3) A.18.25 (8/3)
+
+.. index:: AI12-0340 (Ada 2022 feature)
+
+* *AI12-0340 Put_Image should use a Text_Buffer (0000-00-00)*
+
+ Add a new predefined package Ada.Strings.Text_Buffers (along with child units) and change the definition of Put_Image attribute to refer to it.
+
+ RM references: A.04.12 (0) 4.10 (3.1/5) 4.10 (3.2/5) 4.10 (6/5) 4.10
+ (25.2/5) 4.10 (28/5) 4.10 (31/5) 4.10 (41/5) H.04 (23.2/5) H.04 (23.11/5)
+
+.. index:: AI12-0342 (Ada 2022 feature)
+
+* *AI12-0342 Various issues with user-defined literals (part 2) (2020-04-07)*
+
+ Compiler support is added for three new aspects (``Integer_Literal``, ``Real_Literal``, and ``String_Literal``) as described in AI12-0249 (for ``Integer_Literal`` and ``Real_Literal``), AI12-0295 (for ``String_Literal``), and in two follow-up AIs (AI12-0325 and AI12-0342). For pre-Ada 2022 versions of Ada, these are treated as implementation-defined aspects. Some implementation work remains, particularly in the interactions between these aspects and tagged types.
+
+ RM references: 4.02.01 (0) 3.09.02 (1/2) 6.03.01 (22)
+
+.. index:: AI12-0343 (Ada 2022 feature)
+
+* *AI12-0343 Return Statement Checks (2020-04-02)*
+
+ This binding interpretation has been implemented and the accessibility,
+ predicate, and tag checks prescribed by RM 6.5 are now performed at the appropriate points, as required by this AI.
+
+ RM references: 6.05 (5.12/5) 6.05 (8/4) 6.05 (8.1/3) 6.05 (21/3)
+
+.. index:: AI12-0345 (Ada 2022 feature)
+
+* *AI12-0345 Dynamic accessibility of explicitly aliased parameters (0000-00-00)*
+
+ Further clarify (after AI12-0277) accessibility rules for explicitly aliased parameters.
+
+ RM references: 3.10.02 (5) 3.10.02 (7/4) 3.10.02 (10.5/3) 3.10.02 (13.4/4)
+ 3.10.02 (19.2/5) 3.10.02 (21)
+
+.. index:: AI12-0350 (Ada 2022 feature)
+
+* *AI12-0350 Swap for Indefinite_Holders (0000-00-00)*
+
+ Add a ``Swap`` procedure to the predefined package
+ ``Ada.Containers.Indefinite_Holders``. The AI also contains implementation advice for ``Ada.Containers.Bounded_Indefinite_Holders``, a package that is not implemented by GNAT.
+
+ RM references: A.18.18 (22/5) A.18.18 (67/5) A.18.18 (73/3) A.18.32 (13/5)
+
+.. index:: AI12-0351 (Ada 2022 feature)
+
+* *AI12-0351 Matching for actuals for formal derived types (2020-04-03)*
+
+ This binding interpretation requires the compiler to checks
+ that an actual subtype in a generic parameter association of an instantiation is statically compatible (even when the actual is unconstrained) with the ancestor of an associated nondiscriminated generic formal derived type.
+
+ RM references: 12.05.01 (7) 12.05.01 (8)
+
+.. index:: AI12-0352 (Ada 2022 feature)
+
+* *AI12-0352 Early derivation and equality of untagged types (2020-07-09)*
+
+ AI12-0352 clarifies that declaring a user-defined primitive equality operation for a record type T is illegal if it occurs after a type has been derived from T.
+
+ RM references: 4.05.02 (9.8/4)
+
+.. index:: AI12-0356 (Ada 2022 feature)
+
+* *AI12-0356 Root_Storage_Pool_With_Subpools should have Preelaborable_Initialization (0000-00-00)*
+
+ Add Preelaborable_Initialization pragmas for predefined types ``Root_Storage_Pool_With_Subpools`` and ``Root_Subpool``.
+
+ RM references: 13.11.04 (4/3) 13.11.04 (5/3)
+
+.. index:: AI12-0363 (Ada 2022 feature)
+
+* *AI12-0363 Fixes for Atomic and Volatile (2020-09-08)*
+
+ This amendment has been implemented under the ``-gnat2022`` switch and the compiler now supports the ``Full_Access_Only`` aspect, which is mostly equivalent to GNAT's ``Volatile_Full_Access``.
+
+ RM references: 3.10.02 (26/3) 9.10 (1/5) C.06 (6.4/3) C.06 (6.10/3) C.06
+ (8.1/4) C.06 (12/5) C.06 (12.1/5) C.06 (13.3/5) C.06 (19.1/5)
+
+.. index:: AI12-0364 (Ada 2022 feature)
+
+* *AI12-0364 Add a modular atomic arithmetic package (0000-00-00)*
+
+ Generalize support for atomic integer operations to extend to modular types. Add new predefined generic package,
+ ``System.Atomic_Operations.Modular_Arithmetic``.
+
+ RM references: C.06.05 (0) C.06.04 (1/5) C.06.04 (2/5) C.06.04 (3/5)
+ C.06.04 (9/5)
+
+.. index:: AI12-0366 (Ada 2022 feature)
+
+* *AI12-0366 Changes to Big_Integer and Big_Real (0000-00-00)*
+
+ Simplify ``Big_Integer ``and ``Big_Real`` specs by eliminating explicit support for creating "invalid" values. No more
+ ``Optional_Big_[Integer,Real]`` types.
+
+ RM references: A.05.06 (0) A.05.07 (0)
+
+.. index:: AI12-0367 (Ada 2022 feature)
+
+* *AI12-0367 Glitches in aspect specifications (0000-00-00)*
+
+ The AI clarifies a few wording omissions. For example, a specified Small value for a fixed point type has to be positive.
+
+ RM references: 3.05.09 (8/2) 3.05.10 (2/1) 13.01 (9.1/5) 13.14 (10)
+
+.. index:: AI12-0368 (Ada 2022 feature)
+
+* *AI12-0368 Declare expressions can be static (2020-05-30)*
+
+ AI12-0368 allows declare expressions to be static in Ada 2022.
+
+ RM references: 4.09 (8) 4.09 (12.1/3) 4.09 (17) 6.01.01 (24.2/5) 6.01.01
+ (24.3/5) 6.01.01 (24.4/5) 6.01.01 (24.5/5) C.04 (9)
+
+.. index:: AI12-0369 (Ada 2022 feature)
+
+* *AI12-0369 Relaxing barrier restrictions (2020-03-25)*
+
+ The definitions of the ``Simple_Barriers`` and ``Pure_Barriers`` restrictions were modified by this AI, replacing uses of "statically denotes" with "statically names". This means that in many cases (but not all) a barrier expression that references a subcomponent of a component of the protected type while subject to either of the two restrictions is now allowed; with the previous restriction definitions, such a barrier expression would not have been legal.
+
+ RM references: D.07 (1.3/5) D.07 (10.12/5)
+
+.. index:: AI12-0372 (Ada 2022 feature)
+
+* *AI12-0372 Static accessibility of "master of the call" (0000-00-00)*
+
+ Add an extra compile-time accessibility check for explicitly aliased parameters needed to prevent dangling references.
+
+ RM references: 3.10.02 (10.5/5) 3.10.02 (19.3/4) 6.04.01 (6.4/3)
+
+.. index:: AI12-0373 (Ada 2022 feature)
+
+* *AI12-0373 Bunch of fixes (0000-00-00)*
+
+ Small clarifications to various RM entries with minor impact on compiler implementation.
+
+ RM references: 3.01 (1) 4.02 (4) 4.02 (8/2) 4.02.01 (3/5) 4.02.01 (4/5)
+ 4.02.01 (5/5) 4.09 (17.3/5) 6.01.01 (41/5) 8.05.04 (4/3) 13.01.01
+ (4/3) 13.01.01 (11/3) 13.14 (3/5)
+
+.. index:: AI12-0376 (Ada 2022 feature)
+
+* *AI12-0376 Representation changes finally allowed for untagged derived types (0000-00-00)*
+
+ A change of representation for a derived type is allowed in some previously-illegal cases where a change of representation is required to implement a call to a derived subprogram.
+
+ RM references: 13.01 (10/4)
+
+.. index:: AI12-0377 (Ada 2022 feature)
+
+* *AI12-0377 View conversions and out parameters of types with Default_Value revisited (2020-06-17)*
+
+ This AI clarifies that an actual of an out parameter that is a view conversion
+ is illegal if either the target or operand type has Default_Value specified while the other does not.
+
+ RM references: 6.04.01 (5.1/4) 6.04.01 (5.2/4) 6.04.01 (5.3/4) 6.04.01
+ (13.1/4) 6.04.01 (13.2/4) 6.04.01 (13.3/4) 6.04.01 (13.4/4) 6.04.01 (15/3)
+
+.. index:: AI12-0381 (Ada 2022 feature)
+
+* *AI12-0381 Tag of a delta aggregate (0000-00-00)*
+
+ In the case of a delta aggregate of a specific tagged type, the tag of the aggregate comes from the specific type (as opposed to somehow from the base object).
+
+ RM references: 4.03.04 (14/5)
+
+.. index:: AI12-0382 (Ada 2022 feature)
+
+* *AI12-0382 Loosen type-invariant overriding requirement of AI12-0042-1 (0000-00-00)*
+
+ The AI relaxes some corner-case legality rules about type invariants that were added by AI12-0042-1.
+
+ RM references: 7.3.2(6.1/4)
+
+.. index:: AI12-0383 (Ada 2022 feature)
+
+* *AI12-0383 Renaming values (2020-06-17)*
+
+ This AI allow names that denote values rather than objects to nevertheless be
+ renamed using an object renaming.
+
+ RM references: 8.05.01 (1) 8.05.01 (4) 8.05.01 (4.1/2) 8.05.01 (6/2) 8.05.01 (8)
+
+.. index:: AI12-0384-2 (Ada 2022 feature)
+
+* *AI12-0384-2 Fixups for Put_Image and Text_Buffers (2021-04-29)*
+
+ In GNAT's initial implementation of the Ada 2022 ``Put_Image`` aspect and
+ attribute, buffering was performed using a GNAT-defined package,
+ ``Ada.Strings.Text_Output``. Ada 2022 requires a different package, Ada.``Strings.Text_Buffers``, for this role, and that package is now provided, and the older package is eliminated.
+
+ RM references: 4.10 (0) A.04.12 (0)
+
+.. index:: AI12-0385 (Ada 2022 feature)
+
+* *AI12-0385 Predefined shifts and rotates should be static (0000-00-00)*
+
+ This AI allows Shift and Rotate operations in static expressions. GNAT implements this AI partially.
+
+ RM references: 4.09 (20)
+
+.. index:: AI12-0389 (Ada 2022 feature)
+
+* *AI12-0389 Ignoring unrecognized aspects (2020-10-08)*
+
+ Two new restrictions, ``No_Unrecognized_Aspects`` and ``No_Unrecognized_Pragmas``, are available to make the compiler emit error messages on unrecognized pragmas and aspects.
+
+ RM references: 13.01.01 (38/3) 13.12.01 (6.3/3)
+
+.. index:: AI12-0394 (Ada 2022 feature)
+
+* *AI12-0394 Named Numbers and User-Defined Numeric Literals (2020-10-05)*
+
+ Ada 2022 allows using integer named numbers with types that have an
+ ``Integer_Literal`` aspect. Similarly, real named numbers may now be used with types that have a ``Real_Literal`` aspect with an overloading that takes two strings, to be used in particular with
+ ``Ada.Numerics.Big_Numbers.Big_Reals``.
+
+ RM references: 3.03.02 (3) 4.02.01 (4/5) 4.02.01 (8/5) 4.02.01 (12/5)
+ 4.02.01 (13/5) 4.09 (5)
+
+.. index:: AI12-0395 (Ada 2022 feature)
+
+* *AI12-0395 Allow aspect_specifications on formal parameters (0000-00-00)*
+
+ Change syntax rules to allow aspect_specifications on formal parameters, if an implementation if an implementation wants to define one. Currently, GNAT doesn't define any such aspect_specifications.
+
+ RM references: 6.01 (15/3)
+
+.. index:: AI12-0397 (Ada 2022 feature)
+
+* *AI12-0397 Default_Initial_Condition applied to derived type (2020-12-09)*
+
+ The compiler now implements the rules for resolving ``Default_Initial_Condition``
+ expressions that involve references to the current instance of types with the aspect, as specified by this AI. The type of the current instance is defined to be like a formal derived type, so for a derived type that inherits the aspect, a call passing the current instance to a primitive means that the call will resolve to invoke the corresponding primitive of the descendant type. This also now permits calls to abstract primitives to occur within the aspect expression of an abstract type.
+
+ RM references: 7.03.03 (3/5) 7.03.03 (6/5) 7.03.03 (8/5)
+
+.. index:: AI12-0398 (Ada 2022 feature)
+
+* *AI12-0398 Most declarations should have aspect specifications (2020-11-19)*
+
+ It is now possible to specify aspects for discriminant specifications, extended return object declarations, and entry index specifications. This is an extension added for Ada 2022 by this AI.
+
+ RM references: 3.07 (5/2) 6.03.01 (25) 6.05 (2.1/3) 9.05.02 (8)
+
+.. index:: AI12-0399 (Ada 2022 feature)
+
+* *AI12-0399 Aspect specification for Preelaborable_Initialization (0000-00-00)*
+
+ Semantics-preserving presentation change. Replace ``Preelaborable_Initialization`` pragmas with equivalent aspect specs in the listed predefined packages. GNAT follows the guidance of this AI partially.
+
+ RM references: 9.05 (53/5) 3.09 (6/5) 7.06 (5/2) 7.06 (7/2) 11.04.01 (2/5)
+ 11.04.01 (3/2) 13.11 (6/2) 13.11.04 (4/5) 13.11.04 (5/5) 13.13.01
+ (3/2) A.04.02 (4/2) A.04.02 (20/2) A.04.05 (4/2) A.04.07 (4/2)
+ A.04.07 (20/2) A.04.08 (4/2) A.04.08 (20/2) A.12.01 (5/4) A.18.02
+ (8/5) A.18.02 (9/2) A.18.02 (79.2/5) A.18.02 (79.3/5) A.18.03
+ (6/5) A.18.03 (7/2) A.18.03 (50.2/5) A.18.03 (50.3/5) A.18.05
+ (3/5) A.18.05 (4/2) A.18.05 (37.3/5) A.18.05 (37.4/5) A.18.06
+ (4/5) A.18.06 (5/2) A.18.06 (51.4/5) A.18.06 (51.5/5) A.18.08
+ (3/5) A.18.08 (4/2) A.18.08 (58.2/5) A.18.08 (58.3/5) A.18.09
+ (4/5) A.18.09 (5/2) A.18.09 (74.2/5) A.18.09 (74.3/5) A.18.10
+ (8/5) A.18.10 (9/3) A.18.10 (70.2/5) A.18.10 (70.3/5) A.18.18
+ (6/5) B.03.01 (5/2) C.07.01 (2/5) G.01.01 (4/2)
+
+.. index:: AI12-0400 (Ada 2022 feature)
+
+* *AI12-0400 Ambiguities associated with Vector Append and container aggregates (0000-00-00)*
+
+ Change the names of subprograms in the predefined Vector containers from ``Append`` to ``Append_Vector`` and from ``Prepend`` to ``Prepend_Vector`` in order to resolve some ambiguity problems. GNAT adds the subprograms with new names but also keeps the old ones for backward compatibility.
+
+ RM references: A.18.02 (8/5) A.18.02 (36/5) A.18.02 (37/5) A.18.02 (38/5)
+ A.18.02 (44/5) A.18.02 (46/5) A.18.02 (47/5) A.18.02 (58/5)
+ A.18.02 (79.2/5) A.18.02 (150/5) A.18.02 (151/5) A.18.02 (152/5)
+ A.18.02 (153/5) A.18.02 (154/5) A.18.02 (155/5) A.18.02 (156/5)
+ A.18.02 (168/5) A.18.02 (169/5) A.18.02 (172/5) A.18.02 (173/5)
+ A.18.02 (174/5) A.18.02 (175.1/5) A.18.03 (23/5) A.18.03 (23.1/5)
+ A.18.03 (58.2/5) A.18.03 (96/5) A.18.03 (97.1/5)
+
+.. index:: AI12-0401 (Ada 2022 feature)
+
+* *AI12-0401 Renaming of qualified expression of variable (2020-10-31)*
+
+ Ada 2022 AI12-0401 restricts renaming of a qualified expression to cases where
+ the operand is a constant, or the target subtype statically matches the nominal subtype of the operand, or is unconstrained with no predicates, to prevent setting variables to values outside their range or constraints.
+
+ RM references: 3.03 (23.2/3) 8.05.01 (4.7/5) 8.05.01 (5/3)
+
+.. index:: AI12-0409 (Ada 2022 feature)
+
+* *AI12-0409 Preelaborable_Initialization and bounded containers (2021-06-23)*
+
+ As defined by this AI, the ``Preelaborable_Initializatio`` aspect now has a
+ corresponding attribute of the same name. Types declared within a generic package specification are permitted to specify the expression of a ``Prelaborable_Initialization`` aspect by including one or more references to the attribute applied to a formal private or formal derived type conjoined by ``and`` operators. This permits the full type of a private type with such an aspect expression to have components of the named formal types, and such a type will have preelaborable initialization in an instance when the
+ actual types for all referenced formal types have preelaborable initialization.
+
+ RM references: 10.02.01 (4.1/2) 10.02.01 (4.2/2) 10.02.01 (11.1/2)
+ 10.02.01 (11.2/2) 10.02.01 (11.6/2) 10.02.01 (11.7/2) 10.02.01
+ (11.8/2) 13.01 (11/3) A.18.19 (5/5) A.18.20 (5/5) A.18.21 (5/5)
+ A.18.22 (5/5) A.18.23 (5/5) A.18.24 (5/5) A.18.25 (5/5) A.18.32
+ (6/5) J.15.14 (0)
+
+.. index:: AI12-0411 (Ada 2022 feature)
+
+* *AI12-0411 Add "bool" to Interfaces.C (0000-00-00)*
+
+ RM references: B.03 (13) B.03 (43/2) B.03 (65.1/4)
+
+.. index:: AI12-0412 (Ada 2022 feature)
+
+* *AI12-0412 Abstract Pre/Post'Class on primitive of abstract type (2021-05-19)*
+
+ In Ada 2022, by AI12-0412, it's legal to specify Pre'Class and Post'Class
+ aspects on nonabstract primitive subprograms of an abstract type, but if the
+ expression of such an aspect is nonstatic, then it's illegal to make a nondispatching call to such a primitive, to apply ``'Access`` to it, or to pass such a primitive as an actual subprogram for a concrete formal subprogram in a generic instantiation.
+
+ RM references: 6.01.01 (18.2/4)
+
+.. index:: AI12-0413 (Ada 2022 feature)
+
+* *AI12-0413 Reemergence of "=" when defined to be abstract (0000-00-00)*
+
+ The AI clarifies rules about operator reemergence in instances, and nondispatching calls to abstract subprograms.
+
+ RM references: 3.09.03 (7) 4.05.02 (14.1/3) 4.05.02 (24.1/3) 12.05 (8/3)
+
+.. index:: AI12-0423 (Ada 2022 feature)
+
+* *AI12-0423 Aspect inheritance fixups (0000-00-00)*
+
+ Clarify that the No_Return aspect behaves as one would expect for an inherited subprogram and that inheritance works as one would expect for a multi-part aspect whose value is specified via an aggregate (e.g., the Aggregate aspect).
+
+ RM references: 6.05.01 (3.3/3) 13.01 (15.7/5) 13.01 (15.8/5)
+
+.. index:: AI12-0432 (Ada 2022 feature)
+
+* *AI12-0432 View conversions of assignments and predicate checks (2021-05-05)*
+
+ When a predicate applies to a tagged type, a view conversion to that type
+ normally requires a predicate check. However, as specified by AI12-0432, when the view conversion appears as the target of an assignment, a predicate check is not applied to the object in the conversion.
+
+ RM references: 3.02.04 (31/5) 4.06 (51.1/5)
* Specialized Needs Annexes::
* Implementation of Specific Ada Features::
* Implementation of Ada 2012 Features::
+* Implementation of Ada 2022 Features::
* GNAT language extensions::
* Security Hardening Features::
* Obsolescent Features::
GNAT implementation of the Ada 2012 language standard.
@item
-@ref{15,,Security Hardening Features} documents GNAT extensions aimed
+@ref{15,,Implementation of Ada 2022 Features}, describes the status of the
+GNAT implementation of the Ada 2022 language standard.
+
+@item
+@ref{16,,Security Hardening Features} documents GNAT extensions aimed
at security hardening.
@item
-@ref{16,,Obsolescent Features} documents implementation dependent features,
+@ref{17,,Obsolescent Features} documents implementation dependent features,
including pragmas and attributes, which are considered obsolescent, since
there are other preferred ways of achieving the same results. These
obsolescent forms are retained for backwards compatibility.
@item
-@ref{17,,Compatibility and Porting Guide} presents some guidelines for
+@ref{18,,Compatibility and Porting Guide} presents some guidelines for
developing portable Ada code, describes the compatibility issues that
may arise between GNAT and other Ada compilation systems (including those
for Ada 83), and shows how GNAT can expedite porting applications
package.
@node Conventions,Related Information,What This Reference Manual Contains,About This Guide
-@anchor{gnat_rm/about_this_guide conventions}@anchor{18}
+@anchor{gnat_rm/about_this_guide conventions}@anchor{19}
@section Conventions
@end itemize
@node Related Information,,Conventions,About This Guide
-@anchor{gnat_rm/about_this_guide related-information}@anchor{19}
+@anchor{gnat_rm/about_this_guide related-information}@anchor{1a}
@section Related Information
@end itemize
@node Implementation Defined Pragmas,Implementation Defined Aspects,About This Guide,Top
-@anchor{gnat_rm/implementation_defined_pragmas doc}@anchor{1a}@anchor{gnat_rm/implementation_defined_pragmas id1}@anchor{1b}@anchor{gnat_rm/implementation_defined_pragmas implementation-defined-pragmas}@anchor{7}
+@anchor{gnat_rm/implementation_defined_pragmas doc}@anchor{1b}@anchor{gnat_rm/implementation_defined_pragmas id1}@anchor{1c}@anchor{gnat_rm/implementation_defined_pragmas implementation-defined-pragmas}@anchor{7}
@chapter Implementation Defined Pragmas
@end menu
@node Pragma Abort_Defer,Pragma Abstract_State,,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-abort-defer}@anchor{1c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-abort-defer}@anchor{1d}
@section Pragma Abort_Defer
@end example
@node Pragma Abstract_State,Pragma Ada_83,Pragma Abort_Defer,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id2}@anchor{1d}@anchor{gnat_rm/implementation_defined_pragmas pragma-abstract-state}@anchor{1e}
+@anchor{gnat_rm/implementation_defined_pragmas id2}@anchor{1e}@anchor{gnat_rm/implementation_defined_pragmas pragma-abstract-state}@anchor{1f}
@section Pragma Abstract_State
the SPARK 2014 Reference Manual, section 7.1.4.
@node Pragma Ada_83,Pragma Ada_95,Pragma Abstract_State,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-83}@anchor{1f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-83}@anchor{20}
@section Pragma Ada_83
required by Ada 83.
@node Pragma Ada_95,Pragma Ada_05,Pragma Ada_83,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-95}@anchor{20}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-95}@anchor{21}
@section Pragma Ada_95
package body.
@node Pragma Ada_05,Pragma Ada_2005,Pragma Ada_95,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-05}@anchor{21}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-05}@anchor{22}
@section Pragma Ada_05
intended for exclusive use in the GNAT run-time library.
@node Pragma Ada_2005,Pragma Ada_12,Pragma Ada_05,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-2005}@anchor{22}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-2005}@anchor{23}
@section Pragma Ada_2005
same syntax and effect.
@node Pragma Ada_12,Pragma Ada_2012,Pragma Ada_2005,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-12}@anchor{23}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-12}@anchor{24}
@section Pragma Ada_12
intended for exclusive use in the GNAT run-time library.
@node Pragma Ada_2012,Pragma Ada_2022,Pragma Ada_12,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-2012}@anchor{24}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-2012}@anchor{25}
@section Pragma Ada_2012
same syntax and effect.
@node Pragma Ada_2022,Pragma Aggregate_Individually_Assign,Pragma Ada_2012,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-2022}@anchor{25}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ada-2022}@anchor{26}
@section Pragma Ada_2022
intended for exclusive use in the GNAT run-time library.
@node Pragma Aggregate_Individually_Assign,Pragma Allow_Integer_Address,Pragma Ada_2022,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-aggregate-individually-assign}@anchor{26}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-aggregate-individually-assign}@anchor{27}
@section Pragma Aggregate_Individually_Assign
individual assignment statements.
@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}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-allow-integer-address}@anchor{28}
@section Pragma Allow_Integer_Address
in the two situations.
@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}
+@anchor{gnat_rm/implementation_defined_pragmas id3}@anchor{29}@anchor{gnat_rm/implementation_defined_pragmas pragma-always-terminates}@anchor{2a}
@section Pragma Always_Terminates
in the SPARK 2014 Reference Manual, section 6.1.11.
@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}
+@anchor{gnat_rm/implementation_defined_pragmas id4}@anchor{2b}@anchor{gnat_rm/implementation_defined_pragmas pragma-annotate}@anchor{2c}
@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{2c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assert}@anchor{2d}
@section Pragma Assert
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{2d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assert-and-cut}@anchor{2e}
@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{2e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assertion-policy}@anchor{2f}
@section Pragma Assertion_Policy
@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{2f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assume}@anchor{30}
@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{30}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-assume-no-invalid-values}@anchor{31}
@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 id5}@anchor{31}@anchor{gnat_rm/implementation_defined_pragmas pragma-async-readers}@anchor{32}
+@anchor{gnat_rm/implementation_defined_pragmas id5}@anchor{32}@anchor{gnat_rm/implementation_defined_pragmas pragma-async-readers}@anchor{33}
@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 id6}@anchor{33}@anchor{gnat_rm/implementation_defined_pragmas pragma-async-writers}@anchor{34}
+@anchor{gnat_rm/implementation_defined_pragmas id6}@anchor{34}@anchor{gnat_rm/implementation_defined_pragmas pragma-async-writers}@anchor{35}
@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{35}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-attribute-definition}@anchor{36}
@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{36}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-c-pass-by-copy}@anchor{37}
@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{37}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-check}@anchor{38}
@section Pragma Check
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{38}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-check-float-overflow}@anchor{39}
@section Pragma Check_Float_Overflow
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{39}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-check-name}@anchor{3a}
@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{3a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-check-policy}@anchor{3b}
@section Pragma Check_Policy
@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{3b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-comment}@anchor{3c}
@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{3c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-common-object}@anchor{3d}
@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{3d}@anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-error}@anchor{3e}
+@anchor{gnat_rm/implementation_defined_pragmas compile-time-error}@anchor{3e}@anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-error}@anchor{3f}
@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{3f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-compile-time-warning}@anchor{40}
@section Pragma Compile_Time_Warning
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{3d,,Pragma Compile_Time_Error} to force the generation of
+a warning. You can use @ref{3e,,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{40}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-complete-representation}@anchor{41}
@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{41}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-complex-representation}@anchor{42}
@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{42}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-component-alignment}@anchor{43}
@section Pragma Component_Alignment
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 id7}@anchor{43}@anchor{gnat_rm/implementation_defined_pragmas pragma-constant-after-elaboration}@anchor{44}
+@anchor{gnat_rm/implementation_defined_pragmas id7}@anchor{44}@anchor{gnat_rm/implementation_defined_pragmas pragma-constant-after-elaboration}@anchor{45}
@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 id8}@anchor{45}@anchor{gnat_rm/implementation_defined_pragmas pragma-contract-cases}@anchor{46}
+@anchor{gnat_rm/implementation_defined_pragmas id8}@anchor{46}@anchor{gnat_rm/implementation_defined_pragmas pragma-contract-cases}@anchor{47}
@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{47}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-convention-identifier}@anchor{48}
@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{48}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-class}@anchor{49}
@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{49,,Interfacing to C++} for related information.
+See @ref{4a,,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{4a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-constructor}@anchor{4b}
@section Pragma CPP_Constructor
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{49,,Interfacing to C++} for more related information.
+See @ref{4a,,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{4b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-virtual}@anchor{4c}
@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{49,,Interfacing to C++} for related information.
+See @ref{4a,,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{4c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpp-vtable}@anchor{4d}
@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{49,,Interfacing to C++} for related information.
+See @ref{4a,,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{4d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-cpu}@anchor{4e}
@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{4e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-deadline-floor}@anchor{4f}
@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{4f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-debug}@anchor{50}
@section Pragma Debug
@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{50}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-debug-policy}@anchor{51}
@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 id9}@anchor{51}@anchor{gnat_rm/implementation_defined_pragmas pragma-default-initial-condition}@anchor{52}
+@anchor{gnat_rm/implementation_defined_pragmas id9}@anchor{52}@anchor{gnat_rm/implementation_defined_pragmas pragma-default-initial-condition}@anchor{53}
@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{53}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-default-scalar-storage-order}@anchor{54}
@section Pragma Default_Scalar_Storage_Order
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{54}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-default-storage-pool}@anchor{55}
@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 id10}@anchor{55}@anchor{gnat_rm/implementation_defined_pragmas pragma-depends}@anchor{56}
+@anchor{gnat_rm/implementation_defined_pragmas id10}@anchor{56}@anchor{gnat_rm/implementation_defined_pragmas pragma-depends}@anchor{57}
@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{57}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-detect-blocking}@anchor{58}
@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{58}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-disable-atomic-synchronization}@anchor{59}
@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{59}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-dispatching-domain}@anchor{5a}
@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 id11}@anchor{5a}@anchor{gnat_rm/implementation_defined_pragmas pragma-effective-reads}@anchor{5b}
+@anchor{gnat_rm/implementation_defined_pragmas id11}@anchor{5b}@anchor{gnat_rm/implementation_defined_pragmas pragma-effective-reads}@anchor{5c}
@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 id12}@anchor{5c}@anchor{gnat_rm/implementation_defined_pragmas pragma-effective-writes}@anchor{5d}
+@anchor{gnat_rm/implementation_defined_pragmas id12}@anchor{5d}@anchor{gnat_rm/implementation_defined_pragmas pragma-effective-writes}@anchor{5e}
@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{5e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-elaboration-checks}@anchor{5f}
@section Pragma Elaboration_Checks
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{5f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-eliminate}@anchor{60}
@section Pragma Eliminate
@end quotation
@node Pragma Enable_Atomic_Synchronization,Pragma Exceptional_Cases,Pragma Eliminate,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-enable-atomic-synchronization}@anchor{60}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-enable-atomic-synchronization}@anchor{61}
@section Pragma Enable_Atomic_Synchronization
for details.
@node Pragma Exceptional_Cases,Pragma Exit_Cases,Pragma Enable_Atomic_Synchronization,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-exceptional-cases}@anchor{61}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-exceptional-cases}@anchor{62}
@section Pragma Exceptional_Cases
6.1.9.
@node Pragma Exit_Cases,Pragma Export_Function,Pragma Exceptional_Cases,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-exit-cases}@anchor{62}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-exit-cases}@anchor{63}
@section Pragma Exit_Cases
6.1.10.
@node Pragma Export_Function,Pragma Export_Object,Pragma Exit_Cases,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-export-function}@anchor{63}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-export-function}@anchor{64}
@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{64}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-export-object}@anchor{65}
@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{65}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-export-procedure}@anchor{66}
@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{66}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-export-valued-procedure}@anchor{67}
@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{67}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-extend-system}@anchor{68}
@section Pragma Extend_System
GNAT User’s Guide.
@node Pragma Extensions_Allowed,Pragma Extensions_Visible,Pragma Extend_System,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id13}@anchor{68}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-allowed}@anchor{69}
+@anchor{gnat_rm/implementation_defined_pragmas id13}@anchor{69}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-allowed}@anchor{6a}
@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{6a,,here})
+@ref{6b,,here})
An argument of @code{"All_Extensions"} has the same effect except that some extra
experimental extensions are enabled (See the list here
-@ref{6b,,here})
+@ref{6c,,here})
@node Pragma Extensions_Visible,Pragma External,Pragma Extensions_Allowed,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id14}@anchor{6c}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-visible}@anchor{6d}
+@anchor{gnat_rm/implementation_defined_pragmas id14}@anchor{6d}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-visible}@anchor{6e}
@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{6e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-external}@anchor{6f}
@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{6f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-external-name-casing}@anchor{70}
@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{70}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-fast-math}@anchor{71}
@section Pragma Fast_Math
@end table
@node Pragma Favor_Top_Level,Pragma Finalize_Storage_Only,Pragma Fast_Math,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id15}@anchor{71}@anchor{gnat_rm/implementation_defined_pragmas pragma-favor-top-level}@anchor{72}
+@anchor{gnat_rm/implementation_defined_pragmas id15}@anchor{72}@anchor{gnat_rm/implementation_defined_pragmas pragma-favor-top-level}@anchor{73}
@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{73}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-finalize-storage-only}@anchor{74}
@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{74}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-float-representation}@anchor{75}
@section Pragma Float_Representation
@end itemize
@node Pragma Ghost,Pragma Global,Pragma Float_Representation,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id16}@anchor{75}@anchor{gnat_rm/implementation_defined_pragmas pragma-ghost}@anchor{76}
+@anchor{gnat_rm/implementation_defined_pragmas id16}@anchor{76}@anchor{gnat_rm/implementation_defined_pragmas pragma-ghost}@anchor{77}
@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 id17}@anchor{77}@anchor{gnat_rm/implementation_defined_pragmas pragma-global}@anchor{78}
+@anchor{gnat_rm/implementation_defined_pragmas id17}@anchor{78}@anchor{gnat_rm/implementation_defined_pragmas pragma-global}@anchor{79}
@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{79}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ident}@anchor{7a}
@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{7a}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ignore-pragma}@anchor{7b}
@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{7b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-implementation-defined}@anchor{7c}
@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{7c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-implemented}@anchor{7d}
@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{7d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-implicit-packing}@anchor{7e}
@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{7e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-function}@anchor{7f}
@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{7f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-object}@anchor{80}
@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{80}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-procedure}@anchor{81}
@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{81}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-valued-procedure}@anchor{82}
@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{82}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-independent}@anchor{83}
@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{83}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-independent-components}@anchor{84}
@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 id18}@anchor{84}@anchor{gnat_rm/implementation_defined_pragmas pragma-initial-condition}@anchor{85}
+@anchor{gnat_rm/implementation_defined_pragmas id18}@anchor{85}@anchor{gnat_rm/implementation_defined_pragmas pragma-initial-condition}@anchor{86}
@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{86}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-initialize-scalars}@anchor{87}
@section Pragma Initialize_Scalars
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 id19}@anchor{87}@anchor{gnat_rm/implementation_defined_pragmas pragma-initializes}@anchor{88}
+@anchor{gnat_rm/implementation_defined_pragmas id19}@anchor{88}@anchor{gnat_rm/implementation_defined_pragmas pragma-initializes}@anchor{89}
@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 id20}@anchor{89}@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-always}@anchor{8a}
+@anchor{gnat_rm/implementation_defined_pragmas id20}@anchor{8a}@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-always}@anchor{8b}
@section Pragma Inline_Always
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{8b}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-generic}@anchor{8c}
@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{8c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interface}@anchor{8d}
@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{8d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interface-name}@anchor{8e}
@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{8e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-handler}@anchor{8f}
@section Pragma Interrupt_Handler
as described in Annex C of the Ada Reference Manual.
@node Pragma Interrupt_State,Pragma Interrupts_System_By_Default,Pragma Interrupt_Handler,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-state}@anchor{8f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-state}@anchor{90}
@section Pragma Interrupt_State
and in the case of the signal used to implement the @code{abort} statement.
@node Pragma Interrupts_System_By_Default,Pragma Invariant,Pragma Interrupt_State,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupts-system-by-default}@anchor{90}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupts-system-by-default}@anchor{91}
@section Pragma Interrupts_System_By_Default
@code{Interrupt_State}. This is a configuration pragma.
@node Pragma Invariant,Pragma Keep_Names,Pragma Interrupts_System_By_Default,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id21}@anchor{91}@anchor{gnat_rm/implementation_defined_pragmas pragma-invariant}@anchor{92}
+@anchor{gnat_rm/implementation_defined_pragmas id21}@anchor{92}@anchor{gnat_rm/implementation_defined_pragmas pragma-invariant}@anchor{93}
@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{93}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-keep-names}@anchor{94}
@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{94}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-license}@anchor{95}
@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{95}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-link-with}@anchor{96}
@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{96}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-alias}@anchor{97}
@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{97}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-constructor}@anchor{98}
@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{98}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-destructor}@anchor{99}
@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 id22}@anchor{99}@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-section}@anchor{9a}
+@anchor{gnat_rm/implementation_defined_pragmas id22}@anchor{9a}@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-section}@anchor{9b}
@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 id23}@anchor{9b}@anchor{gnat_rm/implementation_defined_pragmas pragma-lock-free}@anchor{9c}
+@anchor{gnat_rm/implementation_defined_pragmas id23}@anchor{9c}@anchor{gnat_rm/implementation_defined_pragmas pragma-lock-free}@anchor{9d}
@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{9d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-invariant}@anchor{9e}
@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{9e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-optimize}@anchor{9f}
@section Pragma Loop_Optimize
vectorization.
@node Pragma Loop_Variant,Pragma Machine_Attribute,Pragma Loop_Optimize,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-variant}@anchor{9f}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-variant}@anchor{a0}
@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{a0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-machine-attribute}@anchor{a1}
@section Pragma Machine_Attribute
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{a1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-main}@anchor{a2}
@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{a2}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-main-storage}@anchor{a3}
@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 id24}@anchor{a3}@anchor{gnat_rm/implementation_defined_pragmas pragma-max-queue-length}@anchor{a4}
+@anchor{gnat_rm/implementation_defined_pragmas id24}@anchor{a4}@anchor{gnat_rm/implementation_defined_pragmas pragma-max-queue-length}@anchor{a5}
@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{a5}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-body}@anchor{a6}
@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 id25}@anchor{a6}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-caching}@anchor{a7}
+@anchor{gnat_rm/implementation_defined_pragmas id25}@anchor{a7}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-caching}@anchor{a8}
@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{a8}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-component-reordering}@anchor{a9}
@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 id26}@anchor{a9}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-elaboration-code-all}@anchor{aa}
+@anchor{gnat_rm/implementation_defined_pragmas id26}@anchor{aa}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-elaboration-code-all}@anchor{ab}
@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{ab}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-heap-finalization}@anchor{ac}
@section Pragma No_Heap_Finalization
appear at the library level.
@node Pragma No_Inline,Pragma No_Raise,Pragma No_Heap_Finalization,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{ac}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-inline}@anchor{ad}
+@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{ad}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-inline}@anchor{ae}
@section Pragma No_Inline
pragma @code{Inline_Always} for the same @code{NAME}.
@node Pragma No_Raise,Pragma No_Return,Pragma No_Inline,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id28}@anchor{ae}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-raise}@anchor{af}
+@anchor{gnat_rm/implementation_defined_pragmas id28}@anchor{af}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-raise}@anchor{b0}
@section Pragma No_Raise
pragma, and @cite{Program_Error} is raised upon its failure (see RM 11.5(19/5)).
@node Pragma No_Return,Pragma No_Strict_Aliasing,Pragma No_Raise,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-no-return}@anchor{b0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-return}@anchor{b1}
@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{b1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-strict-aliasing}@anchor{b2}
@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 id29}@anchor{b2}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{b3}
+@anchor{gnat_rm/implementation_defined_pragmas id29}@anchor{b3}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{b4}
@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{b4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-normalize-scalars}@anchor{b5}
@section Pragma Normalize_Scalars
@end table
@node Pragma Obsolescent,Pragma Optimize_Alignment,Pragma Normalize_Scalars,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{b5}@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{b6}
+@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{b6}@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{b7}
@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{b7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-optimize-alignment}@anchor{b8}
@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{b8}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ordered}@anchor{b9}
@section Pragma Ordered
`-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{b9}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-overflow-mode}@anchor{ba}
@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{ba}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-overriding-renamings}@anchor{bb}
@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 id31}@anchor{bb}@anchor{gnat_rm/implementation_defined_pragmas pragma-part-of}@anchor{bc}
+@anchor{gnat_rm/implementation_defined_pragmas id31}@anchor{bc}@anchor{gnat_rm/implementation_defined_pragmas pragma-part-of}@anchor{bd}
@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{bd}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-partition-elaboration-policy}@anchor{be}
@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{be}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-passive}@anchor{bf}
@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 id32}@anchor{bf}@anchor{gnat_rm/implementation_defined_pragmas pragma-persistent-bss}@anchor{c0}
+@anchor{gnat_rm/implementation_defined_pragmas id32}@anchor{c0}@anchor{gnat_rm/implementation_defined_pragmas pragma-persistent-bss}@anchor{c1}
@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{c1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-post}@anchor{c2}
@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{c2}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-postcondition}@anchor{c3}
@section Pragma Postcondition
compatibility purposes.
@node Pragma Post_Class,Pragma Pre,Pragma Postcondition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-post-class}@anchor{c3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-post-class}@anchor{c4}
@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{c4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-pre}@anchor{c5}
@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{c5}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-precondition}@anchor{c6}
@section Pragma Precondition
compatibility purposes.
@node Pragma Predicate,Pragma Predicate_Failure,Pragma Precondition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id33}@anchor{c6}@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{c7}
+@anchor{gnat_rm/implementation_defined_pragmas id33}@anchor{c7}@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{c8}
@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{c8}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate-failure}@anchor{c9}
@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{c9}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-preelaborable-initialization}@anchor{ca}
@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{ca}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-prefix-exception-messages}@anchor{cb}
@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{cb}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-pre-class}@anchor{cc}
@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{cc}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-priority-specific-dispatching}@anchor{cd}
@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{cd}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-profile}@anchor{ce}
@section Pragma Profile
@end itemize
@node Pragma Profile_Warnings,Pragma Program_Exit,Pragma Profile,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-profile-warnings}@anchor{ce}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-profile-warnings}@anchor{cf}
@section Pragma Profile_Warnings
of error messages.
@node Pragma Program_Exit,Pragma Propagate_Exceptions,Pragma Profile_Warnings,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id34}@anchor{cf}@anchor{gnat_rm/implementation_defined_pragmas pragma-program-exit}@anchor{d0}
+@anchor{gnat_rm/implementation_defined_pragmas id34}@anchor{d0}@anchor{gnat_rm/implementation_defined_pragmas pragma-program-exit}@anchor{d1}
@section Pragma Program_Exit
in the SPARK 2014 Reference Manual, section 6.1.10.
@node Pragma Propagate_Exceptions,Pragma Provide_Shift_Operators,Pragma Program_Exit,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-propagate-exceptions}@anchor{d1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-propagate-exceptions}@anchor{d2}
@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{d2}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-provide-shift-operators}@anchor{d3}
@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{d3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-psect-object}@anchor{d4}
@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 id35}@anchor{d4}@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{d5}
+@anchor{gnat_rm/implementation_defined_pragmas id35}@anchor{d5}@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{d6}
@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{d6}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-rational}@anchor{d7}
@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{d7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ravenscar}@anchor{d8}
@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 id36}@anchor{d8}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{d9}
+@anchor{gnat_rm/implementation_defined_pragmas id36}@anchor{d9}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{da}
@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 id37}@anchor{da}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{db}
+@anchor{gnat_rm/implementation_defined_pragmas id37}@anchor{db}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{dc}
@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 id38}@anchor{dc}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{dd}
+@anchor{gnat_rm/implementation_defined_pragmas id38}@anchor{dd}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{de}
@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 id39}@anchor{de}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{df}
+@anchor{gnat_rm/implementation_defined_pragmas id39}@anchor{df}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{e0}
@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{e0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-relative-deadline}@anchor{e1}
@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 id40}@anchor{e1}@anchor{gnat_rm/implementation_defined_pragmas pragma-remote-access-type}@anchor{e2}
+@anchor{gnat_rm/implementation_defined_pragmas id40}@anchor{e2}@anchor{gnat_rm/implementation_defined_pragmas pragma-remote-access-type}@anchor{e3}
@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{e3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-rename-pragma}@anchor{e4}
@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{e4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-restricted-run-time}@anchor{e5}
@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{e5}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-restriction-warnings}@anchor{e6}
@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{e6}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-reviewable}@anchor{e7}
@section Pragma Reviewable
information.
@node Pragma Secondary_Stack_Size,Pragma Share_Generic,Pragma Reviewable,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id41}@anchor{e7}@anchor{gnat_rm/implementation_defined_pragmas pragma-secondary-stack-size}@anchor{e8}
+@anchor{gnat_rm/implementation_defined_pragmas id41}@anchor{e8}@anchor{gnat_rm/implementation_defined_pragmas pragma-secondary-stack-size}@anchor{e9}
@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{e9}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-share-generic}@anchor{ea}
@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 id42}@anchor{ea}@anchor{gnat_rm/implementation_defined_pragmas pragma-shared}@anchor{eb}
+@anchor{gnat_rm/implementation_defined_pragmas id42}@anchor{eb}@anchor{gnat_rm/implementation_defined_pragmas pragma-shared}@anchor{ec}
@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{ec}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-short-circuit-and-or}@anchor{ed}
@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{ed}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-short-descriptors}@anchor{ee}
@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 id43}@anchor{ee}@anchor{gnat_rm/implementation_defined_pragmas pragma-side-effects}@anchor{ef}
+@anchor{gnat_rm/implementation_defined_pragmas id43}@anchor{ef}@anchor{gnat_rm/implementation_defined_pragmas pragma-side-effects}@anchor{f0}
@section Pragma Side_Effects
@code{Side_Effects} in the SPARK Reference Manual, section 6.1.12.
@node Pragma Simple_Storage_Pool_Type,Pragma Source_File_Name,Pragma Side_Effects,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id44}@anchor{f0}@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{f1}
+@anchor{gnat_rm/implementation_defined_pragmas id44}@anchor{f1}@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{f2}
@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{f2,,Simple_Storage_Pool}. For example:
+@ref{f3,,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{f2,,Simple_Storage_Pool}
+See attribute @ref{f3,,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 id45}@anchor{f3}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{f4}
+@anchor{gnat_rm/implementation_defined_pragmas id45}@anchor{f4}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{f5}
@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{f5,,Pragma Source_File_Name_Project}.
+Source_File_Name cannot appear after a @ref{f6,,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 id46}@anchor{f6}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{f5}
+@anchor{gnat_rm/implementation_defined_pragmas id46}@anchor{f7}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{f6}
@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{f4,,Pragma Source_File_Name}, and
+It cannot appear after a @ref{f5,,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{f7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-source-reference}@anchor{f8}
@section Pragma Source_Reference
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 id47}@anchor{f8}@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{f9}
+@anchor{gnat_rm/implementation_defined_pragmas id47}@anchor{f9}@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{fa}
@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{fa}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-static-elaboration-desired}@anchor{fb}
@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{fb}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-stream-convert}@anchor{fc}
@section Pragma Stream_Convert
attributes is used instead.
@node Pragma Style_Checks,Pragma Subprogram_Variant,Pragma Stream_Convert,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-style-checks}@anchor{fc}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-style-checks}@anchor{fd}
@section Pragma Style_Checks
@end example
@node Pragma Subprogram_Variant,Pragma Subtitle,Pragma Style_Checks,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-subprogram-variant}@anchor{fd}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-subprogram-variant}@anchor{fe}
@section Pragma Subprogram_Variant
restrictions and semantics.
@node Pragma Subtitle,Pragma Suppress,Pragma Subprogram_Variant,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-subtitle}@anchor{fe}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-subtitle}@anchor{ff}
@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{ff}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress}@anchor{100}
@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{100}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-all}@anchor{101}
@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 id48}@anchor{101}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{102}
+@anchor{gnat_rm/implementation_defined_pragmas id48}@anchor{102}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{103}
@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{103}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-exception-locations}@anchor{104}
@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 id49}@anchor{104}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-initialization}@anchor{105}
+@anchor{gnat_rm/implementation_defined_pragmas id49}@anchor{105}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-initialization}@anchor{106}
@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{106}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-task-name}@anchor{107}
@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{107}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-task-storage}@anchor{108}
@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 id50}@anchor{108}@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{109}
+@anchor{gnat_rm/implementation_defined_pragmas id50}@anchor{109}@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{10a}
@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 id51}@anchor{10a}@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{10b}
+@anchor{gnat_rm/implementation_defined_pragmas id51}@anchor{10b}@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{10c}
@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{10c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-time-slice}@anchor{10d}
@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{10d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-title}@anchor{10e}
@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{10e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant}@anchor{10f}
@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 id52}@anchor{10f}@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant-class}@anchor{110}
+@anchor{gnat_rm/implementation_defined_pragmas id52}@anchor{110}@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant-class}@anchor{111}
@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{111}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unchecked-union}@anchor{112}
@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{112}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unevaluated-use-of-old}@anchor{113}
@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{113}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-user-aspect-definition}@anchor{114}
@section Pragma User_Aspect_Definition
then the 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{114}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unimplemented-unit}@anchor{115}
@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 id53}@anchor{115}@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{116}
+@anchor{gnat_rm/implementation_defined_pragmas id53}@anchor{116}@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{117}
@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 id54}@anchor{117}@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{118}
+@anchor{gnat_rm/implementation_defined_pragmas id54}@anchor{118}@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{119}
@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 id55}@anchor{119}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{11a}
+@anchor{gnat_rm/implementation_defined_pragmas id55}@anchor{11a}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{11b}
@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{b6,,Pragma Obsolescent}.
+for this purpose, see @ref{b7,,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 id56}@anchor{11b}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{11c}
+@anchor{gnat_rm/implementation_defined_pragmas id56}@anchor{11c}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{11d}
@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{11d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unreserve-all-interrupts}@anchor{11e}
@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{11e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unsuppress}@anchor{11f}
@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 id57}@anchor{11f}@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{120}
+@anchor{gnat_rm/implementation_defined_pragmas id57}@anchor{120}@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{121}
@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{121}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-use-vads-size}@anchor{122}
@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{122}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-validity-checks}@anchor{123}
@section Pragma Validity_Checks
@end example
@node Pragma Volatile,Pragma Volatile_Full_Access,Pragma Validity_Checks,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id58}@anchor{123}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{124}
+@anchor{gnat_rm/implementation_defined_pragmas id58}@anchor{124}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{125}
@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 id59}@anchor{125}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-full-access}@anchor{126}
+@anchor{gnat_rm/implementation_defined_pragmas id59}@anchor{126}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-full-access}@anchor{127}
@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 id60}@anchor{127}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-function}@anchor{128}
+@anchor{gnat_rm/implementation_defined_pragmas id60}@anchor{128}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-function}@anchor{129}
@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{129}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-warning-as-error}@anchor{12a}
@section 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{12a,,Pragma Warnings}.
+warnings provided by the back end and mentioned in @ref{12b,,Pragma Warnings}.
By using a single full `-Wxxx' switch in the pragma, such warnings
can also be treated as errors.
“[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 id61}@anchor{12b}@anchor{gnat_rm/implementation_defined_pragmas pragma-warnings}@anchor{12a}
+@anchor{gnat_rm/implementation_defined_pragmas id61}@anchor{12c}@anchor{gnat_rm/implementation_defined_pragmas pragma-warnings}@anchor{12b}
@section Pragma Warnings
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{12c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-weak-external}@anchor{12d}
@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{12d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-wide-character-encoding}@anchor{12e}
@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{12e}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{12f}@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{130}
+@anchor{gnat_rm/implementation_defined_aspects doc}@anchor{12f}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{130}@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{131}
@chapter Implementation Defined Aspects
@end menu
@node Aspect Abstract_State,Aspect Always_Terminates,,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-abstract-state}@anchor{131}
+@anchor{gnat_rm/implementation_defined_aspects aspect-abstract-state}@anchor{132}
@section Aspect Abstract_State
@geindex Abstract_State
-This aspect is equivalent to @ref{1e,,pragma Abstract_State}.
+This aspect is equivalent to @ref{1f,,pragma Abstract_State}.
@node Aspect Always_Terminates,Aspect Annotate,Aspect Abstract_State,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-always-terminates}@anchor{132}
+@anchor{gnat_rm/implementation_defined_aspects aspect-always-terminates}@anchor{133}
@section Aspect Always_Terminates
@geindex Always_Terminates
-This boolean aspect is equivalent to @ref{29,,pragma Always_Terminates}.
+This boolean aspect is equivalent to @ref{2a,,pragma Always_Terminates}.
@node Aspect Annotate,Aspect Async_Readers,Aspect Always_Terminates,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-annotate}@anchor{133}
+@anchor{gnat_rm/implementation_defined_aspects aspect-annotate}@anchor{134}
@section Aspect Annotate
There are three forms of this aspect (where ID is an identifier,
and ARG is a general expression),
-corresponding to @ref{2b,,pragma Annotate}.
+corresponding to @ref{2c,,pragma Annotate}.
@table @asis
@end table
@node Aspect Async_Readers,Aspect Async_Writers,Aspect Annotate,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-async-readers}@anchor{134}
+@anchor{gnat_rm/implementation_defined_aspects aspect-async-readers}@anchor{135}
@section Aspect Async_Readers
@geindex Async_Readers
-This boolean aspect is equivalent to @ref{32,,pragma Async_Readers}.
+This boolean aspect is equivalent to @ref{33,,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{135}
+@anchor{gnat_rm/implementation_defined_aspects aspect-async-writers}@anchor{136}
@section Aspect Async_Writers
@geindex Async_Writers
-This boolean aspect is equivalent to @ref{34,,pragma Async_Writers}.
+This boolean aspect is equivalent to @ref{35,,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{136}
+@anchor{gnat_rm/implementation_defined_aspects aspect-constant-after-elaboration}@anchor{137}
@section Aspect Constant_After_Elaboration
@geindex Constant_After_Elaboration
-This aspect is equivalent to @ref{44,,pragma Constant_After_Elaboration}.
+This aspect is equivalent to @ref{45,,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{137}
+@anchor{gnat_rm/implementation_defined_aspects aspect-contract-cases}@anchor{138}
@section Aspect Contract_Cases
@geindex Contract_Cases
-This aspect is equivalent to @ref{46,,pragma Contract_Cases}, the sequence
+This aspect is equivalent to @ref{47,,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{138}
+@anchor{gnat_rm/implementation_defined_aspects aspect-depends}@anchor{139}
@section Aspect Depends
@geindex Depends
-This aspect is equivalent to @ref{56,,pragma Depends}.
+This aspect is equivalent to @ref{57,,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{139}
+@anchor{gnat_rm/implementation_defined_aspects aspect-default-initial-condition}@anchor{13a}
@section Aspect Default_Initial_Condition
@geindex Default_Initial_Condition
-This aspect is equivalent to @ref{52,,pragma Default_Initial_Condition}.
+This aspect is equivalent to @ref{53,,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{13a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-dimension}@anchor{13b}
@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{13b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-dimension-system}@anchor{13c}
@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{13c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-disable-controlled}@anchor{13d}
@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{13d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-effective-reads}@anchor{13e}
@section Aspect Effective_Reads
@geindex Effective_Reads
-This aspect is equivalent to @ref{5b,,pragma Effective_Reads}.
+This aspect is equivalent to @ref{5c,,pragma Effective_Reads}.
@node Aspect Effective_Writes,Aspect Exceptional_Cases,Aspect Effective_Reads,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-effective-writes}@anchor{13e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-effective-writes}@anchor{13f}
@section Aspect Effective_Writes
@geindex Effective_Writes
-This aspect is equivalent to @ref{5d,,pragma Effective_Writes}.
+This aspect is equivalent to @ref{5e,,pragma Effective_Writes}.
@node Aspect Exceptional_Cases,Aspect Exit_Cases,Aspect Effective_Writes,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-exceptional-cases}@anchor{13f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-exceptional-cases}@anchor{140}
@section Aspect Exceptional_Cases
Manual, section 6.1.9.
@node Aspect Exit_Cases,Aspect Extensions_Visible,Aspect Exceptional_Cases,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-exit-cases}@anchor{140}
+@anchor{gnat_rm/implementation_defined_aspects aspect-exit-cases}@anchor{141}
@section Aspect Exit_Cases
Manual, section 6.1.10.
@node Aspect Extensions_Visible,Aspect Favor_Top_Level,Aspect Exit_Cases,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-extensions-visible}@anchor{141}
+@anchor{gnat_rm/implementation_defined_aspects aspect-extensions-visible}@anchor{142}
@section Aspect Extensions_Visible
@geindex Extensions_Visible
-This aspect is equivalent to @ref{6d,,pragma Extensions_Visible}.
+This aspect is equivalent to @ref{6e,,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{142}
+@anchor{gnat_rm/implementation_defined_aspects aspect-favor-top-level}@anchor{143}
@section Aspect Favor_Top_Level
@geindex Favor_Top_Level
-This boolean aspect is equivalent to @ref{72,,pragma Favor_Top_Level}.
+This boolean aspect is equivalent to @ref{73,,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{143}
+@anchor{gnat_rm/implementation_defined_aspects aspect-ghost}@anchor{144}
@section Aspect Ghost
@geindex Ghost
-This aspect is equivalent to @ref{76,,pragma Ghost}.
+This aspect is equivalent to @ref{77,,pragma Ghost}.
@node Aspect Ghost_Predicate,Aspect Global,Aspect Ghost,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-ghost-predicate}@anchor{144}
+@anchor{gnat_rm/implementation_defined_aspects aspect-ghost-predicate}@anchor{145}
@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{145}
+@anchor{gnat_rm/implementation_defined_aspects aspect-global}@anchor{146}
@section Aspect Global
@geindex Global
-This aspect is equivalent to @ref{78,,pragma Global}.
+This aspect is equivalent to @ref{79,,pragma Global}.
@node Aspect Initial_Condition,Aspect Initializes,Aspect Global,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-initial-condition}@anchor{146}
+@anchor{gnat_rm/implementation_defined_aspects aspect-initial-condition}@anchor{147}
@section Aspect Initial_Condition
@geindex Initial_Condition
-This aspect is equivalent to @ref{85,,pragma Initial_Condition}.
+This aspect is equivalent to @ref{86,,pragma Initial_Condition}.
@node Aspect Initializes,Aspect Inline_Always,Aspect Initial_Condition,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-initializes}@anchor{147}
+@anchor{gnat_rm/implementation_defined_aspects aspect-initializes}@anchor{148}
@section Aspect Initializes
@geindex Initializes
-This aspect is equivalent to @ref{88,,pragma Initializes}.
+This aspect is equivalent to @ref{89,,pragma Initializes}.
@node Aspect Inline_Always,Aspect Invariant,Aspect Initializes,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-inline-always}@anchor{148}
+@anchor{gnat_rm/implementation_defined_aspects aspect-inline-always}@anchor{149}
@section Aspect Inline_Always
@geindex Inline_Always
-This boolean aspect is equivalent to @ref{8a,,pragma Inline_Always}.
+This boolean aspect is equivalent to @ref{8b,,pragma Inline_Always}.
@node Aspect Invariant,Aspect Invariant’Class,Aspect Inline_Always,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-invariant}@anchor{149}
+@anchor{gnat_rm/implementation_defined_aspects aspect-invariant}@anchor{14a}
@section Aspect Invariant
@geindex Invariant
-This aspect is equivalent to @ref{92,,pragma Invariant}. It is a
+This aspect is equivalent to @ref{93,,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{14a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-invariant-class}@anchor{14b}
@section Aspect Invariant’Class
@geindex Invariant'Class
-This aspect is equivalent to @ref{110,,pragma Type_Invariant_Class}. It is a
+This aspect is equivalent to @ref{111,,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{14b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-iterable}@anchor{14c}
@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{14c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-linker-section}@anchor{14d}
@section Aspect Linker_Section
@geindex Linker_Section
-This aspect is equivalent to @ref{9a,,pragma Linker_Section}.
+This aspect is equivalent to @ref{9b,,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{14d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-local-restrictions}@anchor{14e}
@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{14e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-lock-free}@anchor{14f}
@section Aspect Lock_Free
@geindex Lock_Free
-This boolean aspect is equivalent to @ref{9c,,pragma Lock_Free}.
+This boolean aspect is equivalent to @ref{9d,,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{14f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-max-queue-length}@anchor{150}
@section Aspect Max_Queue_Length
@geindex Max_Queue_Length
-This aspect is equivalent to @ref{a4,,pragma Max_Queue_Length}.
+This aspect is equivalent to @ref{a5,,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{150}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-caching}@anchor{151}
@section Aspect No_Caching
@geindex No_Caching
-This boolean aspect is equivalent to @ref{a7,,pragma No_Caching}.
+This boolean aspect is equivalent to @ref{a8,,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{151}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-elaboration-code-all}@anchor{152}
@section Aspect No_Elaboration_Code_All
@geindex No_Elaboration_Code_All
-This aspect is equivalent to @ref{aa,,pragma No_Elaboration_Code_All}
+This aspect is equivalent to @ref{ab,,pragma No_Elaboration_Code_All}
for a program unit.
@node Aspect No_Inline,Aspect No_Raise,Aspect No_Elaboration_Code_All,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-inline}@anchor{152}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-inline}@anchor{153}
@section Aspect No_Inline
@geindex No_Inline
-This boolean aspect is equivalent to @ref{ad,,pragma No_Inline}.
+This boolean aspect is equivalent to @ref{ae,,pragma No_Inline}.
@node Aspect No_Raise,Aspect No_Tagged_Streams,Aspect No_Inline,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-raise}@anchor{153}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-raise}@anchor{154}
@section Aspect No_Raise
@geindex No_Raise
-This boolean aspect is equivalent to @ref{af,,pragma No_Raise}.
+This boolean aspect is equivalent to @ref{b0,,pragma No_Raise}.
@node Aspect No_Tagged_Streams,Aspect No_Task_Parts,Aspect No_Raise,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-tagged-streams}@anchor{154}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-tagged-streams}@anchor{155}
@section Aspect No_Tagged_Streams
@geindex No_Tagged_Streams
-This aspect is equivalent to @ref{b3,,pragma No_Tagged_Streams} with an
+This aspect is equivalent to @ref{b4,,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{155}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-task-parts}@anchor{156}
@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{156}
+@anchor{gnat_rm/implementation_defined_aspects aspect-object-size}@anchor{157}
@section Aspect Object_Size
@geindex Object_Size
-This aspect is equivalent to @ref{157,,attribute Object_Size}.
+This aspect is equivalent to @ref{158,,attribute Object_Size}.
@node Aspect Obsolescent,Aspect Part_Of,Aspect Object_Size,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-obsolescent}@anchor{158}
+@anchor{gnat_rm/implementation_defined_aspects aspect-obsolescent}@anchor{159}
@section Aspect Obsolescent
@geindex Obsolescent
-This aspect is equivalent to @ref{b6,,pragma Obsolescent}. Note that the
+This aspect is equivalent to @ref{b7,,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{159}
+@anchor{gnat_rm/implementation_defined_aspects aspect-part-of}@anchor{15a}
@section Aspect Part_Of
@geindex Part_Of
-This aspect is equivalent to @ref{bc,,pragma Part_Of}.
+This aspect is equivalent to @ref{bd,,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{15a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-persistent-bss}@anchor{15b}
@section Aspect Persistent_BSS
@geindex Persistent_BSS
-This boolean aspect is equivalent to @ref{c0,,pragma Persistent_BSS}.
+This boolean aspect is equivalent to @ref{c1,,pragma Persistent_BSS}.
@node Aspect Predicate,Aspect Program_Exit,Aspect Persistent_BSS,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-predicate}@anchor{15b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-predicate}@anchor{15c}
@section Aspect Predicate
@geindex Predicate
-This aspect is equivalent to @ref{c7,,pragma Predicate}. It is thus
+This aspect is equivalent to @ref{c8,,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 Program_Exit,Aspect Pure_Function,Aspect Predicate,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-program-exit}@anchor{15c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-program-exit}@anchor{15d}
@section Aspect Program_Exit
@geindex Program_Exit
-This boolean aspect is equivalent to @ref{d0,,pragma Program_Exit}.
+This boolean aspect is equivalent to @ref{d1,,pragma Program_Exit}.
@node Aspect Pure_Function,Aspect Refined_Depends,Aspect Program_Exit,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-pure-function}@anchor{15d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-pure-function}@anchor{15e}
@section Aspect Pure_Function
@geindex Pure_Function
-This boolean aspect is equivalent to @ref{d5,,pragma Pure_Function}.
+This boolean aspect is equivalent to @ref{d6,,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{15e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-depends}@anchor{15f}
@section Aspect Refined_Depends
@geindex Refined_Depends
-This aspect is equivalent to @ref{d9,,pragma Refined_Depends}.
+This aspect is equivalent to @ref{da,,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{15f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-global}@anchor{160}
@section Aspect Refined_Global
@geindex Refined_Global
-This aspect is equivalent to @ref{db,,pragma Refined_Global}.
+This aspect is equivalent to @ref{dc,,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{160}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-post}@anchor{161}
@section Aspect Refined_Post
@geindex Refined_Post
-This aspect is equivalent to @ref{dd,,pragma Refined_Post}.
+This aspect is equivalent to @ref{de,,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{161}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-state}@anchor{162}
@section Aspect Refined_State
@geindex Refined_State
-This aspect is equivalent to @ref{df,,pragma Refined_State}.
+This aspect is equivalent to @ref{e0,,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{162}
+@anchor{gnat_rm/implementation_defined_aspects aspect-relaxed-initialization}@anchor{163}
@section Aspect Relaxed_Initialization
Manual, section 6.10.
@node Aspect Remote_Access_Type,Aspect Scalar_Storage_Order,Aspect Relaxed_Initialization,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-remote-access-type}@anchor{163}
+@anchor{gnat_rm/implementation_defined_aspects aspect-remote-access-type}@anchor{164}
@section Aspect Remote_Access_Type
@geindex Remote_Access_Type
-This aspect is equivalent to @ref{e2,,pragma Remote_Access_Type}.
+This aspect is equivalent to @ref{e3,,pragma Remote_Access_Type}.
@node Aspect Scalar_Storage_Order,Aspect Secondary_Stack_Size,Aspect Remote_Access_Type,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-scalar-storage-order}@anchor{164}
+@anchor{gnat_rm/implementation_defined_aspects aspect-scalar-storage-order}@anchor{165}
@section Aspect Scalar_Storage_Order
@geindex Scalar_Storage_Order
-This aspect is equivalent to a @ref{165,,attribute Scalar_Storage_Order}.
+This aspect is equivalent to a @ref{166,,attribute Scalar_Storage_Order}.
@node Aspect Secondary_Stack_Size,Aspect Shared,Aspect Scalar_Storage_Order,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-secondary-stack-size}@anchor{166}
+@anchor{gnat_rm/implementation_defined_aspects aspect-secondary-stack-size}@anchor{167}
@section Aspect Secondary_Stack_Size
@geindex Secondary_Stack_Size
-This aspect is equivalent to @ref{e8,,pragma Secondary_Stack_Size}.
+This aspect is equivalent to @ref{e9,,pragma Secondary_Stack_Size}.
@node Aspect Shared,Aspect Side_Effects,Aspect Secondary_Stack_Size,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-shared}@anchor{167}
+@anchor{gnat_rm/implementation_defined_aspects aspect-shared}@anchor{168}
@section Aspect Shared
@geindex Shared
-This boolean aspect is equivalent to @ref{eb,,pragma Shared}
+This boolean aspect is equivalent to @ref{ec,,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{168}
+@anchor{gnat_rm/implementation_defined_aspects aspect-side-effects}@anchor{169}
@section Aspect Side_Effects
@geindex Side_Effects
-This aspect is equivalent to @ref{ef,,pragma Side_Effects}.
+This aspect is equivalent to @ref{f0,,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{169}
+@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool}@anchor{16a}
@section Aspect Simple_Storage_Pool
@geindex Simple_Storage_Pool
-This aspect is equivalent to @ref{f2,,attribute Simple_Storage_Pool}.
+This aspect is equivalent to @ref{f3,,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{16a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool-type}@anchor{16b}
@section Aspect Simple_Storage_Pool_Type
@geindex Simple_Storage_Pool_Type
-This boolean aspect is equivalent to @ref{f1,,pragma Simple_Storage_Pool_Type}.
+This boolean aspect is equivalent to @ref{f2,,pragma Simple_Storage_Pool_Type}.
@node Aspect SPARK_Mode,Aspect Subprogram_Variant,Aspect Simple_Storage_Pool_Type,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-spark-mode}@anchor{16b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-spark-mode}@anchor{16c}
@section Aspect SPARK_Mode
@geindex SPARK_Mode
-This aspect is equivalent to @ref{f9,,pragma SPARK_Mode} and
+This aspect is equivalent to @ref{fa,,pragma SPARK_Mode} and
may be specified for either or both of the specification and body
of a subprogram or package.
@node Aspect Subprogram_Variant,Aspect Suppress_Debug_Info,Aspect SPARK_Mode,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-subprogram-variant}@anchor{16c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-subprogram-variant}@anchor{16d}
@section Aspect Subprogram_Variant
Manual, section 6.1.8.
@node Aspect Suppress_Debug_Info,Aspect Suppress_Initialization,Aspect Subprogram_Variant,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-debug-info}@anchor{16d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-debug-info}@anchor{16e}
@section Aspect Suppress_Debug_Info
@geindex Suppress_Debug_Info
-This boolean aspect is equivalent to @ref{102,,pragma Suppress_Debug_Info}.
+This boolean aspect is equivalent to @ref{103,,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{16e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-initialization}@anchor{16f}
@section Aspect Suppress_Initialization
@geindex Suppress_Initialization
-This boolean aspect is equivalent to @ref{105,,pragma Suppress_Initialization}.
+This boolean aspect is equivalent to @ref{106,,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{16f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-test-case}@anchor{170}
@section Aspect Test_Case
@geindex Test_Case
-This aspect is equivalent to @ref{109,,pragma Test_Case}.
+This aspect is equivalent to @ref{10a,,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{170}
+@anchor{gnat_rm/implementation_defined_aspects aspect-thread-local-storage}@anchor{171}
@section Aspect Thread_Local_Storage
@geindex Thread_Local_Storage
-This boolean aspect is equivalent to @ref{10b,,pragma Thread_Local_Storage}.
+This boolean aspect is equivalent to @ref{10c,,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{171}
+@anchor{gnat_rm/implementation_defined_aspects aspect-universal-aliasing}@anchor{172}
@section Aspect Universal_Aliasing
@geindex Universal_Aliasing
-This boolean aspect is equivalent to @ref{116,,pragma Universal_Aliasing}.
+This boolean aspect is equivalent to @ref{117,,pragma Universal_Aliasing}.
@node Aspect Unmodified,Aspect Unreferenced,Aspect Universal_Aliasing,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-unmodified}@anchor{172}
+@anchor{gnat_rm/implementation_defined_aspects aspect-unmodified}@anchor{173}
@section Aspect Unmodified
@geindex Unmodified
-This boolean aspect is equivalent to @ref{118,,pragma Unmodified}.
+This boolean aspect is equivalent to @ref{119,,pragma Unmodified}.
@node Aspect Unreferenced,Aspect Unreferenced_Objects,Aspect Unmodified,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced}@anchor{173}
+@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced}@anchor{174}
@section Aspect Unreferenced
@geindex Unreferenced
-This boolean aspect is equivalent to @ref{11a,,pragma Unreferenced}.
+This boolean aspect is equivalent to @ref{11b,,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{174}
+@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced-objects}@anchor{175}
@section Aspect Unreferenced_Objects
@geindex Unreferenced_Objects
-This boolean aspect is equivalent to @ref{11c,,pragma Unreferenced_Objects}.
+This boolean aspect is equivalent to @ref{11d,,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{175}
+@anchor{gnat_rm/implementation_defined_aspects aspect-user-aspect}@anchor{176}
@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{176}
+@anchor{gnat_rm/implementation_defined_aspects aspect-value-size}@anchor{177}
@section Aspect Value_Size
@geindex Value_Size
-This aspect is equivalent to @ref{177,,attribute Value_Size}.
+This aspect is equivalent to @ref{178,,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{178}
+@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-full-access}@anchor{179}
@section Aspect Volatile_Full_Access
@geindex Volatile_Full_Access
-This boolean aspect is equivalent to @ref{126,,pragma Volatile_Full_Access}.
+This boolean aspect is equivalent to @ref{127,,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{179}
+@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-function}@anchor{17a}
@section Aspect Volatile_Function
@geindex Volatile_Function
-This boolean aspect is equivalent to @ref{128,,pragma Volatile_Function}.
+This boolean aspect is equivalent to @ref{129,,pragma Volatile_Function}.
@node Aspect Warnings,,Aspect Volatile_Function,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-warnings}@anchor{17a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-warnings}@anchor{17b}
@section Aspect Warnings
@geindex Warnings
-This aspect is equivalent to the two argument form of @ref{12a,,pragma Warnings},
+This aspect is equivalent to the two argument form of @ref{12b,,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{17b}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{17c}@anchor{gnat_rm/implementation_defined_attributes implementation-defined-attributes}@anchor{8}
+@anchor{gnat_rm/implementation_defined_attributes doc}@anchor{17c}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{17d}@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{17d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-abort-signal}@anchor{17e}
@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{17e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-address-size}@anchor{17f}
@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{17f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-asm-input}@anchor{180}
@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{180,,Machine Code Insertions}
+@ref{181,,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{181}
+@anchor{gnat_rm/implementation_defined_attributes attribute-asm-output}@anchor{182}
@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{180,,Machine Code Insertions}
+@ref{181,,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{182}
+@anchor{gnat_rm/implementation_defined_attributes attribute-atomic-always-lock-free}@anchor{183}
@section Attribute Atomic_Always_Lock_Free
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{183}
+@anchor{gnat_rm/implementation_defined_attributes attribute-bit}@anchor{184}
@section Attribute Bit
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{184}
+@anchor{gnat_rm/implementation_defined_attributes attribute-bit-position}@anchor{185}
@section Attribute Bit_Position
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{185}
+@anchor{gnat_rm/implementation_defined_attributes attribute-code-address}@anchor{186}
@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{186}
+@anchor{gnat_rm/implementation_defined_attributes attribute-compiler-version}@anchor{187}
@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{187}
+@anchor{gnat_rm/implementation_defined_attributes attribute-constrained}@anchor{188}
@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{188}
+@anchor{gnat_rm/implementation_defined_attributes attribute-default-bit-order}@anchor{189}
@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{189}
+@anchor{gnat_rm/implementation_defined_attributes attribute-default-scalar-storage-order}@anchor{18a}
@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{18a}
+@anchor{gnat_rm/implementation_defined_attributes attribute-deref}@anchor{18b}
@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{18b}
+@anchor{gnat_rm/implementation_defined_attributes attribute-descriptor-size}@anchor{18c}
@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{18c}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elaborated}@anchor{18d}
@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{18d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elab-body}@anchor{18e}
@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{18e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elab-spec}@anchor{18f}
@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{18f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elab-subp-body}@anchor{190}
@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{190}
+@anchor{gnat_rm/implementation_defined_attributes attribute-emax}@anchor{191}
@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{191}
+@anchor{gnat_rm/implementation_defined_attributes attribute-enabled}@anchor{192}
@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{192}
+@anchor{gnat_rm/implementation_defined_attributes attribute-enum-rep}@anchor{193}
@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{193}
+@anchor{gnat_rm/implementation_defined_attributes attribute-enum-val}@anchor{194}
@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{194}
+@anchor{gnat_rm/implementation_defined_attributes attribute-epsilon}@anchor{195}
@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{195}
+@anchor{gnat_rm/implementation_defined_attributes attribute-fast-math}@anchor{196}
@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{196}
+@anchor{gnat_rm/implementation_defined_attributes attribute-finalization-size}@anchor{197}
@section Attribute Finalization_Size
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{197}
+@anchor{gnat_rm/implementation_defined_attributes attribute-fixed-value}@anchor{198}
@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{198}
+@anchor{gnat_rm/implementation_defined_attributes attribute-from-any}@anchor{199}
@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{199}
+@anchor{gnat_rm/implementation_defined_attributes attribute-has-access-values}@anchor{19a}
@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{19a}
+@anchor{gnat_rm/implementation_defined_attributes attribute-has-discriminants}@anchor{19b}
@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{19b}
+@anchor{gnat_rm/implementation_defined_attributes attribute-has-tagged-values}@anchor{19c}
@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{19c}
+@anchor{gnat_rm/implementation_defined_attributes attribute-img}@anchor{19d}
@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{19d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-initialized}@anchor{19e}
@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{19e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-integer-value}@anchor{19f}
@section Attribute Integer_Value
standard input-output functions for fixed-point values.
@node Attribute Invalid_Value,Attribute Large,Attribute Integer_Value,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-invalid-value}@anchor{19f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-invalid-value}@anchor{1a0}
@section Attribute Invalid_Value
relevant environment variables at run time.
@node Attribute Large,Attribute Library_Level,Attribute Invalid_Value,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-large}@anchor{1a0}
+@anchor{gnat_rm/implementation_defined_attributes attribute-large}@anchor{1a1}
@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{1a1}
+@anchor{gnat_rm/implementation_defined_attributes attribute-library-level}@anchor{1a2}
@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{1a2}
+@anchor{gnat_rm/implementation_defined_attributes attribute-loop-entry}@anchor{1a3}
@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{1a3}
+@anchor{gnat_rm/implementation_defined_attributes attribute-machine-size}@anchor{1a4}
@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{1a4}
+@anchor{gnat_rm/implementation_defined_attributes attribute-mantissa}@anchor{1a5}
@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{1a5}@anchor{gnat_rm/implementation_defined_attributes id2}@anchor{1a6}
+@anchor{gnat_rm/implementation_defined_attributes attribute-maximum-alignment}@anchor{1a6}@anchor{gnat_rm/implementation_defined_attributes id2}@anchor{1a7}
@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{1a7}
+@anchor{gnat_rm/implementation_defined_attributes attribute-max-integer-size}@anchor{1a8}
@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{1a8}
+@anchor{gnat_rm/implementation_defined_attributes attribute-mechanism-code}@anchor{1a9}
@section Attribute Mechanism_Code
@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{1a9}
+@anchor{gnat_rm/implementation_defined_attributes attribute-null-parameter}@anchor{1aa}
@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{157}@anchor{gnat_rm/implementation_defined_attributes id3}@anchor{1aa}
+@anchor{gnat_rm/implementation_defined_attributes attribute-object-size}@anchor{158}@anchor{gnat_rm/implementation_defined_attributes id3}@anchor{1ab}
@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{1ab}
+@anchor{gnat_rm/implementation_defined_attributes attribute-old}@anchor{1ac}
@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{1ac}
+@anchor{gnat_rm/implementation_defined_attributes attribute-passed-by-reference}@anchor{1ad}
@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{1ad}
+@anchor{gnat_rm/implementation_defined_attributes attribute-pool-address}@anchor{1ae}
@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{1ae}
+@anchor{gnat_rm/implementation_defined_attributes attribute-range-length}@anchor{1af}
@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{1af}
+@anchor{gnat_rm/implementation_defined_attributes attribute-restriction-set}@anchor{1b0}
@section Attribute Restriction_Set
so they do not have a type.
@node Attribute Result,Attribute Round,Attribute Restriction_Set,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-result}@anchor{1b0}
+@anchor{gnat_rm/implementation_defined_attributes attribute-result}@anchor{1b1}
@section Attribute Result
see the description of pragma Postcondition.
@node Attribute Round,Attribute Safe_Emax,Attribute Result,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-round}@anchor{1b1}
+@anchor{gnat_rm/implementation_defined_attributes attribute-round}@anchor{1b2}
@section Attribute Round
fixed point types.
@node Attribute Safe_Emax,Attribute Safe_Large,Attribute Round,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-safe-emax}@anchor{1b2}
+@anchor{gnat_rm/implementation_defined_attributes attribute-safe-emax}@anchor{1b3}
@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{1b3}
+@anchor{gnat_rm/implementation_defined_attributes attribute-safe-large}@anchor{1b4}
@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{1b4}
+@anchor{gnat_rm/implementation_defined_attributes attribute-safe-small}@anchor{1b5}
@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{165}@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{1b5}
+@anchor{gnat_rm/implementation_defined_attributes attribute-scalar-storage-order}@anchor{166}@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{1b6}
@section Attribute Scalar_Storage_Order
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{f2}@anchor{gnat_rm/implementation_defined_attributes id5}@anchor{1b6}
+@anchor{gnat_rm/implementation_defined_attributes attribute-simple-storage-pool}@anchor{f3}@anchor{gnat_rm/implementation_defined_attributes id5}@anchor{1b7}
@section Attribute Simple_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{1b7}
+@anchor{gnat_rm/implementation_defined_attributes attribute-small}@anchor{1b8}
@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{1b8}
+@anchor{gnat_rm/implementation_defined_attributes attribute-small-denominator}@anchor{1b9}
@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{1b9}
+@anchor{gnat_rm/implementation_defined_attributes attribute-small-numerator}@anchor{1ba}
@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{1ba}
+@anchor{gnat_rm/implementation_defined_attributes attribute-storage-unit}@anchor{1bb}
@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{1bb}
+@anchor{gnat_rm/implementation_defined_attributes attribute-stub-type}@anchor{1bc}
@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{1bc}
+@anchor{gnat_rm/implementation_defined_attributes attribute-system-allocator-alignment}@anchor{1bd}
@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{1bd}
+@anchor{gnat_rm/implementation_defined_attributes attribute-target-name}@anchor{1be}
@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{1be}
+@anchor{gnat_rm/implementation_defined_attributes attribute-to-address}@anchor{1bf}
@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{1bf}
+@anchor{gnat_rm/implementation_defined_attributes attribute-to-any}@anchor{1c0}
@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{1c0}
+@anchor{gnat_rm/implementation_defined_attributes attribute-type-class}@anchor{1c1}
@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{1c1}
+@anchor{gnat_rm/implementation_defined_attributes attribute-type-key}@anchor{1c2}
@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{1c2}
+@anchor{gnat_rm/implementation_defined_attributes attribute-typecode}@anchor{1c3}
@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{1c3}
+@anchor{gnat_rm/implementation_defined_attributes attribute-unconstrained-array}@anchor{1c4}
@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{1c4}
+@anchor{gnat_rm/implementation_defined_attributes attribute-universal-literal-string}@anchor{1c5}
@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{1c5}
+@anchor{gnat_rm/implementation_defined_attributes attribute-unrestricted-access}@anchor{1c6}
@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{1c6}
+@anchor{gnat_rm/implementation_defined_attributes attribute-update}@anchor{1c7}
@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{1c7}
+@anchor{gnat_rm/implementation_defined_attributes attribute-valid-value}@anchor{1c8}
@section Attribute Valid_Value
returns True 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{1c8}
+@anchor{gnat_rm/implementation_defined_attributes attribute-valid-scalars}@anchor{1c9}
@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{1c9}
+@anchor{gnat_rm/implementation_defined_attributes attribute-vads-size}@anchor{1ca}
@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{177}@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1ca}
+@anchor{gnat_rm/implementation_defined_attributes attribute-value-size}@anchor{178}@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1cb}
@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{1cb}
+@anchor{gnat_rm/implementation_defined_attributes attribute-wchar-t-size}@anchor{1cc}
@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{1cc}
+@anchor{gnat_rm/implementation_defined_attributes attribute-word-size}@anchor{1cd}
@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{1cd}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1ce}@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{1ce}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1cf}@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{1cf}@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1d0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions id2}@anchor{1d0}@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1d1}
@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{1d1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions immediate-reclamation}@anchor{1d2}
@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{1d2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-asynchronous-select-nesting}@anchor{1d3}
@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{1d3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-entry-queue-length}@anchor{1d4}
@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{1d4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-protected-entries}@anchor{1d5}
@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{1d5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-select-alternatives}@anchor{1d6}
@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{1d6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-storage-at-blocking}@anchor{1d7}
@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{1d7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-task-entries}@anchor{1d8}
@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{1d8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-tasks}@anchor{1d9}
@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{1d9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-abort-statements}@anchor{1da}
@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{1da}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-parameter-allocators}@anchor{1db}
@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{1db}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-subprograms}@anchor{1dc}
@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{1dc}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-allocators}@anchor{1dd}
@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{1dd}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-anonymous-allocators}@anchor{1de}
@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{1de}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-asynchronous-control}@anchor{1df}
@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{1df}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-calendar}@anchor{1e0}
@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{1e0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-coextensions}@anchor{1e1}
@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{1e1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-default-initialization}@anchor{1e2}
@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{1e2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-delay}@anchor{1e3}
@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{1e3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dependence}@anchor{1e4}
@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{1e4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-direct-boolean-operators}@anchor{1e5}
@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{1e5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatch}@anchor{1e6}
@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{1e6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatching-calls}@anchor{1e7}
@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{1e7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-attachment}@anchor{1e8}
@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{1e8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-priorities}@anchor{1e9}
@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{1e9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-calls-in-elaboration-code}@anchor{1ea}
@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{1ea}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-enumeration-maps}@anchor{1eb}
@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{1eb}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-handlers}@anchor{1ec}
@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{1ec}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-propagation}@anchor{1ed}
@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{1ed}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-registration}@anchor{1ee}
@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{1ee}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exceptions}@anchor{1ef}
@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{1ef}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-finalization}@anchor{1f0}
@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{1f0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-fixed-point}@anchor{1f1}
@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{1f1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-floating-point}@anchor{1f2}
@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{1f2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-conditionals}@anchor{1f3}
@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{1f3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-dynamic-code}@anchor{1f4}
@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{1f4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-heap-allocations}@anchor{1f5}
@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{1f5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-protected-object-allocations}@anchor{1f6}
@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{1f6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-task-allocations}@anchor{1f7}
@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{1f7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-initialize-scalars}@anchor{1f8}
@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{1f8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-io}@anchor{1f9}
@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{1f9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-allocators}@anchor{1fa}
@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{1fa}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-protected-objects}@anchor{1fb}
@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{1fb}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-tagged-types}@anchor{1fc}
@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{1fc}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-timing-events}@anchor{1fd}
@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{1fd}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-long-long-integers}@anchor{1fe}
@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{1fe}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-multiple-elaboration}@anchor{1ff}
@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{1ff}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-nested-finalization}@anchor{200}
@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{200}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-type-allocators}@anchor{201}
@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{201}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-types}@anchor{202}
@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{202}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-recursion}@anchor{203}
@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{203}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-reentrancy}@anchor{204}
@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{204}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-relative-delay}@anchor{205}
@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{205}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-requeue-statements}@anchor{206}
@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{206}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-secondary-stack}@anchor{207}
@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{207}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-select-statements}@anchor{208}
@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{208}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specific-termination-handlers}@anchor{209}
@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{209}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specification-of-aspect}@anchor{20a}
@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{20a}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-allocators-after-elaboration}@anchor{20b}
@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{20b}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-storage-pools}@anchor{20c}
@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{20c}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-stream-optimizations}@anchor{20d}
@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{20d}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-streams}@anchor{20e}
@subsection No_Streams
entire partition.
@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{20e}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tagged-type-registration}@anchor{20f}
@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{20f}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-allocators}@anchor{210}
@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{210}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-at-interrupt-priority}@anchor{211}
@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{211}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-attributes-package}@anchor{212}
@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{212}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-hierarchy}@anchor{213}
@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{213}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-termination}@anchor{214}
@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{214}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tasking}@anchor{215}
@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{215}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-terminate-alternatives}@anchor{216}
@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{216}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-access}@anchor{217}
@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{217}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-conversion}@anchor{218}
@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{218}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-deallocation}@anchor{219}
@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{219}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-attribute}@anchor{21a}
@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{21a}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-entity}@anchor{21b}
@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{21b}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-pragma}@anchor{21c}
@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{21c}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions pure-barriers}@anchor{21d}
@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{21d}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions simple-barriers}@anchor{21e}
@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{21e}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-priorities}@anchor{21f}
@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{21f}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-storage-size}@anchor{220}
@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{220}@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{221}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions id3}@anchor{221}@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{222}
@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{222}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-elaboration-code}@anchor{223}
@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{223}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-accessibility-checks}@anchor{224}
@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{224}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-sized-objects}@anchor{225}
@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{225}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-queue}@anchor{226}
@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{226}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-aspect-specifications}@anchor{227}
@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{227}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-attributes}@anchor{228}
@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{228}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-identifiers}@anchor{229}
@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{229}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-pragmas}@anchor{22a}
@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{22a}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-restrictions}@anchor{22b}
@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{22b}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-units}@anchor{22c}
@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{22c}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-aliasing}@anchor{22d}
@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{22d}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-loops}@anchor{22e}
@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{22e}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-obsolescent-features}@anchor{22f}
@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{22f}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-wide-characters}@anchor{230}
@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{230}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-dispatch-tables}@anchor{231}
@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{231}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions spark-05}@anchor{232}
@subsection SPARK_05
@end example
@node Implementation Advice,Implementation Defined Characteristics,Standard and Implementation Defined Restrictions,Top
-@anchor{gnat_rm/implementation_advice doc}@anchor{232}@anchor{gnat_rm/implementation_advice id1}@anchor{233}@anchor{gnat_rm/implementation_advice implementation-advice}@anchor{a}
+@anchor{gnat_rm/implementation_advice doc}@anchor{233}@anchor{gnat_rm/implementation_advice id1}@anchor{234}@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{234}
+@anchor{gnat_rm/implementation_advice rm-1-1-3-20-error-detection}@anchor{235}
@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{235}
+@anchor{gnat_rm/implementation_advice rm-1-1-3-31-child-units}@anchor{236}
@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{236}
+@anchor{gnat_rm/implementation_advice rm-1-1-5-12-bounded-errors}@anchor{237}
@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{237}@anchor{gnat_rm/implementation_advice rm-2-8-16-pragmas}@anchor{238}
+@anchor{gnat_rm/implementation_advice id2}@anchor{238}@anchor{gnat_rm/implementation_advice rm-2-8-16-pragmas}@anchor{239}
@section RM 2.8(16): Pragmas
@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{239}
+@anchor{gnat_rm/implementation_advice rm-2-8-17-19-pragmas}@anchor{23a}
@section RM 2.8(17-19): Pragmas
@end itemize
@end quotation
-See @ref{238,,RM 2.8(16); Pragmas}.
+See @ref{239,,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{23a}
+@anchor{gnat_rm/implementation_advice rm-3-5-2-5-alternative-character-sets}@anchor{23b}
@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{23b}
+@anchor{gnat_rm/implementation_advice rm-3-5-4-28-integer-types}@anchor{23c}
@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{23c}
+@anchor{gnat_rm/implementation_advice rm-3-5-4-29-integer-types}@anchor{23d}
@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{23d}
+@anchor{gnat_rm/implementation_advice rm-3-5-5-8-enumeration-values}@anchor{23e}
@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{23e}
+@anchor{gnat_rm/implementation_advice rm-3-5-7-17-float-types}@anchor{23f}
@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{23f}
+@anchor{gnat_rm/implementation_advice rm-3-6-2-11-multidimensional-arrays}@anchor{240}
@section RM 3.6.2(11): Multidimensional Arrays
@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{240}
+@anchor{gnat_rm/implementation_advice rm-9-6-30-31-duration-small}@anchor{241}
@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{241}
+@anchor{gnat_rm/implementation_advice rm-10-2-1-12-consistent-representation}@anchor{242}
@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{242}
+@anchor{gnat_rm/implementation_advice rm-11-4-1-19-exception-information}@anchor{243}
@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{243}
+@anchor{gnat_rm/implementation_advice rm-11-5-28-suppression-of-checks}@anchor{244}
@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{244}
+@anchor{gnat_rm/implementation_advice rm-13-1-21-24-representation-clauses}@anchor{245}
@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{245}
+@anchor{gnat_rm/implementation_advice rm-13-2-6-8-packed-types}@anchor{246}
@section RM 13.2(6-8): Packed Types
@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{246}
+@anchor{gnat_rm/implementation_advice rm-13-3-14-19-address-clauses}@anchor{247}
@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{247}
+@anchor{gnat_rm/implementation_advice rm-13-3-29-35-alignment-clauses}@anchor{248}
@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{248}
+@anchor{gnat_rm/implementation_advice rm-13-3-42-43-size-clauses}@anchor{249}
@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{249}
+@anchor{gnat_rm/implementation_advice rm-13-3-50-56-size-clauses}@anchor{24a}
@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{24a}
+@anchor{gnat_rm/implementation_advice rm-13-3-71-73-component-size-clauses}@anchor{24b}
@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{24b}
+@anchor{gnat_rm/implementation_advice rm-13-4-9-10-enumeration-representation-clauses}@anchor{24c}
@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{24c}
+@anchor{gnat_rm/implementation_advice rm-13-5-1-17-22-record-representation-clauses}@anchor{24d}
@section RM 13.5.1(17-22): Record Representation Clauses
@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{24d}
+@anchor{gnat_rm/implementation_advice rm-13-5-2-5-storage-place-attributes}@anchor{24e}
@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{24e}
+@anchor{gnat_rm/implementation_advice rm-13-5-3-7-8-bit-ordering}@anchor{24f}
@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{24f}
+@anchor{gnat_rm/implementation_advice rm-13-7-37-address-as-private}@anchor{250}
@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{250}
+@anchor{gnat_rm/implementation_advice rm-13-7-1-16-address-operations}@anchor{251}
@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{251}
+@anchor{gnat_rm/implementation_advice rm-13-9-14-17-unchecked-conversion}@anchor{252}
@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{252}
+@anchor{gnat_rm/implementation_advice rm-13-11-23-25-implicit-heap-usage}@anchor{253}
@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{253}
+@anchor{gnat_rm/implementation_advice rm-13-11-2-17-unchecked-deallocation}@anchor{254}
@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{254}
+@anchor{gnat_rm/implementation_advice rm-13-13-2-1-6-stream-oriented-attributes}@anchor{255}
@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{255}
+@anchor{gnat_rm/implementation_advice rm-a-1-52-names-of-predefined-numeric-types}@anchor{256}
@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{256}
+@anchor{gnat_rm/implementation_advice rm-a-3-2-49-ada-characters-handling}@anchor{257}
@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{257}
+@anchor{gnat_rm/implementation_advice rm-a-4-4-106-bounded-length-string-handling}@anchor{258}
@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{258}
+@anchor{gnat_rm/implementation_advice rm-a-5-2-46-47-random-number-generation}@anchor{259}
@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{259}
+@anchor{gnat_rm/implementation_advice rm-a-10-7-23-get-immediate}@anchor{25a}
@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{25a}
+@anchor{gnat_rm/implementation_advice rm-a-18-containers}@anchor{25b}
@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{25b}
+@anchor{gnat_rm/implementation_advice rm-b-1-39-41-pragma-export}@anchor{25c}
@section RM B.1(39-41): Pragma @code{Export}
@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{25c}
+@anchor{gnat_rm/implementation_advice rm-b-2-12-13-package-interfaces}@anchor{25d}
@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{25d}
+@anchor{gnat_rm/implementation_advice rm-b-3-63-71-interfacing-with-c}@anchor{25e}
@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{25e}
+@anchor{gnat_rm/implementation_advice rm-b-4-95-98-interfacing-with-cobol}@anchor{25f}
@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{25f}
+@anchor{gnat_rm/implementation_advice rm-b-5-22-26-interfacing-with-fortran}@anchor{260}
@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{260}
+@anchor{gnat_rm/implementation_advice rm-c-1-3-5-access-to-machine-operations}@anchor{261}
@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{261}
+@anchor{gnat_rm/implementation_advice rm-c-1-10-16-access-to-machine-operations}@anchor{262}
@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{262}
+@anchor{gnat_rm/implementation_advice rm-c-3-28-interrupt-support}@anchor{263}
@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{263}
+@anchor{gnat_rm/implementation_advice rm-c-3-1-20-21-protected-procedure-handlers}@anchor{264}
@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{264}
+@anchor{gnat_rm/implementation_advice rm-c-3-2-25-package-interrupts}@anchor{265}
@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{265}
+@anchor{gnat_rm/implementation_advice rm-c-4-14-pre-elaboration-requirements}@anchor{266}
@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{266}
+@anchor{gnat_rm/implementation_advice rm-c-5-8-pragma-discard-names}@anchor{267}
@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{267}
+@anchor{gnat_rm/implementation_advice rm-c-7-2-30-the-package-task-attributes}@anchor{268}
@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{268}
+@anchor{gnat_rm/implementation_advice rm-d-3-17-locking-policies}@anchor{269}
@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{269}
+@anchor{gnat_rm/implementation_advice rm-d-4-16-entry-queuing-policies}@anchor{26a}
@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{26a}
+@anchor{gnat_rm/implementation_advice rm-d-6-9-10-preemptive-abort}@anchor{26b}
@section RM D.6(9-10): Preemptive Abort
@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{26b}
+@anchor{gnat_rm/implementation_advice rm-d-7-21-tasking-restrictions}@anchor{26c}
@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{26c}
+@anchor{gnat_rm/implementation_advice rm-d-8-47-49-monotonic-time}@anchor{26d}
@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{26d}
+@anchor{gnat_rm/implementation_advice rm-e-5-28-29-partition-communication-subsystem}@anchor{26e}
@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{26e}
+@anchor{gnat_rm/implementation_advice rm-f-7-cobol-support}@anchor{26f}
@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{26f}
+@anchor{gnat_rm/implementation_advice rm-f-1-2-decimal-radix-support}@anchor{270}
@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{270}
+@anchor{gnat_rm/implementation_advice rm-g-numerics}@anchor{271}
@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{271}
+@anchor{gnat_rm/implementation_advice rm-g-1-1-56-58-complex-types}@anchor{272}
@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{272}
+@anchor{gnat_rm/implementation_advice rm-g-1-2-49-complex-elementary-functions}@anchor{273}
@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{273}
+@anchor{gnat_rm/implementation_advice rm-g-2-4-19-accuracy-requirements}@anchor{274}
@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{274}
+@anchor{gnat_rm/implementation_advice rm-g-2-6-15-complex-arithmetic-accuracy}@anchor{275}
@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{275}
+@anchor{gnat_rm/implementation_advice rm-h-6-15-2-pragma-partition-elaboration-policy}@anchor{276}
@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{276}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{277}@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}
+@anchor{gnat_rm/implementation_defined_characteristics doc}@anchor{277}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{278}@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}
@chapter Implementation Defined Characteristics
such aspects and the legality rules for such aspects. See 13.1.1(38).”
@end itemize
-See @ref{130,,Implementation Defined Aspects}.
+See @ref{131,,Implementation Defined Aspects}.
@itemize *
according to the syntax of regular expressions as defined in the
@code{GNAT.Regexp} package.
-See @ref{278,,GNAT.Regexp (g-regexp.ads)}.
+See @ref{279,,GNAT.Regexp (g-regexp.ads)}.
@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{279}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{27a}@anchor{gnat_rm/intrinsic_subprograms intrinsic-subprograms}@anchor{c}
+@anchor{gnat_rm/intrinsic_subprograms doc}@anchor{27a}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{27b}@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{27b}@anchor{gnat_rm/intrinsic_subprograms intrinsic-operators}@anchor{27c}
+@anchor{gnat_rm/intrinsic_subprograms id2}@anchor{27c}@anchor{gnat_rm/intrinsic_subprograms intrinsic-operators}@anchor{27d}
@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{27d}@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{27e}
+@anchor{gnat_rm/intrinsic_subprograms compilation-iso-date}@anchor{27e}@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{27f}
@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{27f}@anchor{gnat_rm/intrinsic_subprograms id4}@anchor{280}
+@anchor{gnat_rm/intrinsic_subprograms compilation-date}@anchor{280}@anchor{gnat_rm/intrinsic_subprograms id4}@anchor{281}
@section Compilation_Date
MMM DD YYYY.
@node Compilation_Time,Enclosing_Entity,Compilation_Date,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms compilation-time}@anchor{281}@anchor{gnat_rm/intrinsic_subprograms id5}@anchor{282}
+@anchor{gnat_rm/intrinsic_subprograms compilation-time}@anchor{282}@anchor{gnat_rm/intrinsic_subprograms id5}@anchor{283}
@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{283}@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{284}
+@anchor{gnat_rm/intrinsic_subprograms enclosing-entity}@anchor{284}@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{285}
@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{285}@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{286}
+@anchor{gnat_rm/intrinsic_subprograms exception-information}@anchor{286}@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{287}
@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{287}@anchor{gnat_rm/intrinsic_subprograms id8}@anchor{288}
+@anchor{gnat_rm/intrinsic_subprograms exception-message}@anchor{288}@anchor{gnat_rm/intrinsic_subprograms id8}@anchor{289}
@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{289}@anchor{gnat_rm/intrinsic_subprograms id9}@anchor{28a}
+@anchor{gnat_rm/intrinsic_subprograms exception-name}@anchor{28a}@anchor{gnat_rm/intrinsic_subprograms id9}@anchor{28b}
@section Exception_Name
the name of the current exception.
@node File,Line,Exception_Name,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms file}@anchor{28b}@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{28c}
+@anchor{gnat_rm/intrinsic_subprograms file}@anchor{28c}@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{28d}
@section File
file.
@node Line,Shifts and Rotates,File,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id11}@anchor{28d}@anchor{gnat_rm/intrinsic_subprograms line}@anchor{28e}
+@anchor{gnat_rm/intrinsic_subprograms id11}@anchor{28e}@anchor{gnat_rm/intrinsic_subprograms line}@anchor{28f}
@section Line
source line.
@node Shifts and Rotates,Source_Location,Line,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{28f}@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{290}
+@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{290}@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{291}
@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{291}@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{292}
+@anchor{gnat_rm/intrinsic_subprograms id13}@anchor{292}@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{293}
@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{293}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{294}@anchor{gnat_rm/representation_clauses_and_pragmas representation-clauses-and-pragmas}@anchor{d}
+@anchor{gnat_rm/representation_clauses_and_pragmas doc}@anchor{294}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{295}@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{295}@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{296}
+@anchor{gnat_rm/representation_clauses_and_pragmas alignment-clauses}@anchor{296}@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{297}
@section Alignment Clauses
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{1a5,,Attribute Maximum_Alignment}.)
+@code{Standard'Maximum_Alignment}; see @ref{1a6,,Attribute Maximum_Alignment}.)
@geindex Maximum_Alignment attribute
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{297}@anchor{gnat_rm/representation_clauses_and_pragmas size-clauses}@anchor{298}
+@anchor{gnat_rm/representation_clauses_and_pragmas id3}@anchor{298}@anchor{gnat_rm/representation_clauses_and_pragmas size-clauses}@anchor{299}
@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{299}@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{29a}
+@anchor{gnat_rm/representation_clauses_and_pragmas id4}@anchor{29a}@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{29b}
@section Storage_Size Clauses
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{29b}@anchor{gnat_rm/representation_clauses_and_pragmas size-of-variant-record-objects}@anchor{29c}
+@anchor{gnat_rm/representation_clauses_and_pragmas id5}@anchor{29c}@anchor{gnat_rm/representation_clauses_and_pragmas size-of-variant-record-objects}@anchor{29d}
@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{29d}@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{29e}
+@anchor{gnat_rm/representation_clauses_and_pragmas biased-representation}@anchor{29e}@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{29f}
@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{29f}@anchor{gnat_rm/representation_clauses_and_pragmas value-size-and-object-size-clauses}@anchor{2a0}
+@anchor{gnat_rm/representation_clauses_and_pragmas id7}@anchor{2a0}@anchor{gnat_rm/representation_clauses_and_pragmas value-size-and-object-size-clauses}@anchor{2a1}
@section Value_Size and Object_Size Clauses
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{2a1}@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{2a2}
+@anchor{gnat_rm/representation_clauses_and_pragmas component-size-clauses}@anchor{2a2}@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{2a3}
@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{2a3}@anchor{gnat_rm/representation_clauses_and_pragmas id9}@anchor{2a4}
+@anchor{gnat_rm/representation_clauses_and_pragmas bit-order-clauses}@anchor{2a4}@anchor{gnat_rm/representation_clauses_and_pragmas id9}@anchor{2a5}
@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{2a5}@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{2a6}
+@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-bit-order-on-byte-ordering}@anchor{2a6}@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{2a7}
@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{2a7}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{2a8}
+@anchor{gnat_rm/representation_clauses_and_pragmas id11}@anchor{2a8}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{2a9}
@section Pragma Pack for Arrays
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{2a9}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{2aa}
+@anchor{gnat_rm/representation_clauses_and_pragmas id12}@anchor{2aa}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{2ab}
@section Pragma Pack for Records
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{2ab}@anchor{gnat_rm/representation_clauses_and_pragmas record-representation-clauses}@anchor{2ac}
+@anchor{gnat_rm/representation_clauses_and_pragmas id13}@anchor{2ac}@anchor{gnat_rm/representation_clauses_and_pragmas record-representation-clauses}@anchor{2ad}
@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{2ad}@anchor{gnat_rm/representation_clauses_and_pragmas id14}@anchor{2ae}
+@anchor{gnat_rm/representation_clauses_and_pragmas handling-of-records-with-holes}@anchor{2ae}@anchor{gnat_rm/representation_clauses_and_pragmas id14}@anchor{2af}
@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{2af}@anchor{gnat_rm/representation_clauses_and_pragmas id15}@anchor{2b0}
+@anchor{gnat_rm/representation_clauses_and_pragmas enumeration-clauses}@anchor{2b0}@anchor{gnat_rm/representation_clauses_and_pragmas id15}@anchor{2b1}
@section Enumeration Clauses
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{2b1}@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{2b2}
+@anchor{gnat_rm/representation_clauses_and_pragmas address-clauses}@anchor{2b2}@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{2b3}
@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{2b3}@anchor{gnat_rm/representation_clauses_and_pragmas use-of-address-clauses-for-memory-mapped-i-o}@anchor{2b4}
+@anchor{gnat_rm/representation_clauses_and_pragmas id17}@anchor{2b4}@anchor{gnat_rm/representation_clauses_and_pragmas use-of-address-clauses-for-memory-mapped-i-o}@anchor{2b5}
@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{2b5}@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{2b6}
+@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-convention-on-representation}@anchor{2b6}@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{2b7}
@section Effect of Convention on Representation
@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{2b7}@anchor{gnat_rm/representation_clauses_and_pragmas id19}@anchor{2b8}
+@anchor{gnat_rm/representation_clauses_and_pragmas conventions-and-anonymous-access-types}@anchor{2b8}@anchor{gnat_rm/representation_clauses_and_pragmas id19}@anchor{2b9}
@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{2b9}@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{2ba}
+@anchor{gnat_rm/representation_clauses_and_pragmas determining-the-representations-chosen-by-gnat}@anchor{2ba}@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{2bb}
@section Determining the Representations chosen by GNAT
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{2bb}@anchor{gnat_rm/standard_library_routines id1}@anchor{2bc}@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}
+@anchor{gnat_rm/standard_library_routines doc}@anchor{2bc}@anchor{gnat_rm/standard_library_routines id1}@anchor{2bd}@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}
@chapter Standard Library Routines
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{2bd}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{2be}@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{2be}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{2bf}@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{2bf}@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2c0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id2}@anchor{2c0}@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2c1}
@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{2c1}@anchor{gnat_rm/the_implementation_of_standard_i_o id3}@anchor{2c2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o form-strings}@anchor{2c2}@anchor{gnat_rm/the_implementation_of_standard_i_o id3}@anchor{2c3}
@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{2c3}@anchor{gnat_rm/the_implementation_of_standard_i_o id4}@anchor{2c4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o direct-io}@anchor{2c4}@anchor{gnat_rm/the_implementation_of_standard_i_o id4}@anchor{2c5}
@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{2c5}@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2c6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id5}@anchor{2c6}@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2c7}
@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{2c7}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io}@anchor{2c8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id6}@anchor{2c8}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io}@anchor{2c9}
@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{2c9}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning}@anchor{2ca}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id7}@anchor{2ca}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning}@anchor{2cb}
@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{2cb}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2cc}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id8}@anchor{2cc}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2cd}
@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{2cd}@anchor{gnat_rm/the_implementation_of_standard_i_o id9}@anchor{2ce}
+@anchor{gnat_rm/the_implementation_of_standard_i_o get-immediate}@anchor{2ce}@anchor{gnat_rm/the_implementation_of_standard_i_o id9}@anchor{2cf}
@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{2cf}@anchor{gnat_rm/the_implementation_of_standard_i_o treating-text-io-files-as-streams}@anchor{2d0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id10}@anchor{2d0}@anchor{gnat_rm/the_implementation_of_standard_i_o treating-text-io-files-as-streams}@anchor{2d1}
@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{2d1}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-extensions}@anchor{2d2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id11}@anchor{2d2}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-extensions}@anchor{2d3}
@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{2d3}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2d4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id12}@anchor{2d4}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2d5}
@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{2d5}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2d6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id13}@anchor{2d6}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2d7}
@section Wide_Text_IO
@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{2d7}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2d8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id14}@anchor{2d8}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2d9}
@subsection Stream Pointer Positioning
@code{Ada.Wide_Text_IO} is similar to @code{Ada.Text_IO} in its handling
-of stream pointer positioning (@ref{2c8,,Text_IO}). There is one additional
+of stream pointer positioning (@ref{2c9,,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{2d9}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2da}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id15}@anchor{2da}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2db}
@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{2db}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-wide-text-io}@anchor{2dc}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id16}@anchor{2dc}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-wide-text-io}@anchor{2dd}
@section Wide_Wide_Text_IO
@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{2dd}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2de}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id17}@anchor{2de}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2df}
@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{2c8,,Text_IO}). There is one additional
+of stream pointer positioning (@ref{2c9,,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{2df}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-2}@anchor{2e0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id18}@anchor{2e0}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-2}@anchor{2e1}
@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{2e1}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-io}@anchor{2e2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id19}@anchor{2e2}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-io}@anchor{2e3}
@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{2e3}@anchor{gnat_rm/the_implementation_of_standard_i_o text-translation}@anchor{2e4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id20}@anchor{2e4}@anchor{gnat_rm/the_implementation_of_standard_i_o text-translation}@anchor{2e5}
@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{2e5}@anchor{gnat_rm/the_implementation_of_standard_i_o shared-files}@anchor{2e6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id21}@anchor{2e6}@anchor{gnat_rm/the_implementation_of_standard_i_o shared-files}@anchor{2e7}
@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{2e7}@anchor{gnat_rm/the_implementation_of_standard_i_o id22}@anchor{2e8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o filenames-encoding}@anchor{2e8}@anchor{gnat_rm/the_implementation_of_standard_i_o id22}@anchor{2e9}
@section Filenames encoding
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{2e9}@anchor{gnat_rm/the_implementation_of_standard_i_o id23}@anchor{2ea}
+@anchor{gnat_rm/the_implementation_of_standard_i_o file-content-encoding}@anchor{2ea}@anchor{gnat_rm/the_implementation_of_standard_i_o id23}@anchor{2eb}
@section File content encoding
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{2eb}@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2ec}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id24}@anchor{2ec}@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2ed}
@section Open Modes
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{2ed}@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2ee}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id25}@anchor{2ee}@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2ef}
@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{2ef}@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2f0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id26}@anchor{2f0}@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2f1}
@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{2f1}@anchor{gnat_rm/the_gnat_library id1}@anchor{2f2}@anchor{gnat_rm/the_gnat_library the-gnat-library}@anchor{10}
+@anchor{gnat_rm/the_gnat_library doc}@anchor{2f2}@anchor{gnat_rm/the_gnat_library id1}@anchor{2f3}@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{2f3}@anchor{gnat_rm/the_gnat_library id2}@anchor{2f4}
+@anchor{gnat_rm/the_gnat_library ada-characters-latin-9-a-chlat9-ads}@anchor{2f4}@anchor{gnat_rm/the_gnat_library id2}@anchor{2f5}
@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{2f5}@anchor{gnat_rm/the_gnat_library id3}@anchor{2f6}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-1-a-cwila1-ads}@anchor{2f6}@anchor{gnat_rm/the_gnat_library id3}@anchor{2f7}
@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{2f7}@anchor{gnat_rm/the_gnat_library id4}@anchor{2f8}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-9-a-cwila9-ads}@anchor{2f8}@anchor{gnat_rm/the_gnat_library id4}@anchor{2f9}
@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{2f9}@anchor{gnat_rm/the_gnat_library id5}@anchor{2fa}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-1-a-chzla1-ads}@anchor{2fa}@anchor{gnat_rm/the_gnat_library id5}@anchor{2fb}
@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{2fb}@anchor{gnat_rm/the_gnat_library id6}@anchor{2fc}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-9-a-chzla9-ads}@anchor{2fc}@anchor{gnat_rm/the_gnat_library id6}@anchor{2fd}
@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{2fd}@anchor{gnat_rm/the_gnat_library id7}@anchor{2fe}
+@anchor{gnat_rm/the_gnat_library ada-containers-bounded-holders-a-coboho-ads}@anchor{2fe}@anchor{gnat_rm/the_gnat_library id7}@anchor{2ff}
@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{2ff}@anchor{gnat_rm/the_gnat_library id8}@anchor{300}
+@anchor{gnat_rm/the_gnat_library ada-command-line-environment-a-colien-ads}@anchor{300}@anchor{gnat_rm/the_gnat_library id8}@anchor{301}
@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{301}@anchor{gnat_rm/the_gnat_library id9}@anchor{302}
+@anchor{gnat_rm/the_gnat_library ada-command-line-remove-a-colire-ads}@anchor{302}@anchor{gnat_rm/the_gnat_library id9}@anchor{303}
@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{303}@anchor{gnat_rm/the_gnat_library id10}@anchor{304}
+@anchor{gnat_rm/the_gnat_library ada-command-line-response-file-a-clrefi-ads}@anchor{304}@anchor{gnat_rm/the_gnat_library id10}@anchor{305}
@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{305}@anchor{gnat_rm/the_gnat_library id11}@anchor{306}
+@anchor{gnat_rm/the_gnat_library ada-direct-io-c-streams-a-diocst-ads}@anchor{306}@anchor{gnat_rm/the_gnat_library id11}@anchor{307}
@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{307}@anchor{gnat_rm/the_gnat_library id12}@anchor{308}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-is-null-occurrence-a-einuoc-ads}@anchor{308}@anchor{gnat_rm/the_gnat_library id12}@anchor{309}
@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{309}@anchor{gnat_rm/the_gnat_library id13}@anchor{30a}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-last-chance-handler-a-elchha-ads}@anchor{30a}@anchor{gnat_rm/the_gnat_library id13}@anchor{30b}
@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{30b}@anchor{gnat_rm/the_gnat_library id14}@anchor{30c}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-traceback-a-exctra-ads}@anchor{30c}@anchor{gnat_rm/the_gnat_library id14}@anchor{30d}
@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{30d}@anchor{gnat_rm/the_gnat_library id15}@anchor{30e}
+@anchor{gnat_rm/the_gnat_library ada-sequential-io-c-streams-a-siocst-ads}@anchor{30e}@anchor{gnat_rm/the_gnat_library id15}@anchor{30f}
@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{30f}@anchor{gnat_rm/the_gnat_library id16}@anchor{310}
+@anchor{gnat_rm/the_gnat_library ada-streams-stream-io-c-streams-a-ssicst-ads}@anchor{310}@anchor{gnat_rm/the_gnat_library id16}@anchor{311}
@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{311}@anchor{gnat_rm/the_gnat_library id17}@anchor{312}
+@anchor{gnat_rm/the_gnat_library ada-strings-unbounded-text-io-a-suteio-ads}@anchor{312}@anchor{gnat_rm/the_gnat_library id17}@anchor{313}
@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{313}@anchor{gnat_rm/the_gnat_library id18}@anchor{314}
+@anchor{gnat_rm/the_gnat_library ada-strings-wide-unbounded-wide-text-io-a-swuwti-ads}@anchor{314}@anchor{gnat_rm/the_gnat_library id18}@anchor{315}
@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{315}@anchor{gnat_rm/the_gnat_library id19}@anchor{316}
+@anchor{gnat_rm/the_gnat_library ada-strings-wide-wide-unbounded-wide-wide-text-io-a-szuzti-ads}@anchor{316}@anchor{gnat_rm/the_gnat_library id19}@anchor{317}
@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{317}@anchor{gnat_rm/the_gnat_library id20}@anchor{318}
+@anchor{gnat_rm/the_gnat_library ada-task-initialization-a-tasini-ads}@anchor{318}@anchor{gnat_rm/the_gnat_library id20}@anchor{319}
@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{319}@anchor{gnat_rm/the_gnat_library id21}@anchor{31a}
+@anchor{gnat_rm/the_gnat_library ada-text-io-c-streams-a-tiocst-ads}@anchor{31a}@anchor{gnat_rm/the_gnat_library id21}@anchor{31b}
@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{31b}@anchor{gnat_rm/the_gnat_library id22}@anchor{31c}
+@anchor{gnat_rm/the_gnat_library ada-text-io-reset-standard-files-a-tirsfi-ads}@anchor{31c}@anchor{gnat_rm/the_gnat_library id22}@anchor{31d}
@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{31d}@anchor{gnat_rm/the_gnat_library id23}@anchor{31e}
+@anchor{gnat_rm/the_gnat_library ada-wide-characters-unicode-a-wichun-ads}@anchor{31e}@anchor{gnat_rm/the_gnat_library id23}@anchor{31f}
@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{31f}@anchor{gnat_rm/the_gnat_library id24}@anchor{320}
+@anchor{gnat_rm/the_gnat_library ada-wide-text-io-c-streams-a-wtcstr-ads}@anchor{320}@anchor{gnat_rm/the_gnat_library id24}@anchor{321}
@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{321}@anchor{gnat_rm/the_gnat_library id25}@anchor{322}
+@anchor{gnat_rm/the_gnat_library ada-wide-text-io-reset-standard-files-a-wrstfi-ads}@anchor{322}@anchor{gnat_rm/the_gnat_library id25}@anchor{323}
@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{323}@anchor{gnat_rm/the_gnat_library id26}@anchor{324}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-characters-unicode-a-zchuni-ads}@anchor{324}@anchor{gnat_rm/the_gnat_library id26}@anchor{325}
@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{325}@anchor{gnat_rm/the_gnat_library id27}@anchor{326}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-c-streams-a-ztcstr-ads}@anchor{326}@anchor{gnat_rm/the_gnat_library id27}@anchor{327}
@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{327}@anchor{gnat_rm/the_gnat_library id28}@anchor{328}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-reset-standard-files-a-zrstfi-ads}@anchor{328}@anchor{gnat_rm/the_gnat_library id28}@anchor{329}
@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{329}@anchor{gnat_rm/the_gnat_library id29}@anchor{32a}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-g-altive-ads}@anchor{32a}@anchor{gnat_rm/the_gnat_library id29}@anchor{32b}
@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{32b}@anchor{gnat_rm/the_gnat_library id30}@anchor{32c}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-conversions-g-altcon-ads}@anchor{32c}@anchor{gnat_rm/the_gnat_library id30}@anchor{32d}
@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{32d}@anchor{gnat_rm/the_gnat_library id31}@anchor{32e}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-operations-g-alveop-ads}@anchor{32e}@anchor{gnat_rm/the_gnat_library id31}@anchor{32f}
@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{32f}@anchor{gnat_rm/the_gnat_library id32}@anchor{330}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-types-g-alvety-ads}@anchor{330}@anchor{gnat_rm/the_gnat_library id32}@anchor{331}
@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{331}@anchor{gnat_rm/the_gnat_library id33}@anchor{332}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-views-g-alvevi-ads}@anchor{332}@anchor{gnat_rm/the_gnat_library id33}@anchor{333}
@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{333}@anchor{gnat_rm/the_gnat_library id34}@anchor{334}
+@anchor{gnat_rm/the_gnat_library gnat-array-split-g-arrspl-ads}@anchor{334}@anchor{gnat_rm/the_gnat_library id34}@anchor{335}
@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{335}@anchor{gnat_rm/the_gnat_library id35}@anchor{336}
+@anchor{gnat_rm/the_gnat_library gnat-awk-g-awk-ads}@anchor{336}@anchor{gnat_rm/the_gnat_library id35}@anchor{337}
@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{337}@anchor{gnat_rm/the_gnat_library id36}@anchor{338}
+@anchor{gnat_rm/the_gnat_library gnat-binary-search-g-binsea-ads}@anchor{338}@anchor{gnat_rm/the_gnat_library id36}@anchor{339}
@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{339}@anchor{gnat_rm/the_gnat_library id37}@anchor{33a}
+@anchor{gnat_rm/the_gnat_library gnat-bind-environment-g-binenv-ads}@anchor{33a}@anchor{gnat_rm/the_gnat_library id37}@anchor{33b}
@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{33b}@anchor{gnat_rm/the_gnat_library id38}@anchor{33c}
+@anchor{gnat_rm/the_gnat_library gnat-branch-prediction-g-brapre-ads}@anchor{33c}@anchor{gnat_rm/the_gnat_library id38}@anchor{33d}
@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{33d}@anchor{gnat_rm/the_gnat_library id39}@anchor{33e}
+@anchor{gnat_rm/the_gnat_library gnat-bounded-buffers-g-boubuf-ads}@anchor{33e}@anchor{gnat_rm/the_gnat_library id39}@anchor{33f}
@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{33f}@anchor{gnat_rm/the_gnat_library id40}@anchor{340}
+@anchor{gnat_rm/the_gnat_library gnat-bounded-mailboxes-g-boumai-ads}@anchor{340}@anchor{gnat_rm/the_gnat_library id40}@anchor{341}
@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{341}@anchor{gnat_rm/the_gnat_library id41}@anchor{342}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-bubsor-ads}@anchor{342}@anchor{gnat_rm/the_gnat_library id41}@anchor{343}
@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{343}@anchor{gnat_rm/the_gnat_library id42}@anchor{344}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-a-g-busora-ads}@anchor{344}@anchor{gnat_rm/the_gnat_library id42}@anchor{345}
@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{345}@anchor{gnat_rm/the_gnat_library id43}@anchor{346}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-g-busorg-ads}@anchor{346}@anchor{gnat_rm/the_gnat_library id43}@anchor{347}
@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{347}@anchor{gnat_rm/the_gnat_library id44}@anchor{348}
+@anchor{gnat_rm/the_gnat_library gnat-byte-order-mark-g-byorma-ads}@anchor{348}@anchor{gnat_rm/the_gnat_library id44}@anchor{349}
@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{349}@anchor{gnat_rm/the_gnat_library id45}@anchor{34a}
+@anchor{gnat_rm/the_gnat_library gnat-byte-swapping-g-bytswa-ads}@anchor{34a}@anchor{gnat_rm/the_gnat_library id45}@anchor{34b}
@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{34b}@anchor{gnat_rm/the_gnat_library id46}@anchor{34c}
+@anchor{gnat_rm/the_gnat_library gnat-calendar-g-calend-ads}@anchor{34c}@anchor{gnat_rm/the_gnat_library id46}@anchor{34d}
@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{34d}@anchor{gnat_rm/the_gnat_library id47}@anchor{34e}
+@anchor{gnat_rm/the_gnat_library gnat-calendar-time-io-g-catiio-ads}@anchor{34e}@anchor{gnat_rm/the_gnat_library id47}@anchor{34f}
@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{34f}@anchor{gnat_rm/the_gnat_library id48}@anchor{350}
+@anchor{gnat_rm/the_gnat_library gnat-crc32-g-crc32-ads}@anchor{350}@anchor{gnat_rm/the_gnat_library id48}@anchor{351}
@section @code{GNAT.CRC32} (@code{g-crc32.ads})
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{351}@anchor{gnat_rm/the_gnat_library id49}@anchor{352}
+@anchor{gnat_rm/the_gnat_library gnat-case-util-g-casuti-ads}@anchor{352}@anchor{gnat_rm/the_gnat_library id49}@anchor{353}
@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{353}@anchor{gnat_rm/the_gnat_library id50}@anchor{354}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-g-cgi-ads}@anchor{354}@anchor{gnat_rm/the_gnat_library id50}@anchor{355}
@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{355}@anchor{gnat_rm/the_gnat_library id51}@anchor{356}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-cookie-g-cgicoo-ads}@anchor{356}@anchor{gnat_rm/the_gnat_library id51}@anchor{357}
@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{357}@anchor{gnat_rm/the_gnat_library id52}@anchor{358}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-debug-g-cgideb-ads}@anchor{358}@anchor{gnat_rm/the_gnat_library id52}@anchor{359}
@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{359}@anchor{gnat_rm/the_gnat_library id53}@anchor{35a}
+@anchor{gnat_rm/the_gnat_library gnat-command-line-g-comlin-ads}@anchor{35a}@anchor{gnat_rm/the_gnat_library id53}@anchor{35b}
@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{35b}@anchor{gnat_rm/the_gnat_library id54}@anchor{35c}
+@anchor{gnat_rm/the_gnat_library gnat-compiler-version-g-comver-ads}@anchor{35c}@anchor{gnat_rm/the_gnat_library id54}@anchor{35d}
@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{35d}@anchor{gnat_rm/the_gnat_library id55}@anchor{35e}
+@anchor{gnat_rm/the_gnat_library gnat-ctrl-c-g-ctrl-c-ads}@anchor{35e}@anchor{gnat_rm/the_gnat_library id55}@anchor{35f}
@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{35f}@anchor{gnat_rm/the_gnat_library id56}@anchor{360}
+@anchor{gnat_rm/the_gnat_library gnat-current-exception-g-curexc-ads}@anchor{360}@anchor{gnat_rm/the_gnat_library id56}@anchor{361}
@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{361}@anchor{gnat_rm/the_gnat_library id57}@anchor{362}
+@anchor{gnat_rm/the_gnat_library gnat-debug-pools-g-debpoo-ads}@anchor{362}@anchor{gnat_rm/the_gnat_library id57}@anchor{363}
@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{363}@anchor{gnat_rm/the_gnat_library id58}@anchor{364}
+@anchor{gnat_rm/the_gnat_library gnat-debug-utilities-g-debuti-ads}@anchor{364}@anchor{gnat_rm/the_gnat_library id58}@anchor{365}
@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{365}@anchor{gnat_rm/the_gnat_library id59}@anchor{366}
+@anchor{gnat_rm/the_gnat_library gnat-decode-string-g-decstr-ads}@anchor{366}@anchor{gnat_rm/the_gnat_library id59}@anchor{367}
@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{367}@anchor{gnat_rm/the_gnat_library id60}@anchor{368}
+@anchor{gnat_rm/the_gnat_library gnat-decode-utf8-string-g-deutst-ads}@anchor{368}@anchor{gnat_rm/the_gnat_library id60}@anchor{369}
@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{369}@anchor{gnat_rm/the_gnat_library id61}@anchor{36a}
+@anchor{gnat_rm/the_gnat_library gnat-directory-operations-g-dirope-ads}@anchor{36a}@anchor{gnat_rm/the_gnat_library id61}@anchor{36b}
@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{36b}@anchor{gnat_rm/the_gnat_library id62}@anchor{36c}
+@anchor{gnat_rm/the_gnat_library gnat-directory-operations-iteration-g-diopit-ads}@anchor{36c}@anchor{gnat_rm/the_gnat_library id62}@anchor{36d}
@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{36d}@anchor{gnat_rm/the_gnat_library id63}@anchor{36e}
+@anchor{gnat_rm/the_gnat_library gnat-dynamic-htables-g-dynhta-ads}@anchor{36e}@anchor{gnat_rm/the_gnat_library id63}@anchor{36f}
@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{36f}@anchor{gnat_rm/the_gnat_library id64}@anchor{370}
+@anchor{gnat_rm/the_gnat_library gnat-dynamic-tables-g-dyntab-ads}@anchor{370}@anchor{gnat_rm/the_gnat_library id64}@anchor{371}
@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{371}@anchor{gnat_rm/the_gnat_library id65}@anchor{372}
+@anchor{gnat_rm/the_gnat_library gnat-encode-string-g-encstr-ads}@anchor{372}@anchor{gnat_rm/the_gnat_library id65}@anchor{373}
@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{373}@anchor{gnat_rm/the_gnat_library id66}@anchor{374}
+@anchor{gnat_rm/the_gnat_library gnat-encode-utf8-string-g-enutst-ads}@anchor{374}@anchor{gnat_rm/the_gnat_library id66}@anchor{375}
@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{375}@anchor{gnat_rm/the_gnat_library id67}@anchor{376}
+@anchor{gnat_rm/the_gnat_library gnat-exception-actions-g-excact-ads}@anchor{376}@anchor{gnat_rm/the_gnat_library id67}@anchor{377}
@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{377}@anchor{gnat_rm/the_gnat_library id68}@anchor{378}
+@anchor{gnat_rm/the_gnat_library gnat-exception-traces-g-exctra-ads}@anchor{378}@anchor{gnat_rm/the_gnat_library id68}@anchor{379}
@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{379}@anchor{gnat_rm/the_gnat_library id69}@anchor{37a}
+@anchor{gnat_rm/the_gnat_library gnat-exceptions-g-except-ads}@anchor{37a}@anchor{gnat_rm/the_gnat_library id69}@anchor{37b}
@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{37b}@anchor{gnat_rm/the_gnat_library id70}@anchor{37c}
+@anchor{gnat_rm/the_gnat_library gnat-expect-g-expect-ads}@anchor{37c}@anchor{gnat_rm/the_gnat_library id70}@anchor{37d}
@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{37d}@anchor{gnat_rm/the_gnat_library id71}@anchor{37e}
+@anchor{gnat_rm/the_gnat_library gnat-expect-tty-g-exptty-ads}@anchor{37e}@anchor{gnat_rm/the_gnat_library id71}@anchor{37f}
@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{37f}@anchor{gnat_rm/the_gnat_library id72}@anchor{380}
+@anchor{gnat_rm/the_gnat_library gnat-float-control-g-flocon-ads}@anchor{380}@anchor{gnat_rm/the_gnat_library id72}@anchor{381}
@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{381}@anchor{gnat_rm/the_gnat_library id73}@anchor{382}
+@anchor{gnat_rm/the_gnat_library gnat-formatted-string-g-forstr-ads}@anchor{382}@anchor{gnat_rm/the_gnat_library id73}@anchor{383}
@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{383}@anchor{gnat_rm/the_gnat_library id74}@anchor{384}
+@anchor{gnat_rm/the_gnat_library gnat-generic-fast-math-functions-g-gfmafu-ads}@anchor{384}@anchor{gnat_rm/the_gnat_library id74}@anchor{385}
@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{385}@anchor{gnat_rm/the_gnat_library id75}@anchor{386}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-heasor-ads}@anchor{386}@anchor{gnat_rm/the_gnat_library id75}@anchor{387}
@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{387}@anchor{gnat_rm/the_gnat_library id76}@anchor{388}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-a-g-hesora-ads}@anchor{388}@anchor{gnat_rm/the_gnat_library id76}@anchor{389}
@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{389}@anchor{gnat_rm/the_gnat_library id77}@anchor{38a}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-g-hesorg-ads}@anchor{38a}@anchor{gnat_rm/the_gnat_library id77}@anchor{38b}
@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{38b}@anchor{gnat_rm/the_gnat_library id78}@anchor{38c}
+@anchor{gnat_rm/the_gnat_library gnat-htable-g-htable-ads}@anchor{38c}@anchor{gnat_rm/the_gnat_library id78}@anchor{38d}
@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{38d}@anchor{gnat_rm/the_gnat_library id79}@anchor{38e}
+@anchor{gnat_rm/the_gnat_library gnat-io-g-io-ads}@anchor{38e}@anchor{gnat_rm/the_gnat_library id79}@anchor{38f}
@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{38f}@anchor{gnat_rm/the_gnat_library id80}@anchor{390}
+@anchor{gnat_rm/the_gnat_library gnat-io-aux-g-io-aux-ads}@anchor{390}@anchor{gnat_rm/the_gnat_library id80}@anchor{391}
@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{391}@anchor{gnat_rm/the_gnat_library id81}@anchor{392}
+@anchor{gnat_rm/the_gnat_library gnat-lock-files-g-locfil-ads}@anchor{392}@anchor{gnat_rm/the_gnat_library id81}@anchor{393}
@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{393}@anchor{gnat_rm/the_gnat_library id82}@anchor{394}
+@anchor{gnat_rm/the_gnat_library gnat-mbbs-discrete-random-g-mbdira-ads}@anchor{394}@anchor{gnat_rm/the_gnat_library id82}@anchor{395}
@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{395}@anchor{gnat_rm/the_gnat_library id83}@anchor{396}
+@anchor{gnat_rm/the_gnat_library gnat-mbbs-float-random-g-mbflra-ads}@anchor{396}@anchor{gnat_rm/the_gnat_library id83}@anchor{397}
@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{397}@anchor{gnat_rm/the_gnat_library id84}@anchor{398}
+@anchor{gnat_rm/the_gnat_library gnat-md5-g-md5-ads}@anchor{398}@anchor{gnat_rm/the_gnat_library id84}@anchor{399}
@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{399}@anchor{gnat_rm/the_gnat_library id85}@anchor{39a}
+@anchor{gnat_rm/the_gnat_library gnat-memory-dump-g-memdum-ads}@anchor{39a}@anchor{gnat_rm/the_gnat_library id85}@anchor{39b}
@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{39b}@anchor{gnat_rm/the_gnat_library id86}@anchor{39c}
+@anchor{gnat_rm/the_gnat_library gnat-most-recent-exception-g-moreex-ads}@anchor{39c}@anchor{gnat_rm/the_gnat_library id86}@anchor{39d}
@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{39d}@anchor{gnat_rm/the_gnat_library id87}@anchor{39e}
+@anchor{gnat_rm/the_gnat_library gnat-os-lib-g-os-lib-ads}@anchor{39e}@anchor{gnat_rm/the_gnat_library id87}@anchor{39f}
@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{39f}@anchor{gnat_rm/the_gnat_library id88}@anchor{3a0}
+@anchor{gnat_rm/the_gnat_library gnat-perfect-hash-generators-g-pehage-ads}@anchor{3a0}@anchor{gnat_rm/the_gnat_library id88}@anchor{3a1}
@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{3a1}@anchor{gnat_rm/the_gnat_library id89}@anchor{3a2}
+@anchor{gnat_rm/the_gnat_library gnat-random-numbers-g-rannum-ads}@anchor{3a2}@anchor{gnat_rm/the_gnat_library id89}@anchor{3a3}
@section @code{GNAT.Random_Numbers} (@code{g-rannum.ads})
randomness.
@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{278}@anchor{gnat_rm/the_gnat_library id90}@anchor{3a3}
+@anchor{gnat_rm/the_gnat_library gnat-regexp-g-regexp-ads}@anchor{279}@anchor{gnat_rm/the_gnat_library id90}@anchor{3a4}
@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{3a4}@anchor{gnat_rm/the_gnat_library id91}@anchor{3a5}
+@anchor{gnat_rm/the_gnat_library gnat-registry-g-regist-ads}@anchor{3a5}@anchor{gnat_rm/the_gnat_library id91}@anchor{3a6}
@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{3a6}@anchor{gnat_rm/the_gnat_library id92}@anchor{3a7}
+@anchor{gnat_rm/the_gnat_library gnat-regpat-g-regpat-ads}@anchor{3a7}@anchor{gnat_rm/the_gnat_library id92}@anchor{3a8}
@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{3a8}@anchor{gnat_rm/the_gnat_library id93}@anchor{3a9}
+@anchor{gnat_rm/the_gnat_library gnat-rewrite-data-g-rewdat-ads}@anchor{3a9}@anchor{gnat_rm/the_gnat_library id93}@anchor{3aa}
@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{3aa}@anchor{gnat_rm/the_gnat_library id94}@anchor{3ab}
+@anchor{gnat_rm/the_gnat_library gnat-secondary-stack-info-g-sestin-ads}@anchor{3ab}@anchor{gnat_rm/the_gnat_library id94}@anchor{3ac}
@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{3ac}@anchor{gnat_rm/the_gnat_library id95}@anchor{3ad}
+@anchor{gnat_rm/the_gnat_library gnat-semaphores-g-semaph-ads}@anchor{3ad}@anchor{gnat_rm/the_gnat_library id95}@anchor{3ae}
@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{3ae}@anchor{gnat_rm/the_gnat_library id96}@anchor{3af}
+@anchor{gnat_rm/the_gnat_library gnat-serial-communications-g-sercom-ads}@anchor{3af}@anchor{gnat_rm/the_gnat_library id96}@anchor{3b0}
@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{3b0}@anchor{gnat_rm/the_gnat_library id97}@anchor{3b1}
+@anchor{gnat_rm/the_gnat_library gnat-sha1-g-sha1-ads}@anchor{3b1}@anchor{gnat_rm/the_gnat_library id97}@anchor{3b2}
@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{3b2}@anchor{gnat_rm/the_gnat_library id98}@anchor{3b3}
+@anchor{gnat_rm/the_gnat_library gnat-sha224-g-sha224-ads}@anchor{3b3}@anchor{gnat_rm/the_gnat_library id98}@anchor{3b4}
@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{3b4}@anchor{gnat_rm/the_gnat_library id99}@anchor{3b5}
+@anchor{gnat_rm/the_gnat_library gnat-sha256-g-sha256-ads}@anchor{3b5}@anchor{gnat_rm/the_gnat_library id99}@anchor{3b6}
@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{3b6}@anchor{gnat_rm/the_gnat_library id100}@anchor{3b7}
+@anchor{gnat_rm/the_gnat_library gnat-sha384-g-sha384-ads}@anchor{3b7}@anchor{gnat_rm/the_gnat_library id100}@anchor{3b8}
@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{3b8}@anchor{gnat_rm/the_gnat_library id101}@anchor{3b9}
+@anchor{gnat_rm/the_gnat_library gnat-sha512-g-sha512-ads}@anchor{3b9}@anchor{gnat_rm/the_gnat_library id101}@anchor{3ba}
@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{3ba}@anchor{gnat_rm/the_gnat_library id102}@anchor{3bb}
+@anchor{gnat_rm/the_gnat_library gnat-signals-g-signal-ads}@anchor{3bb}@anchor{gnat_rm/the_gnat_library id102}@anchor{3bc}
@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{3bc}@anchor{gnat_rm/the_gnat_library id103}@anchor{3bd}
+@anchor{gnat_rm/the_gnat_library gnat-sockets-g-socket-ads}@anchor{3bd}@anchor{gnat_rm/the_gnat_library id103}@anchor{3be}
@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{3be}@anchor{gnat_rm/the_gnat_library id104}@anchor{3bf}
+@anchor{gnat_rm/the_gnat_library gnat-source-info-g-souinf-ads}@anchor{3bf}@anchor{gnat_rm/the_gnat_library id104}@anchor{3c0}
@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{3c0}@anchor{gnat_rm/the_gnat_library id105}@anchor{3c1}
+@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-g-speche-ads}@anchor{3c1}@anchor{gnat_rm/the_gnat_library id105}@anchor{3c2}
@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{3c2}@anchor{gnat_rm/the_gnat_library id106}@anchor{3c3}
+@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-generic-g-spchge-ads}@anchor{3c3}@anchor{gnat_rm/the_gnat_library id106}@anchor{3c4}
@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{3c4}@anchor{gnat_rm/the_gnat_library id107}@anchor{3c5}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-patterns-g-spipat-ads}@anchor{3c5}@anchor{gnat_rm/the_gnat_library id107}@anchor{3c6}
@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{3c6}@anchor{gnat_rm/the_gnat_library id108}@anchor{3c7}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-g-spitbo-ads}@anchor{3c7}@anchor{gnat_rm/the_gnat_library id108}@anchor{3c8}
@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{3c8}@anchor{gnat_rm/the_gnat_library id109}@anchor{3c9}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-boolean-g-sptabo-ads}@anchor{3c9}@anchor{gnat_rm/the_gnat_library id109}@anchor{3ca}
@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{3ca}@anchor{gnat_rm/the_gnat_library id110}@anchor{3cb}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-integer-g-sptain-ads}@anchor{3cb}@anchor{gnat_rm/the_gnat_library id110}@anchor{3cc}
@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{3cc}@anchor{gnat_rm/the_gnat_library id111}@anchor{3cd}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-vstring-g-sptavs-ads}@anchor{3cd}@anchor{gnat_rm/the_gnat_library id111}@anchor{3ce}
@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{3ce}@anchor{gnat_rm/the_gnat_library id112}@anchor{3cf}
+@anchor{gnat_rm/the_gnat_library gnat-sse-g-sse-ads}@anchor{3cf}@anchor{gnat_rm/the_gnat_library id112}@anchor{3d0}
@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{3d0}@anchor{gnat_rm/the_gnat_library id113}@anchor{3d1}
+@anchor{gnat_rm/the_gnat_library gnat-sse-vector-types-g-ssvety-ads}@anchor{3d1}@anchor{gnat_rm/the_gnat_library id113}@anchor{3d2}
@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{3d2}@anchor{gnat_rm/the_gnat_library id114}@anchor{3d3}
+@anchor{gnat_rm/the_gnat_library gnat-string-hash-g-strhas-ads}@anchor{3d3}@anchor{gnat_rm/the_gnat_library id114}@anchor{3d4}
@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{3d4}@anchor{gnat_rm/the_gnat_library id115}@anchor{3d5}
+@anchor{gnat_rm/the_gnat_library gnat-strings-g-string-ads}@anchor{3d5}@anchor{gnat_rm/the_gnat_library id115}@anchor{3d6}
@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{3d6}@anchor{gnat_rm/the_gnat_library id116}@anchor{3d7}
+@anchor{gnat_rm/the_gnat_library gnat-string-split-g-strspl-ads}@anchor{3d7}@anchor{gnat_rm/the_gnat_library id116}@anchor{3d8}
@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{3d8}@anchor{gnat_rm/the_gnat_library id117}@anchor{3d9}
+@anchor{gnat_rm/the_gnat_library gnat-table-g-table-ads}@anchor{3d9}@anchor{gnat_rm/the_gnat_library id117}@anchor{3da}
@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{3da}@anchor{gnat_rm/the_gnat_library id118}@anchor{3db}
+@anchor{gnat_rm/the_gnat_library gnat-task-lock-g-tasloc-ads}@anchor{3db}@anchor{gnat_rm/the_gnat_library id118}@anchor{3dc}
@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{3dc}@anchor{gnat_rm/the_gnat_library id119}@anchor{3dd}
+@anchor{gnat_rm/the_gnat_library gnat-time-stamp-g-timsta-ads}@anchor{3dd}@anchor{gnat_rm/the_gnat_library id119}@anchor{3de}
@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{3de}@anchor{gnat_rm/the_gnat_library id120}@anchor{3df}
+@anchor{gnat_rm/the_gnat_library gnat-threads-g-thread-ads}@anchor{3df}@anchor{gnat_rm/the_gnat_library id120}@anchor{3e0}
@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{3e0}@anchor{gnat_rm/the_gnat_library id121}@anchor{3e1}
+@anchor{gnat_rm/the_gnat_library gnat-traceback-g-traceb-ads}@anchor{3e1}@anchor{gnat_rm/the_gnat_library id121}@anchor{3e2}
@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{3e2}@anchor{gnat_rm/the_gnat_library id122}@anchor{3e3}
+@anchor{gnat_rm/the_gnat_library gnat-traceback-symbolic-g-trasym-ads}@anchor{3e3}@anchor{gnat_rm/the_gnat_library id122}@anchor{3e4}
@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{3e4}@anchor{gnat_rm/the_gnat_library id123}@anchor{3e5}
+@anchor{gnat_rm/the_gnat_library gnat-utf-32-g-utf-32-ads}@anchor{3e5}@anchor{gnat_rm/the_gnat_library id123}@anchor{3e6}
@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{3e6}@anchor{gnat_rm/the_gnat_library id124}@anchor{3e7}
+@anchor{gnat_rm/the_gnat_library gnat-utf-32-spelling-checker-g-u3spch-ads}@anchor{3e7}@anchor{gnat_rm/the_gnat_library id124}@anchor{3e8}
@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{3e8}@anchor{gnat_rm/the_gnat_library id125}@anchor{3e9}
+@anchor{gnat_rm/the_gnat_library gnat-wide-spelling-checker-g-wispch-ads}@anchor{3e9}@anchor{gnat_rm/the_gnat_library id125}@anchor{3ea}
@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{3ea}@anchor{gnat_rm/the_gnat_library id126}@anchor{3eb}
+@anchor{gnat_rm/the_gnat_library gnat-wide-string-split-g-wistsp-ads}@anchor{3eb}@anchor{gnat_rm/the_gnat_library id126}@anchor{3ec}
@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{3ec}@anchor{gnat_rm/the_gnat_library id127}@anchor{3ed}
+@anchor{gnat_rm/the_gnat_library gnat-wide-wide-spelling-checker-g-zspche-ads}@anchor{3ed}@anchor{gnat_rm/the_gnat_library id127}@anchor{3ee}
@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{3ee}@anchor{gnat_rm/the_gnat_library id128}@anchor{3ef}
+@anchor{gnat_rm/the_gnat_library gnat-wide-wide-string-split-g-zistsp-ads}@anchor{3ef}@anchor{gnat_rm/the_gnat_library id128}@anchor{3f0}
@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{3f0}@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3f1}
+@anchor{gnat_rm/the_gnat_library id129}@anchor{3f1}@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3f2}
@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{3f2}@anchor{gnat_rm/the_gnat_library interfaces-c-streams-i-cstrea-ads}@anchor{3f3}
+@anchor{gnat_rm/the_gnat_library id130}@anchor{3f3}@anchor{gnat_rm/the_gnat_library interfaces-c-streams-i-cstrea-ads}@anchor{3f4}
@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{3f4}@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3f5}
+@anchor{gnat_rm/the_gnat_library id131}@anchor{3f5}@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3f6}
@section @code{Interfaces.Packed_Decimal} (@code{i-pacdec.ads})
mainframes.
@node Interfaces VxWorks i-vxwork ads,Interfaces VxWorks IO i-vxwoio ads,Interfaces Packed_Decimal i-pacdec ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id132}@anchor{3f6}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3f7}
+@anchor{gnat_rm/the_gnat_library id132}@anchor{3f7}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3f8}
@section @code{Interfaces.VxWorks} (@code{i-vxwork.ads})
This package provides a limited binding to the VxWorks API.
@node Interfaces VxWorks IO i-vxwoio ads,System Address_Image s-addima ads,Interfaces VxWorks i-vxwork ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id133}@anchor{3f8}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3f9}
+@anchor{gnat_rm/the_gnat_library id133}@anchor{3f9}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3fa}
@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 id134}@anchor{3fa}@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3fb}
+@anchor{gnat_rm/the_gnat_library id134}@anchor{3fb}@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3fc}
@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 id135}@anchor{3fc}@anchor{gnat_rm/the_gnat_library system-assertions-s-assert-ads}@anchor{3fd}
+@anchor{gnat_rm/the_gnat_library id135}@anchor{3fd}@anchor{gnat_rm/the_gnat_library system-assertions-s-assert-ads}@anchor{3fe}
@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 id136}@anchor{3fe}@anchor{gnat_rm/the_gnat_library system-atomic-counters-s-atocou-ads}@anchor{3ff}
+@anchor{gnat_rm/the_gnat_library id136}@anchor{3ff}@anchor{gnat_rm/the_gnat_library system-atomic-counters-s-atocou-ads}@anchor{400}
@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 id137}@anchor{400}@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{401}
+@anchor{gnat_rm/the_gnat_library id137}@anchor{401}@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{402}
@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 id138}@anchor{402}@anchor{gnat_rm/the_gnat_library system-multiprocessors-s-multip-ads}@anchor{403}
+@anchor{gnat_rm/the_gnat_library id138}@anchor{403}@anchor{gnat_rm/the_gnat_library system-multiprocessors-s-multip-ads}@anchor{404}
@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 id139}@anchor{404}@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{405}
+@anchor{gnat_rm/the_gnat_library id139}@anchor{405}@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{406}
@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 id140}@anchor{406}@anchor{gnat_rm/the_gnat_library system-partition-interface-s-parint-ads}@anchor{407}
+@anchor{gnat_rm/the_gnat_library id140}@anchor{407}@anchor{gnat_rm/the_gnat_library system-partition-interface-s-parint-ads}@anchor{408}
@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 id141}@anchor{408}@anchor{gnat_rm/the_gnat_library system-pool-global-s-pooglo-ads}@anchor{409}
+@anchor{gnat_rm/the_gnat_library id141}@anchor{409}@anchor{gnat_rm/the_gnat_library system-pool-global-s-pooglo-ads}@anchor{40a}
@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 id142}@anchor{40a}@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{40b}
+@anchor{gnat_rm/the_gnat_library id142}@anchor{40b}@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{40c}
@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 id143}@anchor{40c}@anchor{gnat_rm/the_gnat_library system-restrictions-s-restri-ads}@anchor{40d}
+@anchor{gnat_rm/the_gnat_library id143}@anchor{40d}@anchor{gnat_rm/the_gnat_library system-restrictions-s-restri-ads}@anchor{40e}
@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 id144}@anchor{40e}@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{40f}
+@anchor{gnat_rm/the_gnat_library id144}@anchor{40f}@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{410}
@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 id145}@anchor{410}@anchor{gnat_rm/the_gnat_library system-strings-stream-ops-s-ststop-ads}@anchor{411}
+@anchor{gnat_rm/the_gnat_library id145}@anchor{411}@anchor{gnat_rm/the_gnat_library system-strings-stream-ops-s-ststop-ads}@anchor{412}
@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 id146}@anchor{412}@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{413}
+@anchor{gnat_rm/the_gnat_library id146}@anchor{413}@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{414}
@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 id147}@anchor{414}@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{415}
+@anchor{gnat_rm/the_gnat_library id147}@anchor{415}@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{416}
@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 id148}@anchor{416}@anchor{gnat_rm/the_gnat_library system-wch-con-s-wchcon-ads}@anchor{417}
+@anchor{gnat_rm/the_gnat_library id148}@anchor{417}@anchor{gnat_rm/the_gnat_library system-wch-con-s-wchcon-ads}@anchor{418}
@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{418}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{419}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-other-languages}@anchor{11}
+@anchor{gnat_rm/interfacing_to_other_languages doc}@anchor{419}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{41a}@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{41a}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{41b}
+@anchor{gnat_rm/interfacing_to_other_languages id2}@anchor{41b}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{41c}
@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{49}@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{41c}
+@anchor{gnat_rm/interfacing_to_other_languages id3}@anchor{4a}@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{41d}
@section Interfacing to C++
object at a given @code{System.Address}.
@node Interfacing to COBOL,Interfacing to Fortran,Interfacing to C++,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id5}@anchor{41d}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-cobol}@anchor{41e}
+@anchor{gnat_rm/interfacing_to_other_languages id5}@anchor{41e}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-cobol}@anchor{41f}
@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{41f}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-fortran}@anchor{420}
+@anchor{gnat_rm/interfacing_to_other_languages id6}@anchor{420}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-fortran}@anchor{421}
@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{421}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{422}
+@anchor{gnat_rm/interfacing_to_other_languages id7}@anchor{422}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{423}
@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{423}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{424}@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}
+@anchor{gnat_rm/specialized_needs_annexes doc}@anchor{424}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{425}@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}
@chapter Specialized Needs Annexes
@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{425}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{426}@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{426}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{427}@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{427}@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{180}
+@anchor{gnat_rm/implementation_of_specific_ada_features id2}@anchor{428}@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{181}
@section Machine Code Insertions
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{428}@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{429}
+@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-tasking}@anchor{429}@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{42a}
@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{42a}@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{42b}
+@anchor{gnat_rm/implementation_of_specific_ada_features id4}@anchor{42b}@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{42c}
@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{42c}@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{42d}
+@anchor{gnat_rm/implementation_of_specific_ada_features ensuring-compliance-with-the-real-time-annex}@anchor{42d}@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{42e}
@subsection Ensuring Compliance with the Real-Time Annex
@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{42e}
+@anchor{gnat_rm/implementation_of_specific_ada_features support-for-locking-policies}@anchor{42f}
@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{42f}@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{430}
+@anchor{gnat_rm/implementation_of_specific_ada_features gnat-implementation-of-shared-passive-packages}@anchor{430}@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{431}
@section GNAT Implementation of Shared Passive Packages
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{431}@anchor{gnat_rm/implementation_of_specific_ada_features id7}@anchor{432}
+@anchor{gnat_rm/implementation_of_specific_ada_features code-generation-for-array-aggregates}@anchor{432}@anchor{gnat_rm/implementation_of_specific_ada_features id7}@anchor{433}
@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{433}@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{434}
+@anchor{gnat_rm/implementation_of_specific_ada_features id8}@anchor{434}@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{435}
@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{435}@anchor{gnat_rm/implementation_of_specific_ada_features id9}@anchor{436}
+@anchor{gnat_rm/implementation_of_specific_ada_features constant-aggregates-with-unconstrained-nominal-types}@anchor{436}@anchor{gnat_rm/implementation_of_specific_ada_features id9}@anchor{437}
@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{437}@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{438}
+@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-static-bounds}@anchor{438}@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{439}
@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{439}@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{43a}
+@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-with-nonstatic-bounds}@anchor{43a}@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{43b}
@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{43b}@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{43c}
+@anchor{gnat_rm/implementation_of_specific_ada_features aggregates-in-assignment-statements}@anchor{43c}@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{43d}
@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{43d}@anchor{gnat_rm/implementation_of_specific_ada_features the-size-of-discriminated-records-with-default-discriminants}@anchor{43e}
+@anchor{gnat_rm/implementation_of_specific_ada_features id13}@anchor{43e}@anchor{gnat_rm/implementation_of_specific_ada_features the-size-of-discriminated-records-with-default-discriminants}@anchor{43f}
@section The Size of Discriminated Records with Default Discriminants
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{43f}@anchor{gnat_rm/implementation_of_specific_ada_features image-values-for-nonscalar-types}@anchor{440}
+@anchor{gnat_rm/implementation_of_specific_ada_features id14}@anchor{440}@anchor{gnat_rm/implementation_of_specific_ada_features image-values-for-nonscalar-types}@anchor{441}
@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{441}@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{442}
+@anchor{gnat_rm/implementation_of_specific_ada_features id15}@anchor{442}@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{443}
@section Strict Conformance to the Ada Reference Manual
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{443}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{444}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}
+@node Implementation of Ada 2012 Features,Implementation of Ada 2022 Features,Implementation of Specific Ada Features,Top
+@anchor{gnat_rm/implementation_of_ada_2012_features doc}@anchor{444}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{445}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}
@chapter Implementation of Ada 2012 Features
Each feature corresponds to an Ada Issue (‘AI’) approved by the Ada
standardization group (ISO/IEC JTC1/SC22/WG9) for inclusion in Ada 2012.
-The features are ordered based on the relevant sections of the Ada
-Reference Manual (“RM”). When a given AI relates to multiple points
-in the RM, the earliest is used.
-A complete description of the AIs may be found in
+The section “RM references” lists all modified paragraphs in the Ada 2005 reference manual. The details of each modification as well as a complete description of the AIs may be found in
@indicateurl{http://www.ada-auth.org/ai05-summary.html}.
@geindex AI-0002 (Ada 2012 feature)
RM References: 4.03.01 (17)
@end itemize
-@node GNAT language extensions,Security Hardening Features,Implementation of Ada 2012 Features,Top
-@anchor{gnat_rm/gnat_language_extensions doc}@anchor{445}@anchor{gnat_rm/gnat_language_extensions gnat-language-extensions}@anchor{446}@anchor{gnat_rm/gnat_language_extensions id1}@anchor{447}
+@node Implementation of Ada 2022 Features,GNAT language extensions,Implementation of Ada 2012 Features,Top
+@anchor{gnat_rm/implementation_of_ada_2022_features doc}@anchor{446}@anchor{gnat_rm/implementation_of_ada_2022_features id1}@anchor{447}@anchor{gnat_rm/implementation_of_ada_2022_features implementation-of-ada-2022-features}@anchor{15}
+@chapter Implementation of Ada 2022 Features
+
+
+@geindex Ada 2022 implementation status
+
+@geindex -gnat22 option (gcc)
+
+@geindex pragma Ada_2022
+
+@geindex configuration pragma Ada_2022
+
+@geindex Ada_2022 configuration pragma
+
+This chapter contains a complete list of Ada 2022 features that have been
+implemented. Generally, these features are only available if the `-gnat22' (Ada 2022 features enabled) option is set, or if the configuration pragma @code{Ada_2022} is used.
+
+However, new pragmas, attributes, and restrictions are unconditionally available, since the Ada standard allows the addition of new pragmas, attributes, and restrictions (there are exceptions, which are
+documented in the individual descriptions), and also certain packages
+were made available in earlier versions of Ada.
+
+An ISO date (YYYY-MM-DD) appears in parentheses on the description line.
+This date shows the implementation date of the feature. Any wavefront
+subsequent to this date will contain the indicated feature, as will any
+subsequent releases. A date of 0000-00-00 means that GNAT has always
+implemented the feature, or implemented it as soon as it appeared as a
+binding interpretation.
+
+Each feature corresponds to an Ada Issue (‘AI’) approved by the Ada
+standardization group (ISO/IEC JTC1/SC22/WG9) for inclusion in Ada 2022.
+
+The section “RM references” lists all modified paragraphs in the Ada 2012 reference manual. The details of each modification as well as a complete description of the AIs may be found in
+@indicateurl{http://www.ada-auth.org/AI12-SUMMARY.HTML}.
+
+@geindex AI12-0001 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0001 Independence and Representation clauses for atomic objects (2019-11-27)'
+
+The compiler accepts packing clauses in all cases, even if they have effectively no influence on the layout. Types, where packing is essentially infeasible are, for instance atomic, aliased and by-reference types.
+
+RM references: 13.02 (6.1/2) 13.02 (7) 13.02 (8) 13.02 (9/3) C.06 (8.1/3)
+C.06 (10) C.06 (11) C.06 (21) C.06 (24)
+@end itemize
+
+@geindex AI12-0003 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0003 Specifying the standard storage pool (2020-06-25)'
+
+Allows the standard storage pool being specified with a @code{Default_Storage_Pool} pragma or aspect.
+
+RM references: 8.02 (11) 13.11.03 (1/3) 13.11.03 (3.1/3) 13.11.03 (4/3)
+13.11.03 (4.1/3) 13.11.03 (5/3) 13.11.03 (6.2/3) 13.11.03
+(6.3/3)
+@end itemize
+
+@geindex AI12-0004 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0004 Normalization and allowed characters for identifiers (2020-06-11)'
+
+This AI clarifies that Ada identifiers containing characters which are not
+allowed in Normalization Form KC are illegal.
+
+RM references: 2.01 (4.1/3) 2.03 (4/3) A.03.02 (4/3) A.03.02 (32.5/3)
+A.03.05 (18/3) A.03.05 (51/3)
+@end itemize
+
+@geindex AI12-0020 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0020 ‘Image for all types (2020-03-30)'
+
+Put_Image prints out a human-readable representation of an object. The
+functionality in Ada2022 RM is fully implemented except the support for
+types in the @code{Remote_Types} packages.
+
+RM references: 4.10 (0) 3.05 (27.1/2) 3.05 (27.2/2) 3.05 (27.3/2) 3.05
+(27.4/2) 3.05 (27.5/2) 3.05 (27.6/2) 3.05 (27.7/2) 3.05 (28) 3.05
+(29) 3.05 (30/3) 3.05 (31) 3.05 (32) 3.05 (33/3) 3.05 (37.1/2)
+3.05 (38) 3.05 (39) 3.05 (43/3) 3.05 (55/3) 3.05 (55.1/5) 3.05
+(55.2/4) 3.05 (55.3/4) 3.05 (55.4/4) 3.05 (59) H.04 (23) H.04 (23.8/2)
+@end itemize
+
+@geindex AI12-0022 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0022 Raise_Expressions (2013-01-27)'
+
+This feature allows you to write “raise NAME [with STRING]” in an
+expression to rise given exception. It is particularly useful in the case of
+assertions such as preconditions allowing to specify which exception a
+precondition raises if it fails.
+
+RM references: 4.04 (3/3) 11.02 (6) 11.03 (2/2) 11.03 (3) 11.03 (3.1/2)
+11.03 (4/2) 11.04.01 (10.1/3)
+@end itemize
+
+@geindex AI12-0027 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0027 Access values should never designate unaliased components (2020-06-15)'
+
+AI12-0027 adds a requirement for a value conversion that converts from an array of unaliased components to an array of aliased components to make a copy. It defines such conversions to have a local accessibility, effectively preventing the possibility of unsafe accesses to unaliased components.
+
+RM references: 4.06 (24.17/3) 4.06 (24.21/2) 4.06 (58) 6.02 (10/3) 3.10.02 (10/3)
+@end itemize
+
+@geindex AI12-0028 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0028 Import of variadic C functions (2020-03-03)'
+
+Ada programs can now properly call variadic C functions by means of the
+conventions C_Variadic_<n>, for small integer values <n>.
+
+RM references: B.03 (1/3) B.03 (60.15/3) B.03 (75)
+@end itemize
+
+@geindex AI12-0030 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0030 Formal derived types and stream attribute availability (2020-08-21)'
+
+Corner cases involving streaming operations for formal derived limited types
+that are now defined to raise Program_Error. Before, behavior in these cases
+was undefined. Stream attribute availability is more precisely computed in cases where a derived type declaration occurs ahead of a streaming attribute specification for the parent type.
+
+RM references: 12.05.01 (21/3) 13.13.02 (49/2)
+@end itemize
+
+@geindex AI12-0031 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0031 All_Calls_Remote and indirect calls (0000-00-00)'
+
+Remote indirect calls (i.e., calls through a remote access-to-subprogram type)
+behave the same as remote direct calls.
+
+RM references: E.02.03 (19/3)
+@end itemize
+
+@geindex AI12-0032 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0032 Questions on ‘Old (2020-04-24)'
+
+AI12-0032 resolves several issues related to the ‘Old attribute. The GNAT
+compiler already implemented what the AI requires in most of those cases, but two having to do with static and dynamic checking of the accessibility level of the constant object implicitly declared for an ‘Old attribute reference were not yet implemented. Accessibility checking for these constants is now implemented as defined in the AI.
+
+RM references: 4.01.03 (9/3) 6.01.01 (22/3) 6.01.01 (26/3) 6.01.01 (35/3)
+@end itemize
+
+@geindex AI12-0033 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0033 Sets of CPUs when defining dispatching domains (0000-00-00)'
+
+The set of CPUs associated with a dispatching domain is no longer required
+to be a contiguous range of CPU values.
+
+RM references: D.16.01 (7/3) D.16.01 (9/3) D.16.01 (20/3) D.16.01 (23/3)
+D.16.01 (24/3) D.16.01 (26/3)
+@end itemize
+
+@geindex AI12-0035 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0035 Accessibility checks for indefinite elements of containers (0000-00-00)'
+
+If the element type for an instance of one of the indefinite container generics has an access discriminant, then accessibility checks (at run-time) prevent inserting a value into a container object if the value’s discriminant designates an object that is too short-lived (that is, if the designated object has an accessibility level that is deeper than that of the instance). Without this check, dangling references would be possible. GNAT handled this correctly already before this AI was issued.
+
+RM references: A.18 (5/3) A.18.11 (8/2) A.18.12 (7/2) A.18.13 (8/2)
+A.18.14 (8/2) A.18.15 (4/2) A.18.16 (4/2) A.18.17 (7/3) A.18.18
+(39/3) A.18.18 (47/3)
+@end itemize
+
+@geindex AI12-0036 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0036 The actual for an untagged formal derived type cannot be tagged (2019-10-21)'
+
+AI12-0036 is a binding interpretation that adds the following legality rule:
+The actual type for a formal derived type shall be tagged if and only if the
+formal derived type is a private extension. The check is implemented for all Ada dialects, not just Ada 2022.
+
+RM references: 12.05.01 (5.1/3)
+@end itemize
+
+@geindex AI12-0037 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0037 New types in Ada.Locales can’t be converted to/from strings (2016-09-10)'
+
+The type definitions for Language_Code and Country_Code are now using dynamic
+predicates.
+
+RM references: A.19 (4/3)
+@end itemize
+
+@geindex AI12-0039 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0039 Ambiguity in syntax for membership expression removed (0000-00-00)'
+
+An ambiguity in the syntax for membership expressions was resolved. For example, “A in B and C” can be parsed in only one way because of this AI.
+
+RM references: 4.04 (3/3) 4.04 (3.2/3) 4.05.02 (3.1/3) 4.05.02 (4) 4.05.02
+(4.1/3) 4.05.02 (27/3) 4.05.02 (27.1/3) 4.05.02 (28.1/3) 4.05.02
+(28.2/3) 4.05.02 (29/3) 4.05.02 (30/3) 4.05.02 (30.1/3) 4.05.02
+(30.2/3) 4.05.02 (30.3/3) 4.09 (11/3) 4.09 (32.6/3) 8.06 (27.1/3)
+3.02.04 (17/3)
+@end itemize
+
+@geindex AI12-0040 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0040 Resolving the selecting_expression of a case_expression (0000-00-00)'
+
+The definition of “complete context” is corrected so that selectors of case expressions
+and of case statements are treated uniformly.
+
+RM references: 8.06 (9)
+@end itemize
+
+@geindex AI12-0041 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0041 Type_Invariant’Class for interface types (2016-12-12)'
+
+Subprogram calls within class-wide type invariant expressions get resolved
+as primitive operations instead of being dynamically dispatched.
+
+RM references: 7.03.02 (1/3) 7.03.02 (3/3)
+@end itemize
+
+@geindex AI12-0042 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0042 Type invariant checking rules (2020-06-05)'
+
+AI12-0042 adds rules for type invariants.
+Specifically, when inheriting a private dispatching operation when the ancestor operation is visible at the point of the type extension, the operation must be abstract or else overridden. In addition, for a class-wide view conversion from an object of a specific type T to which a type invariant applies, an invariant check is performed when the conversion is within the immediate scope of T.
+
+RM references: 7.03.02 (6/3) 7.03.02 (17/3) 7.03.02 (18/3) 7.03.02 (19/3)
+7.03.02 (20/3)
+@end itemize
+
+@geindex AI12-0043 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0043 Details of the storage pool used when Storage_Size is specified (0000-00-00)'
+
+Clarify that a Storage_Size specification for an access type specifies both an upper bound and a lower bound (not just a lower bound) of the amount of storage allowed for allocated objects.
+
+RM references: 13.11 (18)
+@end itemize
+
+@geindex AI12-0044 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0044 Calling visible functions from type invariant expressions (2020-05-11)'
+
+AI05-0289-1 extends invariant checking to @cite{in} parameters. However, this makes
+it impossible to call a public function of the type from an invariant
+expression, as that public function will attempt to check the invariant,
+resulting in an infinite recursion.
+
+This AI specifies, that type-invariant checking is performed on parameters
+of mode @cite{in} upon return from procedure calls, but not of @cite{in}-mode
+parameters in functions.
+
+RM references: 7.03.02 (19/3)
+@end itemize
+
+@geindex AI12-0045 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0045 Pre- and Postconditions are allowed on generic subprograms (2015-03-17)'
+
+The SPARK toolset now supports contracts on generic subprograms, packages and
+their respective bodies.
+
+RM references: 6.01.01 (1/3)
+@end itemize
+
+@geindex AI12-0046 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0046 Enforcing legality for anonymous access components in record aggregates (0000-00-00)'
+
+For a record aggregate of the form (X | Y => ….), any relevant legality rules are checked for both for X and Y.
+
+For example,
+
+@example
+X : aliased constant String := ... ;
+type R is record
+ F1 : access constant String;
+ F2 : access String;
+end record;
+Obj : R := (F1 | F2 => X'Access); -- ok for F1, but illegal for F2
+@end example
+
+RM references: 4.03.01 (16/3)
+@end itemize
+
+@geindex AI12-0047 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0047 Generalized iterators and discriminant-dependent components (0000-00-00)'
+
+Iterating over the elements of an array is subject to the same legality checks as renaming the array. For example, if an assignment to an enclosing discriminated object could cause an array object to cease to exist then we don’t allow renaming the array. So it is similarly not allowed to iterate over the elements of such an array.
+
+RM references: 5.05.02 (6/3)
+@end itemize
+
+@geindex AI12-0048 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0048 Default behavior of tasks on a multiprocessor with a specified dispatching policy (0000-00-00)'
+
+Clarify that if the user does not impose requirements about what CPUs a given task might execute on, then the implementation does not get to impose such requirements. This avoids potential problems with priority inversion.
+
+RM references: D.16.01 (30/3)
+@end itemize
+
+@geindex AI12-0049 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0049 Invariants need to be checked on the initialization of deferred constants (0000-00-00)'
+
+Invariant checking for deferred constants (and subcomponents thereof) is performed. Corrects a clear oversight in the previous RM wording.
+
+RM references: 7.03.02 (10/3)
+@end itemize
+
+@geindex AI12-0050 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0050 Conformance of quantified expressions (2016-07-22)'
+
+Compiler rejects a subprogram body when an expression for a boolean formal
+parameter includes a quantified expression, and the subprogram declaration
+contains a textual copy of the same.
+
+RM references: 6.03.01 (20) 6.03.01 (21)
+@end itemize
+
+@geindex AI12-0051 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0051 The Priority aspect can be specified when Attach_Handler is specified (0000-00-00)'
+
+Previous RM wording had two contradictory rules for determining (in some cases) the priority of a protected subprogram that is attached to an interrupt. The AI clarifies which one of the rules takes precedence.
+
+RM references: D.03 (10/3)
+@end itemize
+
+@geindex AI12-0052 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0052 Implicit objects are considered overlapping (0000-00-00)'
+
+Clarify that the rules about unsynchronized concurrent access apply as one would expect in the case of predefined routines that access Text_IO’s default input and default output files. There was no compiler changes needed to implement this.
+
+RM references: A (3/2) A.10.03 (21)
+@end itemize
+
+@geindex AI12-0054-2 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0054-2 Aspect Predicate_Failure (0000-00-00)'
+
+New aspect Predicate_Failure is defined. A solution for the problem that a predicate like
+
+@example
+subtype Open_File is File with Dynamic_Predicate =\> Is_Open (Open_File) or else (raise File_Not_Open);
+@end example
+
+does the wrong thing in the case of a membership test.
+
+RM references: 3.02.04 (14/3) 3.02.04 (31/3) 3.02.04 (35/3)
+@end itemize
+
+@geindex AI12-0055 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0055 All properties of a usage profile are defined by pragmas (2020-06-09)'
+
+AI12-0055 allows the use of the No_Dynamic_CPU_Assignment restriction in pragmas Restrictions and Restrictions_Warnings.
+
+RM references: D.07 (10/3) D.13 (6/3) D.13 (8/3) D.13 (10/3)
+@end itemize
+
+@geindex AI12-0059 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0059 Object_Size attribute (2019-12-02)'
+
+AI12-0059 brings GNAT-defined attribute Object_Size to Ada standard
+and clarifies its semantics. Given that the attribute already existed in
+GNAT compiler, the feature is supported for all language versions.
+
+RM references: 4.09.01 (2/3) 13.01 (14) 13.01 (23) 13.03 (9/3) 13.03
+(50/2) 13.03 (51) 13.03 (52) 13.03 (58)
+@end itemize
+
+@geindex AI12-0061 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0061 Iterated component associations in array aggregates (2016-09-01)'
+
+Ada issue AI12-061 introduces a new construct in array aggregates allowing
+component associations to be parameterized by a loop variable, for example:
+
+@example
+Array (1 .. 10) of Integer :=
+ (for I in 1 .. 10 => I ** 2);
+type Matrix is
+array
+ (Positive range <>, Positive range <>) of Float;
+G : constant Matrix
+:=
+ (for I in 1 .. 4 =>
+ (for J in 1 .. 4 =>
+ (if I=J then
+1.0 else 0.0))); -- Identity matrix
+@end example
+
+The expression in such an association can also be a function that returns a
+limited type, and the range can be specified by the ‘others’ choice.
+
+RM references: 4.03.03 (5/2) 4.03.03 (6) 4.03.03 (17/3) 4.03.03 (20)
+4.03.03 (23.1/4) 4.03.03 (32/3) 4.03.03 (43) 3.01 (6/3) 3.03 (6)
+3.03 (18.1/3) 3.03.01 (23/3) 5.05 (6) 8.01 (2.1/4)
+@end itemize
+
+@geindex AI12-0062 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0062 Raise exception with failing string function (0000-00-00)'
+
+Clarify that if raising exception E1 is accompanied with a String-valued
+expression whose evaluation raises exception E2, then E2 is what gets propagated.
+
+RM references: 11.03 (4/2)
+@end itemize
+
+@geindex AI12-0065 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0065 Descendants of incomplete views (0000-00-00)'
+
+This AI is a clarification of potentially confusing wording. GNAT correctly handles the example given in AARM 7.3.1(5.b-5.d), which illustrates the topic of this AI.
+
+RM references: 7.03.01 (5.2/3)
+@end itemize
+
+@geindex AI12-0067 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0067 Accessibility level of explicitly aliased parameters of procedures and entries (0000-00-00)'
+
+The AI fixes a case where the intent was fairly obvious but the RM wording failed to mention a case (with the result that the accessibility level of an explicitly aliased parameter of a procedure or entry was undefined even though the intent was clear).
+
+RM references: 3.10.02 (7/3)
+@end itemize
+
+@geindex AI12-0068 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0068 Predicates and the current instance of a subtype (2020-05-06)'
+
+AI12-0068 is a binding interpretation that defines the current instance name in a type or subtype aspect to be a value rather than an object. This affects
+attributes whose prefix is a current instance in predicates, type invariants, and @code{Default_Initial_Condition} aspects. In particular, in the case of the @code{Constrained} attribute the value will always be True, and formerly legal attributes that require an object as their prefix (such as @code{Size}, @code{Access}, @code{Address}, etc.) are illegal when applied to a current instance in type and subtype aspects.
+
+RM references: 8.06 (17/3)
+@end itemize
+
+@geindex AI12-0069 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0069 Inconsistency in Tree container definition (0000-00-00)'
+
+The description of how iteration over a Tree container’s elements was contradictory in some cases regarding whether a cursor designating the Root node is included in the iteration. This contradiction was resolved. In the “!ACATS Test” section of the AI, it says that if an implementation were to get this wrong then almost any attempt to iterate over any tree would fail at runtime.
+
+RM references: A.18.10 (153/3) A.18.10 (155/3) A.18.10 (157/3) A.18.10 (159/3)
+@end itemize
+
+@geindex AI12-0070 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0070 9.3(2) does not work for anonymous access types (0000-00-00)'
+
+The RM contained some old wording about the master of an allocated object that only made sense for named access types. The AI clarifies the wording to clearly state the scope of validity and ensures that the paragraph does not contradict 3.10.2’s rules for anonymous access types.
+
+RM references: 3.10.02 (13.1/3) 9.03 (2)
+@end itemize
+
+@geindex AI12-0071 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0071 Order of evaluation when multiple predicates apply (2015-08-10)'
+
+AI12-0071 specifies the semantics of multiple/inherited predicates on a
+single subtype.
+
+RM references: 3.02.04 (4/3) 3.02.04 (6/3) 3.02.04 (30/3) 3.02.04 (31/3)
+3.02.04 (32/3) 3.02.04 (33/3) 3.02.04 (35/3) 3.05.05 (7.1/3)
+3.05.05 (7.2/3) 3.05.05 (7.3/3) 3.08.01 (10.1/3) 3.08.01 (15/3)
+4.05.02 (29/3) 4.05.02 (30/3) 4.06 (51/3) 4.09.01 (10/3) 5.04
+(7/3) 5.05 (9/3) 13.09.02 (3/3) 13.09.02 (12)
+@end itemize
+
+@geindex AI12-0072 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0072 Missing rules for Discard_Names aspect (0000-00-00)'
+
+Clarify that Discard_Names is an aspect, not just a pragma.
+
+RM references: C.05 (1) C.05 (5) C.05 (7/2) C.05 (8)
+@end itemize
+
+@geindex AI12-0073 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0073 Synchronous Barriers are not allowed with Ravenscar (2020-02-24)'
+
+Ada 2022 adds (as a binding interpretation) a @code{No_Dependence =>
+Ada.Synchronous_Barriers} restriction to the Ravenscar profile.
+
+RM references: D.13 (6/3)
+@end itemize
+
+@geindex AI12-0074 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0074 View conversions and out parameters passed by copy (2020-03-26)'
+
+This Ada 2022 AI makes illegal some cases of out parameters whose type has a
+@code{Default_Value} aspect.
+
+RM references: 4.06 (56) 6.04.01 (6.25/3) 6.04.01 (13.1/3)
+@end itemize
+
+@geindex AI12-0075 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0075 Static expression functions (2020-04-13)'
+
+Ada 2022 defines a new aspect @code{Static} that can be specified on expression
+functions. Such an expression function can be called in contexts requiring static expressions when the actual parameters are all static, allowing for greater abstraction in complex static expressions.
+
+RM references: 4.09 (21) 6.08 (3/4) 6.08 (5/4) 6.08 (6/4) 7.03.02 (8.2/5)
+7.03.02 (15/4) 7.03.02 (16/4) 7.03.02 (17/4) 7.03.02 (19/4)
+7.03.02 (20/5)
+@end itemize
+
+@geindex AI12-0076 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0076 Variable state in pure packages (0000-00-00)'
+
+Defines an obscure constant-modifying construct to be erroneous. The issue is that the current instance of a type is a variable object, so the following is legal:
+
+@example
+ type T;
+ type T_Ref (Access_To_Variable : access T) is null record;
+ type T is limited record
+ Self : T_Ref (T'Access);
+ Int : Integer;
+ end record;
+
+ Obj : constant T := (Self => <>, Int => 123);
+begin
+ Obj.Self.Access_To_Variable.Int := 456; -- modifying a component of a constant
+@end example
+
+In cases where constancy is really needed (e.g., for an object declared in a Pure context), such a case needs to be erroneous.
+
+RM references: 10.02.01 (17/3) E.02.02 (17/2)
+@end itemize
+
+@geindex AI12-0077 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0077 Has_Same_Storage on objects of size zero (2020-03-30)'
+
+This binding interpretation requires the Has_Same_Storage attribute
+to return always @cite{false} for objects that have a size of zero.
+
+RM references: 13.03 (73.4/3)
+@end itemize
+
+@geindex AI12-0078 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0078 Definition of node for tree container is confusing (0000-00-00)'
+
+Clarifies the expected behavior in processing tree containers.
+
+RM references: A.18.10 (2/3) A.18.10 (3/3)
+@end itemize
+
+@geindex AI12-0081 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0081 Real-time aspects need to specify when they are evaluated (0000-00-00)'
+
+Clarify the point at which Priority and Interrupt_Priority aspect expressions are evaluated.
+
+RM references: D.01 (17/3) D.16 (9/3)
+@end itemize
+
+@geindex AI12-0084 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0084 Box expressions in array aggregates (2014-12-15)'
+
+This AI addresses an issue where compiler used to fail to initialize
+components of a multidimensional aggregates with box initialization when
+scalar components have a specified default value. The AI clarifies that
+in an array aggregate with box (i.e., @code{<>}) component values, the
+@code{Default_Component_Value} of the array type (if any) should not be ignored.
+
+RM references: 4.03.03 (23.1/2)
+@end itemize
+
+@geindex AI12-0085 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0085 Missing aspect cases for Remote_Types (0000-00-00)'
+
+A distributed systems annex (Annex E) clarification. Aspect specifications
+that are forbidden using attribute definition clause syntax are also forbidden
+using aspect_specification syntax.
+
+RM references: E.02.02 (17/2)
+@end itemize
+
+@geindex AI12-0086 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0086 Aggregates and variant parts (2019-08-14)'
+
+In Ada 2012, a discriminant value that governs an active variant part in an
+aggregate had to be static. AI12-0086 relaxes this restriction: If the subtype of the discriminant value is a static subtype all of whose values select the same variant, then the expression for the discriminant is allowed to be nonstatic.
+
+RM references: 4.03.01 (17/3) 4.03.01 (19/3)
+@end itemize
+
+@geindex AI12-0088 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0088 UTF_Encoding.Conversions and overlong characters on input (0000-00-00)'
+
+Clarify that overlong characters are acceptable on input even if we never generate them as output.
+
+RM references: A.04.11 (54/3) A.04.11 (55/3)
+@end itemize
+
+@geindex AI12-0089 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0089 Accessibility rules need to take into account that a generic function is not a (0000-00-00)'
+
+Fix cases in RM wording where the accessibility rules for a function failed to take into account the fact that a generic function is not a function. For example, a generic function with an explicitly aliased parameter should be able to return references to that parameter in the same ways that a (non-generic) function can. The previous wording did not allow that.
+
+RM references: 3.10.02 (7/3) 3.10.02 (19.2/3) 3.10.02 (19.3/3) 6.05 (4/3)
+@end itemize
+
+@geindex AI12-0093 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0093 Iterator with indefinite cursor (0000-00-00)'
+
+A clarification that confirms what GNAT is already doing.
+
+RM references: 5.05.02 (8/3) 5.05.02 (10/3)
+@end itemize
+
+@geindex AI12-0094 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0094 An access_definition should be a declarative region (0000-00-00)'
+
+Fixes wording omission in the RM, confirming that the behaviour of GNAT is
+correct.
+
+RM references: 8.03 (2) 8.03 (26/3)
+@end itemize
+
+@geindex AI12-0095 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0095 Generic formal types and constrained partial views (0000-00-00)'
+
+Deciding whether an actual parameter corresponding to an explicitly aliased formal parameter is legal depends on (among other things) whether the parameter type has a constrained partial view. The AI clarifies how this compile-time checking works in the case of a generic formal type (assume the best in the spec and recheck each instance, assume the worst in a generic body).
+
+RM references: 3.10.02 (27.2/3) 4.06 (24.16/2) 6.04.01 (6.2/3) 12.05.01 (15)
+@end itemize
+
+@geindex AI12-0096 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0096 The exception raised when a subtype conversion fails a predicate check (0000-00-00)'
+
+Clarify that the Predicate_Failure aspect works the same in a subtype conversion as in any other context.
+
+RM references: 4.06 (57/3)
+@end itemize
+
+@geindex AI12-0097 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0097 Tag of the return object of a simple return expression (0000-00-00)'
+
+Clarify wording about the tag of a function result in the case of a simple (i.e. not extended) return statement in a function with a class-wide result type.
+
+RM references: 6.05 (8/3)
+@end itemize
+
+@geindex AI12-0098 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0098 Problematic examples for ATC (0000-00-00)'
+
+The AI clarifies reference manual examples, there is no compiler impact.
+
+RM references: 9.07.04 (13)
+@end itemize
+
+@geindex AI12-0099 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0099 Wording problems with predicates (2020-05-04)'
+
+When extending a task or protected type from an ancestor interface subtype with a predicate, a link error can occur due to the compiler failing to generate the predicate-checking function. This AI clarifies the requirement for such predicate inheritance for concurrent types.
+
+RM references: 3.02.04 (4/4) 3.02.04 (12/3) 3.02.04 (20/3)
+@end itemize
+
+@geindex AI12-0100 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0100 A qualified expression makes a predicate check (2020-02-17)'
+
+The compiler now enforces predicate checks on qualified expressions when the
+qualifying subtype imposes a predicate.
+
+RM references: 4.07 (4)
+@end itemize
+
+@geindex AI12-0101 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0101 Incompatibility of hidden untagged record equality (2019-10-31)'
+
+AI12-0101 is a binding interpretation that removes a legality rule that
+prohibited the declaration of a primitive equality function for a private type in the private part of its enclosing package (either before or after the completion of the type) when the type is completed as an untagged record type. Such declarations are now accepted in Ada 2012 and later Ada versions.
+
+As a consequence of this work, some cases where the implementation of AI05-0123 was incomplete were corrected.
+More specifically, if a user-defined equality operator is present for an untagged record type in an Ada 2012 program, that user-defined equality operator will be (correctly) executed in some difficult-to-characterize cases where the predefined component-by-component comparison was previously being (incorrectly) executed. This can arise, for example, in the case of the predefined equality operation for an enclosing composite type that has a component of the user-defined primitive equality op’s operand type.
+This correction means that the impact of this change is not limited solely to code that was previously rejected at compile time.
+
+RM references: 4.05.02 (9.8/3)
+@end itemize
+
+@geindex AI12-0102 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0102 Stream_IO.File_Type has Preelaborable_Initialization (0000-00-00)'
+
+Modifies the declaration of one type in a predefined package. GNAT’s version of @code{Ada.Streams.Stream_IO} already had this modification (the @code{Preelaborable__Initialization} pragma).
+
+RM references: A.12.01 (5)
+@end itemize
+
+@geindex AI12-0103 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0103 Expression functions that are completions in package specifications (0000-00-00)'
+
+Clarifies that expression functions that are completions do not cause “general” freeze-everybody-in-sight freezing like a subprogram body.
+
+RM references: 13.14 (3/3) 13.14 (5/3)
+@end itemize
+
+@geindex AI12-0104 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0104 Overriding an aspect is undefined (0000-00-00)'
+
+A clarification of the wording in RM, no compiler impact.
+
+RM references: 4.01.06 (4/3) 4.01.06 (17/3)
+@end itemize
+
+@geindex AI12-0105 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0105 Pre and Post are not allowed on any subprogram completion (0000-00-00)'
+
+Language-defined aspects (e.g., @code{Post}) cannot be specified as part of the completion of a subprogram declaration. Fix a hole in the RM wording to clarify that this general rule applies even in the special cases where the completion is either an expression function or a null procedure.
+
+RM references: 13.01.01 (18/3)
+@end itemize
+
+@geindex AI12-0106 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0106 Write’Class aspect (0000-00-00)'
+
+Clarify that the syntax used in an ACATS test BDD2005 for specifying a class-wide streaming aspect is correct.
+
+RM references: 13.01.01 (28/3) 13.13.02 (38/3)
+@end itemize
+
+@geindex AI12-0107 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0107 A prefixed view of a By_Protected_Procedure interface has convention protected (2020-06-05)'
+
+A prefixed view of a subprogram with aspect Synchronization set to
+By_Protected_Procedure has convention protected.
+
+RM references: 6.03.01 (10.1/2) 6.03.01 (12) 6.03.01 (13)
+@end itemize
+
+@geindex AI12-0109 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0109 Representation of untagged derived types (2019-11-12)'
+
+Ada disallows a nonconforming specification of a type-related representation
+aspect of an untagged by-reference type. The motivation for this rule is to ensure that a parent type and a later type derived from the parent agree with respect to such aspects. AI12-0109 disallows a construct that otherwise could be used to get around this rule: an aspect specification for the parent type that occurs after the declaration of the derived type.
+
+RM references: 13.01 (10/3)
+@end itemize
+
+@geindex AI12-0110 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0110 Tampering checks are performed first (2020-04-14)'
+
+AI12-0110 requires tampering checks in the containers library to be
+performed first, before any other checks.
+
+RM references: A.18.02 (97.1/3) A.18.03 (69.1/3) A.18.04 (15.1/3) A.18.07
+(14.1/3) A.18.10 (90/3) A.18.18 (35/3)
+@end itemize
+
+@geindex AI12-0112 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0112 Contracts for container operations (0000-00-00)'
+
+A representation change replacing english descriptions of contracts for
+operations on predefined container types with pre/post-conditions. No compiler
+impact.
+
+RM references: A.18.02 (99/3) 11.04.02 (23.1/3) 11.05 (23) 11.05 (26) A
+(4) A.18 (10)
+@end itemize
+
+@geindex AI12-0114 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0114 Overlapping objects designated by access parameters are not thread-safe (0000-00-00)'
+
+There are rules saying that concurrent calls to predefined subprograms don’t interfere with each other unless actual parameters overlap. The AI clarifies that such an interference is also possible if overlapping objects are reachable via access dereferencing from actual parameters of the two calls.
+
+RM references: A (3/2)
+@end itemize
+
+@geindex AI12-0116 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0116 Private types and predicates (0000-00-00)'
+
+Clarify that the same aspect cannot be specified twice for the same type. @code{Dynamic_Predicate}, for example, can be specified on either the partial view of a type or on the completion in the private part, but not on both.
+
+RM references: 13.01 (9/3) 13.01 (9.1/3)
+@end itemize
+
+@geindex AI12-0117 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0117 Restriction No_Tasks_Unassigned_To_CPU (2020-06-12)'
+
+This AI adds a restriction No_Tasks_Unassigned_To_CPU to provide safe
+use of Ravenscar.
+
+The CPU aspect is specified for the environment task. No CPU aspect is
+specified to be statically equal to @code{Not_A_Specific_CPU}. If aspect CPU
+is specified (dynamically) to the value @code{Not_A_Specific_CPU}, then
+Program_Error is raised. If Set_CPU or @code{Delay_Until_And_Set_CPU} are called
+with the CPU parameter equal to @code{Not_A_Specific_CPU}, then @code{Program_Error} is raised.
+
+RM references: D.07 (10.8/3)
+@end itemize
+
+@geindex AI12-0120 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0120 Legality and exceptions of generalized loop iteration (0000-00-00)'
+
+Clarify that the expansion-based definition of generalized loop iteration
+includes legality checking. If the expansion would be illegal (for example,
+because of passing a constant actual parameter in a call when the mode of
+the corresponding formal parameter is in-out), then the loop is illegal too.
+
+RM references: 5.05.02 (6.1/4) 5.05.02 (10/3) 5.05.02 (13/3)
+@end itemize
+
+@geindex AI12-0121 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0121 Stream-oriented aspects (0000-00-00)'
+
+Clarify that streaming-oriented aspects (e.g., Read) can be specified using
+aspect_specification syntax, not just via an attribute definition clause.
+
+RM references: 13.13.02 (38/3)
+@end itemize
+
+@geindex AI12-0124 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0124 Add Object’Image (2017-03-24)'
+
+The corrigendum of Ada 2012 extends attribute @code{'Image following} the syntax for the GNAT @code{'Img} attribute. This AI fixes a gap in the earlier implementation, which did not recognize function calls and attributes that are functions as valid object prefixes.
+
+RM references: 3.05 (55/3)
+@end itemize
+
+@geindex AI12-0125-3 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0125-3 Add @@ as an abbreviation for the LHS of an assignment (2016-11-11)'
+
+This AI introduces the use of the character ‘@@’ as an abbreviation for the left-hand side of an assignment statement, usable anywhere within the expression on the right-hand side. To use this feature the compilation flag -gnat2022 must be specified.
+
+RM references: 5.02.01 (0) 2.02 (9) 3.03 (21.1/3) 4.01 (2/3) 8.06 (9/4)
+@end itemize
+
+@geindex AI12-0127 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0127 Partial aggregate notation (2016-10-12)'
+
+This AI describes a new constructor for aggregates, in terms of an existing record or array object, and a series of component-wise modifications of its value, given by named associations for the modified components. To use this feature the compilation flag @code{-gnat2022} must be specified.
+
+RM references: 4.03 (2) 4.03 (3/2) 4.03 (4) 4.03.01 (9) 4.03.01 (15/3)
+4.03.01 (16/4) 4.03.01 (17/5) 4.03.01 (17.1/2) 4.03.03 (4) 4.03.03
+(14) 4.03.03 (17/5) 4.03.04 (0) 7.05 (2.6/2)
+@end itemize
+
+@geindex AI12-0128 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0128 Exact size access to parts of composite atomic objects (2019-11-24)'
+
+According to this AI, the compiler generates full access to atomic composite objects even if the access is only partial in the source code. To use this feature the compilation flag @code{-gnat2022} must be specified.
+
+RM references: C.06 (13.2/3) C.06 (19) C.06 (20) C.06 (22/2) C.06 (25/4)
+@end itemize
+
+@geindex AI12-0129 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0129 Make protected objects more protecting (2020-07-01)'
+
+A new aspect Exclusive_Functions has been added to the language to force the
+use of read/write locks on protected functions when needed.
+
+RM references: 9.05.01 (2) 9.05.01 (4) 9.05.01 (5) 9.05.01 (7) 9.05.03
+(15) 9.05.03 (23)
+@end itemize
+
+@geindex AI12-0130 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0130 All I/O packages should have Flush (2016-07-03)'
+
+The Flush routine has been added for the @code{Sequential_IO} and @code{Direct_IO} standard packages in the Ada 2012 COR.1:2016. The Flush routine here is equivalent to the one found in @code{Text_IO}. The @code{Flush} procedure synchronizes the external file with the internal file (by flushing any internal buffers) without closing the file.
+
+RM references: A.08.01 (10) A.08.02 (28/3) A.08.04 (10) A.10.03 (21)
+A.12.01 (28/2) A.12.01 (28.6/1)
+@end itemize
+
+@geindex AI12-0131 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0131 Inherited Pre’Class when unspecified on initial subprogram (0000-00-00)'
+
+If T1 is a tagged type with a primitive P that has no class-wide precondition,
+and if T2 is an extension of T1 which overrides the inherited primitive P, then that overriding P is not allowed to have a class-wide precondition. Allowing it would be ineffective except in corner cases where it would be confusing.
+
+RM references: 6.01.01 (17/3) 6.01.01 (18/3)
+@end itemize
+
+@geindex AI12-0132 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0132 Freezing of renames-as-body (2020-06-13)'
+
+This AI clarifies that a renames-as-body freezes the expression of any
+expression function that it renames.
+
+RM references: 13.14 (5/3)
+@end itemize
+
+@geindex AI12-0133 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0133 Type invariants and default initialized objects (0000-00-00)'
+
+Clarify that invariant checking for a default-initialized object is performed regardless of where the object is declared (in particular, even when the full view of the type is visible).
+
+RM references: 7.03.02 (10.3/3)
+@end itemize
+
+@geindex AI12-0135 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0135 Enumeration types should be eligible for convention C (0000-00-00)'
+
+Ada previously allowed but did not require supporting specifying convention C for an enumeration type. Now it is required that an implementation shall support it.
+
+RM references: B.01 (14/3) B.01 (41/3) B.03 (65)
+@end itemize
+
+@geindex AI12-0136 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0136 Language-defined packages and aspect Default_Storage_Pool (0000-00-00)'
+
+Clarify that the effect of specifying Default_Storage_Pool for an instance of a predefined generic is implementation-defined. No compiler impact.
+
+RM references: 13.11.03 (5/3)
+@end itemize
+
+@geindex AI12-0137 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0137 Incomplete views and access to class-wide types (0000-00-00)'
+
+If the designated type of an access type is incomplete when the access type is declared, then we have rules about whether we get a complete view when a value of the access type is dereferenced. Clarify that analogous rules apply if the designated type is class-wide.
+
+RM references: 3.10.01 (2.1/2)
+@end itemize
+
+@geindex AI12-0138 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0138 Iterators of formal derived types (2021-02-11)'
+
+AI12-0138 specifies the legality rules for confirming specifications of
+nonoverridable aspects. This completes the legality checks for aspect @code{Implicit_Dereference} and simplifies the checks for those aspects that are inherited operations.
+
+RM references: 13.01.01 (18/4) 13.01.01 (34/3) 4.01.05 (6/3) 4.01.06 (5/3)
+4.01.06 (6/3) 4.01.06 (7/3) 4.01.06 (8/3) 4.01.06 (9/3) 5.05.01 (11/3)
+@end itemize
+
+@geindex AI12-0140 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0140 Access to unconstrained partial view when full view is constrained (0000-00-00)'
+
+Clarify some confusion about about whether what matters when checking whether designated subtypes statically match is the view of the designated type that is currently available v.s. the view that was available when the access type was declared.
+
+RM references: 3.02 (7/2) 7.03.01 (5/1)
+@end itemize
+
+@geindex AI12-0143 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0143 Using an entry index of a family in a precondition (2022-04-05)'
+
+Ada 2022 adds the @code{Index} attribute, which allows the use of the entry family index of an entry call within preconditions and post-conditions.
+
+RM references: 6.01.01 (30/3) 9.05.04 (5/3)
+@end itemize
+
+@geindex AI12-0144 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0144 Make Discrete_Random more flexible (2020-01-31)'
+
+A new function Random with First/Last parameters is provided in the
+@code{Ada.Numerics.Discrete_Random} package.
+
+RM references: A.05.02 (20) A.05.02 (32) A.05.02 (41) A.05.02 (42)
+@end itemize
+
+@geindex AI12-0145 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0145 Pool_of_Subpool returns null when called too early (0000-00-00)'
+
+Clarify that if you ask for the pool of a subpool (by calling @code{Pool_Of_Subpool}) before @code{Set_Pool_of_Subpool} is called, then the result is null.
+
+RM references: 13.11.04 (20/3)
+@end itemize
+
+@geindex AI12-0147 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0147 Expression functions and null procedures can be declared in a protected_body (2015-03-05)'
+
+AI12-0147 specifies that null procedures and expression functions are now
+allowed in protected bodies.
+
+RM references: 9.04 (8/1)
+@end itemize
+
+@geindex AI12-0149 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0149 Type invariants are checked for functions returning access-to-type (0000-00-00)'
+
+Extend the rule saying that @code{Type_Invariant} checks are performed for access-to-T parameters (where T has a specified @code{Type_Invariant}) so that the rule also applies to function results.
+
+RM references: 7.03.02 (19.3/4)
+@end itemize
+
+@geindex AI12-0150 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0150 Class-wide type invariants and statically bound calls (0000-00-00)'
+
+The same approach used in AI12-0113 to ensure that contract-related calls associated with a call to a subprogram “match” with respect to dispatching also applies to @code{Type_Invariant} checking.
+
+RM references: 7.03.02 (3/3) 7.03.02 (5/3) 7.03.02 (9/3) 7.03.02 (22/3)
+@end itemize
+
+@geindex AI12-0154 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0154 Aspects of library units (0000-00-00)'
+
+Clarify that an aspect_specification for a library unit is equivalent to a corresponding aspect-specifying pragma.
+
+RM references: 13.01.01 (32/3)
+@end itemize
+
+@geindex AI12-0156 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0156 Use subtype_indication in generalized iterators (0000-00-00)'
+
+For iterating over an array, we already allow (but do not require) explicitly providing a subtype indication in an iterator_specification. Tee AI generalizes this to handle the case where the element type of the array is of an anonymous access type. This also allows (but does not require) explicitly naming the cursor subtype in a generalized iterator.
+The main motivation for allowing these new cases is improving readability by making it easy to infer the (sub)type of the iteration object just by looking at the loop.
+
+RM references: 5.05.02 (2/3) 5.05.02 (5/4) 5.05.02 (7/3) 3.10.02 (11.1/2)
+@end itemize
+
+@geindex AI12-0157 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0157 Missing rules for expression functions (0000-00-00)'
+
+Clarify that an expression function behaves like a single-return-statement
+function in more cases: it can return an aggregate without extra parens, the expression has an applicable index constraint, and the same accessibility rules apply in both cases.
+
+For instance, the code below is legal:
+
+@example
+subtype S is String (1 .. 10);
+function f return S is (others => '?');
+@end example
+
+RM references: 3.10.02 (19.2/4) 3.10.02 (19.3/4) 4.03.03 (11/2) 6.08 (2/3)
+6.08 (3/3) 6.08 (5/3) 6.08 (6/3) 6.08 (7/3) 7.05 (2.9/3) 13.14
+(5.1/4) 13.14 (5.2/4) 13.14 (8/3) 13.14 (10.1/3) 13.14 (10.2/3)
+13.14 (10.3/3)
+@end itemize
+
+@geindex AI12-0160 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0160 Adding an indexing aspect to an indexable container type (0000-00-00)'
+
+If the parent type of a derived type has exactly one of the two indexing aspects (that is, constant_indexing and variable_indexing) specified, then the derived type cannot have a specification for the other one.
+
+RM references: 4.01.06 (6/4) 4.01.06 (9/4) 3.06 (22.2/3)
+@end itemize
+
+@geindex AI12-0162 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0162 Memberships and Unchecked_Unions (0000-00-00)'
+
+Clarify that membership tests for unchecked_union types work consistently when
+testing membership in more than one subtype (X in AA | BB | CC) as when
+testing for one.
+
+RM references: B.03.03 (25/2)
+@end itemize
+
+@geindex AI12-0164 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0164 Max_Entry_Queue_Length aspect for entries (2019-06-11)'
+
+AI12-0164 defines pragma and aspect @code{Max_Entry_Queue_Length} in addition
+to the GNAT-specific equivalents @code{Max_Queue_Length} and @code{Max_Entry_Queue_Depth}.
+
+RM references: D.04 (16)
+@end itemize
+
+@geindex AI12-0165 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0165 Operations of class-wide types and formal abstract subprograms (2021-10-19)'
+
+Ada 2022 specifies that when the controlling type of a formal abstract
+subprogram declaration is a formal type, and the actual type is a class-wide type T’Class, the actual subprogram can be an implicitly declared subprogram corresponding to a primitive operation of type T.
+
+RM references: 12.06 (8.5/2)
+@end itemize
+
+@geindex AI12-0166 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0166 External calls to protected functions that appear to be internal calls (2016-11-15)'
+
+According to this AI, the compiler rejects a call to a protected operation when the call appears within a precondition for another protected operation.
+
+RM references: 6.01.01 (34/3) 9.05 (3/3) 9.05 (7.1/3)
+@end itemize
+
+@geindex AI12-0167 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0167 Type_Invariants and tagged-type View Conversions (0000-00-00)'
+
+This AI clarifies that no invariant check is performed in a case where an invariant-violating value is assigned to a component. This confirms the current compiler behavior.
+
+RM references: 7.03.02 (9/4)
+@end itemize
+
+@geindex AI12-0168 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0168 Freezing of generic instantiations of generics with bodies (0000-00-00)'
+
+Adjust freezing rules to be compatible with AI12-0103-1. The change confirms the current compiler behavior.
+
+RM references: 13.14 (3/4)
+@end itemize
+
+@geindex AI12-0169 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0169 Aspect specifications for entry bodies (0000-00-00)'
+
+Change syntax to allow aspect specifications for implementation-defined aspects on entry bodies. The change doesn’t influence any of the language-defined aspects and is solely required for SPARK.
+
+RM references: 9.05.02 (5)
+@end itemize
+
+@geindex AI12-0170 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0170 Abstract subprogram calls in class-wide precondition expressions (2020-07-06)'
+
+This AI specifies rules for calls to abstract functions within class-wide preconditions and postconditions.
+
+RM references: 3.09.03 (7) 6.01.01 (7/4) 6.01.01 (18/4) 6.01.01 (18.2/4)
+@end itemize
+
+@geindex AI12-0172 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0172 Raise expressions in limited contexts (2019-07-29)'
+
+The compiler has been enhanced to support the use of raise expressions in
+limited contexts.
+
+RM references: 7.05 (2.1/3)
+@end itemize
+
+@geindex AI12-0173 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0173 Expression of an extended return statement (0000-00-00)'
+
+Fix the wording related to expression of an extended return statement that was made ambiguous by changes of syntax in other AI’s. No compiler changes involved.
+
+RM references: 6.05 (3/2) 6.05 (5/3)
+@end itemize
+
+@geindex AI12-0174 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0174 Aggregates of Unchecked_Unions using named notation (0000-00-00)'
+
+In many cases, it is illegal to name a discriminant of an unchecked_union type. Relax this rule to allow the use of named notation in an aggregate of an unchecked_union type.
+
+RM references: B.03.03 (9/3)
+@end itemize
+
+@geindex AI12-0175 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0175 Preelaborable packages with address clauses (2020-03-20)'
+
+The compiler nows accepts calls to certain functions that are essentially unchecked conversions in preelaborated library units. To use this feature the compilation flag @code{-gnat2022} must be specified.
+
+RM references: 10.02.01 (7)
+@end itemize
+
+@geindex AI12-0179 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0179 Failure of postconditions of language-defined units (0000-00-00)'
+
+A clarification that expressing postconditions for predefined units via RM wording or via @code{Post} aspect specifications are equivalent. In particular, the expression in such a @code{Post} aspect specification should not yield False. No implementation changes needed.
+
+RM references: 1.01.03 (17/3) 11.04.02 (23.1/3)
+@end itemize
+
+@geindex AI12-0180 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0180 Using protected subprograms and entries within an invariant (2020-06-22)'
+
+AI12-0180 makes entries and protected subprograms directly visible within Invariant aspects of a task or protected type.
+
+RM references: 13.01.01 (12/3)
+@end itemize
+
+@geindex AI12-0181 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0181 Self-referencing representation aspects (0000-00-00)'
+
+Clarify that a name or expression which freezes an entity cannot occur in an aspect specification for that entity.
+
+RM references: 13.01 (9/4) 13.01 (9.1/4) 13.14 (19)
+@end itemize
+
+@geindex AI12-0182 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0182 Pre’Class and protected operations (0000-00-00)'
+
+Confirm that Pre’Class and Post’Class cannot be specified for a protected operation. No language change.
+
+RM references: 13.01.01 (16/3)
+@end itemize
+
+@geindex AI12-0184 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0184 Long Long C Data Types (2020-01-30)'
+
+Two new types @code{long_long} and @code{unsigned_long_long} are introduced in the package @code{Interfaces.C}.
+
+RM references: B.03 (71.3/3)
+@end itemize
+
+@geindex AI12-0185 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0185 Resolution of postcondition-specific attributes (0000-00-00)'
+
+Clarify resolution rules for @code{'Old} and @code{'Result} attribute references to match original intent.
+
+RM references: 6.01.01 (7/4) 6.01.01 (8/3) 6.01.01 (26.10/4) 6.01.01 (29/3)
+@end itemize
+
+@geindex AI12-0186 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0186 Profile freezing for the Access attribute (0000-00-00)'
+
+Clarify that the use of Some_Subprogram’Access does not freeze the profile of Some_Subprogram.
+
+RM references: 13.14 (15)
+@end itemize
+
+@geindex AI12-0187 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0187 Stable properties of abstract data types (2020-11-04)'
+
+Ada 2022 defines a new aspect, @code{Stable_Properties}, for use in
+generating additional postcondition checks for subprograms.
+
+RM references: 7.03.04 (0) 13.01.01 (4/3)
+@end itemize
+
+@geindex AI12-0191 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0191 Clarify “part” for type invariants (0000-00-00)'
+
+Clarify that for purposes of determining whether an invariant check is required for a “part” of an object, we do not look at “parts” which do not correspond to “parts” of the nominal type of the object. For example, if we have a parameter Param of a tagged type T1 (or equivalently of type T1’Class), and type T2 is an extension of T1 which declares a component Foo, and T1’Class (Param)’Tag = T2’Tag, then no invariant check is performed for Param’s Foo component (or any subcomponent thereof).
+
+RM references: 3.03 (23/5) 3.09.01 (4.1/2) 6.08 (5.8/5) 7.03.02 (8.3/5)
+7.03.02 (8.4/5) 7.03.02 (8.5/5) 7.03.02 (8.6/5) 7.03.02 (8.7/5)
+7.03.02 (8.8/5) 7.03.02 (8.9/5) 7.03.02 (8.10/5) 7.03.02 (8.11/5)
+7.03.02 (8.12/5) 7.03.02 (10.1/4) 7.03.02 (15/5) 7.03.02 (17/4)
+7.03.02 (18/4) 7.03.02 (19/4) 13.13.02 (9/3)
+@end itemize
+
+@geindex AI12-0192 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0192 “requires late initialization” and protected types (2020-03-11)'
+
+This AI clarifies that components of a protected type require late initialization when their initialization references (implicitly) the current instance of the type.
+
+RM references: 3.03.01 (8.1/2)
+@end itemize
+
+@geindex AI12-0194 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0194 Language-defined aspects and entry bodies (0000-00-00)'
+
+The AI Includes entry bodies on the list of bodies for which no language-defined aspects can be specified (although specifying an implementation-defined aspect may be allowed).
+
+A wording change, no implementation impact.
+
+RM references: 13.01.01 (17/3)
+@end itemize
+
+@geindex AI12-0195 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0195 Inheriting body but overriding precondition or postcondition (2021-08-11)'
+
+Ada 2022 specifies that if a primitive with a class-wide precondition or
+postcondition is inherited, and some primitive function called in the class-wide precondition or postcondition is overridden, then a dispatching call to the first primitive with a controlling operand that has the tag of the overriding type is required to check both the interpretation using the overriding function and the interpretation using the original overridden function.
+
+RM references: 6.01.01 (38/4)
+@end itemize
+
+@geindex AI12-0196 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0196 Concurrent access to Ada container libraries (0000-00-00)'
+
+Clarify that parallel execution of operations which use cursors to refer to different elements of the same container does not violate the rules about erroneous concurrent access in some cases. That is, if C1 and C2 are cursors that refer to different elements of some container, then it is ok to concurrently execute an operation that is passed C1 and which accesses one element of the container, with another operation (perhaps the same operation, perhaps not) that is passed C2 and which accesses another element of the container.
+
+RM references: A.18 (2/2) A.18.02 (125/2) A.18.02 (133/3) A.18.02 (135/3)
+A.18.03 (81/3) A.18.04 (36/3) A.18.07 (34/2) A.18.10 (116/3)
+@end itemize
+
+@geindex AI12-0198 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0198 Potentially unevaluated components of array aggregates (2020-05-13)'
+
+Ada 2022 enforces the detection of components that belong to a nonstatic or
+null range of index values of an array aggregate.
+
+RM references: 6.01.01 (22.1/4)
+@end itemize
+
+@geindex AI12-0199 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0199 Abstract subprogram calls in class-wide invariant expressions (0000-00-00)'
+
+Class-wide type invariants do not apply to abstract types, to avoid various
+problems. Define the notion of a “corresponding expression” for a class-wide
+type invariant, replacing references to components as appropriate, taking into
+account rules for corresponding and specified discriminants when applying them
+to a nonabstract descendant.
+
+RM references: 7.03.02 (5/4) 7.03.02 (8/3)
+@end itemize
+
+@geindex AI12-0201 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0201 Missing operations of static string types (2020-02-25)'
+
+Relational operators and type conversions of static string types are now static in Ada 2022.
+
+RM references: 4.09 (9) 4.09 (19) 4.09 (20) 4.09 (24)
+@end itemize
+
+@geindex AI12-0203 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0203 Overriding a nonoverridable aspect (0000-00-00)'
+
+A corner case wording clarification that has no impact on compilers.
+
+RM references: 4.01.05 (5.1/4) 4.01.05 (7/3)
+@end itemize
+
+@geindex AI12-0204 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0204 Renaming of a prefixed view (2020-02-24)'
+
+AI12-0204 clarifies that the prefix of a prefixed view that is renamed or
+passed as a formal subprogram must be renameable as an object.
+
+RM references: 8.05.04 (5.2/2) 12.06 (8.3/2) 4.01.03 (13.1/2) 4.01.06 (9/5)
+@end itemize
+
+@geindex AI12-0205 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0205 Defaults for generic formal types (2021-04-01)'
+
+AI12-0205 specifies syntax and semantics that provide defaults for formal types of generic units. The legality rules guarantee that the default subtype_mark that is specified for a formal type would be a legal actual in any instantiation of the generic unit.
+
+RM references: 12.03 (7/3) 12.03 (10) 12.05 (2.1/3) 12.05 (2.2/3) 12.05 (7/2)
+@end itemize
+
+@geindex AI12-0206 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0206 Nonoverridable should allow arbitrary kinds of aspects (0000-00-00)'
+
+A non-overridable aspect can have a value other than a name; for example, @code{Max_Entry_Queue_Length} is non-overridable and it has a scalar value.
+Part of adding support for @code{Max_Entry_Queue_Length} (which is already supported by GNAT).
+
+RM references: 13.01.01 (18.2/4) 13.01.01 (18.3/4) 13.01.01 (18.6/4)
+@end itemize
+
+@geindex AI12-0207 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0207 Convention of anonymous access types (2020-02-01)'
+
+The convention of anonymous access elements of arrays now have the same convention as the array instead of convention Ada.
+
+RM references: 6.03.01 (13.1/3) B.01 (19) B.01 (21/3)
+@end itemize
+
+@geindex AI12-0208 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0208 Predefined Big numbers support (0000-00-00)'
+
+Add predefined package @code{Ada.Numerics.Big_Numbers}.
+
+RM references: A.05.05 (0) A.05.06 (0) A.05.07 (0)
+@end itemize
+
+@geindex AI12-0211 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0211 Interface types and inherited nonoverridable aspects (2020-08-24)'
+
+AI12-0211 introduces two new legality rules for Ada 2022. The first says that
+if a nonoverridable aspect is explicitly specified for a type that also inherits that aspect from another type (an ancestor or a progenitor), then the explicit aspect specification shall be confirming. The second says that if a type inherits a nonoverridable aspect from two different sources (this can only occur if at least one of the two is an interface type), then the two sources shall agree with respect to the given aspect. This AI is a binding interpretation, so these checks are performed even for earlier Ada versions. Because of compatibility concerns, an escape mechanism for suppressing these legality checks is provided: these new checks always pass if the @code{-gnatd.M} switch (relaxed RM semantics) is specified.
+
+RM references: 13.01.01 (18.3/5) 13.01.01 (18.4/4)
+@end itemize
+
+@geindex AI12-0212 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0212 Container aggregates; generalized array aggregates (0000-00-00)'
+
+The AI defines a new feature: generalized array aggregates that already exists in GNAT.
+
+RM references: 4.03.05 (0) 1.01.04 (12) 1.01.04 (13) 2.01 (15) 2.02 (9/5)
+3.07.01 (3) 3.08.01 (4) 4.03 (2/5) 4.03 (3/5) 4.03.01 (5) 4.03.03
+(3/2) 4.03.03 (4/5) 4.03.03 (5.1/5) 4.03.03 (9) 4.03.03 (17/5)
+4.03.03 (21) 4.03.03 (23.2/5) 4.03.03 (26) 4.03.03 (27) 4.03.03
+(31) 4.03.04 (4/5) 4.04 (3.1/3) 11.02 (3) 13.01.01 (5/3)
+13.01.01 (7/3) A.18.02 (8/3) A.18.02 (14/2) A.18.02 (47/2) A.18.02
+(175/2) A.18.03 (6/3) A.18.05 (3/3) A.18.06 (4/3) A.18.08 (3/3)
+A.18.09 (4/3)
+@end itemize
+
+@geindex AI12-0216 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0216 6.4.1(6.16-17/3) should never apply to composite objects (0000-00-00)'
+
+Fix wording so that parameter passing cases where there isn’t really any aliasing problems or evaluation order dependency are classified as acceptable.
+
+No compiler impact.
+
+RM references: 6.04.01 (6.17/3)
+@end itemize
+
+@geindex AI12-0217 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0217 Rules regarding restrictions on the use of the Old attribute are too strict (2020-03-25)'
+
+AI12-0217 loosens the rules regarding what is allowed as the prefix of a ‘Old
+attribute reference. In particular, a prefix is now only required to “statically name” (as opposed to the previous “statically denote”) an object. This means that components of composite objects that previously would have been illegal are now legal prefixes.
+
+RM references: 6.01.01 (24/3) 6.01.01 (27/3)
+@end itemize
+
+@geindex AI12-0220 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0220 Pre/Post for access-to-subprogram types (2020-04-14)'
+
+Contract aspects can now be specified for access-to-subprogram types, as
+defined for Ada 2022 in this AI.
+
+RM references: 6.01.01 (1/4) 6.01.01 (2/3) 6.01.01 (4/3) 6.01.01 (19/3)
+6.01.01 (28/3) 6.01.01 (29/3) 6.01.01 (39/3) 13.01.01 (12/5)
+@end itemize
+
+@geindex AI12-0222 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0222 Representation aspects and private types (0000-00-00)'
+
+Clarify that the rule against specifying a representation aspect for a type before the type is completely defined also applies in the case where aspect_specification syntax is used (not just in the case where a pragma or some other kind of representation item is used).
+
+GNAT already implements this.
+
+RM references: 13.01 (9/5) 13.01 (9.1/4) 13.01 (9.2/5)
+@end itemize
+
+@geindex AI12-0225 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0225 Prefix of Obj’Image (0000-00-00)'
+
+Clarify some Object vs. Value corner cases to allow names that do not denote objects in more contexts, such as a qualified expression as a prefix of an Image attribute.
+
+RM references: 3.05 (55.1/4)
+@end itemize
+
+@geindex AI12-0226 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0226 Make objects more consistent (0000-00-00)'
+
+Allow value conversions as objects. For instance this example becomes legal: @code{Long_Integer (Duration'Last)'Image}.
+
+RM references: 3.03 (11.1/3) 3.03 (21.1/3) 3.03 (23.8/5) 4.06 (58.1/4)
+4.06 (58.3/4)
+@end itemize
+
+@geindex AI12-0227 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0227 Evaluation of nonstatic universal expressions when no operators are involved (0000-00-00)'
+
+Nonstatic universal integer expressions are always evaluated at runtime as values of type root_integer; similarly, nonstatic universal real expressions are always evaluated at runtime as values of type root_real.
+This AI corrects a wording oversight. Previously, the above was only true if a call to operator was involved. With this change it is true in all cases.
+
+No compiler impact.
+
+RM references: 4.04 (10) 8.06 (29)
+@end itemize
+
+@geindex AI12-0228 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0228 Properties of qualified expressions used as names (2020-02-19)'
+
+This AI clarifies that properties of a qualified object pass through a
+qualified expression used as a name. Specifically, “aliased” and “known to be
+constrained” are not changed by a qualified expression.
+
+RM references: 3.03 (23.7/3) 3.10 (9/3)
+@end itemize
+
+@geindex AI12-0231 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0231 Null_Task_Id and Activation_Is_Complete (0000-00-00)'
+
+Add @code{Activation_Is_Complete} to the list of functions that raise P_E if passed @code{Null_Task_Id}, correcting an oversight.
+
+RM references: C.07.01 (15)
+@end itemize
+
+@geindex AI12-0232 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0232 Rules for pure generic bodies (0000-00-00)'
+
+Clarify the rules for a generic body nested in a pure library unit.
+
+RM references: 10.02.01 (9/3) 10.02.01 (15.1/3) 10.02.01 (15.5/3)
+@end itemize
+
+@geindex AI12-0233 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0233 Pre’Class for hidden operations of private types (0000-00-00)'
+
+Clarify how @code{Pre'Class} checking interacts with private-part overriding of inherited subprograms. A class-wide precondition can be checked at runtime even if it is specified in a private part that the caller cannot see into.
+
+RM references: 6.01.01 (38/4)
+@end itemize
+
+@geindex AI12-0234 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0234 Compare-and-swap for atomic objects (0000-00-00)'
+
+New predefined units for atomic operations (@code{System.Atomic_Operations} and child units thereof).
+
+RM references: C.06.01 (0) C.06.02 (0)
+@end itemize
+
+@geindex AI12-0235 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0235 System.Storage_Pools should be pure (0000-00-00)'
+
+Change the predefined package System.Storage_Pools from preelaborated to pure.
+
+RM references: 13.11 (5)
+@end itemize
+
+@geindex AI12-0236 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0236 declare expressions (2020-04-08)'
+
+A @code{declare expression} allows constant objects and renamings to be
+declared within an expression.
+
+RM references: 2.08 (6) 3.09.02 (3) 3.10.02 (9.1/3) 3.10.02 (16.1/3)
+3.10.02 (32.2/3) 4.03.02 (5.4/3) 4.03.03 (15.1/3) 4.04 (7/3)
+4.05.09 (0) 6.02 (10/4) 7.05 (2.1/5) 8.01 (2.1/4)
+@end itemize
+
+@geindex AI12-0237 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0237 Getting the representation of an enumeration value (2020-01-31)'
+
+The GNAT-specific attributes @code{Enum_Rep} and @code{Enum_Val} have been standardized and are now also supported as Ada 2022 attributes.
+
+RM references: 13.04 (10) 13.04 (11/3)
+@end itemize
+
+@geindex AI12-0242 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0242 Shorthand Reduction Expressions for Objects (0000-00-00)'
+
+Allow reduction expressions to iterate over an an array or an iterable object without having to explicitly create a value sequence.
+
+This allows, for instance, writing @code{A'Reduce("+", 0)} instead of the equivalent (but more verbose) @code{[for Value of A => Value]'Reduce("+", 0);}.
+
+RM references: 4.05.10 (0) 4.01.04 (6)
+@end itemize
+
+@geindex AI12-0247 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0247 Potentially Blocking goes too far for Detect_Blocking (0000-00-00)'
+
+During a protected action, a call on a subprogram that contains a potentially blocking operation is considered a bounded error (so raising P_E is optional).
+This rule imposed an unreasonable implementation burden.
+The new rule introduced by this AI allows ignoring (i.e., not detecting) the problem until execution of a potentially blocking operation is actually attempted.
+
+RM references: 9.05 (55/5) 9.05 (56/5) 9.05.01 (18/5) H.05 (5/2)
+@end itemize
+
+@geindex AI12-0249 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0249 User-defined numeric literals (2020-04-07)'
+
+Compiler support is added for three new aspects (@code{Integer_Literal}, @code{Real_Literal}, and @code{String_Literal}) as described in AI12-0249 (for @code{Integer_Literal} and @code{Real_Literal}), AI12-0295 (for @code{String_Literal}), and in two follow-up AIs (AI12-0325 and AI12-0342). For pre-Ada 2022 versions of Ada, these are treated as implementation-defined
+aspects. Some implementation work remains, particularly in the interactions between these aspects and tagged types.
+
+RM references: 4.02 (9) 4.02.01 (0) 4.09 (3)
+@end itemize
+
+@geindex AI12-0250 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0250 Iterator Filters (2020-05-19)'
+
+This AI defines Ada 2022 feature of iterator filters, which can be
+applied to loop parameter specifications and iterator specifications.
+
+RM references: 4.03.03 (21) 4.03.03 (26) 4.03.03 (31) 4.03.05 (0) 4.05.10
+(0) 5.05 (4) 5.05 (7) 5.05 (9/4) 5.05 (9.1/4) 5.05 (10)
+5.05.02 (2/3) 5.05.02 (10/3) 5.05.02 (11/3)
+@end itemize
+
+@geindex AI12-0252 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0252 Duplicate interrupt handlers under Ravenscar (2018-07-05)'
+
+Ada Issue AI12-0252 requires that the runtime shall terminate with a
+Program_Error when more than one interrupt handler is attached to the same interrupt and the restriction No_Dynamic_Attachment is in effect.
+
+RM references: C.03.01 (13)
+@end itemize
+
+@geindex AI12-0256 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0256 Aspect No_Controlled_Parts (2021-01-26)'
+
+The compiler now supports the Ada 2022 aspect No_Controlled_Parts (see
+AI12-0256). When specified for a type, this aspect requires that the type and any of its ancestors must not have any controlled parts.
+
+RM references: H.04.01 (0) 13.01.01 (18.7/5)
+@end itemize
+
+@geindex AI12-0258 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0258 Containers and controlled element types (0000-00-00)'
+
+Most predefined containers are allowed to defer finalization of container elements until the finalization of the container. This allows implementation flexibility but causes problems in some cases. AI12-0258 tightens up the rules for the indefinite containers to say that finalization happens earlier - if a client needs the tighter finalization guarantees, then it can use the indefinite containers (even if the element subtype in question is definite). Other solutions involving the holder generic are also possible.
+
+GNAT implements these tighter element finalization requirements for instances of the indefinite container generics.
+
+RM references: A.18 (10/4)
+@end itemize
+
+@geindex AI12-0259 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0259 Lower bound of strings returned from Ada.Command_Line (0000-00-00)'
+
+Specify that the low-bound of a couple of predefined String-valued functions will always be one.
+
+RM references: A.15 (14) A.15 (16/3)
+@end itemize
+
+@geindex AI12-0260 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0260 Functions Is_Basic and To_Basic in Wide_Characters.Handling (2020-04-01)'
+
+AI12-0260 is implemented for Ada 2022, providing the new functions @code{Is_Basic} and @code{To_Basic} in package @code{Ada.Wide_Characters.Handling}.
+
+RM references: 1.02 (8/3) A.03.05 (8/3) A.03.05 (20/3) A.03.05 (21/3)
+A.03.05 (33/3) A.03.05 (61/3)
+@end itemize
+
+@geindex AI12-0261 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0261 Conflict in “private with” rules (0000-00-00)'
+
+If a library unit is only visible at some point because of a “private with”, there are legality rules about a name denoting that entity. The AI cleans up the wording so that it captures the intent in a corner case involving a private-child library-unit subprogram. The previous wording incorrectly caused this case to be illegal.
+
+RM references: 10.01.02 (12/3) 10.01.02 (13/2) 10.01.02 (14/2) 10.01.02
+(15/2) 10.01.02 (16/2)
+@end itemize
+
+@geindex AI12-0262 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0262 Map-Reduce attribute (0000-00-00)'
+
+The AI defines Reduction Expressions to allow the programmer to apply the
+Map-Reduce paradigm to map/transform a set of values to a new set of values,
+and then summarize/reduce the transformed values into a single result value.
+
+RM references: 4.01.04 (1) 4.01.04 (6) 4.01.04 (11) 4.05.10 (0)
+@end itemize
+
+@geindex AI12-0263 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0263 Update references to ISO/IEC 10646 (0000-00-00)'
+
+Change RM references to ISO/IEC 10646:2011 to instead refer to ISO/IEC 10646:2017. No compiler impact.
+
+RM references: 1.01.04 (14.2/3) 2.01 (1/3) 2.01 (3.1/3) 2.01 (4/3) 2.01
+(4.1/5) 2.01 (5/3) 2.01 (15/3) 2.01 (4.1/5) 2.01 (5/3) 2.03
+(4.1/5) 2.03 (5/3) 3.05.02 (2/3) 3.05.02 (3/3) 3.05.02 (4/3) A.01
+(36.1/3) A.01 (36.2/3) A.03.02 (32.6/5) A.03.05 (51.2/5) A.03.05
+(55/3) A.03.05 (59/3) A.04.10 (3/3) B.05 (21/5)
+@end itemize
+
+@geindex AI12-0264 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0264 Overshifting and overrotating (0000-00-00)'
+
+Clarify Shift and Rotate op behavior with large shift/rotate amounts.
+
+RM references: B.02 (9)
+@end itemize
+
+@geindex AI12-0265 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0265 Default_Initial_Condition for types (2020-11-13)'
+
+The aspect @code{Default_Initial_Condition}, originally proposed by SPARK and
+supported in GNAT, is now also included in Ada 2022. One change from the
+original implementation is that when the aspect is specified on ancestor types of a derived type, the ancestors’ check expressions also apply to the derived type.
+@code{Default_Initial_Condition} checks are also now applied in cases of default
+initialization of components, allocators, ancestor parts of extension aggregates, and box associations of aggregates.
+
+RM references: 7.03.03 (0) 1.01.03 (17.1/5) 11.04.02 (23.2/5) 11.04.02 (23.3/5)
+@end itemize
+
+@geindex AI12-0269 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0269 Aspect No_Return for functions reprise (2020-03-19)'
+
+This amendment has been implemented under the @code{-gnat2022} switch, and the
+compiler now accepts the aspect/pragma No_Return for functions and generic
+functions.
+
+RM references: 6.05.01 (0) 6.05.01 (1/3) 6.05.01 (3.1/3) 6.05.01 (3.4/3)
+6.05.01 (5/2) 6.05.01 (6/2) 6.05.01 (7/2) J.15.02 (2/3) J.15.02
+(3/3) J.15.02 (4/3)
+@end itemize
+
+@geindex AI12-0272 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0272 (part 1) Pre/Postconditions for formal subprograms (0000-00-00)'
+
+Pre and Post aspects can be specified for a generic formal subprogram. @code{Default_Initial_Condition} can be specified for a generic formal private type.
+
+GNAT implements this with an exception of the part related to @code{Default_Initial_Condition}.
+
+RM references: 6.01.01 (1/5) 6.01.01 (39/5) 7.03.03 (1/5) 7.03.03 (2/5)
+7.03.03 (8/5) 7.03.04 (5/5) F.01 (1)
+@end itemize
+
+@geindex AI12-0275 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0275 Make subtype_mark optional in object renames (2020-01-28)'
+
+AI12-0275 allows object renamings to be declared without an explicit
+subtype_mark or access_definition. This feature can be used by compiling
+with the switch @code{-gnat2022}.
+
+RM references: 8.05.01 (2/3) 8.05.01 (3/2)
+@end itemize
+
+@geindex AI12-0277 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0277 The meaning of “accessibility level of the body of F” (0000-00-00)'
+
+Clarify that the only time that an explicitly aliased formal parameter has different accessibility properties than an aliased part of a “normal” parameter is for the accessibility checking associated with a return statement.
+
+RM references: 3.10.02 (19.2/4)
+@end itemize
+
+@geindex AI12-0278 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0278 Implicit conversions of anonymous return types (0000-00-00)'
+
+If a call to a function with an anonymous-access-type result is converted to a named access type, it doesn’t matter whether the conversion is implicit or explicit. the AI fixes hole where the previous rules didn’t cover the implicit conversion case.
+
+RM references: 3.10.02 (10.3/3)
+@end itemize
+
+@geindex AI12-0279 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0279 Nonpreemptive dispatching needs more dispatching points (2020-04-17)'
+
+Ada 2022 defines a new aspect @cite{Yield} that can be specified in the declaration of a noninstance subprogram (including a generic formal subprogram), a generic subprogram, or an entry, to ensure that the associated subprogram has at least one task dispatching point during each invocation.
+
+RM references: D.02.01 (1.5/2) D.02.01 (7/5)
+@end itemize
+
+@geindex AI12-0280-2 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0280-2 Making ‘Old more flexible (2020-07-24)'
+
+For Ada 2022, AI12-0280-2 relaxes Ada’s restrictions on ‘Old attribute
+references whose attribute prefix does not statically name an entity. Previously, it was required that such an attribute reference must be unconditionally evaluated when the postcondition is evaluated; with the new rule, conditional evaluation is permitted if the relevant conditions can be evaluated upon entry to the subprogram with the same results as evaluation at the time of the postcondition’s evaluation. In this case, the ‘Old attribute prefix is evaluated conditionally (more specifically, the prefix is evaluated only if the result of that evaluation is going to be referenced later when the
+postcondition is evaluated).
+
+RM references: 6.01.01 (20/3) 6.01.01 (21/3) 6.01.01 (22/3) 6.01.01
+(22.1/4) 6.01.01 (22.2/5) 6.01.01 (23/3) 6.01.01 (24/3) 6.01.01
+(26/4) 6.01.01 (27/5) 6.01.01 (39/5)
+@end itemize
+
+@geindex AI12-0282 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0282 Atomic, Volatile, and Independent generic formal types (0000-00-00)'
+
+The AI specifies that the aspects @code{Atomic}, @code{Volatile}, @code{Independent}, @code{Atomic_Components}, @code{Volatile_Components}, and @code{Independent_Components} are specifiable for generic formal types. The actual type must have a matching specification.
+
+RM references: C.06 (6.1/3) C.06 (6.3/3) C.06 (6.5/3) C.06 (6.8/3) C.06
+(12/3) C.06 (12.1/3) C.06 (21/4)
+@end itemize
+
+@geindex AI12-0285 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0285 Syntax for Stable_Properties aspects (0000-00-00)'
+
+The AI establishes the required named notation for a Stable_Properties aspect specification in order to avoid syntactic ambiguities.
+
+With the old syntax, an example like
+
+@example
+type Ugh is ...
+ with Stable_Properties =\> Foo, Bar, Nonblocking, Pack;
+@end example
+
+was problematic; @code{Nonblocking} and @code{Pack} are other aspects, while @code{Foo} and @code{Bar} are @code{Stable_Properties} functions. With the clarified syntax, the example above shall be written as:
+
+@example
+type Ugh is ...
+ with Stable_Properties => (Foo, Bar), Nonblocking, Pack;
+@end example
+
+RM references: 7.03.04 (2/5) 7.03.04 (3/5) 7.03.04 (4/5) 7.03.04 (6/5)
+7.03.04 (7/5) 7.03.04 (9/5) 7.03.04 (10/5) 7.03.04 (14/5) 13.01.01 (4/5)
+@end itemize
+
+@geindex AI12-0287 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0287 Legality Rules for null exclusions in renaming are too fierce (2020-02-17)'
+
+The null exclusion legality rules for generic formal object matching and object renaming now only apply to generic formal objects with mode in out.
+
+RM references: 8.05.01 (4.4/2) 8.05.01 (4.5/2) 8.05.01 (4.6/2) 8.05.04
+(4.2/2) 12.04 (8.3/2) 12.04 (8.4/2) 12.04 (8.5/2) 12.04 (8.2/5)
+12.06 (8.2/5)
+@end itemize
+
+@geindex AI12-0289 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0289 Implicitly null excluding anonymous access types and conformance (2020-06-09)'
+
+AI12-0289 is implemented for Ada 2022, allowing safer use of access parameters
+when the partial view of the designated type is untagged, but the full view is
+tagged.
+
+RM references: 3.10 (26)
+@end itemize
+
+@geindex AI12-0290 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0290 Restriction Pure_Barriers (2020-02-18)'
+
+The GNAT implementation of the Pure_Barriers restriction has
+been updated to match the Ada RM’s definition as specified
+in this AI. Some constructs that were accepted by the previous
+implementation are now rejected, and vice versa. In
+particular, the use of a component of a component of a
+protected record in a barrier expression, as in “when
+Some_Component.Another_Component =>”, formerly was (at least
+in some cases) not considered to be a violation of the
+Pure_Barriers restriction; that is no longer the case.
+
+RM references: D.07 (2) D.07 (10.10/4)
+@end itemize
+
+@geindex AI12-0291 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0291 Jorvik Profile (2020-02-19)'
+
+The Jorvik profile is now implemented, as defined in this AI.
+For Ada 2012 and earlier versions of Ada, Jorvik is an implementation-defined
+profile whose definition matches its Ada 2022 definition.
+
+RM references: D.13 (0) D.13 (1/3) D.13 (4/3) D.13 (6/4) D.13 (9/3) D.13
+(10/3) D.13 (11/4) D.13 (12/4)
+@end itemize
+
+@geindex AI12-0293 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0293 Add predefined FIFO_Streams packages (0000-00-00)'
+
+The AI adds @code{Ada.Streams.Storage} and its two subunits @code{Bounded} and @code{Unbounded}.
+
+RM references: 13.13.01 (1) 13.13.01 (9) 13.13.01 (9.1/1)
+@end itemize
+
+@geindex AI12-0295 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0295 User-defined string (2020-04-07)'
+
+Compiler support is added for three new aspects (@code{Integer_Literal}, @code{Real_Literal}, and @code{String_Literal}) as described in AI12-0249 (for @code{Integer_Literal} and @code{Real_Literal}), AI12-0295 (for @code{String_Literal}), and in two follow-up AIs (AI12-0325 and AI12-0342). For pre-Ada 2022 versions of Ada, these are treated as implementation-defined aspects. Some implementation work remains, particularly in the interactions between these aspects and tagged types.
+
+RM references: 4.02 (6) 4.02 (10) 4.02 (11) 3.06.03 (1) 4.02.01 (0) 4.09 (26/3)
+@end itemize
+
+@geindex AI12-0301 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0301 Predicates should be checked like constraints for types with Default_Value (2020-02-25)'
+
+This AI clarifies that predicate checks apply for objects that are initialized
+by default and that are of a type that has any components whose subtypes specify @code{Default_Value} or @code{Default_Component_Value}.
+
+RM references: 3.02.04 (31/4)
+@end itemize
+
+@geindex AI12-0304 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0304 Image attributes of language-defined types (2020-07-07)'
+
+According to this AI, @code{Put_Image} (and therefore @code{'Image}) is provided for
+the containers and for unbounded strings.
+
+RM references: 4.10 (0)
+@end itemize
+
+@geindex AI12-0306 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0306 Split null array aggregates from positional array aggregates (0000-00-00)'
+
+The AI clarifies the wording of the references RM paragraphs without introducing any language changes.
+
+RM references: 4.03.03 (2) 4.03.03 (3/2) 4.03.03 (9/5) 4.03.03 (26/5)
+4.03.03 (26.1/5) 4.03.03 (33/3) 4.03.03 (38) 4.03.03 (39) 4.03.03 (42)
+@end itemize
+
+@geindex AI12-0307 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0307 Resolution of aggregates (2020-08-13)'
+
+The proposed new syntax for aggregates in Ada 2022 uses square brackets as
+delimiters, and in particular allows @code{[]} as a notation for empty array and container aggregates. This syntax is currently available as an experimental feature under the @code{-gnatX} flag.
+
+RM references: 4.03 (3/5)
+@end itemize
+
+@geindex AI12-0309 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0309 Missing checks for pragma Suppress (0000-00-00)'
+
+The AI includes some previously overlooked run-time checks in the list of checks that are potentially suppressed via a pragma @code{Suppress}. For example, AI12-0251-1 adds a check that the number of chunks in a chunk_specification is not zero or negative. Clarify that suppressing @code{Program_Error_Check} suppresses that check too.
+
+RM references: 11.05 (10) 11.05 (19) 11.05 (20) 11.05 (22) 11.05 (24)
+@end itemize
+
+@geindex AI12-0311 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0311 Suppressing client-side assertions for language-defined units (0000-00-00)'
+
+The AI defines some new assertion policies that can be given as arguments in a Suppress pragma (e.g., Calendar_Assertion_Check). GNAT recognizes and ignores those new policies, the checks are not implemented.
+
+RM references: 11.04.02 (23.5/5) 11.05 (23) 11.05 (26)
+@end itemize
+
+@geindex AI12-0315 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0315 Image Attributes subclause improvements (0000-00-00)'
+
+Clarify that a named number or similar can be the prefix of an Image attribute reference.
+
+RM references: 4.10 (0)
+@end itemize
+
+@geindex AI12-0318 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0318 No_IO should apply to Ada.Directories (2020-01-31)'
+
+The restriction No_IO now applies to and prevents the use of the
+@code{Ada.Directories package}.
+
+RM references: H.04 (20/2) H.04 (24/3)
+@end itemize
+
+@geindex AI12-0321 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0321 Support for Arithmetic Atomic Operations and Test and Set (0000-00-00)'
+
+The AI adds some predefined atomic operations, e.g. package System.`@w{`}Atomic_Operations.Test_And_Set`@w{`}.
+
+RM references: C.06.03 (0) C.06.04 (0)
+@end itemize
+
+@geindex AI12-0325 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0325 Various issues with user-defined literals (2020-04-07)'
+
+Compiler support is added for three new aspects (@code{Integer_Literal}, @code{Real_Literal}, and @code{String_Literal}) as described in AI12-0249 (for @code{Integer_Literal} and @code{Real_Literal}), AI12-0295 (for @code{String_Literal}), and in two follow-up AIs (AI12-0325 and AI12-0342). For pre-Ada 2022 versions of Ada, these are treated as implementation-defined aspects. Some implementation work remains, particularly in the interactions between these aspects and tagged types.
+
+RM references: 4.02 (6) 4.02 (10) 4.02 (11) 4.02.01 (0)
+@end itemize
+
+@geindex AI12-0329 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0329 Naming of FIFO_Streams packages (0000-00-00)'
+
+The AI changes the name of predefined package @code{Ada.Streams.FIFO_Streams} to @code{Ada.Streams.Storage}.
+
+RM references: 13.13.01 (9/5) 13.13.01 (9.1/5)
+@end itemize
+
+@geindex AI12-0331 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0331 Order of finalization of a subpool (0000-00-00)'
+
+Clarify that when a subpool is being finalized, objects allocated from that subpool are finalized before (not after) they cease to exist (i.e. object’s storage has been reclaimed).
+
+RM references: 13.11.05 (5/3) 13.11.05 (6/3) 13.11.05 (7/3) 13.11.05
+(7.1/4) 13.11.05 (8/3) 13.11.05 (9/3)
+@end itemize
+
+@geindex AI12-0333 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0333 Predicate checks on out parameters (0000-00-00)'
+
+If a view conversion is passed as an actual parameter corresponding to an out-mode formal parameter, and if the subtype of the formal parameter has a predicate, then no predicate check associated with the conversion is performed.
+
+RM references: 3.02.04 (31/5) 4.06 (51/4) 6.04.01 (14)
+@end itemize
+
+@geindex AI12-0335 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0335 Dynamic accessibility check needed for some requeue targets (0000-00-00)'
+
+Define a new runtime accessibility check for a corner case involving requeue statements.
+
+RM references: 9.05.04 (7/4)
+@end itemize
+
+@geindex AI12-0336 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0336 Meaning of Time_Offset (0000-00-00)'
+
+The AI introduces changes to the predefined package @code{Ada.Calendar.Time_Zones}.
+
+RM references: 9.06.01 (6/2) 9.06.01 (35/2) 9.06.01 (40/2) 9.06.01 (41/2)
+9.06.01 (42/3) 9.06.01 (90/2) 9.06.01 (91/2)
+@end itemize
+
+@geindex AI12-0337 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0337 Simple_Name(“/”) in Ada.Directories (0000-00-00)'
+
+Clarify behavior of subprograms in the predefined package @code{Ada.Directories}. In particular, Simple_Name (“/”) should return “/” on Unix-like systems.
+
+RM references: A.16 (47/2) A.16 (74/2) A.16 (82/3)
+@end itemize
+
+@geindex AI12-0338 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0338 Type invariant checking and incomplete types (0000-00-00)'
+
+Clarify that type invariants for type T are not checked for incomplete types whose completion is not available, even if that completion has components of type T.
+
+RM references: 7.03.02 (20/5)
+@end itemize
+
+@geindex AI12-0339 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0339 Empty function for Container aggregates (2020-08-06)'
+
+To provide uniform support for container aggregates, all standard container
+libraries have been enhanced with a function Empty, to be used when initializing an aggregate prior to inserting the specified elements in the object being constructed. All products have been updated to remove the ambiguities that may have arisen from previous uses of entities named Empty in our sources, and the expansion of container aggregates uses Empty wherever needed.
+
+RM references: A.18.02 (8/5) A.18.02 (12.3/5) A.18.02 (78.2/5) A.18.02
+(98.6/5) A.18.03 (6/5) A.18.03 (10.2/5) A.18.03 (50.2/5) A.18.05
+(3/5) A.18.05 (7.2/5) A.18.05 (37.3/5) A.18.05 (46/2) A.18.06
+(4/5) A.18.06 (8.2/5) A.18.06 (51.4/5) A.18.08 (3/5) A.18.08
+(8.1/5) A.18.08 (59.2/5) A.18.08 (68/2) A.18.09 (4/5) A.18.09
+(9.1/5) A.18.09 (74.2/5) A.18.10 (15.2/5) A.18.18 (8.1/5) A.18.19
+(6.1/5) A.18.20 (6/3) A.18.21 (6/3) A.18.22 (6/3) A.18.23 (6/3)
+A.18.24 (6/3) A.18.25 (8/3)
+@end itemize
+
+@geindex AI12-0340 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0340 Put_Image should use a Text_Buffer (0000-00-00)'
+
+Add a new predefined package Ada.Strings.Text_Buffers (along with child units) and change the definition of Put_Image attribute to refer to it.
+
+RM references: A.04.12 (0) 4.10 (3.1/5) 4.10 (3.2/5) 4.10 (6/5) 4.10
+(25.2/5) 4.10 (28/5) 4.10 (31/5) 4.10 (41/5) H.04 (23.2/5) H.04 (23.11/5)
+@end itemize
+
+@geindex AI12-0342 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0342 Various issues with user-defined literals (part 2) (2020-04-07)'
+
+Compiler support is added for three new aspects (@code{Integer_Literal}, @code{Real_Literal}, and @code{String_Literal}) as described in AI12-0249 (for @code{Integer_Literal} and @code{Real_Literal}), AI12-0295 (for @code{String_Literal}), and in two follow-up AIs (AI12-0325 and AI12-0342). For pre-Ada 2022 versions of Ada, these are treated as implementation-defined aspects. Some implementation work remains, particularly in the interactions between these aspects and tagged types.
+
+RM references: 4.02.01 (0) 3.09.02 (1/2) 6.03.01 (22)
+@end itemize
+
+@geindex AI12-0343 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0343 Return Statement Checks (2020-04-02)'
+
+This binding interpretation has been implemented and the accessibility,
+predicate, and tag checks prescribed by RM 6.5 are now performed at the appropriate points, as required by this AI.
+
+RM references: 6.05 (5.12/5) 6.05 (8/4) 6.05 (8.1/3) 6.05 (21/3)
+@end itemize
+
+@geindex AI12-0345 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0345 Dynamic accessibility of explicitly aliased parameters (0000-00-00)'
+
+Further clarify (after AI12-0277) accessibility rules for explicitly aliased parameters.
+
+RM references: 3.10.02 (5) 3.10.02 (7/4) 3.10.02 (10.5/3) 3.10.02 (13.4/4)
+3.10.02 (19.2/5) 3.10.02 (21)
+@end itemize
+
+@geindex AI12-0350 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0350 Swap for Indefinite_Holders (0000-00-00)'
+
+Add a @code{Swap} procedure to the predefined package
+@code{Ada.Containers.Indefinite_Holders}. The AI also contains implementation advice for @code{Ada.Containers.Bounded_Indefinite_Holders}, a package that is not implemented by GNAT.
+
+RM references: A.18.18 (22/5) A.18.18 (67/5) A.18.18 (73/3) A.18.32 (13/5)
+@end itemize
+
+@geindex AI12-0351 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0351 Matching for actuals for formal derived types (2020-04-03)'
+
+This binding interpretation requires the compiler to checks
+that an actual subtype in a generic parameter association of an instantiation is statically compatible (even when the actual is unconstrained) with the ancestor of an associated nondiscriminated generic formal derived type.
+
+RM references: 12.05.01 (7) 12.05.01 (8)
+@end itemize
+
+@geindex AI12-0352 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0352 Early derivation and equality of untagged types (2020-07-09)'
+
+AI12-0352 clarifies that declaring a user-defined primitive equality operation for a record type T is illegal if it occurs after a type has been derived from T.
+
+RM references: 4.05.02 (9.8/4)
+@end itemize
+
+@geindex AI12-0356 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0356 Root_Storage_Pool_With_Subpools should have Preelaborable_Initialization (0000-00-00)'
+
+Add Preelaborable_Initialization pragmas for predefined types @code{Root_Storage_Pool_With_Subpools} and @code{Root_Subpool}.
+
+RM references: 13.11.04 (4/3) 13.11.04 (5/3)
+@end itemize
+
+@geindex AI12-0363 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0363 Fixes for Atomic and Volatile (2020-09-08)'
+
+This amendment has been implemented under the @code{-gnat2022} switch and the compiler now supports the @code{Full_Access_Only} aspect, which is mostly equivalent to GNAT’s @code{Volatile_Full_Access}.
+
+RM references: 3.10.02 (26/3) 9.10 (1/5) C.06 (6.4/3) C.06 (6.10/3) C.06
+(8.1/4) C.06 (12/5) C.06 (12.1/5) C.06 (13.3/5) C.06 (19.1/5)
+@end itemize
+
+@geindex AI12-0364 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0364 Add a modular atomic arithmetic package (0000-00-00)'
+
+Generalize support for atomic integer operations to extend to modular types. Add new predefined generic package,
+@code{System.Atomic_Operations.Modular_Arithmetic}.
+
+RM references: C.06.05 (0) C.06.04 (1/5) C.06.04 (2/5) C.06.04 (3/5)
+C.06.04 (9/5)
+@end itemize
+
+@geindex AI12-0366 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0366 Changes to Big_Integer and Big_Real (0000-00-00)'
+
+Simplify @code{Big_Integer `@w{`}and `@w{`}Big_Real} specs by eliminating explicit support for creating “invalid” values. No more
+@code{Optional_Big_[Integer,Real]} types.
+
+RM references: A.05.06 (0) A.05.07 (0)
+@end itemize
+
+@geindex AI12-0367 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0367 Glitches in aspect specifications (0000-00-00)'
+
+The AI clarifies a few wording omissions. For example, a specified Small value for a fixed point type has to be positive.
+
+RM references: 3.05.09 (8/2) 3.05.10 (2/1) 13.01 (9.1/5) 13.14 (10)
+@end itemize
+
+@geindex AI12-0368 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0368 Declare expressions can be static (2020-05-30)'
+
+AI12-0368 allows declare expressions to be static in Ada 2022.
+
+RM references: 4.09 (8) 4.09 (12.1/3) 4.09 (17) 6.01.01 (24.2/5) 6.01.01
+(24.3/5) 6.01.01 (24.4/5) 6.01.01 (24.5/5) C.04 (9)
+@end itemize
+
+@geindex AI12-0369 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0369 Relaxing barrier restrictions (2020-03-25)'
+
+The definitions of the @code{Simple_Barriers} and @code{Pure_Barriers} restrictions were modified by this AI, replacing uses of “statically denotes” with “statically names”. This means that in many cases (but not all) a barrier expression that references a subcomponent of a component of the protected type while subject to either of the two restrictions is now allowed; with the previous restriction definitions, such a barrier expression would not have been legal.
+
+RM references: D.07 (1.3/5) D.07 (10.12/5)
+@end itemize
+
+@geindex AI12-0372 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0372 Static accessibility of “master of the call” (0000-00-00)'
+
+Add an extra compile-time accessibility check for explicitly aliased parameters needed to prevent dangling references.
+
+RM references: 3.10.02 (10.5/5) 3.10.02 (19.3/4) 6.04.01 (6.4/3)
+@end itemize
+
+@geindex AI12-0373 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0373 Bunch of fixes (0000-00-00)'
+
+Small clarifications to various RM entries with minor impact on compiler implementation.
+
+RM references: 3.01 (1) 4.02 (4) 4.02 (8/2) 4.02.01 (3/5) 4.02.01 (4/5)
+4.02.01 (5/5) 4.09 (17.3/5) 6.01.01 (41/5) 8.05.04 (4/3) 13.01.01
+(4/3) 13.01.01 (11/3) 13.14 (3/5)
+@end itemize
+
+@geindex AI12-0376 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0376 Representation changes finally allowed for untagged derived types (0000-00-00)'
+
+A change of representation for a derived type is allowed in some previously-illegal cases where a change of representation is required to implement a call to a derived subprogram.
+
+RM references: 13.01 (10/4)
+@end itemize
+
+@geindex AI12-0377 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0377 View conversions and out parameters of types with Default_Value revisited (2020-06-17)'
+
+This AI clarifies that an actual of an out parameter that is a view conversion
+is illegal if either the target or operand type has Default_Value specified while the other does not.
+
+RM references: 6.04.01 (5.1/4) 6.04.01 (5.2/4) 6.04.01 (5.3/4) 6.04.01
+(13.1/4) 6.04.01 (13.2/4) 6.04.01 (13.3/4) 6.04.01 (13.4/4) 6.04.01 (15/3)
+@end itemize
+
+@geindex AI12-0381 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0381 Tag of a delta aggregate (0000-00-00)'
+
+In the case of a delta aggregate of a specific tagged type, the tag of the aggregate comes from the specific type (as opposed to somehow from the base object).
+
+RM references: 4.03.04 (14/5)
+@end itemize
+
+@geindex AI12-0382 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0382 Loosen type-invariant overriding requirement of AI12-0042-1 (0000-00-00)'
+
+The AI relaxes some corner-case legality rules about type invariants that were added by AI12-0042-1.
+
+RM references: 7.3.2(6.1/4)
+@end itemize
+
+@geindex AI12-0383 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0383 Renaming values (2020-06-17)'
+
+This AI allow names that denote values rather than objects to nevertheless be
+renamed using an object renaming.
+
+RM references: 8.05.01 (1) 8.05.01 (4) 8.05.01 (4.1/2) 8.05.01 (6/2) 8.05.01 (8)
+@end itemize
+
+@geindex AI12-0384-2 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0384-2 Fixups for Put_Image and Text_Buffers (2021-04-29)'
+
+In GNAT’s initial implementation of the Ada 2022 @code{Put_Image} aspect and
+attribute, buffering was performed using a GNAT-defined package,
+@code{Ada.Strings.Text_Output}. Ada 2022 requires a different package, Ada.`@w{`}Strings.Text_Buffers`@w{`}, for this role, and that package is now provided, and the older package is eliminated.
+
+RM references: 4.10 (0) A.04.12 (0)
+@end itemize
+
+@geindex AI12-0385 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0385 Predefined shifts and rotates should be static (0000-00-00)'
+
+This AI allows Shift and Rotate operations in static expressions. GNAT implements this AI partially.
+
+RM references: 4.09 (20)
+@end itemize
+
+@geindex AI12-0389 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0389 Ignoring unrecognized aspects (2020-10-08)'
+
+Two new restrictions, @code{No_Unrecognized_Aspects} and @code{No_Unrecognized_Pragmas}, are available to make the compiler emit error messages on unrecognized pragmas and aspects.
+
+RM references: 13.01.01 (38/3) 13.12.01 (6.3/3)
+@end itemize
+
+@geindex AI12-0394 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0394 Named Numbers and User-Defined Numeric Literals (2020-10-05)'
+
+Ada 2022 allows using integer named numbers with types that have an
+@code{Integer_Literal} aspect. Similarly, real named numbers may now be used with types that have a @code{Real_Literal} aspect with an overloading that takes two strings, to be used in particular with
+@code{Ada.Numerics.Big_Numbers.Big_Reals}.
+
+RM references: 3.03.02 (3) 4.02.01 (4/5) 4.02.01 (8/5) 4.02.01 (12/5)
+4.02.01 (13/5) 4.09 (5)
+@end itemize
+
+@geindex AI12-0395 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0395 Allow aspect_specifications on formal parameters (0000-00-00)'
+
+Change syntax rules to allow aspect_specifications on formal parameters, if an implementation if an implementation wants to define one. Currently, GNAT doesn’t define any such aspect_specifications.
+
+RM references: 6.01 (15/3)
+@end itemize
+
+@geindex AI12-0397 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0397 Default_Initial_Condition applied to derived type (2020-12-09)'
+
+The compiler now implements the rules for resolving @code{Default_Initial_Condition}
+expressions that involve references to the current instance of types with the aspect, as specified by this AI. The type of the current instance is defined to be like a formal derived type, so for a derived type that inherits the aspect, a call passing the current instance to a primitive means that the call will resolve to invoke the corresponding primitive of the descendant type. This also now permits calls to abstract primitives to occur within the aspect expression of an abstract type.
+
+RM references: 7.03.03 (3/5) 7.03.03 (6/5) 7.03.03 (8/5)
+@end itemize
+
+@geindex AI12-0398 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0398 Most declarations should have aspect specifications (2020-11-19)'
+
+It is now possible to specify aspects for discriminant specifications, extended return object declarations, and entry index specifications. This is an extension added for Ada 2022 by this AI.
+
+RM references: 3.07 (5/2) 6.03.01 (25) 6.05 (2.1/3) 9.05.02 (8)
+@end itemize
+
+@geindex AI12-0399 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0399 Aspect specification for Preelaborable_Initialization (0000-00-00)'
+
+Semantics-preserving presentation change. Replace @code{Preelaborable_Initialization} pragmas with equivalent aspect specs in the listed predefined packages. GNAT follows the guidance of this AI partially.
+
+RM references: 9.05 (53/5) 3.09 (6/5) 7.06 (5/2) 7.06 (7/2) 11.04.01 (2/5)
+11.04.01 (3/2) 13.11 (6/2) 13.11.04 (4/5) 13.11.04 (5/5) 13.13.01
+(3/2) A.04.02 (4/2) A.04.02 (20/2) A.04.05 (4/2) A.04.07 (4/2)
+A.04.07 (20/2) A.04.08 (4/2) A.04.08 (20/2) A.12.01 (5/4) A.18.02
+(8/5) A.18.02 (9/2) A.18.02 (79.2/5) A.18.02 (79.3/5) A.18.03
+(6/5) A.18.03 (7/2) A.18.03 (50.2/5) A.18.03 (50.3/5) A.18.05
+(3/5) A.18.05 (4/2) A.18.05 (37.3/5) A.18.05 (37.4/5) A.18.06
+(4/5) A.18.06 (5/2) A.18.06 (51.4/5) A.18.06 (51.5/5) A.18.08
+(3/5) A.18.08 (4/2) A.18.08 (58.2/5) A.18.08 (58.3/5) A.18.09
+(4/5) A.18.09 (5/2) A.18.09 (74.2/5) A.18.09 (74.3/5) A.18.10
+(8/5) A.18.10 (9/3) A.18.10 (70.2/5) A.18.10 (70.3/5) A.18.18
+(6/5) B.03.01 (5/2) C.07.01 (2/5) G.01.01 (4/2)
+@end itemize
+
+@geindex AI12-0400 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0400 Ambiguities associated with Vector Append and container aggregates (0000-00-00)'
+
+Change the names of subprograms in the predefined Vector containers from @code{Append} to @code{Append_Vector} and from @code{Prepend} to @code{Prepend_Vector} in order to resolve some ambiguity problems. GNAT adds the subprograms with new names but also keeps the old ones for backward compatibility.
+
+RM references: A.18.02 (8/5) A.18.02 (36/5) A.18.02 (37/5) A.18.02 (38/5)
+A.18.02 (44/5) A.18.02 (46/5) A.18.02 (47/5) A.18.02 (58/5)
+A.18.02 (79.2/5) A.18.02 (150/5) A.18.02 (151/5) A.18.02 (152/5)
+A.18.02 (153/5) A.18.02 (154/5) A.18.02 (155/5) A.18.02 (156/5)
+A.18.02 (168/5) A.18.02 (169/5) A.18.02 (172/5) A.18.02 (173/5)
+A.18.02 (174/5) A.18.02 (175.1/5) A.18.03 (23/5) A.18.03 (23.1/5)
+A.18.03 (58.2/5) A.18.03 (96/5) A.18.03 (97.1/5)
+@end itemize
+
+@geindex AI12-0401 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0401 Renaming of qualified expression of variable (2020-10-31)'
+
+Ada 2022 AI12-0401 restricts renaming of a qualified expression to cases where
+the operand is a constant, or the target subtype statically matches the nominal subtype of the operand, or is unconstrained with no predicates, to prevent setting variables to values outside their range or constraints.
+
+RM references: 3.03 (23.2/3) 8.05.01 (4.7/5) 8.05.01 (5/3)
+@end itemize
+
+@geindex AI12-0409 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0409 Preelaborable_Initialization and bounded containers (2021-06-23)'
+
+As defined by this AI, the @code{Preelaborable_Initializatio} aspect now has a
+corresponding attribute of the same name. Types declared within a generic package specification are permitted to specify the expression of a @code{Prelaborable_Initialization} aspect by including one or more references to the attribute applied to a formal private or formal derived type conjoined by @code{and} operators. This permits the full type of a private type with such an aspect expression to have components of the named formal types, and such a type will have preelaborable initialization in an instance when the
+actual types for all referenced formal types have preelaborable initialization.
+
+RM references: 10.02.01 (4.1/2) 10.02.01 (4.2/2) 10.02.01 (11.1/2)
+10.02.01 (11.2/2) 10.02.01 (11.6/2) 10.02.01 (11.7/2) 10.02.01
+(11.8/2) 13.01 (11/3) A.18.19 (5/5) A.18.20 (5/5) A.18.21 (5/5)
+A.18.22 (5/5) A.18.23 (5/5) A.18.24 (5/5) A.18.25 (5/5) A.18.32
+(6/5) J.15.14 (0)
+@end itemize
+
+@geindex AI12-0411 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0411 Add “bool” to Interfaces.C (0000-00-00)'
+
+RM references: B.03 (13) B.03 (43/2) B.03 (65.1/4)
+@end itemize
+
+@geindex AI12-0412 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0412 Abstract Pre/Post’Class on primitive of abstract type (2021-05-19)'
+
+In Ada 2022, by AI12-0412, it’s legal to specify Pre’Class and Post’Class
+aspects on nonabstract primitive subprograms of an abstract type, but if the
+expression of such an aspect is nonstatic, then it’s illegal to make a nondispatching call to such a primitive, to apply @code{'Access} to it, or to pass such a primitive as an actual subprogram for a concrete formal subprogram in a generic instantiation.
+
+RM references: 6.01.01 (18.2/4)
+@end itemize
+
+@geindex AI12-0413 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0413 Reemergence of “=” when defined to be abstract (0000-00-00)'
+
+The AI clarifies rules about operator reemergence in instances, and nondispatching calls to abstract subprograms.
+
+RM references: 3.09.03 (7) 4.05.02 (14.1/3) 4.05.02 (24.1/3) 12.05 (8/3)
+@end itemize
+
+@geindex AI12-0423 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0423 Aspect inheritance fixups (0000-00-00)'
+
+Clarify that the No_Return aspect behaves as one would expect for an inherited subprogram and that inheritance works as one would expect for a multi-part aspect whose value is specified via an aggregate (e.g., the Aggregate aspect).
+
+RM references: 6.05.01 (3.3/3) 13.01 (15.7/5) 13.01 (15.8/5)
+@end itemize
+
+@geindex AI12-0432 (Ada 2022 feature)
+
+
+@itemize *
+
+@item
+`AI12-0432 View conversions of assignments and predicate checks (2021-05-05)'
+
+When a predicate applies to a tagged type, a view conversion to that type
+normally requires a predicate check. However, as specified by AI12-0432, when the view conversion appears as the target of an assignment, a predicate check is not applied to the object in the conversion.
+
+RM references: 3.02.04 (31/5) 4.06 (51.1/5)
+@end itemize
+
+@node GNAT language extensions,Security Hardening Features,Implementation of Ada 2022 Features,Top
+@anchor{gnat_rm/gnat_language_extensions doc}@anchor{448}@anchor{gnat_rm/gnat_language_extensions gnat-language-extensions}@anchor{449}@anchor{gnat_rm/gnat_language_extensions id1}@anchor{44a}
@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{448}
+@anchor{gnat_rm/gnat_language_extensions how-to-activate-the-extended-gnat-ada-superset}@anchor{44b}
@section How to activate the extended GNAT Ada superset
@itemize *
@item
-The @ref{69,,Pragma Extensions_Allowed}. To activate
+The @ref{6a,,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{449}@anchor{gnat_rm/gnat_language_extensions curated-language-extensions}@anchor{6a}
+@anchor{gnat_rm/gnat_language_extensions curated-extensions}@anchor{44c}@anchor{gnat_rm/gnat_language_extensions curated-language-extensions}@anchor{6b}
@section Curated Extensions
@end menu
@node Local Declarations Without Block,Deep delta Aggregates,,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions local-declarations-without-block}@anchor{44a}
+@anchor{gnat_rm/gnat_language_extensions local-declarations-without-block}@anchor{44d}
@subsection Local Declarations Without Block
@end cartouche
@node Deep delta Aggregates,Fixed lower bounds for array types and subtypes,Local Declarations Without Block,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions deep-delta-aggregates}@anchor{44b}
+@anchor{gnat_rm/gnat_language_extensions deep-delta-aggregates}@anchor{44e}
@subsection Deep delta Aggregates
@end menu
@node Syntax,Legality Rules,,Deep delta Aggregates
-@anchor{gnat_rm/gnat_language_extensions syntax}@anchor{44c}
+@anchor{gnat_rm/gnat_language_extensions syntax}@anchor{44f}
@subsubsection Syntax
@end example
@node Legality Rules,Dynamic Semantics,Syntax,Deep delta Aggregates
-@anchor{gnat_rm/gnat_language_extensions legality-rules}@anchor{44d}
+@anchor{gnat_rm/gnat_language_extensions legality-rules}@anchor{450}
@subsubsection Legality Rules
@end enumerate
@node Dynamic Semantics,Examples,Legality Rules,Deep delta Aggregates
-@anchor{gnat_rm/gnat_language_extensions dynamic-semantics}@anchor{44e}
+@anchor{gnat_rm/gnat_language_extensions dynamic-semantics}@anchor{451}
@subsubsection Dynamic Semantics
@end itemize
@node Examples,,Dynamic Semantics,Deep delta Aggregates
-@anchor{gnat_rm/gnat_language_extensions examples}@anchor{44f}
+@anchor{gnat_rm/gnat_language_extensions examples}@anchor{452}
@subsubsection Examples
@end example
@node Fixed lower bounds for array types and subtypes,Prefixed-view notation for calls to primitive subprograms of untagged types,Deep delta Aggregates,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions fixed-lower-bounds-for-array-types-and-subtypes}@anchor{450}
+@anchor{gnat_rm/gnat_language_extensions fixed-lower-bounds-for-array-types-and-subtypes}@anchor{453}
@subsection Fixed lower bounds for array types and subtypes
ranges with static fixed lower bounds.
@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{451}
+@anchor{gnat_rm/gnat_language_extensions prefixed-view-notation-for-calls-to-primitive-subprograms-of-untagged-types}@anchor{454}
@subsection Prefixed-view notation for calls to primitive subprograms of untagged types
@end example
@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{452}
+@anchor{gnat_rm/gnat_language_extensions expression-defaults-for-generic-formal-functions}@anchor{455}
@subsection Expression defaults for generic formal functions
then calls to Copy in the instance will simply return Item.
@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{453}
+@anchor{gnat_rm/gnat_language_extensions string-interpolation}@anchor{456}
@subsection String interpolation
@end example
@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{454}
+@anchor{gnat_rm/gnat_language_extensions constrained-attribute-for-generic-objects}@anchor{457}
@subsection Constrained attribute for generic objects
result indicates whether the corresponding actual is constrained.
@node Static aspect on intrinsic functions,First Controlling Parameter,Constrained attribute for generic objects,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions static-aspect-on-intrinsic-functions}@anchor{455}
+@anchor{gnat_rm/gnat_language_extensions static-aspect-on-intrinsic-functions}@anchor{458}
@subsection @code{Static} aspect on intrinsic functions
particular the @code{Shift_Left} and @code{Shift_Right} intrinsics.
@node First Controlling Parameter,,Static aspect on intrinsic functions,Curated Extensions
-@anchor{gnat_rm/gnat_language_extensions first-controlling-parameter}@anchor{456}
+@anchor{gnat_rm/gnat_language_extensions first-controlling-parameter}@anchor{459}
@subsection First Controlling Parameter
@end itemize
@node Experimental Language Extensions,,Curated Extensions,GNAT language extensions
-@anchor{gnat_rm/gnat_language_extensions experimental-language-extensions}@anchor{6b}@anchor{gnat_rm/gnat_language_extensions id2}@anchor{457}
+@anchor{gnat_rm/gnat_language_extensions experimental-language-extensions}@anchor{6c}@anchor{gnat_rm/gnat_language_extensions id2}@anchor{45a}
@section Experimental Language Extensions
@end menu
@node Conditional when constructs,Implicit With,,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions conditional-when-constructs}@anchor{458}
+@anchor{gnat_rm/gnat_language_extensions conditional-when-constructs}@anchor{45b}
@subsection Conditional when constructs
@end example
@node Implicit With,Storage Model,Conditional when constructs,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions implicit-with}@anchor{459}
+@anchor{gnat_rm/gnat_language_extensions implicit-with}@anchor{45c}
@subsection Implicit With
@end example
@node Storage Model,Attribute Super,Implicit With,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions storage-model}@anchor{45a}
+@anchor{gnat_rm/gnat_language_extensions storage-model}@anchor{45d}
@subsection Storage Model
@end menu
@node Aspect Storage_Model_Type,Aspect Designated_Storage_Model,,Storage Model
-@anchor{gnat_rm/gnat_language_extensions aspect-storage-model-type}@anchor{45b}
+@anchor{gnat_rm/gnat_language_extensions aspect-storage-model-type}@anchor{45e}
@subsubsection Aspect Storage_Model_Type
@end example
@node Aspect Designated_Storage_Model,Legacy Storage Pools,Aspect Storage_Model_Type,Storage Model
-@anchor{gnat_rm/gnat_language_extensions aspect-designated-storage-model}@anchor{45c}
+@anchor{gnat_rm/gnat_language_extensions aspect-designated-storage-model}@anchor{45f}
@subsubsection Aspect Designated_Storage_Model
@end example
@node Legacy Storage Pools,,Aspect Designated_Storage_Model,Storage Model
-@anchor{gnat_rm/gnat_language_extensions legacy-storage-pools}@anchor{45d}
+@anchor{gnat_rm/gnat_language_extensions legacy-storage-pools}@anchor{460}
@subsubsection Legacy Storage Pools
can still be accepted as a shortcut for the new syntax.
@node Attribute Super,Simpler Accessibility Model,Storage Model,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions attribute-super}@anchor{45e}
+@anchor{gnat_rm/gnat_language_extensions attribute-super}@anchor{461}
@subsection Attribute Super
@end example
@node Simpler Accessibility Model,Case pattern matching,Attribute Super,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions simpler-accessibility-model}@anchor{45f}
+@anchor{gnat_rm/gnat_language_extensions simpler-accessibility-model}@anchor{462}
@subsection Simpler Accessibility Model
@end menu
@node Stand-alone objects,Subprogram parameters,,Simpler Accessibility Model
-@anchor{gnat_rm/gnat_language_extensions stand-alone-objects}@anchor{460}
+@anchor{gnat_rm/gnat_language_extensions stand-alone-objects}@anchor{463}
@subsubsection Stand-alone objects
statically deeper than that of the target type …”.
@node Subprogram parameters,Function results,Stand-alone objects,Simpler Accessibility Model
-@anchor{gnat_rm/gnat_language_extensions subprogram-parameters}@anchor{461}
+@anchor{gnat_rm/gnat_language_extensions subprogram-parameters}@anchor{464}
@subsubsection Subprogram parameters
@end example
@node Function results,,Subprogram parameters,Simpler Accessibility Model
-@anchor{gnat_rm/gnat_language_extensions function-results}@anchor{462}
+@anchor{gnat_rm/gnat_language_extensions function-results}@anchor{465}
@subsubsection Function results
@end example
@node Case pattern matching,Mutably Tagged Types with Size’Class Aspect,Simpler Accessibility Model,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions case-pattern-matching}@anchor{463}
+@anchor{gnat_rm/gnat_language_extensions case-pattern-matching}@anchor{466}
@subsection Case pattern matching
case statement with composite selector type”.
@node Mutably Tagged Types with Size’Class Aspect,Generalized Finalization,Case pattern matching,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions mutably-tagged-types-with-size-class-aspect}@anchor{464}
+@anchor{gnat_rm/gnat_language_extensions mutably-tagged-types-with-size-class-aspect}@anchor{467}
@subsection Mutably Tagged Types with Size’Class Aspect
This is analogous to the RM 6.4.1(18) rule about discriminated parameters.
@node Generalized Finalization,No_Raise aspect,Mutably Tagged Types with Size’Class Aspect,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions generalized-finalization}@anchor{465}
+@anchor{gnat_rm/gnat_language_extensions generalized-finalization}@anchor{468}
@subsection Generalized Finalization
@item
The @code{Adjust} and @code{Finalize} procedures are automatically considered as
-having the @ref{466,,No_Raise aspect} specified for them. In particular, the
+having the @ref{469,,No_Raise aspect} specified for them. In particular, the
compiler has permission to enforce none of the guarantees specified by the
RM 7.6.1 (14/1) and subsequent subclauses.
@end itemize
@end menu
@node Finalizable tagged types,Composite types,,Generalized Finalization
-@anchor{gnat_rm/gnat_language_extensions finalizable-tagged-types}@anchor{467}
+@anchor{gnat_rm/gnat_language_extensions finalizable-tagged-types}@anchor{46a}
@subsubsection Finalizable tagged types
class-wide type and the class includes at least one finalizable tagged type.
@node Composite types,Interoperability with controlled types,Finalizable tagged types,Generalized Finalization
-@anchor{gnat_rm/gnat_language_extensions composite-types}@anchor{468}
+@anchor{gnat_rm/gnat_language_extensions composite-types}@anchor{46b}
@subsubsection Composite types
the same as for controlled components of composite types.
@node Interoperability with controlled types,,Composite types,Generalized Finalization
-@anchor{gnat_rm/gnat_language_extensions interoperability-with-controlled-types}@anchor{469}
+@anchor{gnat_rm/gnat_language_extensions interoperability-with-controlled-types}@anchor{46c}
@subsubsection Interoperability with controlled types
types, is applied in this case.
@node No_Raise aspect,Inference of Dependent Types in Generic Instantiations,Generalized Finalization,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions id3}@anchor{46a}@anchor{gnat_rm/gnat_language_extensions no-raise-aspect}@anchor{466}
+@anchor{gnat_rm/gnat_language_extensions id3}@anchor{46d}@anchor{gnat_rm/gnat_language_extensions no-raise-aspect}@anchor{469}
@subsection No_Raise aspect
this execution and @code{Program_Error} is propagated to the caller.
@node Inference of Dependent Types in Generic Instantiations,External_Initialization Aspect,No_Raise aspect,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions inference-of-dependent-types-in-generic-instantiations}@anchor{46b}
+@anchor{gnat_rm/gnat_language_extensions inference-of-dependent-types-in-generic-instantiations}@anchor{46e}
@subsection Inference of Dependent Types in Generic Instantiations
@end example
@node External_Initialization Aspect,Finally construct,Inference of Dependent Types in Generic Instantiations,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions external-initialization-aspect}@anchor{46c}
+@anchor{gnat_rm/gnat_language_extensions external-initialization-aspect}@anchor{46f}
@subsection External_Initialization Aspect
@end cartouche
@node Finally construct,,External_Initialization Aspect,Experimental Language Extensions
-@anchor{gnat_rm/gnat_language_extensions finally-construct}@anchor{46d}
+@anchor{gnat_rm/gnat_language_extensions finally-construct}@anchor{470}
@subsection Finally construct
@end menu
@node Syntax<2>,Legality Rules<2>,,Finally construct
-@anchor{gnat_rm/gnat_language_extensions id4}@anchor{46e}
+@anchor{gnat_rm/gnat_language_extensions id4}@anchor{471}
@subsubsection Syntax
@end example
@node Legality Rules<2>,Dynamic Semantics<2>,Syntax<2>,Finally construct
-@anchor{gnat_rm/gnat_language_extensions id5}@anchor{46f}
+@anchor{gnat_rm/gnat_language_extensions id5}@anchor{472}
@subsubsection Legality Rules
Goto & exit where the target is outside of the finally’s @code{sequence_of_statements} are forbidden
@node Dynamic Semantics<2>,,Legality Rules<2>,Finally construct
-@anchor{gnat_rm/gnat_language_extensions id6}@anchor{470}
+@anchor{gnat_rm/gnat_language_extensions id6}@anchor{473}
@subsubsection Dynamic Semantics
aborted, or if the control is transferred out of the block.
@node Security Hardening Features,Obsolescent Features,GNAT language extensions,Top
-@anchor{gnat_rm/security_hardening_features doc}@anchor{471}@anchor{gnat_rm/security_hardening_features id1}@anchor{472}@anchor{gnat_rm/security_hardening_features security-hardening-features}@anchor{15}
+@anchor{gnat_rm/security_hardening_features doc}@anchor{474}@anchor{gnat_rm/security_hardening_features id1}@anchor{475}@anchor{gnat_rm/security_hardening_features security-hardening-features}@anchor{16}
@chapter Security Hardening Features
@end menu
@node Register Scrubbing,Stack Scrubbing,,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features register-scrubbing}@anchor{473}
+@anchor{gnat_rm/security_hardening_features register-scrubbing}@anchor{476}
@section Register Scrubbing
@c Stack Scrubbing:
@node Stack Scrubbing,Hardened Conditionals,Register Scrubbing,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features stack-scrubbing}@anchor{474}
+@anchor{gnat_rm/security_hardening_features stack-scrubbing}@anchor{477}
@section Stack Scrubbing
@c Hardened Conditionals:
@node Hardened Conditionals,Hardened Booleans,Stack Scrubbing,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features hardened-conditionals}@anchor{475}
+@anchor{gnat_rm/security_hardening_features hardened-conditionals}@anchor{478}
@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{476}
+@anchor{gnat_rm/security_hardening_features hardened-booleans}@anchor{479}
@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{477}
+@anchor{gnat_rm/security_hardening_features control-flow-redundancy}@anchor{47a}
@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{478}@anchor{gnat_rm/obsolescent_features id1}@anchor{479}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{16}
+@anchor{gnat_rm/obsolescent_features doc}@anchor{47b}@anchor{gnat_rm/obsolescent_features id1}@anchor{47c}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{17}
@chapter Obsolescent Features
@end menu
@node pragma No_Run_Time,pragma Ravenscar,,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features id2}@anchor{47a}@anchor{gnat_rm/obsolescent_features pragma-no-run-time}@anchor{47b}
+@anchor{gnat_rm/obsolescent_features id2}@anchor{47d}@anchor{gnat_rm/obsolescent_features pragma-no-run-time}@anchor{47e}
@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{47c}@anchor{gnat_rm/obsolescent_features pragma-ravenscar}@anchor{47d}
+@anchor{gnat_rm/obsolescent_features id3}@anchor{47f}@anchor{gnat_rm/obsolescent_features pragma-ravenscar}@anchor{480}
@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{47e}@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{47f}
+@anchor{gnat_rm/obsolescent_features id4}@anchor{481}@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{482}
@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{480}@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{481}
+@anchor{gnat_rm/obsolescent_features id5}@anchor{483}@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{484}
@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{482}@anchor{gnat_rm/obsolescent_features package-system-task-info-s-tasinf-ads}@anchor{483}
+@anchor{gnat_rm/obsolescent_features package-system-task-info}@anchor{485}@anchor{gnat_rm/obsolescent_features package-system-task-info-s-tasinf-ads}@anchor{486}
@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{484}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{17}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{485}
+@anchor{gnat_rm/compatibility_and_porting_guide doc}@anchor{487}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{18}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{488}
@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{486}@anchor{gnat_rm/compatibility_and_porting_guide writing-portable-fixed-point-declarations}@anchor{487}
+@anchor{gnat_rm/compatibility_and_porting_guide id2}@anchor{489}@anchor{gnat_rm/compatibility_and_porting_guide writing-portable-fixed-point-declarations}@anchor{48a}
@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{488}@anchor{gnat_rm/compatibility_and_porting_guide id3}@anchor{489}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-ada-83}@anchor{48b}@anchor{gnat_rm/compatibility_and_porting_guide id3}@anchor{48c}
@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{48a}@anchor{gnat_rm/compatibility_and_porting_guide legal-ada-83-programs-that-are-illegal-in-ada-95}@anchor{48b}
+@anchor{gnat_rm/compatibility_and_porting_guide id4}@anchor{48d}@anchor{gnat_rm/compatibility_and_porting_guide legal-ada-83-programs-that-are-illegal-in-ada-95}@anchor{48e}
@subsection Legal Ada 83 programs that are illegal in Ada 95
@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{48c}@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{48d}
+@anchor{gnat_rm/compatibility_and_porting_guide id5}@anchor{48f}@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{490}
@subsection More deterministic semantics
@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{48e}@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{48f}
+@anchor{gnat_rm/compatibility_and_porting_guide changed-semantics}@anchor{491}@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{492}
@subsection Changed semantics
@end itemize
@node Other language compatibility issues,,Changed semantics,Compatibility with Ada 83
-@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{490}@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{491}
+@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{493}@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{494}
@subsection Other language compatibility issues
@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{492}@anchor{gnat_rm/compatibility_and_porting_guide id8}@anchor{493}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-between-ada-95-and-ada-2005}@anchor{495}@anchor{gnat_rm/compatibility_and_porting_guide id8}@anchor{496}
@section Compatibility between Ada 95 and Ada 2005
@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{494}@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{495}
+@anchor{gnat_rm/compatibility_and_porting_guide id9}@anchor{497}@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{498}
@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{496}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{497}
+@anchor{gnat_rm/compatibility_and_porting_guide id10}@anchor{499}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{49a}
@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{498}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-attributes}@anchor{499}
+@anchor{gnat_rm/compatibility_and_porting_guide id11}@anchor{49b}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-attributes}@anchor{49c}
@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{49a}@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{49b}
+@anchor{gnat_rm/compatibility_and_porting_guide id12}@anchor{49d}@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{49e}
@subsection Libraries
@end itemize
@node Elaboration order,Target-specific aspects,Libraries,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide elaboration-order}@anchor{49c}@anchor{gnat_rm/compatibility_and_porting_guide id13}@anchor{49d}
+@anchor{gnat_rm/compatibility_and_porting_guide elaboration-order}@anchor{49f}@anchor{gnat_rm/compatibility_and_porting_guide id13}@anchor{4a0}
@subsection Elaboration order
@end itemize
@node Target-specific aspects,,Elaboration order,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{49e}@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{49f}
+@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{4a1}@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{4a2}
@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{4a0,,Representation Clauses}.
+GNAT’s approach to these issues is described in @ref{4a3,,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{4a1}@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{4a2}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-other-ada-systems}@anchor{4a4}@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{4a5}
@section Compatibility with Other Ada Systems
@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{4a3}@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{4a0}
+@anchor{gnat_rm/compatibility_and_porting_guide id16}@anchor{4a6}@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{4a3}
@section Representation Clauses
@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{4a4}@anchor{gnat_rm/compatibility_and_porting_guide id17}@anchor{4a5}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-hp-ada-83}@anchor{4a7}@anchor{gnat_rm/compatibility_and_porting_guide id17}@anchor{4a8}
@section Compatibility with HP Ada 83
@end itemize
@node GNU Free Documentation License,Index,Compatibility and Porting Guide,Top
-@anchor{share/gnu_free_documentation_license doc}@anchor{4a6}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{4a7}
+@anchor{share/gnu_free_documentation_license doc}@anchor{4a9}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{4aa}
@chapter GNU Free Documentation License
projects / thirdparty / gcc.git / commitdiff
