ada: Reorganize documentation of GNAT experimental features

gcc/ada/

	* doc/gnat_rm.rst, doc/gnat_rm/gnat_language_extensions.rst,
	doc/gnat_rm/implementation_defined_pragmas.rst:
	* gnat_rm.texi: Regenerate.

diff --git a/gcc/ada/doc/gnat_rm.rst b/gcc/ada/doc/gnat_rm.rst
index 7743ef8b5f437cbe6858bd1c55cd6af65e979f2f..e52f2a636d98e6797598779c83b2f66b54bf7f53 100644 (file)
--- a/gcc/ada/doc/gnat_rm.rst
+++ b/gcc/ada/doc/gnat_rm.rst
@@ -55,6 +55,7 @@ GNAT Reference Manual
    gnat_rm/specialized_needs_annexes
    gnat_rm/implementation_of_specific_ada_features
    gnat_rm/implementation_of_ada_2012_features
+   gnat_rm/gnat_language_extensions
    gnat_rm/security_hardening_features
    gnat_rm/obsolescent_features
    gnat_rm/compatibility_and_porting_guide

diff --git a/gcc/ada/doc/gnat_rm/gnat_language_extensions.rst b/gcc/ada/doc/gnat_rm/gnat_language_extensions.rst
new file mode 100644 (file)
index 0000000..5646141
--- /dev/null
+++ b/gcc/ada/doc/gnat_rm/gnat_language_extensions.rst
@@ -0,0 +1,477 @@
+.. _GNAT_Language_Extensions:
+
+************************
+GNAT language extensions
+************************
+
+The GNAT compiler implements a certain number of language extensions on top of
+the latest Ada standard, implementing its own extended superset of Ada.
+
+There are two sets of language extensions:
+
+* The first is the curated set. The features in that set are features that we
+  consider being worthy additions to the Ada language, and that we want to make
+  available to users early on.
+
+* The second is the experimental set. It includes the first, but also
+  experimental features, that are here because they're still in an early
+  prototyping phase.
+
+How to activate the extended GNAT Ada superset
+==============================================
+
+There are two ways to activate the extended GNAT Ada superset:
+
+* The :ref:`Pragma Extensions_Allowed<Pragma_Extensions_Allowed>`. To activate
+  the curated set of extensions, you should use
+
+.. code-block:: ada
+
+   pragma Extensions_Allowed (On)
+
+As a configuration pragma, you can either put it at the beginning of a source
+file, or in a ``.adc`` file corresponding to your project.
+
+* The ``-gnatX`` option, that you can pass to the compiler directly, will
+  activate the curated subset of extensions.
+
+.. attention:: You can activate the extended set of extensions by using either
+   the ``-gnatX0`` command line flag, or the pragma ``Extensions_Allowed`` with
+   ``All`` as an argument. However, it is not recommended you use this subset
+   for serious projects, and is only means as a playground/technology preview.
+
+.. _Curated_Language_Extensions:
+
+Curated Extensions
+==================
+
+Conditional when constructs
+---------------------------
+
+This feature extends the use of ``when`` as a way to condition a control-flow
+related statement, to all control-flow related statements.
+
+To do a conditional return in a procedure the following syntax should be used:
+
+.. code-block:: ada
+
+   procedure P (Condition : Boolean) is
+   begin
+      return when Condition;
+   end;
+
+This will return from the procedure if ``Condition`` is true.
+
+When being used in a function the conditional part comes after the return value:
+
+.. code-block:: ada
+
+   function Is_Null (I : Integer) return Boolean is
+   begin
+      return True when I = 0;
+      return False;
+   end;
+
+In a similar way to the ``exit when`` a ``goto ... when`` can be employed:
+
+.. code-block:: ada
+
+   procedure Low_Level_Optimized is
+      Flags : Bitmapping;
+   begin
+      Do_1 (Flags);
+      goto Cleanup when Flags (1);
+
+      Do_2 (Flags);
+      goto Cleanup when Flags (32);
+
+      --  ...
+
+   <<Cleanup>>
+      --  ...
+   end;
+
+.. code-block
+
+To use a conditional raise construct:
+
+.. code-block:: ada
+
+   procedure Foo is
+   begin
+      raise Error when Imported_C_Func /= 0;
+   end;
+
+An exception message can also be added:
+
+.. code-block:: ada
+
+   procedure Foo is
+   begin
+      raise Error with "Unix Error"
+        when Imported_C_Func /= 0;
+   end;
+
+
+Link to the original RFC:
+https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-conditional-when-constructs.rst
+
+Case pattern matching
+---------------------
+
+The selector for a case statement may be of a composite type, subject to
+some restrictions (described below). Aggregate syntax is used for choices
+of such a case statement; however, in cases where a "normal" aggregate would
+require a discrete value, a discrete subtype may be used instead; box
+notation can also be used to match all values.
+
+Consider this example:
+
+.. code-block:: ada
+
+  type Rec is record
+     F1, F2 : Integer;
+  end record;
+
+  procedure Caser_1 (X : Rec) is
+  begin
+     case X is
+        when (F1 => Positive, F2 => Positive) =>
+           Do_This;
+        when (F1 => Natural, F2 => <>) | (F1 => <>, F2 => Natural) =>
+           Do_That;
+        when others =>
+            Do_The_Other_Thing;
+     end case;
+  end Caser_1;
+
+If ``Caser_1`` is called and both components of X are positive, then
+``Do_This`` will be called; otherwise, if either component is nonnegative
+then ``Do_That`` will be called; otherwise, ``Do_The_Other_Thing`` will be
+called.
+
+In addition, pattern bindings are supported. This is a mechanism
+for binding a name to a component of a matching value for use within
+an alternative of a case statement. For a component association
+that occurs within a case choice, the expression may be followed by
+``is <identifier>``. In the special case of a "box" component association,
+the identifier may instead be provided within the box. Either of these
+indicates that the given identifier denotes (a constant view of) the matching
+subcomponent of the case selector.
+
+.. attention:: Binding is not yet supported for arrays or subcomponents
+   thereof.
+
+Consider this example (which uses type ``Rec`` from the previous example):
+
+.. code-block:: ada
+
+  procedure Caser_2 (X : Rec) is
+  begin
+     case X is
+        when (F1 => Positive is Abc, F2 => Positive) =>
+           Do_This (Abc)
+        when (F1 => Natural is N1, F2 => <N2>) |
+             (F1 => <N2>, F2 => Natural is N1) =>
+           Do_That (Param_1 => N1, Param_2 => N2);
+        when others =>
+           Do_The_Other_Thing;
+     end case;
+  end Caser_2;
+
+This example is the same as the previous one with respect to determining
+whether ``Do_This``, ``Do_That``, or ``Do_The_Other_Thing`` will be called. But
+for this version, ``Do_This`` takes a parameter and ``Do_That`` takes two
+parameters. If ``Do_This`` is called, the actual parameter in the call will be
+``X.F1``.
+
+If ``Do_That`` is called, the situation is more complex because there are two
+choices for that alternative. If ``Do_That`` is called because the first choice
+matched (i.e., because ``X.F1`` is nonnegative and either ``X.F1`` or ``X.F2``
+is zero or negative), then the actual parameters of the call will be (in order)
+``X.F1`` and ``X.F2``. If ``Do_That`` is called because the second choice
+matched (and the first one did not), then the actual parameters will be
+reversed.
+
+Within the choice list for single alternative, each choice must define the same
+set of bindings and the component subtypes for for a given identifer must all
+statically match. Currently, the case of a binding for a nondiscrete component
+is not implemented.
+
+If the set of values that match the choice(s) of an earlier alternative
+overlaps the corresponding set of a later alternative, then the first set shall
+be a proper subset of the second (and the later alternative will not be
+executed if the earlier alternative "matches"). All possible values of the
+composite type shall be covered. The composite type of the selector shall be an
+array or record type that is neither limited nor class-wide. Currently, a "when
+others =>" case choice is required; it is intended that this requirement will
+be relaxed at some point.
+
+If a subcomponent's subtype does not meet certain restrictions, then the only
+value that can be specified for that subcomponent in a case choice expression
+is a "box" component association (which matches all possible values for the
+subcomponent). This restriction applies if:
+
+- the component subtype is not a record, array, or discrete type; or
+
+- the component subtype is subject to a non-static constraint or has a
+  predicate; or:
+
+- the component type is an enumeration type that is subject to an enumeration
+  representation clause; or
+
+- the component type is a multidimensional array type or an array type with a
+  nonstatic index subtype.
+
+Support for casing on arrays (and on records that contain arrays) is
+currently subject to some restrictions. Non-positional
+array aggregates are not supported as (or within) case choices. Likewise
+for array type and subtype names. The current implementation exceeds
+compile-time capacity limits in some annoyingly common scenarios; the
+message generated in such cases is usually "Capacity exceeded in compiling
+case statement with composite selector type".
+
+Link to the original RFC:
+https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-pattern-matching.rst
+
+Fixed lower bounds for array types and subtypes
+-----------------------------------------------
+
+Unconstrained array types and subtypes can be specified with a lower bound that
+is fixed to a certain value, by writing an index range that uses the syntax
+``<lower-bound-expression> .. <>``. This guarantees that all objects of the
+type or subtype will have the specified lower bound.
+
+For example, a matrix type with fixed lower bounds of zero for each dimension
+can be declared by the following:
+
+.. code-block:: ada
+
+    type Matrix is
+      array (Natural range 0 .. <>, Natural range 0 .. <>) of Integer;
+
+Objects of type ``Matrix`` declared with an index constraint must have index
+ranges starting at zero:
+
+.. code-block:: ada
+
+    M1 : Matrix (0 .. 9, 0 .. 19);
+    M2 : Matrix (2 .. 11, 3 .. 22);  -- Warning about bounds; will raise CE
+
+Similarly, a subtype of ``String`` can be declared that specifies the lower
+bound of objects of that subtype to be ``1``:
+
+ .. code-block:: ada
+
+    subtype String_1 is String (1 .. <>);
+
+If a string slice is passed to a formal of subtype ``String_1`` in a call to a
+subprogram ``S``, the slice's bounds will "slide" so that the lower bound is
+``1``.
+
+Within ``S``, the lower bound of the formal is known to be ``1``, so, unlike a
+normal unconstrained ``String`` formal, there is no need to worry about
+accounting for other possible lower-bound values. Sliding of bounds also occurs
+in other contexts, such as for object declarations with an unconstrained
+subtype with fixed lower bound, as well as in subtype conversions.
+
+Use of this feature increases safety by simplifying code, and can also improve
+the efficiency of indexing operations, since the compiler statically knows the
+lower bound of unconstrained array formals when the formal's subtype has index
+ranges with static fixed lower bounds.
+
+Link to the original RFC:
+https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-fixed-lower-bound.rst
+
+Prefixed-view notation for calls to primitive subprograms of untagged types
+---------------------------------------------------------------------------
+
+When operating on an untagged type, if it has any primitive operations, and the
+first parameter of an operation is of the type (or is an access parameter with
+an anonymous type that designates the type), you may invoke these operations
+using an ``object.op(...)`` notation, where the parameter that would normally be
+the first parameter is brought out front, and the remaining parameters (if any)
+appear within parentheses after the name of the primitive operation.
+
+This same notation is already available for tagged types. This extension allows
+for untagged types. It is allowed for all primitive operations of the type
+independent of whether they were originally declared in a package spec or its
+private part, or were inherited and/or overridden as part of a derived type
+declaration occuring anywhere, so long as the first parameter is of the type,
+or an access parameter designating the type.
+
+For example:
+
+.. code-block:: ada
+
+    generic
+       type Elem_Type is private;
+    package Vectors is
+        type Vector is private;
+        procedure Add_Element (V : in out Vector; Elem : Elem_Type);
+        function Nth_Element (V : Vector; N : Positive) return Elem_Type;
+        function Length (V : Vector) return Natural;
+    private
+        function Capacity (V : Vector) return Natural;
+           --  Return number of elements that may be added without causing
+           --  any new allocation of space
+
+        type Vector is ...
+          with Type_Invariant => Vector.Length <= Vector.Capacity;
+        ...
+    end Vectors;
+
+    package Int_Vecs is new Vectors(Integer);
+
+    V : Int_Vecs.Vector;
+    ...
+    V.Add_Element(42);
+    V.Add_Element(-33);
+
+    pragma Assert (V.Length = 2);
+    pragma Assert (V.Nth_Element(1) = 42);
+
+Link to the original RFC:
+https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-prefixed-untagged.rst
+
+Expression defaults for generic formal functions
+------------------------------------------------
+
+The declaration of a generic formal function is allowed to specify
+an expression as a default, using the syntax of an expression function.
+
+Here is an example of this feature:
+
+.. code-block:: ada
+
+    generic
+       type T is private;
+       with function Copy (Item : T) return T is (Item); -- Defaults to Item
+    package Stacks is
+
+       type Stack is limited private;
+
+       procedure Push (S : in out Stack; X : T); -- Calls Copy on X
+       function Pop (S : in out Stack) return T; -- Calls Copy to return item
+
+    private
+       -- ...
+    end Stacks;
+
+Link to the original RFC:
+https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-expression-functions-as-default-for-generic-formal-function-parameters.rst
+
+String interpolation
+--------------------
+
+The syntax for string literals is extended to support string interpolation.
+
+Within an interpolated string literal, an arbitrary expression, when
+enclosed in ``{ ... }``, is expanded at run time into the result of calling
+``'Image`` on the result of evaluating the expression enclosed by the brace
+characters, unless it is already a string or a single character.
+
+Here is an example of this feature where the expressions ``Name`` and ``X + Y``
+will be evaluated and included in the string.
+
+.. code-block:: ada
+
+   procedure Test_Interpolation is
+      X    : Integer := 12;
+      Y    : Integer := 15;
+      Name : String := "Leo";
+   begin
+      Put_Line (f"The name is {Name} and the sum is {X + Y}.");
+   end Test_Interpolation;
+
+In addition, an escape character (``\``) is provided for inserting certain
+standard control characters (such as ``\t`` for tabulation or ``\n`` for
+newline) or to escape characters with special significance to the
+interpolated string syntax, namely ``"``, ``{``, ``}``,and ``\`` itself.
+
+=================   =================
+escaped_character   meaning
+-----------------   -----------------
+``\a``              ALERT
+``\b``              BACKSPACE
+``\f``              FORM FEED
+``\n``              LINE FEED
+``\r``              CARRIAGE RETURN
+``\t``              CHARACTER TABULATION
+``\v``              LINE TABULATION
+``\0``              NUL
+-----------------   -----------------
+``\\``              ``\``
+``\"``              ``"``
+``\{``              ``{``
+``\}``              ``}``
+=================   =================
+
+Note that, unlike normal string literals, doubled characters have no
+special significance. So to include a double-quote or a brace character
+in an interpolated string, they must be preceded by a ``\``.
+For example:
+
+.. code-block:: ada
+
+    Put_Line
+      (f"X = {X} and Y = {Y} and X+Y = {X+Y};\n" &
+       f" a double quote is \" and" &
+       f" an open brace is \{");
+
+Finally, a syntax is provided for creating multi-line string literals,
+without having to explicitly use an escape sequence such as ``\n``. For
+example:
+
+.. code-block:: ada
+
+    Put_Line
+      (f"This is a multi-line"
+        "string literal"
+        "There is no ambiguity about how many"
+        "spaces are included in each line");
+
+Here is a link to the original RFC   :
+https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-string-interpolation.rst
+
+Constrained attribute for generic objects
+-----------------------------------------
+
+The ``Constrained`` attribute is permitted for objects of generic types. The
+result indicates whether the corresponding actual is constrained.
+
+``Static`` aspect on intrinsic functions
+----------------------------------------
+
+The Ada 202x ``Static`` aspect can be specified on Intrinsic imported functions
+and the compiler will evaluate some of these intrinsics statically, in
+particular the ``Shift_Left`` and ``Shift_Right`` intrinsics.
+
+.. _Experimental_Language_Extensions:
+
+Experimental Language Extensions
+================================
+
+Pragma Storage_Model
+--------------------
+
+This feature proposes to redesign the concepts of Storage Pools into a more
+efficient model allowing higher performances and easier integration with low
+footprint embedded run-times.
+
+It also extends it to support distributed memory models, in particular to
+support interactions with GPU.
+
+Here is a link to the full RFC:
+https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-storage-model.rst
+
+Simpler accessibility model
+---------------------------
+
+The goal of this feature is to restore a common understanding of accessibility
+rules for implementers and users alike. The new rules should both be effective
+at preventing errors and feel natural and compatible in an Ada environment
+while removing dynamic accessibility checking.
+
+Here is a link to the full RFC:
+https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-simpler-accessibility.md

diff --git a/gcc/ada/doc/gnat_rm/implementation_defined_pragmas.rst b/gcc/ada/doc/gnat_rm/implementation_defined_pragmas.rst
index 725d52418455350e9c2ac8b7e96cd55bce96dfe1..a6c560010ef1c411291afe43f21ef5a5b029c7c5 100644 (file)
--- a/gcc/ada/doc/gnat_rm/implementation_defined_pragmas.rst
+++ b/gcc/ada/doc/gnat_rm/implementation_defined_pragmas.rst
@@ -2163,6 +2163,8 @@ To compile it you will have to use the *-gnatg* switch
 for compiling System units, as explained in the
 GNAT User's Guide.
 
+.. _Pragma_Extensions_Allowed:
+
 Pragma Extensions_Allowed
 =========================
 .. index:: Ada Extensions
@@ -2179,314 +2181,16 @@ Syntax:
 
 This configuration pragma enables (via the "On" or "All" argument) or disables
 (via the "Off" argument) the implementation extension mode; the pragma takes
-precedence over the *-gnatX* and *-gnatX0* command switches.
-
-If an argument of "All" is specified, the latest version of the Ada language
-is implemented (currently Ada 2022) and, in addition, a number
-of GNAT specific extensions are recognized. These extensions are listed
-below. An argument of "On" has the same effect except that only
-some, not all, of the listed extensions are enabled; those extensions
-are identified below.
-
-* Constrained attribute for generic objects
-
-  The ``Constrained`` attribute is permitted for objects of
-  generic types. The result indicates if the corresponding actual
-  is constrained.
-
-* ``Static`` aspect on intrinsic functions
-
-  The Ada 202x ``Static`` aspect can be specified on Intrinsic imported
-  functions and the compiler will evaluate some of these intrinsic statically,
-  in particular the ``Shift_Left`` and ``Shift_Right`` intrinsics.
-
-  An Extensions_Allowed pragma argument of "On" enables this extension.
-
-* ``[]`` aggregates
-
-  This new aggregate syntax for arrays and containers is provided under -gnatX
-  to experiment and confirm this new language syntax.
-
-* Additional ``when`` constructs
-
-  In addition to the ``exit when CONDITION`` control structure, several
-  additional constructs are allowed following this format. Including
-  ``return when CONDITION``, ``goto when CONDITION``, and
-  ``raise [with EXCEPTION_MESSAGE] when CONDITION.``
-
-  Some examples:
-
-  .. code-block:: ada
-
-      return Result when Variable > 10;
-
-      raise Program_Error with "Element is null" when Element = null;
-
-      goto End_Of_Subprogram when Variable = -1;
-
-* Casing on composite values (aka pattern matching)
-
-  The selector for a case statement may be of a composite type, subject to
-  some restrictions (described below). Aggregate syntax is used for choices
-  of such a case statement; however, in cases where a "normal" aggregate would
-  require a discrete value, a discrete subtype may be used instead; box
-  notation can also be used to match all values.
-
-  Consider this example:
-
-  .. code-block:: ada
-
-      type Rec is record
-         F1, F2 : Integer;
-      end record;
-
-      procedure Caser_1 (X : Rec) is
-      begin
-         case X is
-            when (F1 => Positive, F2 => Positive) =>
-               Do_This;
-            when (F1 => Natural, F2 => <>) | (F1 => <>, F2 => Natural) =>
-               Do_That;
-            when others =>
-                Do_The_Other_Thing;
-         end case;
-      end Caser_1;
-
-  If Caser_1 is called and both components of X are positive, then
-  Do_This will be called; otherwise, if either component is nonnegative
-  then Do_That will be called; otherwise, Do_The_Other_Thing will be called.
-
-  If the set of values that match the choice(s) of an earlier alternative
-  overlaps the corresponding set of a later alternative, then the first
-  set shall be a proper subset of the second (and the later alternative
-  will not be executed if the earlier alternative "matches"). All possible
-  values of the composite type shall be covered. The composite type of the
-  selector shall be an array or record type that is neither limited
-  class-wide. Currently, a "when others =>" case choice is required; it is
-  intended that this requirement will be relaxed at some point.
-
-  If a subcomponent's subtype does not meet certain restrictions, then
-  the only value that can be specified for that subcomponent in a case
-  choice expression is a "box" component association (which matches all
-  possible values for the subcomponent). This restriction applies if
-
-  - the component subtype is not a record, array, or discrete type; or
-
-  - the component subtype is subject to a non-static constraint or
-    has a predicate; or
-
-  - the component type is an enumeration type that is subject to an
-    enumeration representation clause; or
-
-  - the component type is a multidimensional array type or an
-    array type with a nonstatic index subtype.
-
-  Support for casing on arrays (and on records that contain arrays) is
-  currently subject to some restrictions. Non-positional
-  array aggregates are not supported as (or within) case choices. Likewise
-  for array type and subtype names. The current implementation exceeds
-  compile-time capacity limits in some annoyingly common scenarios; the
-  message generated in such cases is usually "Capacity exceeded in compiling
-  case statement with composite selector type".
-
-  In addition, pattern bindings are supported. This is a mechanism
-  for binding a name to a component of a matching value for use within
-  an alternative of a case statement. For a component association
-  that occurs within a case choice, the expression may be followed by
-  "is <identifier>". In the special case of a "box" component association,
-  the identifier may instead be provided within the box. Either of these
-  indicates that the given identifer denotes (a constant view of) the matching
-  subcomponent of the case selector. Binding is not yet supported for arrays
-  or subcomponents thereof.
-
-  Consider this example (which uses type Rec from the previous example):
-
-  .. code-block:: ada
-
-      procedure Caser_2 (X : Rec) is
-      begin
-         case X is
-            when (F1 => Positive is Abc, F2 => Positive) =>
-               Do_This (Abc)
-            when (F1 => Natural is N1, F2 => <N2>) |
-                 (F1 => <N2>, F2 => Natural is N1) =>
-               Do_That (Param_1 => N1, Param_2 => N2);
-            when others =>
-               Do_The_Other_Thing;
-         end case;
-      end Caser_2;
-
-  This example is the same as the previous one with respect to
-  determining whether Do_This, Do_That, or Do_The_Other_Thing will
-  be called. But for this version, Do_This takes a parameter and Do_That
-  takes two parameters. If Do_This is called, the actual parameter in the
-  call will be X.F1.
-
-  If Do_That is called, the situation is more complex because there are two
-  choices for that alternative. If Do_That is called because the first choice
-  matched (i.e., because X.F1 is nonnegative and either X.F1 or X.F2 is zero
-  or negative), then the actual parameters of the call will be (in order)
-  X.F1 and X.F2. If Do_That is called because the second choice matched (and
-  the first one did not), then the actual parameters will be reversed.
-
-  Within the choice list for single alternative, each choice must
-  define the same set of bindings and the component subtypes for
-  for a given identifer must all statically match. Currently, the case
-  of a binding for a nondiscrete component is not implemented.
-
-  An Extensions_Allowed pragma argument of "On" enables this extension.
-
-* Fixed lower bounds for array types and subtypes
-
-  Unconstrained array types and subtypes can be specified with a lower bound
-  that is fixed to a certain value, by writing an index range that uses the
-  syntax "<lower-bound-expression> .. <>". This guarantees that all objects
-  of the type or subtype will have the specified lower bound.
-
-  For example, a matrix type with fixed lower bounds of zero for each
-  dimension can be declared by the following:
-
-  .. code-block:: ada
-
-      type Matrix is
-        array (Natural range 0 .. <>, Natural range 0 .. <>) of Integer;
-
-  Objects of type Matrix declared with an index constraint must have index
-  ranges starting at zero:
-
-  .. code-block:: ada
-
-      M1 : Matrix (0 .. 9, 0 .. 19);
-      M2 : Matrix (2 .. 11, 3 .. 22);  -- Warning about bounds; will raise CE
+precedence over the ``-gnatX`` and ``-gnatX0`` command switches.
 
-  Similarly, a subtype of String can be declared that specifies the lower
-  bound of objects of that subtype to be 1:
-
-   .. code-block:: ada
-
-      subtype String_1 is String (1 .. <>);
-
-  If a string slice is passed to a formal of subtype String_1 in a call to
-  a subprogram S, the slice's bounds will "slide" so that the lower bound
-  is 1. Within S, the lower bound of the formal is known to be 1, so, unlike
-  a normal unconstrained String formal, there is no need to worry about
-  accounting for other possible lower-bound values. Sliding of bounds also
-  occurs in other contexts, such as for object declarations with an
-  unconstrained subtype with fixed lower bound, as well as in subtype
-  conversions.
-
-  Use of this feature increases safety by simplifying code, and can also
-  improve the efficiency of indexing operations, since the compiler statically
-  knows the lower bound of unconstrained array formals when the formal's
-  subtype has index ranges with static fixed lower bounds.
-
-  An Extensions_Allowed pragma argument of "On" enables this extension.
-
-* Prefixed-view notation for calls to primitive subprograms of untagged types
-
-  Since Ada 2005, calls to primitive subprograms of a tagged type that
-  have a "prefixed view" (see RM 4.1.3(9.2)) have been allowed to be
-  written using the form of a selected_component, with the first actual
-  parameter given as the prefix and the name of the subprogram as a
-  selector. This prefixed-view notation for calls is extended so as to
-  also allow such syntax for calls to primitive subprograms of untagged
-  types. The primitives of an untagged type T that have a prefixed view
-  are those where the first formal parameter of the subprogram either
-  is of type T or is an anonymous access parameter whose designated type
-  is T. For a type that has a component that happens to have the same
-  simple name as one of the type's primitive subprograms, where the
-  component is visible at the point of a selected_component using that
-  name, preference is given to the component in a selected_component
-  (as is currently the case for tagged types with such component names).
-
-  An Extensions_Allowed pragma argument of "On" enables this extension.
-
-* Expression defaults for generic formal functions
-
-  The declaration of a generic formal function is allowed to specify
-  an expression as a default, using the syntax of an expression function.
-
-  Here is an example of this feature:
-
-  .. code-block:: ada
-
-      generic
-         type T is private;
-         with function Copy (Item : T) return T is (Item); -- Defaults to Item
-      package Stacks is
-
-         type Stack is limited private;
-
-         procedure Push (S : in out Stack; X : T); -- Calls Copy on X
-
-         function Pop (S : in out Stack) return T; -- Calls Copy to return item
-
-      private
-         -- ...
-      end Stacks;
-
-* String Interpolation
-
-  The syntax for string literals is extended to support string interpolation.
-
-  Within an interpolated string literal, an arbitrary expression, when
-  enclosed in { ... }, is expanded at run time into the result of calling
-  'Image on the result of evaluating the expression enclosed by the brace
-  characters, unless it is already a string or a single character.
-
-  Here is an example of this feature where the expressions "Name" and
-  "X + Y" will be evaluated and included in the string.
-
-  .. code-block:: ada
-
-      Put_Line (f"The name is {Name} and the sum is {X + Y}.");
-
-  In addition, an escape character (\'\\\') is provided for inserting certain
-  standard control characters (such as \'\\t\' for tabulation or \'\\n\' for
-  newline) or to escape characters with special significance to the
-  interpolated string syntax, namely \'"\', \'{\', \'}\',and \'\\\' itself.
-
-=================   =================
-escaped_character   meaning
------------------   -----------------
-'\\a'                ALERT
-'\\b'                BACKSPACE
-'\\f'                FORM FEED
-'\\n'                LINE FEED
-'\\r'                CARRIAGE RETURN
-'\\t'                CHARACTER TABULATION
-'\\v'                LINE TABULATION
-'\\0'                NUL
------------------   -----------------
-'\\\\'               '\\'
-'\\"'                '"'
-'\\{'                '{'
-'\\}'                '}'
-=================   =================
-
-  Note that, unlike normal string literals, doubled characters have no
-  special significance. So to include a double-quote or a brace character
-  in an interpolated string, they must be preceded by a \'\\\'.
-  For example:
-
-  .. code-block:: ada
-
-      Put_Line
-        (f"X = {X} and Y = {Y} and X+Y = {X+Y};\n" &
-         f" a double quote is \" and" &
-         f" an open brace is \{");
-
-  Finally, a syntax is provided for creating multi-line string literals,
-  without having to explicitly use an escape sequence such as \'\\n\'. For
-  example:
-
-  .. code-block:: ada
+If an argument of ``"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:`here<Curated_Language_Extensions>`)
 
-      Put_Line
-        (f"This is a multi-line"
-          "string literal"
-          "There is no ambiguity about how many"
-          "spaces are included in each line");
+An argument of ``"All"`` has the same effect except that some extra
+experimental extensions are enabled (See the list here
+:ref:`here<Experimental_Language_Extensions>`)
 
 .. _Pragma-Extensions_Visible:
 

diff --git a/gcc/ada/gnat_rm.texi b/gcc/ada/gnat_rm.texi
index 3818f22414ae95a0735744361ce316235c1ccf60..6abf8f02be59a65b5d295f67a2661d867ad19291 100644 (file)
--- a/gcc/ada/gnat_rm.texi
+++ b/gcc/ada/gnat_rm.texi
@@ -77,6 +77,7 @@ included in the section entitled @ref{1,,GNU Free Documentation License}.
 * Specialized Needs Annexes:: 
 * Implementation of Specific Ada Features:: 
 * Implementation of Ada 2012 Features:: 
+* GNAT language extensions:: 
 * Security Hardening Features:: 
 * Obsolescent Features:: 
 * Compatibility and Porting Guide:: 
@@ -869,6 +870,28 @@ Code Generation for Array Aggregates
 * Aggregates with nonstatic bounds:: 
 * Aggregates in assignment statements:: 
 
+GNAT language extensions
+
+* How to activate the extended GNAT Ada superset:: 
+* Curated Extensions:: 
+* Experimental Language Extensions:: 
+
+Curated Extensions
+
+* Conditional when constructs:: 
+* Case pattern matching:: 
+* Fixed lower bounds for array types and subtypes:: 
+* Prefixed-view notation for calls to primitive subprograms of untagged types:: 
+* Expression defaults for generic formal functions:: 
+* String interpolation:: 
+* Constrained attribute for generic objects:: 
+* Static aspect on intrinsic functions:: 
+
+Experimental Language Extensions
+
+* Pragma Storage_Model:: 
+* Simpler accessibility model:: 
+
 Security Hardening Features
 
 * Register Scrubbing:: 
@@ -3597,7 +3620,7 @@ for compiling System units, as explained in the
 GNAT User’s Guide.
 
 @node Pragma Extensions_Allowed,Pragma Extensions_Visible,Pragma Extend_System,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-allowed}@anchor{64}
+@anchor{gnat_rm/implementation_defined_pragmas id12}@anchor{64}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-allowed}@anchor{65}
 @section Pragma Extensions_Allowed
 
 
@@ -3613,2330 +3636,1914 @@ pragma Extensions_Allowed (On | Off | All);
 
 This configuration pragma enables (via the “On” or “All” argument) or disables
 (via the “Off” argument) the implementation extension mode; the pragma takes
-precedence over the `-gnatX' and `-gnatX0' command switches.
-
-If an argument of “All” is specified, the latest version of the Ada language
-is implemented (currently Ada 2022) and, in addition, a number
-of GNAT specific extensions are recognized. These extensions are listed
-below. An argument of “On” has the same effect except that only
-some, not all, of the listed extensions are enabled; those extensions
-are identified below.
-
+precedence over the @code{-gnatX} and @code{-gnatX0} command switches.
 
-@itemize *
-
-@item 
-Constrained attribute for generic objects
+If an argument of @code{"On"} is specified, the latest version of the Ada language
+is implemented (currently Ada 2022) and, in addition, a curated set of GNAT
+specific extensions are recognized. (See the list here
+@ref{66,,here})
 
-The @code{Constrained} attribute is permitted for objects of
-generic types. The result indicates if the corresponding actual
-is constrained.
+An argument of @code{"All"} has the same effect except that some extra
+experimental extensions are enabled (See the list here
+@ref{67,,here})
 
-@item 
-@code{Static} aspect on intrinsic functions
+@node Pragma Extensions_Visible,Pragma External,Pragma Extensions_Allowed,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id13}@anchor{68}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-visible}@anchor{69}
+@section Pragma Extensions_Visible
 
-The Ada 202x @code{Static} aspect can be specified on Intrinsic imported
-functions and the compiler will evaluate some of these intrinsic statically,
-in particular the @code{Shift_Left} and @code{Shift_Right} intrinsics.
 
-An Extensions_Allowed pragma argument of “On” enables this extension.
+Syntax:
 
-@item 
-@code{[]} aggregates
+@example
+pragma Extensions_Visible [ (static_boolean_EXPRESSION) ];
+@end example
 
-This new aggregate syntax for arrays and containers is provided under -gnatX
-to experiment and confirm this new language syntax.
+For the semantics of this pragma, see the entry for aspect @code{Extensions_Visible}
+in the SPARK 2014 Reference Manual, section 6.1.7.
 
-@item 
-Additional @code{when} constructs
+@node Pragma External,Pragma External_Name_Casing,Pragma Extensions_Visible,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-external}@anchor{6a}
+@section Pragma External
 
-In addition to the @code{exit when CONDITION} control structure, several
-additional constructs are allowed following this format. Including
-@code{return when CONDITION}, @code{goto when CONDITION}, and
-@code{raise [with EXCEPTION_MESSAGE] when CONDITION.}
 
-Some examples:
+Syntax:
 
 @example
-return Result when Variable > 10;
-
-raise Program_Error with "Element is null" when Element = null;
-
-goto End_Of_Subprogram when Variable = -1;
+pragma External (
+  [   Convention    =>] convention_IDENTIFIER,
+  [   Entity        =>] LOCAL_NAME
+  [, [External_Name =>] static_string_EXPRESSION ]
+  [, [Link_Name     =>] static_string_EXPRESSION ]);
 @end example
 
-@item 
-Casing on composite values (aka pattern matching)
-
-The selector for a case statement may be of a composite type, subject to
-some restrictions (described below). Aggregate syntax is used for choices
-of such a case statement; however, in cases where a “normal” aggregate would
-require a discrete value, a discrete subtype may be used instead; box
-notation can also be used to match all values.
-
-Consider this example:
+This pragma is identical in syntax and semantics to pragma
+@code{Export} as defined in the Ada Reference Manual.  It is
+provided for compatibility with some Ada 83 compilers that
+used this pragma for exactly the same purposes as pragma
+@code{Export} before the latter was standardized.
 
-@example
-type Rec is record
-   F1, F2 : Integer;
-end record;
+@node Pragma External_Name_Casing,Pragma Fast_Math,Pragma External,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-external-name-casing}@anchor{6b}
+@section Pragma External_Name_Casing
 
-procedure Caser_1 (X : Rec) is
-begin
-   case X is
-      when (F1 => Positive, F2 => Positive) =>
-         Do_This;
-      when (F1 => Natural, F2 => <>) | (F1 => <>, F2 => Natural) =>
-         Do_That;
-      when others =>
-          Do_The_Other_Thing;
-   end case;
-end Caser_1;
-@end example
 
-If Caser_1 is called and both components of X are positive, then
-Do_This will be called; otherwise, if either component is nonnegative
-then Do_That will be called; otherwise, Do_The_Other_Thing will be called.
+@geindex Dec Ada 83 casing compatibility
 
-If the set of values that match the choice(s) of an earlier alternative
-overlaps the corresponding set of a later alternative, then the first
-set shall be a proper subset of the second (and the later alternative
-will not be executed if the earlier alternative “matches”). All possible
-values of the composite type shall be covered. The composite type of the
-selector shall be an array or record type that is neither limited
-class-wide. Currently, a “when others =>” case choice is required; it is
-intended that this requirement will be relaxed at some point.
+@geindex External Names
+@geindex casing
 
-If a subcomponent’s subtype does not meet certain restrictions, then
-the only value that can be specified for that subcomponent in a case
-choice expression is a “box” component association (which matches all
-possible values for the subcomponent). This restriction applies if
+@geindex Casing of External names
 
+Syntax:
 
-@itemize -
+@example
+pragma External_Name_Casing (
+  Uppercase | Lowercase
+  [, Uppercase | Lowercase | As_Is]);
+@end example
 
-@item 
-the component subtype is not a record, array, or discrete type; or
+This pragma provides control over the casing of external names associated
+with Import and Export pragmas.  There are two cases to consider:
 
-@item 
-the component subtype is subject to a non-static constraint or
-has a predicate; or
 
-@item 
-the component type is an enumeration type that is subject to an
-enumeration representation clause; or
+@itemize *
 
 @item 
-the component type is a multidimensional array type or an
-array type with a nonstatic index subtype.
-@end itemize
-
-Support for casing on arrays (and on records that contain arrays) is
-currently subject to some restrictions. Non-positional
-array aggregates are not supported as (or within) case choices. Likewise
-for array type and subtype names. The current implementation exceeds
-compile-time capacity limits in some annoyingly common scenarios; the
-message generated in such cases is usually “Capacity exceeded in compiling
-case statement with composite selector type”.
-
-In addition, pattern bindings are supported. This is a mechanism
-for binding a name to a component of a matching value for use within
-an alternative of a case statement. For a component association
-that occurs within a case choice, the expression may be followed by
-“is <identifier>”. In the special case of a “box” component association,
-the identifier may instead be provided within the box. Either of these
-indicates that the given identifer denotes (a constant view of) the matching
-subcomponent of the case selector. Binding is not yet supported for arrays
-or subcomponents thereof.
+Implicit external names
 
-Consider this example (which uses type Rec from the previous example):
+Implicit external names are derived from identifiers.  The most common case
+arises when a standard Ada Import or Export pragma is used with only two
+arguments, as in:
 
 @example
-procedure Caser_2 (X : Rec) is
-begin
-   case X is
-      when (F1 => Positive is Abc, F2 => Positive) =>
-         Do_This (Abc)
-      when (F1 => Natural is N1, F2 => <N2>) |
-           (F1 => <N2>, F2 => Natural is N1) =>
-         Do_That (Param_1 => N1, Param_2 => N2);
-      when others =>
-         Do_The_Other_Thing;
-   end case;
-end Caser_2;
+pragma Import (C, C_Routine);
 @end example
 
-This example is the same as the previous one with respect to
-determining whether Do_This, Do_That, or Do_The_Other_Thing will
-be called. But for this version, Do_This takes a parameter and Do_That
-takes two parameters. If Do_This is called, the actual parameter in the
-call will be X.F1.
-
-If Do_That is called, the situation is more complex because there are two
-choices for that alternative. If Do_That is called because the first choice
-matched (i.e., because X.F1 is nonnegative and either X.F1 or X.F2 is zero
-or negative), then the actual parameters of the call will be (in order)
-X.F1 and X.F2. If Do_That is called because the second choice matched (and
-the first one did not), then the actual parameters will be reversed.
-
-Within the choice list for single alternative, each choice must
-define the same set of bindings and the component subtypes for
-for a given identifer must all statically match. Currently, the case
-of a binding for a nondiscrete component is not implemented.
+Since Ada is a case-insensitive language, the spelling of the identifier in
+the Ada source program does not provide any information on the desired
+casing of the external name, and so a convention is needed.  In GNAT the
+default treatment is that such names are converted to all lower case
+letters.  This corresponds to the normal C style in many environments.
+The first argument of pragma @code{External_Name_Casing} can be used to
+control this treatment.  If @code{Uppercase} is specified, then the name
+will be forced to all uppercase letters.  If @code{Lowercase} is specified,
+then the normal default of all lower case letters will be used.
 
-An Extensions_Allowed pragma argument of “On” enables this extension.
+This same implicit treatment is also used in the case of extended DEC Ada 83
+compatible Import and Export pragmas where an external name is explicitly
+specified using an identifier rather than a string.
 
 @item 
-Fixed lower bounds for array types and subtypes
-
-Unconstrained array types and subtypes can be specified with a lower bound
-that is fixed to a certain value, by writing an index range that uses the
-syntax “<lower-bound-expression> .. <>”. This guarantees that all objects
-of the type or subtype will have the specified lower bound.
+Explicit external names
 
-For example, a matrix type with fixed lower bounds of zero for each
-dimension can be declared by the following:
+Explicit external names are given as string literals.  The most common case
+arises when a standard Ada Import or Export pragma is used with three
+arguments, as in:
 
 @example
-type Matrix is
-  array (Natural range 0 .. <>, Natural range 0 .. <>) of Integer;
+pragma Import (C, C_Routine, "C_routine");
 @end example
 
-Objects of type Matrix declared with an index constraint must have index
-ranges starting at zero:
-
-@example
-M1 : Matrix (0 .. 9, 0 .. 19);
-M2 : Matrix (2 .. 11, 3 .. 22);  -- Warning about bounds; will raise CE
-@end example
+In this case, the string literal normally provides the exact casing required
+for the external name.  The second argument of pragma
+@code{External_Name_Casing} may be used to modify this behavior.
+If @code{Uppercase} is specified, then the name
+will be forced to all uppercase letters.  If @code{Lowercase} is specified,
+then the name will be forced to all lowercase letters.  A specification of
+@code{As_Is} provides the normal default behavior in which the casing is
+taken from the string provided.
+@end itemize
 
-Similarly, a subtype of String can be declared that specifies the lower
-bound of objects of that subtype to be 1:
+This pragma may appear anywhere that a pragma is valid. In particular, it
+can be used as a configuration pragma in the @code{gnat.adc} file, in which
+case it applies to all subsequent compilations, or it can be used as a program
+unit pragma, in which case it only applies to the current unit, or it can
+be used more locally to control individual Import/Export pragmas.
 
-@quotation
+It was primarily intended for use with OpenVMS systems, where many
+compilers convert all symbols to upper case by default.  For interfacing to
+such compilers (e.g., the DEC C compiler), it may be convenient to use
+the pragma:
 
 @example
-subtype String_1 is String (1 .. <>);
+pragma External_Name_Casing (Uppercase, Uppercase);
 @end example
-@end quotation
 
-If a string slice is passed to a formal of subtype String_1 in a call to
-a subprogram S, the slice’s bounds will “slide” so that the lower bound
-is 1. Within S, the lower bound of the formal is known to be 1, so, unlike
-a normal unconstrained String formal, there is no need to worry about
-accounting for other possible lower-bound values. Sliding of bounds also
-occurs in other contexts, such as for object declarations with an
-unconstrained subtype with fixed lower bound, as well as in subtype
-conversions.
+to enforce the upper casing of all external symbols.
 
-Use of this feature increases safety by simplifying code, and can also
-improve the efficiency of indexing operations, since the compiler statically
-knows the lower bound of unconstrained array formals when the formal’s
-subtype has index ranges with static fixed lower bounds.
+@node Pragma Fast_Math,Pragma Favor_Top_Level,Pragma External_Name_Casing,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-fast-math}@anchor{6c}
+@section Pragma Fast_Math
 
-An Extensions_Allowed pragma argument of “On” enables this extension.
 
-@item 
-Prefixed-view notation for calls to primitive subprograms of untagged types
+Syntax:
 
-Since Ada 2005, calls to primitive subprograms of a tagged type that
-have a “prefixed view” (see RM 4.1.3(9.2)) have been allowed to be
-written using the form of a selected_component, with the first actual
-parameter given as the prefix and the name of the subprogram as a
-selector. This prefixed-view notation for calls is extended so as to
-also allow such syntax for calls to primitive subprograms of untagged
-types. The primitives of an untagged type T that have a prefixed view
-are those where the first formal parameter of the subprogram either
-is of type T or is an anonymous access parameter whose designated type
-is T. For a type that has a component that happens to have the same
-simple name as one of the type’s primitive subprograms, where the
-component is visible at the point of a selected_component using that
-name, preference is given to the component in a selected_component
-(as is currently the case for tagged types with such component names).
+@example
+pragma Fast_Math;
+@end example
 
-An Extensions_Allowed pragma argument of “On” enables this extension.
+This is a configuration pragma which activates a mode in which speed is
+considered more important for floating-point operations than absolutely
+accurate adherence to the requirements of the standard. Currently the
+following operations are affected:
 
-@item 
-Expression defaults for generic formal functions
 
-The declaration of a generic formal function is allowed to specify
-an expression as a default, using the syntax of an expression function.
+@table @asis
 
-Here is an example of this feature:
+@item `Complex Multiplication'
 
-@example
-generic
-   type T is private;
-   with function Copy (Item : T) return T is (Item); -- Defaults to Item
-package Stacks is
+The normal simple formula for complex multiplication can result in intermediate
+overflows for numbers near the end of the range. The Ada standard requires that
+this situation be detected and corrected by scaling, but in Fast_Math mode such
+cases will simply result in overflow. Note that to take advantage of this you
+must instantiate your own version of @code{Ada.Numerics.Generic_Complex_Types}
+under control of the pragma, rather than use the preinstantiated versions.
+@end table
 
-   type Stack is limited private;
+@node Pragma Favor_Top_Level,Pragma Finalize_Storage_Only,Pragma Fast_Math,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id14}@anchor{6d}@anchor{gnat_rm/implementation_defined_pragmas pragma-favor-top-level}@anchor{6e}
+@section Pragma Favor_Top_Level
 
-   procedure Push (S : in out Stack; X : T); -- Calls Copy on X
 
-   function Pop (S : in out Stack) return T; -- Calls Copy to return item
+Syntax:
 
-private
-   -- ...
-end Stacks;
+@example
+pragma Favor_Top_Level (type_NAME);
 @end example
 
-@item 
-String Interpolation
+The argument of pragma @code{Favor_Top_Level} must be a named access-to-subprogram
+type. This pragma is an efficiency hint to the compiler, regarding the use of
+@code{'Access} or @code{'Unrestricted_Access} on nested (non-library-level) subprograms.
+The pragma means that nested subprograms are not used with this type, or are
+rare, so that the generated code should be efficient in the top-level case.
+When this pragma is used, dynamically generated trampolines may be used on some
+targets for nested subprograms. See restriction @code{No_Implicit_Dynamic_Code}.
 
-The syntax for string literals is extended to support string interpolation.
+@node Pragma Finalize_Storage_Only,Pragma Float_Representation,Pragma Favor_Top_Level,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-finalize-storage-only}@anchor{6f}
+@section Pragma Finalize_Storage_Only
 
-Within an interpolated string literal, an arbitrary expression, when
-enclosed in @{ … @}, is expanded at run time into the result of calling
-‘Image on the result of evaluating the expression enclosed by the brace
-characters, unless it is already a string or a single character.
 
-Here is an example of this feature where the expressions “Name” and
-“X + Y” will be evaluated and included in the string.
+Syntax:
 
 @example
-Put_Line (f"The name is @{Name@} and the sum is @{X + Y@}.");
+pragma Finalize_Storage_Only (first_subtype_LOCAL_NAME);
 @end example
 
-In addition, an escape character ('\') is provided for inserting certain
-standard control characters (such as '\t' for tabulation or '\n' for
-newline) or to escape characters with special significance to the
-interpolated string syntax, namely '”', '@{', '@}',and '\' itself.
-@end itemize
-
+The argument of pragma @code{Finalize_Storage_Only} must denote a local type which
+is derived from @code{Ada.Finalization.Controlled} or @code{Limited_Controlled}. The
+pragma suppresses the call to @code{Finalize} for declared library-level objects
+of the argument type. This is mostly useful for types where finalization is
+only used to deal with storage reclamation since in most environments it is
+not necessary to reclaim memory just before terminating execution, hence the
+name. Note that this pragma does not suppress Finalize calls for library-level
+heap-allocated objects (see pragma @code{No_Heap_Finalization}).
 
-@multitable {xxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxxxxxxxxxxxx} 
-@item
+@node Pragma Float_Representation,Pragma Ghost,Pragma Finalize_Storage_Only,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-float-representation}@anchor{70}
+@section Pragma Float_Representation
 
-escaped_character
 
-@tab
+Syntax:
 
-meaning
+@example
+pragma Float_Representation (FLOAT_REP[, float_type_LOCAL_NAME]);
 
-@item
+FLOAT_REP ::= VAX_Float | IEEE_Float
+@end example
 
-‘\a’
+In the one argument form, this pragma is a configuration pragma which
+allows control over the internal representation chosen for the predefined
+floating point types declared in the packages @code{Standard} and
+@code{System}. This pragma is only provided for compatibility and has no effect.
 
-@tab
+The two argument form specifies the representation to be used for
+the specified floating-point type. The argument must
+be @code{IEEE_Float} to specify the use of IEEE format, as follows:
 
-ALERT
 
-@item
+@itemize *
 
-‘\b’
+@item 
+For a digits value of 6, 32-bit IEEE short format will be used.
 
-@tab
+@item 
+For a digits value of 15, 64-bit IEEE long format will be used.
 
-BACKSPACE
+@item 
+No other value of digits is permitted.
+@end itemize
 
-@item
+@node Pragma Ghost,Pragma Global,Pragma Float_Representation,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id15}@anchor{71}@anchor{gnat_rm/implementation_defined_pragmas pragma-ghost}@anchor{72}
+@section Pragma Ghost
 
-‘\f’
 
-@tab
+Syntax:
 
-FORM FEED
+@example
+pragma Ghost [ (static_boolean_EXPRESSION) ];
+@end example
 
-@item
+For the semantics of this pragma, see the entry for aspect @code{Ghost} in the SPARK
+2014 Reference Manual, section 6.9.
 
-‘\n’
+@node Pragma Global,Pragma Ident,Pragma Ghost,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id16}@anchor{73}@anchor{gnat_rm/implementation_defined_pragmas pragma-global}@anchor{74}
+@section Pragma Global
 
-@tab
 
-LINE FEED
+Syntax:
 
-@item
+@example
+pragma Global (GLOBAL_SPECIFICATION);
 
-‘\r’
+GLOBAL_SPECIFICATION ::=
+     null
+  | (GLOBAL_LIST)
+  | (MODED_GLOBAL_LIST @{, MODED_GLOBAL_LIST@})
 
-@tab
+MODED_GLOBAL_LIST ::= MODE_SELECTOR => GLOBAL_LIST
 
-CARRIAGE RETURN
+MODE_SELECTOR ::= In_Out | Input | Output | Proof_In
+GLOBAL_LIST   ::= GLOBAL_ITEM | (GLOBAL_ITEM @{, GLOBAL_ITEM@})
+GLOBAL_ITEM   ::= NAME
+@end example
 
-@item
+For the semantics of this pragma, see the entry for aspect @code{Global} in the
+SPARK 2014 Reference Manual, section 6.1.4.
 
-‘\t’
+@node Pragma Ident,Pragma Ignore_Pragma,Pragma Global,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ident}@anchor{75}
+@section Pragma Ident
 
-@tab
 
-CHARACTER TABULATION
+Syntax:
 
-@item
+@example
+pragma Ident (static_string_EXPRESSION);
+@end example
 
-‘\v’
+This pragma is identical in effect to pragma @code{Comment}. It is provided
+for compatibility with other Ada compilers providing this pragma.
 
-@tab
+@node Pragma Ignore_Pragma,Pragma Implementation_Defined,Pragma Ident,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ignore-pragma}@anchor{76}
+@section Pragma Ignore_Pragma
 
-LINE TABULATION
 
-@item
+Syntax:
 
-‘\0’
+@example
+pragma Ignore_Pragma (pragma_IDENTIFIER);
+@end example
 
-@tab
+This is a configuration pragma
+that takes a single argument that is a simple identifier. Any subsequent
+use of a pragma whose pragma identifier matches this argument will be
+silently ignored. This may be useful when legacy code or code intended
+for compilation with some other compiler contains pragmas that match the
+name, but not the exact implementation, of a GNAT pragma. The use of this
+pragma allows such pragmas to be ignored, which may be useful in CodePeer
+mode, or during porting of legacy code.
 
-NUL
+@node Pragma Implementation_Defined,Pragma Implemented,Pragma Ignore_Pragma,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-implementation-defined}@anchor{77}
+@section Pragma Implementation_Defined
 
-@item
 
-‘\\’
+Syntax:
 
-@tab
+@example
+pragma Implementation_Defined (local_NAME);
+@end example
 
-‘\’
+This pragma marks a previously declared entity as implementation-defined.
+For an overloaded entity, applies to the most recent homonym.
 
-@item
+@example
+pragma Implementation_Defined;
+@end example
 
-‘\”’
+The form with no arguments appears anywhere within a scope, most
+typically a package spec, and indicates that all entities that are
+defined within the package spec are Implementation_Defined.
 
-@tab
+This pragma is used within the GNAT runtime library to identify
+implementation-defined entities introduced in language-defined units,
+for the purpose of implementing the No_Implementation_Identifiers
+restriction.
 
-‘”’
+@node Pragma Implemented,Pragma Implicit_Packing,Pragma Implementation_Defined,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-implemented}@anchor{78}
+@section Pragma Implemented
 
-@item
 
-‘\@{’
+Syntax:
 
-@tab
+@example
+pragma Implemented (procedure_LOCAL_NAME, implementation_kind);
 
-‘@{’
+implementation_kind ::= By_Entry | By_Protected_Procedure | By_Any
+@end example
 
-@item
+This is an Ada 2012 representation pragma which applies to protected, task
+and synchronized interface primitives. The use of pragma Implemented provides
+a way to impose a static requirement on the overriding operation by adhering
+to one of the three implementation kinds: entry, protected procedure or any of
+the above. This pragma is available in all earlier versions of Ada as an
+implementation-defined pragma.
 
-‘\@}’
+@example
+type Synch_Iface is synchronized interface;
+procedure Prim_Op (Obj : in out Iface) is abstract;
+pragma Implemented (Prim_Op, By_Protected_Procedure);
 
-@tab
+protected type Prot_1 is new Synch_Iface with
+   procedure Prim_Op;  --  Legal
+end Prot_1;
 
-‘@}’
+protected type Prot_2 is new Synch_Iface with
+   entry Prim_Op;      --  Illegal
+end Prot_2;
 
-@end multitable
+task type Task_Typ is new Synch_Iface with
+   entry Prim_Op;      --  Illegal
+end Task_Typ;
+@end example
 
+When applied to the procedure_or_entry_NAME of a requeue statement, pragma
+Implemented determines the runtime behavior of the requeue. Implementation kind
+By_Entry guarantees that the action of requeueing will proceed from an entry to
+another entry. Implementation kind By_Protected_Procedure transforms the
+requeue into a dispatching call, thus eliminating the chance of blocking. Kind
+By_Any shares the behavior of By_Entry and By_Protected_Procedure depending on
+the target’s overriding subprogram kind.
 
-@quotation
+@node Pragma Implicit_Packing,Pragma Import_Function,Pragma Implemented,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-implicit-packing}@anchor{79}
+@section Pragma Implicit_Packing
 
-Note that, unlike normal string literals, doubled characters have no
-special significance. So to include a double-quote or a brace character
-in an interpolated string, they must be preceded by a '\'.
-For example:
 
-@example
-Put_Line
-  (f"X = @{X@} and Y = @{Y@} and X+Y = @{X+Y@};\n" &
-   f" a double quote is \" and" &
-   f" an open brace is \@{");
-@end example
+@geindex Rational Profile
 
-Finally, a syntax is provided for creating multi-line string literals,
-without having to explicitly use an escape sequence such as '\n'. For
-example:
+Syntax:
 
 @example
-Put_Line
-  (f"This is a multi-line"
-    "string literal"
-    "There is no ambiguity about how many"
-    "spaces are included in each line");
+pragma Implicit_Packing;
 @end example
-@end quotation
-
-@node Pragma Extensions_Visible,Pragma External,Pragma Extensions_Allowed,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id12}@anchor{65}@anchor{gnat_rm/implementation_defined_pragmas pragma-extensions-visible}@anchor{66}
-@section Pragma Extensions_Visible
 
-
-Syntax:
+This is a configuration pragma that requests implicit packing for packed
+arrays for which a size clause is given but no explicit pragma Pack or
+specification of Component_Size is present. It also applies to records
+where no record representation clause is present. Consider this example:
 
 @example
-pragma Extensions_Visible [ (static_boolean_EXPRESSION) ];
+type R is array (0 .. 7) of Boolean;
+for R'Size use 8;
 @end example
 
-For the semantics of this pragma, see the entry for aspect @code{Extensions_Visible}
-in the SPARK 2014 Reference Manual, section 6.1.7.
+In accordance with the recommendation in the RM (RM 13.3(53)), a Size clause
+does not change the layout of a composite object. So the Size clause in the
+above example is normally rejected, since the default layout of the array uses
+8-bit components, and thus the array requires a minimum of 64 bits.
 
-@node Pragma External,Pragma External_Name_Casing,Pragma Extensions_Visible,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-external}@anchor{67}
-@section Pragma External
+If this declaration is compiled in a region of code covered by an occurrence
+of the configuration pragma Implicit_Packing, then the Size clause in this
+and similar examples will cause implicit packing and thus be accepted. For
+this implicit packing to occur, the type in question must be an array of small
+components whose size is known at compile time, and the Size clause must
+specify the exact size that corresponds to the number of elements in the array
+multiplied by the size in bits of the component type (both single and
+multi-dimensioned arrays can be controlled with this pragma).
 
+@geindex Array packing
 
-Syntax:
+Similarly, the following example shows the use in the record case
 
 @example
-pragma External (
-  [   Convention    =>] convention_IDENTIFIER,
-  [   Entity        =>] LOCAL_NAME
-  [, [External_Name =>] static_string_EXPRESSION ]
-  [, [Link_Name     =>] static_string_EXPRESSION ]);
+type r is record
+   a, b, c, d, e, f, g, h : boolean;
+   chr                    : character;
+end record;
+for r'size use 16;
 @end example
 
-This pragma is identical in syntax and semantics to pragma
-@code{Export} as defined in the Ada Reference Manual.  It is
-provided for compatibility with some Ada 83 compilers that
-used this pragma for exactly the same purposes as pragma
-@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{68}
-@section Pragma External_Name_Casing
-
-
-@geindex Dec Ada 83 casing compatibility
+Without a pragma Pack, each Boolean field requires 8 bits, so the
+minimum size is 72 bits, but with a pragma Pack, 16 bits would be
+sufficient. The use of pragma Implicit_Packing allows this record
+declaration to compile without an explicit pragma Pack.
 
-@geindex External Names
-@geindex casing
+@node Pragma Import_Function,Pragma Import_Object,Pragma Implicit_Packing,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-function}@anchor{7a}
+@section Pragma Import_Function
 
-@geindex Casing of External names
 
 Syntax:
 
 @example
-pragma External_Name_Casing (
-  Uppercase | Lowercase
-  [, Uppercase | Lowercase | As_Is]);
-@end example
+pragma Import_Function (
+     [Internal         =>] LOCAL_NAME,
+  [, [External         =>] EXTERNAL_SYMBOL]
+  [, [Parameter_Types  =>] PARAMETER_TYPES]
+  [, [Result_Type      =>] SUBTYPE_MARK]
+  [, [Mechanism        =>] MECHANISM]
+  [, [Result_Mechanism =>] MECHANISM_NAME]);
 
-This pragma provides control over the casing of external names associated
-with Import and Export pragmas.  There are two cases to consider:
+EXTERNAL_SYMBOL ::=
+  IDENTIFIER
+| static_string_EXPRESSION
 
+PARAMETER_TYPES ::=
+  null
+| TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@}
 
-@itemize *
+TYPE_DESIGNATOR ::=
+  subtype_NAME
+| subtype_Name ' Access
 
-@item 
-Implicit external names
+MECHANISM ::=
+  MECHANISM_NAME
+| (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@})
 
-Implicit external names are derived from identifiers.  The most common case
-arises when a standard Ada Import or Export pragma is used with only two
-arguments, as in:
+MECHANISM_ASSOCIATION ::=
+  [formal_parameter_NAME =>] MECHANISM_NAME
 
-@example
-pragma Import (C, C_Routine);
+MECHANISM_NAME ::=
+  Value
+| Reference
 @end example
 
-Since Ada is a case-insensitive language, the spelling of the identifier in
-the Ada source program does not provide any information on the desired
-casing of the external name, and so a convention is needed.  In GNAT the
-default treatment is that such names are converted to all lower case
-letters.  This corresponds to the normal C style in many environments.
-The first argument of pragma @code{External_Name_Casing} can be used to
-control this treatment.  If @code{Uppercase} is specified, then the name
-will be forced to all uppercase letters.  If @code{Lowercase} is specified,
-then the normal default of all lower case letters will be used.
-
-This same implicit treatment is also used in the case of extended DEC Ada 83
-compatible Import and Export pragmas where an external name is explicitly
-specified using an identifier rather than a string.
-
-@item 
-Explicit external names
+This pragma is used in conjunction with a pragma @code{Import} to
+specify additional information for an imported function.  The pragma
+@code{Import} (or equivalent pragma @code{Interface}) must precede the
+@code{Import_Function} pragma and both must appear in the same
+declarative part as the function specification.
 
-Explicit external names are given as string literals.  The most common case
-arises when a standard Ada Import or Export pragma is used with three
-arguments, as in:
+The @code{Internal} argument must uniquely designate
+the function to which the
+pragma applies.  If more than one function name exists of this name in
+the declarative part you must use the @code{Parameter_Types} and
+@code{Result_Type} parameters to achieve the required unique
+designation.  Subtype marks in these parameters must exactly match the
+subtypes in the corresponding function specification, using positional
+notation to match parameters with subtype marks.
+The form with an @code{'Access} attribute can be used to match an
+anonymous access parameter.
 
-@example
-pragma Import (C, C_Routine, "C_routine");
-@end example
+You may optionally use the @code{Mechanism} and @code{Result_Mechanism}
+parameters to specify passing mechanisms for the
+parameters and result.  If you specify a single mechanism name, it
+applies to all parameters.  Otherwise you may specify a mechanism on a
+parameter by parameter basis using either positional or named
+notation.  If the mechanism is not specified, the default mechanism
+is used.
 
-In this case, the string literal normally provides the exact casing required
-for the external name.  The second argument of pragma
-@code{External_Name_Casing} may be used to modify this behavior.
-If @code{Uppercase} is specified, then the name
-will be forced to all uppercase letters.  If @code{Lowercase} is specified,
-then the name will be forced to all lowercase letters.  A specification of
-@code{As_Is} provides the normal default behavior in which the casing is
-taken from the string provided.
-@end itemize
+@node Pragma Import_Object,Pragma Import_Procedure,Pragma Import_Function,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-object}@anchor{7b}
+@section Pragma Import_Object
 
-This pragma may appear anywhere that a pragma is valid. In particular, it
-can be used as a configuration pragma in the @code{gnat.adc} file, in which
-case it applies to all subsequent compilations, or it can be used as a program
-unit pragma, in which case it only applies to the current unit, or it can
-be used more locally to control individual Import/Export pragmas.
 
-It was primarily intended for use with OpenVMS systems, where many
-compilers convert all symbols to upper case by default.  For interfacing to
-such compilers (e.g., the DEC C compiler), it may be convenient to use
-the pragma:
+Syntax:
 
 @example
-pragma External_Name_Casing (Uppercase, Uppercase);
+pragma Import_Object (
+     [Internal =>] LOCAL_NAME
+  [, [External =>] EXTERNAL_SYMBOL]
+  [, [Size     =>] EXTERNAL_SYMBOL]);
+
+EXTERNAL_SYMBOL ::=
+  IDENTIFIER
+| static_string_EXPRESSION
 @end example
 
-to enforce the upper casing of all external symbols.
+This pragma designates an object as imported, and apart from the
+extended rules for external symbols, is identical in effect to the use of
+the normal @code{Import} pragma applied to an object.  Unlike the
+subprogram case, you need not use a separate @code{Import} pragma,
+although you may do so (and probably should do so from a portability
+point of view).  @code{size} is syntax checked, but otherwise ignored by
+GNAT.
 
-@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{69}
-@section Pragma Fast_Math
+@node Pragma Import_Procedure,Pragma Import_Valued_Procedure,Pragma Import_Object,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-procedure}@anchor{7c}
+@section Pragma Import_Procedure
 
 
 Syntax:
 
 @example
-pragma Fast_Math;
-@end example
+pragma Import_Procedure (
+     [Internal        =>] LOCAL_NAME
+  [, [External        =>] EXTERNAL_SYMBOL]
+  [, [Parameter_Types =>] PARAMETER_TYPES]
+  [, [Mechanism       =>] MECHANISM]);
 
-This is a configuration pragma which activates a mode in which speed is
-considered more important for floating-point operations than absolutely
-accurate adherence to the requirements of the standard. Currently the
-following operations are affected:
+EXTERNAL_SYMBOL ::=
+  IDENTIFIER
+| static_string_EXPRESSION
 
+PARAMETER_TYPES ::=
+  null
+| TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@}
 
-@table @asis
+TYPE_DESIGNATOR ::=
+  subtype_NAME
+| subtype_Name ' Access
 
-@item `Complex Multiplication'
+MECHANISM ::=
+  MECHANISM_NAME
+| (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@})
 
-The normal simple formula for complex multiplication can result in intermediate
-overflows for numbers near the end of the range. The Ada standard requires that
-this situation be detected and corrected by scaling, but in Fast_Math mode such
-cases will simply result in overflow. Note that to take advantage of this you
-must instantiate your own version of @code{Ada.Numerics.Generic_Complex_Types}
-under control of the pragma, rather than use the preinstantiated versions.
-@end table
+MECHANISM_ASSOCIATION ::=
+  [formal_parameter_NAME =>] MECHANISM_NAME
 
-@node Pragma Favor_Top_Level,Pragma Finalize_Storage_Only,Pragma Fast_Math,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id13}@anchor{6a}@anchor{gnat_rm/implementation_defined_pragmas pragma-favor-top-level}@anchor{6b}
-@section Pragma Favor_Top_Level
+MECHANISM_NAME ::= Value | Reference
+@end example
+
+This pragma is identical to @code{Import_Function} except that it
+applies to a procedure rather than a function and the parameters
+@code{Result_Type} and @code{Result_Mechanism} are not permitted.
+
+@node Pragma Import_Valued_Procedure,Pragma Independent,Pragma Import_Procedure,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-import-valued-procedure}@anchor{7d}
+@section Pragma Import_Valued_Procedure
 
 
 Syntax:
 
 @example
-pragma Favor_Top_Level (type_NAME);
-@end example
+pragma Import_Valued_Procedure (
+     [Internal        =>] LOCAL_NAME
+  [, [External        =>] EXTERNAL_SYMBOL]
+  [, [Parameter_Types =>] PARAMETER_TYPES]
+  [, [Mechanism       =>] MECHANISM]);
 
-The argument of pragma @code{Favor_Top_Level} must be a named access-to-subprogram
-type. This pragma is an efficiency hint to the compiler, regarding the use of
-@code{'Access} or @code{'Unrestricted_Access} on nested (non-library-level) subprograms.
-The pragma means that nested subprograms are not used with this type, or are
-rare, so that the generated code should be efficient in the top-level case.
-When this pragma is used, dynamically generated trampolines may be used on some
-targets for nested subprograms. See restriction @code{No_Implicit_Dynamic_Code}.
+EXTERNAL_SYMBOL ::=
+  IDENTIFIER
+| static_string_EXPRESSION
 
-@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{6c}
-@section Pragma Finalize_Storage_Only
+PARAMETER_TYPES ::=
+  null
+| TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@}
 
+TYPE_DESIGNATOR ::=
+  subtype_NAME
+| subtype_Name ' Access
 
-Syntax:
+MECHANISM ::=
+  MECHANISM_NAME
+| (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@})
 
-@example
-pragma Finalize_Storage_Only (first_subtype_LOCAL_NAME);
+MECHANISM_ASSOCIATION ::=
+  [formal_parameter_NAME =>] MECHANISM_NAME
+
+MECHANISM_NAME ::= Value | Reference
 @end example
 
-The argument of pragma @code{Finalize_Storage_Only} must denote a local type which
-is derived from @code{Ada.Finalization.Controlled} or @code{Limited_Controlled}. The
-pragma suppresses the call to @code{Finalize} for declared library-level objects
-of the argument type. This is mostly useful for types where finalization is
-only used to deal with storage reclamation since in most environments it is
-not necessary to reclaim memory just before terminating execution, hence the
-name. Note that this pragma does not suppress Finalize calls for library-level
-heap-allocated objects (see pragma @code{No_Heap_Finalization}).
+This pragma is identical to @code{Import_Procedure} except that the
+first parameter of @code{LOCAL_NAME}, which must be present, must be of
+mode @code{out}, and externally the subprogram is treated as a function
+with this parameter as the result of the function.  The purpose of this
+capability is to allow the use of @code{out} and @code{in out}
+parameters in interfacing to external functions (which are not permitted
+in Ada functions).  You may optionally use the @code{Mechanism}
+parameters to specify passing mechanisms for the parameters.
+If you specify a single mechanism name, it applies to all parameters.
+Otherwise you may specify a mechanism on a parameter by parameter
+basis using either positional or named notation.  If the mechanism is not
+specified, the default mechanism is used.
 
-@node Pragma Float_Representation,Pragma Ghost,Pragma Finalize_Storage_Only,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-float-representation}@anchor{6d}
-@section Pragma Float_Representation
+Note that it is important to use this pragma in conjunction with a separate
+pragma Import that specifies the desired convention, since otherwise the
+default convention is Ada, which is almost certainly not what is required.
+
+@node Pragma Independent,Pragma Independent_Components,Pragma Import_Valued_Procedure,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-independent}@anchor{7e}
+@section Pragma Independent
 
 
 Syntax:
 
 @example
-pragma Float_Representation (FLOAT_REP[, float_type_LOCAL_NAME]);
-
-FLOAT_REP ::= VAX_Float | IEEE_Float
+pragma Independent (Local_NAME);
 @end example
 
-In the one argument form, this pragma is a configuration pragma which
-allows control over the internal representation chosen for the predefined
-floating point types declared in the packages @code{Standard} and
-@code{System}. This pragma is only provided for compatibility and has no effect.
-
-The two argument form specifies the representation to be used for
-the specified floating-point type. The argument must
-be @code{IEEE_Float} to specify the use of IEEE format, as follows:
+This pragma is standard in Ada 2012 mode (which also provides an aspect
+of the same name). It is also available as an implementation-defined
+pragma in all earlier versions. It specifies that the
+designated object or all objects of the designated type must be
+independently addressable. This means that separate tasks can safely
+manipulate such objects. For example, if two components of a record are
+independent, then two separate tasks may access these two components.
+This may place
+constraints on the representation of the object (for instance prohibiting
+tight packing).
 
+@node Pragma Independent_Components,Pragma Initial_Condition,Pragma Independent,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-independent-components}@anchor{7f}
+@section Pragma Independent_Components
 
-@itemize *
 
-@item 
-For a digits value of 6, 32-bit IEEE short format will be used.
+Syntax:
 
-@item 
-For a digits value of 15, 64-bit IEEE long format will be used.
+@example
+pragma Independent_Components (Local_NAME);
+@end example
 
-@item 
-No other value of digits is permitted.
-@end itemize
+This pragma is standard in Ada 2012 mode (which also provides an aspect
+of the same name). It is also available as an implementation-defined
+pragma in all earlier versions. It specifies that the components of the
+designated object, or the components of each object of the designated
+type, must be
+independently addressable. This means that separate tasks can safely
+manipulate separate components in the composite object. This may place
+constraints on the representation of the object (for instance prohibiting
+tight packing).
 
-@node Pragma Ghost,Pragma Global,Pragma Float_Representation,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id14}@anchor{6e}@anchor{gnat_rm/implementation_defined_pragmas pragma-ghost}@anchor{6f}
-@section Pragma Ghost
+@node Pragma Initial_Condition,Pragma Initialize_Scalars,Pragma Independent_Components,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id17}@anchor{80}@anchor{gnat_rm/implementation_defined_pragmas pragma-initial-condition}@anchor{81}
+@section Pragma Initial_Condition
 
 
 Syntax:
 
 @example
-pragma Ghost [ (static_boolean_EXPRESSION) ];
+pragma Initial_Condition (boolean_EXPRESSION);
 @end example
 
-For the semantics of this pragma, see the entry for aspect @code{Ghost} in the SPARK
-2014 Reference Manual, section 6.9.
+For the semantics of this pragma, see the entry for aspect @code{Initial_Condition}
+in the SPARK 2014 Reference Manual, section 7.1.6.
+
+@node Pragma Initialize_Scalars,Pragma Initializes,Pragma Initial_Condition,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-initialize-scalars}@anchor{82}
+@section Pragma Initialize_Scalars
 
-@node Pragma Global,Pragma Ident,Pragma Ghost,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id15}@anchor{70}@anchor{gnat_rm/implementation_defined_pragmas pragma-global}@anchor{71}
-@section Pragma Global
 
+@geindex debugging with Initialize_Scalars
 
 Syntax:
 
 @example
-pragma Global (GLOBAL_SPECIFICATION);
-
-GLOBAL_SPECIFICATION ::=
-     null
-  | (GLOBAL_LIST)
-  | (MODED_GLOBAL_LIST @{, MODED_GLOBAL_LIST@})
+pragma Initialize_Scalars
+  [ ( TYPE_VALUE_PAIR @{, TYPE_VALUE_PAIR@} ) ];
 
-MODED_GLOBAL_LIST ::= MODE_SELECTOR => GLOBAL_LIST
+TYPE_VALUE_PAIR ::=
+  SCALAR_TYPE => static_EXPRESSION
 
-MODE_SELECTOR ::= In_Out | Input | Output | Proof_In
-GLOBAL_LIST   ::= GLOBAL_ITEM | (GLOBAL_ITEM @{, GLOBAL_ITEM@})
-GLOBAL_ITEM   ::= NAME
+SCALAR_TYPE :=
+  Short_Float
+| Float
+| Long_Float
+| Long_Long_Flat
+| Signed_8
+| Signed_16
+| Signed_32
+| Signed_64
+| Unsigned_8
+| Unsigned_16
+| Unsigned_32
+| Unsigned_64
 @end example
 
-For the semantics of this pragma, see the entry for aspect @code{Global} in the
-SPARK 2014 Reference Manual, section 6.1.4.
+This pragma is similar to @code{Normalize_Scalars} conceptually but has two
+important differences.
 
-@node Pragma Ident,Pragma Ignore_Pragma,Pragma Global,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ident}@anchor{72}
-@section Pragma Ident
+First, there is no requirement for the pragma to be used uniformly in all units
+of a partition. In particular, it is fine to use this just for some or all of
+the application units of a partition, without needing to recompile the run-time
+library. In the case where some units are compiled with the pragma, and some
+without, then a declaration of a variable where the type is defined in package
+Standard or is locally declared will always be subject to initialization, as
+will any declaration of a scalar variable. For composite variables, whether the
+variable is initialized may also depend on whether the package in which the
+type of the variable is declared is compiled with the pragma.
 
+The other important difference is that the programmer can control the value
+used for initializing scalar objects. This effect can be achieved in several
+different ways:
 
-Syntax:
 
-@example
-pragma Ident (static_string_EXPRESSION);
-@end example
+@itemize *
 
-This pragma is identical in effect to pragma @code{Comment}. It is provided
-for compatibility with other Ada compilers providing this pragma.
+@item 
+At compile time, the programmer can specify the invalid value for a
+particular family of scalar types using the optional arguments of the pragma.
 
-@node Pragma Ignore_Pragma,Pragma Implementation_Defined,Pragma Ident,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ignore-pragma}@anchor{73}
-@section Pragma Ignore_Pragma
+The compile-time approach is intended to optimize the generated code for the
+pragma, by possibly using fast operations such as @code{memset}. Note that such
+optimizations require using values where the bytes all have the same binary
+representation.
 
+@item 
+At bind time, the programmer has several options:
 
-Syntax:
 
-@example
-pragma Ignore_Pragma (pragma_IDENTIFIER);
-@end example
+@itemize *
 
-This is a configuration pragma
-that takes a single argument that is a simple identifier. Any subsequent
-use of a pragma whose pragma identifier matches this argument will be
-silently ignored. This may be useful when legacy code or code intended
-for compilation with some other compiler contains pragmas that match the
-name, but not the exact implementation, of a GNAT pragma. The use of this
-pragma allows such pragmas to be ignored, which may be useful in CodePeer
-mode, or during porting of legacy code.
+@item 
+Initialization with invalid values (similar to Normalize_Scalars, though
+for Initialize_Scalars it is not always possible to determine the invalid
+values in complex cases like signed component fields with nonstandard
+sizes).
 
-@node Pragma Implementation_Defined,Pragma Implemented,Pragma Ignore_Pragma,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-implementation-defined}@anchor{74}
-@section Pragma Implementation_Defined
+@item 
+Initialization with high values.
 
+@item 
+Initialization with low values.
 
-Syntax:
+@item 
+Initialization with a specific bit pattern.
+@end itemize
 
-@example
-pragma Implementation_Defined (local_NAME);
-@end example
+See the GNAT User’s Guide for binder options for specifying these cases.
 
-This pragma marks a previously declared entity as implementation-defined.
-For an overloaded entity, applies to the most recent homonym.
+The bind-time approach is intended to provide fast turnaround for testing
+with different values, without having to recompile the program.
 
-@example
-pragma Implementation_Defined;
-@end example
+@item 
+At execution time, the programmer can specify the invalid values using an
+environment variable. See the GNAT User’s Guide for details.
 
-The form with no arguments appears anywhere within a scope, most
-typically a package spec, and indicates that all entities that are
-defined within the package spec are Implementation_Defined.
+The execution-time approach is intended to provide fast turnaround for
+testing with different values, without having to recompile and rebind the
+program.
+@end itemize
 
-This pragma is used within the GNAT runtime library to identify
-implementation-defined entities introduced in language-defined units,
-for the purpose of implementing the No_Implementation_Identifiers
-restriction.
+Note that pragma @code{Initialize_Scalars} is particularly useful in conjunction
+with the enhanced validity checking that is now provided in GNAT, which checks
+for invalid values under more conditions. Using this feature (see description
+of the `-gnatV' flag in the GNAT User’s Guide) in conjunction with pragma
+@code{Initialize_Scalars} provides a powerful new tool to assist in the detection
+of problems caused by uninitialized variables.
 
-@node Pragma Implemented,Pragma Implicit_Packing,Pragma Implementation_Defined,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-implemented}@anchor{75}
-@section Pragma Implemented
+Note: the use of @code{Initialize_Scalars} has a fairly extensive effect on the
+generated code. This may cause your code to be substantially larger. It may
+also cause an increase in the amount of stack required, so it is probably a
+good idea to turn on stack checking (see description of stack checking in the
+GNAT User’s Guide) when using this pragma.
+
+@node Pragma Initializes,Pragma Inline_Always,Pragma Initialize_Scalars,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id18}@anchor{83}@anchor{gnat_rm/implementation_defined_pragmas pragma-initializes}@anchor{84}
+@section Pragma Initializes
 
 
 Syntax:
 
 @example
-pragma Implemented (procedure_LOCAL_NAME, implementation_kind);
-
-implementation_kind ::= By_Entry | By_Protected_Procedure | By_Any
-@end example
-
-This is an Ada 2012 representation pragma which applies to protected, task
-and synchronized interface primitives. The use of pragma Implemented provides
-a way to impose a static requirement on the overriding operation by adhering
-to one of the three implementation kinds: entry, protected procedure or any of
-the above. This pragma is available in all earlier versions of Ada as an
-implementation-defined pragma.
+pragma Initializes (INITIALIZATION_LIST);
 
-@example
-type Synch_Iface is synchronized interface;
-procedure Prim_Op (Obj : in out Iface) is abstract;
-pragma Implemented (Prim_Op, By_Protected_Procedure);
+INITIALIZATION_LIST ::=
+     null
+  | (INITIALIZATION_ITEM @{, INITIALIZATION_ITEM@})
 
-protected type Prot_1 is new Synch_Iface with
-   procedure Prim_Op;  --  Legal
-end Prot_1;
+INITIALIZATION_ITEM ::= name [=> INPUT_LIST]
 
-protected type Prot_2 is new Synch_Iface with
-   entry Prim_Op;      --  Illegal
-end Prot_2;
+INPUT_LIST ::=
+     null
+  |  INPUT
+  | (INPUT @{, INPUT@})
 
-task type Task_Typ is new Synch_Iface with
-   entry Prim_Op;      --  Illegal
-end Task_Typ;
+INPUT ::= name
 @end example
 
-When applied to the procedure_or_entry_NAME of a requeue statement, pragma
-Implemented determines the runtime behavior of the requeue. Implementation kind
-By_Entry guarantees that the action of requeueing will proceed from an entry to
-another entry. Implementation kind By_Protected_Procedure transforms the
-requeue into a dispatching call, thus eliminating the chance of blocking. Kind
-By_Any shares the behavior of By_Entry and By_Protected_Procedure depending on
-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{76}
-@section Pragma Implicit_Packing
+For the semantics of this pragma, see the entry for aspect @code{Initializes} in the
+SPARK 2014 Reference Manual, section 7.1.5.
 
+@node Pragma Inline_Always,Pragma Inline_Generic,Pragma Initializes,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id19}@anchor{85}@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-always}@anchor{86}
+@section Pragma Inline_Always
 
-@geindex Rational Profile
 
 Syntax:
 
 @example
-pragma Implicit_Packing;
+pragma Inline_Always (NAME [, NAME]);
 @end example
 
-This is a configuration pragma that requests implicit packing for packed
-arrays for which a size clause is given but no explicit pragma Pack or
-specification of Component_Size is present. It also applies to records
-where no record representation clause is present. Consider this example:
+Similar to pragma @code{Inline} except that inlining is unconditional.
+Inline_Always instructs the compiler to inline every direct call to the
+subprogram or else to emit a compilation error, independently of any
+option, in particular `-gnatn' or `-gnatN' or the optimization level.
+It is an error to take the address or access of @code{NAME}. It is also an error to
+apply this pragma to a primitive operation of a tagged type. Thanks to such
+restrictions, the compiler is allowed to remove the out-of-line body of @code{NAME}.
+
+@node Pragma Inline_Generic,Pragma Interface,Pragma Inline_Always,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-generic}@anchor{87}
+@section Pragma Inline_Generic
+
+
+Syntax:
 
 @example
-type R is array (0 .. 7) of Boolean;
-for R'Size use 8;
+pragma Inline_Generic (GNAME @{, GNAME@});
+
+GNAME ::= generic_unit_NAME | generic_instance_NAME
 @end example
 
-In accordance with the recommendation in the RM (RM 13.3(53)), a Size clause
-does not change the layout of a composite object. So the Size clause in the
-above example is normally rejected, since the default layout of the array uses
-8-bit components, and thus the array requires a minimum of 64 bits.
+This pragma is provided for compatibility with Dec Ada 83. It has
+no effect in GNAT (which always inlines generics), other
+than to check that the given names are all names of generic units or
+generic instances.
 
-If this declaration is compiled in a region of code covered by an occurrence
-of the configuration pragma Implicit_Packing, then the Size clause in this
-and similar examples will cause implicit packing and thus be accepted. For
-this implicit packing to occur, the type in question must be an array of small
-components whose size is known at compile time, and the Size clause must
-specify the exact size that corresponds to the number of elements in the array
-multiplied by the size in bits of the component type (both single and
-multi-dimensioned arrays can be controlled with this pragma).
+@node Pragma Interface,Pragma Interface_Name,Pragma Inline_Generic,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interface}@anchor{88}
+@section Pragma Interface
 
-@geindex Array packing
 
-Similarly, the following example shows the use in the record case
+Syntax:
 
 @example
-type r is record
-   a, b, c, d, e, f, g, h : boolean;
-   chr                    : character;
-end record;
-for r'size use 16;
+pragma Interface (
+     [Convention    =>] convention_identifier,
+     [Entity        =>] local_NAME
+  [, [External_Name =>] static_string_expression]
+  [, [Link_Name     =>] static_string_expression]);
 @end example
 
-Without a pragma Pack, each Boolean field requires 8 bits, so the
-minimum size is 72 bits, but with a pragma Pack, 16 bits would be
-sufficient. The use of pragma Implicit_Packing allows this record
-declaration to compile without an explicit pragma Pack.
+This pragma is identical in syntax and semantics to
+the standard Ada pragma @code{Import}.  It is provided for compatibility
+with Ada 83.  The definition is upwards compatible both with pragma
+@code{Interface} as defined in the Ada 83 Reference Manual, and also
+with some extended implementations of this pragma in certain Ada 83
+implementations.  The only difference between pragma @code{Interface}
+and pragma @code{Import} is that there is special circuitry to allow
+both pragmas to appear for the same subprogram entity (normally it
+is illegal to have multiple @code{Import} pragmas). This is useful in
+maintaining Ada 83/Ada 95 compatibility and is compatible with other
+Ada 83 compilers.
 
-@node Pragma Import_Function,Pragma Import_Object,Pragma Implicit_Packing,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-import-function}@anchor{77}
-@section Pragma Import_Function
+@node Pragma Interface_Name,Pragma Interrupt_Handler,Pragma Interface,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interface-name}@anchor{89}
+@section Pragma Interface_Name
 
 
 Syntax:
 
 @example
-pragma Import_Function (
-     [Internal         =>] LOCAL_NAME,
-  [, [External         =>] EXTERNAL_SYMBOL]
-  [, [Parameter_Types  =>] PARAMETER_TYPES]
-  [, [Result_Type      =>] SUBTYPE_MARK]
-  [, [Mechanism        =>] MECHANISM]
-  [, [Result_Mechanism =>] MECHANISM_NAME]);
-
-EXTERNAL_SYMBOL ::=
-  IDENTIFIER
-| static_string_EXPRESSION
+pragma Interface_Name (
+     [Entity        =>] LOCAL_NAME
+  [, [External_Name =>] static_string_EXPRESSION]
+  [, [Link_Name     =>] static_string_EXPRESSION]);
+@end example
 
-PARAMETER_TYPES ::=
-  null
-| TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@}
+This pragma provides an alternative way of specifying the interface name
+for an interfaced subprogram, and is provided for compatibility with Ada
+83 compilers that use the pragma for this purpose.  You must provide at
+least one of @code{External_Name} or @code{Link_Name}.
 
-TYPE_DESIGNATOR ::=
-  subtype_NAME
-| subtype_Name ' Access
+@node Pragma Interrupt_Handler,Pragma Interrupt_State,Pragma Interface_Name,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-handler}@anchor{8a}
+@section Pragma Interrupt_Handler
 
-MECHANISM ::=
-  MECHANISM_NAME
-| (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@})
 
-MECHANISM_ASSOCIATION ::=
-  [formal_parameter_NAME =>] MECHANISM_NAME
+Syntax:
 
-MECHANISM_NAME ::=
-  Value
-| Reference
+@example
+pragma Interrupt_Handler (procedure_LOCAL_NAME);
 @end example
 
-This pragma is used in conjunction with a pragma @code{Import} to
-specify additional information for an imported function.  The pragma
-@code{Import} (or equivalent pragma @code{Interface}) must precede the
-@code{Import_Function} pragma and both must appear in the same
-declarative part as the function specification.
-
-The @code{Internal} argument must uniquely designate
-the function to which the
-pragma applies.  If more than one function name exists of this name in
-the declarative part you must use the @code{Parameter_Types} and
-@code{Result_Type} parameters to achieve the required unique
-designation.  Subtype marks in these parameters must exactly match the
-subtypes in the corresponding function specification, using positional
-notation to match parameters with subtype marks.
-The form with an @code{'Access} attribute can be used to match an
-anonymous access parameter.
-
-You may optionally use the @code{Mechanism} and @code{Result_Mechanism}
-parameters to specify passing mechanisms for the
-parameters and result.  If you specify a single mechanism name, it
-applies to all parameters.  Otherwise you may specify a mechanism on a
-parameter by parameter basis using either positional or named
-notation.  If the mechanism is not specified, the default mechanism
-is used.
+This program unit pragma is supported for parameterless protected procedures
+as described in Annex C of the Ada Reference Manual.
 
-@node Pragma Import_Object,Pragma Import_Procedure,Pragma Import_Function,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-import-object}@anchor{78}
-@section Pragma Import_Object
+@node Pragma Interrupt_State,Pragma Invariant,Pragma Interrupt_Handler,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-state}@anchor{8b}
+@section Pragma Interrupt_State
 
 
 Syntax:
 
 @example
-pragma Import_Object (
-     [Internal =>] LOCAL_NAME
-  [, [External =>] EXTERNAL_SYMBOL]
-  [, [Size     =>] EXTERNAL_SYMBOL]);
-
-EXTERNAL_SYMBOL ::=
-  IDENTIFIER
-| static_string_EXPRESSION
+pragma Interrupt_State
+ ([Name  =>] value,
+  [State =>] SYSTEM | RUNTIME | USER);
 @end example
 
-This pragma designates an object as imported, and apart from the
-extended rules for external symbols, is identical in effect to the use of
-the normal @code{Import} pragma applied to an object.  Unlike the
-subprogram case, you need not use a separate @code{Import} pragma,
-although you may do so (and probably should do so from a portability
-point of view).  @code{size} is syntax checked, but otherwise ignored by
-GNAT.
+Normally certain interrupts are reserved to the implementation.  Any attempt
+to attach an interrupt causes Program_Error to be raised, as described in
+RM C.3.2(22).  A typical example is the @code{SIGINT} interrupt used in
+many systems for an @code{Ctrl-C} interrupt.  Normally this interrupt is
+reserved to the implementation, so that @code{Ctrl-C} can be used to
+interrupt execution.  Additionally, signals such as @code{SIGSEGV},
+@code{SIGABRT}, @code{SIGFPE} and @code{SIGILL} are often mapped to specific
+Ada exceptions, or used to implement run-time functions such as the
+@code{abort} statement and stack overflow checking.
 
-@node Pragma Import_Procedure,Pragma Import_Valued_Procedure,Pragma Import_Object,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-import-procedure}@anchor{79}
-@section Pragma Import_Procedure
+Pragma @code{Interrupt_State} provides a general mechanism for overriding
+such uses of interrupts.  It subsumes the functionality of pragma
+@code{Unreserve_All_Interrupts}.  Pragma @code{Interrupt_State} is not
+available on Windows.  On all other platforms than VxWorks,
+it applies to signals; on VxWorks, it applies to vectored hardware interrupts
+and may be used to mark interrupts required by the board support package
+as reserved.
 
+Interrupts can be in one of three states:
 
-Syntax:
 
-@example
-pragma Import_Procedure (
-     [Internal        =>] LOCAL_NAME
-  [, [External        =>] EXTERNAL_SYMBOL]
-  [, [Parameter_Types =>] PARAMETER_TYPES]
-  [, [Mechanism       =>] MECHANISM]);
+@itemize *
 
-EXTERNAL_SYMBOL ::=
-  IDENTIFIER
-| static_string_EXPRESSION
+@item 
+System
 
-PARAMETER_TYPES ::=
-  null
-| TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@}
+The interrupt is reserved (no Ada handler can be installed), and the
+Ada run-time may not install a handler. As a result you are guaranteed
+standard system default action if this interrupt is raised. This also allows
+installing a low level handler via C APIs such as sigaction(), outside
+of Ada control.
 
-TYPE_DESIGNATOR ::=
-  subtype_NAME
-| subtype_Name ' Access
+@item 
+Runtime
 
-MECHANISM ::=
-  MECHANISM_NAME
-| (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@})
+The interrupt is reserved (no Ada handler can be installed). The run time
+is allowed to install a handler for internal control purposes, but is
+not required to do so.
 
-MECHANISM_ASSOCIATION ::=
-  [formal_parameter_NAME =>] MECHANISM_NAME
+@item 
+User
 
-MECHANISM_NAME ::= Value | Reference
-@end example
+The interrupt is unreserved.  The user may install an Ada handler via
+Ada.Interrupts and pragma Interrupt_Handler or Attach_Handler to provide
+some other action.
+@end itemize
 
-This pragma is identical to @code{Import_Function} except that it
-applies to a procedure rather than a function and the parameters
-@code{Result_Type} and @code{Result_Mechanism} are not permitted.
+These states are the allowed values of the @code{State} parameter of the
+pragma.  The @code{Name} parameter is a value of the type
+@code{Ada.Interrupts.Interrupt_ID}.  Typically, it is a name declared in
+@code{Ada.Interrupts.Names}.
 
-@node Pragma Import_Valued_Procedure,Pragma Independent,Pragma Import_Procedure,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-import-valued-procedure}@anchor{7a}
-@section Pragma Import_Valued_Procedure
+This is a configuration pragma, and the binder will check that there
+are no inconsistencies between different units in a partition in how a
+given interrupt is specified. It may appear anywhere a pragma is legal.
 
+The effect is to move the interrupt to the specified state.
 
-Syntax:
+By declaring interrupts to be SYSTEM, you guarantee the standard system
+action, such as a core dump.
 
-@example
-pragma Import_Valued_Procedure (
-     [Internal        =>] LOCAL_NAME
-  [, [External        =>] EXTERNAL_SYMBOL]
-  [, [Parameter_Types =>] PARAMETER_TYPES]
-  [, [Mechanism       =>] MECHANISM]);
+By declaring interrupts to be USER, you guarantee that you can install
+a handler.
 
-EXTERNAL_SYMBOL ::=
-  IDENTIFIER
-| static_string_EXPRESSION
+Note that certain signals on many operating systems cannot be caught and
+handled by applications.  In such cases, the pragma is ignored.  See the
+operating system documentation, or the value of the array @code{Reserved}
+declared in the spec of package @code{System.OS_Interface}.
 
-PARAMETER_TYPES ::=
-  null
-| TYPE_DESIGNATOR @{, TYPE_DESIGNATOR@}
+Overriding the default state of signals used by the Ada runtime may interfere
+with an application’s runtime behavior in the cases of the synchronous signals,
+and in the case of the signal used to implement the @code{abort} statement.
 
-TYPE_DESIGNATOR ::=
-  subtype_NAME
-| subtype_Name ' Access
+@node Pragma Invariant,Pragma Keep_Names,Pragma Interrupt_State,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id20}@anchor{8c}@anchor{gnat_rm/implementation_defined_pragmas pragma-invariant}@anchor{8d}
+@section Pragma Invariant
 
-MECHANISM ::=
-  MECHANISM_NAME
-| (MECHANISM_ASSOCIATION @{, MECHANISM_ASSOCIATION@})
 
-MECHANISM_ASSOCIATION ::=
-  [formal_parameter_NAME =>] MECHANISM_NAME
+Syntax:
 
-MECHANISM_NAME ::= Value | Reference
+@example
+pragma Invariant
+  ([Entity =>]    private_type_LOCAL_NAME,
+   [Check  =>]    EXPRESSION
+   [,[Message =>] String_Expression]);
 @end example
 
-This pragma is identical to @code{Import_Procedure} except that the
-first parameter of @code{LOCAL_NAME}, which must be present, must be of
-mode @code{out}, and externally the subprogram is treated as a function
-with this parameter as the result of the function.  The purpose of this
-capability is to allow the use of @code{out} and @code{in out}
-parameters in interfacing to external functions (which are not permitted
-in Ada functions).  You may optionally use the @code{Mechanism}
-parameters to specify passing mechanisms for the parameters.
-If you specify a single mechanism name, it applies to all parameters.
-Otherwise you may specify a mechanism on a parameter by parameter
-basis using either positional or named notation.  If the mechanism is not
-specified, the default mechanism is used.
+This pragma provides exactly the same capabilities as the Type_Invariant aspect
+defined in AI05-0146-1, and in the Ada 2012 Reference Manual. The
+Type_Invariant aspect is fully implemented in Ada 2012 mode, but since it
+requires the use of the aspect syntax, which is not available except in 2012
+mode, it is not possible to use the Type_Invariant aspect in earlier versions
+of Ada. However the Invariant pragma may be used in any version of Ada. Also
+note that the aspect Invariant is a synonym in GNAT for the aspect
+Type_Invariant, but there is no pragma Type_Invariant.
 
-Note that it is important to use this pragma in conjunction with a separate
-pragma Import that specifies the desired convention, since otherwise the
-default convention is Ada, which is almost certainly not what is required.
+The pragma must appear within the visible part of the package specification,
+after the type to which its Entity argument appears. As with the Invariant
+aspect, the Check expression is not analyzed until the end of the visible
+part of the package, so it may contain forward references. The Message
+argument, if present, provides the exception message used if the invariant
+is violated. If no Message parameter is provided, a default message that
+identifies the line on which the pragma appears is used.
 
-@node Pragma Independent,Pragma Independent_Components,Pragma Import_Valued_Procedure,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-independent}@anchor{7b}
-@section Pragma Independent
+It is permissible to have multiple Invariants for the same type entity, in
+which case they are and’ed together. It is permissible to use this pragma
+in Ada 2012 mode, but you cannot have both an invariant aspect and an
+invariant pragma for the same entity.
+
+For further details on the use of this pragma, see the Ada 2012 documentation
+of the Type_Invariant aspect.
+
+@node Pragma Keep_Names,Pragma License,Pragma Invariant,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-keep-names}@anchor{8e}
+@section Pragma Keep_Names
 
 
 Syntax:
 
 @example
-pragma Independent (Local_NAME);
+pragma Keep_Names ([On =>] enumeration_first_subtype_LOCAL_NAME);
 @end example
 
-This pragma is standard in Ada 2012 mode (which also provides an aspect
-of the same name). It is also available as an implementation-defined
-pragma in all earlier versions. It specifies that the
-designated object or all objects of the designated type must be
-independently addressable. This means that separate tasks can safely
-manipulate such objects. For example, if two components of a record are
-independent, then two separate tasks may access these two components.
-This may place
-constraints on the representation of the object (for instance prohibiting
-tight packing).
-
-@node Pragma Independent_Components,Pragma Initial_Condition,Pragma Independent,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-independent-components}@anchor{7c}
-@section Pragma Independent_Components
-
-
-Syntax:
-
-@example
-pragma Independent_Components (Local_NAME);
-@end example
-
-This pragma is standard in Ada 2012 mode (which also provides an aspect
-of the same name). It is also available as an implementation-defined
-pragma in all earlier versions. It specifies that the components of the
-designated object, or the components of each object of the designated
-type, must be
-independently addressable. This means that separate tasks can safely
-manipulate separate components in the composite object. This may place
-constraints on the representation of the object (for instance prohibiting
-tight packing).
-
-@node Pragma Initial_Condition,Pragma Initialize_Scalars,Pragma Independent_Components,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id16}@anchor{7d}@anchor{gnat_rm/implementation_defined_pragmas pragma-initial-condition}@anchor{7e}
-@section Pragma Initial_Condition
-
-
-Syntax:
-
-@example
-pragma Initial_Condition (boolean_EXPRESSION);
-@end example
-
-For the semantics of this pragma, see the entry for aspect @code{Initial_Condition}
-in the SPARK 2014 Reference Manual, section 7.1.6.
+The @code{LOCAL_NAME} argument
+must refer to an enumeration first subtype
+in the current declarative part. The effect is to retain the enumeration
+literal names for use by @code{Image} and @code{Value} even if a global
+@code{Discard_Names} pragma applies. This is useful when you want to
+generally suppress enumeration literal names and for example you therefore
+use a @code{Discard_Names} pragma in the @code{gnat.adc} file, but you
+want to retain the names for specific enumeration types.
 
-@node Pragma Initialize_Scalars,Pragma Initializes,Pragma Initial_Condition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-initialize-scalars}@anchor{7f}
-@section Pragma Initialize_Scalars
+@node Pragma License,Pragma Link_With,Pragma Keep_Names,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-license}@anchor{8f}
+@section Pragma License
 
 
-@geindex debugging with Initialize_Scalars
+@geindex License checking
 
 Syntax:
 
 @example
-pragma Initialize_Scalars
-  [ ( TYPE_VALUE_PAIR @{, TYPE_VALUE_PAIR@} ) ];
-
-TYPE_VALUE_PAIR ::=
-  SCALAR_TYPE => static_EXPRESSION
-
-SCALAR_TYPE :=
-  Short_Float
-| Float
-| Long_Float
-| Long_Long_Flat
-| Signed_8
-| Signed_16
-| Signed_32
-| Signed_64
-| Unsigned_8
-| Unsigned_16
-| Unsigned_32
-| Unsigned_64
+pragma License (Unrestricted | GPL | Modified_GPL | Restricted);
 @end example
 
-This pragma is similar to @code{Normalize_Scalars} conceptually but has two
-important differences.
-
-First, there is no requirement for the pragma to be used uniformly in all units
-of a partition. In particular, it is fine to use this just for some or all of
-the application units of a partition, without needing to recompile the run-time
-library. In the case where some units are compiled with the pragma, and some
-without, then a declaration of a variable where the type is defined in package
-Standard or is locally declared will always be subject to initialization, as
-will any declaration of a scalar variable. For composite variables, whether the
-variable is initialized may also depend on whether the package in which the
-type of the variable is declared is compiled with the pragma.
-
-The other important difference is that the programmer can control the value
-used for initializing scalar objects. This effect can be achieved in several
-different ways:
-
-
-@itemize *
-
-@item 
-At compile time, the programmer can specify the invalid value for a
-particular family of scalar types using the optional arguments of the pragma.
-
-The compile-time approach is intended to optimize the generated code for the
-pragma, by possibly using fast operations such as @code{memset}. Note that such
-optimizations require using values where the bytes all have the same binary
-representation.
-
-@item 
-At bind time, the programmer has several options:
+This pragma is provided to allow automated checking for appropriate license
+conditions with respect to the standard and modified GPL.  A pragma
+@code{License}, which is a configuration pragma that typically appears at
+the start of a source file or in a separate @code{gnat.adc} file, specifies
+the licensing conditions of a unit as follows:
 
 
 @itemize *
 
 @item 
-Initialization with invalid values (similar to Normalize_Scalars, though
-for Initialize_Scalars it is not always possible to determine the invalid
-values in complex cases like signed component fields with nonstandard
-sizes).
-
-@item 
-Initialization with high values.
+Unrestricted
+This is used for a unit that can be freely used with no license restrictions.
+Examples of such units are public domain units, and units from the Ada
+Reference Manual.
 
 @item 
-Initialization with low values.
+GPL
+This is used for a unit that is licensed under the unmodified GPL, and which
+therefore cannot be @code{with}ed by a restricted unit.
 
 @item 
-Initialization with a specific bit pattern.
-@end itemize
-
-See the GNAT User’s Guide for binder options for specifying these cases.
-
-The bind-time approach is intended to provide fast turnaround for testing
-with different values, without having to recompile the program.
+Modified_GPL
+This is used for a unit licensed under the GNAT modified GPL that includes
+a special exception paragraph that specifically permits the inclusion of
+the unit in programs without requiring the entire program to be released
+under the GPL.
 
 @item 
-At execution time, the programmer can specify the invalid values using an
-environment variable. See the GNAT User’s Guide for details.
-
-The execution-time approach is intended to provide fast turnaround for
-testing with different values, without having to recompile and rebind the
-program.
+Restricted
+This is used for a unit that is restricted in that it is not permitted to
+depend on units that are licensed under the GPL.  Typical examples are
+proprietary code that is to be released under more restrictive license
+conditions.  Note that restricted units are permitted to @code{with} units
+which are licensed under the modified GPL (this is the whole point of the
+modified GPL).
 @end itemize
 
-Note that pragma @code{Initialize_Scalars} is particularly useful in conjunction
-with the enhanced validity checking that is now provided in GNAT, which checks
-for invalid values under more conditions. Using this feature (see description
-of the `-gnatV' flag in the GNAT User’s Guide) in conjunction with pragma
-@code{Initialize_Scalars} provides a powerful new tool to assist in the detection
-of problems caused by uninitialized variables.
+Normally a unit with no @code{License} pragma is considered to have an
+unknown license, and no checking is done.  However, standard GNAT headers
+are recognized, and license information is derived from them as follows.
 
-Note: the use of @code{Initialize_Scalars} has a fairly extensive effect on the
-generated code. This may cause your code to be substantially larger. It may
-also cause an increase in the amount of stack required, so it is probably a
-good idea to turn on stack checking (see description of stack checking in the
-GNAT User’s Guide) when using this pragma.
+A GNAT license header starts with a line containing 78 hyphens.  The following
+comment text is searched for the appearance of any of the following strings.
 
-@node Pragma Initializes,Pragma Inline_Always,Pragma Initialize_Scalars,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id17}@anchor{80}@anchor{gnat_rm/implementation_defined_pragmas pragma-initializes}@anchor{81}
-@section Pragma Initializes
+If the string ‘GNU General Public License’ is found, then the unit is assumed
+to have GPL license, unless the string ‘As a special exception’ follows, in
+which case the license is assumed to be modified GPL.
 
+If one of the strings
+‘This specification is adapted from the Ada Semantic Interface’ or
+‘This specification is derived from the Ada Reference Manual’ is found
+then the unit is assumed to be unrestricted.
 
-Syntax:
+These default actions means that a program with a restricted license pragma
+will automatically get warnings if a GPL unit is inappropriately
+@code{with}ed.  For example, the program:
 
 @example
-pragma Initializes (INITIALIZATION_LIST);
-
-INITIALIZATION_LIST ::=
-     null
-  | (INITIALIZATION_ITEM @{, INITIALIZATION_ITEM@})
+with Sem_Ch3;
+with GNAT.Sockets;
+procedure Secret_Stuff is
+  ...
+end Secret_Stuff
+@end example
 
-INITIALIZATION_ITEM ::= name [=> INPUT_LIST]
+if compiled with pragma @code{License} (@code{Restricted}) in a
+@code{gnat.adc} file will generate the warning:
 
-INPUT_LIST ::=
-     null
-  |  INPUT
-  | (INPUT @{, INPUT@})
+@example
+1.  with Sem_Ch3;
+        |
+   >>> license of withed unit "Sem_Ch3" is incompatible
 
-INPUT ::= name
+2.  with GNAT.Sockets;
+3.  procedure Secret_Stuff is
 @end example
 
-For the semantics of this pragma, see the entry for aspect @code{Initializes} in the
-SPARK 2014 Reference Manual, section 7.1.5.
+Here we get a warning on @code{Sem_Ch3} since it is part of the GNAT
+compiler and is licensed under the
+GPL, but no warning for @code{GNAT.Sockets} which is part of the GNAT
+run time, and is therefore licensed under the modified GPL.
 
-@node Pragma Inline_Always,Pragma Inline_Generic,Pragma Initializes,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id18}@anchor{82}@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-always}@anchor{83}
-@section Pragma Inline_Always
+@node Pragma Link_With,Pragma Linker_Alias,Pragma License,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-link-with}@anchor{90}
+@section Pragma Link_With
 
 
 Syntax:
 
 @example
-pragma Inline_Always (NAME [, NAME]);
+pragma Link_With (static_string_EXPRESSION @{,static_string_EXPRESSION@});
 @end example
 
-Similar to pragma @code{Inline} except that inlining is unconditional.
-Inline_Always instructs the compiler to inline every direct call to the
-subprogram or else to emit a compilation error, independently of any
-option, in particular `-gnatn' or `-gnatN' or the optimization level.
-It is an error to take the address or access of @code{NAME}. It is also an error to
-apply this pragma to a primitive operation of a tagged type. Thanks to such
-restrictions, the compiler is allowed to remove the out-of-line body of @code{NAME}.
-
-@node Pragma Inline_Generic,Pragma Interface,Pragma Inline_Always,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-inline-generic}@anchor{84}
-@section Pragma Inline_Generic
-
-
-Syntax:
+This pragma is provided for compatibility with certain Ada 83 compilers.
+It has exactly the same effect as pragma @code{Linker_Options} except
+that spaces occurring within one of the string expressions are treated
+as separators. For example, in the following case:
 
 @example
-pragma Inline_Generic (GNAME @{, GNAME@});
-
-GNAME ::= generic_unit_NAME | generic_instance_NAME
+pragma Link_With ("-labc -ldef");
 @end example
 
-This pragma is provided for compatibility with Dec Ada 83. It has
-no effect in GNAT (which always inlines generics), other
-than to check that the given names are all names of generic units or
-generic instances.
+results in passing the strings @code{-labc} and @code{-ldef} as two
+separate arguments to the linker. In addition pragma Link_With allows
+multiple arguments, with the same effect as successive pragmas.
 
-@node Pragma Interface,Pragma Interface_Name,Pragma Inline_Generic,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-interface}@anchor{85}
-@section Pragma Interface
+@node Pragma Linker_Alias,Pragma Linker_Constructor,Pragma Link_With,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-alias}@anchor{91}
+@section Pragma Linker_Alias
 
 
 Syntax:
 
 @example
-pragma Interface (
-     [Convention    =>] convention_identifier,
-     [Entity        =>] local_NAME
-  [, [External_Name =>] static_string_expression]
-  [, [Link_Name     =>] static_string_expression]);
+pragma Linker_Alias (
+  [Entity =>] LOCAL_NAME,
+  [Target =>] static_string_EXPRESSION);
 @end example
 
-This pragma is identical in syntax and semantics to
-the standard Ada pragma @code{Import}.  It is provided for compatibility
-with Ada 83.  The definition is upwards compatible both with pragma
-@code{Interface} as defined in the Ada 83 Reference Manual, and also
-with some extended implementations of this pragma in certain Ada 83
-implementations.  The only difference between pragma @code{Interface}
-and pragma @code{Import} is that there is special circuitry to allow
-both pragmas to appear for the same subprogram entity (normally it
-is illegal to have multiple @code{Import} pragmas). This is useful in
-maintaining Ada 83/Ada 95 compatibility and is compatible with other
-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{86}
-@section Pragma Interface_Name
+@code{LOCAL_NAME} must refer to an object that is declared at the library
+level. This pragma establishes the given entity as a linker alias for the
+given target. It is equivalent to @code{__attribute__((alias))} in GNU C
+and causes @code{LOCAL_NAME} to be emitted as an alias for the symbol
+@code{static_string_EXPRESSION} in the object file, that is to say no space
+is reserved for @code{LOCAL_NAME} by the assembler and it will be resolved
+to the same address as @code{static_string_EXPRESSION} by the linker.
 
+The actual linker name for the target must be used (e.g., the fully
+encoded name with qualification in Ada, or the mangled name in C++),
+or it must be declared using the C convention with @code{pragma Import}
+or @code{pragma Export}.
 
-Syntax:
+Not all target machines support this pragma. On some of them it is accepted
+only if @code{pragma Weak_External} has been applied to @code{LOCAL_NAME}.
 
 @example
-pragma Interface_Name (
-     [Entity        =>] LOCAL_NAME
-  [, [External_Name =>] static_string_EXPRESSION]
-  [, [Link_Name     =>] static_string_EXPRESSION]);
-@end example
+--  Example of the use of pragma Linker_Alias
 
-This pragma provides an alternative way of specifying the interface name
-for an interfaced subprogram, and is provided for compatibility with Ada
-83 compilers that use the pragma for this purpose.  You must provide at
-least one of @code{External_Name} or @code{Link_Name}.
+package p is
+  i : Integer := 1;
+  pragma Export (C, i);
 
-@node Pragma Interrupt_Handler,Pragma Interrupt_State,Pragma Interface_Name,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-handler}@anchor{87}
-@section Pragma Interrupt_Handler
+  new_name_for_i : Integer;
+  pragma Linker_Alias (new_name_for_i, "i");
+end p;
+@end example
+
+@node Pragma Linker_Constructor,Pragma Linker_Destructor,Pragma Linker_Alias,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-constructor}@anchor{92}
+@section Pragma Linker_Constructor
 
 
 Syntax:
 
 @example
-pragma Interrupt_Handler (procedure_LOCAL_NAME);
+pragma Linker_Constructor (procedure_LOCAL_NAME);
 @end example
 
-This program unit pragma is supported for parameterless protected procedures
-as described in Annex C of the Ada Reference Manual.
+@code{procedure_LOCAL_NAME} must refer to a parameterless procedure that
+is declared at the library level. A procedure to which this pragma is
+applied will be treated as an initialization routine by the linker.
+It is equivalent to @code{__attribute__((constructor))} in GNU C and
+causes @code{procedure_LOCAL_NAME} to be invoked before the entry point
+of the executable is called (or immediately after the shared library is
+loaded if the procedure is linked in a shared library), in particular
+before the Ada run-time environment is set up.
 
-@node Pragma Interrupt_State,Pragma Invariant,Pragma Interrupt_Handler,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-interrupt-state}@anchor{88}
-@section Pragma Interrupt_State
+Because of these specific contexts, the set of operations such a procedure
+can perform is very limited and the type of objects it can manipulate is
+essentially restricted to the elementary types. In particular, it must only
+contain code to which pragma Restrictions (No_Elaboration_Code) applies.
+
+This pragma is used by GNAT to implement auto-initialization of shared Stand
+Alone Libraries, which provides a related capability without the restrictions
+listed above. Where possible, the use of Stand Alone Libraries is preferable
+to the use of this pragma.
+
+@node Pragma Linker_Destructor,Pragma Linker_Section,Pragma Linker_Constructor,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-destructor}@anchor{93}
+@section Pragma Linker_Destructor
 
 
 Syntax:
 
 @example
-pragma Interrupt_State
- ([Name  =>] value,
-  [State =>] SYSTEM | RUNTIME | USER);
+pragma Linker_Destructor (procedure_LOCAL_NAME);
 @end example
 
-Normally certain interrupts are reserved to the implementation.  Any attempt
-to attach an interrupt causes Program_Error to be raised, as described in
-RM C.3.2(22).  A typical example is the @code{SIGINT} interrupt used in
-many systems for an @code{Ctrl-C} interrupt.  Normally this interrupt is
-reserved to the implementation, so that @code{Ctrl-C} can be used to
-interrupt execution.  Additionally, signals such as @code{SIGSEGV},
-@code{SIGABRT}, @code{SIGFPE} and @code{SIGILL} are often mapped to specific
-Ada exceptions, or used to implement run-time functions such as the
-@code{abort} statement and stack overflow checking.
+@code{procedure_LOCAL_NAME} must refer to a parameterless procedure that
+is declared at the library level. A procedure to which this pragma is
+applied will be treated as a finalization routine by the linker.
+It is equivalent to @code{__attribute__((destructor))} in GNU C and
+causes @code{procedure_LOCAL_NAME} to be invoked after the entry point
+of the executable has exited (or immediately before the shared library
+is unloaded if the procedure is linked in a shared library), in particular
+after the Ada run-time environment is shut down.
 
-Pragma @code{Interrupt_State} provides a general mechanism for overriding
-such uses of interrupts.  It subsumes the functionality of pragma
-@code{Unreserve_All_Interrupts}.  Pragma @code{Interrupt_State} is not
-available on Windows.  On all other platforms than VxWorks,
-it applies to signals; on VxWorks, it applies to vectored hardware interrupts
-and may be used to mark interrupts required by the board support package
-as reserved.
+See @code{pragma Linker_Constructor} for the set of restrictions that apply
+because of these specific contexts.
 
-Interrupts can be in one of three states:
+@node Pragma Linker_Section,Pragma Lock_Free,Pragma Linker_Destructor,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id21}@anchor{94}@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-section}@anchor{95}
+@section Pragma Linker_Section
 
 
-@itemize *
+Syntax:
 
-@item 
-System
+@example
+pragma Linker_Section (
+  [Entity  =>] LOCAL_NAME,
+  [Section =>] static_string_EXPRESSION);
+@end example
 
-The interrupt is reserved (no Ada handler can be installed), and the
-Ada run-time may not install a handler. As a result you are guaranteed
-standard system default action if this interrupt is raised. This also allows
-installing a low level handler via C APIs such as sigaction(), outside
-of Ada control.
+@code{LOCAL_NAME} must refer to an object, type, or subprogram that is
+declared at the library level. This pragma specifies the name of the
+linker section for the given entity. It is equivalent to
+@code{__attribute__((section))} in GNU C and causes @code{LOCAL_NAME} to
+be placed in the @code{static_string_EXPRESSION} section of the
+executable (assuming the linker doesn’t rename the section).
+GNAT also provides an implementation defined aspect of the same name.
 
-@item 
-Runtime
+In the case of specifying this aspect for a type, the effect is to
+specify the corresponding section for all library-level objects of
+the type that do not have an explicit linker section set. Note that
+this only applies to whole objects, not to components of composite objects.
 
-The interrupt is reserved (no Ada handler can be installed). The run time
-is allowed to install a handler for internal control purposes, but is
-not required to do so.
+In the case of a subprogram, the linker section applies to all previously
+declared matching overloaded subprograms in the current declarative part
+which do not already have a linker section assigned. The linker section
+aspect is useful in this case for specifying different linker sections
+for different elements of such an overloaded set.
 
-@item 
-User
+Note that an empty string specifies that no linker section is specified.
+This is not quite the same as omitting the pragma or aspect, since it
+can be used to specify that one element of an overloaded set of subprograms
+has the default linker section, or that one object of a type for which a
+linker section is specified should has the default linker section.
 
-The interrupt is unreserved.  The user may install an Ada handler via
-Ada.Interrupts and pragma Interrupt_Handler or Attach_Handler to provide
-some other action.
-@end itemize
+The compiler normally places library-level entities in standard sections
+depending on the class: procedures and functions generally go in the
+@code{.text} section, initialized variables in the @code{.data} section
+and uninitialized variables in the @code{.bss} section.
 
-These states are the allowed values of the @code{State} parameter of the
-pragma.  The @code{Name} parameter is a value of the type
-@code{Ada.Interrupts.Interrupt_ID}.  Typically, it is a name declared in
-@code{Ada.Interrupts.Names}.
+Other, special sections may exist on given target machines to map special
+hardware, for example I/O ports or flash memory. This pragma is a means to
+defer the final layout of the executable to the linker, thus fully working
+at the symbolic level with the compiler.
 
-This is a configuration pragma, and the binder will check that there
-are no inconsistencies between different units in a partition in how a
-given interrupt is specified. It may appear anywhere a pragma is legal.
+Some file formats do not support arbitrary sections so not all target
+machines support this pragma. The use of this pragma may cause a program
+execution to be erroneous if it is used to place an entity into an
+inappropriate section (e.g., a modified variable into the @code{.text}
+section). See also @code{pragma Persistent_BSS}.
 
-The effect is to move the interrupt to the specified state.
+@example
+--  Example of the use of pragma Linker_Section
 
-By declaring interrupts to be SYSTEM, you guarantee the standard system
-action, such as a core dump.
+package IO_Card is
+  Port_A : Integer;
+  pragma Volatile (Port_A);
+  pragma Linker_Section (Port_A, ".bss.port_a");
 
-By declaring interrupts to be USER, you guarantee that you can install
-a handler.
+  Port_B : Integer;
+  pragma Volatile (Port_B);
+  pragma Linker_Section (Port_B, ".bss.port_b");
 
-Note that certain signals on many operating systems cannot be caught and
-handled by applications.  In such cases, the pragma is ignored.  See the
-operating system documentation, or the value of the array @code{Reserved}
-declared in the spec of package @code{System.OS_Interface}.
+  type Port_Type is new Integer with Linker_Section => ".bss";
+  PA : Port_Type with Linker_Section => ".bss.PA";
+  PB : Port_Type; --  ends up in linker section ".bss"
 
-Overriding the default state of signals used by the Ada runtime may interfere
-with an application’s runtime behavior in the cases of the synchronous signals,
-and in the case of the signal used to implement the @code{abort} statement.
+  procedure Q with Linker_Section => "Qsection";
+end IO_Card;
+@end example
 
-@node Pragma Invariant,Pragma Keep_Names,Pragma Interrupt_State,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id19}@anchor{89}@anchor{gnat_rm/implementation_defined_pragmas pragma-invariant}@anchor{8a}
-@section Pragma Invariant
+@node Pragma Lock_Free,Pragma Loop_Invariant,Pragma Linker_Section,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id22}@anchor{96}@anchor{gnat_rm/implementation_defined_pragmas pragma-lock-free}@anchor{97}
+@section Pragma Lock_Free
 
 
 Syntax:
+This pragma may be specified for protected types or objects. It specifies that
+the implementation of protected operations must be implemented without locks.
+Compilation fails if the compiler cannot generate lock-free code for the
+operations.
 
-@example
-pragma Invariant
-  ([Entity =>]    private_type_LOCAL_NAME,
-   [Check  =>]    EXPRESSION
-   [,[Message =>] String_Expression]);
-@end example
+The current conditions required to support this pragma are:
 
-This pragma provides exactly the same capabilities as the Type_Invariant aspect
-defined in AI05-0146-1, and in the Ada 2012 Reference Manual. The
-Type_Invariant aspect is fully implemented in Ada 2012 mode, but since it
-requires the use of the aspect syntax, which is not available except in 2012
-mode, it is not possible to use the Type_Invariant aspect in earlier versions
-of Ada. However the Invariant pragma may be used in any version of Ada. Also
-note that the aspect Invariant is a synonym in GNAT for the aspect
-Type_Invariant, but there is no pragma Type_Invariant.
 
-The pragma must appear within the visible part of the package specification,
-after the type to which its Entity argument appears. As with the Invariant
-aspect, the Check expression is not analyzed until the end of the visible
-part of the package, so it may contain forward references. The Message
-argument, if present, provides the exception message used if the invariant
-is violated. If no Message parameter is provided, a default message that
-identifies the line on which the pragma appears is used.
+@itemize *
 
-It is permissible to have multiple Invariants for the same type entity, in
-which case they are and’ed together. It is permissible to use this pragma
-in Ada 2012 mode, but you cannot have both an invariant aspect and an
-invariant pragma for the same entity.
+@item 
+Protected type declarations may not contain entries
 
-For further details on the use of this pragma, see the Ada 2012 documentation
-of the Type_Invariant aspect.
+@item 
+Protected subprogram declarations may not have nonelementary parameters
+@end itemize
 
-@node Pragma Keep_Names,Pragma License,Pragma Invariant,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-keep-names}@anchor{8b}
-@section Pragma Keep_Names
+In addition, each protected subprogram body must satisfy:
 
 
-Syntax:
+@itemize *
 
-@example
-pragma Keep_Names ([On =>] enumeration_first_subtype_LOCAL_NAME);
-@end example
+@item 
+May reference only one protected component
 
-The @code{LOCAL_NAME} argument
-must refer to an enumeration first subtype
-in the current declarative part. The effect is to retain the enumeration
-literal names for use by @code{Image} and @code{Value} even if a global
-@code{Discard_Names} pragma applies. This is useful when you want to
-generally suppress enumeration literal names and for example you therefore
-use a @code{Discard_Names} pragma in the @code{gnat.adc} file, but you
-want to retain the names for specific enumeration types.
+@item 
+May not reference nonconstant entities outside the protected subprogram
+scope
 
-@node Pragma License,Pragma Link_With,Pragma Keep_Names,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-license}@anchor{8c}
-@section Pragma License
-
-
-@geindex License checking
-
-Syntax:
-
-@example
-pragma License (Unrestricted | GPL | Modified_GPL | Restricted);
-@end example
-
-This pragma is provided to allow automated checking for appropriate license
-conditions with respect to the standard and modified GPL.  A pragma
-@code{License}, which is a configuration pragma that typically appears at
-the start of a source file or in a separate @code{gnat.adc} file, specifies
-the licensing conditions of a unit as follows:
-
-
-@itemize *
+@item 
+May not contain address representation items, allocators, or quantified
+expressions
 
 @item 
-Unrestricted
-This is used for a unit that can be freely used with no license restrictions.
-Examples of such units are public domain units, and units from the Ada
-Reference Manual.
+May not contain delay, goto, loop, or procedure-call statements
 
 @item 
-GPL
-This is used for a unit that is licensed under the unmodified GPL, and which
-therefore cannot be @code{with}ed by a restricted unit.
+May not contain exported and imported entities
 
 @item 
-Modified_GPL
-This is used for a unit licensed under the GNAT modified GPL that includes
-a special exception paragraph that specifically permits the inclusion of
-the unit in programs without requiring the entire program to be released
-under the GPL.
+May not dereferenced access values
 
 @item 
-Restricted
-This is used for a unit that is restricted in that it is not permitted to
-depend on units that are licensed under the GPL.  Typical examples are
-proprietary code that is to be released under more restrictive license
-conditions.  Note that restricted units are permitted to @code{with} units
-which are licensed under the modified GPL (this is the whole point of the
-modified GPL).
+Function calls and attribute references must be static
 @end itemize
 
-Normally a unit with no @code{License} pragma is considered to have an
-unknown license, and no checking is done.  However, standard GNAT headers
-are recognized, and license information is derived from them as follows.
-
-A GNAT license header starts with a line containing 78 hyphens.  The following
-comment text is searched for the appearance of any of the following strings.
+If the Lock_Free aspect is specified to be True for a protected unit
+and the Ceiling_Locking locking policy is in effect, then the run-time
+actions associated with the Ceiling_Locking locking policy (described in
+Ada RM D.3) are not performed when a protected operation of the protected
+unit is executed.
 
-If the string ‘GNU General Public License’ is found, then the unit is assumed
-to have GPL license, unless the string ‘As a special exception’ follows, in
-which case the license is assumed to be modified GPL.
+@node Pragma Loop_Invariant,Pragma Loop_Optimize,Pragma Lock_Free,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-invariant}@anchor{98}
+@section Pragma Loop_Invariant
 
-If one of the strings
-‘This specification is adapted from the Ada Semantic Interface’ or
-‘This specification is derived from the Ada Reference Manual’ is found
-then the unit is assumed to be unrestricted.
 
-These default actions means that a program with a restricted license pragma
-will automatically get warnings if a GPL unit is inappropriately
-@code{with}ed.  For example, the program:
+Syntax:
 
 @example
-with Sem_Ch3;
-with GNAT.Sockets;
-procedure Secret_Stuff is
-  ...
-end Secret_Stuff
+pragma Loop_Invariant ( boolean_EXPRESSION );
 @end example
 
-if compiled with pragma @code{License} (@code{Restricted}) in a
-@code{gnat.adc} file will generate the warning:
+The effect of this pragma is similar to that of pragma @code{Assert},
+except that in an @code{Assertion_Policy} pragma, the identifier
+@code{Loop_Invariant} is used to control whether it is ignored or checked
+(or disabled).
 
-@example
-1.  with Sem_Ch3;
-        |
-   >>> license of withed unit "Sem_Ch3" is incompatible
+@code{Loop_Invariant} can only appear as one of the items in the sequence
+of statements of a loop body, or nested inside block statements that
+appear in the sequence of statements of a loop body.
+The intention is that it be used to
+represent a “loop invariant” assertion, i.e. something that is true each
+time through the loop, and which can be used to show that the loop is
+achieving its purpose.
 
-2.  with GNAT.Sockets;
-3.  procedure Secret_Stuff is
-@end example
+Multiple @code{Loop_Invariant} and @code{Loop_Variant} pragmas that
+apply to the same loop should be grouped in the same sequence of
+statements.
 
-Here we get a warning on @code{Sem_Ch3} since it is part of the GNAT
-compiler and is licensed under the
-GPL, but no warning for @code{GNAT.Sockets} which is part of the GNAT
-run time, and is therefore licensed under the modified GPL.
+To aid in writing such invariants, the special attribute @code{Loop_Entry}
+may be used to refer to the value of an expression on entry to the loop. This
+attribute can only be used within the expression of a @code{Loop_Invariant}
+pragma. For full details, see documentation of attribute @code{Loop_Entry}.
 
-@node Pragma Link_With,Pragma Linker_Alias,Pragma License,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-link-with}@anchor{8d}
-@section Pragma Link_With
+@node Pragma Loop_Optimize,Pragma Loop_Variant,Pragma Loop_Invariant,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-optimize}@anchor{99}
+@section Pragma Loop_Optimize
 
 
 Syntax:
 
 @example
-pragma Link_With (static_string_EXPRESSION @{,static_string_EXPRESSION@});
+pragma Loop_Optimize (OPTIMIZATION_HINT @{, OPTIMIZATION_HINT@});
+
+OPTIMIZATION_HINT ::= Ivdep | No_Unroll | Unroll | No_Vector | Vector
 @end example
 
-This pragma is provided for compatibility with certain Ada 83 compilers.
-It has exactly the same effect as pragma @code{Linker_Options} except
-that spaces occurring within one of the string expressions are treated
-as separators. For example, in the following case:
+This pragma must appear immediately within a loop statement.  It allows the
+programmer to specify optimization hints for the enclosing loop.  The hints
+are not mutually exclusive and can be freely mixed, but not all combinations
+will yield a sensible outcome.
 
-@example
-pragma Link_With ("-labc -ldef");
-@end example
+There are five supported optimization hints for a loop:
 
-results in passing the strings @code{-labc} and @code{-ldef} as two
-separate arguments to the linker. In addition pragma Link_With allows
-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{8e}
-@section Pragma Linker_Alias
+@itemize *
 
+@item 
+Ivdep
 
-Syntax:
+The programmer asserts that there are no loop-carried dependencies
+which would prevent consecutive iterations of the loop from being
+executed simultaneously.
 
-@example
-pragma Linker_Alias (
-  [Entity =>] LOCAL_NAME,
-  [Target =>] static_string_EXPRESSION);
-@end example
+@item 
+No_Unroll
 
-@code{LOCAL_NAME} must refer to an object that is declared at the library
-level. This pragma establishes the given entity as a linker alias for the
-given target. It is equivalent to @code{__attribute__((alias))} in GNU C
-and causes @code{LOCAL_NAME} to be emitted as an alias for the symbol
-@code{static_string_EXPRESSION} in the object file, that is to say no space
-is reserved for @code{LOCAL_NAME} by the assembler and it will be resolved
-to the same address as @code{static_string_EXPRESSION} by the linker.
+The loop must not be unrolled.  This is a strong hint: the compiler will not
+unroll a loop marked with this hint.
 
-The actual linker name for the target must be used (e.g., the fully
-encoded name with qualification in Ada, or the mangled name in C++),
-or it must be declared using the C convention with @code{pragma Import}
-or @code{pragma Export}.
+@item 
+Unroll
 
-Not all target machines support this pragma. On some of them it is accepted
-only if @code{pragma Weak_External} has been applied to @code{LOCAL_NAME}.
+The loop should be unrolled.  This is a weak hint: the compiler will try to
+apply unrolling to this loop preferably to other optimizations, notably
+vectorization, but there is no guarantee that the loop will be unrolled.
 
-@example
---  Example of the use of pragma Linker_Alias
+@item 
+No_Vector
 
-package p is
-  i : Integer := 1;
-  pragma Export (C, i);
+The loop must not be vectorized.  This is a strong hint: the compiler will not
+vectorize a loop marked with this hint.
 
-  new_name_for_i : Integer;
-  pragma Linker_Alias (new_name_for_i, "i");
-end p;
-@end example
+@item 
+Vector
 
-@node Pragma Linker_Constructor,Pragma Linker_Destructor,Pragma Linker_Alias,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-constructor}@anchor{8f}
-@section Pragma Linker_Constructor
+The loop should be vectorized.  This is a weak hint: the compiler will try to
+apply vectorization to this loop preferably to other optimizations, notably
+unrolling, but there is no guarantee that the loop will be vectorized.
+@end itemize
+
+These hints do not remove the need to pass the appropriate switches to the
+compiler in order to enable the relevant optimizations, that is to say
+`-funroll-loops' for unrolling and `-ftree-vectorize' for
+vectorization.
+
+@node Pragma Loop_Variant,Pragma Machine_Attribute,Pragma Loop_Optimize,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-variant}@anchor{9a}
+@section Pragma Loop_Variant
 
 
 Syntax:
 
 @example
-pragma Linker_Constructor (procedure_LOCAL_NAME);
+pragma Loop_Variant ( LOOP_VARIANT_ITEM @{, LOOP_VARIANT_ITEM @} );
+LOOP_VARIANT_ITEM ::= CHANGE_DIRECTION => discrete_EXPRESSION
+CHANGE_DIRECTION ::= Increases | Decreases
 @end example
 
-@code{procedure_LOCAL_NAME} must refer to a parameterless procedure that
-is declared at the library level. A procedure to which this pragma is
-applied will be treated as an initialization routine by the linker.
-It is equivalent to @code{__attribute__((constructor))} in GNU C and
-causes @code{procedure_LOCAL_NAME} to be invoked before the entry point
-of the executable is called (or immediately after the shared library is
-loaded if the procedure is linked in a shared library), in particular
-before the Ada run-time environment is set up.
+@code{Loop_Variant} can only appear as one of the items in the sequence
+of statements of a loop body, or nested inside block statements that
+appear in the sequence of statements of a loop body.
+It allows the specification of quantities which must always
+decrease or increase in successive iterations of the loop. In its simplest
+form, just one expression is specified, whose value must increase or decrease
+on each iteration of the loop.
 
-Because of these specific contexts, the set of operations such a procedure
-can perform is very limited and the type of objects it can manipulate is
-essentially restricted to the elementary types. In particular, it must only
-contain code to which pragma Restrictions (No_Elaboration_Code) applies.
+In a more complex form, multiple arguments can be given which are interpreted
+in a nesting lexicographic manner. For example:
 
-This pragma is used by GNAT to implement auto-initialization of shared Stand
-Alone Libraries, which provides a related capability without the restrictions
-listed above. Where possible, the use of Stand Alone Libraries is preferable
-to the use of this pragma.
+@example
+pragma Loop_Variant (Increases => X, Decreases => Y);
+@end example
 
-@node Pragma Linker_Destructor,Pragma Linker_Section,Pragma Linker_Constructor,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-destructor}@anchor{90}
-@section Pragma Linker_Destructor
+specifies that each time through the loop either X increases, or X stays
+the same and Y decreases. A @code{Loop_Variant} pragma ensures that the
+loop is making progress. It can be useful in helping to show informally
+or prove formally that the loop always terminates.
+
+@code{Loop_Variant} is an assertion whose effect can be controlled using
+an @code{Assertion_Policy} with a check name of @code{Loop_Variant}. The
+policy can be @code{Check} to enable the loop variant check, @code{Ignore}
+to ignore the check (in which case the pragma has no effect on the program),
+or @code{Disable} in which case the pragma is not even checked for correct
+syntax.
+
+Multiple @code{Loop_Invariant} and @code{Loop_Variant} pragmas that
+apply to the same loop should be grouped in the same sequence of
+statements.
+
+The @code{Loop_Entry} attribute may be used within the expressions of the
+@code{Loop_Variant} pragma to refer to values on entry to the loop.
+
+@node Pragma Machine_Attribute,Pragma Main,Pragma Loop_Variant,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-machine-attribute}@anchor{9b}
+@section Pragma Machine_Attribute
 
 
 Syntax:
 
 @example
-pragma Linker_Destructor (procedure_LOCAL_NAME);
+pragma Machine_Attribute (
+     [Entity         =>] LOCAL_NAME,
+     [Attribute_Name =>] static_string_EXPRESSION
+  [, [Info           =>] static_EXPRESSION @{, static_EXPRESSION@}] );
 @end example
 
-@code{procedure_LOCAL_NAME} must refer to a parameterless procedure that
-is declared at the library level. A procedure to which this pragma is
-applied will be treated as a finalization routine by the linker.
-It is equivalent to @code{__attribute__((destructor))} in GNU C and
-causes @code{procedure_LOCAL_NAME} to be invoked after the entry point
-of the executable has exited (or immediately before the shared library
-is unloaded if the procedure is linked in a shared library), in particular
-after the Ada run-time environment is shut down.
-
-See @code{pragma Linker_Constructor} for the set of restrictions that apply
-because of these specific contexts.
+Machine-dependent attributes can be specified for types and/or
+declarations.  This pragma is semantically equivalent to
+@code{__attribute__((@var{attribute_name}))} (if @code{info} is not
+specified) or @code{__attribute__((@var{attribute_name(info})))}
+or @code{__attribute__((@var{attribute_name(info,...})))} in GNU C,
+where `attribute_name' is recognized by the compiler middle-end
+or the @code{TARGET_ATTRIBUTE_TABLE} machine specific macro.  Note
+that a string literal for the optional parameter @code{info} or the
+following ones is transformed by default into an identifier,
+which may make this pragma unusable for some attributes.
+For further information see @cite{GNU Compiler Collection (GCC) Internals}.
 
-@node Pragma Linker_Section,Pragma Lock_Free,Pragma Linker_Destructor,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id20}@anchor{91}@anchor{gnat_rm/implementation_defined_pragmas pragma-linker-section}@anchor{92}
-@section Pragma Linker_Section
+@node Pragma Main,Pragma Main_Storage,Pragma Machine_Attribute,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-main}@anchor{9c}
+@section Pragma Main
 
 
 Syntax:
 
 @example
-pragma Linker_Section (
-  [Entity  =>] LOCAL_NAME,
-  [Section =>] static_string_EXPRESSION);
-@end example
+pragma Main
+ (MAIN_OPTION [, MAIN_OPTION]);
 
-@code{LOCAL_NAME} must refer to an object, type, or subprogram that is
-declared at the library level. This pragma specifies the name of the
-linker section for the given entity. It is equivalent to
-@code{__attribute__((section))} in GNU C and causes @code{LOCAL_NAME} to
-be placed in the @code{static_string_EXPRESSION} section of the
-executable (assuming the linker doesn’t rename the section).
-GNAT also provides an implementation defined aspect of the same name.
+MAIN_OPTION ::=
+  [Stack_Size              =>] static_integer_EXPRESSION
+| [Task_Stack_Size_Default =>] static_integer_EXPRESSION
+| [Time_Slicing_Enabled    =>] static_boolean_EXPRESSION
+@end example
 
-In the case of specifying this aspect for a type, the effect is to
-specify the corresponding section for all library-level objects of
-the type that do not have an explicit linker section set. Note that
-this only applies to whole objects, not to components of composite objects.
+This pragma is provided for compatibility with OpenVMS VAX Systems.  It has
+no effect in GNAT, other than being syntax checked.
 
-In the case of a subprogram, the linker section applies to all previously
-declared matching overloaded subprograms in the current declarative part
-which do not already have a linker section assigned. The linker section
-aspect is useful in this case for specifying different linker sections
-for different elements of such an overloaded set.
+@node Pragma Main_Storage,Pragma Max_Queue_Length,Pragma Main,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-main-storage}@anchor{9d}
+@section Pragma Main_Storage
 
-Note that an empty string specifies that no linker section is specified.
-This is not quite the same as omitting the pragma or aspect, since it
-can be used to specify that one element of an overloaded set of subprograms
-has the default linker section, or that one object of a type for which a
-linker section is specified should has the default linker section.
 
-The compiler normally places library-level entities in standard sections
-depending on the class: procedures and functions generally go in the
-@code{.text} section, initialized variables in the @code{.data} section
-and uninitialized variables in the @code{.bss} section.
+Syntax:
 
-Other, special sections may exist on given target machines to map special
-hardware, for example I/O ports or flash memory. This pragma is a means to
-defer the final layout of the executable to the linker, thus fully working
-at the symbolic level with the compiler.
+@example
+pragma Main_Storage
+  (MAIN_STORAGE_OPTION [, MAIN_STORAGE_OPTION]);
 
-Some file formats do not support arbitrary sections so not all target
-machines support this pragma. The use of this pragma may cause a program
-execution to be erroneous if it is used to place an entity into an
-inappropriate section (e.g., a modified variable into the @code{.text}
-section). See also @code{pragma Persistent_BSS}.
+MAIN_STORAGE_OPTION ::=
+  [WORKING_STORAGE =>] static_SIMPLE_EXPRESSION
+| [TOP_GUARD       =>] static_SIMPLE_EXPRESSION
+@end example
 
-@example
---  Example of the use of pragma Linker_Section
+This pragma is provided for compatibility with OpenVMS VAX Systems.  It has
+no effect in GNAT, other than being syntax checked.
 
-package IO_Card is
-  Port_A : Integer;
-  pragma Volatile (Port_A);
-  pragma Linker_Section (Port_A, ".bss.port_a");
+@node Pragma Max_Queue_Length,Pragma No_Body,Pragma Main_Storage,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id23}@anchor{9e}@anchor{gnat_rm/implementation_defined_pragmas pragma-max-queue-length}@anchor{9f}
+@section Pragma Max_Queue_Length
 
-  Port_B : Integer;
-  pragma Volatile (Port_B);
-  pragma Linker_Section (Port_B, ".bss.port_b");
 
-  type Port_Type is new Integer with Linker_Section => ".bss";
-  PA : Port_Type with Linker_Section => ".bss.PA";
-  PB : Port_Type; --  ends up in linker section ".bss"
+Syntax:
 
-  procedure Q with Linker_Section => "Qsection";
-end IO_Card;
+@example
+pragma Max_Entry_Queue (static_integer_EXPRESSION);
 @end example
 
-@node Pragma Lock_Free,Pragma Loop_Invariant,Pragma Linker_Section,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id21}@anchor{93}@anchor{gnat_rm/implementation_defined_pragmas pragma-lock-free}@anchor{94}
-@section Pragma Lock_Free
-
+This pragma is used to specify the maximum callers per entry queue for
+individual protected entries and entry families. It accepts a single
+integer (-1 or more) as a parameter and must appear after the declaration of an
+entry.
 
-Syntax:
-This pragma may be specified for protected types or objects. It specifies that
-the implementation of protected operations must be implemented without locks.
-Compilation fails if the compiler cannot generate lock-free code for the
-operations.
+A value of -1 represents no additional restriction on queue length.
 
-The current conditions required to support this pragma are:
+@node Pragma No_Body,Pragma No_Caching,Pragma Max_Queue_Length,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-body}@anchor{a0}
+@section Pragma No_Body
 
 
-@itemize *
+Syntax:
 
-@item 
-Protected type declarations may not contain entries
+@example
+pragma No_Body;
+@end example
 
-@item 
-Protected subprogram declarations may not have nonelementary parameters
-@end itemize
+There are a number of cases in which a package spec does not require a body,
+and in fact a body is not permitted. GNAT will not permit the spec to be
+compiled if there is a body around. The pragma No_Body allows you to provide
+a body file, even in a case where no body is allowed. The body file must
+contain only comments and a single No_Body pragma. This is recognized by
+the compiler as indicating that no body is logically present.
 
-In addition, each protected subprogram body must satisfy:
+This is particularly useful during maintenance when a package is modified in
+such a way that a body needed before is no longer needed. The provision of a
+dummy body with a No_Body pragma ensures that there is no interference from
+earlier versions of the package body.
 
+@node Pragma No_Caching,Pragma No_Component_Reordering,Pragma No_Body,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id24}@anchor{a1}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-caching}@anchor{a2}
+@section Pragma No_Caching
 
-@itemize *
 
-@item 
-May reference only one protected component
+Syntax:
 
-@item 
-May not reference nonconstant entities outside the protected subprogram
-scope
+@example
+pragma No_Caching [ (static_boolean_EXPRESSION) ];
+@end example
 
-@item 
-May not contain address representation items, allocators, or quantified
-expressions
+For the semantics of this pragma, see the entry for aspect @code{No_Caching} in
+the SPARK 2014 Reference Manual, section 7.1.2.
 
-@item 
-May not contain delay, goto, loop, or procedure-call statements
+@node Pragma No_Component_Reordering,Pragma No_Elaboration_Code_All,Pragma No_Caching,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-component-reordering}@anchor{a3}
+@section Pragma No_Component_Reordering
 
-@item 
-May not contain exported and imported entities
 
-@item 
-May not dereferenced access values
+Syntax:
 
-@item 
-Function calls and attribute references must be static
-@end itemize
+@example
+pragma No_Component_Reordering [([Entity =>] type_LOCAL_NAME)];
+@end example
 
-If the Lock_Free aspect is specified to be True for a protected unit
-and the Ceiling_Locking locking policy is in effect, then the run-time
-actions associated with the Ceiling_Locking locking policy (described in
-Ada RM D.3) are not performed when a protected operation of the protected
-unit is executed.
+@code{type_LOCAL_NAME} must refer to a record type declaration in the current
+declarative part. The effect is to preclude any reordering of components
+for the layout of the record, i.e. the record is laid out by the compiler
+in the order in which the components are declared textually. The form with
+no argument is a configuration pragma which applies to all record types
+declared in units to which the pragma applies and there is a requirement
+that this pragma be used consistently within a partition.
 
-@node Pragma Loop_Invariant,Pragma Loop_Optimize,Pragma Lock_Free,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-invariant}@anchor{95}
-@section Pragma Loop_Invariant
+@node Pragma No_Elaboration_Code_All,Pragma No_Heap_Finalization,Pragma No_Component_Reordering,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id25}@anchor{a4}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-elaboration-code-all}@anchor{a5}
+@section Pragma No_Elaboration_Code_All
 
 
 Syntax:
 
 @example
-pragma Loop_Invariant ( boolean_EXPRESSION );
+pragma No_Elaboration_Code_All [(program_unit_NAME)];
 @end example
 
-The effect of this pragma is similar to that of pragma @code{Assert},
-except that in an @code{Assertion_Policy} pragma, the identifier
-@code{Loop_Invariant} is used to control whether it is ignored or checked
-(or disabled).
-
-@code{Loop_Invariant} can only appear as one of the items in the sequence
-of statements of a loop body, or nested inside block statements that
-appear in the sequence of statements of a loop body.
-The intention is that it be used to
-represent a “loop invariant” assertion, i.e. something that is true each
-time through the loop, and which can be used to show that the loop is
-achieving its purpose.
-
-Multiple @code{Loop_Invariant} and @code{Loop_Variant} pragmas that
-apply to the same loop should be grouped in the same sequence of
-statements.
-
-To aid in writing such invariants, the special attribute @code{Loop_Entry}
-may be used to refer to the value of an expression on entry to the loop. This
-attribute can only be used within the expression of a @code{Loop_Invariant}
-pragma. For full details, see documentation of attribute @code{Loop_Entry}.
+This is a program unit pragma (there is also an equivalent aspect of the
+same name) that establishes the restriction @code{No_Elaboration_Code} for
+the current unit and any extended main source units (body and subunits).
+It also has the effect of enforcing a transitive application of this
+aspect, so that if any unit is implicitly or explicitly with’ed by the
+current unit, it must also have the No_Elaboration_Code_All aspect set.
+It may be applied to package or subprogram specs or their generic versions.
 
-@node Pragma Loop_Optimize,Pragma Loop_Variant,Pragma Loop_Invariant,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-optimize}@anchor{96}
-@section Pragma Loop_Optimize
+@node Pragma No_Heap_Finalization,Pragma No_Inline,Pragma No_Elaboration_Code_All,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-heap-finalization}@anchor{a6}
+@section Pragma No_Heap_Finalization
 
 
 Syntax:
 
 @example
-pragma Loop_Optimize (OPTIMIZATION_HINT @{, OPTIMIZATION_HINT@});
-
-OPTIMIZATION_HINT ::= Ivdep | No_Unroll | Unroll | No_Vector | Vector
+pragma No_Heap_Finalization [ (first_subtype_LOCAL_NAME) ];
 @end example
 
-This pragma must appear immediately within a loop statement.  It allows the
-programmer to specify optimization hints for the enclosing loop.  The hints
-are not mutually exclusive and can be freely mixed, but not all combinations
-will yield a sensible outcome.
+Pragma @code{No_Heap_Finalization} may be used as a configuration pragma or as a
+type-specific pragma.
 
-There are five supported optimization hints for a loop:
+In its configuration form, the pragma must appear within a configuration file
+such as gnat.adc, without an argument. The pragma suppresses the call to
+@code{Finalize} for heap-allocated objects created through library-level named
+access-to-object types in cases where the designated type requires finalization
+actions.
 
+In its type-specific form, the argument of the pragma must denote a
+library-level named access-to-object type. The pragma suppresses the call to
+@code{Finalize} for heap-allocated objects created through the specific access type
+in cases where the designated type requires finalization actions.
 
-@itemize *
+It is still possible to finalize such heap-allocated objects by explicitly
+deallocating them.
 
-@item 
-Ivdep
+A library-level named access-to-object type declared within a generic unit will
+lose its @code{No_Heap_Finalization} pragma when the corresponding instance does not
+appear at the library level.
 
-The programmer asserts that there are no loop-carried dependencies
-which would prevent consecutive iterations of the loop from being
-executed simultaneously.
-
-@item 
-No_Unroll
-
-The loop must not be unrolled.  This is a strong hint: the compiler will not
-unroll a loop marked with this hint.
-
-@item 
-Unroll
-
-The loop should be unrolled.  This is a weak hint: the compiler will try to
-apply unrolling to this loop preferably to other optimizations, notably
-vectorization, but there is no guarantee that the loop will be unrolled.
-
-@item 
-No_Vector
-
-The loop must not be vectorized.  This is a strong hint: the compiler will not
-vectorize a loop marked with this hint.
-
-@item 
-Vector
-
-The loop should be vectorized.  This is a weak hint: the compiler will try to
-apply vectorization to this loop preferably to other optimizations, notably
-unrolling, but there is no guarantee that the loop will be vectorized.
-@end itemize
-
-These hints do not remove the need to pass the appropriate switches to the
-compiler in order to enable the relevant optimizations, that is to say
-`-funroll-loops' for unrolling and `-ftree-vectorize' for
-vectorization.
-
-@node Pragma Loop_Variant,Pragma Machine_Attribute,Pragma Loop_Optimize,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-loop-variant}@anchor{97}
-@section Pragma Loop_Variant
+@node Pragma No_Inline,Pragma No_Return,Pragma No_Heap_Finalization,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id26}@anchor{a7}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-inline}@anchor{a8}
+@section Pragma No_Inline
 
 
 Syntax:
 
 @example
-pragma Loop_Variant ( LOOP_VARIANT_ITEM @{, LOOP_VARIANT_ITEM @} );
-LOOP_VARIANT_ITEM ::= CHANGE_DIRECTION => discrete_EXPRESSION
-CHANGE_DIRECTION ::= Increases | Decreases
+pragma No_Inline (NAME @{, NAME@});
 @end example
 
-@code{Loop_Variant} can only appear as one of the items in the sequence
-of statements of a loop body, or nested inside block statements that
-appear in the sequence of statements of a loop body.
-It allows the specification of quantities which must always
-decrease or increase in successive iterations of the loop. In its simplest
-form, just one expression is specified, whose value must increase or decrease
-on each iteration of the loop.
+This pragma suppresses inlining for the callable entity or the instances of
+the generic subprogram designated by @code{NAME}, including inlining that
+results from the use of pragma @code{Inline}.  This pragma is always active,
+in particular it is not subject to the use of option `-gnatn' or
+`-gnatN'.  It is illegal to specify both pragma @code{No_Inline} and
+pragma @code{Inline_Always} for the same @code{NAME}.
+
+@node Pragma No_Return,Pragma No_Strict_Aliasing,Pragma No_Inline,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-return}@anchor{a9}
+@section Pragma No_Return
 
-In a more complex form, multiple arguments can be given which are interpreted
-in a nesting lexicographic manner. For example:
+
+Syntax:
 
 @example
-pragma Loop_Variant (Increases => X, Decreases => Y);
+pragma No_Return (procedure_LOCAL_NAME @{, procedure_LOCAL_NAME@});
 @end example
 
-specifies that each time through the loop either X increases, or X stays
-the same and Y decreases. A @code{Loop_Variant} pragma ensures that the
-loop is making progress. It can be useful in helping to show informally
-or prove formally that the loop always terminates.
-
-@code{Loop_Variant} is an assertion whose effect can be controlled using
-an @code{Assertion_Policy} with a check name of @code{Loop_Variant}. The
-policy can be @code{Check} to enable the loop variant check, @code{Ignore}
-to ignore the check (in which case the pragma has no effect on the program),
-or @code{Disable} in which case the pragma is not even checked for correct
-syntax.
+Each @code{procedure_LOCAL_NAME} argument must refer to one or more procedure
+declarations in the current declarative part.  A procedure to which this
+pragma is applied may not contain any explicit @code{return} statements.
+In addition, if the procedure contains any implicit returns from falling
+off the end of a statement sequence, then execution of that implicit
+return will cause Program_Error to be raised.
 
-Multiple @code{Loop_Invariant} and @code{Loop_Variant} pragmas that
-apply to the same loop should be grouped in the same sequence of
-statements.
+One use of this pragma is to identify procedures whose only purpose is to raise
+an exception. Another use of this pragma is to suppress incorrect warnings
+about missing returns in functions, where the last statement of a function
+statement sequence is a call to such a procedure.
 
-The @code{Loop_Entry} attribute may be used within the expressions of the
-@code{Loop_Variant} pragma to refer to values on entry to the loop.
+Note that in Ada 2005 mode, this pragma is part of the language. It is
+available in all earlier versions of Ada as an implementation-defined
+pragma.
 
-@node Pragma Machine_Attribute,Pragma Main,Pragma Loop_Variant,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-machine-attribute}@anchor{98}
-@section Pragma Machine_Attribute
+@node Pragma No_Strict_Aliasing,Pragma No_Tagged_Streams,Pragma No_Return,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-no-strict-aliasing}@anchor{aa}
+@section Pragma No_Strict_Aliasing
 
 
 Syntax:
 
 @example
-pragma Machine_Attribute (
-     [Entity         =>] LOCAL_NAME,
-     [Attribute_Name =>] static_string_EXPRESSION
-  [, [Info           =>] static_EXPRESSION @{, static_EXPRESSION@}] );
+pragma No_Strict_Aliasing [([Entity =>] type_LOCAL_NAME)];
 @end example
 
-Machine-dependent attributes can be specified for types and/or
-declarations.  This pragma is semantically equivalent to
-@code{__attribute__((@var{attribute_name}))} (if @code{info} is not
-specified) or @code{__attribute__((@var{attribute_name(info})))}
-or @code{__attribute__((@var{attribute_name(info,...})))} in GNU C,
-where `attribute_name' is recognized by the compiler middle-end
-or the @code{TARGET_ATTRIBUTE_TABLE} machine specific macro.  Note
-that a string literal for the optional parameter @code{info} or the
-following ones is transformed by default into an identifier,
-which may make this pragma unusable for some attributes.
-For further information see @cite{GNU Compiler Collection (GCC) Internals}.
+@code{type_LOCAL_NAME} must refer to an access type
+declaration in the current declarative part.  The effect is to inhibit
+strict aliasing optimization for the given type.  The form with no
+arguments is a configuration pragma which applies to all access types
+declared in units to which the pragma applies. For a detailed
+description of the strict aliasing optimization, and the situations
+in which it must be suppressed, see the section on Optimization and Strict Aliasing
+in the @cite{GNAT User’s Guide}.
 
-@node Pragma Main,Pragma Main_Storage,Pragma Machine_Attribute,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-main}@anchor{99}
-@section Pragma Main
+This pragma currently has no effects on access to unconstrained array types.
+
+@node Pragma No_Tagged_Streams,Pragma Normalize_Scalars,Pragma No_Strict_Aliasing,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{ab}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{ac}
+@section Pragma No_Tagged_Streams
 
 
 Syntax:
 
 @example
-pragma Main
- (MAIN_OPTION [, MAIN_OPTION]);
-
-MAIN_OPTION ::=
-  [Stack_Size              =>] static_integer_EXPRESSION
-| [Task_Stack_Size_Default =>] static_integer_EXPRESSION
-| [Time_Slicing_Enabled    =>] static_boolean_EXPRESSION
+pragma No_Tagged_Streams [([Entity =>] tagged_type_LOCAL_NAME)];
 @end example
 
-This pragma is provided for compatibility with OpenVMS VAX Systems.  It has
-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{9a}
-@section Pragma Main_Storage
-
+Normally when a tagged type is introduced using a full type declaration,
+part of the processing includes generating stream access routines to be
+used by stream attributes referencing the type (or one of its subtypes
+or derived types). This can involve the generation of significant amounts
+of code which is wasted space if stream routines are not needed for the
+type in question.
 
-Syntax:
+The @code{No_Tagged_Streams} pragma causes the generation of these stream
+routines to be skipped, and any attempt to use stream operations on
+types subject to this pragma will be statically rejected as illegal.
 
-@example
-pragma Main_Storage
-  (MAIN_STORAGE_OPTION [, MAIN_STORAGE_OPTION]);
+There are two forms of the pragma. The form with no arguments must appear
+in a declarative sequence or in the declarations of a package spec. This
+pragma affects all subsequent root tagged types declared in the declaration
+sequence, and specifies that no stream routines be generated. The form with
+an argument (for which there is also a corresponding aspect) specifies a
+single root tagged type for which stream routines are not to be generated.
 
-MAIN_STORAGE_OPTION ::=
-  [WORKING_STORAGE =>] static_SIMPLE_EXPRESSION
-| [TOP_GUARD       =>] static_SIMPLE_EXPRESSION
-@end example
+Once the pragma has been given for a particular root tagged type, all subtypes
+and derived types of this type inherit the pragma automatically, so the effect
+applies to a complete hierarchy (this is necessary to deal with the class-wide
+dispatching versions of the stream routines).
 
-This pragma is provided for compatibility with OpenVMS VAX Systems.  It has
-no effect in GNAT, other than being syntax checked.
+When pragmas @code{Discard_Names} and @code{No_Tagged_Streams} are simultaneously
+applied to a tagged type its Expanded_Name and External_Tag are initialized
+with empty strings. This is useful to avoid exposing entity names at binary
+level but has a negative impact on the debuggability of tagged types.
 
-@node Pragma Max_Queue_Length,Pragma No_Body,Pragma Main_Storage,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id22}@anchor{9b}@anchor{gnat_rm/implementation_defined_pragmas pragma-max-queue-length}@anchor{9c}
-@section Pragma Max_Queue_Length
+@node Pragma Normalize_Scalars,Pragma Obsolescent,Pragma No_Tagged_Streams,Implementation Defined Pragmas
+@anchor{gnat_rm/implementation_defined_pragmas pragma-normalize-scalars}@anchor{ad}
+@section Pragma Normalize_Scalars
 
 
 Syntax:
 
 @example
-pragma Max_Entry_Queue (static_integer_EXPRESSION);
+pragma Normalize_Scalars;
 @end example
 
-This pragma is used to specify the maximum callers per entry queue for
-individual protected entries and entry families. It accepts a single
-integer (-1 or more) as a parameter and must appear after the declaration of an
-entry.
+This is a language defined pragma which is fully implemented in GNAT.  The
+effect is to cause all scalar objects that are not otherwise initialized
+to be initialized.  The initial values are implementation dependent and
+are as follows:
 
-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{9d}
-@section Pragma No_Body
+@table @asis
 
+@item `Standard.Character'
 
-Syntax:
+Objects whose root type is Standard.Character are initialized to
+Character’Last unless the subtype range excludes NUL (in which case
+NUL is used). This choice will always generate an invalid value if
+one exists.
 
-@example
-pragma No_Body;
-@end example
+@item `Standard.Wide_Character'
 
-There are a number of cases in which a package spec does not require a body,
-and in fact a body is not permitted. GNAT will not permit the spec to be
-compiled if there is a body around. The pragma No_Body allows you to provide
-a body file, even in a case where no body is allowed. The body file must
-contain only comments and a single No_Body pragma. This is recognized by
-the compiler as indicating that no body is logically present.
+Objects whose root type is Standard.Wide_Character are initialized to
+Wide_Character’Last unless the subtype range excludes NUL (in which case
+NUL is used). This choice will always generate an invalid value if
+one exists.
 
-This is particularly useful during maintenance when a package is modified in
-such a way that a body needed before is no longer needed. The provision of a
-dummy body with a No_Body pragma ensures that there is no interference from
-earlier versions of the package body.
+@item `Standard.Wide_Wide_Character'
 
-@node Pragma No_Caching,Pragma No_Component_Reordering,Pragma No_Body,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id23}@anchor{9e}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-caching}@anchor{9f}
-@section Pragma No_Caching
+Objects whose root type is Standard.Wide_Wide_Character are initialized to
+the invalid value 16#FFFF_FFFF# unless the subtype range excludes NUL (in
+which case NUL is used). This choice will always generate an invalid value if
+one exists.
 
+@item `Integer types'
 
-Syntax:
+Objects of an integer type are treated differently depending on whether
+negative values are present in the subtype. If no negative values are
+present, then all one bits is used as the initial value except in the
+special case where zero is excluded from the subtype, in which case
+all zero bits are used. This choice will always generate an invalid
+value if one exists.
 
-@example
-pragma No_Caching [ (static_boolean_EXPRESSION) ];
-@end example
+For subtypes with negative values present, the largest negative number
+is used, except in the unusual case where this largest negative number
+is in the subtype, and the largest positive number is not, in which case
+the largest positive value is used. This choice will always generate
+an invalid value if one exists.
 
-For the semantics of this pragma, see the entry for aspect @code{No_Caching} in
-the SPARK 2014 Reference Manual, section 7.1.2.
+@item `Floating-Point Types'
 
-@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{a0}
-@section Pragma No_Component_Reordering
+Objects of all floating-point types are initialized to all 1-bits. For
+standard IEEE format, this corresponds to a NaN (not a number) which is
+indeed an invalid value.
 
+@item `Fixed-Point Types'
 
-Syntax:
+Objects of all fixed-point types are treated as described above for integers,
+with the rules applying to the underlying integer value used to represent
+the fixed-point value.
 
-@example
-pragma No_Component_Reordering [([Entity =>] type_LOCAL_NAME)];
-@end example
-
-@code{type_LOCAL_NAME} must refer to a record type declaration in the current
-declarative part. The effect is to preclude any reordering of components
-for the layout of the record, i.e. the record is laid out by the compiler
-in the order in which the components are declared textually. The form with
-no argument is a configuration pragma which applies to all record types
-declared in units to which the pragma applies and there is a requirement
-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 id24}@anchor{a1}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-elaboration-code-all}@anchor{a2}
-@section Pragma No_Elaboration_Code_All
-
-
-Syntax:
-
-@example
-pragma No_Elaboration_Code_All [(program_unit_NAME)];
-@end example
-
-This is a program unit pragma (there is also an equivalent aspect of the
-same name) that establishes the restriction @code{No_Elaboration_Code} for
-the current unit and any extended main source units (body and subunits).
-It also has the effect of enforcing a transitive application of this
-aspect, so that if any unit is implicitly or explicitly with’ed by the
-current unit, it must also have the No_Elaboration_Code_All aspect set.
-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{a3}
-@section Pragma No_Heap_Finalization
-
-
-Syntax:
-
-@example
-pragma No_Heap_Finalization [ (first_subtype_LOCAL_NAME) ];
-@end example
-
-Pragma @code{No_Heap_Finalization} may be used as a configuration pragma or as a
-type-specific pragma.
-
-In its configuration form, the pragma must appear within a configuration file
-such as gnat.adc, without an argument. The pragma suppresses the call to
-@code{Finalize} for heap-allocated objects created through library-level named
-access-to-object types in cases where the designated type requires finalization
-actions.
-
-In its type-specific form, the argument of the pragma must denote a
-library-level named access-to-object type. The pragma suppresses the call to
-@code{Finalize} for heap-allocated objects created through the specific access type
-in cases where the designated type requires finalization actions.
-
-It is still possible to finalize such heap-allocated objects by explicitly
-deallocating them.
-
-A library-level named access-to-object type declared within a generic unit will
-lose its @code{No_Heap_Finalization} pragma when the corresponding instance does not
-appear at the library level.
-
-@node Pragma No_Inline,Pragma No_Return,Pragma No_Heap_Finalization,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id25}@anchor{a4}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-inline}@anchor{a5}
-@section Pragma No_Inline
-
-
-Syntax:
-
-@example
-pragma No_Inline (NAME @{, NAME@});
-@end example
-
-This pragma suppresses inlining for the callable entity or the instances of
-the generic subprogram designated by @code{NAME}, including inlining that
-results from the use of pragma @code{Inline}.  This pragma is always active,
-in particular it is not subject to the use of option `-gnatn' or
-`-gnatN'.  It is illegal to specify both pragma @code{No_Inline} and
-pragma @code{Inline_Always} for the same @code{NAME}.
-
-@node Pragma No_Return,Pragma No_Strict_Aliasing,Pragma No_Inline,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-no-return}@anchor{a6}
-@section Pragma No_Return
-
-
-Syntax:
-
-@example
-pragma No_Return (procedure_LOCAL_NAME @{, procedure_LOCAL_NAME@});
-@end example
-
-Each @code{procedure_LOCAL_NAME} argument must refer to one or more procedure
-declarations in the current declarative part.  A procedure to which this
-pragma is applied may not contain any explicit @code{return} statements.
-In addition, if the procedure contains any implicit returns from falling
-off the end of a statement sequence, then execution of that implicit
-return will cause Program_Error to be raised.
-
-One use of this pragma is to identify procedures whose only purpose is to raise
-an exception. Another use of this pragma is to suppress incorrect warnings
-about missing returns in functions, where the last statement of a function
-statement sequence is a call to such a procedure.
-
-Note that in Ada 2005 mode, this pragma is part of the language. It is
-available in all earlier versions of Ada as an implementation-defined
-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{a7}
-@section Pragma No_Strict_Aliasing
-
-
-Syntax:
-
-@example
-pragma No_Strict_Aliasing [([Entity =>] type_LOCAL_NAME)];
-@end example
-
-@code{type_LOCAL_NAME} must refer to an access type
-declaration in the current declarative part.  The effect is to inhibit
-strict aliasing optimization for the given type.  The form with no
-arguments is a configuration pragma which applies to all access types
-declared in units to which the pragma applies. For a detailed
-description of the strict aliasing optimization, and the situations
-in which it must be suppressed, see the section on Optimization and Strict Aliasing
-in the @cite{GNAT User’s Guide}.
-
-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 id26}@anchor{a8}@anchor{gnat_rm/implementation_defined_pragmas pragma-no-tagged-streams}@anchor{a9}
-@section Pragma No_Tagged_Streams
-
-
-Syntax:
-
-@example
-pragma No_Tagged_Streams [([Entity =>] tagged_type_LOCAL_NAME)];
-@end example
-
-Normally when a tagged type is introduced using a full type declaration,
-part of the processing includes generating stream access routines to be
-used by stream attributes referencing the type (or one of its subtypes
-or derived types). This can involve the generation of significant amounts
-of code which is wasted space if stream routines are not needed for the
-type in question.
-
-The @code{No_Tagged_Streams} pragma causes the generation of these stream
-routines to be skipped, and any attempt to use stream operations on
-types subject to this pragma will be statically rejected as illegal.
-
-There are two forms of the pragma. The form with no arguments must appear
-in a declarative sequence or in the declarations of a package spec. This
-pragma affects all subsequent root tagged types declared in the declaration
-sequence, and specifies that no stream routines be generated. The form with
-an argument (for which there is also a corresponding aspect) specifies a
-single root tagged type for which stream routines are not to be generated.
-
-Once the pragma has been given for a particular root tagged type, all subtypes
-and derived types of this type inherit the pragma automatically, so the effect
-applies to a complete hierarchy (this is necessary to deal with the class-wide
-dispatching versions of the stream routines).
-
-When pragmas @code{Discard_Names} and @code{No_Tagged_Streams} are simultaneously
-applied to a tagged type its Expanded_Name and External_Tag are initialized
-with empty strings. This is useful to avoid exposing entity names at binary
-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{aa}
-@section Pragma Normalize_Scalars
-
-
-Syntax:
-
-@example
-pragma Normalize_Scalars;
-@end example
-
-This is a language defined pragma which is fully implemented in GNAT.  The
-effect is to cause all scalar objects that are not otherwise initialized
-to be initialized.  The initial values are implementation dependent and
-are as follows:
-
-
-@table @asis
-
-@item `Standard.Character'
-
-Objects whose root type is Standard.Character are initialized to
-Character’Last unless the subtype range excludes NUL (in which case
-NUL is used). This choice will always generate an invalid value if
-one exists.
-
-@item `Standard.Wide_Character'
-
-Objects whose root type is Standard.Wide_Character are initialized to
-Wide_Character’Last unless the subtype range excludes NUL (in which case
-NUL is used). This choice will always generate an invalid value if
-one exists.
-
-@item `Standard.Wide_Wide_Character'
-
-Objects whose root type is Standard.Wide_Wide_Character are initialized to
-the invalid value 16#FFFF_FFFF# unless the subtype range excludes NUL (in
-which case NUL is used). This choice will always generate an invalid value if
-one exists.
-
-@item `Integer types'
-
-Objects of an integer type are treated differently depending on whether
-negative values are present in the subtype. If no negative values are
-present, then all one bits is used as the initial value except in the
-special case where zero is excluded from the subtype, in which case
-all zero bits are used. This choice will always generate an invalid
-value if one exists.
-
-For subtypes with negative values present, the largest negative number
-is used, except in the unusual case where this largest negative number
-is in the subtype, and the largest positive number is not, in which case
-the largest positive value is used. This choice will always generate
-an invalid value if one exists.
-
-@item `Floating-Point Types'
-
-Objects of all floating-point types are initialized to all 1-bits. For
-standard IEEE format, this corresponds to a NaN (not a number) which is
-indeed an invalid value.
-
-@item `Fixed-Point Types'
-
-Objects of all fixed-point types are treated as described above for integers,
-with the rules applying to the underlying integer value used to represent
-the fixed-point value.
-
-@item `Modular types'
+@item `Modular types'
 
 Objects of a modular type are initialized to all one bits, except in
 the special case where zero is excluded from the subtype, in which
@@ -5952,7 +5559,7 @@ will always generate an invalid value if one exists.
 @end table
 
 @node Pragma Obsolescent,Pragma Optimize_Alignment,Pragma Normalize_Scalars,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id27}@anchor{ab}@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{ac}
+@anchor{gnat_rm/implementation_defined_pragmas id28}@anchor{ae}@anchor{gnat_rm/implementation_defined_pragmas pragma-obsolescent}@anchor{af}
 @section Pragma Obsolescent
 
 
@@ -6048,7 +5655,7 @@ So if you specify @code{Entity =>} for the @code{Entity} argument, and a @code{M
 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{ad}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-optimize-alignment}@anchor{b0}
 @section Pragma Optimize_Alignment
 
 
@@ -6134,7 +5741,7 @@ latter are compiled by default in pragma Optimize_Alignment (Off) mode if no
 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{ae}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ordered}@anchor{b1}
 @section Pragma Ordered
 
 
@@ -6226,7 +5833,7 @@ For additional information please refer to the description of the
 `-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{af}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-overflow-mode}@anchor{b2}
 @section Pragma Overflow_Mode
 
 
@@ -6265,7 +5872,7 @@ The pragma @code{Unsuppress (Overflow_Check)} unsuppresses (enables)
 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{b0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-overriding-renamings}@anchor{b3}
 @section Pragma Overriding_Renamings
 
 
@@ -6300,7 +5907,7 @@ RM 8.3 (15) stipulates that an overridden operation is not visible within the
 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 id28}@anchor{b1}@anchor{gnat_rm/implementation_defined_pragmas pragma-part-of}@anchor{b2}
+@anchor{gnat_rm/implementation_defined_pragmas id29}@anchor{b4}@anchor{gnat_rm/implementation_defined_pragmas pragma-part-of}@anchor{b5}
 @section Pragma Part_Of
 
 
@@ -6316,7 +5923,7 @@ For the semantics of this pragma, see the entry for aspect @code{Part_Of} in the
 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{b3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-partition-elaboration-policy}@anchor{b6}
 @section Pragma Partition_Elaboration_Policy
 
 
@@ -6333,7 +5940,7 @@ versions of Ada as an implementation-defined pragma.
 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{b4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-passive}@anchor{b7}
 @section Pragma Passive
 
 
@@ -6357,7 +5964,7 @@ For more information on the subject of passive tasks, see the section
 ‘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 id29}@anchor{b5}@anchor{gnat_rm/implementation_defined_pragmas pragma-persistent-bss}@anchor{b6}
+@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{b8}@anchor{gnat_rm/implementation_defined_pragmas pragma-persistent-bss}@anchor{b9}
 @section Pragma Persistent_BSS
 
 
@@ -6388,7 +5995,7 @@ If this pragma is used on a target where this feature is not supported,
 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{b7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-post}@anchor{ba}
 @section Pragma Post
 
 
@@ -6413,7 +6020,7 @@ appear at the start of the declarations in a subprogram body
 (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{b8}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-postcondition}@anchor{bb}
 @section Pragma Postcondition
 
 
@@ -6578,7 +6185,7 @@ Ada 2012, and has been retained in its original form for
 compatibility purposes.
 
 @node Pragma Post_Class,Pragma Pre,Pragma Postcondition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-post-class}@anchor{b9}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-post-class}@anchor{bc}
 @section Pragma Post_Class
 
 
@@ -6613,7 +6220,7 @@ policy that controls this pragma is @code{Post'Class}, not
 @code{Post_Class}.
 
 @node Pragma Pre,Pragma Precondition,Pragma Post_Class,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-pre}@anchor{ba}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-pre}@anchor{bd}
 @section Pragma Pre
 
 
@@ -6638,7 +6245,7 @@ appear at the start of the declarations in a subprogram body
 (preceded only by other pragmas).
 
 @node Pragma Precondition,Pragma Predicate,Pragma Pre,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-precondition}@anchor{bb}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-precondition}@anchor{be}
 @section Pragma Precondition
 
 
@@ -6697,7 +6304,7 @@ Ada 2012, and has been retained in its original form for
 compatibility purposes.
 
 @node Pragma Predicate,Pragma Predicate_Failure,Pragma Precondition,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id30}@anchor{bc}@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{bd}
+@anchor{gnat_rm/implementation_defined_pragmas id31}@anchor{bf}@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate}@anchor{c0}
 @section Pragma Predicate
 
 
@@ -6751,7 +6358,7 @@ defined for subtype B). When following this approach, the
 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{be}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-predicate-failure}@anchor{c1}
 @section Pragma Predicate_Failure
 
 
@@ -6768,7 +6375,7 @@ the language-defined
 @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{bf}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-preelaborable-initialization}@anchor{c2}
 @section Pragma Preelaborable_Initialization
 
 
@@ -6783,7 +6390,7 @@ versions of Ada as an implementation-defined pragma.
 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{c0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-prefix-exception-messages}@anchor{c3}
 @section Pragma Prefix_Exception_Messages
 
 
@@ -6814,7 +6421,7 @@ prefixing in this case, you can always call
 @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{c1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-pre-class}@anchor{c4}
 @section Pragma Pre_Class
 
 
@@ -6849,7 +6456,7 @@ policy that controls this pragma is @code{Pre'Class}, not
 @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{c2}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-priority-specific-dispatching}@anchor{c5}
 @section Pragma Priority_Specific_Dispatching
 
 
@@ -6873,7 +6480,7 @@ versions of Ada as an implementation-defined pragma.
 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{c3}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-profile}@anchor{c6}
 @section Pragma Profile
 
 
@@ -7152,7 +6759,7 @@ conforming Ada constructs.  The profile enables the following three pragmas:
 @end itemize
 
 @node Pragma Profile_Warnings,Pragma Propagate_Exceptions,Pragma Profile,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-profile-warnings}@anchor{c4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-profile-warnings}@anchor{c7}
 @section Pragma Profile_Warnings
 
 
@@ -7170,7 +6777,7 @@ violations of the profile generate warning messages instead
 of error messages.
 
 @node Pragma Propagate_Exceptions,Pragma Provide_Shift_Operators,Pragma Profile_Warnings,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-propagate-exceptions}@anchor{c5}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-propagate-exceptions}@anchor{c8}
 @section Pragma Propagate_Exceptions
 
 
@@ -7189,7 +6796,7 @@ purposes. It used to be used in connection with optimization of
 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{c6}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-provide-shift-operators}@anchor{c9}
 @section Pragma Provide_Shift_Operators
 
 
@@ -7209,7 +6816,7 @@ including the function declarations for these five operators, together
 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{c7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-psect-object}@anchor{ca}
 @section Pragma Psect_Object
 
 
@@ -7229,7 +6836,7 @@ EXTERNAL_SYMBOL ::=
 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 id31}@anchor{c8}@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{c9}
+@anchor{gnat_rm/implementation_defined_pragmas id32}@anchor{cb}@anchor{gnat_rm/implementation_defined_pragmas pragma-pure-function}@anchor{cc}
 @section Pragma Pure_Function
 
 
@@ -7291,7 +6898,7 @@ unit is not a Pure unit in the categorization sense. So for example, a 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{ca}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-rational}@anchor{cd}
 @section Pragma Rational
 
 
@@ -7309,7 +6916,7 @@ pragma Profile (Rational);
 @end example
 
 @node Pragma Ravenscar,Pragma Refined_Depends,Pragma Rational,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-ravenscar}@anchor{cb}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-ravenscar}@anchor{ce}
 @section Pragma Ravenscar
 
 
@@ -7329,7 +6936,7 @@ pragma Profile (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 id32}@anchor{cc}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{cd}
+@anchor{gnat_rm/implementation_defined_pragmas id33}@anchor{cf}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-depends}@anchor{d0}
 @section Pragma Refined_Depends
 
 
@@ -7362,7 +6969,7 @@ For the semantics of this pragma, see the entry for aspect @code{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 id33}@anchor{ce}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{cf}
+@anchor{gnat_rm/implementation_defined_pragmas id34}@anchor{d1}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-global}@anchor{d2}
 @section Pragma Refined_Global
 
 
@@ -7387,7 +6994,7 @@ For the semantics of this pragma, see the entry for aspect @code{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 id34}@anchor{d0}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{d1}
+@anchor{gnat_rm/implementation_defined_pragmas id35}@anchor{d3}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-post}@anchor{d4}
 @section Pragma Refined_Post
 
 
@@ -7401,7 +7008,7 @@ For the semantics of this pragma, see the entry for aspect @code{Refined_Post} i
 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 id35}@anchor{d2}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{d3}
+@anchor{gnat_rm/implementation_defined_pragmas id36}@anchor{d5}@anchor{gnat_rm/implementation_defined_pragmas pragma-refined-state}@anchor{d6}
 @section Pragma Refined_State
 
 
@@ -7427,7 +7034,7 @@ For the semantics of this pragma, see the entry for aspect @code{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{d4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-relative-deadline}@anchor{d7}
 @section Pragma Relative_Deadline
 
 
@@ -7442,7 +7049,7 @@ versions of Ada as an implementation-defined pragma.
 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 id36}@anchor{d5}@anchor{gnat_rm/implementation_defined_pragmas pragma-remote-access-type}@anchor{d6}
+@anchor{gnat_rm/implementation_defined_pragmas id37}@anchor{d8}@anchor{gnat_rm/implementation_defined_pragmas pragma-remote-access-type}@anchor{d9}
 @section Pragma Remote_Access_Type
 
 
@@ -7468,7 +7075,7 @@ pertaining to remote access to class-wide types. At instantiation, the
 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{d7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-rename-pragma}@anchor{da}
 @section Pragma Rename_Pragma
 
 
@@ -7507,7 +7114,7 @@ Pragma Inline_Only will not necessarily mean the same thing as the other Ada
 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{d8}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-restricted-run-time}@anchor{db}
 @section Pragma Restricted_Run_Time
 
 
@@ -7528,7 +7135,7 @@ which is the preferred method of setting the 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{d9}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-restriction-warnings}@anchor{dc}
 @section Pragma Restriction_Warnings
 
 
@@ -7566,7 +7173,7 @@ generating a warning, but any other use of implementation
 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{da}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-reviewable}@anchor{dd}
 @section Pragma Reviewable
 
 
@@ -7670,7 +7277,7 @@ comprehensive messages identifying possible problems based on this
 information.
 
 @node Pragma Secondary_Stack_Size,Pragma Share_Generic,Pragma Reviewable,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id37}@anchor{db}@anchor{gnat_rm/implementation_defined_pragmas pragma-secondary-stack-size}@anchor{dc}
+@anchor{gnat_rm/implementation_defined_pragmas id38}@anchor{de}@anchor{gnat_rm/implementation_defined_pragmas pragma-secondary-stack-size}@anchor{df}
 @section Pragma Secondary_Stack_Size
 
 
@@ -7706,7 +7313,7 @@ Note the pragma cannot appear when the restriction @code{No_Secondary_Stack}
 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{dd}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-share-generic}@anchor{e0}
 @section Pragma Share_Generic
 
 
@@ -7724,7 +7331,7 @@ than to check that the given names are all names of generic units or
 generic instances.
 
 @node Pragma Shared,Pragma Short_Circuit_And_Or,Pragma Share_Generic,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id38}@anchor{de}@anchor{gnat_rm/implementation_defined_pragmas pragma-shared}@anchor{df}
+@anchor{gnat_rm/implementation_defined_pragmas id39}@anchor{e1}@anchor{gnat_rm/implementation_defined_pragmas pragma-shared}@anchor{e2}
 @section Pragma Shared
 
 
@@ -7732,7 +7339,7 @@ This pragma is provided for compatibility with Ada 83. The syntax and
 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{e0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-short-circuit-and-or}@anchor{e3}
 @section Pragma Short_Circuit_And_Or
 
 
@@ -7751,7 +7358,7 @@ within the file being compiled, it applies only to the file being compiled.
 There is no requirement that all units in a partition use this option.
 
 @node Pragma Short_Descriptors,Pragma Simple_Storage_Pool_Type,Pragma Short_Circuit_And_Or,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-short-descriptors}@anchor{e1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-short-descriptors}@anchor{e4}
 @section Pragma Short_Descriptors
 
 
@@ -7765,7 +7372,7 @@ This pragma is provided for compatibility with other Ada implementations. It
 is recognized but ignored by all current versions of GNAT.
 
 @node Pragma Simple_Storage_Pool_Type,Pragma Source_File_Name,Pragma Short_Descriptors,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id39}@anchor{e2}@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{e3}
+@anchor{gnat_rm/implementation_defined_pragmas id40}@anchor{e5}@anchor{gnat_rm/implementation_defined_pragmas pragma-simple-storage-pool-type}@anchor{e6}
 @section Pragma Simple_Storage_Pool_Type
 
 
@@ -7819,7 +7426,7 @@ storage-management discipline).
 
 An object of a simple storage pool type can be associated with an access
 type by specifying the attribute
-@ref{e4,,Simple_Storage_Pool}. For example:
+@ref{e7,,Simple_Storage_Pool}. For example:
 
 @example
 My_Pool : My_Simple_Storage_Pool_Type;
@@ -7829,11 +7436,11 @@ type Acc is access My_Data_Type;
 for Acc'Simple_Storage_Pool use My_Pool;
 @end example
 
-See attribute @ref{e4,,Simple_Storage_Pool}
+See attribute @ref{e7,,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 id40}@anchor{e5}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{e6}
+@anchor{gnat_rm/implementation_defined_pragmas id41}@anchor{e8}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name}@anchor{e9}
 @section Pragma Source_File_Name
 
 
@@ -7925,20 +7532,20 @@ aware of these pragmas, and so other tools that use the project file would not
 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{e7,,Pragma Source_File_Name_Project}.
+Source_File_Name cannot appear after a @ref{ea,,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 id41}@anchor{e8}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{e7}
+@anchor{gnat_rm/implementation_defined_pragmas id42}@anchor{eb}@anchor{gnat_rm/implementation_defined_pragmas pragma-source-file-name-project}@anchor{ea}
 @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{e6,,Pragma Source_File_Name}, and
+It cannot appear after a @ref{e9,,Pragma Source_File_Name}, and
 most importantly, once pragma Source_File_Name_Project appears,
 no further Source_File_Name pragmas are allowed.
 
@@ -7950,7 +7557,7 @@ Source_File_Name or Source_File_Name_Project pragmas (which would not be
 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{e9}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-source-reference}@anchor{ec}
 @section Pragma Source_Reference
 
 
@@ -7974,7 +7581,7 @@ string expression other than a string literal.  This is because its value
 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 id42}@anchor{ea}@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{eb}
+@anchor{gnat_rm/implementation_defined_pragmas id43}@anchor{ed}@anchor{gnat_rm/implementation_defined_pragmas pragma-spark-mode}@anchor{ee}
 @section Pragma SPARK_Mode
 
 
@@ -8056,7 +7663,7 @@ SPARK_Mode (@code{Off}), then that pragma will need to be repeated in
 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{ec}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-static-elaboration-desired}@anchor{ef}
 @section Pragma Static_Elaboration_Desired
 
 
@@ -8080,7 +7687,7 @@ construction of larger aggregates with static components that include an others
 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{ed}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-stream-convert}@anchor{f0}
 @section Pragma Stream_Convert
 
 
@@ -8157,7 +7764,7 @@ the pragma is silently ignored, and the default implementation of the stream
 attributes is used instead.
 
 @node Pragma Style_Checks,Pragma Subtitle,Pragma Stream_Convert,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-style-checks}@anchor{ee}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-style-checks}@anchor{f1}
 @section Pragma Style_Checks
 
 
@@ -8230,7 +7837,7 @@ Rf2 : Integer := ARG;      -- OK, no error
 @end example
 
 @node Pragma Subtitle,Pragma Suppress,Pragma Style_Checks,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-subtitle}@anchor{ef}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-subtitle}@anchor{f2}
 @section Pragma Subtitle
 
 
@@ -8244,7 +7851,7 @@ This pragma is recognized for compatibility with other Ada compilers
 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{f0}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress}@anchor{f3}
 @section Pragma Suppress
 
 
@@ -8317,7 +7924,7 @@ Of course, run-time checks are omitted whenever the compiler can prove
 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{f1}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-all}@anchor{f4}
 @section Pragma Suppress_All
 
 
@@ -8336,7 +7943,7 @@ The use of the standard Ada pragma @code{Suppress (All_Checks)}
 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 id43}@anchor{f2}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{f3}
+@anchor{gnat_rm/implementation_defined_pragmas id44}@anchor{f5}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-debug-info}@anchor{f6}
 @section Pragma Suppress_Debug_Info
 
 
@@ -8351,7 +7958,7 @@ for the specified entity. It is intended primarily for use in debugging
 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{f4}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-exception-locations}@anchor{f7}
 @section Pragma Suppress_Exception_Locations
 
 
@@ -8374,7 +7981,7 @@ a partition, so it is fine to have some units within a partition compiled
 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 id44}@anchor{f5}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-initialization}@anchor{f6}
+@anchor{gnat_rm/implementation_defined_pragmas id45}@anchor{f8}@anchor{gnat_rm/implementation_defined_pragmas pragma-suppress-initialization}@anchor{f9}
 @section Pragma Suppress_Initialization
 
 
@@ -8419,7 +8026,7 @@ is suppressed, just as though its subtype had been given in a pragma
 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{f7}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-task-name}@anchor{fa}
 @section Pragma Task_Name
 
 
@@ -8475,7 +8082,7 @@ end;
 @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{f8}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-task-storage}@anchor{fb}
 @section Pragma Task_Storage
 
 
@@ -8495,7 +8102,7 @@ created, depending on the target.  This pragma can appear anywhere a
 type.
 
 @node Pragma Test_Case,Pragma Thread_Local_Storage,Pragma Task_Storage,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id45}@anchor{f9}@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{fa}
+@anchor{gnat_rm/implementation_defined_pragmas id46}@anchor{fc}@anchor{gnat_rm/implementation_defined_pragmas pragma-test-case}@anchor{fd}
 @section Pragma Test_Case
 
 
@@ -8551,7 +8158,7 @@ postcondition. Mode @code{Robustness} indicates that the precondition and
 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 id46}@anchor{fb}@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{fc}
+@anchor{gnat_rm/implementation_defined_pragmas id47}@anchor{fe}@anchor{gnat_rm/implementation_defined_pragmas pragma-thread-local-storage}@anchor{ff}
 @section Pragma Thread_Local_Storage
 
 
@@ -8589,7 +8196,7 @@ If this pragma is used on a system where @code{TLS} is not supported,
 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{fd}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-time-slice}@anchor{100}
 @section Pragma Time_Slice
 
 
@@ -8605,7 +8212,7 @@ It is ignored if it is used in a system that does not allow this control,
 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{fe}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-title}@anchor{101}
 @section Pragma Title
 
 
@@ -8630,7 +8237,7 @@ notation is used, and named and positional notation can be mixed
 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{ff}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant}@anchor{102}
 @section Pragma Type_Invariant
 
 
@@ -8651,7 +8258,7 @@ controlled by the assertion identifier @code{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 id47}@anchor{100}@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant-class}@anchor{101}
+@anchor{gnat_rm/implementation_defined_pragmas id48}@anchor{103}@anchor{gnat_rm/implementation_defined_pragmas pragma-type-invariant-class}@anchor{104}
 @section Pragma Type_Invariant_Class
 
 
@@ -8678,7 +8285,7 @@ policy that controls this pragma is @code{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{102}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unchecked-union}@anchor{105}
 @section Pragma Unchecked_Union
 
 
@@ -8698,7 +8305,7 @@ version in all language modes (Ada 83, Ada 95, and Ada 2005). For full
 details, consult the Ada 2012 Reference Manual, section B.3.3.
 
 @node Pragma Unevaluated_Use_Of_Old,Pragma Unimplemented_Unit,Pragma Unchecked_Union,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unevaluated-use-of-old}@anchor{103}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unevaluated-use-of-old}@anchor{106}
 @section Pragma Unevaluated_Use_Of_Old
 
 
@@ -8753,7 +8360,7 @@ uses up to the end of the corresponding statement sequence or
 sequence of package declarations.
 
 @node Pragma Unimplemented_Unit,Pragma Universal_Aliasing,Pragma Unevaluated_Use_Of_Old,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-unimplemented-unit}@anchor{104}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unimplemented-unit}@anchor{107}
 @section Pragma Unimplemented_Unit
 
 
@@ -8773,7 +8380,7 @@ The abort only happens if code is being generated.  Thus you can use
 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 id48}@anchor{105}@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{106}
+@anchor{gnat_rm/implementation_defined_pragmas id49}@anchor{108}@anchor{gnat_rm/implementation_defined_pragmas pragma-universal-aliasing}@anchor{109}
 @section Pragma Universal_Aliasing
 
 
@@ -8792,7 +8399,7 @@ situations in which it must be suppressed, see the section on
 @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 id49}@anchor{107}@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{108}
+@anchor{gnat_rm/implementation_defined_pragmas id50}@anchor{10a}@anchor{gnat_rm/implementation_defined_pragmas pragma-unmodified}@anchor{10b}
 @section Pragma Unmodified
 
 
@@ -8826,7 +8433,7 @@ Thus it is never necessary to use @code{pragma Unmodified} for such
 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 id50}@anchor{109}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{10a}
+@anchor{gnat_rm/implementation_defined_pragmas id51}@anchor{10c}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced}@anchor{10d}
 @section Pragma Unreferenced
 
 
@@ -8872,7 +8479,7 @@ Note that if a warning is desired for all calls to a given subprogram,
 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{ac,,Pragma Obsolescent}.
+for this purpose, see @ref{af,,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
@@ -8888,7 +8495,7 @@ Thus it is never necessary to use @code{pragma Unreferenced} for such
 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 id51}@anchor{10b}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{10c}
+@anchor{gnat_rm/implementation_defined_pragmas id52}@anchor{10e}@anchor{gnat_rm/implementation_defined_pragmas pragma-unreferenced-objects}@anchor{10f}
 @section Pragma Unreferenced_Objects
 
 
@@ -8913,7 +8520,7 @@ compiler will automatically suppress unwanted warnings about these variables
 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{10d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unreserve-all-interrupts}@anchor{110}
 @section Pragma Unreserve_All_Interrupts
 
 
@@ -8949,7 +8556,7 @@ handled, see pragma @code{Interrupt_State}, which subsumes the functionality
 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{10e}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-unsuppress}@anchor{111}
 @section Pragma Unsuppress
 
 
@@ -8985,7 +8592,7 @@ number of implementation-defined check names. See the description of pragma
 @code{Suppress} for full details.
 
 @node Pragma Unused,Pragma Use_VADS_Size,Pragma Unsuppress,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id52}@anchor{10f}@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{110}
+@anchor{gnat_rm/implementation_defined_pragmas id53}@anchor{112}@anchor{gnat_rm/implementation_defined_pragmas pragma-unused}@anchor{113}
 @section Pragma Unused
 
 
@@ -9019,7 +8626,7 @@ Thus it is never necessary to use @code{pragma Unused} for such
 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{111}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-use-vads-size}@anchor{114}
 @section Pragma Use_VADS_Size
 
 
@@ -9043,7 +8650,7 @@ as implemented in the VADS compiler.  See description of the 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{112}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-validity-checks}@anchor{115}
 @section Pragma Validity_Checks
 
 
@@ -9099,7 +8706,7 @@ A := C;                       -- C will be validity checked
 @end example
 
 @node Pragma Volatile,Pragma Volatile_Full_Access,Pragma Validity_Checks,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id53}@anchor{113}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{114}
+@anchor{gnat_rm/implementation_defined_pragmas id54}@anchor{116}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile}@anchor{117}
 @section Pragma Volatile
 
 
@@ -9117,7 +8724,7 @@ implementation of pragma Volatile is upwards compatible with the
 implementation in DEC Ada 83.
 
 @node Pragma Volatile_Full_Access,Pragma Volatile_Function,Pragma Volatile,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas id54}@anchor{115}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-full-access}@anchor{116}
+@anchor{gnat_rm/implementation_defined_pragmas id55}@anchor{118}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-full-access}@anchor{119}
 @section Pragma Volatile_Full_Access
 
 
@@ -9143,7 +8750,7 @@ is not to the whole object; the compiler is allowed (and generally will)
 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 id55}@anchor{117}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-function}@anchor{118}
+@anchor{gnat_rm/implementation_defined_pragmas id56}@anchor{11a}@anchor{gnat_rm/implementation_defined_pragmas pragma-volatile-function}@anchor{11b}
 @section Pragma Volatile_Function
 
 
@@ -9157,7 +8764,7 @@ For the semantics of this pragma, see the entry for aspect @code{Volatile_Functi
 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{119}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-warning-as-error}@anchor{11c}
 @section Pragma Warning_As_Error
 
 
@@ -9197,7 +8804,7 @@ you can use multiple pragma Warning_As_Error.
 
 The above use of patterns to match the message applies only to warning
 messages generated by the front end. This pragma can also be applied to
-warnings provided by the back end and mentioned in @ref{11a,,Pragma Warnings}.
+warnings provided by the back end and mentioned in @ref{11d,,Pragma Warnings}.
 By using a single full `-Wxxx' switch in the pragma, such warnings
 can also be treated as errors.
 
@@ -9247,7 +8854,7 @@ the tag is changed from “warning:” to “error:” and the string
 “[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 id56}@anchor{11b}@anchor{gnat_rm/implementation_defined_pragmas pragma-warnings}@anchor{11a}
+@anchor{gnat_rm/implementation_defined_pragmas id57}@anchor{11e}@anchor{gnat_rm/implementation_defined_pragmas pragma-warnings}@anchor{11d}
 @section Pragma Warnings
 
 
@@ -9403,7 +9010,7 @@ selectively for each tool, and as a consequence to detect useless pragma
 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{11c}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-weak-external}@anchor{11f}
 @section Pragma Weak_External
 
 
@@ -9454,7 +9061,7 @@ end External_Module;
 @end example
 
 @node Pragma Wide_Character_Encoding,,Pragma Weak_External,Implementation Defined Pragmas
-@anchor{gnat_rm/implementation_defined_pragmas pragma-wide-character-encoding}@anchor{11d}
+@anchor{gnat_rm/implementation_defined_pragmas pragma-wide-character-encoding}@anchor{120}
 @section Pragma Wide_Character_Encoding
 
 
@@ -9485,7 +9092,7 @@ encoding within that file, and does not affect withed units, specs,
 or subunits.
 
 @node Implementation Defined Aspects,Implementation Defined Attributes,Implementation Defined Pragmas,Top
-@anchor{gnat_rm/implementation_defined_aspects doc}@anchor{11e}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{11f}@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{120}
+@anchor{gnat_rm/implementation_defined_aspects doc}@anchor{121}@anchor{gnat_rm/implementation_defined_aspects id1}@anchor{122}@anchor{gnat_rm/implementation_defined_aspects implementation-defined-aspects}@anchor{123}
 @chapter Implementation Defined Aspects
 
 
@@ -9605,7 +9212,7 @@ or attribute definition clause.
 @end menu
 
 @node Aspect Abstract_State,Aspect Annotate,,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-abstract-state}@anchor{121}
+@anchor{gnat_rm/implementation_defined_aspects aspect-abstract-state}@anchor{124}
 @section Aspect Abstract_State
 
 
@@ -9614,7 +9221,7 @@ or attribute definition clause.
 This aspect is equivalent to @ref{1e,,pragma Abstract_State}.
 
 @node Aspect Annotate,Aspect Async_Readers,Aspect Abstract_State,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-annotate}@anchor{122}
+@anchor{gnat_rm/implementation_defined_aspects aspect-annotate}@anchor{125}
 @section Aspect Annotate
 
 
@@ -9641,7 +9248,7 @@ Equivalent to @code{pragma Annotate (ID, ID @{, ARG@}, Entity => Name);}
 @end table
 
 @node Aspect Async_Readers,Aspect Async_Writers,Aspect Annotate,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-async-readers}@anchor{123}
+@anchor{gnat_rm/implementation_defined_aspects aspect-async-readers}@anchor{126}
 @section Aspect Async_Readers
 
 
@@ -9650,7 +9257,7 @@ Equivalent to @code{pragma Annotate (ID, ID @{, ARG@}, Entity => Name);}
 This boolean aspect is equivalent to @ref{30,,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{124}
+@anchor{gnat_rm/implementation_defined_aspects aspect-async-writers}@anchor{127}
 @section Aspect Async_Writers
 
 
@@ -9659,7 +9266,7 @@ This boolean aspect is equivalent to @ref{30,,pragma Async_Readers}.
 This boolean aspect is equivalent to @ref{32,,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{125}
+@anchor{gnat_rm/implementation_defined_aspects aspect-constant-after-elaboration}@anchor{128}
 @section Aspect Constant_After_Elaboration
 
 
@@ -9668,7 +9275,7 @@ This boolean aspect is equivalent to @ref{32,,pragma Async_Writers}.
 This aspect is equivalent to @ref{42,,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{126}
+@anchor{gnat_rm/implementation_defined_aspects aspect-contract-cases}@anchor{129}
 @section Aspect Contract_Cases
 
 
@@ -9679,7 +9286,7 @@ 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{127}
+@anchor{gnat_rm/implementation_defined_aspects aspect-depends}@anchor{12a}
 @section Aspect Depends
 
 
@@ -9688,7 +9295,7 @@ aggregate.
 This aspect is equivalent to @ref{54,,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{128}
+@anchor{gnat_rm/implementation_defined_aspects aspect-default-initial-condition}@anchor{12b}
 @section Aspect Default_Initial_Condition
 
 
@@ -9697,7 +9304,7 @@ This aspect is equivalent to @ref{54,,pragma Depends}.
 This aspect is equivalent to @ref{50,,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{129}
+@anchor{gnat_rm/implementation_defined_aspects aspect-dimension}@anchor{12c}
 @section Aspect Dimension
 
 
@@ -9733,7 +9340,7 @@ Note that when the dimensioned type is an integer type, then any
 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{12a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-dimension-system}@anchor{12d}
 @section Aspect Dimension_System
 
 
@@ -9793,7 +9400,7 @@ See section ‘Performing Dimensionality Analysis in GNAT’ in the GNAT Users
 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{12b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-disable-controlled}@anchor{12e}
 @section Aspect Disable_Controlled
 
 
@@ -9806,7 +9413,7 @@ where for example you might want a record to be controlled or not depending on
 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{12c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-effective-reads}@anchor{12f}
 @section Aspect Effective_Reads
 
 
@@ -9815,7 +9422,7 @@ whether some run-time check is enabled or suppressed.
 This aspect is equivalent to @ref{59,,pragma Effective_Reads}.
 
 @node Aspect Effective_Writes,Aspect Extensions_Visible,Aspect Effective_Reads,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-effective-writes}@anchor{12d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-effective-writes}@anchor{130}
 @section Aspect Effective_Writes
 
 
@@ -9824,92 +9431,92 @@ This aspect is equivalent to @ref{59,,pragma Effective_Reads}.
 This aspect is equivalent to @ref{5b,,pragma Effective_Writes}.
 
 @node Aspect Extensions_Visible,Aspect Favor_Top_Level,Aspect Effective_Writes,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-extensions-visible}@anchor{12e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-extensions-visible}@anchor{131}
 @section Aspect Extensions_Visible
 
 
 @geindex Extensions_Visible
 
-This aspect is equivalent to @ref{66,,pragma Extensions_Visible}.
+This aspect is equivalent to @ref{69,,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{12f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-favor-top-level}@anchor{132}
 @section Aspect Favor_Top_Level
 
 
 @geindex Favor_Top_Level
 
-This boolean aspect is equivalent to @ref{6b,,pragma Favor_Top_Level}.
+This boolean aspect is equivalent to @ref{6e,,pragma Favor_Top_Level}.
 
 @node Aspect Ghost,Aspect Global,Aspect Favor_Top_Level,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-ghost}@anchor{130}
+@anchor{gnat_rm/implementation_defined_aspects aspect-ghost}@anchor{133}
 @section Aspect Ghost
 
 
 @geindex Ghost
 
-This aspect is equivalent to @ref{6f,,pragma Ghost}.
+This aspect is equivalent to @ref{72,,pragma Ghost}.
 
 @node Aspect Global,Aspect Initial_Condition,Aspect Ghost,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-global}@anchor{131}
+@anchor{gnat_rm/implementation_defined_aspects aspect-global}@anchor{134}
 @section Aspect Global
 
 
 @geindex Global
 
-This aspect is equivalent to @ref{71,,pragma Global}.
+This aspect is equivalent to @ref{74,,pragma Global}.
 
 @node Aspect Initial_Condition,Aspect Initializes,Aspect Global,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-initial-condition}@anchor{132}
+@anchor{gnat_rm/implementation_defined_aspects aspect-initial-condition}@anchor{135}
 @section Aspect Initial_Condition
 
 
 @geindex Initial_Condition
 
-This aspect is equivalent to @ref{7e,,pragma Initial_Condition}.
+This aspect is equivalent to @ref{81,,pragma Initial_Condition}.
 
 @node Aspect Initializes,Aspect Inline_Always,Aspect Initial_Condition,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-initializes}@anchor{133}
+@anchor{gnat_rm/implementation_defined_aspects aspect-initializes}@anchor{136}
 @section Aspect Initializes
 
 
 @geindex Initializes
 
-This aspect is equivalent to @ref{81,,pragma Initializes}.
+This aspect is equivalent to @ref{84,,pragma Initializes}.
 
 @node Aspect Inline_Always,Aspect Invariant,Aspect Initializes,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-inline-always}@anchor{134}
+@anchor{gnat_rm/implementation_defined_aspects aspect-inline-always}@anchor{137}
 @section Aspect Inline_Always
 
 
 @geindex Inline_Always
 
-This boolean aspect is equivalent to @ref{83,,pragma Inline_Always}.
+This boolean aspect is equivalent to @ref{86,,pragma Inline_Always}.
 
 @node Aspect Invariant,Aspect Invariant’Class,Aspect Inline_Always,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-invariant}@anchor{135}
+@anchor{gnat_rm/implementation_defined_aspects aspect-invariant}@anchor{138}
 @section Aspect Invariant
 
 
 @geindex Invariant
 
-This aspect is equivalent to @ref{8a,,pragma Invariant}. It is a
+This aspect is equivalent to @ref{8d,,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{136}
+@anchor{gnat_rm/implementation_defined_aspects aspect-invariant-class}@anchor{139}
 @section Aspect Invariant’Class
 
 
 @geindex Invariant'Class
 
-This aspect is equivalent to @ref{101,,pragma Type_Invariant_Class}. It is a
+This aspect is equivalent to @ref{104,,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{137}
+@anchor{gnat_rm/implementation_defined_aspects aspect-iterable}@anchor{13a}
 @section Aspect Iterable
 
 
@@ -9993,73 +9600,73 @@ function Get_Element (Cont : Container; Position : Cursor) return Element_Type;
 This aspect is used in the GNAT-defined formal container packages.
 
 @node Aspect Linker_Section,Aspect Lock_Free,Aspect Iterable,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-linker-section}@anchor{138}
+@anchor{gnat_rm/implementation_defined_aspects aspect-linker-section}@anchor{13b}
 @section Aspect Linker_Section
 
 
 @geindex Linker_Section
 
-This aspect is equivalent to @ref{92,,pragma Linker_Section}.
+This aspect is equivalent to @ref{95,,pragma Linker_Section}.
 
 @node Aspect Lock_Free,Aspect Max_Queue_Length,Aspect Linker_Section,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-lock-free}@anchor{139}
+@anchor{gnat_rm/implementation_defined_aspects aspect-lock-free}@anchor{13c}
 @section Aspect Lock_Free
 
 
 @geindex Lock_Free
 
-This boolean aspect is equivalent to @ref{94,,pragma Lock_Free}.
+This boolean aspect is equivalent to @ref{97,,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{13a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-max-queue-length}@anchor{13d}
 @section Aspect Max_Queue_Length
 
 
 @geindex Max_Queue_Length
 
-This aspect is equivalent to @ref{9c,,pragma Max_Queue_Length}.
+This aspect is equivalent to @ref{9f,,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{13b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-caching}@anchor{13e}
 @section Aspect No_Caching
 
 
 @geindex No_Caching
 
-This boolean aspect is equivalent to @ref{9f,,pragma No_Caching}.
+This boolean aspect is equivalent to @ref{a2,,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{13c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-elaboration-code-all}@anchor{13f}
 @section Aspect No_Elaboration_Code_All
 
 
 @geindex No_Elaboration_Code_All
 
-This aspect is equivalent to @ref{a2,,pragma No_Elaboration_Code_All}
+This aspect is equivalent to @ref{a5,,pragma No_Elaboration_Code_All}
 for a program unit.
 
 @node Aspect No_Inline,Aspect No_Tagged_Streams,Aspect No_Elaboration_Code_All,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-inline}@anchor{13d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-inline}@anchor{140}
 @section Aspect No_Inline
 
 
 @geindex No_Inline
 
-This boolean aspect is equivalent to @ref{a5,,pragma No_Inline}.
+This boolean aspect is equivalent to @ref{a8,,pragma No_Inline}.
 
 @node Aspect No_Tagged_Streams,Aspect No_Task_Parts,Aspect No_Inline,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-no-tagged-streams}@anchor{13e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-tagged-streams}@anchor{141}
 @section Aspect No_Tagged_Streams
 
 
 @geindex No_Tagged_Streams
 
-This aspect is equivalent to @ref{a9,,pragma No_Tagged_Streams} with an
+This aspect is equivalent to @ref{ac,,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{13f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-no-task-parts}@anchor{142}
 @section Aspect No_Task_Parts
 
 
@@ -10075,51 +9682,51 @@ away certain tasking-related code that would otherwise be needed
 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{140}
+@anchor{gnat_rm/implementation_defined_aspects aspect-object-size}@anchor{143}
 @section Aspect Object_Size
 
 
 @geindex Object_Size
 
-This aspect is equivalent to @ref{141,,attribute Object_Size}.
+This aspect is equivalent to @ref{144,,attribute Object_Size}.
 
 @node Aspect Obsolescent,Aspect Part_Of,Aspect Object_Size,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-obsolescent}@anchor{142}
+@anchor{gnat_rm/implementation_defined_aspects aspect-obsolescent}@anchor{145}
 @section Aspect Obsolescent
 
 
 @geindex Obsolescent
 
-This aspect is equivalent to @ref{ac,,pragma Obsolescent}. Note that the
+This aspect is equivalent to @ref{af,,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{143}
+@anchor{gnat_rm/implementation_defined_aspects aspect-part-of}@anchor{146}
 @section Aspect Part_Of
 
 
 @geindex Part_Of
 
-This aspect is equivalent to @ref{b2,,pragma Part_Of}.
+This aspect is equivalent to @ref{b5,,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{144}
+@anchor{gnat_rm/implementation_defined_aspects aspect-persistent-bss}@anchor{147}
 @section Aspect Persistent_BSS
 
 
 @geindex Persistent_BSS
 
-This boolean aspect is equivalent to @ref{b6,,pragma Persistent_BSS}.
+This boolean aspect is equivalent to @ref{b9,,pragma Persistent_BSS}.
 
 @node Aspect Predicate,Aspect Pure_Function,Aspect Persistent_BSS,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-predicate}@anchor{145}
+@anchor{gnat_rm/implementation_defined_aspects aspect-predicate}@anchor{148}
 @section Aspect Predicate
 
 
 @geindex Predicate
 
-This aspect is equivalent to @ref{bd,,pragma Predicate}. It is thus
+This aspect is equivalent to @ref{c0,,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
@@ -10127,52 +9734,52 @@ expression. It is also separately controllable using pragma
 @code{Assertion_Policy}.
 
 @node Aspect Pure_Function,Aspect Refined_Depends,Aspect Predicate,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-pure-function}@anchor{146}
+@anchor{gnat_rm/implementation_defined_aspects aspect-pure-function}@anchor{149}
 @section Aspect Pure_Function
 
 
 @geindex Pure_Function
 
-This boolean aspect is equivalent to @ref{c9,,pragma Pure_Function}.
+This boolean aspect is equivalent to @ref{cc,,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{147}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-depends}@anchor{14a}
 @section Aspect Refined_Depends
 
 
 @geindex Refined_Depends
 
-This aspect is equivalent to @ref{cd,,pragma Refined_Depends}.
+This aspect is equivalent to @ref{d0,,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{148}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-global}@anchor{14b}
 @section Aspect Refined_Global
 
 
 @geindex Refined_Global
 
-This aspect is equivalent to @ref{cf,,pragma Refined_Global}.
+This aspect is equivalent to @ref{d2,,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{149}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-post}@anchor{14c}
 @section Aspect Refined_Post
 
 
 @geindex Refined_Post
 
-This aspect is equivalent to @ref{d1,,pragma Refined_Post}.
+This aspect is equivalent to @ref{d4,,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{14a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-refined-state}@anchor{14d}
 @section Aspect Refined_State
 
 
 @geindex Refined_State
 
-This aspect is equivalent to @ref{d3,,pragma Refined_State}.
+This aspect is equivalent to @ref{d6,,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{14b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-relaxed-initialization}@anchor{14e}
 @section Aspect Relaxed_Initialization
 
 
@@ -10182,187 +9789,187 @@ For the syntax and semantics of this aspect, see the SPARK 2014 Reference
 Manual, section 6.10.
 
 @node Aspect Remote_Access_Type,Aspect Secondary_Stack_Size,Aspect Relaxed_Initialization,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-remote-access-type}@anchor{14c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-remote-access-type}@anchor{14f}
 @section Aspect Remote_Access_Type
 
 
 @geindex Remote_Access_Type
 
-This aspect is equivalent to @ref{d6,,pragma Remote_Access_Type}.
+This aspect is equivalent to @ref{d9,,pragma Remote_Access_Type}.
 
 @node Aspect Secondary_Stack_Size,Aspect Scalar_Storage_Order,Aspect Remote_Access_Type,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-secondary-stack-size}@anchor{14d}
+@anchor{gnat_rm/implementation_defined_aspects aspect-secondary-stack-size}@anchor{150}
 @section Aspect Secondary_Stack_Size
 
 
 @geindex Secondary_Stack_Size
 
-This aspect is equivalent to @ref{dc,,pragma Secondary_Stack_Size}.
+This aspect is equivalent to @ref{df,,pragma Secondary_Stack_Size}.
 
 @node Aspect Scalar_Storage_Order,Aspect Shared,Aspect Secondary_Stack_Size,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-scalar-storage-order}@anchor{14e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-scalar-storage-order}@anchor{151}
 @section Aspect Scalar_Storage_Order
 
 
 @geindex Scalar_Storage_Order
 
-This aspect is equivalent to a @ref{14f,,attribute Scalar_Storage_Order}.
+This aspect is equivalent to a @ref{152,,attribute Scalar_Storage_Order}.
 
 @node Aspect Shared,Aspect Simple_Storage_Pool,Aspect Scalar_Storage_Order,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-shared}@anchor{150}
+@anchor{gnat_rm/implementation_defined_aspects aspect-shared}@anchor{153}
 @section Aspect Shared
 
 
 @geindex Shared
 
-This boolean aspect is equivalent to @ref{df,,pragma Shared}
+This boolean aspect is equivalent to @ref{e2,,pragma Shared}
 and is thus a synonym for aspect @code{Atomic}.
 
 @node Aspect Simple_Storage_Pool,Aspect Simple_Storage_Pool_Type,Aspect Shared,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool}@anchor{151}
+@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool}@anchor{154}
 @section Aspect Simple_Storage_Pool
 
 
 @geindex Simple_Storage_Pool
 
-This aspect is equivalent to @ref{e4,,attribute Simple_Storage_Pool}.
+This aspect is equivalent to @ref{e7,,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{152}
+@anchor{gnat_rm/implementation_defined_aspects aspect-simple-storage-pool-type}@anchor{155}
 @section Aspect Simple_Storage_Pool_Type
 
 
 @geindex Simple_Storage_Pool_Type
 
-This boolean aspect is equivalent to @ref{e3,,pragma Simple_Storage_Pool_Type}.
+This boolean aspect is equivalent to @ref{e6,,pragma Simple_Storage_Pool_Type}.
 
 @node Aspect SPARK_Mode,Aspect Suppress_Debug_Info,Aspect Simple_Storage_Pool_Type,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-spark-mode}@anchor{153}
+@anchor{gnat_rm/implementation_defined_aspects aspect-spark-mode}@anchor{156}
 @section Aspect SPARK_Mode
 
 
 @geindex SPARK_Mode
 
-This aspect is equivalent to @ref{eb,,pragma SPARK_Mode} and
+This aspect is equivalent to @ref{ee,,pragma SPARK_Mode} and
 may be specified for either or both of the specification and body
 of a subprogram or package.
 
 @node Aspect Suppress_Debug_Info,Aspect Suppress_Initialization,Aspect SPARK_Mode,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-debug-info}@anchor{154}
+@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-debug-info}@anchor{157}
 @section Aspect Suppress_Debug_Info
 
 
 @geindex Suppress_Debug_Info
 
-This boolean aspect is equivalent to @ref{f3,,pragma Suppress_Debug_Info}.
+This boolean aspect is equivalent to @ref{f6,,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{155}
+@anchor{gnat_rm/implementation_defined_aspects aspect-suppress-initialization}@anchor{158}
 @section Aspect Suppress_Initialization
 
 
 @geindex Suppress_Initialization
 
-This boolean aspect is equivalent to @ref{f6,,pragma Suppress_Initialization}.
+This boolean aspect is equivalent to @ref{f9,,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{156}
+@anchor{gnat_rm/implementation_defined_aspects aspect-test-case}@anchor{159}
 @section Aspect Test_Case
 
 
 @geindex Test_Case
 
-This aspect is equivalent to @ref{fa,,pragma Test_Case}.
+This aspect is equivalent to @ref{fd,,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{157}
+@anchor{gnat_rm/implementation_defined_aspects aspect-thread-local-storage}@anchor{15a}
 @section Aspect Thread_Local_Storage
 
 
 @geindex Thread_Local_Storage
 
-This boolean aspect is equivalent to @ref{fc,,pragma Thread_Local_Storage}.
+This boolean aspect is equivalent to @ref{ff,,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{158}
+@anchor{gnat_rm/implementation_defined_aspects aspect-universal-aliasing}@anchor{15b}
 @section Aspect Universal_Aliasing
 
 
 @geindex Universal_Aliasing
 
-This boolean aspect is equivalent to @ref{106,,pragma Universal_Aliasing}.
+This boolean aspect is equivalent to @ref{109,,pragma Universal_Aliasing}.
 
 @node Aspect Unmodified,Aspect Unreferenced,Aspect Universal_Aliasing,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-unmodified}@anchor{159}
+@anchor{gnat_rm/implementation_defined_aspects aspect-unmodified}@anchor{15c}
 @section Aspect Unmodified
 
 
 @geindex Unmodified
 
-This boolean aspect is equivalent to @ref{108,,pragma Unmodified}.
+This boolean aspect is equivalent to @ref{10b,,pragma Unmodified}.
 
 @node Aspect Unreferenced,Aspect Unreferenced_Objects,Aspect Unmodified,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced}@anchor{15a}
+@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced}@anchor{15d}
 @section Aspect Unreferenced
 
 
 @geindex Unreferenced
 
-This boolean aspect is equivalent to @ref{10a,,pragma Unreferenced}.
+This boolean aspect is equivalent to @ref{10d,,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 Value_Size,Aspect Unreferenced,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced-objects}@anchor{15b}
+@anchor{gnat_rm/implementation_defined_aspects aspect-unreferenced-objects}@anchor{15e}
 @section Aspect Unreferenced_Objects
 
 
 @geindex Unreferenced_Objects
 
-This boolean aspect is equivalent to @ref{10c,,pragma Unreferenced_Objects}.
+This boolean aspect is equivalent to @ref{10f,,pragma Unreferenced_Objects}.
 
 @node Aspect Value_Size,Aspect Volatile_Full_Access,Aspect Unreferenced_Objects,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-value-size}@anchor{15c}
+@anchor{gnat_rm/implementation_defined_aspects aspect-value-size}@anchor{15f}
 @section Aspect Value_Size
 
 
 @geindex Value_Size
 
-This aspect is equivalent to @ref{15d,,attribute Value_Size}.
+This aspect is equivalent to @ref{160,,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{15e}
+@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-full-access}@anchor{161}
 @section Aspect Volatile_Full_Access
 
 
 @geindex Volatile_Full_Access
 
-This boolean aspect is equivalent to @ref{116,,pragma Volatile_Full_Access}.
+This boolean aspect is equivalent to @ref{119,,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{15f}
+@anchor{gnat_rm/implementation_defined_aspects aspect-volatile-function}@anchor{162}
 @section Aspect Volatile_Function
 
 
 @geindex Volatile_Function
 
-This boolean aspect is equivalent to @ref{118,,pragma Volatile_Function}.
+This boolean aspect is equivalent to @ref{11b,,pragma Volatile_Function}.
 
 @node Aspect Warnings,,Aspect Volatile_Function,Implementation Defined Aspects
-@anchor{gnat_rm/implementation_defined_aspects aspect-warnings}@anchor{160}
+@anchor{gnat_rm/implementation_defined_aspects aspect-warnings}@anchor{163}
 @section Aspect Warnings
 
 
 @geindex Warnings
 
-This aspect is equivalent to the two argument form of @ref{11a,,pragma Warnings},
+This aspect is equivalent to the two argument form of @ref{11d,,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{161}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{162}@anchor{gnat_rm/implementation_defined_attributes implementation-defined-attributes}@anchor{8}
+@anchor{gnat_rm/implementation_defined_attributes doc}@anchor{164}@anchor{gnat_rm/implementation_defined_attributes id1}@anchor{165}@anchor{gnat_rm/implementation_defined_attributes implementation-defined-attributes}@anchor{8}
 @chapter Implementation Defined Attributes
 
 
@@ -10468,7 +10075,7 @@ consideration, you should minimize the use of these attributes.
 @end menu
 
 @node Attribute Abort_Signal,Attribute Address_Size,,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-abort-signal}@anchor{163}
+@anchor{gnat_rm/implementation_defined_attributes attribute-abort-signal}@anchor{166}
 @section Attribute Abort_Signal
 
 
@@ -10482,7 +10089,7 @@ completely outside the normal semantics of Ada, for a user program to
 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{164}
+@anchor{gnat_rm/implementation_defined_attributes attribute-address-size}@anchor{167}
 @section Attribute Address_Size
 
 
@@ -10498,7 +10105,7 @@ reference to System.Address’Size is nonstatic because Address
 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{165}
+@anchor{gnat_rm/implementation_defined_attributes attribute-asm-input}@anchor{168}
 @section Attribute Asm_Input
 
 
@@ -10512,10 +10119,10 @@ to be a static expression, and is the constraint for the parameter,
 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{166,,Machine Code Insertions}
+@ref{169,,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{167}
+@anchor{gnat_rm/implementation_defined_attributes attribute-asm-output}@anchor{16a}
 @section Attribute Asm_Output
 
 
@@ -10531,10 +10138,10 @@ result.  The possible values for constraint are the same as those used in
 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{166,,Machine Code Insertions}
+@ref{169,,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{168}
+@anchor{gnat_rm/implementation_defined_attributes attribute-atomic-always-lock-free}@anchor{16b}
 @section Attribute Atomic_Always_Lock_Free
 
 
@@ -10546,7 +10153,7 @@ and False otherwise.  The result indicate whether atomic operations are
 supported by the target for the given type.
 
 @node Attribute Bit,Attribute Bit_Position,Attribute Atomic_Always_Lock_Free,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-bit}@anchor{169}
+@anchor{gnat_rm/implementation_defined_attributes attribute-bit}@anchor{16c}
 @section Attribute Bit
 
 
@@ -10577,7 +10184,7 @@ This attribute is designed to be compatible with the DEC Ada 83 definition
 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{16a}
+@anchor{gnat_rm/implementation_defined_attributes attribute-bit-position}@anchor{16d}
 @section Attribute Bit_Position
 
 
@@ -10592,7 +10199,7 @@ type `universal_integer'.  The value depends only on the field
 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{16b}
+@anchor{gnat_rm/implementation_defined_attributes attribute-code-address}@anchor{16e}
 @section Attribute Code_Address
 
 
@@ -10635,7 +10242,7 @@ the same value as is returned by the corresponding @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{16c}
+@anchor{gnat_rm/implementation_defined_attributes attribute-compiler-version}@anchor{16f}
 @section Attribute Compiler_Version
 
 
@@ -10646,7 +10253,7 @@ prefix) yields a static string identifying the version of the compiler
 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{16d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-constrained}@anchor{170}
 @section Attribute Constrained
 
 
@@ -10661,7 +10268,7 @@ record type without discriminants is always @code{True}. This usage is
 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{16e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-default-bit-order}@anchor{171}
 @section Attribute Default_Bit_Order
 
 
@@ -10678,7 +10285,7 @@ as a @code{Pos} value (0 for @code{High_Order_First}, 1 for
 @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{16f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-default-scalar-storage-order}@anchor{172}
 @section Attribute Default_Scalar_Storage_Order
 
 
@@ -10695,7 +10302,7 @@ equal to @code{Default_Bit_Order} if unspecified) as a
 @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{170}
+@anchor{gnat_rm/implementation_defined_attributes attribute-deref}@anchor{173}
 @section Attribute Deref
 
 
@@ -10708,7 +10315,7 @@ a named access-to-@cite{typ} type, except that it yields a variable, so it can b
 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{171}
+@anchor{gnat_rm/implementation_defined_attributes attribute-descriptor-size}@anchor{174}
 @section Attribute Descriptor_Size
 
 
@@ -10737,7 +10344,7 @@ since @code{Positive} has an alignment of 4, the size of the descriptor is
 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{172}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elaborated}@anchor{175}
 @section Attribute Elaborated
 
 
@@ -10752,7 +10359,7 @@ units has been completed.  An exception is for units which need no
 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{173}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elab-body}@anchor{176}
 @section Attribute Elab_Body
 
 
@@ -10768,7 +10375,7 @@ e.g., if it is necessary to do selective re-elaboration to fix some
 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{174}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elab-spec}@anchor{177}
 @section Attribute Elab_Spec
 
 
@@ -10784,7 +10391,7 @@ Ada code, e.g., if it is necessary to do selective re-elaboration to fix
 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{175}
+@anchor{gnat_rm/implementation_defined_attributes attribute-elab-subp-body}@anchor{178}
 @section Attribute Elab_Subp_Body
 
 
@@ -10798,7 +10405,7 @@ elaboration procedure by the binder in CodePeer mode only and is unrecognized
 otherwise.
 
 @node Attribute Emax,Attribute Enabled,Attribute Elab_Subp_Body,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-emax}@anchor{176}
+@anchor{gnat_rm/implementation_defined_attributes attribute-emax}@anchor{179}
 @section Attribute Emax
 
 
@@ -10811,7 +10418,7 @@ the Ada 83 reference manual for an exact description of the semantics of
 this attribute.
 
 @node Attribute Enabled,Attribute Enum_Rep,Attribute Emax,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-enabled}@anchor{177}
+@anchor{gnat_rm/implementation_defined_attributes attribute-enabled}@anchor{17a}
 @section Attribute Enabled
 
 
@@ -10835,7 +10442,7 @@ a @code{pragma Suppress} or @code{pragma Unsuppress} before instantiating
 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{178}
+@anchor{gnat_rm/implementation_defined_attributes attribute-enum-rep}@anchor{17b}
 @section Attribute Enum_Rep
 
 
@@ -10875,7 +10482,7 @@ integer calculation is done at run time, then the call to @code{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{179}
+@anchor{gnat_rm/implementation_defined_attributes attribute-enum-val}@anchor{17c}
 @section Attribute Enum_Val
 
 
@@ -10901,7 +10508,7 @@ absence of an enumeration representation clause.  This is a static
 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{17a}
+@anchor{gnat_rm/implementation_defined_attributes attribute-epsilon}@anchor{17d}
 @section Attribute Epsilon
 
 
@@ -10914,7 +10521,7 @@ the Ada 83 reference manual for an exact description of the semantics of
 this attribute.
 
 @node Attribute Fast_Math,Attribute Finalization_Size,Attribute Epsilon,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-fast-math}@anchor{17b}
+@anchor{gnat_rm/implementation_defined_attributes attribute-fast-math}@anchor{17e}
 @section Attribute Fast_Math
 
 
@@ -10925,7 +10532,7 @@ prefix) yields a static Boolean value that is True if pragma
 @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{17c}
+@anchor{gnat_rm/implementation_defined_attributes attribute-finalization-size}@anchor{17f}
 @section Attribute Finalization_Size
 
 
@@ -10943,7 +10550,7 @@ class-wide type whose tag denotes a type with no controlled parts.
 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{17d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-fixed-value}@anchor{180}
 @section Attribute Fixed_Value
 
 
@@ -10970,7 +10577,7 @@ This attribute is primarily intended for use in implementation of the
 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{17e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-from-any}@anchor{181}
 @section Attribute From_Any
 
 
@@ -10980,7 +10587,7 @@ This internal attribute is used for the generation of remote subprogram
 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{17f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-has-access-values}@anchor{182}
 @section Attribute Has_Access_Values
 
 
@@ -10998,7 +10605,7 @@ definitions.  If the attribute is applied to a generic private type, it
 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{180}
+@anchor{gnat_rm/implementation_defined_attributes attribute-has-discriminants}@anchor{183}
 @section Attribute Has_Discriminants
 
 
@@ -11014,7 +10621,7 @@ definitions.  If the attribute is applied to a generic private type, it
 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{181}
+@anchor{gnat_rm/implementation_defined_attributes attribute-has-tagged-values}@anchor{184}
 @section Attribute Has_Tagged_Values
 
 
@@ -11031,7 +10638,7 @@ definitions. If the attribute is applied to a generic private type, it
 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{182}
+@anchor{gnat_rm/implementation_defined_attributes attribute-img}@anchor{185}
 @section Attribute Img
 
 
@@ -11061,7 +10668,7 @@ that returns the appropriate string when called. This means that
 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{183}
+@anchor{gnat_rm/implementation_defined_attributes attribute-initialized}@anchor{186}
 @section Attribute Initialized
 
 
@@ -11071,7 +10678,7 @@ For the syntax and semantics of this attribute, see the SPARK 2014 Reference
 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{184}
+@anchor{gnat_rm/implementation_defined_attributes attribute-integer-value}@anchor{187}
 @section Attribute Integer_Value
 
 
@@ -11099,7 +10706,7 @@ This attribute is primarily intended for use in implementation of the
 standard input-output functions for fixed-point values.
 
 @node Attribute Invalid_Value,Attribute Iterable,Attribute Integer_Value,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-invalid-value}@anchor{185}
+@anchor{gnat_rm/implementation_defined_attributes attribute-invalid-value}@anchor{188}
 @section Attribute Invalid_Value
 
 
@@ -11113,7 +10720,7 @@ including the ability to modify the value with the binder -Sxx flag and
 relevant environment variables at run time.
 
 @node Attribute Iterable,Attribute Large,Attribute Invalid_Value,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-iterable}@anchor{186}
+@anchor{gnat_rm/implementation_defined_attributes attribute-iterable}@anchor{189}
 @section Attribute Iterable
 
 
@@ -11122,7 +10729,7 @@ relevant environment variables at run time.
 Equivalent to Aspect Iterable.
 
 @node Attribute Large,Attribute Library_Level,Attribute Iterable,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-large}@anchor{187}
+@anchor{gnat_rm/implementation_defined_attributes attribute-large}@anchor{18a}
 @section Attribute Large
 
 
@@ -11135,7 +10742,7 @@ the Ada 83 reference manual for an exact description of the semantics of
 this attribute.
 
 @node Attribute Library_Level,Attribute Loop_Entry,Attribute Large,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-library-level}@anchor{188}
+@anchor{gnat_rm/implementation_defined_attributes attribute-library-level}@anchor{18b}
 @section Attribute Library_Level
 
 
@@ -11161,7 +10768,7 @@ end Gen;
 @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{189}
+@anchor{gnat_rm/implementation_defined_attributes attribute-loop-entry}@anchor{18c}
 @section Attribute Loop_Entry
 
 
@@ -11194,7 +10801,7 @@ entry. This copy is not performed if the loop is not entered, or if the
 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{18a}
+@anchor{gnat_rm/implementation_defined_attributes attribute-machine-size}@anchor{18d}
 @section Attribute Machine_Size
 
 
@@ -11204,7 +10811,7 @@ This attribute is identical to the @code{Object_Size} attribute.  It is
 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{18b}
+@anchor{gnat_rm/implementation_defined_attributes attribute-mantissa}@anchor{18e}
 @section Attribute Mantissa
 
 
@@ -11217,7 +10824,7 @@ the Ada 83 reference manual for an exact description of the semantics of
 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{18c}@anchor{gnat_rm/implementation_defined_attributes id2}@anchor{18d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-maximum-alignment}@anchor{18f}@anchor{gnat_rm/implementation_defined_attributes id2}@anchor{190}
 @section Attribute Maximum_Alignment
 
 
@@ -11233,7 +10840,7 @@ for an object, guaranteeing that it is properly aligned in all
 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{18e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-max-integer-size}@anchor{191}
 @section Attribute Max_Integer_Size
 
 
@@ -11244,7 +10851,7 @@ prefix) provides the size of the largest supported integer type for
 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{18f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-mechanism-code}@anchor{192}
 @section Attribute Mechanism_Code
 
 
@@ -11275,7 +10882,7 @@ by reference
 @end table
 
 @node Attribute Null_Parameter,Attribute Object_Size,Attribute Mechanism_Code,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-null-parameter}@anchor{190}
+@anchor{gnat_rm/implementation_defined_attributes attribute-null-parameter}@anchor{193}
 @section Attribute Null_Parameter
 
 
@@ -11300,7 +10907,7 @@ There is no way of indicating this without the @code{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{141}@anchor{gnat_rm/implementation_defined_attributes id3}@anchor{191}
+@anchor{gnat_rm/implementation_defined_attributes attribute-object-size}@anchor{144}@anchor{gnat_rm/implementation_defined_attributes id3}@anchor{194}
 @section Attribute Object_Size
 
 
@@ -11370,7 +10977,7 @@ Similar additional checks are performed in other contexts requiring
 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{192}
+@anchor{gnat_rm/implementation_defined_attributes attribute-old}@anchor{195}
 @section Attribute Old
 
 
@@ -11385,7 +10992,7 @@ definition are allowed under control of
 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{193}
+@anchor{gnat_rm/implementation_defined_attributes attribute-passed-by-reference}@anchor{196}
 @section Attribute Passed_By_Reference
 
 
@@ -11401,7 +11008,7 @@ passed by copy in calls.  For scalar types, the result is always @code{False}
 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{194}
+@anchor{gnat_rm/implementation_defined_attributes attribute-pool-address}@anchor{197}
 @section Attribute Pool_Address
 
 
@@ -11423,7 +11030,7 @@ For an object created by @code{new}, @code{Ptr.all'Pool_Address} is
 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{195}
+@anchor{gnat_rm/implementation_defined_attributes attribute-range-length}@anchor{198}
 @section Attribute Range_Length
 
 
@@ -11436,7 +11043,7 @@ applied to the index subtype of a one dimensional array always gives the
 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{196}
+@anchor{gnat_rm/implementation_defined_attributes attribute-restriction-set}@anchor{199}
 @section Attribute Restriction_Set
 
 
@@ -11506,7 +11113,7 @@ Restrictions pragma, they are not analyzed semantically,
 so they do not have a type.
 
 @node Attribute Result,Attribute Safe_Emax,Attribute Restriction_Set,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-result}@anchor{197}
+@anchor{gnat_rm/implementation_defined_attributes attribute-result}@anchor{19a}
 @section Attribute Result
 
 
@@ -11519,7 +11126,7 @@ For a further discussion of the use of this attribute and examples of its use,
 see the description of pragma Postcondition.
 
 @node Attribute Safe_Emax,Attribute Safe_Large,Attribute Result,Implementation Defined Attributes
-@anchor{gnat_rm/implementation_defined_attributes attribute-safe-emax}@anchor{198}
+@anchor{gnat_rm/implementation_defined_attributes attribute-safe-emax}@anchor{19b}
 @section Attribute Safe_Emax
 
 
@@ -11532,7 +11139,7 @@ the Ada 83 reference manual for an exact description of the semantics of
 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{199}
+@anchor{gnat_rm/implementation_defined_attributes attribute-safe-large}@anchor{19c}
 @section Attribute Safe_Large
 
 
@@ -11545,7 +11152,7 @@ the Ada 83 reference manual for an exact description of the semantics of
 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{19a}
+@anchor{gnat_rm/implementation_defined_attributes attribute-safe-small}@anchor{19d}
 @section Attribute Safe_Small
 
 
@@ -11558,7 +11165,7 @@ the Ada 83 reference manual for an exact description of the semantics of
 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{14f}@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{19b}
+@anchor{gnat_rm/implementation_defined_attributes attribute-scalar-storage-order}@anchor{152}@anchor{gnat_rm/implementation_defined_attributes id4}@anchor{19e}
 @section Attribute Scalar_Storage_Order
 
 
@@ -11721,7 +11328,7 @@ Note that debuggers may be unable to display the correct value of scalar
 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{e4}@anchor{gnat_rm/implementation_defined_attributes id5}@anchor{19c}
+@anchor{gnat_rm/implementation_defined_attributes attribute-simple-storage-pool}@anchor{e7}@anchor{gnat_rm/implementation_defined_attributes id5}@anchor{19f}
 @section Attribute Simple_Storage_Pool
 
 
@@ -11784,7 +11391,7 @@ as defined in section 13.11.2 of the Ada Reference Manual, except that the
 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{19d}
+@anchor{gnat_rm/implementation_defined_attributes attribute-small}@anchor{1a0}
 @section Attribute Small
 
 
@@ -11800,7 +11407,7 @@ the Ada 83 reference manual for an exact description of the semantics of
 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{19e}
+@anchor{gnat_rm/implementation_defined_attributes attribute-small-denominator}@anchor{1a1}
 @section Attribute Small_Denominator
 
 
@@ -11813,7 +11420,7 @@ denominator in the representation of @code{typ'Small} as a rational number
 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{19f}
+@anchor{gnat_rm/implementation_defined_attributes attribute-small-numerator}@anchor{1a2}
 @section Attribute Small_Numerator
 
 
@@ -11826,7 +11433,7 @@ numerator in the representation of @code{typ'Small} as a rational number
 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{1a0}
+@anchor{gnat_rm/implementation_defined_attributes attribute-storage-unit}@anchor{1a3}
 @section Attribute Storage_Unit
 
 
@@ -11836,7 +11443,7 @@ with coprime factors (i.e. as an irreducible fraction).
 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{1a1}
+@anchor{gnat_rm/implementation_defined_attributes attribute-stub-type}@anchor{1a4}
 @section Attribute Stub_Type
 
 
@@ -11860,7 +11467,7 @@ unit @code{System.Partition_Interface}. Use of this attribute will create
 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{1a2}
+@anchor{gnat_rm/implementation_defined_attributes attribute-system-allocator-alignment}@anchor{1a5}
 @section Attribute System_Allocator_Alignment
 
 
@@ -11877,7 +11484,7 @@ with alignment too large or to enable a realignment circuitry if the
 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{1a3}
+@anchor{gnat_rm/implementation_defined_attributes attribute-target-name}@anchor{1a6}
 @section Attribute Target_Name
 
 
@@ -11890,7 +11497,7 @@ standard gcc target name without the terminating slash (for
 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{1a4}
+@anchor{gnat_rm/implementation_defined_attributes attribute-to-address}@anchor{1a7}
 @section Attribute To_Address
 
 
@@ -11913,7 +11520,7 @@ modular manner (e.g., -1 means the same as 16#FFFF_FFFF# on
 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{1a5}
+@anchor{gnat_rm/implementation_defined_attributes attribute-to-any}@anchor{1a8}
 @section Attribute To_Any
 
 
@@ -11923,7 +11530,7 @@ This internal attribute is used for the generation of remote subprogram
 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{1a6}
+@anchor{gnat_rm/implementation_defined_attributes attribute-type-class}@anchor{1a9}
 @section Attribute Type_Class
 
 
@@ -11953,7 +11560,7 @@ applies to all concurrent types.  This attribute is designed to
 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{1a7}
+@anchor{gnat_rm/implementation_defined_attributes attribute-type-key}@anchor{1aa}
 @section Attribute Type_Key
 
 
@@ -11965,7 +11572,7 @@ about the type or subtype. This provides improved compatibility with
 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{1a8}
+@anchor{gnat_rm/implementation_defined_attributes attribute-typecode}@anchor{1ab}
 @section Attribute TypeCode
 
 
@@ -11975,7 +11582,7 @@ This internal attribute is used for the generation of remote subprogram
 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{1a9}
+@anchor{gnat_rm/implementation_defined_attributes attribute-unconstrained-array}@anchor{1ac}
 @section Attribute Unconstrained_Array
 
 
@@ -11989,7 +11596,7 @@ still static, and yields the result of applying this test to the
 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{1aa}
+@anchor{gnat_rm/implementation_defined_attributes attribute-universal-literal-string}@anchor{1ad}
 @section Attribute Universal_Literal_String
 
 
@@ -12017,7 +11624,7 @@ end;
 @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{1ab}
+@anchor{gnat_rm/implementation_defined_attributes attribute-unrestricted-access}@anchor{1ae}
 @section Attribute Unrestricted_Access
 
 
@@ -12204,7 +11811,7 @@ In general this is a risky approach. It may appear to “work” but such uses o
 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{1ac}
+@anchor{gnat_rm/implementation_defined_attributes attribute-update}@anchor{1af}
 @section Attribute Update
 
 
@@ -12285,7 +11892,7 @@ A := A'Update ((1, 2) => 20, (3, 4) => 30);
 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{1ad}
+@anchor{gnat_rm/implementation_defined_attributes attribute-valid-value}@anchor{1b0}
 @section Attribute Valid_Value
 
 
@@ -12297,7 +11904,7 @@ a String, and returns Boolean. @code{T'Valid_Value (S)} 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{1ae}
+@anchor{gnat_rm/implementation_defined_attributes attribute-valid-scalars}@anchor{1b1}
 @section Attribute Valid_Scalars
 
 
@@ -12331,7 +11938,7 @@ write a function with a single use of the attribute, and then call that
 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{1af}
+@anchor{gnat_rm/implementation_defined_attributes attribute-vads-size}@anchor{1b2}
 @section Attribute VADS_Size
 
 
@@ -12351,7 +11958,7 @@ gives the result that would be obtained by applying the attribute to
 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{15d}@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1b0}
+@anchor{gnat_rm/implementation_defined_attributes attribute-value-size}@anchor{160}@anchor{gnat_rm/implementation_defined_attributes id6}@anchor{1b3}
 @section Attribute Value_Size
 
 
@@ -12365,7 +11972,7 @@ a value of the given subtype.  It is the same as @code{type'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{1b1}
+@anchor{gnat_rm/implementation_defined_attributes attribute-wchar-t-size}@anchor{1b4}
 @section Attribute Wchar_T_Size
 
 
@@ -12377,7 +11984,7 @@ primarily for constructing the definition of this type in
 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{1b2}
+@anchor{gnat_rm/implementation_defined_attributes attribute-word-size}@anchor{1b5}
 @section Attribute Word_Size
 
 
@@ -12388,7 +11995,7 @@ prefix) provides the value @code{System.Word_Size}. The result is
 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{1b3}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1b4}@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{1b6}@anchor{gnat_rm/standard_and_implementation_defined_restrictions id1}@anchor{1b7}@anchor{gnat_rm/standard_and_implementation_defined_restrictions standard-and-implementation-defined-restrictions}@anchor{9}
 @chapter Standard and Implementation Defined Restrictions
 
 
@@ -12417,7 +12024,7 @@ language defined or GNAT-specific, are listed in the following.
 @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{1b5}@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1b6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions id2}@anchor{1b8}@anchor{gnat_rm/standard_and_implementation_defined_restrictions partition-wide-restrictions}@anchor{1b9}
 @section Partition-Wide Restrictions
 
 
@@ -12508,7 +12115,7 @@ then all compilation units in the partition must obey the restriction).
 @end menu
 
 @node Immediate_Reclamation,Max_Asynchronous_Select_Nesting,,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions immediate-reclamation}@anchor{1b7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions immediate-reclamation}@anchor{1ba}
 @subsection Immediate_Reclamation
 
 
@@ -12520,7 +12127,7 @@ deallocation, any storage reserved at run time for an object is
 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{1b8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-asynchronous-select-nesting}@anchor{1bb}
 @subsection Max_Asynchronous_Select_Nesting
 
 
@@ -12532,7 +12139,7 @@ detected at compile time. Violations of this restriction with values
 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{1b9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-entry-queue-length}@anchor{1bc}
 @subsection Max_Entry_Queue_Length
 
 
@@ -12553,7 +12160,7 @@ compatibility purposes (and a warning will be generated for its use if
 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{1ba}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-protected-entries}@anchor{1bd}
 @subsection Max_Protected_Entries
 
 
@@ -12564,7 +12171,7 @@ bounds of every entry family of a protected unit shall be static, or shall be
 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{1bb}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-select-alternatives}@anchor{1be}
 @subsection Max_Select_Alternatives
 
 
@@ -12573,7 +12180,7 @@ defined by a discriminant of a subtype whose corresponding bound is static.
 [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{1bc}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-storage-at-blocking}@anchor{1bf}
 @subsection Max_Storage_At_Blocking
 
 
@@ -12584,7 +12191,7 @@ Storage_Size that can be retained by a blocked task. A violation of this
 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{1bd}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-task-entries}@anchor{1c0}
 @subsection Max_Task_Entries
 
 
@@ -12597,7 +12204,7 @@ defined by a discriminant of a subtype whose
 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{1be}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions max-tasks}@anchor{1c1}
 @subsection Max_Tasks
 
 
@@ -12610,7 +12217,7 @@ time. Violations of this restriction with values other than zero cause
 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{1bf}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-abort-statements}@anchor{1c2}
 @subsection No_Abort_Statements
 
 
@@ -12620,7 +12227,7 @@ Storage_Error to be raised.
 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{1c0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-parameter-allocators}@anchor{1c3}
 @subsection No_Access_Parameter_Allocators
 
 
@@ -12631,7 +12238,7 @@ occurrences of an allocator as the actual parameter to an access
 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{1c1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-access-subprograms}@anchor{1c4}
 @subsection No_Access_Subprograms
 
 
@@ -12641,7 +12248,7 @@ parameter.
 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{1c2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-allocators}@anchor{1c5}
 @subsection No_Allocators
 
 
@@ -12651,7 +12258,7 @@ declarations of access-to-subprogram types.
 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{1c3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-anonymous-allocators}@anchor{1c6}
 @subsection No_Anonymous_Allocators
 
 
@@ -12661,7 +12268,7 @@ occurrences of an allocator.
 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{1c4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-asynchronous-control}@anchor{1c7}
 @subsection No_Asynchronous_Control
 
 
@@ -12671,7 +12278,7 @@ occurrences of an allocator of anonymous access type.
 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{1c5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-calendar}@anchor{1c8}
 @subsection No_Calendar
 
 
@@ -12681,7 +12288,7 @@ dependences on the predefined package Asynchronous_Task_Control.
 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{1c6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-coextensions}@anchor{1c9}
 @subsection No_Coextensions
 
 
@@ -12691,7 +12298,7 @@ dependences on package Calendar.
 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{1c7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-default-initialization}@anchor{1ca}
 @subsection No_Default_Initialization
 
 
@@ -12708,7 +12315,7 @@ is to prohibit all cases of variables declared without a specific
 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{1c8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-delay}@anchor{1cb}
 @subsection No_Delay
 
 
@@ -12718,7 +12325,7 @@ initializer (including the case of OUT scalar parameters).
 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{1c9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dependence}@anchor{1cc}
 @subsection No_Dependence
 
 
@@ -12761,7 +12368,7 @@ to support specific constructs of the language. Here are some examples:
 @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{1ca}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-direct-boolean-operators}@anchor{1cd}
 @subsection No_Direct_Boolean_Operators
 
 
@@ -12774,7 +12381,7 @@ protocol requires the use of short-circuit (and then, or else) forms for all
 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{1cb}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatch}@anchor{1ce}
 @subsection No_Dispatch
 
 
@@ -12784,7 +12391,7 @@ composite boolean operations.
 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{1cc}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dispatching-calls}@anchor{1cf}
 @subsection No_Dispatching_Calls
 
 
@@ -12845,7 +12452,7 @@ end Example;
 @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{1cd}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-attachment}@anchor{1d0}
 @subsection No_Dynamic_Attachment
 
 
@@ -12864,7 +12471,7 @@ compatibility purposes (and a warning will be generated for its use if
 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{1ce}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-priorities}@anchor{1d1}
 @subsection No_Dynamic_Priorities
 
 
@@ -12873,7 +12480,7 @@ warnings on obsolescent features are activated).
 [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{1cf}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-calls-in-elaboration-code}@anchor{1d2}
 @subsection No_Entry_Calls_In_Elaboration_Code
 
 
@@ -12885,7 +12492,7 @@ restriction, the compiler can assume that no code past an accept statement
 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{1d0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-enumeration-maps}@anchor{1d3}
 @subsection No_Enumeration_Maps
 
 
@@ -12896,7 +12503,7 @@ enumeration maps are used (that is Image and Value attributes applied
 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{1d1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-handlers}@anchor{1d4}
 @subsection No_Exception_Handlers
 
 
@@ -12921,7 +12528,7 @@ statement generated by the compiler). The Line parameter when nonzero
 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{1d2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-propagation}@anchor{1d5}
 @subsection No_Exception_Propagation
 
 
@@ -12938,7 +12545,7 @@ the package GNAT.Current_Exception is not permitted, and reraise
 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{1d3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exception-registration}@anchor{1d6}
 @subsection No_Exception_Registration
 
 
@@ -12952,7 +12559,7 @@ code is simplified by omitting the otherwise-required global 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{1d4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-exceptions}@anchor{1d7}
 @subsection No_Exceptions
 
 
@@ -12963,7 +12570,7 @@ raise statements and no exception handlers and also suppresses the
 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{1d5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-finalization}@anchor{1d8}
 @subsection No_Finalization
 
 
@@ -13004,7 +12611,7 @@ object or a nested component, either declared on the stack or on the heap. The
 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{1d6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-fixed-point}@anchor{1d9}
 @subsection No_Fixed_Point
 
 
@@ -13014,7 +12621,7 @@ deallocation of a controlled object no longer finalizes its contents.
 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{1d7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-floating-point}@anchor{1da}
 @subsection No_Floating_Point
 
 
@@ -13024,7 +12631,7 @@ occurrences of fixed point types and operations.
 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{1d8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-conditionals}@anchor{1db}
 @subsection No_Implicit_Conditionals
 
 
@@ -13040,7 +12647,7 @@ normal manner. Constructs generating implicit conditionals include comparisons
 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{1d9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-dynamic-code}@anchor{1dc}
 @subsection No_Implicit_Dynamic_Code
 
 
@@ -13070,7 +12677,7 @@ foreign-language convention; primitive operations of nested tagged
 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{1da}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-heap-allocations}@anchor{1dd}
 @subsection No_Implicit_Heap_Allocations
 
 
@@ -13079,7 +12686,7 @@ types.
 [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{1db}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-protected-object-allocations}@anchor{1de}
 @subsection No_Implicit_Protected_Object_Allocations
 
 
@@ -13089,7 +12696,7 @@ types.
 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{1dc}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-task-allocations}@anchor{1df}
 @subsection No_Implicit_Task_Allocations
 
 
@@ -13098,7 +12705,7 @@ protected object.
 [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{1dd}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-initialize-scalars}@anchor{1e0}
 @subsection No_Initialize_Scalars
 
 
@@ -13110,7 +12717,7 @@ code, and in particular eliminates dummy null initialization routines that
 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{1de}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-io}@anchor{1e1}
 @subsection No_IO
 
 
@@ -13121,7 +12728,7 @@ dependences on any of the library units Sequential_IO, Direct_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{1df}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-allocators}@anchor{1e2}
 @subsection No_Local_Allocators
 
 
@@ -13132,7 +12739,7 @@ occurrences of an allocator in subprograms, generic subprograms, tasks,
 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{1e0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-protected-objects}@anchor{1e3}
 @subsection No_Local_Protected_Objects
 
 
@@ -13142,7 +12749,7 @@ and entry bodies.
 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{1e1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-tagged-types}@anchor{1e4}
 @subsection No_Local_Tagged_Types
 
 
@@ -13152,7 +12759,7 @@ only declared at the library level.
 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{1e2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-local-timing-events}@anchor{1e5}
 @subsection No_Local_Timing_Events
 
 
@@ -13162,7 +12769,7 @@ declared at the library level.
 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{1e3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-long-long-integers}@anchor{1e6}
 @subsection No_Long_Long_Integers
 
 
@@ -13174,7 +12781,7 @@ implicit base type is Long_Long_Integer, and modular types whose size exceeds
 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{1e4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-multiple-elaboration}@anchor{1e7}
 @subsection No_Multiple_Elaboration
 
 
@@ -13190,7 +12797,7 @@ possible, including non-Ada main programs and Stand Alone libraries, are not
 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{1e5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-nested-finalization}@anchor{1e8}
 @subsection No_Nested_Finalization
 
 
@@ -13199,7 +12806,7 @@ permitted and will be diagnosed by the binder.
 [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{1e6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-type-allocators}@anchor{1e9}
 @subsection No_Protected_Type_Allocators
 
 
@@ -13209,7 +12816,7 @@ permitted and will be diagnosed by the binder.
 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{1e7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-protected-types}@anchor{1ea}
 @subsection No_Protected_Types
 
 
@@ -13219,7 +12826,7 @@ expressions that attempt to allocate protected objects.
 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{1e8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-recursion}@anchor{1eb}
 @subsection No_Recursion
 
 
@@ -13229,7 +12836,7 @@ declarations of protected types or protected objects.
 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{1e9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-reentrancy}@anchor{1ec}
 @subsection No_Reentrancy
 
 
@@ -13239,7 +12846,7 @@ part of its execution.
 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{1ea}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-relative-delay}@anchor{1ed}
 @subsection No_Relative_Delay
 
 
@@ -13250,7 +12857,7 @@ relative statements and prevents expressions such as @code{delay 1.23;} from
 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{1eb}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-requeue-statements}@anchor{1ee}
 @subsection No_Requeue_Statements
 
 
@@ -13268,7 +12875,7 @@ compatibility purposes (and a warning will be generated for its use if
 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{1ec}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-secondary-stack}@anchor{1ef}
 @subsection No_Secondary_Stack
 
 
@@ -13281,7 +12888,7 @@ stack is used to implement functions returning unconstrained objects
 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{1ed}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-select-statements}@anchor{1f0}
 @subsection No_Select_Statements
 
 
@@ -13291,7 +12898,7 @@ secondary stacks for tasks (excluding the environment task) at run time.
 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{1ee}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specific-termination-handlers}@anchor{1f1}
 @subsection No_Specific_Termination_Handlers
 
 
@@ -13301,7 +12908,7 @@ kind are permitted, that is the keyword @code{select} may not appear.
 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{1ef}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-specification-of-aspect}@anchor{1f2}
 @subsection No_Specification_of_Aspect
 
 
@@ -13312,7 +12919,7 @@ specification, attribute definition clause, or pragma is given for a
 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{1f0}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-allocators-after-elaboration}@anchor{1f3}
 @subsection No_Standard_Allocators_After_Elaboration
 
 
@@ -13324,7 +12931,7 @@ library items of the partition has completed. Otherwise, Storage_Error
 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{1f1}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-standard-storage-pools}@anchor{1f4}
 @subsection No_Standard_Storage_Pools
 
 
@@ -13336,7 +12943,7 @@ have an explicit Storage_Pool attribute defined specifying a
 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{1f2}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-stream-optimizations}@anchor{1f5}
 @subsection No_Stream_Optimizations
 
 
@@ -13349,7 +12956,7 @@ due to their superior performance. When this restriction is in effect, the
 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{1f3}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-streams}@anchor{1f6}
 @subsection No_Streams
 
 
@@ -13370,7 +12977,7 @@ unit declaring a tagged type should be compiled with the restriction,
 though this is not required.
 
 @node No_Tagged_Type_Registration,No_Task_Allocators,No_Streams,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tagged-type-registration}@anchor{1f4}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tagged-type-registration}@anchor{1f7}
 @subsection No_Tagged_Type_Registration
 
 
@@ -13385,7 +12992,7 @@ are declared. This restriction may be necessary in order to also apply
 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{1f5}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-allocators}@anchor{1f8}
 @subsection No_Task_Allocators
 
 
@@ -13395,7 +13002,7 @@ the No_Elaboration_Code restriction.
 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{1f6}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-at-interrupt-priority}@anchor{1f9}
 @subsection No_Task_At_Interrupt_Priority
 
 
@@ -13407,7 +13014,7 @@ a consequence, the tasks are always created with a priority below
 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{1f7}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-attributes-package}@anchor{1fa}
 @subsection No_Task_Attributes_Package
 
 
@@ -13424,7 +13031,7 @@ compatibility purposes (and a warning will be generated for its use if
 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{1f8}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-hierarchy}@anchor{1fb}
 @subsection No_Task_Hierarchy
 
 
@@ -13434,7 +13041,7 @@ warnings on obsolescent features are activated).
 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{1f9}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-task-termination}@anchor{1fc}
 @subsection No_Task_Termination
 
 
@@ -13443,7 +13050,7 @@ directly on the environment task of the partition.
 [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{1fa}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-tasking}@anchor{1fd}
 @subsection No_Tasking
 
 
@@ -13456,7 +13063,7 @@ and cause an error message to be output either by the compiler or
 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{1fb}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-terminate-alternatives}@anchor{1fe}
 @subsection No_Terminate_Alternatives
 
 
@@ -13465,7 +13072,7 @@ binder.
 [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{1fc}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-access}@anchor{1ff}
 @subsection No_Unchecked_Access
 
 
@@ -13475,7 +13082,7 @@ binder.
 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{1fd}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-conversion}@anchor{200}
 @subsection No_Unchecked_Conversion
 
 
@@ -13485,7 +13092,7 @@ occurrences of the Unchecked_Access attribute.
 dependences on the predefined generic function Unchecked_Conversion.
 
 @node No_Unchecked_Deallocation,No_Use_Of_Entity,No_Unchecked_Conversion,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-deallocation}@anchor{1fe}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-unchecked-deallocation}@anchor{201}
 @subsection No_Unchecked_Deallocation
 
 
@@ -13495,7 +13102,7 @@ dependences on the predefined generic function Unchecked_Conversion.
 dependences on the predefined generic procedure Unchecked_Deallocation.
 
 @node No_Use_Of_Entity,Pure_Barriers,No_Unchecked_Deallocation,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-entity}@anchor{1ff}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-use-of-entity}@anchor{202}
 @subsection No_Use_Of_Entity
 
 
@@ -13515,7 +13122,7 @@ No_Use_Of_Entity => Ada.Text_IO.Put_Line
 @end example
 
 @node Pure_Barriers,Simple_Barriers,No_Use_Of_Entity,Partition-Wide Restrictions
-@anchor{gnat_rm/standard_and_implementation_defined_restrictions pure-barriers}@anchor{200}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions pure-barriers}@anchor{203}
 @subsection Pure_Barriers
 
 
@@ -13566,7 +13173,7 @@ but still ensures absence of side effects, exceptions, and recursion
 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{201}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions simple-barriers}@anchor{204}
 @subsection Simple_Barriers
 
 
@@ -13585,7 +13192,7 @@ compatibility purposes (and a warning will be generated for its use if
 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{202}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-priorities}@anchor{205}
 @subsection Static_Priorities
 
 
@@ -13596,7 +13203,7 @@ are static, and that there are no dependences on the package
 @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{203}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-storage-size}@anchor{206}
 @subsection Static_Storage_Size
 
 
@@ -13606,7 +13213,7 @@ are static, and that there are no dependences on the package
 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{204}@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{205}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions id3}@anchor{207}@anchor{gnat_rm/standard_and_implementation_defined_restrictions program-unit-level-restrictions}@anchor{208}
 @section Program Unit Level Restrictions
 
 
@@ -13637,7 +13244,7 @@ other compilation units in the partition.
 @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{206}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-elaboration-code}@anchor{209}
 @subsection No_Elaboration_Code
 
 
@@ -13693,7 +13300,7 @@ associated with the unit. This counter is typically used to check for access
 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{207}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-accessibility-checks}@anchor{20a}
 @subsection No_Dynamic_Accessibility_Checks
 
 
@@ -13742,7 +13349,7 @@ In all other cases, the level of T is as defined by the existing rules of Ada.
 @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{208}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-dynamic-sized-objects}@anchor{20b}
 @subsection No_Dynamic_Sized_Objects
 
 
@@ -13760,7 +13367,7 @@ access discriminants. It is often a good idea to combine this restriction
 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{209}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-entry-queue}@anchor{20c}
 @subsection No_Entry_Queue
 
 
@@ -13773,7 +13380,7 @@ checked at compile time.  A program execution is erroneous if an attempt
 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{20a}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-aspect-specifications}@anchor{20d}
 @subsection No_Implementation_Aspect_Specifications
 
 
@@ -13784,7 +13391,7 @@ GNAT-defined aspects are present.  With this restriction, the only
 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{20b}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-attributes}@anchor{20e}
 @subsection No_Implementation_Attributes
 
 
@@ -13796,7 +13403,7 @@ attributes that can be used are those defined in the Ada Reference
 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{20c}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-identifiers}@anchor{20f}
 @subsection No_Implementation_Identifiers
 
 
@@ -13807,7 +13414,7 @@ implementation-defined identifiers (marked with pragma Implementation_Defined)
 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{20d}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-pragmas}@anchor{210}
 @subsection No_Implementation_Pragmas
 
 
@@ -13818,7 +13425,7 @@ GNAT-defined pragmas are present.  With this restriction, the only
 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{20e}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-restrictions}@anchor{211}
 @subsection No_Implementation_Restrictions
 
 
@@ -13830,7 +13437,7 @@ are present.  With this restriction, the only other restriction identifiers
 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{20f}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implementation-units}@anchor{212}
 @subsection No_Implementation_Units
 
 
@@ -13841,7 +13448,7 @@ mention in the context clause of any implementation-defined descendants
 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{210}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-aliasing}@anchor{213}
 @subsection No_Implicit_Aliasing
 
 
@@ -13856,7 +13463,7 @@ to be aliased, and in such cases, it can always be replaced by
 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{211}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-implicit-loops}@anchor{214}
 @subsection No_Implicit_Loops
 
 
@@ -13873,7 +13480,7 @@ arrays larger than about 5000 scalar components. Note that if this restriction
 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{212}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-obsolescent-features}@anchor{215}
 @subsection No_Obsolescent_Features
 
 
@@ -13883,7 +13490,7 @@ is set in the spec of a package, it will not apply to its body.
 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{213}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions no-wide-characters}@anchor{216}
 @subsection No_Wide_Characters
 
 
@@ -13897,7 +13504,7 @@ appear in the program (that is literals representing characters not in
 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{214}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions static-dispatch-tables}@anchor{217}
 @subsection Static_Dispatch_Tables
 
 
@@ -13907,7 +13514,7 @@ type @code{Character}).
 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{215}
+@anchor{gnat_rm/standard_and_implementation_defined_restrictions spark-05}@anchor{218}
 @subsection SPARK_05
 
 
@@ -13930,7 +13537,7 @@ gnatprove -P project.gpr --mode=check_all
 @end example
 
 @node Implementation Advice,Implementation Defined Characteristics,Standard and Implementation Defined Restrictions,Top
-@anchor{gnat_rm/implementation_advice doc}@anchor{216}@anchor{gnat_rm/implementation_advice id1}@anchor{217}@anchor{gnat_rm/implementation_advice implementation-advice}@anchor{a}
+@anchor{gnat_rm/implementation_advice doc}@anchor{219}@anchor{gnat_rm/implementation_advice id1}@anchor{21a}@anchor{gnat_rm/implementation_advice implementation-advice}@anchor{a}
 @chapter Implementation Advice
 
 
@@ -14028,7 +13635,7 @@ case the text describes what GNAT does and why.
 @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{218}
+@anchor{gnat_rm/implementation_advice rm-1-1-3-20-error-detection}@anchor{21b}
 @section RM 1.1.3(20): Error Detection
 
 
@@ -14045,7 +13652,7 @@ or diagnosed at compile time.
 @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{219}
+@anchor{gnat_rm/implementation_advice rm-1-1-3-31-child-units}@anchor{21c}
 @section RM 1.1.3(31): Child Units
 
 
@@ -14061,7 +13668,7 @@ Followed.
 @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{21a}
+@anchor{gnat_rm/implementation_advice rm-1-1-5-12-bounded-errors}@anchor{21d}
 @section RM 1.1.5(12): Bounded Errors
 
 
@@ -14078,7 +13685,7 @@ runtime.
 @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{21b}@anchor{gnat_rm/implementation_advice rm-2-8-16-pragmas}@anchor{21c}
+@anchor{gnat_rm/implementation_advice id2}@anchor{21e}@anchor{gnat_rm/implementation_advice rm-2-8-16-pragmas}@anchor{21f}
 @section RM 2.8(16): Pragmas
 
 
@@ -14191,7 +13798,7 @@ that this advice not be followed.  For details see
 @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{21d}
+@anchor{gnat_rm/implementation_advice rm-2-8-17-19-pragmas}@anchor{220}
 @section RM 2.8(17-19): Pragmas
 
 
@@ -14212,14 +13819,14 @@ replacing @code{library_items}.”
 @end itemize
 @end quotation
 
-See @ref{21c,,RM 2.8(16); Pragmas}.
+See @ref{21f,,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{21e}
+@anchor{gnat_rm/implementation_advice rm-3-5-2-5-alternative-character-sets}@anchor{221}
 @section RM 3.5.2(5): Alternative Character Sets
 
 
@@ -14247,7 +13854,7 @@ there is no such restriction.
 @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{21f}
+@anchor{gnat_rm/implementation_advice rm-3-5-4-28-integer-types}@anchor{222}
 @section RM 3.5.4(28): Integer Types
 
 
@@ -14266,7 +13873,7 @@ are supported for convenient interface to C, and so that all hardware
 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{220}
+@anchor{gnat_rm/implementation_advice rm-3-5-4-29-integer-types}@anchor{223}
 @section RM 3.5.4(29): Integer Types
 
 
@@ -14282,7 +13889,7 @@ Followed.
 @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{221}
+@anchor{gnat_rm/implementation_advice rm-3-5-5-8-enumeration-values}@anchor{224}
 @section RM 3.5.5(8): Enumeration Values
 
 
@@ -14302,7 +13909,7 @@ Followed.
 @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{222}
+@anchor{gnat_rm/implementation_advice rm-3-5-7-17-float-types}@anchor{225}
 @section RM 3.5.7(17): Float Types
 
 
@@ -14332,7 +13939,7 @@ is a software rather than a hardware format.
 @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{223}
+@anchor{gnat_rm/implementation_advice rm-3-6-2-11-multidimensional-arrays}@anchor{226}
 @section RM 3.6.2(11): Multidimensional Arrays
 
 
@@ -14350,7 +13957,7 @@ Followed.
 @geindex Duration'Small
 
 @node RM 9 6 30-31 Duration’Small,RM 10 2 1 12 Consistent Representation,RM 3 6 2 11 Multidimensional Arrays,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-9-6-30-31-duration-small}@anchor{224}
+@anchor{gnat_rm/implementation_advice rm-9-6-30-31-duration-small}@anchor{227}
 @section RM 9.6(30-31): Duration’Small
 
 
@@ -14371,7 +13978,7 @@ it need not be the same time base as used for @code{Calendar.Clock}.”
 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{225}
+@anchor{gnat_rm/implementation_advice rm-10-2-1-12-consistent-representation}@anchor{228}
 @section RM 10.2.1(12): Consistent Representation
 
 
@@ -14393,7 +14000,7 @@ advice without severely impacting efficiency of execution.
 @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{226}
+@anchor{gnat_rm/implementation_advice rm-11-4-1-19-exception-information}@anchor{229}
 @section RM 11.4.1(19): Exception Information
 
 
@@ -14424,7 +14031,7 @@ Pragma @code{Discard_Names}.
 @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{227}
+@anchor{gnat_rm/implementation_advice rm-11-5-28-suppression-of-checks}@anchor{22a}
 @section RM 11.5(28): Suppression of Checks
 
 
@@ -14439,7 +14046,7 @@ Followed.
 @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{228}
+@anchor{gnat_rm/implementation_advice rm-13-1-21-24-representation-clauses}@anchor{22b}
 @section RM 13.1 (21-24): Representation Clauses
 
 
@@ -14488,7 +14095,7 @@ Followed.
 @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{229}
+@anchor{gnat_rm/implementation_advice rm-13-2-6-8-packed-types}@anchor{22c}
 @section RM 13.2(6-8): Packed Types
 
 
@@ -14519,7 +14126,7 @@ subcomponent of the packed type.
 @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{22a}
+@anchor{gnat_rm/implementation_advice rm-13-3-14-19-address-clauses}@anchor{22d}
 @section RM 13.3(14-19): Address Clauses
 
 
@@ -14572,7 +14179,7 @@ Followed.
 @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{22b}
+@anchor{gnat_rm/implementation_advice rm-13-3-29-35-alignment-clauses}@anchor{22e}
 @section RM 13.3(29-35): Alignment Clauses
 
 
@@ -14629,7 +14236,7 @@ Followed.
 @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{22c}
+@anchor{gnat_rm/implementation_advice rm-13-3-42-43-size-clauses}@anchor{22f}
 @section RM 13.3(42-43): Size Clauses
 
 
@@ -14647,7 +14254,7 @@ object’s @code{Alignment} (if the @code{Alignment} is nonzero).”
 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{22d}
+@anchor{gnat_rm/implementation_advice rm-13-3-50-56-size-clauses}@anchor{230}
 @section RM 13.3(50-56): Size Clauses
 
 
@@ -14698,7 +14305,7 @@ Followed.
 @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{22e}
+@anchor{gnat_rm/implementation_advice rm-13-3-71-73-component-size-clauses}@anchor{231}
 @section RM 13.3(71-73): Component Size Clauses
 
 
@@ -14732,7 +14339,7 @@ Followed.
 @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{22f}
+@anchor{gnat_rm/implementation_advice rm-13-4-9-10-enumeration-representation-clauses}@anchor{232}
 @section RM 13.4(9-10): Enumeration Representation Clauses
 
 
@@ -14754,7 +14361,7 @@ Followed.
 @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{230}
+@anchor{gnat_rm/implementation_advice rm-13-5-1-17-22-record-representation-clauses}@anchor{233}
 @section RM 13.5.1(17-22): Record Representation Clauses
 
 
@@ -14814,7 +14421,7 @@ and all mentioned features are implemented.
 @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{231}
+@anchor{gnat_rm/implementation_advice rm-13-5-2-5-storage-place-attributes}@anchor{234}
 @section RM 13.5.2(5): Storage Place Attributes
 
 
@@ -14834,7 +14441,7 @@ Followed.  There are no such components in GNAT.
 @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{232}
+@anchor{gnat_rm/implementation_advice rm-13-5-3-7-8-bit-ordering}@anchor{235}
 @section RM 13.5.3(7-8): Bit Ordering
 
 
@@ -14854,7 +14461,7 @@ Thus non-default bit ordering is not supported.
 @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{233}
+@anchor{gnat_rm/implementation_advice rm-13-7-37-address-as-private}@anchor{236}
 @section RM 13.7(37): Address as Private
 
 
@@ -14872,7 +14479,7 @@ Followed.
 @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{234}
+@anchor{gnat_rm/implementation_advice rm-13-7-1-16-address-operations}@anchor{237}
 @section RM 13.7.1(16): Address Operations
 
 
@@ -14890,7 +14497,7 @@ operation raises @code{Program_Error}, since all operations make sense.
 @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{235}
+@anchor{gnat_rm/implementation_advice rm-13-9-14-17-unchecked-conversion}@anchor{238}
 @section RM 13.9(14-17): Unchecked Conversion
 
 
@@ -14934,7 +14541,7 @@ Followed.
 @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{236}
+@anchor{gnat_rm/implementation_advice rm-13-11-23-25-implicit-heap-usage}@anchor{239}
 @section RM 13.11(23-25): Implicit Heap Usage
 
 
@@ -14985,7 +14592,7 @@ Followed.
 @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{237}
+@anchor{gnat_rm/implementation_advice rm-13-11-2-17-unchecked-deallocation}@anchor{23a}
 @section RM 13.11.2(17): Unchecked Deallocation
 
 
@@ -15000,7 +14607,7 @@ Followed.
 @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{238}
+@anchor{gnat_rm/implementation_advice rm-13-13-2-1-6-stream-oriented-attributes}@anchor{23b}
 @section RM 13.13.2(1.6): Stream Oriented Attributes
 
 
@@ -15031,7 +14638,7 @@ scalar types. This XDR alternative can be enabled via the binder switch -xdr.
 @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{239}
+@anchor{gnat_rm/implementation_advice rm-a-1-52-names-of-predefined-numeric-types}@anchor{23c}
 @section RM A.1(52): Names of Predefined Numeric Types
 
 
@@ -15049,7 +14656,7 @@ Followed.
 @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{23a}
+@anchor{gnat_rm/implementation_advice rm-a-3-2-49-ada-characters-handling}@anchor{23d}
 @section RM A.3.2(49): @code{Ada.Characters.Handling}
 
 
@@ -15066,7 +14673,7 @@ Followed.  GNAT provides no such localized definitions.
 @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{23b}
+@anchor{gnat_rm/implementation_advice rm-a-4-4-106-bounded-length-string-handling}@anchor{23e}
 @section RM A.4.4(106): Bounded-Length String Handling
 
 
@@ -15081,7 +14688,7 @@ Followed.  No implicit pointers or dynamic allocation are used.
 @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{23c}
+@anchor{gnat_rm/implementation_advice rm-a-5-2-46-47-random-number-generation}@anchor{23f}
 @section RM A.5.2(46-47): Random Number Generation
 
 
@@ -15110,7 +14717,7 @@ condition here to hold true.
 @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{23d}
+@anchor{gnat_rm/implementation_advice rm-a-10-7-23-get-immediate}@anchor{240}
 @section RM A.10.7(23): @code{Get_Immediate}
 
 
@@ -15134,7 +14741,7 @@ this functionality.
 @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{23e}
+@anchor{gnat_rm/implementation_advice rm-a-18-containers}@anchor{241}
 @section RM A.18: @code{Containers}
 
 
@@ -15155,7 +14762,7 @@ follow the implementation advice.
 @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{23f}
+@anchor{gnat_rm/implementation_advice rm-b-1-39-41-pragma-export}@anchor{242}
 @section RM B.1(39-41): Pragma @code{Export}
 
 
@@ -15203,7 +14810,7 @@ Followed.
 @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{240}
+@anchor{gnat_rm/implementation_advice rm-b-2-12-13-package-interfaces}@anchor{243}
 @section RM B.2(12-13): Package @code{Interfaces}
 
 
@@ -15233,7 +14840,7 @@ Followed.  GNAT provides all the packages described in this section.
 @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{241}
+@anchor{gnat_rm/implementation_advice rm-b-3-63-71-interfacing-with-c}@anchor{244}
 @section RM B.3(63-71): Interfacing with C
 
 
@@ -15321,7 +14928,7 @@ Followed.
 @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{242}
+@anchor{gnat_rm/implementation_advice rm-b-4-95-98-interfacing-with-cobol}@anchor{245}
 @section RM B.4(95-98): Interfacing with COBOL
 
 
@@ -15362,7 +14969,7 @@ Followed.
 @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{243}
+@anchor{gnat_rm/implementation_advice rm-b-5-22-26-interfacing-with-fortran}@anchor{246}
 @section RM B.5(22-26): Interfacing with Fortran
 
 
@@ -15413,7 +15020,7 @@ Followed.
 @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{244}
+@anchor{gnat_rm/implementation_advice rm-c-1-3-5-access-to-machine-operations}@anchor{247}
 @section RM C.1(3-5): Access to Machine Operations
 
 
@@ -15448,7 +15055,7 @@ object that is specified as exported.”
 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{245}
+@anchor{gnat_rm/implementation_advice rm-c-1-10-16-access-to-machine-operations}@anchor{248}
 @section RM C.1(10-16): Access to Machine Operations
 
 
@@ -15509,7 +15116,7 @@ Followed on any target supporting such 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{246}
+@anchor{gnat_rm/implementation_advice rm-c-3-28-interrupt-support}@anchor{249}
 @section RM C.3(28): Interrupt Support
 
 
@@ -15527,7 +15134,7 @@ of interrupt blocking.
 @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{247}
+@anchor{gnat_rm/implementation_advice rm-c-3-1-20-21-protected-procedure-handlers}@anchor{24a}
 @section RM C.3.1(20-21): Protected Procedure Handlers
 
 
@@ -15553,7 +15160,7 @@ Followed.  Compile time warnings are given when possible.
 @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{248}
+@anchor{gnat_rm/implementation_advice rm-c-3-2-25-package-interrupts}@anchor{24b}
 @section RM C.3.2(25): Package @code{Interrupts}
 
 
@@ -15571,7 +15178,7 @@ Followed.
 @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{249}
+@anchor{gnat_rm/implementation_advice rm-c-4-14-pre-elaboration-requirements}@anchor{24c}
 @section RM C.4(14): Pre-elaboration Requirements
 
 
@@ -15587,7 +15194,7 @@ Followed.  Executable code is generated in some cases, e.g., loops
 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{24a}
+@anchor{gnat_rm/implementation_advice rm-c-5-8-pragma-discard-names}@anchor{24d}
 @section RM C.5(8): Pragma @code{Discard_Names}
 
 
@@ -15605,7 +15212,7 @@ Followed.
 @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{24b}
+@anchor{gnat_rm/implementation_advice rm-c-7-2-30-the-package-task-attributes}@anchor{24e}
 @section RM C.7.2(30): The Package Task_Attributes
 
 
@@ -15626,7 +15233,7 @@ Not followed.  This implementation is not targeted to such a domain.
 @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{24c}
+@anchor{gnat_rm/implementation_advice rm-d-3-17-locking-policies}@anchor{24f}
 @section RM D.3(17): Locking Policies
 
 
@@ -15643,7 +15250,7 @@ whose names (@code{Inheritance_Locking} and
 @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{24d}
+@anchor{gnat_rm/implementation_advice rm-d-4-16-entry-queuing-policies}@anchor{250}
 @section RM D.4(16): Entry Queuing Policies
 
 
@@ -15658,7 +15265,7 @@ Followed.  No such implementation-defined queuing policies exist.
 @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{24e}
+@anchor{gnat_rm/implementation_advice rm-d-6-9-10-preemptive-abort}@anchor{251}
 @section RM D.6(9-10): Preemptive Abort
 
 
@@ -15684,7 +15291,7 @@ Followed.
 @geindex Tasking restrictions
 
 @node RM D 7 21 Tasking Restrictions,RM D 8 47-49 Monotonic Time,RM D 6 9-10 Preemptive Abort,Implementation Advice
-@anchor{gnat_rm/implementation_advice rm-d-7-21-tasking-restrictions}@anchor{24f}
+@anchor{gnat_rm/implementation_advice rm-d-7-21-tasking-restrictions}@anchor{252}
 @section RM D.7(21): Tasking Restrictions
 
 
@@ -15703,7 +15310,7 @@ pragma @code{Profile (Restricted)} for more details.
 @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{250}
+@anchor{gnat_rm/implementation_advice rm-d-8-47-49-monotonic-time}@anchor{253}
 @section RM D.8(47-49): Monotonic Time
 
 
@@ -15738,7 +15345,7 @@ Followed.
 @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{251}
+@anchor{gnat_rm/implementation_advice rm-e-5-28-29-partition-communication-subsystem}@anchor{254}
 @section RM E.5(28-29): Partition Communication Subsystem
 
 
@@ -15766,7 +15373,7 @@ GNAT.
 @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{252}
+@anchor{gnat_rm/implementation_advice rm-f-7-cobol-support}@anchor{255}
 @section RM F(7): COBOL Support
 
 
@@ -15786,7 +15393,7 @@ Followed.
 @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{253}
+@anchor{gnat_rm/implementation_advice rm-f-1-2-decimal-radix-support}@anchor{256}
 @section RM F.1(2): Decimal Radix Support
 
 
@@ -15802,7 +15409,7 @@ representations.
 @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{254}
+@anchor{gnat_rm/implementation_advice rm-g-numerics}@anchor{257}
 @section RM G: Numerics
 
 
@@ -15822,7 +15429,7 @@ Followed.
 @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{255}
+@anchor{gnat_rm/implementation_advice rm-g-1-1-56-58-complex-types}@anchor{258}
 @section RM G.1.1(56-58): Complex Types
 
 
@@ -15884,7 +15491,7 @@ Followed.
 @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{256}
+@anchor{gnat_rm/implementation_advice rm-g-1-2-49-complex-elementary-functions}@anchor{259}
 @section RM G.1.2(49): Complex Elementary Functions
 
 
@@ -15906,7 +15513,7 @@ Followed.
 @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{257}
+@anchor{gnat_rm/implementation_advice rm-g-2-4-19-accuracy-requirements}@anchor{25a}
 @section RM G.2.4(19): Accuracy Requirements
 
 
@@ -15930,7 +15537,7 @@ Followed.
 @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{258}
+@anchor{gnat_rm/implementation_advice rm-g-2-6-15-complex-arithmetic-accuracy}@anchor{25b}
 @section RM G.2.6(15): Complex Arithmetic Accuracy
 
 
@@ -15948,7 +15555,7 @@ Followed.
 @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{259}
+@anchor{gnat_rm/implementation_advice rm-h-6-15-2-pragma-partition-elaboration-policy}@anchor{25c}
 @section RM H.6(15/2): Pragma Partition_Elaboration_Policy
 
 
@@ -15963,7 +15570,7 @@ immediately terminated.”
 Not followed.
 
 @node Implementation Defined Characteristics,Intrinsic Subprograms,Implementation Advice,Top
-@anchor{gnat_rm/implementation_defined_characteristics doc}@anchor{25a}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{25b}@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}
+@anchor{gnat_rm/implementation_defined_characteristics doc}@anchor{25d}@anchor{gnat_rm/implementation_defined_characteristics id1}@anchor{25e}@anchor{gnat_rm/implementation_defined_characteristics implementation-defined-characteristics}@anchor{b}
 @chapter Implementation Defined Characteristics
 
 
@@ -16812,7 +16419,7 @@ See separate section on data representations.
 such aspects and the legality rules for such aspects.  See 13.1.1(38).”
 @end itemize
 
-See @ref{120,,Implementation Defined Aspects}.
+See @ref{123,,Implementation Defined Aspects}.
 
 
 @itemize *
@@ -17258,7 +16865,7 @@ When the @code{Pattern} parameter is not the null string, it is interpreted
 according to the syntax of regular expressions as defined in the
 @code{GNAT.Regexp} package.
 
-See @ref{25c,,GNAT.Regexp (g-regexp.ads)}.
+See @ref{25f,,GNAT.Regexp (g-regexp.ads)}.
 
 
 @itemize *
@@ -18356,7 +17963,7 @@ Information on those subjects is not yet available.
 Execution is erroneous in that case.
 
 @node Intrinsic Subprograms,Representation Clauses and Pragmas,Implementation Defined Characteristics,Top
-@anchor{gnat_rm/intrinsic_subprograms doc}@anchor{25d}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{25e}@anchor{gnat_rm/intrinsic_subprograms intrinsic-subprograms}@anchor{c}
+@anchor{gnat_rm/intrinsic_subprograms doc}@anchor{260}@anchor{gnat_rm/intrinsic_subprograms id1}@anchor{261}@anchor{gnat_rm/intrinsic_subprograms intrinsic-subprograms}@anchor{c}
 @chapter Intrinsic Subprograms
 
 
@@ -18394,7 +18001,7 @@ Ada standard does not require Ada compilers to implement this feature.
 @end menu
 
 @node Intrinsic Operators,Compilation_ISO_Date,,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id2}@anchor{25f}@anchor{gnat_rm/intrinsic_subprograms intrinsic-operators}@anchor{260}
+@anchor{gnat_rm/intrinsic_subprograms id2}@anchor{262}@anchor{gnat_rm/intrinsic_subprograms intrinsic-operators}@anchor{263}
 @section Intrinsic Operators
 
 
@@ -18425,7 +18032,7 @@ It is also possible to specify such operators for private types, if the
 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{261}@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{262}
+@anchor{gnat_rm/intrinsic_subprograms compilation-iso-date}@anchor{264}@anchor{gnat_rm/intrinsic_subprograms id3}@anchor{265}
 @section Compilation_ISO_Date
 
 
@@ -18439,7 +18046,7 @@ application program should simply call the function
 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{263}@anchor{gnat_rm/intrinsic_subprograms id4}@anchor{264}
+@anchor{gnat_rm/intrinsic_subprograms compilation-date}@anchor{266}@anchor{gnat_rm/intrinsic_subprograms id4}@anchor{267}
 @section Compilation_Date
 
 
@@ -18449,7 +18056,7 @@ Same as Compilation_ISO_Date, except the string is in the form
 MMM DD YYYY.
 
 @node Compilation_Time,Enclosing_Entity,Compilation_Date,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms compilation-time}@anchor{265}@anchor{gnat_rm/intrinsic_subprograms id5}@anchor{266}
+@anchor{gnat_rm/intrinsic_subprograms compilation-time}@anchor{268}@anchor{gnat_rm/intrinsic_subprograms id5}@anchor{269}
 @section Compilation_Time
 
 
@@ -18463,7 +18070,7 @@ application program should simply call the function
 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{267}@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{268}
+@anchor{gnat_rm/intrinsic_subprograms enclosing-entity}@anchor{26a}@anchor{gnat_rm/intrinsic_subprograms id6}@anchor{26b}
 @section Enclosing_Entity
 
 
@@ -18477,7 +18084,7 @@ application program should simply call the function
 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{269}@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{26a}
+@anchor{gnat_rm/intrinsic_subprograms exception-information}@anchor{26c}@anchor{gnat_rm/intrinsic_subprograms id7}@anchor{26d}
 @section Exception_Information
 
 
@@ -18491,7 +18098,7 @@ so an application program should simply call the function
 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{26b}@anchor{gnat_rm/intrinsic_subprograms id8}@anchor{26c}
+@anchor{gnat_rm/intrinsic_subprograms exception-message}@anchor{26e}@anchor{gnat_rm/intrinsic_subprograms id8}@anchor{26f}
 @section Exception_Message
 
 
@@ -18505,7 +18112,7 @@ so an application program should simply call the function
 the message associated with the current exception.
 
 @node Exception_Name,File,Exception_Message,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms exception-name}@anchor{26d}@anchor{gnat_rm/intrinsic_subprograms id9}@anchor{26e}
+@anchor{gnat_rm/intrinsic_subprograms exception-name}@anchor{270}@anchor{gnat_rm/intrinsic_subprograms id9}@anchor{271}
 @section Exception_Name
 
 
@@ -18519,7 +18126,7 @@ so an application program should simply call the function
 the name of the current exception.
 
 @node File,Line,Exception_Name,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms file}@anchor{26f}@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{270}
+@anchor{gnat_rm/intrinsic_subprograms file}@anchor{272}@anchor{gnat_rm/intrinsic_subprograms id10}@anchor{273}
 @section File
 
 
@@ -18533,7 +18140,7 @@ application program should simply call the function
 file.
 
 @node Line,Shifts and Rotates,File,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id11}@anchor{271}@anchor{gnat_rm/intrinsic_subprograms line}@anchor{272}
+@anchor{gnat_rm/intrinsic_subprograms id11}@anchor{274}@anchor{gnat_rm/intrinsic_subprograms line}@anchor{275}
 @section Line
 
 
@@ -18547,7 +18154,7 @@ application program should simply call the function
 source line.
 
 @node Shifts and Rotates,Source_Location,Line,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{273}@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{274}
+@anchor{gnat_rm/intrinsic_subprograms id12}@anchor{276}@anchor{gnat_rm/intrinsic_subprograms shifts-and-rotates}@anchor{277}
 @section Shifts and Rotates
 
 
@@ -18590,7 +18197,7 @@ corresponding operator for modular type. In particular, shifting a negative
 number may change its sign bit to positive.
 
 @node Source_Location,,Shifts and Rotates,Intrinsic Subprograms
-@anchor{gnat_rm/intrinsic_subprograms id13}@anchor{275}@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{276}
+@anchor{gnat_rm/intrinsic_subprograms id13}@anchor{278}@anchor{gnat_rm/intrinsic_subprograms source-location}@anchor{279}
 @section Source_Location
 
 
@@ -18604,7 +18211,7 @@ application program should simply call the function
 source file location.
 
 @node Representation Clauses and Pragmas,Standard Library Routines,Intrinsic Subprograms,Top
-@anchor{gnat_rm/representation_clauses_and_pragmas doc}@anchor{277}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{278}@anchor{gnat_rm/representation_clauses_and_pragmas representation-clauses-and-pragmas}@anchor{d}
+@anchor{gnat_rm/representation_clauses_and_pragmas doc}@anchor{27a}@anchor{gnat_rm/representation_clauses_and_pragmas id1}@anchor{27b}@anchor{gnat_rm/representation_clauses_and_pragmas representation-clauses-and-pragmas}@anchor{d}
 @chapter Representation Clauses and Pragmas
 
 
@@ -18650,7 +18257,7 @@ and this section describes the additional capabilities provided.
 @end menu
 
 @node Alignment Clauses,Size Clauses,,Representation Clauses and Pragmas
-@anchor{gnat_rm/representation_clauses_and_pragmas alignment-clauses}@anchor{279}@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{27a}
+@anchor{gnat_rm/representation_clauses_and_pragmas alignment-clauses}@anchor{27c}@anchor{gnat_rm/representation_clauses_and_pragmas id2}@anchor{27d}
 @section Alignment Clauses
 
 
@@ -18672,7 +18279,7 @@ For elementary types, the alignment is the minimum of the actual size of
 objects of the type divided by @code{Storage_Unit},
 and the maximum alignment supported by the target.
 (This maximum alignment is given by the GNAT-specific attribute
-@code{Standard'Maximum_Alignment}; see @ref{18c,,Attribute Maximum_Alignment}.)
+@code{Standard'Maximum_Alignment}; see @ref{18f,,Attribute Maximum_Alignment}.)
 
 @geindex Maximum_Alignment attribute
 
@@ -18781,7 +18388,7 @@ assumption is non-portable, and other compilers may choose different
 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{27b}@anchor{gnat_rm/representation_clauses_and_pragmas size-clauses}@anchor{27c}
+@anchor{gnat_rm/representation_clauses_and_pragmas id3}@anchor{27e}@anchor{gnat_rm/representation_clauses_and_pragmas size-clauses}@anchor{27f}
 @section Size Clauses
 
 
@@ -18858,7 +18465,7 @@ if it is known that a Size value can be accommodated in an object of
 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{27d}@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{27e}
+@anchor{gnat_rm/representation_clauses_and_pragmas id4}@anchor{280}@anchor{gnat_rm/representation_clauses_and_pragmas storage-size-clauses}@anchor{281}
 @section Storage_Size Clauses
 
 
@@ -18931,7 +18538,7 @@ Of course in practice, there will not be any explicit allocators in the
 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{27f}@anchor{gnat_rm/representation_clauses_and_pragmas size-of-variant-record-objects}@anchor{280}
+@anchor{gnat_rm/representation_clauses_and_pragmas id5}@anchor{282}@anchor{gnat_rm/representation_clauses_and_pragmas size-of-variant-record-objects}@anchor{283}
 @section Size of Variant Record Objects
 
 
@@ -19041,7 +18648,7 @@ the maximum size, regardless of the current variant value, the
 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{281}@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{282}
+@anchor{gnat_rm/representation_clauses_and_pragmas biased-representation}@anchor{284}@anchor{gnat_rm/representation_clauses_and_pragmas id6}@anchor{285}
 @section Biased Representation
 
 
@@ -19079,7 +18686,7 @@ biased representation can be used for all discrete types except for
 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{283}@anchor{gnat_rm/representation_clauses_and_pragmas value-size-and-object-size-clauses}@anchor{284}
+@anchor{gnat_rm/representation_clauses_and_pragmas id7}@anchor{286}@anchor{gnat_rm/representation_clauses_and_pragmas value-size-and-object-size-clauses}@anchor{287}
 @section Value_Size and Object_Size Clauses
 
 
@@ -19395,7 +19002,7 @@ definition clause forces biased representation. This
 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{285}@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{286}
+@anchor{gnat_rm/representation_clauses_and_pragmas component-size-clauses}@anchor{288}@anchor{gnat_rm/representation_clauses_and_pragmas id8}@anchor{289}
 @section Component_Size Clauses
 
 
@@ -19443,7 +19050,7 @@ and a pragma Pack for the same array type. if such duplicate
 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{287}@anchor{gnat_rm/representation_clauses_and_pragmas id9}@anchor{288}
+@anchor{gnat_rm/representation_clauses_and_pragmas bit-order-clauses}@anchor{28a}@anchor{gnat_rm/representation_clauses_and_pragmas id9}@anchor{28b}
 @section Bit_Order Clauses
 
 
@@ -19549,7 +19156,7 @@ if desired.  The following section contains additional
 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{289}@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{28a}
+@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-bit-order-on-byte-ordering}@anchor{28c}@anchor{gnat_rm/representation_clauses_and_pragmas id10}@anchor{28d}
 @section Effect of Bit_Order on Byte Ordering
 
 
@@ -19806,7 +19413,7 @@ to set the boolean constant @code{Master_Byte_First} in
 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{28b}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{28c}
+@anchor{gnat_rm/representation_clauses_and_pragmas id11}@anchor{28e}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-arrays}@anchor{28f}
 @section Pragma Pack for Arrays
 
 
@@ -19926,7 +19533,7 @@ Here 31-bit packing is achieved as required, and no warning is generated,
 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{28d}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{28e}
+@anchor{gnat_rm/representation_clauses_and_pragmas id12}@anchor{290}@anchor{gnat_rm/representation_clauses_and_pragmas pragma-pack-for-records}@anchor{291}
 @section Pragma Pack for Records
 
 
@@ -20010,7 +19617,7 @@ array that is longer than 64 bits, so it is itself non-packable on
 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{28f}@anchor{gnat_rm/representation_clauses_and_pragmas record-representation-clauses}@anchor{290}
+@anchor{gnat_rm/representation_clauses_and_pragmas id13}@anchor{292}@anchor{gnat_rm/representation_clauses_and_pragmas record-representation-clauses}@anchor{293}
 @section Record Representation Clauses
 
 
@@ -20089,7 +19696,7 @@ end record;
 @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{291}@anchor{gnat_rm/representation_clauses_and_pragmas id14}@anchor{292}
+@anchor{gnat_rm/representation_clauses_and_pragmas handling-of-records-with-holes}@anchor{294}@anchor{gnat_rm/representation_clauses_and_pragmas id14}@anchor{295}
 @section Handling of Records with Holes
 
 
@@ -20165,7 +19772,7 @@ for Hrec'Size use 64;
 @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{293}@anchor{gnat_rm/representation_clauses_and_pragmas id15}@anchor{294}
+@anchor{gnat_rm/representation_clauses_and_pragmas enumeration-clauses}@anchor{296}@anchor{gnat_rm/representation_clauses_and_pragmas id15}@anchor{297}
 @section Enumeration Clauses
 
 
@@ -20208,7 +19815,7 @@ the overhead of converting representation values to the corresponding
 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{295}@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{296}
+@anchor{gnat_rm/representation_clauses_and_pragmas address-clauses}@anchor{298}@anchor{gnat_rm/representation_clauses_and_pragmas id16}@anchor{299}
 @section Address Clauses
 
 
@@ -20548,7 +20155,7 @@ then the program compiles without the warning and when run will generate
 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{297}@anchor{gnat_rm/representation_clauses_and_pragmas use-of-address-clauses-for-memory-mapped-i-o}@anchor{298}
+@anchor{gnat_rm/representation_clauses_and_pragmas id17}@anchor{29a}@anchor{gnat_rm/representation_clauses_and_pragmas use-of-address-clauses-for-memory-mapped-i-o}@anchor{29b}
 @section Use of Address Clauses for Memory-Mapped I/O
 
 
@@ -20606,7 +20213,7 @@ provides the pragma @code{Volatile_Full_Access} which can be used in lieu of
 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{299}@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{29a}
+@anchor{gnat_rm/representation_clauses_and_pragmas effect-of-convention-on-representation}@anchor{29c}@anchor{gnat_rm/representation_clauses_and_pragmas id18}@anchor{29d}
 @section Effect of Convention on Representation
 
 
@@ -20684,7 +20291,7 @@ when one of these values is read, any nonzero value is treated as True.
 @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{29b}@anchor{gnat_rm/representation_clauses_and_pragmas id19}@anchor{29c}
+@anchor{gnat_rm/representation_clauses_and_pragmas conventions-and-anonymous-access-types}@anchor{29e}@anchor{gnat_rm/representation_clauses_and_pragmas id19}@anchor{29f}
 @section Conventions and Anonymous Access Types
 
 
@@ -20760,7 +20367,7 @@ package ConvComp is
 @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{29d}@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{29e}
+@anchor{gnat_rm/representation_clauses_and_pragmas determining-the-representations-chosen-by-gnat}@anchor{2a0}@anchor{gnat_rm/representation_clauses_and_pragmas id20}@anchor{2a1}
 @section Determining the Representations chosen by GNAT
 
 
@@ -20912,7 +20519,7 @@ generated by the compiler into the original source to fix and guarantee
 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{29f}@anchor{gnat_rm/standard_library_routines id1}@anchor{2a0}@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}
+@anchor{gnat_rm/standard_library_routines doc}@anchor{2a2}@anchor{gnat_rm/standard_library_routines id1}@anchor{2a3}@anchor{gnat_rm/standard_library_routines standard-library-routines}@anchor{e}
 @chapter Standard Library Routines
 
 
@@ -21736,7 +21343,7 @@ For packages in Interfaces and System, all the RM defined packages are
 available in GNAT, see the Ada 2012 RM for full details.
 
 @node The Implementation of Standard I/O,The GNAT Library,Standard Library Routines,Top
-@anchor{gnat_rm/the_implementation_of_standard_i_o doc}@anchor{2a1}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{2a2}@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{2a4}@anchor{gnat_rm/the_implementation_of_standard_i_o id1}@anchor{2a5}@anchor{gnat_rm/the_implementation_of_standard_i_o the-implementation-of-standard-i-o}@anchor{f}
 @chapter The Implementation of Standard I/O
 
 
@@ -21788,7 +21395,7 @@ these additional facilities are also described in this chapter.
 @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{2a3}@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2a4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id2}@anchor{2a6}@anchor{gnat_rm/the_implementation_of_standard_i_o standard-i-o-packages}@anchor{2a7}
 @section Standard I/O Packages
 
 
@@ -21859,7 +21466,7 @@ flush the common I/O streams and in particular Standard_Output before
 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{2a5}@anchor{gnat_rm/the_implementation_of_standard_i_o id3}@anchor{2a6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o form-strings}@anchor{2a8}@anchor{gnat_rm/the_implementation_of_standard_i_o id3}@anchor{2a9}
 @section FORM Strings
 
 
@@ -21885,7 +21492,7 @@ unrecognized keyword appears in a form string, it is silently ignored
 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{2a7}@anchor{gnat_rm/the_implementation_of_standard_i_o id4}@anchor{2a8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o direct-io}@anchor{2aa}@anchor{gnat_rm/the_implementation_of_standard_i_o id4}@anchor{2ab}
 @section Direct_IO
 
 
@@ -21905,7 +21512,7 @@ There is no limit on the size of Direct_IO files, they are expanded as
 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{2a9}@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2aa}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id5}@anchor{2ac}@anchor{gnat_rm/the_implementation_of_standard_i_o sequential-io}@anchor{2ad}
 @section Sequential_IO
 
 
@@ -21952,7 +21559,7 @@ using Stream_IO, and this is the preferred mechanism.  In particular, the
 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{2ab}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io}@anchor{2ac}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id6}@anchor{2ae}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io}@anchor{2af}
 @section Text_IO
 
 
@@ -22035,7 +21642,7 @@ the file.
 @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{2ad}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning}@anchor{2ae}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id7}@anchor{2b0}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning}@anchor{2b1}
 @subsection Stream Pointer Positioning
 
 
@@ -22071,7 +21678,7 @@ between two Ada files, then the difference may be observable in some
 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{2af}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2b0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id8}@anchor{2b2}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files}@anchor{2b3}
 @subsection Reading and Writing Non-Regular Files
 
 
@@ -22122,7 +21729,7 @@ to read data past that end of
 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{2b1}@anchor{gnat_rm/the_implementation_of_standard_i_o id9}@anchor{2b2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o get-immediate}@anchor{2b4}@anchor{gnat_rm/the_implementation_of_standard_i_o id9}@anchor{2b5}
 @subsection Get_Immediate
 
 
@@ -22140,7 +21747,7 @@ possible), it is undefined whether the FF character will be treated as a
 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{2b3}@anchor{gnat_rm/the_implementation_of_standard_i_o treating-text-io-files-as-streams}@anchor{2b4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id10}@anchor{2b6}@anchor{gnat_rm/the_implementation_of_standard_i_o treating-text-io-files-as-streams}@anchor{2b7}
 @subsection Treating Text_IO Files as Streams
 
 
@@ -22156,7 +21763,7 @@ skipped and the effect is similar to that described above for
 @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{2b5}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-extensions}@anchor{2b6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id11}@anchor{2b8}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-extensions}@anchor{2b9}
 @subsection Text_IO Extensions
 
 
@@ -22184,7 +21791,7 @@ the string is to be read.
 @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{2b7}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2b8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id12}@anchor{2ba}@anchor{gnat_rm/the_implementation_of_standard_i_o text-io-facilities-for-unbounded-strings}@anchor{2bb}
 @subsection Text_IO Facilities for Unbounded Strings
 
 
@@ -22232,7 +21839,7 @@ files @code{a-szuzti.ads} and @code{a-szuzti.adb} provides similar extended
 @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{2b9}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2ba}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id13}@anchor{2bc}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-text-io}@anchor{2bd}
 @section Wide_Text_IO
 
 
@@ -22479,12 +22086,12 @@ input also causes Constraint_Error to be raised.
 @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{2bb}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2bc}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id14}@anchor{2be}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-1}@anchor{2bf}
 @subsection Stream Pointer Positioning
 
 
 @code{Ada.Wide_Text_IO} is similar to @code{Ada.Text_IO} in its handling
-of stream pointer positioning (@ref{2ac,,Text_IO}).  There is one additional
+of stream pointer positioning (@ref{2af,,Text_IO}).  There is one additional
 case:
 
 If @code{Ada.Wide_Text_IO.Look_Ahead} reads a character outside the
@@ -22503,7 +22110,7 @@ to a normal program using @code{Wide_Text_IO}.  However, this discrepancy
 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{2bd}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2be}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id15}@anchor{2c0}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-1}@anchor{2c1}
 @subsection Reading and Writing Non-Regular Files
 
 
@@ -22514,7 +22121,7 @@ treated as data characters), and @code{End_Of_Page} always returns
 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{2bf}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-wide-text-io}@anchor{2c0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id16}@anchor{2c2}@anchor{gnat_rm/the_implementation_of_standard_i_o wide-wide-text-io}@anchor{2c3}
 @section Wide_Wide_Text_IO
 
 
@@ -22683,12 +22290,12 @@ input also causes Constraint_Error to be raised.
 @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{2c1}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2c2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id17}@anchor{2c4}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-pointer-positioning-2}@anchor{2c5}
 @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{2ac,,Text_IO}).  There is one additional
+of stream pointer positioning (@ref{2af,,Text_IO}).  There is one additional
 case:
 
 If @code{Ada.Wide_Wide_Text_IO.Look_Ahead} reads a character outside the
@@ -22707,7 +22314,7 @@ to a normal program using @code{Wide_Wide_Text_IO}.  However, this discrepancy
 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{2c3}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-2}@anchor{2c4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id18}@anchor{2c6}@anchor{gnat_rm/the_implementation_of_standard_i_o reading-and-writing-non-regular-files-2}@anchor{2c7}
 @subsection Reading and Writing Non-Regular Files
 
 
@@ -22718,7 +22325,7 @@ treated as data characters), and @code{End_Of_Page} always returns
 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{2c5}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-io}@anchor{2c6}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id19}@anchor{2c8}@anchor{gnat_rm/the_implementation_of_standard_i_o stream-io}@anchor{2c9}
 @section Stream_IO
 
 
@@ -22740,7 +22347,7 @@ manner described for stream attributes.
 @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{2c7}@anchor{gnat_rm/the_implementation_of_standard_i_o text-translation}@anchor{2c8}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id20}@anchor{2ca}@anchor{gnat_rm/the_implementation_of_standard_i_o text-translation}@anchor{2cb}
 @section Text Translation
 
 
@@ -22774,7 +22381,7 @@ mode. (corresponds to_O_U16TEXT).
 @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{2c9}@anchor{gnat_rm/the_implementation_of_standard_i_o shared-files}@anchor{2ca}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id21}@anchor{2cc}@anchor{gnat_rm/the_implementation_of_standard_i_o shared-files}@anchor{2cd}
 @section Shared Files
 
 
@@ -22837,7 +22444,7 @@ heterogeneous input-output.  Although this approach will work in GNAT if
 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{2cb}@anchor{gnat_rm/the_implementation_of_standard_i_o id22}@anchor{2cc}
+@anchor{gnat_rm/the_implementation_of_standard_i_o filenames-encoding}@anchor{2ce}@anchor{gnat_rm/the_implementation_of_standard_i_o id22}@anchor{2cf}
 @section Filenames encoding
 
 
@@ -22877,7 +22484,7 @@ platform. On the other Operating Systems the run-time is supporting
 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{2cd}@anchor{gnat_rm/the_implementation_of_standard_i_o id23}@anchor{2ce}
+@anchor{gnat_rm/the_implementation_of_standard_i_o file-content-encoding}@anchor{2d0}@anchor{gnat_rm/the_implementation_of_standard_i_o id23}@anchor{2d1}
 @section File content encoding
 
 
@@ -22910,7 +22517,7 @@ Unicode 8-bit 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{2cf}@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2d0}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id24}@anchor{2d2}@anchor{gnat_rm/the_implementation_of_standard_i_o open-modes}@anchor{2d3}
 @section Open Modes
 
 
@@ -23013,7 +22620,7 @@ subsequently requires switching from reading to writing or vice-versa,
 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{2d1}@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2d2}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id25}@anchor{2d4}@anchor{gnat_rm/the_implementation_of_standard_i_o operations-on-c-streams}@anchor{2d5}
 @section Operations on C Streams
 
 
@@ -23173,7 +22780,7 @@ end Interfaces.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{2d3}@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2d4}
+@anchor{gnat_rm/the_implementation_of_standard_i_o id26}@anchor{2d6}@anchor{gnat_rm/the_implementation_of_standard_i_o interfacing-to-c-streams}@anchor{2d7}
 @section Interfacing to C Streams
 
 
@@ -23266,7 +22873,7 @@ imported from a C program, allowing an Ada file to operate on an
 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{2d5}@anchor{gnat_rm/the_gnat_library id1}@anchor{2d6}@anchor{gnat_rm/the_gnat_library the-gnat-library}@anchor{10}
+@anchor{gnat_rm/the_gnat_library doc}@anchor{2d8}@anchor{gnat_rm/the_gnat_library id1}@anchor{2d9}@anchor{gnat_rm/the_gnat_library the-gnat-library}@anchor{10}
 @chapter The GNAT Library
 
 
@@ -23452,7 +23059,7 @@ of GNAT, and will generate a warning message.
 @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{2d7}@anchor{gnat_rm/the_gnat_library id2}@anchor{2d8}
+@anchor{gnat_rm/the_gnat_library ada-characters-latin-9-a-chlat9-ads}@anchor{2da}@anchor{gnat_rm/the_gnat_library id2}@anchor{2db}
 @section @code{Ada.Characters.Latin_9} (@code{a-chlat9.ads})
 
 
@@ -23469,7 +23076,7 @@ is specifically authorized by the Ada Reference Manual
 (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{2d9}@anchor{gnat_rm/the_gnat_library id3}@anchor{2da}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-1-a-cwila1-ads}@anchor{2dc}@anchor{gnat_rm/the_gnat_library id3}@anchor{2dd}
 @section @code{Ada.Characters.Wide_Latin_1} (@code{a-cwila1.ads})
 
 
@@ -23486,7 +23093,7 @@ is specifically authorized by the Ada Reference Manual
 (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{2db}@anchor{gnat_rm/the_gnat_library id4}@anchor{2dc}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-latin-9-a-cwila9-ads}@anchor{2de}@anchor{gnat_rm/the_gnat_library id4}@anchor{2df}
 @section @code{Ada.Characters.Wide_Latin_9} (@code{a-cwila9.ads})
 
 
@@ -23503,7 +23110,7 @@ is specifically authorized by the Ada Reference Manual
 (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{2dd}@anchor{gnat_rm/the_gnat_library id5}@anchor{2de}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-1-a-chzla1-ads}@anchor{2e0}@anchor{gnat_rm/the_gnat_library id5}@anchor{2e1}
 @section @code{Ada.Characters.Wide_Wide_Latin_1} (@code{a-chzla1.ads})
 
 
@@ -23520,7 +23127,7 @@ is specifically authorized by the Ada Reference Manual
 (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{2df}@anchor{gnat_rm/the_gnat_library id6}@anchor{2e0}
+@anchor{gnat_rm/the_gnat_library ada-characters-wide-wide-latin-9-a-chzla9-ads}@anchor{2e2}@anchor{gnat_rm/the_gnat_library id6}@anchor{2e3}
 @section @code{Ada.Characters.Wide_Wide_Latin_9} (@code{a-chzla9.ads})
 
 
@@ -23537,7 +23144,7 @@ is specifically authorized by the Ada Reference Manual
 (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{2e1}@anchor{gnat_rm/the_gnat_library id7}@anchor{2e2}
+@anchor{gnat_rm/the_gnat_library ada-containers-bounded-holders-a-coboho-ads}@anchor{2e4}@anchor{gnat_rm/the_gnat_library id7}@anchor{2e5}
 @section @code{Ada.Containers.Bounded_Holders} (@code{a-coboho.ads})
 
 
@@ -23549,7 +23156,7 @@ This child of @code{Ada.Containers} defines a modified version of
 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{2e3}@anchor{gnat_rm/the_gnat_library id8}@anchor{2e4}
+@anchor{gnat_rm/the_gnat_library ada-command-line-environment-a-colien-ads}@anchor{2e6}@anchor{gnat_rm/the_gnat_library id8}@anchor{2e7}
 @section @code{Ada.Command_Line.Environment} (@code{a-colien.ads})
 
 
@@ -23562,7 +23169,7 @@ provides a mechanism for obtaining environment values on systems
 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{2e5}@anchor{gnat_rm/the_gnat_library id9}@anchor{2e6}
+@anchor{gnat_rm/the_gnat_library ada-command-line-remove-a-colire-ads}@anchor{2e8}@anchor{gnat_rm/the_gnat_library id9}@anchor{2e9}
 @section @code{Ada.Command_Line.Remove} (@code{a-colire.ads})
 
 
@@ -23580,7 +23187,7 @@ to further calls to the subprograms in @code{Ada.Command_Line}. These calls
 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{2e7}@anchor{gnat_rm/the_gnat_library id10}@anchor{2e8}
+@anchor{gnat_rm/the_gnat_library ada-command-line-response-file-a-clrefi-ads}@anchor{2ea}@anchor{gnat_rm/the_gnat_library id10}@anchor{2eb}
 @section @code{Ada.Command_Line.Response_File} (@code{a-clrefi.ads})
 
 
@@ -23600,7 +23207,7 @@ Using a response file allow passing a set of arguments to an executable longer
 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{2e9}@anchor{gnat_rm/the_gnat_library id11}@anchor{2ea}
+@anchor{gnat_rm/the_gnat_library ada-direct-io-c-streams-a-diocst-ads}@anchor{2ec}@anchor{gnat_rm/the_gnat_library id11}@anchor{2ed}
 @section @code{Ada.Direct_IO.C_Streams} (@code{a-diocst.ads})
 
 
@@ -23615,7 +23222,7 @@ extracted from a file opened on the Ada side, and an Ada file
 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{2eb}@anchor{gnat_rm/the_gnat_library id12}@anchor{2ec}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-is-null-occurrence-a-einuoc-ads}@anchor{2ee}@anchor{gnat_rm/the_gnat_library id12}@anchor{2ef}
 @section @code{Ada.Exceptions.Is_Null_Occurrence} (@code{a-einuoc.ads})
 
 
@@ -23629,7 +23236,7 @@ exception occurrence (@code{Null_Occurrence}) without raising
 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{2ed}@anchor{gnat_rm/the_gnat_library id13}@anchor{2ee}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-last-chance-handler-a-elchha-ads}@anchor{2f0}@anchor{gnat_rm/the_gnat_library id13}@anchor{2f1}
 @section @code{Ada.Exceptions.Last_Chance_Handler} (@code{a-elchha.ads})
 
 
@@ -23643,7 +23250,7 @@ exceptions (hence the name last chance), and perform clean ups before
 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{2ef}@anchor{gnat_rm/the_gnat_library id14}@anchor{2f0}
+@anchor{gnat_rm/the_gnat_library ada-exceptions-traceback-a-exctra-ads}@anchor{2f2}@anchor{gnat_rm/the_gnat_library id14}@anchor{2f3}
 @section @code{Ada.Exceptions.Traceback} (@code{a-exctra.ads})
 
 
@@ -23656,7 +23263,7 @@ give a traceback array of addresses based on an exception
 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{2f1}@anchor{gnat_rm/the_gnat_library id15}@anchor{2f2}
+@anchor{gnat_rm/the_gnat_library ada-sequential-io-c-streams-a-siocst-ads}@anchor{2f4}@anchor{gnat_rm/the_gnat_library id15}@anchor{2f5}
 @section @code{Ada.Sequential_IO.C_Streams} (@code{a-siocst.ads})
 
 
@@ -23671,7 +23278,7 @@ extracted from a file opened on the Ada side, and an Ada file
 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{2f3}@anchor{gnat_rm/the_gnat_library id16}@anchor{2f4}
+@anchor{gnat_rm/the_gnat_library ada-streams-stream-io-c-streams-a-ssicst-ads}@anchor{2f6}@anchor{gnat_rm/the_gnat_library id16}@anchor{2f7}
 @section @code{Ada.Streams.Stream_IO.C_Streams} (@code{a-ssicst.ads})
 
 
@@ -23686,7 +23293,7 @@ extracted from a file opened on the Ada side, and an Ada file
 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{2f5}@anchor{gnat_rm/the_gnat_library id17}@anchor{2f6}
+@anchor{gnat_rm/the_gnat_library ada-strings-unbounded-text-io-a-suteio-ads}@anchor{2f8}@anchor{gnat_rm/the_gnat_library id17}@anchor{2f9}
 @section @code{Ada.Strings.Unbounded.Text_IO} (@code{a-suteio.ads})
 
 
@@ -23703,7 +23310,7 @@ strings, avoiding the necessity for an intermediate operation
 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{2f7}@anchor{gnat_rm/the_gnat_library id18}@anchor{2f8}
+@anchor{gnat_rm/the_gnat_library ada-strings-wide-unbounded-wide-text-io-a-swuwti-ads}@anchor{2fa}@anchor{gnat_rm/the_gnat_library id18}@anchor{2fb}
 @section @code{Ada.Strings.Wide_Unbounded.Wide_Text_IO} (@code{a-swuwti.ads})
 
 
@@ -23720,7 +23327,7 @@ wide strings, avoiding the necessity for an intermediate operation
 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{2f9}@anchor{gnat_rm/the_gnat_library id19}@anchor{2fa}
+@anchor{gnat_rm/the_gnat_library ada-strings-wide-wide-unbounded-wide-wide-text-io-a-szuzti-ads}@anchor{2fc}@anchor{gnat_rm/the_gnat_library id19}@anchor{2fd}
 @section @code{Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO} (@code{a-szuzti.ads})
 
 
@@ -23737,7 +23344,7 @@ wide wide strings, avoiding the necessity for an intermediate operation
 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{2fb}@anchor{gnat_rm/the_gnat_library id20}@anchor{2fc}
+@anchor{gnat_rm/the_gnat_library ada-task-initialization-a-tasini-ads}@anchor{2fe}@anchor{gnat_rm/the_gnat_library id20}@anchor{2ff}
 @section @code{Ada.Task_Initialization} (@code{a-tasini.ads})
 
 
@@ -23749,7 +23356,7 @@ parameterless procedures. Note that such a handler is only invoked for
 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{2fd}@anchor{gnat_rm/the_gnat_library id21}@anchor{2fe}
+@anchor{gnat_rm/the_gnat_library ada-text-io-c-streams-a-tiocst-ads}@anchor{300}@anchor{gnat_rm/the_gnat_library id21}@anchor{301}
 @section @code{Ada.Text_IO.C_Streams} (@code{a-tiocst.ads})
 
 
@@ -23764,7 +23371,7 @@ extracted from a file opened on the Ada side, and an Ada file
 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{2ff}@anchor{gnat_rm/the_gnat_library id22}@anchor{300}
+@anchor{gnat_rm/the_gnat_library ada-text-io-reset-standard-files-a-tirsfi-ads}@anchor{302}@anchor{gnat_rm/the_gnat_library id22}@anchor{303}
 @section @code{Ada.Text_IO.Reset_Standard_Files} (@code{a-tirsfi.ads})
 
 
@@ -23779,7 +23386,7 @@ execution (for example a standard input file may be redefined to be
 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{301}@anchor{gnat_rm/the_gnat_library id23}@anchor{302}
+@anchor{gnat_rm/the_gnat_library ada-wide-characters-unicode-a-wichun-ads}@anchor{304}@anchor{gnat_rm/the_gnat_library id23}@anchor{305}
 @section @code{Ada.Wide_Characters.Unicode} (@code{a-wichun.ads})
 
 
@@ -23792,7 +23399,7 @@ This package provides subprograms that allow categorization of
 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{303}@anchor{gnat_rm/the_gnat_library id24}@anchor{304}
+@anchor{gnat_rm/the_gnat_library ada-wide-text-io-c-streams-a-wtcstr-ads}@anchor{306}@anchor{gnat_rm/the_gnat_library id24}@anchor{307}
 @section @code{Ada.Wide_Text_IO.C_Streams} (@code{a-wtcstr.ads})
 
 
@@ -23807,7 +23414,7 @@ extracted from a file opened on the Ada side, and an Ada file
 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{305}@anchor{gnat_rm/the_gnat_library id25}@anchor{306}
+@anchor{gnat_rm/the_gnat_library ada-wide-text-io-reset-standard-files-a-wrstfi-ads}@anchor{308}@anchor{gnat_rm/the_gnat_library id25}@anchor{309}
 @section @code{Ada.Wide_Text_IO.Reset_Standard_Files} (@code{a-wrstfi.ads})
 
 
@@ -23822,7 +23429,7 @@ execution (for example a standard input file may be redefined to be
 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{307}@anchor{gnat_rm/the_gnat_library id26}@anchor{308}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-characters-unicode-a-zchuni-ads}@anchor{30a}@anchor{gnat_rm/the_gnat_library id26}@anchor{30b}
 @section @code{Ada.Wide_Wide_Characters.Unicode} (@code{a-zchuni.ads})
 
 
@@ -23835,7 +23442,7 @@ This package provides subprograms that allow categorization of
 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{309}@anchor{gnat_rm/the_gnat_library id27}@anchor{30a}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-c-streams-a-ztcstr-ads}@anchor{30c}@anchor{gnat_rm/the_gnat_library id27}@anchor{30d}
 @section @code{Ada.Wide_Wide_Text_IO.C_Streams} (@code{a-ztcstr.ads})
 
 
@@ -23850,7 +23457,7 @@ extracted from a file opened on the Ada side, and an Ada file
 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{30b}@anchor{gnat_rm/the_gnat_library id28}@anchor{30c}
+@anchor{gnat_rm/the_gnat_library ada-wide-wide-text-io-reset-standard-files-a-zrstfi-ads}@anchor{30e}@anchor{gnat_rm/the_gnat_library id28}@anchor{30f}
 @section @code{Ada.Wide_Wide_Text_IO.Reset_Standard_Files} (@code{a-zrstfi.ads})
 
 
@@ -23865,7 +23472,7 @@ change during execution (for example a standard input file may be
 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{30d}@anchor{gnat_rm/the_gnat_library id29}@anchor{30e}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-g-altive-ads}@anchor{310}@anchor{gnat_rm/the_gnat_library id29}@anchor{311}
 @section @code{GNAT.Altivec} (@code{g-altive.ads})
 
 
@@ -23878,7 +23485,7 @@ definitions of constants and types common to all the versions of the
 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{30f}@anchor{gnat_rm/the_gnat_library id30}@anchor{310}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-conversions-g-altcon-ads}@anchor{312}@anchor{gnat_rm/the_gnat_library id30}@anchor{313}
 @section @code{GNAT.Altivec.Conversions} (@code{g-altcon.ads})
 
 
@@ -23889,7 +23496,7 @@ binding.
 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{311}@anchor{gnat_rm/the_gnat_library id31}@anchor{312}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-operations-g-alveop-ads}@anchor{314}@anchor{gnat_rm/the_gnat_library id31}@anchor{315}
 @section @code{GNAT.Altivec.Vector_Operations} (@code{g-alveop.ads})
 
 
@@ -23903,7 +23510,7 @@ library. The hard binding is provided as a separate package. This unit
 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{313}@anchor{gnat_rm/the_gnat_library id32}@anchor{314}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-types-g-alvety-ads}@anchor{316}@anchor{gnat_rm/the_gnat_library id32}@anchor{317}
 @section @code{GNAT.Altivec.Vector_Types} (@code{g-alvety.ads})
 
 
@@ -23915,7 +23522,7 @@ This package exposes the various vector types part of the Ada binding
 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{315}@anchor{gnat_rm/the_gnat_library id33}@anchor{316}
+@anchor{gnat_rm/the_gnat_library gnat-altivec-vector-views-g-alvevi-ads}@anchor{318}@anchor{gnat_rm/the_gnat_library id33}@anchor{319}
 @section @code{GNAT.Altivec.Vector_Views} (@code{g-alvevi.ads})
 
 
@@ -23930,7 +23537,7 @@ vector elements and provides a simple way to initialize vector
 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{317}@anchor{gnat_rm/the_gnat_library id34}@anchor{318}
+@anchor{gnat_rm/the_gnat_library gnat-array-split-g-arrspl-ads}@anchor{31a}@anchor{gnat_rm/the_gnat_library id34}@anchor{31b}
 @section @code{GNAT.Array_Split} (@code{g-arrspl.ads})
 
 
@@ -23943,7 +23550,7 @@ an array wherever the separators appear, and provide direct access
 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{319}@anchor{gnat_rm/the_gnat_library id35}@anchor{31a}
+@anchor{gnat_rm/the_gnat_library gnat-awk-g-awk-ads}@anchor{31c}@anchor{gnat_rm/the_gnat_library id35}@anchor{31d}
 @section @code{GNAT.AWK} (@code{g-awk.ads})
 
 
@@ -23958,7 +23565,7 @@ or more files containing formatted data.  The file is viewed as a database
 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{31b}@anchor{gnat_rm/the_gnat_library id36}@anchor{31c}
+@anchor{gnat_rm/the_gnat_library gnat-binary-search-g-binsea-ads}@anchor{31e}@anchor{gnat_rm/the_gnat_library id36}@anchor{31f}
 @section @code{GNAT.Binary_Search} (@code{g-binsea.ads})
 
 
@@ -23970,7 +23577,7 @@ Allow binary search of a sorted array (or of an array-like container;
 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{31d}@anchor{gnat_rm/the_gnat_library id37}@anchor{31e}
+@anchor{gnat_rm/the_gnat_library gnat-bind-environment-g-binenv-ads}@anchor{320}@anchor{gnat_rm/the_gnat_library id37}@anchor{321}
 @section @code{GNAT.Bind_Environment} (@code{g-binenv.ads})
 
 
@@ -23983,7 +23590,7 @@ These associations can be specified using the @code{-V} binder command
 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{31f}@anchor{gnat_rm/the_gnat_library id38}@anchor{320}
+@anchor{gnat_rm/the_gnat_library gnat-branch-prediction-g-brapre-ads}@anchor{322}@anchor{gnat_rm/the_gnat_library id38}@anchor{323}
 @section @code{GNAT.Branch_Prediction} (@code{g-brapre.ads})
 
 
@@ -23994,7 +23601,7 @@ line switch.
 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{321}@anchor{gnat_rm/the_gnat_library id39}@anchor{322}
+@anchor{gnat_rm/the_gnat_library gnat-bounded-buffers-g-boubuf-ads}@anchor{324}@anchor{gnat_rm/the_gnat_library id39}@anchor{325}
 @section @code{GNAT.Bounded_Buffers} (@code{g-boubuf.ads})
 
 
@@ -24009,7 +23616,7 @@ useful directly or as parts of the implementations of other abstractions,
 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{323}@anchor{gnat_rm/the_gnat_library id40}@anchor{324}
+@anchor{gnat_rm/the_gnat_library gnat-bounded-mailboxes-g-boumai-ads}@anchor{326}@anchor{gnat_rm/the_gnat_library id40}@anchor{327}
 @section @code{GNAT.Bounded_Mailboxes} (@code{g-boumai.ads})
 
 
@@ -24022,7 +23629,7 @@ such as mailboxes.
 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{325}@anchor{gnat_rm/the_gnat_library id41}@anchor{326}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-bubsor-ads}@anchor{328}@anchor{gnat_rm/the_gnat_library id41}@anchor{329}
 @section @code{GNAT.Bubble_Sort} (@code{g-bubsor.ads})
 
 
@@ -24037,7 +23644,7 @@ data items.  Exchange and comparison procedures are provided by passing
 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{327}@anchor{gnat_rm/the_gnat_library id42}@anchor{328}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-a-g-busora-ads}@anchor{32a}@anchor{gnat_rm/the_gnat_library id42}@anchor{32b}
 @section @code{GNAT.Bubble_Sort_A} (@code{g-busora.ads})
 
 
@@ -24053,7 +23660,7 @@ access-to-procedure values. This is an older version, retained for
 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{329}@anchor{gnat_rm/the_gnat_library id43}@anchor{32a}
+@anchor{gnat_rm/the_gnat_library gnat-bubble-sort-g-g-busorg-ads}@anchor{32c}@anchor{gnat_rm/the_gnat_library id43}@anchor{32d}
 @section @code{GNAT.Bubble_Sort_G} (@code{g-busorg.ads})
 
 
@@ -24069,7 +23676,7 @@ if the procedures can be inlined, at the expense of duplicating code for
 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{32b}@anchor{gnat_rm/the_gnat_library id44}@anchor{32c}
+@anchor{gnat_rm/the_gnat_library gnat-byte-order-mark-g-byorma-ads}@anchor{32e}@anchor{gnat_rm/the_gnat_library id44}@anchor{32f}
 @section @code{GNAT.Byte_Order_Mark} (@code{g-byorma.ads})
 
 
@@ -24085,7 +23692,7 @@ the encoding of the string. The routine includes detection of special XML
 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{32d}@anchor{gnat_rm/the_gnat_library id45}@anchor{32e}
+@anchor{gnat_rm/the_gnat_library gnat-byte-swapping-g-bytswa-ads}@anchor{330}@anchor{gnat_rm/the_gnat_library id45}@anchor{331}
 @section @code{GNAT.Byte_Swapping} (@code{g-bytswa.ads})
 
 
@@ -24099,7 +23706,7 @@ General routines for swapping the bytes in 2-, 4-, and 8-byte quantities.
 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{32f}@anchor{gnat_rm/the_gnat_library id46}@anchor{330}
+@anchor{gnat_rm/the_gnat_library gnat-calendar-g-calend-ads}@anchor{332}@anchor{gnat_rm/the_gnat_library id46}@anchor{333}
 @section @code{GNAT.Calendar} (@code{g-calend.ads})
 
 
@@ -24113,7 +23720,7 @@ Also provides conversion of @code{Ada.Calendar.Time} values to and from the
 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{331}@anchor{gnat_rm/the_gnat_library id47}@anchor{332}
+@anchor{gnat_rm/the_gnat_library gnat-calendar-time-io-g-catiio-ads}@anchor{334}@anchor{gnat_rm/the_gnat_library id47}@anchor{335}
 @section @code{GNAT.Calendar.Time_IO} (@code{g-catiio.ads})
 
 
@@ -24124,7 +23731,7 @@ C @code{timeval} format.
 @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{333}@anchor{gnat_rm/the_gnat_library id48}@anchor{334}
+@anchor{gnat_rm/the_gnat_library gnat-crc32-g-crc32-ads}@anchor{336}@anchor{gnat_rm/the_gnat_library id48}@anchor{337}
 @section @code{GNAT.CRC32} (@code{g-crc32.ads})
 
 
@@ -24141,7 +23748,7 @@ of this algorithm see
 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{335}@anchor{gnat_rm/the_gnat_library id49}@anchor{336}
+@anchor{gnat_rm/the_gnat_library gnat-case-util-g-casuti-ads}@anchor{338}@anchor{gnat_rm/the_gnat_library id49}@anchor{339}
 @section @code{GNAT.Case_Util} (@code{g-casuti.ads})
 
 
@@ -24156,7 +23763,7 @@ without the overhead of the full casing tables
 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{337}@anchor{gnat_rm/the_gnat_library id50}@anchor{338}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-g-cgi-ads}@anchor{33a}@anchor{gnat_rm/the_gnat_library id50}@anchor{33b}
 @section @code{GNAT.CGI} (@code{g-cgi.ads})
 
 
@@ -24171,7 +23778,7 @@ builds a table whose index is the key and provides some services to deal
 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{339}@anchor{gnat_rm/the_gnat_library id51}@anchor{33a}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-cookie-g-cgicoo-ads}@anchor{33c}@anchor{gnat_rm/the_gnat_library id51}@anchor{33d}
 @section @code{GNAT.CGI.Cookie} (@code{g-cgicoo.ads})
 
 
@@ -24186,7 +23793,7 @@ Common Gateway Interface (CGI).  It exports services to deal with Web
 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{33b}@anchor{gnat_rm/the_gnat_library id52}@anchor{33c}
+@anchor{gnat_rm/the_gnat_library gnat-cgi-debug-g-cgideb-ads}@anchor{33e}@anchor{gnat_rm/the_gnat_library id52}@anchor{33f}
 @section @code{GNAT.CGI.Debug} (@code{g-cgideb.ads})
 
 
@@ -24198,7 +23805,7 @@ This is a package to help debugging CGI (Common Gateway Interface)
 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{33d}@anchor{gnat_rm/the_gnat_library id53}@anchor{33e}
+@anchor{gnat_rm/the_gnat_library gnat-command-line-g-comlin-ads}@anchor{340}@anchor{gnat_rm/the_gnat_library id53}@anchor{341}
 @section @code{GNAT.Command_Line} (@code{g-comlin.ads})
 
 
@@ -24211,7 +23818,7 @@ including the ability to scan for named switches with optional parameters
 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{33f}@anchor{gnat_rm/the_gnat_library id54}@anchor{340}
+@anchor{gnat_rm/the_gnat_library gnat-compiler-version-g-comver-ads}@anchor{342}@anchor{gnat_rm/the_gnat_library id54}@anchor{343}
 @section @code{GNAT.Compiler_Version} (@code{g-comver.ads})
 
 
@@ -24229,7 +23836,7 @@ of the compiler if a consistent tool set is used to compile all units
 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{341}@anchor{gnat_rm/the_gnat_library id55}@anchor{342}
+@anchor{gnat_rm/the_gnat_library gnat-ctrl-c-g-ctrl-c-ads}@anchor{344}@anchor{gnat_rm/the_gnat_library id55}@anchor{345}
 @section @code{GNAT.Ctrl_C} (@code{g-ctrl_c.ads})
 
 
@@ -24240,7 +23847,7 @@ of a partition).
 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{343}@anchor{gnat_rm/the_gnat_library id56}@anchor{344}
+@anchor{gnat_rm/the_gnat_library gnat-current-exception-g-curexc-ads}@anchor{346}@anchor{gnat_rm/the_gnat_library id56}@anchor{347}
 @section @code{GNAT.Current_Exception} (@code{g-curexc.ads})
 
 
@@ -24257,7 +23864,7 @@ This is particularly useful in simulating typical facilities for
 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{345}@anchor{gnat_rm/the_gnat_library id57}@anchor{346}
+@anchor{gnat_rm/the_gnat_library gnat-debug-pools-g-debpoo-ads}@anchor{348}@anchor{gnat_rm/the_gnat_library id57}@anchor{349}
 @section @code{GNAT.Debug_Pools} (@code{g-debpoo.ads})
 
 
@@ -24274,7 +23881,7 @@ problems.
 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{347}@anchor{gnat_rm/the_gnat_library id58}@anchor{348}
+@anchor{gnat_rm/the_gnat_library gnat-debug-utilities-g-debuti-ads}@anchor{34a}@anchor{gnat_rm/the_gnat_library id58}@anchor{34b}
 @section @code{GNAT.Debug_Utilities} (@code{g-debuti.ads})
 
 
@@ -24287,7 +23894,7 @@ to and from string images of address values. Supports both C and Ada formats
 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{349}@anchor{gnat_rm/the_gnat_library id59}@anchor{34a}
+@anchor{gnat_rm/the_gnat_library gnat-decode-string-g-decstr-ads}@anchor{34c}@anchor{gnat_rm/the_gnat_library id59}@anchor{34d}
 @section @code{GNAT.Decode_String} (@code{g-decstr.ads})
 
 
@@ -24311,7 +23918,7 @@ Useful in conjunction with Unicode character coding. Note there is a
 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{34b}@anchor{gnat_rm/the_gnat_library id60}@anchor{34c}
+@anchor{gnat_rm/the_gnat_library gnat-decode-utf8-string-g-deutst-ads}@anchor{34e}@anchor{gnat_rm/the_gnat_library id60}@anchor{34f}
 @section @code{GNAT.Decode_UTF8_String} (@code{g-deutst.ads})
 
 
@@ -24332,7 +23939,7 @@ preinstantiation for UTF-8. See next entry.
 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{34d}@anchor{gnat_rm/the_gnat_library id61}@anchor{34e}
+@anchor{gnat_rm/the_gnat_library gnat-directory-operations-g-dirope-ads}@anchor{350}@anchor{gnat_rm/the_gnat_library id61}@anchor{351}
 @section @code{GNAT.Directory_Operations} (@code{g-dirope.ads})
 
 
@@ -24345,7 +23952,7 @@ the current directory, making new directories, and scanning the files in a
 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{34f}@anchor{gnat_rm/the_gnat_library id62}@anchor{350}
+@anchor{gnat_rm/the_gnat_library gnat-directory-operations-iteration-g-diopit-ads}@anchor{352}@anchor{gnat_rm/the_gnat_library id62}@anchor{353}
 @section @code{GNAT.Directory_Operations.Iteration} (@code{g-diopit.ads})
 
 
@@ -24357,7 +23964,7 @@ A child unit of GNAT.Directory_Operations providing additional operations
 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{351}@anchor{gnat_rm/the_gnat_library id63}@anchor{352}
+@anchor{gnat_rm/the_gnat_library gnat-dynamic-htables-g-dynhta-ads}@anchor{354}@anchor{gnat_rm/the_gnat_library id63}@anchor{355}
 @section @code{GNAT.Dynamic_HTables} (@code{g-dynhta.ads})
 
 
@@ -24375,7 +23982,7 @@ dynamic instances of the hash table, while an instantiation of
 @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{353}@anchor{gnat_rm/the_gnat_library id64}@anchor{354}
+@anchor{gnat_rm/the_gnat_library gnat-dynamic-tables-g-dyntab-ads}@anchor{356}@anchor{gnat_rm/the_gnat_library id64}@anchor{357}
 @section @code{GNAT.Dynamic_Tables} (@code{g-dyntab.ads})
 
 
@@ -24395,7 +24002,7 @@ dynamic instances of the table, while an instantiation of
 @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{355}@anchor{gnat_rm/the_gnat_library id65}@anchor{356}
+@anchor{gnat_rm/the_gnat_library gnat-encode-string-g-encstr-ads}@anchor{358}@anchor{gnat_rm/the_gnat_library id65}@anchor{359}
 @section @code{GNAT.Encode_String} (@code{g-encstr.ads})
 
 
@@ -24417,7 +24024,7 @@ encoding method. Useful in conjunction with Unicode character coding.
 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{357}@anchor{gnat_rm/the_gnat_library id66}@anchor{358}
+@anchor{gnat_rm/the_gnat_library gnat-encode-utf8-string-g-enutst-ads}@anchor{35a}@anchor{gnat_rm/the_gnat_library id66}@anchor{35b}
 @section @code{GNAT.Encode_UTF8_String} (@code{g-enutst.ads})
 
 
@@ -24438,7 +24045,7 @@ Note there is a preinstantiation for UTF-8. See next entry.
 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{359}@anchor{gnat_rm/the_gnat_library id67}@anchor{35a}
+@anchor{gnat_rm/the_gnat_library gnat-exception-actions-g-excact-ads}@anchor{35c}@anchor{gnat_rm/the_gnat_library id67}@anchor{35d}
 @section @code{GNAT.Exception_Actions} (@code{g-excact.ads})
 
 
@@ -24451,7 +24058,7 @@ for specific exceptions, or when any exception is raised. This
 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{35b}@anchor{gnat_rm/the_gnat_library id68}@anchor{35c}
+@anchor{gnat_rm/the_gnat_library gnat-exception-traces-g-exctra-ads}@anchor{35e}@anchor{gnat_rm/the_gnat_library id68}@anchor{35f}
 @section @code{GNAT.Exception_Traces} (@code{g-exctra.ads})
 
 
@@ -24465,7 +24072,7 @@ Provides an interface allowing to control automatic output upon exception
 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{35d}@anchor{gnat_rm/the_gnat_library id69}@anchor{35e}
+@anchor{gnat_rm/the_gnat_library gnat-exceptions-g-except-ads}@anchor{360}@anchor{gnat_rm/the_gnat_library id69}@anchor{361}
 @section @code{GNAT.Exceptions} (@code{g-except.ads})
 
 
@@ -24486,7 +24093,7 @@ predefined exceptions, and for example allows raising
 @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{35f}@anchor{gnat_rm/the_gnat_library id70}@anchor{360}
+@anchor{gnat_rm/the_gnat_library gnat-expect-g-expect-ads}@anchor{362}@anchor{gnat_rm/the_gnat_library id70}@anchor{363}
 @section @code{GNAT.Expect} (@code{g-expect.ads})
 
 
@@ -24502,7 +24109,7 @@ It is not implemented for cross ports, and in particular is not
 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{361}@anchor{gnat_rm/the_gnat_library id71}@anchor{362}
+@anchor{gnat_rm/the_gnat_library gnat-expect-tty-g-exptty-ads}@anchor{364}@anchor{gnat_rm/the_gnat_library id71}@anchor{365}
 @section @code{GNAT.Expect.TTY} (@code{g-exptty.ads})
 
 
@@ -24514,7 +24121,7 @@ ports. It is not implemented for cross ports, and
 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{363}@anchor{gnat_rm/the_gnat_library id72}@anchor{364}
+@anchor{gnat_rm/the_gnat_library gnat-float-control-g-flocon-ads}@anchor{366}@anchor{gnat_rm/the_gnat_library id72}@anchor{367}
 @section @code{GNAT.Float_Control} (@code{g-flocon.ads})
 
 
@@ -24528,7 +24135,7 @@ library calls may cause this mode to be modified, and the Reset procedure
 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{365}@anchor{gnat_rm/the_gnat_library id73}@anchor{366}
+@anchor{gnat_rm/the_gnat_library gnat-formatted-string-g-forstr-ads}@anchor{368}@anchor{gnat_rm/the_gnat_library id73}@anchor{369}
 @section @code{GNAT.Formatted_String} (@code{g-forstr.ads})
 
 
@@ -24543,7 +24150,7 @@ derived from Integer, Float or enumerations as values for the
 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{367}@anchor{gnat_rm/the_gnat_library id74}@anchor{368}
+@anchor{gnat_rm/the_gnat_library gnat-generic-fast-math-functions-g-gfmafu-ads}@anchor{36a}@anchor{gnat_rm/the_gnat_library id74}@anchor{36b}
 @section @code{GNAT.Generic_Fast_Math_Functions} (@code{g-gfmafu.ads})
 
 
@@ -24561,7 +24168,7 @@ have a vector implementation that can be automatically used by the
 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{369}@anchor{gnat_rm/the_gnat_library id75}@anchor{36a}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-heasor-ads}@anchor{36c}@anchor{gnat_rm/the_gnat_library id75}@anchor{36d}
 @section @code{GNAT.Heap_Sort} (@code{g-heasor.ads})
 
 
@@ -24575,7 +24182,7 @@ access-to-procedure values.  The algorithm used is a modified heap sort
 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{36b}@anchor{gnat_rm/the_gnat_library id76}@anchor{36c}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-a-g-hesora-ads}@anchor{36e}@anchor{gnat_rm/the_gnat_library id76}@anchor{36f}
 @section @code{GNAT.Heap_Sort_A} (@code{g-hesora.ads})
 
 
@@ -24591,7 +24198,7 @@ This differs from @code{GNAT.Heap_Sort} in having a less convenient
 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{36d}@anchor{gnat_rm/the_gnat_library id77}@anchor{36e}
+@anchor{gnat_rm/the_gnat_library gnat-heap-sort-g-g-hesorg-ads}@anchor{370}@anchor{gnat_rm/the_gnat_library id77}@anchor{371}
 @section @code{GNAT.Heap_Sort_G} (@code{g-hesorg.ads})
 
 
@@ -24605,7 +24212,7 @@ if the procedures can be inlined, at the expense of duplicating code for
 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{36f}@anchor{gnat_rm/the_gnat_library id78}@anchor{370}
+@anchor{gnat_rm/the_gnat_library gnat-htable-g-htable-ads}@anchor{372}@anchor{gnat_rm/the_gnat_library id78}@anchor{373}
 @section @code{GNAT.HTable} (@code{g-htable.ads})
 
 
@@ -24618,7 +24225,7 @@ data.  Provides two approaches, one a simple static approach, and the other
 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{371}@anchor{gnat_rm/the_gnat_library id79}@anchor{372}
+@anchor{gnat_rm/the_gnat_library gnat-io-g-io-ads}@anchor{374}@anchor{gnat_rm/the_gnat_library id79}@anchor{375}
 @section @code{GNAT.IO} (@code{g-io.ads})
 
 
@@ -24634,7 +24241,7 @@ Standard_Input, and writing characters, strings and integers to either
 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{373}@anchor{gnat_rm/the_gnat_library id80}@anchor{374}
+@anchor{gnat_rm/the_gnat_library gnat-io-aux-g-io-aux-ads}@anchor{376}@anchor{gnat_rm/the_gnat_library id80}@anchor{377}
 @section @code{GNAT.IO_Aux} (@code{g-io_aux.ads})
 
 
@@ -24648,7 +24255,7 @@ Provides some auxiliary functions for use with Text_IO, including a test
 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{375}@anchor{gnat_rm/the_gnat_library id81}@anchor{376}
+@anchor{gnat_rm/the_gnat_library gnat-lock-files-g-locfil-ads}@anchor{378}@anchor{gnat_rm/the_gnat_library id81}@anchor{379}
 @section @code{GNAT.Lock_Files} (@code{g-locfil.ads})
 
 
@@ -24662,7 +24269,7 @@ Provides a general interface for using files as locks.  Can be used for
 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{377}@anchor{gnat_rm/the_gnat_library id82}@anchor{378}
+@anchor{gnat_rm/the_gnat_library gnat-mbbs-discrete-random-g-mbdira-ads}@anchor{37a}@anchor{gnat_rm/the_gnat_library id82}@anchor{37b}
 @section @code{GNAT.MBBS_Discrete_Random} (@code{g-mbdira.ads})
 
 
@@ -24674,7 +24281,7 @@ The original implementation of @code{Ada.Numerics.Discrete_Random}.  Uses
 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{379}@anchor{gnat_rm/the_gnat_library id83}@anchor{37a}
+@anchor{gnat_rm/the_gnat_library gnat-mbbs-float-random-g-mbflra-ads}@anchor{37c}@anchor{gnat_rm/the_gnat_library id83}@anchor{37d}
 @section @code{GNAT.MBBS_Float_Random} (@code{g-mbflra.ads})
 
 
@@ -24686,7 +24293,7 @@ The original implementation of @code{Ada.Numerics.Float_Random}.  Uses
 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{37b}@anchor{gnat_rm/the_gnat_library id84}@anchor{37c}
+@anchor{gnat_rm/the_gnat_library gnat-md5-g-md5-ads}@anchor{37e}@anchor{gnat_rm/the_gnat_library id84}@anchor{37f}
 @section @code{GNAT.MD5} (@code{g-md5.ads})
 
 
@@ -24699,7 +24306,7 @@ the HMAC-MD5 message authentication function as described in RFC 2104 and
 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{37d}@anchor{gnat_rm/the_gnat_library id85}@anchor{37e}
+@anchor{gnat_rm/the_gnat_library gnat-memory-dump-g-memdum-ads}@anchor{380}@anchor{gnat_rm/the_gnat_library id85}@anchor{381}
 @section @code{GNAT.Memory_Dump} (@code{g-memdum.ads})
 
 
@@ -24712,7 +24319,7 @@ standard output or standard error files. Uses GNAT.IO for actual
 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{37f}@anchor{gnat_rm/the_gnat_library id86}@anchor{380}
+@anchor{gnat_rm/the_gnat_library gnat-most-recent-exception-g-moreex-ads}@anchor{382}@anchor{gnat_rm/the_gnat_library id86}@anchor{383}
 @section @code{GNAT.Most_Recent_Exception} (@code{g-moreex.ads})
 
 
@@ -24726,7 +24333,7 @@ various logging purposes, including duplicating functionality of some
 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{381}@anchor{gnat_rm/the_gnat_library id87}@anchor{382}
+@anchor{gnat_rm/the_gnat_library gnat-os-lib-g-os-lib-ads}@anchor{384}@anchor{gnat_rm/the_gnat_library id87}@anchor{385}
 @section @code{GNAT.OS_Lib} (@code{g-os_lib.ads})
 
 
@@ -24742,7 +24349,7 @@ including a portable spawn procedure, and access to environment variables
 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{383}@anchor{gnat_rm/the_gnat_library id88}@anchor{384}
+@anchor{gnat_rm/the_gnat_library gnat-perfect-hash-generators-g-pehage-ads}@anchor{386}@anchor{gnat_rm/the_gnat_library id88}@anchor{387}
 @section @code{GNAT.Perfect_Hash_Generators} (@code{g-pehage.ads})
 
 
@@ -24760,7 +24367,7 @@ hashcode are in the same order. These hashing functions are very
 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{385}@anchor{gnat_rm/the_gnat_library id89}@anchor{386}
+@anchor{gnat_rm/the_gnat_library gnat-random-numbers-g-rannum-ads}@anchor{388}@anchor{gnat_rm/the_gnat_library id89}@anchor{389}
 @section @code{GNAT.Random_Numbers} (@code{g-rannum.ads})
 
 
@@ -24772,7 +24379,7 @@ Provides random number capabilities which extend those available in the
 standard Ada library and are more convenient to use.
 
 @node GNAT Regexp g-regexp ads,GNAT Registry g-regist ads,GNAT Random_Numbers g-rannum ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library gnat-regexp-g-regexp-ads}@anchor{25c}@anchor{gnat_rm/the_gnat_library id90}@anchor{387}
+@anchor{gnat_rm/the_gnat_library gnat-regexp-g-regexp-ads}@anchor{25f}@anchor{gnat_rm/the_gnat_library id90}@anchor{38a}
 @section @code{GNAT.Regexp} (@code{g-regexp.ads})
 
 
@@ -24788,7 +24395,7 @@ simplest of the three pattern matching packages provided, and is particularly
 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{388}@anchor{gnat_rm/the_gnat_library id91}@anchor{389}
+@anchor{gnat_rm/the_gnat_library gnat-registry-g-regist-ads}@anchor{38b}@anchor{gnat_rm/the_gnat_library id91}@anchor{38c}
 @section @code{GNAT.Registry} (@code{g-regist.ads})
 
 
@@ -24802,7 +24409,7 @@ registry API, but at a lower level of abstraction, refer to the Win32.Winreg
 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{38a}@anchor{gnat_rm/the_gnat_library id92}@anchor{38b}
+@anchor{gnat_rm/the_gnat_library gnat-regpat-g-regpat-ads}@anchor{38d}@anchor{gnat_rm/the_gnat_library id92}@anchor{38e}
 @section @code{GNAT.Regpat} (@code{g-regpat.ads})
 
 
@@ -24817,7 +24424,7 @@ from the original V7 style regular expression library written in C by
 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{38c}@anchor{gnat_rm/the_gnat_library id93}@anchor{38d}
+@anchor{gnat_rm/the_gnat_library gnat-rewrite-data-g-rewdat-ads}@anchor{38f}@anchor{gnat_rm/the_gnat_library id93}@anchor{390}
 @section @code{GNAT.Rewrite_Data} (@code{g-rewdat.ads})
 
 
@@ -24831,7 +24438,7 @@ full content to be processed is not loaded into memory all at once. This makes
 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{38e}@anchor{gnat_rm/the_gnat_library id94}@anchor{38f}
+@anchor{gnat_rm/the_gnat_library gnat-secondary-stack-info-g-sestin-ads}@anchor{391}@anchor{gnat_rm/the_gnat_library id94}@anchor{392}
 @section @code{GNAT.Secondary_Stack_Info} (@code{g-sestin.ads})
 
 
@@ -24843,7 +24450,7 @@ Provides the capability to query the high water mark of the current task’s
 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{390}@anchor{gnat_rm/the_gnat_library id95}@anchor{391}
+@anchor{gnat_rm/the_gnat_library gnat-semaphores-g-semaph-ads}@anchor{393}@anchor{gnat_rm/the_gnat_library id95}@anchor{394}
 @section @code{GNAT.Semaphores} (@code{g-semaph.ads})
 
 
@@ -24854,7 +24461,7 @@ secondary stack.
 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{392}@anchor{gnat_rm/the_gnat_library id96}@anchor{393}
+@anchor{gnat_rm/the_gnat_library gnat-serial-communications-g-sercom-ads}@anchor{395}@anchor{gnat_rm/the_gnat_library id96}@anchor{396}
 @section @code{GNAT.Serial_Communications} (@code{g-sercom.ads})
 
 
@@ -24866,7 +24473,7 @@ Provides a simple interface to send and receive data over a serial
 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{394}@anchor{gnat_rm/the_gnat_library id97}@anchor{395}
+@anchor{gnat_rm/the_gnat_library gnat-sha1-g-sha1-ads}@anchor{397}@anchor{gnat_rm/the_gnat_library id97}@anchor{398}
 @section @code{GNAT.SHA1} (@code{g-sha1.ads})
 
 
@@ -24879,7 +24486,7 @@ and RFC 3174, and the HMAC-SHA1 message authentication function as described
 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{396}@anchor{gnat_rm/the_gnat_library id98}@anchor{397}
+@anchor{gnat_rm/the_gnat_library gnat-sha224-g-sha224-ads}@anchor{399}@anchor{gnat_rm/the_gnat_library id98}@anchor{39a}
 @section @code{GNAT.SHA224} (@code{g-sha224.ads})
 
 
@@ -24892,7 +24499,7 @@ and the HMAC-SHA224 message authentication function as described
 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{398}@anchor{gnat_rm/the_gnat_library id99}@anchor{399}
+@anchor{gnat_rm/the_gnat_library gnat-sha256-g-sha256-ads}@anchor{39b}@anchor{gnat_rm/the_gnat_library id99}@anchor{39c}
 @section @code{GNAT.SHA256} (@code{g-sha256.ads})
 
 
@@ -24905,7 +24512,7 @@ and the HMAC-SHA256 message authentication function as described
 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{39a}@anchor{gnat_rm/the_gnat_library id100}@anchor{39b}
+@anchor{gnat_rm/the_gnat_library gnat-sha384-g-sha384-ads}@anchor{39d}@anchor{gnat_rm/the_gnat_library id100}@anchor{39e}
 @section @code{GNAT.SHA384} (@code{g-sha384.ads})
 
 
@@ -24918,7 +24525,7 @@ and the HMAC-SHA384 message authentication function as described
 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{39c}@anchor{gnat_rm/the_gnat_library id101}@anchor{39d}
+@anchor{gnat_rm/the_gnat_library gnat-sha512-g-sha512-ads}@anchor{39f}@anchor{gnat_rm/the_gnat_library id101}@anchor{3a0}
 @section @code{GNAT.SHA512} (@code{g-sha512.ads})
 
 
@@ -24931,7 +24538,7 @@ and the HMAC-SHA512 message authentication function as described
 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{39e}@anchor{gnat_rm/the_gnat_library id102}@anchor{39f}
+@anchor{gnat_rm/the_gnat_library gnat-signals-g-signal-ads}@anchor{3a1}@anchor{gnat_rm/the_gnat_library id102}@anchor{3a2}
 @section @code{GNAT.Signals} (@code{g-signal.ads})
 
 
@@ -24943,7 +24550,7 @@ Provides the ability to manipulate the blocked status of signals on supported
 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{3a0}@anchor{gnat_rm/the_gnat_library id103}@anchor{3a1}
+@anchor{gnat_rm/the_gnat_library gnat-sockets-g-socket-ads}@anchor{3a3}@anchor{gnat_rm/the_gnat_library id103}@anchor{3a4}
 @section @code{GNAT.Sockets} (@code{g-socket.ads})
 
 
@@ -24958,7 +24565,7 @@ on all native GNAT ports and on VxWorks cross ports.  It is not implemented for
 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{3a2}@anchor{gnat_rm/the_gnat_library id104}@anchor{3a3}
+@anchor{gnat_rm/the_gnat_library gnat-source-info-g-souinf-ads}@anchor{3a5}@anchor{gnat_rm/the_gnat_library id104}@anchor{3a6}
 @section @code{GNAT.Source_Info} (@code{g-souinf.ads})
 
 
@@ -24972,7 +24579,7 @@ subprograms yielding the date and time of the current compilation (like the
 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{3a4}@anchor{gnat_rm/the_gnat_library id105}@anchor{3a5}
+@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-g-speche-ads}@anchor{3a7}@anchor{gnat_rm/the_gnat_library id105}@anchor{3a8}
 @section @code{GNAT.Spelling_Checker} (@code{g-speche.ads})
 
 
@@ -24984,7 +24591,7 @@ Provides a function for determining whether one string is a plausible
 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{3a6}@anchor{gnat_rm/the_gnat_library id106}@anchor{3a7}
+@anchor{gnat_rm/the_gnat_library gnat-spelling-checker-generic-g-spchge-ads}@anchor{3a9}@anchor{gnat_rm/the_gnat_library id106}@anchor{3aa}
 @section @code{GNAT.Spelling_Checker_Generic} (@code{g-spchge.ads})
 
 
@@ -24997,7 +24604,7 @@ determining whether one string is a plausible near misspelling of another
 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{3a8}@anchor{gnat_rm/the_gnat_library id107}@anchor{3a9}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-patterns-g-spipat-ads}@anchor{3ab}@anchor{gnat_rm/the_gnat_library id107}@anchor{3ac}
 @section @code{GNAT.Spitbol.Patterns} (@code{g-spipat.ads})
 
 
@@ -25013,7 +24620,7 @@ the SNOBOL4 dynamic pattern construction and matching capabilities, using the
 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{3aa}@anchor{gnat_rm/the_gnat_library id108}@anchor{3ab}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-g-spitbo-ads}@anchor{3ad}@anchor{gnat_rm/the_gnat_library id108}@anchor{3ae}
 @section @code{GNAT.Spitbol} (@code{g-spitbo.ads})
 
 
@@ -25028,7 +24635,7 @@ useful for constructing arbitrary mappings from strings in the style of
 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{3ac}@anchor{gnat_rm/the_gnat_library id109}@anchor{3ad}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-boolean-g-sptabo-ads}@anchor{3af}@anchor{gnat_rm/the_gnat_library id109}@anchor{3b0}
 @section @code{GNAT.Spitbol.Table_Boolean} (@code{g-sptabo.ads})
 
 
@@ -25043,7 +24650,7 @@ for type @code{Standard.Boolean}, giving an implementation of sets of
 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{3ae}@anchor{gnat_rm/the_gnat_library id110}@anchor{3af}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-integer-g-sptain-ads}@anchor{3b1}@anchor{gnat_rm/the_gnat_library id110}@anchor{3b2}
 @section @code{GNAT.Spitbol.Table_Integer} (@code{g-sptain.ads})
 
 
@@ -25060,7 +24667,7 @@ for type @code{Standard.Integer}, giving an implementation of maps
 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{3b0}@anchor{gnat_rm/the_gnat_library id111}@anchor{3b1}
+@anchor{gnat_rm/the_gnat_library gnat-spitbol-table-vstring-g-sptavs-ads}@anchor{3b3}@anchor{gnat_rm/the_gnat_library id111}@anchor{3b4}
 @section @code{GNAT.Spitbol.Table_VString} (@code{g-sptavs.ads})
 
 
@@ -25077,7 +24684,7 @@ a variable length string type, giving an implementation of general
 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{3b2}@anchor{gnat_rm/the_gnat_library id112}@anchor{3b3}
+@anchor{gnat_rm/the_gnat_library gnat-sse-g-sse-ads}@anchor{3b5}@anchor{gnat_rm/the_gnat_library id112}@anchor{3b6}
 @section @code{GNAT.SSE} (@code{g-sse.ads})
 
 
@@ -25089,7 +24696,7 @@ targets.  It exposes vector component types together with a general
 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{3b4}@anchor{gnat_rm/the_gnat_library id113}@anchor{3b5}
+@anchor{gnat_rm/the_gnat_library gnat-sse-vector-types-g-ssvety-ads}@anchor{3b7}@anchor{gnat_rm/the_gnat_library id113}@anchor{3b8}
 @section @code{GNAT.SSE.Vector_Types} (@code{g-ssvety.ads})
 
 
@@ -25098,7 +24705,7 @@ introduction to the binding contents and use.
 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{3b6}@anchor{gnat_rm/the_gnat_library id114}@anchor{3b7}
+@anchor{gnat_rm/the_gnat_library gnat-string-hash-g-strhas-ads}@anchor{3b9}@anchor{gnat_rm/the_gnat_library id114}@anchor{3ba}
 @section @code{GNAT.String_Hash} (@code{g-strhas.ads})
 
 
@@ -25110,7 +24717,7 @@ Provides a generic hash function working on arrays of scalars. Both the scalar
 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{3b8}@anchor{gnat_rm/the_gnat_library id115}@anchor{3b9}
+@anchor{gnat_rm/the_gnat_library gnat-strings-g-string-ads}@anchor{3bb}@anchor{gnat_rm/the_gnat_library id115}@anchor{3bc}
 @section @code{GNAT.Strings} (@code{g-string.ads})
 
 
@@ -25120,7 +24727,7 @@ Common String access types and related subprograms. Basically it
 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{3ba}@anchor{gnat_rm/the_gnat_library id116}@anchor{3bb}
+@anchor{gnat_rm/the_gnat_library gnat-string-split-g-strspl-ads}@anchor{3bd}@anchor{gnat_rm/the_gnat_library id116}@anchor{3be}
 @section @code{GNAT.String_Split} (@code{g-strspl.ads})
 
 
@@ -25134,7 +24741,7 @@ to the resulting slices. This package is instantiated from
 @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{3bc}@anchor{gnat_rm/the_gnat_library id117}@anchor{3bd}
+@anchor{gnat_rm/the_gnat_library gnat-table-g-table-ads}@anchor{3bf}@anchor{gnat_rm/the_gnat_library id117}@anchor{3c0}
 @section @code{GNAT.Table} (@code{g-table.ads})
 
 
@@ -25154,7 +24761,7 @@ while an instantiation of @code{GNAT.Dynamic_Tables} creates a type that can be
 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{3be}@anchor{gnat_rm/the_gnat_library id118}@anchor{3bf}
+@anchor{gnat_rm/the_gnat_library gnat-task-lock-g-tasloc-ads}@anchor{3c1}@anchor{gnat_rm/the_gnat_library id118}@anchor{3c2}
 @section @code{GNAT.Task_Lock} (@code{g-tasloc.ads})
 
 
@@ -25171,7 +24778,7 @@ single global task lock.  Appropriate for use in situations where contention
 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{3c0}@anchor{gnat_rm/the_gnat_library id119}@anchor{3c1}
+@anchor{gnat_rm/the_gnat_library gnat-time-stamp-g-timsta-ads}@anchor{3c3}@anchor{gnat_rm/the_gnat_library id119}@anchor{3c4}
 @section @code{GNAT.Time_Stamp} (@code{g-timsta.ads})
 
 
@@ -25186,7 +24793,7 @@ represents the current date and time in ISO 8601 format. This is a very simple
 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{3c2}@anchor{gnat_rm/the_gnat_library id120}@anchor{3c3}
+@anchor{gnat_rm/the_gnat_library gnat-threads-g-thread-ads}@anchor{3c5}@anchor{gnat_rm/the_gnat_library id120}@anchor{3c6}
 @section @code{GNAT.Threads} (@code{g-thread.ads})
 
 
@@ -25203,7 +24810,7 @@ further details if your program has threads that are created by a non-Ada
 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{3c4}@anchor{gnat_rm/the_gnat_library id121}@anchor{3c5}
+@anchor{gnat_rm/the_gnat_library gnat-traceback-g-traceb-ads}@anchor{3c7}@anchor{gnat_rm/the_gnat_library id121}@anchor{3c8}
 @section @code{GNAT.Traceback} (@code{g-traceb.ads})
 
 
@@ -25215,7 +24822,7 @@ Provides a facility for obtaining non-symbolic traceback information, useful
 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{3c6}@anchor{gnat_rm/the_gnat_library id122}@anchor{3c7}
+@anchor{gnat_rm/the_gnat_library gnat-traceback-symbolic-g-trasym-ads}@anchor{3c9}@anchor{gnat_rm/the_gnat_library id122}@anchor{3ca}
 @section @code{GNAT.Traceback.Symbolic} (@code{g-trasym.ads})
 
 
@@ -25224,7 +24831,7 @@ in various debugging situations.
 @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{3c8}@anchor{gnat_rm/the_gnat_library id123}@anchor{3c9}
+@anchor{gnat_rm/the_gnat_library gnat-utf-32-g-utf-32-ads}@anchor{3cb}@anchor{gnat_rm/the_gnat_library id123}@anchor{3cc}
 @section @code{GNAT.UTF_32} (@code{g-utf_32.ads})
 
 
@@ -25243,7 +24850,7 @@ lower case to upper case fold routine corresponding to
 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{3ca}@anchor{gnat_rm/the_gnat_library id124}@anchor{3cb}
+@anchor{gnat_rm/the_gnat_library gnat-utf-32-spelling-checker-g-u3spch-ads}@anchor{3cd}@anchor{gnat_rm/the_gnat_library id124}@anchor{3ce}
 @section @code{GNAT.UTF_32_Spelling_Checker} (@code{g-u3spch.ads})
 
 
@@ -25256,7 +24863,7 @@ near misspelling of another wide wide string, where the strings are represented
 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{3cc}@anchor{gnat_rm/the_gnat_library id125}@anchor{3cd}
+@anchor{gnat_rm/the_gnat_library gnat-wide-spelling-checker-g-wispch-ads}@anchor{3cf}@anchor{gnat_rm/the_gnat_library id125}@anchor{3d0}
 @section @code{GNAT.Wide_Spelling_Checker} (@code{g-wispch.ads})
 
 
@@ -25268,7 +24875,7 @@ Provides a function for determining whether one wide string is a plausible
 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{3ce}@anchor{gnat_rm/the_gnat_library id126}@anchor{3cf}
+@anchor{gnat_rm/the_gnat_library gnat-wide-string-split-g-wistsp-ads}@anchor{3d1}@anchor{gnat_rm/the_gnat_library id126}@anchor{3d2}
 @section @code{GNAT.Wide_String_Split} (@code{g-wistsp.ads})
 
 
@@ -25282,7 +24889,7 @@ to the resulting slices. This package is instantiated from
 @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{3d0}@anchor{gnat_rm/the_gnat_library id127}@anchor{3d1}
+@anchor{gnat_rm/the_gnat_library gnat-wide-wide-spelling-checker-g-zspche-ads}@anchor{3d3}@anchor{gnat_rm/the_gnat_library id127}@anchor{3d4}
 @section @code{GNAT.Wide_Wide_Spelling_Checker} (@code{g-zspche.ads})
 
 
@@ -25294,7 +24901,7 @@ Provides a function for determining whether one wide wide string is a plausible
 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{3d2}@anchor{gnat_rm/the_gnat_library id128}@anchor{3d3}
+@anchor{gnat_rm/the_gnat_library gnat-wide-wide-string-split-g-zistsp-ads}@anchor{3d5}@anchor{gnat_rm/the_gnat_library id128}@anchor{3d6}
 @section @code{GNAT.Wide_Wide_String_Split} (@code{g-zistsp.ads})
 
 
@@ -25308,7 +24915,7 @@ to the resulting slices. This package is instantiated from
 @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{3d4}@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3d5}
+@anchor{gnat_rm/the_gnat_library id129}@anchor{3d7}@anchor{gnat_rm/the_gnat_library interfaces-c-extensions-i-cexten-ads}@anchor{3d8}
 @section @code{Interfaces.C.Extensions} (@code{i-cexten.ads})
 
 
@@ -25319,7 +24926,7 @@ for use with either manually or automatically generated bindings
 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{3d6}@anchor{gnat_rm/the_gnat_library interfaces-c-streams-i-cstrea-ads}@anchor{3d7}
+@anchor{gnat_rm/the_gnat_library id130}@anchor{3d9}@anchor{gnat_rm/the_gnat_library interfaces-c-streams-i-cstrea-ads}@anchor{3da}
 @section @code{Interfaces.C.Streams} (@code{i-cstrea.ads})
 
 
@@ -25332,7 +24939,7 @@ This package is a binding for the most commonly used operations
 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{3d8}@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3d9}
+@anchor{gnat_rm/the_gnat_library id131}@anchor{3db}@anchor{gnat_rm/the_gnat_library interfaces-packed-decimal-i-pacdec-ads}@anchor{3dc}
 @section @code{Interfaces.Packed_Decimal} (@code{i-pacdec.ads})
 
 
@@ -25347,7 +24954,7 @@ from a packed decimal format compatible with that used on IBM
 mainframes.
 
 @node Interfaces VxWorks i-vxwork ads,Interfaces VxWorks Int_Connection i-vxinco ads,Interfaces Packed_Decimal i-pacdec ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id132}@anchor{3da}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3db}
+@anchor{gnat_rm/the_gnat_library id132}@anchor{3dd}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-i-vxwork-ads}@anchor{3de}
 @section @code{Interfaces.VxWorks} (@code{i-vxwork.ads})
 
 
@@ -25363,7 +24970,7 @@ In particular, it interfaces with the
 VxWorks hardware interrupt facilities.
 
 @node Interfaces VxWorks Int_Connection i-vxinco ads,Interfaces VxWorks IO i-vxwoio ads,Interfaces VxWorks i-vxwork ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id133}@anchor{3dc}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-int-connection-i-vxinco-ads}@anchor{3dd}
+@anchor{gnat_rm/the_gnat_library id133}@anchor{3df}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-int-connection-i-vxinco-ads}@anchor{3e0}
 @section @code{Interfaces.VxWorks.Int_Connection} (@code{i-vxinco.ads})
 
 
@@ -25379,7 +24986,7 @@ intConnect() with a custom routine for installing interrupt
 handlers.
 
 @node Interfaces VxWorks IO i-vxwoio ads,System Address_Image s-addima ads,Interfaces VxWorks Int_Connection i-vxinco ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id134}@anchor{3de}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3df}
+@anchor{gnat_rm/the_gnat_library id134}@anchor{3e1}@anchor{gnat_rm/the_gnat_library interfaces-vxworks-io-i-vxwoio-ads}@anchor{3e2}
 @section @code{Interfaces.VxWorks.IO} (@code{i-vxwoio.ads})
 
 
@@ -25402,7 +25009,7 @@ function codes. A particular use of this package is
 to enable the use of Get_Immediate under VxWorks.
 
 @node System Address_Image s-addima ads,System Assertions s-assert ads,Interfaces VxWorks IO i-vxwoio ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id135}@anchor{3e0}@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3e1}
+@anchor{gnat_rm/the_gnat_library id135}@anchor{3e3}@anchor{gnat_rm/the_gnat_library system-address-image-s-addima-ads}@anchor{3e4}
 @section @code{System.Address_Image} (@code{s-addima.ads})
 
 
@@ -25418,7 +25025,7 @@ function that gives an (implementation dependent)
 string which identifies an address.
 
 @node System Assertions s-assert ads,System Atomic_Counters s-atocou ads,System Address_Image s-addima ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id136}@anchor{3e2}@anchor{gnat_rm/the_gnat_library system-assertions-s-assert-ads}@anchor{3e3}
+@anchor{gnat_rm/the_gnat_library id136}@anchor{3e5}@anchor{gnat_rm/the_gnat_library system-assertions-s-assert-ads}@anchor{3e6}
 @section @code{System.Assertions} (@code{s-assert.ads})
 
 
@@ -25434,7 +25041,7 @@ by an run-time assertion failure, as well as the routine that
 is used internally to raise this assertion.
 
 @node System Atomic_Counters s-atocou ads,System Memory s-memory ads,System Assertions s-assert ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id137}@anchor{3e4}@anchor{gnat_rm/the_gnat_library system-atomic-counters-s-atocou-ads}@anchor{3e5}
+@anchor{gnat_rm/the_gnat_library id137}@anchor{3e7}@anchor{gnat_rm/the_gnat_library system-atomic-counters-s-atocou-ads}@anchor{3e8}
 @section @code{System.Atomic_Counters} (@code{s-atocou.ads})
 
 
@@ -25448,7 +25055,7 @@ on most targets, including all Alpha, AARCH64, ARM, ia64, PowerPC, SPARC V9,
 x86, and x86_64 platforms.
 
 @node System Memory s-memory ads,System Multiprocessors s-multip ads,System Atomic_Counters s-atocou ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id138}@anchor{3e6}@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{3e7}
+@anchor{gnat_rm/the_gnat_library id138}@anchor{3e9}@anchor{gnat_rm/the_gnat_library system-memory-s-memory-ads}@anchor{3ea}
 @section @code{System.Memory} (@code{s-memory.ads})
 
 
@@ -25466,7 +25073,7 @@ calls to this unit may be made for low level allocation uses (for
 example see the body of @code{GNAT.Tables}).
 
 @node System Multiprocessors s-multip ads,System Multiprocessors Dispatching_Domains s-mudido ads,System Memory s-memory ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id139}@anchor{3e8}@anchor{gnat_rm/the_gnat_library system-multiprocessors-s-multip-ads}@anchor{3e9}
+@anchor{gnat_rm/the_gnat_library id139}@anchor{3eb}@anchor{gnat_rm/the_gnat_library system-multiprocessors-s-multip-ads}@anchor{3ec}
 @section @code{System.Multiprocessors} (@code{s-multip.ads})
 
 
@@ -25479,7 +25086,7 @@ in GNAT we also make it available in Ada 95 and Ada 2005 (where it is
 technically an implementation-defined addition).
 
 @node System Multiprocessors Dispatching_Domains s-mudido ads,System Partition_Interface s-parint ads,System Multiprocessors s-multip ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id140}@anchor{3ea}@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{3eb}
+@anchor{gnat_rm/the_gnat_library id140}@anchor{3ed}@anchor{gnat_rm/the_gnat_library system-multiprocessors-dispatching-domains-s-mudido-ads}@anchor{3ee}
 @section @code{System.Multiprocessors.Dispatching_Domains} (@code{s-mudido.ads})
 
 
@@ -25492,7 +25099,7 @@ in GNAT we also make it available in Ada 95 and Ada 2005 (where it is
 technically an implementation-defined addition).
 
 @node System Partition_Interface s-parint ads,System Pool_Global s-pooglo ads,System Multiprocessors Dispatching_Domains s-mudido ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id141}@anchor{3ec}@anchor{gnat_rm/the_gnat_library system-partition-interface-s-parint-ads}@anchor{3ed}
+@anchor{gnat_rm/the_gnat_library id141}@anchor{3ef}@anchor{gnat_rm/the_gnat_library system-partition-interface-s-parint-ads}@anchor{3f0}
 @section @code{System.Partition_Interface} (@code{s-parint.ads})
 
 
@@ -25505,7 +25112,7 @@ is used primarily in a distribution context when using Annex E
 with @code{GLADE}.
 
 @node System Pool_Global s-pooglo ads,System Pool_Local s-pooloc ads,System Partition_Interface s-parint ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id142}@anchor{3ee}@anchor{gnat_rm/the_gnat_library system-pool-global-s-pooglo-ads}@anchor{3ef}
+@anchor{gnat_rm/the_gnat_library id142}@anchor{3f1}@anchor{gnat_rm/the_gnat_library system-pool-global-s-pooglo-ads}@anchor{3f2}
 @section @code{System.Pool_Global} (@code{s-pooglo.ads})
 
 
@@ -25522,7 +25129,7 @@ declared. It uses malloc/free to allocate/free and does not attempt to
 do any automatic reclamation.
 
 @node System Pool_Local s-pooloc ads,System Restrictions s-restri ads,System Pool_Global s-pooglo ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id143}@anchor{3f0}@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{3f1}
+@anchor{gnat_rm/the_gnat_library id143}@anchor{3f3}@anchor{gnat_rm/the_gnat_library system-pool-local-s-pooloc-ads}@anchor{3f4}
 @section @code{System.Pool_Local} (@code{s-pooloc.ads})
 
 
@@ -25539,7 +25146,7 @@ a list of allocated blocks, so that all storage allocated for the pool can
 be freed automatically when the pool is finalized.
 
 @node System Restrictions s-restri ads,System Rident s-rident ads,System Pool_Local s-pooloc ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id144}@anchor{3f2}@anchor{gnat_rm/the_gnat_library system-restrictions-s-restri-ads}@anchor{3f3}
+@anchor{gnat_rm/the_gnat_library id144}@anchor{3f5}@anchor{gnat_rm/the_gnat_library system-restrictions-s-restri-ads}@anchor{3f6}
 @section @code{System.Restrictions} (@code{s-restri.ads})
 
 
@@ -25555,7 +25162,7 @@ compiler determined information on which restrictions
 are violated by one or more packages in the partition.
 
 @node System Rident s-rident ads,System Strings Stream_Ops s-ststop ads,System Restrictions s-restri ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id145}@anchor{3f4}@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{3f5}
+@anchor{gnat_rm/the_gnat_library id145}@anchor{3f7}@anchor{gnat_rm/the_gnat_library system-rident-s-rident-ads}@anchor{3f8}
 @section @code{System.Rident} (@code{s-rident.ads})
 
 
@@ -25571,7 +25178,7 @@ since the necessary instantiation is included in
 package System.Restrictions.
 
 @node System Strings Stream_Ops s-ststop ads,System Unsigned_Types s-unstyp ads,System Rident s-rident ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id146}@anchor{3f6}@anchor{gnat_rm/the_gnat_library system-strings-stream-ops-s-ststop-ads}@anchor{3f7}
+@anchor{gnat_rm/the_gnat_library id146}@anchor{3f9}@anchor{gnat_rm/the_gnat_library system-strings-stream-ops-s-ststop-ads}@anchor{3fa}
 @section @code{System.Strings.Stream_Ops} (@code{s-ststop.ads})
 
 
@@ -25587,7 +25194,7 @@ stream attributes are applied to string types, but the subprograms in this
 package can be used directly by application programs.
 
 @node System Unsigned_Types s-unstyp ads,System Wch_Cnv s-wchcnv ads,System Strings Stream_Ops s-ststop ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id147}@anchor{3f8}@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{3f9}
+@anchor{gnat_rm/the_gnat_library id147}@anchor{3fb}@anchor{gnat_rm/the_gnat_library system-unsigned-types-s-unstyp-ads}@anchor{3fc}
 @section @code{System.Unsigned_Types} (@code{s-unstyp.ads})
 
 
@@ -25600,7 +25207,7 @@ also contains some related definitions for other specialized types
 used by the compiler in connection with packed array types.
 
 @node System Wch_Cnv s-wchcnv ads,System Wch_Con s-wchcon ads,System Unsigned_Types s-unstyp ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id148}@anchor{3fa}@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{3fb}
+@anchor{gnat_rm/the_gnat_library id148}@anchor{3fd}@anchor{gnat_rm/the_gnat_library system-wch-cnv-s-wchcnv-ads}@anchor{3fe}
 @section @code{System.Wch_Cnv} (@code{s-wchcnv.ads})
 
 
@@ -25621,7 +25228,7 @@ encoding method.  It uses definitions in
 package @code{System.Wch_Con}.
 
 @node System Wch_Con s-wchcon ads,,System Wch_Cnv s-wchcnv ads,The GNAT Library
-@anchor{gnat_rm/the_gnat_library id149}@anchor{3fc}@anchor{gnat_rm/the_gnat_library system-wch-con-s-wchcon-ads}@anchor{3fd}
+@anchor{gnat_rm/the_gnat_library id149}@anchor{3ff}@anchor{gnat_rm/the_gnat_library system-wch-con-s-wchcon-ads}@anchor{400}
 @section @code{System.Wch_Con} (@code{s-wchcon.ads})
 
 
@@ -25633,7 +25240,7 @@ in ordinary strings.  These definitions are used by
 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{3fe}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{3ff}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-other-languages}@anchor{11}
+@anchor{gnat_rm/interfacing_to_other_languages doc}@anchor{401}@anchor{gnat_rm/interfacing_to_other_languages id1}@anchor{402}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-other-languages}@anchor{11}
 @chapter Interfacing to Other Languages
 
 
@@ -25651,7 +25258,7 @@ provided.
 @end menu
 
 @node Interfacing to C,Interfacing to C++,,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id2}@anchor{400}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{401}
+@anchor{gnat_rm/interfacing_to_other_languages id2}@anchor{403}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-c}@anchor{404}
 @section Interfacing to C
 
 
@@ -25791,7 +25398,7 @@ of the length corresponding to the @code{type'Size} value in Ada.
 @end itemize
 
 @node Interfacing to C++,Interfacing to COBOL,Interfacing to C,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id3}@anchor{47}@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{402}
+@anchor{gnat_rm/interfacing_to_other_languages id3}@anchor{47}@anchor{gnat_rm/interfacing_to_other_languages id4}@anchor{405}
 @section Interfacing to C++
 
 
@@ -25848,7 +25455,7 @@ The @code{External_Name} is the name of the C++ RTTI symbol. You can then
 cover a specific C++ exception in an exception handler.
 
 @node Interfacing to COBOL,Interfacing to Fortran,Interfacing to C++,Interfacing to Other Languages
-@anchor{gnat_rm/interfacing_to_other_languages id5}@anchor{403}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-cobol}@anchor{404}
+@anchor{gnat_rm/interfacing_to_other_languages id5}@anchor{406}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-cobol}@anchor{407}
 @section Interfacing to COBOL
 
 
@@ -25856,7 +25463,7 @@ Interfacing to COBOL is achieved as described in section B.4 of
 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{405}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-fortran}@anchor{406}
+@anchor{gnat_rm/interfacing_to_other_languages id6}@anchor{408}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-fortran}@anchor{409}
 @section Interfacing to Fortran
 
 
@@ -25866,7 +25473,7 @@ multi-dimensional array causes the array to be stored in column-major
 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{407}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{408}
+@anchor{gnat_rm/interfacing_to_other_languages id7}@anchor{40a}@anchor{gnat_rm/interfacing_to_other_languages interfacing-to-non-gnat-ada-code}@anchor{40b}
 @section Interfacing to non-GNAT Ada code
 
 
@@ -25890,7 +25497,7 @@ values or simple record types without variants, or simple array
 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{409}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{40a}@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}
+@anchor{gnat_rm/specialized_needs_annexes doc}@anchor{40c}@anchor{gnat_rm/specialized_needs_annexes id1}@anchor{40d}@anchor{gnat_rm/specialized_needs_annexes specialized-needs-annexes}@anchor{12}
 @chapter Specialized Needs Annexes
 
 
@@ -25931,7 +25538,7 @@ in Ada 2005) is fully implemented.
 @end table
 
 @node Implementation of Specific Ada Features,Implementation of Ada 2012 Features,Specialized Needs Annexes,Top
-@anchor{gnat_rm/implementation_of_specific_ada_features doc}@anchor{40b}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{40c}@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{40e}@anchor{gnat_rm/implementation_of_specific_ada_features id1}@anchor{40f}@anchor{gnat_rm/implementation_of_specific_ada_features implementation-of-specific-ada-features}@anchor{13}
 @chapter Implementation of Specific Ada Features
 
 
@@ -25950,7 +25557,7 @@ facilities.
 @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{40d}@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{166}
+@anchor{gnat_rm/implementation_of_specific_ada_features id2}@anchor{410}@anchor{gnat_rm/implementation_of_specific_ada_features machine-code-insertions}@anchor{169}
 @section Machine Code Insertions
 
 
@@ -26070,2790 +25677,3439 @@ private type @code{Asm_Insn}, can be used in code statements, and indeed
 this is the only context where such calls are allowed.  Code statements
 appear as aggregates of the form:
 
-@example
-Asm_Insn'(Asm (...));
-Asm_Insn'(Asm_Volatile (...));
-@end example
+@example
+Asm_Insn'(Asm (...));
+Asm_Insn'(Asm_Volatile (...));
+@end example
+
+In accordance with RM rules, such code statements are allowed only
+within subprograms whose entire body consists of such statements.  It is
+not permissible to intermix such statements with other Ada statements.
+
+Typically the form using intrinsic procedure calls is more convenient
+and more flexible.  The code statement form is provided to meet the RM
+suggestion that such a facility should be made available.  The following
+is the exact syntax of the call to @code{Asm}. As usual, if named notation
+is used, the arguments may be given in arbitrary order, following the
+normal rules for use of positional and named arguments:
+
+@example
+ASM_CALL ::= Asm (
+                 [Template =>] static_string_EXPRESSION
+               [,[Outputs  =>] OUTPUT_OPERAND_LIST      ]
+               [,[Inputs   =>] INPUT_OPERAND_LIST       ]
+               [,[Clobber  =>] static_string_EXPRESSION ]
+               [,[Volatile =>] static_boolean_EXPRESSION] )
+
+OUTPUT_OPERAND_LIST ::=
+  [PREFIX.]No_Output_Operands
+| OUTPUT_OPERAND_ATTRIBUTE
+| (OUTPUT_OPERAND_ATTRIBUTE @{,OUTPUT_OPERAND_ATTRIBUTE@})
+
+OUTPUT_OPERAND_ATTRIBUTE ::=
+  SUBTYPE_MARK'Asm_Output (static_string_EXPRESSION, NAME)
+
+INPUT_OPERAND_LIST ::=
+  [PREFIX.]No_Input_Operands
+| INPUT_OPERAND_ATTRIBUTE
+| (INPUT_OPERAND_ATTRIBUTE @{,INPUT_OPERAND_ATTRIBUTE@})
+
+INPUT_OPERAND_ATTRIBUTE ::=
+  SUBTYPE_MARK'Asm_Input (static_string_EXPRESSION, EXPRESSION)
+@end example
+
+The identifiers @code{No_Input_Operands} and @code{No_Output_Operands}
+are declared in the package @code{Machine_Code} and must be referenced
+according to normal visibility rules. In particular if there is no
+@code{use} clause for this package, then appropriate package name
+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{411}@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{412}
+@section GNAT Implementation of Tasking
+
+
+This chapter outlines the basic GNAT approach to tasking (in particular,
+a multi-layered library for portability) and discusses issues related
+to compliance with the Real-Time Systems Annex.
+
+@menu
+* Mapping Ada Tasks onto the Underlying Kernel Threads:: 
+* Ensuring Compliance with the Real-Time Annex:: 
+* Support for Locking Policies:: 
+
+@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{413}@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{414}
+@subsection Mapping Ada Tasks onto the Underlying Kernel Threads
+
+
+GNAT’s run-time support comprises two layers:
+
+
+@itemize *
+
+@item 
+GNARL (GNAT Run-time Layer)
+
+@item 
+GNULL (GNAT Low-level Library)
+@end itemize
+
+In GNAT, Ada’s tasking services rely on a platform and OS independent
+layer known as GNARL.  This code is responsible for implementing the
+correct semantics of Ada’s task creation, rendezvous, protected
+operations etc.
+
+GNARL decomposes Ada’s tasking semantics into simpler lower level
+operations such as create a thread, set the priority of a thread,
+yield, create a lock, lock/unlock, etc.  The spec for these low-level
+operations constitutes GNULLI, the GNULL Interface.  This interface is
+directly inspired from the POSIX real-time API.
+
+If the underlying executive or OS implements the POSIX standard
+faithfully, the GNULL Interface maps as is to the services offered by
+the underlying kernel.  Otherwise, some target dependent glue code maps
+the services offered by the underlying kernel to the semantics expected
+by GNARL.
+
+Whatever the underlying OS (VxWorks, UNIX, Windows, etc.) the
+key point is that each Ada task is mapped on a thread in the underlying
+kernel.  For example, in the case of VxWorks, one Ada task = one VxWorks task.
+
+In addition Ada task priorities map onto the underlying thread priorities.
+Mapping Ada tasks onto the underlying kernel threads has several advantages:
+
+
+@itemize *
+
+@item 
+The underlying scheduler is used to schedule the Ada tasks.  This
+makes Ada tasks as efficient as kernel threads from a scheduling
+standpoint.
+
+@item 
+Interaction with code written in C containing threads is eased
+since at the lowest level Ada tasks and C threads map onto the same
+underlying kernel concept.
+
+@item 
+When an Ada task is blocked during I/O the remaining Ada tasks are
+able to proceed.
+
+@item 
+On multiprocessor systems Ada tasks can execute in parallel.
+@end itemize
+
+Some threads libraries offer a mechanism to fork a new process, with the
+child process duplicating the threads from the parent.
+GNAT does not
+support this functionality when the parent contains more than one task.
+
+@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{415}@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{416}
+@subsection Ensuring Compliance with the Real-Time Annex
+
+
+@geindex Real-Time Systems Annex compliance
+
+Although mapping Ada tasks onto
+the underlying threads has significant advantages, it does create some
+complications when it comes to respecting the scheduling semantics
+specified in the real-time annex (Annex D).
+
+For instance the Annex D requirement for the @code{FIFO_Within_Priorities}
+scheduling policy states:
+
+@quotation
+
+`When the active priority of a ready task that is not running
+changes, or the setting of its base priority takes effect, the
+task is removed from the ready queue for its old active priority
+and is added at the tail of the ready queue for its new active
+priority, except in the case where the active priority is lowered
+due to the loss of inherited priority, in which case the task is
+added at the head of the ready queue for its new active priority.'
+@end quotation
+
+While most kernels do put tasks at the end of the priority queue when
+a task changes its priority, (which respects the main
+FIFO_Within_Priorities requirement), almost none keep a thread at the
+beginning of its priority queue when its priority drops from the loss
+of inherited priority.
+
+As a result most vendors have provided incomplete Annex D implementations.
+
+The GNAT run-time, has a nice cooperative solution to this problem
+which ensures that accurate FIFO_Within_Priorities semantics are
+respected.
+
+The principle is as follows.  When an Ada task T is about to start
+running, it checks whether some other Ada task R with the same
+priority as T has been suspended due to the loss of priority
+inheritance.  If this is the case, T yields and is placed at the end of
+its priority queue.  When R arrives at the front of the queue it
+executes.
+
+Note that this simple scheme preserves the relative order of the tasks
+that were ready to execute in the priority queue where R has been
+placed at the end.
+
+@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{417}
+@subsection Support for Locking Policies
+
+
+This section specifies which policies specified by pragma Locking_Policy
+are supported on which platforms.
+
+GNAT supports the standard @code{Ceiling_Locking} policy, and the
+implementation defined @code{Inheritance_Locking} and
+@code{Concurrent_Readers_Locking} policies.
+
+@code{Ceiling_Locking} is supported on all platforms if the operating system
+supports it. In particular, @code{Ceiling_Locking} is not supported on
+VxWorks.
+@code{Inheritance_Locking} is supported on
+Linux,
+Darwin (Mac OS X),
+LynxOS 178,
+and VxWorks.
+@code{Concurrent_Readers_Locking} is supported on Linux.
+
+Notes about @code{Ceiling_Locking} on Linux:
+If the process is running as ‘root’, ceiling locking is used.
+If the capabilities facility is installed
+(“sudo apt-get –assume-yes install libcap-dev” on Ubuntu,
+for example),
+and the program is linked against that library
+(“-largs -lcap”),
+and the executable file has the cap_sys_nice capability
+(“sudo /sbin/setcap cap_sys_nice=ep executable_file_name”),
+then ceiling locking is used.
+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{418}@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{419}
+@section GNAT Implementation of Shared Passive Packages
+
+
+@geindex Shared passive packages
+
+GNAT fully implements the 
+@geindex pragma Shared_Passive
+pragma
+@code{Shared_Passive} for
+the purpose of designating shared passive packages.
+This allows the use of passive partitions in the
+context described in the Ada Reference Manual; i.e., for communication
+between separate partitions of a distributed application using the
+features in Annex E.
+
+@geindex Annex E
+
+@geindex Distribution Systems Annex
+
+However, the implementation approach used by GNAT provides for more
+extensive usage as follows:
+
+
+@table @asis
+
+@item `Communication between separate programs'
+
+This allows separate programs to access the data in passive
+partitions, using protected objects for synchronization where
+needed. The only requirement is that the two programs have a
+common shared file system. It is even possible for programs
+running on different machines with different architectures
+(e.g., different endianness) to communicate via the data in
+a passive partition.
+
+@item `Persistence between program runs'
+
+The data in a passive package can persist from one run of a
+program to another, so that a later program sees the final
+values stored by a previous run of the same program.
+@end table
+
+The implementation approach used is to store the data in files. A
+separate stream file is created for each object in the package, and
+an access to an object causes the corresponding file to be read or
+written.
+
+@geindex SHARED_MEMORY_DIRECTORY environment variable
+
+The environment variable @code{SHARED_MEMORY_DIRECTORY} should be
+set to the directory to be used for these files.
+The files in this directory
+have names that correspond to their fully qualified names. For
+example, if we have the package
+
+@example
+package X is
+  pragma Shared_Passive (X);
+  Y : Integer;
+  Z : Float;
+end X;
+@end example
+
+and the environment variable is set to @code{/stemp/}, then the files created
+will have the names:
+
+@example
+/stemp/x.y
+/stemp/x.z
+@end example
+
+These files are created when a value is initially written to the object, and
+the files are retained until manually deleted. This provides the persistence
+semantics. If no file exists, it means that no partition has assigned a value
+to the variable; in this case the initial value declared in the package
+will be used. This model ensures that there are no issues in synchronizing
+the elaboration process, since elaboration of passive packages elaborates the
+initial values, but does not create the files.
+
+The files are written using normal @code{Stream_IO} access.
+If you want to be able
+to communicate between programs or partitions running on different
+architectures, then you should use the XDR versions of the stream attribute
+routines, since these are architecture independent.
+
+If active synchronization is required for access to the variables in the
+shared passive package, then as described in the Ada Reference Manual, the
+package may contain protected objects used for this purpose. In this case
+a lock file (whose name is @code{___lock}, with three underscores)
+is created in the shared memory directory.
+
+@geindex ___lock file (for shared passive packages)
+
+This is used to provide the required locking
+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{41a}@anchor{gnat_rm/implementation_of_specific_ada_features id7}@anchor{41b}
+@section Code Generation for Array Aggregates
+
+
+Aggregates have a rich syntax and allow the user to specify the values of
+complex data structures by means of a single construct.  As a result, the
+code generated for aggregates can be quite complex and involve loops, case
+statements and multiple assignments.  In the simplest cases, however, the
+compiler will recognize aggregates whose components and constraints are
+fully static, and in those cases the compiler will generate little or no
+executable code.  The following is an outline of the code that GNAT generates
+for various aggregate constructs.  For further details, you will find it
+useful to examine the output produced by the -gnatG flag to see the expanded
+source that is input to the code generator.  You may also want to examine
+the assembly code generated at various levels of optimization.
+
+The code generated for aggregates depends on the context, the component values,
+and the type.  In the context of an object declaration the code generated is
+generally simpler than in the case of an assignment.  As a general rule, static
+component values and static subtypes also lead to simpler code.
+
+@menu
+* Static constant aggregates with static bounds:: 
+* Constant aggregates with unconstrained nominal types:: 
+* Aggregates with static bounds:: 
+* Aggregates with nonstatic bounds:: 
+* Aggregates in assignment statements:: 
+
+@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{41c}@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{41d}
+@subsection Static constant aggregates with static bounds
+
+
+For the declarations:
+
+@example
+type One_Dim is array (1..10) of integer;
+ar0 : constant One_Dim := (1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
+@end example
+
+GNAT generates no executable code: the constant ar0 is placed in static memory.
+The same is true for constant aggregates with named associations:
+
+@example
+Cr1 : constant One_Dim := (4 => 16, 2 => 4, 3 => 9, 1 => 1, 5 .. 10 => 0);
+Cr3 : constant One_Dim := (others => 7777);
+@end example
+
+The same is true for multidimensional constant arrays such as:
+
+@example
+type two_dim is array (1..3, 1..3) of integer;
+Unit : constant two_dim := ( (1,0,0), (0,1,0), (0,0,1));
+@end example
+
+The same is true for arrays of one-dimensional arrays: the following are
+static:
+
+@example
+type ar1b  is array (1..3) of boolean;
+type ar_ar is array (1..3) of ar1b;
+None  : constant ar1b := (others => false);     --  fully static
+None2 : constant ar_ar := (1..3 => None);       --  fully static
+@end example
+
+However, for multidimensional aggregates with named associations, GNAT will
+generate assignments and loops, even if all associations are static.  The
+following two declarations generate a loop for the first dimension, and
+individual component assignments for the second dimension:
+
+@example
+Zero1: constant two_dim := (1..3 => (1..3 => 0));
+Zero2: constant two_dim := (others => (others => 0));
+@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{41e}@anchor{gnat_rm/implementation_of_specific_ada_features id9}@anchor{41f}
+@subsection Constant aggregates with unconstrained nominal types
+
+
+In such cases the aggregate itself establishes the subtype, so that
+associations with @code{others} cannot be used.  GNAT determines the
+bounds for the actual subtype of the aggregate, and allocates the
+aggregate statically as well.  No code is generated for the following:
+
+@example
+type One_Unc is array (natural range <>) of integer;
+Cr_Unc : constant One_Unc := (12,24,36);
+@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{420}@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{421}
+@subsection Aggregates with static bounds
+
+
+In all previous examples the aggregate was the initial (and immutable) value
+of a constant.  If the aggregate initializes a variable, then code is generated
+for it as a combination of individual assignments and loops over the target
+object.  The declarations
+
+@example
+Cr_Var1 : One_Dim := (2, 5, 7, 11, 0, 0, 0, 0, 0, 0);
+Cr_Var2 : One_Dim := (others > -1);
+@end example
+
+generate the equivalent of
+
+@example
+Cr_Var1 (1) := 2;
+Cr_Var1 (2) := 3;
+Cr_Var1 (3) := 5;
+Cr_Var1 (4) := 11;
+
+for I in Cr_Var2'range loop
+   Cr_Var2 (I) := -1;
+end loop;
+@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{422}@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{423}
+@subsection Aggregates with nonstatic bounds
+
+
+If the bounds of the aggregate are not statically compatible with the bounds
+of the nominal subtype  of the target, then constraint checks have to be
+generated on the bounds.  For a multidimensional array, constraint checks may
+have to be applied to sub-arrays individually, if they do not have statically
+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{424}@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{425}
+@subsection Aggregates in assignment statements
+
+
+In general, aggregate assignment requires the construction of a temporary,
+and a copy from the temporary to the target of the assignment.  This is because
+it is not always possible to convert the assignment into a series of individual
+component assignments.  For example, consider the simple case:
+
+@example
+A := (A(2), A(1));
+@end example
+
+This cannot be converted into:
+
+@example
+A(1) := A(2);
+A(2) := A(1);
+@end example
+
+So the aggregate has to be built first in a separate location, and then
+copied into the target.  GNAT recognizes simple cases where this intermediate
+step is not required, and the assignments can be performed in place, directly
+into the target.  The following sufficient criteria are applied:
+
+
+@itemize *
+
+@item 
+The bounds of the aggregate are static, and the associations are static.
+
+@item 
+The components of the aggregate are static constants, names of
+simple variables that are not renamings, or expressions not involving
+indexed components whose operands obey these rules.
+@end itemize
+
+If any of these conditions are violated, the aggregate will be built in
+a temporary (created either by the front-end or the code generator) and then
+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{426}@anchor{gnat_rm/implementation_of_specific_ada_features the-size-of-discriminated-records-with-default-discriminants}@anchor{427}
+@section The Size of Discriminated Records with Default Discriminants
+
+
+If a discriminated type @code{T} has discriminants with default values, it is
+possible to declare an object of this type without providing an explicit
+constraint:
+
+@example
+type Size is range 1..100;
+
+type Rec (D : Size := 15) is record
+   Name : String (1..D);
+end T;
+
+Word : Rec;
+@end example
+
+Such an object is said to be `unconstrained'.
+The discriminant of the object
+can be modified by a full assignment to the object, as long as it preserves the
+relation between the value of the discriminant, and the value of the components
+that depend on it:
+
+@example
+Word := (3, "yes");
+
+Word := (5, "maybe");
+
+Word := (5, "no"); -- raises Constraint_Error
+@end example
+
+In order to support this behavior efficiently, an unconstrained object is
+given the maximum size that any value of the type requires. In the case
+above, @code{Word} has storage for the discriminant and for
+a @code{String} of length 100.
+It is important to note that unconstrained objects do not require dynamic
+allocation. It would be an improper implementation to place on the heap those
+components whose size depends on discriminants. (This improper implementation
+was used by some Ada83 compilers, where the @code{Name} component above
+would have
+been stored as a pointer to a dynamic string). Following the principle that
+dynamic storage management should never be introduced implicitly,
+an Ada compiler should reserve the full size for an unconstrained declared
+object, and place it on the stack.
+
+This maximum size approach
+has been a source of surprise to some users, who expect the default
+values of the discriminants to determine the size reserved for an
+unconstrained object: “If the default is 15, why should the object occupy
+a larger size?”
+The answer, of course, is that the discriminant may be later modified,
+and its full range of values must be taken into account. This is why the
+declaration:
+
+@example
+type Rec (D : Positive := 15) is record
+   Name : String (1..D);
+end record;
+
+Too_Large : Rec;
+@end example
+
+is flagged by the compiler with a warning:
+an attempt to create @code{Too_Large} will raise @code{Storage_Error},
+because the required size includes @code{Positive'Last}
+bytes. As the first example indicates, the proper approach is to declare an
+index type of ‘reasonable’ range so that unconstrained objects are not too
+large.
+
+One final wrinkle: if the object is declared to be @code{aliased}, or if it is
+created in the heap by means of an allocator, then it is `not'
+unconstrained:
+it is constrained by the default values of the discriminants, and those values
+cannot be modified by full assignment. This is because in the presence of
+aliasing all views of the object (which may be manipulated by different tasks,
+say) must be consistent, so it is imperative that the object, once created,
+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{428}@anchor{gnat_rm/implementation_of_specific_ada_features image-values-for-nonscalar-types}@anchor{429}
+@section Image Values For Nonscalar Types
+
+
+Ada 2022 defines the Image, Wide_Image, and Wide_Wide image attributes
+for nonscalar types; earlier Ada versions defined these attributes only
+for scalar types. Ada RM 4.10 provides some general guidance regarding
+the default implementation of these attributes and the GNAT compiler
+follows that guidance. However, beyond that the precise details of the
+image text generated in these cases are deliberately not documented and are
+subject to change. In particular, users should not rely on formatting details
+(such as spaces or line breaking), record field order, image values for access
+types, image values for types that have ancestor or subcomponent types
+declared in non-Ada2022 code, image values for predefined types, or the
+compiler’s choices regarding the implementation permissions described in
+Ada RM 4.10. This list is not intended to be exhaustive. If more precise
+control of image text is required for some type T, then T’Put_Image should be
+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{42a}@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{42b}
+@section Strict Conformance to the Ada Reference Manual
+
+
+The dynamic semantics defined by the Ada Reference Manual impose a set of
+run-time checks to be generated. By default, the GNAT compiler will insert many
+run-time checks into the compiled code, including most of those required by the
+Ada Reference Manual. However, there are two checks that are not enabled in
+the default mode for efficiency reasons: checks for access before elaboration
+on subprogram calls, and stack overflow checking (most operating systems do not
+perform this check by default).
+
+Strict conformance to the Ada Reference Manual can be achieved by adding two
+compiler options for dynamic checks for access-before-elaboration on subprogram
+calls and generic instantiations (`-gnatE'), and stack overflow checking
+(`-fstack-check').
+
+Note that the result of a floating point arithmetic operation in overflow and
+invalid situations, when the @code{Machine_Overflows} attribute of the result
+type is @code{False}, is to generate IEEE NaN and infinite values. This is the
+case for machines compliant with the IEEE floating-point standard, but on
+machines that are not fully compliant with this standard, such as Alpha, the
+`-mieee' compiler flag must be used for achieving IEEE confirming
+behavior (although at the cost of a significant performance penalty), so
+infinite and NaN values are properly generated.
+
+@node Implementation of Ada 2012 Features,GNAT language extensions,Implementation of Specific Ada Features,Top
+@anchor{gnat_rm/implementation_of_ada_2012_features doc}@anchor{42c}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{42d}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}
+@chapter Implementation of Ada 2012 Features
+
+
+@geindex Ada 2012 implementation status
+
+@geindex -gnat12 option (gcc)
+
+@geindex pragma Ada_2012
+
+@geindex configuration pragma Ada_2012
+
+@geindex Ada_2012 configuration pragma
+
+This chapter contains a complete list of Ada 2012 features that have been
+implemented.
+Generally, these features are only
+available if the `-gnat12' (Ada 2012 features enabled) option is set,
+which is the default behavior,
+or if the configuration pragma @code{Ada_2012} is used.
+
+However, new pragmas, attributes, and restrictions are
+unconditionally available, since the Ada 95 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 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
+@indicateurl{http://www.ada-auth.org/ai05-summary.html}.
+
+@geindex AI-0176 (Ada 2012 feature)
 
-In accordance with RM rules, such code statements are allowed only
-within subprograms whose entire body consists of such statements.  It is
-not permissible to intermix such statements with other Ada statements.
 
-Typically the form using intrinsic procedure calls is more convenient
-and more flexible.  The code statement form is provided to meet the RM
-suggestion that such a facility should be made available.  The following
-is the exact syntax of the call to @code{Asm}. As usual, if named notation
-is used, the arguments may be given in arbitrary order, following the
-normal rules for use of positional and named arguments:
+@itemize *
 
-@example
-ASM_CALL ::= Asm (
-                 [Template =>] static_string_EXPRESSION
-               [,[Outputs  =>] OUTPUT_OPERAND_LIST      ]
-               [,[Inputs   =>] INPUT_OPERAND_LIST       ]
-               [,[Clobber  =>] static_string_EXPRESSION ]
-               [,[Volatile =>] static_boolean_EXPRESSION] )
+@item 
+`AI-0176 Quantified expressions (2010-09-29)'
 
-OUTPUT_OPERAND_LIST ::=
-  [PREFIX.]No_Output_Operands
-| OUTPUT_OPERAND_ATTRIBUTE
-| (OUTPUT_OPERAND_ATTRIBUTE @{,OUTPUT_OPERAND_ATTRIBUTE@})
+Both universally and existentially quantified expressions are implemented.
+They use the new syntax for iterators proposed in AI05-139-2, as well as
+the standard Ada loop syntax.
 
-OUTPUT_OPERAND_ATTRIBUTE ::=
-  SUBTYPE_MARK'Asm_Output (static_string_EXPRESSION, NAME)
+RM References:  1.01.04 (12)   2.09 (2/2)   4.04 (7)   4.05.09 (0)
+@end itemize
 
-INPUT_OPERAND_LIST ::=
-  [PREFIX.]No_Input_Operands
-| INPUT_OPERAND_ATTRIBUTE
-| (INPUT_OPERAND_ATTRIBUTE @{,INPUT_OPERAND_ATTRIBUTE@})
+@geindex AI-0079 (Ada 2012 feature)
 
-INPUT_OPERAND_ATTRIBUTE ::=
-  SUBTYPE_MARK'Asm_Input (static_string_EXPRESSION, EXPRESSION)
-@end example
 
-The identifiers @code{No_Input_Operands} and @code{No_Output_Operands}
-are declared in the package @code{Machine_Code} and must be referenced
-according to normal visibility rules. In particular if there is no
-@code{use} clause for this package, then appropriate package name
-qualification is required.
+@itemize *
 
-@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{40e}@anchor{gnat_rm/implementation_of_specific_ada_features id3}@anchor{40f}
-@section GNAT Implementation of Tasking
+@item 
+`AI-0079 Allow other_format characters in source (2010-07-10)'
 
+Wide characters in the unicode category `other_format' are now allowed in
+source programs between tokens, but not within a token such as an identifier.
 
-This chapter outlines the basic GNAT approach to tasking (in particular,
-a multi-layered library for portability) and discusses issues related
-to compliance with the Real-Time Systems Annex.
+RM References:  2.01 (4/2)   2.02 (7)
+@end itemize
 
-@menu
-* Mapping Ada Tasks onto the Underlying Kernel Threads:: 
-* Ensuring Compliance with the Real-Time Annex:: 
-* Support for Locking Policies:: 
+@geindex AI-0091 (Ada 2012 feature)
 
-@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{410}@anchor{gnat_rm/implementation_of_specific_ada_features mapping-ada-tasks-onto-the-underlying-kernel-threads}@anchor{411}
-@subsection Mapping Ada Tasks onto the Underlying Kernel Threads
+@itemize *
+
+@item 
+`AI-0091 Do not allow other_format in identifiers (0000-00-00)'
 
+Wide characters in the unicode category `other_format' are not permitted
+within  an identifier, since this can be a security problem. The error
+message for this case has been improved to be more specific, but GNAT has
+never allowed such characters to appear in identifiers.
 
-GNAT’s run-time support comprises two layers:
+RM References:  2.03 (3.1/2)   2.03 (4/2)   2.03 (5/2)   2.03 (5.1/2)   2.03 (5.2/2)   2.03 (5.3/2)   2.09 (2/2)
+@end itemize
+
+@geindex AI-0100 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-GNARL (GNAT Run-time Layer)
+`AI-0100 Placement of pragmas  (2010-07-01)'
 
-@item 
-GNULL (GNAT Low-level Library)
+This AI is an earlier version of AI-163. It simplifies the rules
+for legal placement of pragmas. In the case of lists that allow pragmas, if
+the list may have no elements, then the list may consist solely of pragmas.
+
+RM References:  2.08 (7)
 @end itemize
 
-In GNAT, Ada’s tasking services rely on a platform and OS independent
-layer known as GNARL.  This code is responsible for implementing the
-correct semantics of Ada’s task creation, rendezvous, protected
-operations etc.
+@geindex AI-0163 (Ada 2012 feature)
 
-GNARL decomposes Ada’s tasking semantics into simpler lower level
-operations such as create a thread, set the priority of a thread,
-yield, create a lock, lock/unlock, etc.  The spec for these low-level
-operations constitutes GNULLI, the GNULL Interface.  This interface is
-directly inspired from the POSIX real-time API.
 
-If the underlying executive or OS implements the POSIX standard
-faithfully, the GNULL Interface maps as is to the services offered by
-the underlying kernel.  Otherwise, some target dependent glue code maps
-the services offered by the underlying kernel to the semantics expected
-by GNARL.
+@itemize *
 
-Whatever the underlying OS (VxWorks, UNIX, Windows, etc.) the
-key point is that each Ada task is mapped on a thread in the underlying
-kernel.  For example, in the case of VxWorks, one Ada task = one VxWorks task.
+@item 
+`AI-0163 Pragmas in place of null (2010-07-01)'
 
-In addition Ada task priorities map onto the underlying thread priorities.
-Mapping Ada tasks onto the underlying kernel threads has several advantages:
+A statement sequence may be composed entirely of pragmas. It is no longer
+necessary to add a dummy @code{null} statement to make the sequence legal.
+
+RM References:  2.08 (7)   2.08 (16)
+@end itemize
+
+@geindex AI-0080 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-The underlying scheduler is used to schedule the Ada tasks.  This
-makes Ada tasks as efficient as kernel threads from a scheduling
-standpoint.
+`AI-0080 ‘View of’ not needed if clear from context (0000-00-00)'
 
-@item 
-Interaction with code written in C containing threads is eased
-since at the lowest level Ada tasks and C threads map onto the same
-underlying kernel concept.
+This is an editorial change only, described as non-testable in the AI.
 
-@item 
-When an Ada task is blocked during I/O the remaining Ada tasks are
-able to proceed.
+RM References:  3.01 (7)
+@end itemize
+
+@geindex AI-0183 (Ada 2012 feature)
+
+
+@itemize *
 
 @item 
-On multiprocessor systems Ada tasks can execute in parallel.
+`AI-0183 Aspect specifications (2010-08-16)'
+
+Aspect specifications have been fully implemented except for pre and post-
+conditions, and type invariants, which have their own separate AI’s. All
+forms of declarations listed in the AI are supported. The following is a
+list of the aspects supported (with GNAT implementation aspects marked)
 @end itemize
 
-Some threads libraries offer a mechanism to fork a new process, with the
-child process duplicating the threads from the parent.
-GNAT does not
-support this functionality when the parent contains more than one task.
 
-@geindex Forking a new process
+@multitable {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxx} 
+@headitem
 
-@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{412}@anchor{gnat_rm/implementation_of_specific_ada_features id5}@anchor{413}
-@subsection Ensuring Compliance with the Real-Time Annex
+Supported Aspect
 
+@tab
 
-@geindex Real-Time Systems Annex compliance
+Source
 
-Although mapping Ada tasks onto
-the underlying threads has significant advantages, it does create some
-complications when it comes to respecting the scheduling semantics
-specified in the real-time annex (Annex D).
+@item
 
-For instance the Annex D requirement for the @code{FIFO_Within_Priorities}
-scheduling policy states:
+@code{Ada_2005}
 
-@quotation
+@tab
 
-`When the active priority of a ready task that is not running
-changes, or the setting of its base priority takes effect, the
-task is removed from the ready queue for its old active priority
-and is added at the tail of the ready queue for its new active
-priority, except in the case where the active priority is lowered
-due to the loss of inherited priority, in which case the task is
-added at the head of the ready queue for its new active priority.'
-@end quotation
+– GNAT
 
-While most kernels do put tasks at the end of the priority queue when
-a task changes its priority, (which respects the main
-FIFO_Within_Priorities requirement), almost none keep a thread at the
-beginning of its priority queue when its priority drops from the loss
-of inherited priority.
+@item
 
-As a result most vendors have provided incomplete Annex D implementations.
+@code{Ada_2012}
 
-The GNAT run-time, has a nice cooperative solution to this problem
-which ensures that accurate FIFO_Within_Priorities semantics are
-respected.
+@tab
 
-The principle is as follows.  When an Ada task T is about to start
-running, it checks whether some other Ada task R with the same
-priority as T has been suspended due to the loss of priority
-inheritance.  If this is the case, T yields and is placed at the end of
-its priority queue.  When R arrives at the front of the queue it
-executes.
+– GNAT
 
-Note that this simple scheme preserves the relative order of the tasks
-that were ready to execute in the priority queue where R has been
-placed at the end.
+@item
 
-@c Support_for_Locking_Policies
+@code{Address}
 
-@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{414}
-@subsection Support for Locking Policies
+@tab
+
+@item
+
+@code{Alignment}
+
+@tab
+
+@item
+
+@code{Atomic}
+
+@tab
+
+@item
+
+@code{Atomic_Components}
+
+@tab
+
+@item
+
+@code{Bit_Order}
+
+@tab
+
+@item
+
+@code{Component_Size}
+
+@tab
+
+@item
+
+@code{Contract_Cases}
+
+@tab
+
+– GNAT
+
+@item
+
+@code{Discard_Names}
+
+@tab
+
+@item
+
+@code{External_Tag}
 
+@tab
 
-This section specifies which policies specified by pragma Locking_Policy
-are supported on which platforms.
+@item
 
-GNAT supports the standard @code{Ceiling_Locking} policy, and the
-implementation defined @code{Inheritance_Locking} and
-@code{Concurrent_Readers_Locking} policies.
+@code{Favor_Top_Level}
 
-@code{Ceiling_Locking} is supported on all platforms if the operating system
-supports it. In particular, @code{Ceiling_Locking} is not supported on
-VxWorks.
-@code{Inheritance_Locking} is supported on
-Linux,
-Darwin (Mac OS X),
-LynxOS 178,
-and VxWorks.
-@code{Concurrent_Readers_Locking} is supported on Linux.
+@tab
 
-Notes about @code{Ceiling_Locking} on Linux:
-If the process is running as ‘root’, ceiling locking is used.
-If the capabilities facility is installed
-(“sudo apt-get –assume-yes install libcap-dev” on Ubuntu,
-for example),
-and the program is linked against that library
-(“-largs -lcap”),
-and the executable file has the cap_sys_nice capability
-(“sudo /sbin/setcap cap_sys_nice=ep executable_file_name”),
-then ceiling locking is used.
-Otherwise, the @code{Ceiling_Locking} policy is ignored.
+– GNAT
 
-@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{415}@anchor{gnat_rm/implementation_of_specific_ada_features id6}@anchor{416}
-@section GNAT Implementation of Shared Passive Packages
+@item
 
+@code{Inline}
 
-@geindex Shared passive packages
+@tab
 
-GNAT fully implements the 
-@geindex pragma Shared_Passive
-pragma
-@code{Shared_Passive} for
-the purpose of designating shared passive packages.
-This allows the use of passive partitions in the
-context described in the Ada Reference Manual; i.e., for communication
-between separate partitions of a distributed application using the
-features in Annex E.
+@item
 
-@geindex Annex E
+@code{Inline_Always}
 
-@geindex Distribution Systems Annex
+@tab
 
-However, the implementation approach used by GNAT provides for more
-extensive usage as follows:
+– GNAT
 
+@item
 
-@table @asis
+@code{Invariant}
 
-@item `Communication between separate programs'
+@tab
 
-This allows separate programs to access the data in passive
-partitions, using protected objects for synchronization where
-needed. The only requirement is that the two programs have a
-common shared file system. It is even possible for programs
-running on different machines with different architectures
-(e.g., different endianness) to communicate via the data in
-a passive partition.
+– GNAT
 
-@item `Persistence between program runs'
+@item
 
-The data in a passive package can persist from one run of a
-program to another, so that a later program sees the final
-values stored by a previous run of the same program.
-@end table
+@code{Machine_Radix}
 
-The implementation approach used is to store the data in files. A
-separate stream file is created for each object in the package, and
-an access to an object causes the corresponding file to be read or
-written.
+@tab
 
-@geindex SHARED_MEMORY_DIRECTORY environment variable
+@item
 
-The environment variable @code{SHARED_MEMORY_DIRECTORY} should be
-set to the directory to be used for these files.
-The files in this directory
-have names that correspond to their fully qualified names. For
-example, if we have the package
+@code{No_Return}
 
-@example
-package X is
-  pragma Shared_Passive (X);
-  Y : Integer;
-  Z : Float;
-end X;
-@end example
+@tab
 
-and the environment variable is set to @code{/stemp/}, then the files created
-will have the names:
+@item
 
-@example
-/stemp/x.y
-/stemp/x.z
-@end example
+@code{Object_Size}
 
-These files are created when a value is initially written to the object, and
-the files are retained until manually deleted. This provides the persistence
-semantics. If no file exists, it means that no partition has assigned a value
-to the variable; in this case the initial value declared in the package
-will be used. This model ensures that there are no issues in synchronizing
-the elaboration process, since elaboration of passive packages elaborates the
-initial values, but does not create the files.
+@tab
 
-The files are written using normal @code{Stream_IO} access.
-If you want to be able
-to communicate between programs or partitions running on different
-architectures, then you should use the XDR versions of the stream attribute
-routines, since these are architecture independent.
+– GNAT
 
-If active synchronization is required for access to the variables in the
-shared passive package, then as described in the Ada Reference Manual, the
-package may contain protected objects used for this purpose. In this case
-a lock file (whose name is @code{___lock}, with three underscores)
-is created in the shared memory directory.
+@item
 
-@geindex ___lock file (for shared passive packages)
+@code{Pack}
 
-This is used to provide the required locking
-semantics for proper protected object synchronization.
+@tab
 
-@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{417}@anchor{gnat_rm/implementation_of_specific_ada_features id7}@anchor{418}
-@section Code Generation for Array Aggregates
+@item
 
+@code{Persistent_BSS}
 
-Aggregates have a rich syntax and allow the user to specify the values of
-complex data structures by means of a single construct.  As a result, the
-code generated for aggregates can be quite complex and involve loops, case
-statements and multiple assignments.  In the simplest cases, however, the
-compiler will recognize aggregates whose components and constraints are
-fully static, and in those cases the compiler will generate little or no
-executable code.  The following is an outline of the code that GNAT generates
-for various aggregate constructs.  For further details, you will find it
-useful to examine the output produced by the -gnatG flag to see the expanded
-source that is input to the code generator.  You may also want to examine
-the assembly code generated at various levels of optimization.
+@tab
 
-The code generated for aggregates depends on the context, the component values,
-and the type.  In the context of an object declaration the code generated is
-generally simpler than in the case of an assignment.  As a general rule, static
-component values and static subtypes also lead to simpler code.
+– GNAT
 
-@menu
-* Static constant aggregates with static bounds:: 
-* Constant aggregates with unconstrained nominal types:: 
-* Aggregates with static bounds:: 
-* Aggregates with nonstatic bounds:: 
-* Aggregates in assignment statements:: 
+@item
 
-@end menu
+@code{Post}
 
-@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{419}@anchor{gnat_rm/implementation_of_specific_ada_features static-constant-aggregates-with-static-bounds}@anchor{41a}
-@subsection Static constant aggregates with static bounds
+@tab
 
+@item
 
-For the declarations:
+@code{Pre}
 
-@example
-type One_Dim is array (1..10) of integer;
-ar0 : constant One_Dim := (1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
-@end example
+@tab
 
-GNAT generates no executable code: the constant ar0 is placed in static memory.
-The same is true for constant aggregates with named associations:
+@item
 
-@example
-Cr1 : constant One_Dim := (4 => 16, 2 => 4, 3 => 9, 1 => 1, 5 .. 10 => 0);
-Cr3 : constant One_Dim := (others => 7777);
-@end example
+@code{Predicate}
 
-The same is true for multidimensional constant arrays such as:
+@tab
 
-@example
-type two_dim is array (1..3, 1..3) of integer;
-Unit : constant two_dim := ( (1,0,0), (0,1,0), (0,0,1));
-@end example
+@item
 
-The same is true for arrays of one-dimensional arrays: the following are
-static:
+@code{Preelaborable_Initialization}
 
-@example
-type ar1b  is array (1..3) of boolean;
-type ar_ar is array (1..3) of ar1b;
-None  : constant ar1b := (others => false);     --  fully static
-None2 : constant ar_ar := (1..3 => None);       --  fully static
-@end example
+@tab
 
-However, for multidimensional aggregates with named associations, GNAT will
-generate assignments and loops, even if all associations are static.  The
-following two declarations generate a loop for the first dimension, and
-individual component assignments for the second dimension:
+@item
 
-@example
-Zero1: constant two_dim := (1..3 => (1..3 => 0));
-Zero2: constant two_dim := (others => (others => 0));
-@end example
+@code{Pure_Function}
 
-@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{41b}@anchor{gnat_rm/implementation_of_specific_ada_features id9}@anchor{41c}
-@subsection Constant aggregates with unconstrained nominal types
+@tab
 
+– GNAT
 
-In such cases the aggregate itself establishes the subtype, so that
-associations with @code{others} cannot be used.  GNAT determines the
-bounds for the actual subtype of the aggregate, and allocates the
-aggregate statically as well.  No code is generated for the following:
+@item
 
-@example
-type One_Unc is array (natural range <>) of integer;
-Cr_Unc : constant One_Unc := (12,24,36);
-@end example
+@code{Remote_Access_Type}
 
-@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{41d}@anchor{gnat_rm/implementation_of_specific_ada_features id10}@anchor{41e}
-@subsection Aggregates with static bounds
+@tab
 
+– GNAT
 
-In all previous examples the aggregate was the initial (and immutable) value
-of a constant.  If the aggregate initializes a variable, then code is generated
-for it as a combination of individual assignments and loops over the target
-object.  The declarations
+@item
 
-@example
-Cr_Var1 : One_Dim := (2, 5, 7, 11, 0, 0, 0, 0, 0, 0);
-Cr_Var2 : One_Dim := (others > -1);
-@end example
+@code{Shared}
 
-generate the equivalent of
+@tab
 
-@example
-Cr_Var1 (1) := 2;
-Cr_Var1 (2) := 3;
-Cr_Var1 (3) := 5;
-Cr_Var1 (4) := 11;
+– GNAT
 
-for I in Cr_Var2'range loop
-   Cr_Var2 (I) := -1;
-end loop;
-@end example
+@item
 
-@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{41f}@anchor{gnat_rm/implementation_of_specific_ada_features id11}@anchor{420}
-@subsection Aggregates with nonstatic bounds
+@code{Size}
+
+@tab
 
+@item
 
-If the bounds of the aggregate are not statically compatible with the bounds
-of the nominal subtype  of the target, then constraint checks have to be
-generated on the bounds.  For a multidimensional array, constraint checks may
-have to be applied to sub-arrays individually, if they do not have statically
-compatible subtypes.
+@code{Storage_Pool}
 
-@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{421}@anchor{gnat_rm/implementation_of_specific_ada_features id12}@anchor{422}
-@subsection Aggregates in assignment statements
+@tab
 
+@item
 
-In general, aggregate assignment requires the construction of a temporary,
-and a copy from the temporary to the target of the assignment.  This is because
-it is not always possible to convert the assignment into a series of individual
-component assignments.  For example, consider the simple case:
+@code{Storage_Size}
 
-@example
-A := (A(2), A(1));
-@end example
+@tab
 
-This cannot be converted into:
+@item
 
-@example
-A(1) := A(2);
-A(2) := A(1);
-@end example
+@code{Stream_Size}
 
-So the aggregate has to be built first in a separate location, and then
-copied into the target.  GNAT recognizes simple cases where this intermediate
-step is not required, and the assignments can be performed in place, directly
-into the target.  The following sufficient criteria are applied:
+@tab
 
+@item
 
-@itemize *
+@code{Suppress}
 
-@item 
-The bounds of the aggregate are static, and the associations are static.
+@tab
 
-@item 
-The components of the aggregate are static constants, names of
-simple variables that are not renamings, or expressions not involving
-indexed components whose operands obey these rules.
-@end itemize
+@item
 
-If any of these conditions are violated, the aggregate will be built in
-a temporary (created either by the front-end or the code generator) and then
-that temporary will be copied onto the target.
+@code{Suppress_Debug_Info}
 
-@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{423}@anchor{gnat_rm/implementation_of_specific_ada_features the-size-of-discriminated-records-with-default-discriminants}@anchor{424}
-@section The Size of Discriminated Records with Default Discriminants
+@tab
 
+– GNAT
 
-If a discriminated type @code{T} has discriminants with default values, it is
-possible to declare an object of this type without providing an explicit
-constraint:
+@item
 
-@example
-type Size is range 1..100;
+@code{Test_Case}
 
-type Rec (D : Size := 15) is record
-   Name : String (1..D);
-end T;
+@tab
 
-Word : Rec;
-@end example
+– GNAT
 
-Such an object is said to be `unconstrained'.
-The discriminant of the object
-can be modified by a full assignment to the object, as long as it preserves the
-relation between the value of the discriminant, and the value of the components
-that depend on it:
+@item
 
-@example
-Word := (3, "yes");
+@code{Thread_Local_Storage}
 
-Word := (5, "maybe");
+@tab
 
-Word := (5, "no"); -- raises Constraint_Error
-@end example
+– GNAT
 
-In order to support this behavior efficiently, an unconstrained object is
-given the maximum size that any value of the type requires. In the case
-above, @code{Word} has storage for the discriminant and for
-a @code{String} of length 100.
-It is important to note that unconstrained objects do not require dynamic
-allocation. It would be an improper implementation to place on the heap those
-components whose size depends on discriminants. (This improper implementation
-was used by some Ada83 compilers, where the @code{Name} component above
-would have
-been stored as a pointer to a dynamic string). Following the principle that
-dynamic storage management should never be introduced implicitly,
-an Ada compiler should reserve the full size for an unconstrained declared
-object, and place it on the stack.
+@item
 
-This maximum size approach
-has been a source of surprise to some users, who expect the default
-values of the discriminants to determine the size reserved for an
-unconstrained object: “If the default is 15, why should the object occupy
-a larger size?”
-The answer, of course, is that the discriminant may be later modified,
-and its full range of values must be taken into account. This is why the
-declaration:
+@code{Type_Invariant}
 
-@example
-type Rec (D : Positive := 15) is record
-   Name : String (1..D);
-end record;
+@tab
 
-Too_Large : Rec;
-@end example
+@item
 
-is flagged by the compiler with a warning:
-an attempt to create @code{Too_Large} will raise @code{Storage_Error},
-because the required size includes @code{Positive'Last}
-bytes. As the first example indicates, the proper approach is to declare an
-index type of ‘reasonable’ range so that unconstrained objects are not too
-large.
+@code{Unchecked_Union}
 
-One final wrinkle: if the object is declared to be @code{aliased}, or if it is
-created in the heap by means of an allocator, then it is `not'
-unconstrained:
-it is constrained by the default values of the discriminants, and those values
-cannot be modified by full assignment. This is because in the presence of
-aliasing all views of the object (which may be manipulated by different tasks,
-say) must be consistent, so it is imperative that the object, once created,
-remain invariant.
+@tab
 
-@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{425}@anchor{gnat_rm/implementation_of_specific_ada_features image-values-for-nonscalar-types}@anchor{426}
-@section Image Values For Nonscalar Types
+@item
 
+@code{Universal_Aliasing}
 
-Ada 2022 defines the Image, Wide_Image, and Wide_Wide image attributes
-for nonscalar types; earlier Ada versions defined these attributes only
-for scalar types. Ada RM 4.10 provides some general guidance regarding
-the default implementation of these attributes and the GNAT compiler
-follows that guidance. However, beyond that the precise details of the
-image text generated in these cases are deliberately not documented and are
-subject to change. In particular, users should not rely on formatting details
-(such as spaces or line breaking), record field order, image values for access
-types, image values for types that have ancestor or subcomponent types
-declared in non-Ada2022 code, image values for predefined types, or the
-compiler’s choices regarding the implementation permissions described in
-Ada RM 4.10. This list is not intended to be exhaustive. If more precise
-control of image text is required for some type T, then T’Put_Image should be
-explicitly specified.
+@tab
 
-@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{427}@anchor{gnat_rm/implementation_of_specific_ada_features strict-conformance-to-the-ada-reference-manual}@anchor{428}
-@section Strict Conformance to the Ada Reference Manual
+– GNAT
 
+@item
 
-The dynamic semantics defined by the Ada Reference Manual impose a set of
-run-time checks to be generated. By default, the GNAT compiler will insert many
-run-time checks into the compiled code, including most of those required by the
-Ada Reference Manual. However, there are two checks that are not enabled in
-the default mode for efficiency reasons: checks for access before elaboration
-on subprogram calls, and stack overflow checking (most operating systems do not
-perform this check by default).
+@code{Unmodified}
 
-Strict conformance to the Ada Reference Manual can be achieved by adding two
-compiler options for dynamic checks for access-before-elaboration on subprogram
-calls and generic instantiations (`-gnatE'), and stack overflow checking
-(`-fstack-check').
+@tab
 
-Note that the result of a floating point arithmetic operation in overflow and
-invalid situations, when the @code{Machine_Overflows} attribute of the result
-type is @code{False}, is to generate IEEE NaN and infinite values. This is the
-case for machines compliant with the IEEE floating-point standard, but on
-machines that are not fully compliant with this standard, such as Alpha, the
-`-mieee' compiler flag must be used for achieving IEEE confirming
-behavior (although at the cost of a significant performance penalty), so
-infinite and NaN values are properly generated.
+– GNAT
 
-@node Implementation of Ada 2012 Features,Security Hardening Features,Implementation of Specific Ada Features,Top
-@anchor{gnat_rm/implementation_of_ada_2012_features doc}@anchor{429}@anchor{gnat_rm/implementation_of_ada_2012_features id1}@anchor{42a}@anchor{gnat_rm/implementation_of_ada_2012_features implementation-of-ada-2012-features}@anchor{14}
-@chapter Implementation of Ada 2012 Features
+@item
 
+@code{Unreferenced}
 
-@geindex Ada 2012 implementation status
+@tab
 
-@geindex -gnat12 option (gcc)
+– GNAT
 
-@geindex pragma Ada_2012
+@item
 
-@geindex configuration pragma Ada_2012
+@code{Unreferenced_Objects}
 
-@geindex Ada_2012 configuration pragma
+@tab
 
-This chapter contains a complete list of Ada 2012 features that have been
-implemented.
-Generally, these features are only
-available if the `-gnat12' (Ada 2012 features enabled) option is set,
-which is the default behavior,
-or if the configuration pragma @code{Ada_2012} is used.
+– GNAT
 
-However, new pragmas, attributes, and restrictions are
-unconditionally available, since the Ada 95 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.
+@item
 
-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.
+@code{Unsuppress}
 
-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.
+@tab
 
-A complete description of the AIs may be found in
-@indicateurl{http://www.ada-auth.org/ai05-summary.html}.
+@item
 
-@geindex AI-0176 (Ada 2012 feature)
+@code{Value_Size}
 
+@tab
 
-@itemize *
+– GNAT
 
-@item 
-`AI-0176 Quantified expressions (2010-09-29)'
+@item
 
-Both universally and existentially quantified expressions are implemented.
-They use the new syntax for iterators proposed in AI05-139-2, as well as
-the standard Ada loop syntax.
+@code{Volatile}
 
-RM References:  1.01.04 (12)   2.09 (2/2)   4.04 (7)   4.05.09 (0)
-@end itemize
+@tab
 
-@geindex AI-0079 (Ada 2012 feature)
+@item
 
+@code{Volatile_Components}
 
-@itemize *
+@tab
 
-@item 
-`AI-0079 Allow other_format characters in source (2010-07-10)'
+@item
 
-Wide characters in the unicode category `other_format' are now allowed in
-source programs between tokens, but not within a token such as an identifier.
+@code{Warnings}
 
-RM References:  2.01 (4/2)   2.02 (7)
-@end itemize
+@tab
 
-@geindex AI-0091 (Ada 2012 feature)
+– GNAT
 
+@end multitable
 
-@itemize *
 
-@item 
-`AI-0091 Do not allow other_format in identifiers (0000-00-00)'
+@quotation
 
-Wide characters in the unicode category `other_format' are not permitted
-within  an identifier, since this can be a security problem. The error
-message for this case has been improved to be more specific, but GNAT has
-never allowed such characters to appear in identifiers.
+Note that for aspects with an expression, e.g. @code{Size}, the expression is
+treated like a default expression (visibility is analyzed at the point of
+occurrence of the aspect, but evaluation of the expression occurs at the
+freeze point of the entity involved).
 
-RM References:  2.03 (3.1/2)   2.03 (4/2)   2.03 (5/2)   2.03 (5.1/2)   2.03 (5.2/2)   2.03 (5.3/2)   2.09 (2/2)
-@end itemize
+RM References:  3.02.01 (3)   3.02.02 (2)   3.03.01 (2/2)   3.08 (6)
+3.09.03 (1.1/2)   6.01 (2/2)   6.07 (2/2)   9.05.02 (2/2)   7.01 (3)   7.03
+(2)   7.03 (3)   9.01 (2/2)   9.01 (3/2)   9.04 (2/2)   9.04 (3/2)
+9.05.02 (2/2)   11.01 (2)   12.01 (3)   12.03 (2/2)   12.04 (2/2)   12.05 (2)
+12.06 (2.1/2)   12.06 (2.2/2)   12.07 (2)   13.01 (0.1/2)   13.03 (5/1)
+13.03.01 (0)
+@end quotation
 
-@geindex AI-0100 (Ada 2012 feature)
+@geindex AI-0128 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0100 Placement of pragmas  (2010-07-01)'
+`AI-0128 Inequality is a primitive operation (0000-00-00)'
 
-This AI is an earlier version of AI-163. It simplifies the rules
-for legal placement of pragmas. In the case of lists that allow pragmas, if
-the list may have no elements, then the list may consist solely of pragmas.
+If an equality operator (“=”) is declared for a type, then the implicitly
+declared inequality operator (“/=”) is a primitive operation of the type.
+This is the only reasonable interpretation, and is the one always implemented
+by GNAT, but the RM was not entirely clear in making this point.
 
-RM References:  2.08 (7)
+RM References:  3.02.03 (6)   6.06 (6)
 @end itemize
 
-@geindex AI-0163 (Ada 2012 feature)
+@geindex AI-0003 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0163 Pragmas in place of null (2010-07-01)'
+`AI-0003 Qualified expressions as names (2010-07-11)'
 
-A statement sequence may be composed entirely of pragmas. It is no longer
-necessary to add a dummy @code{null} statement to make the sequence legal.
+In Ada 2012, a qualified expression is considered to be syntactically a name,
+meaning that constructs such as @code{A'(F(X)).B} are now legal. This is
+useful in disambiguating some cases of overloading.
 
-RM References:  2.08 (7)   2.08 (16)
+RM References:  3.03 (11)   3.03 (21)   4.01 (2)   4.04 (7)   4.07 (3)
+5.04 (7)
 @end itemize
 
-@geindex AI-0080 (Ada 2012 feature)
+@geindex AI-0120 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0080 ‘View of’ not needed if clear from context (0000-00-00)'
+`AI-0120 Constant instance of protected object (0000-00-00)'
 
-This is an editorial change only, described as non-testable in the AI.
+This is an RM editorial change only. The section that lists objects that are
+constant failed to include the current instance of a protected object
+within a protected function. This has always been treated as a constant
+in GNAT.
 
-RM References:  3.01 (7)
+RM References:  3.03 (21)
 @end itemize
 
-@geindex AI-0183 (Ada 2012 feature)
+@geindex AI-0008 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0183 Aspect specifications (2010-08-16)'
-
-Aspect specifications have been fully implemented except for pre and post-
-conditions, and type invariants, which have their own separate AI’s. All
-forms of declarations listed in the AI are supported. The following is a
-list of the aspects supported (with GNAT implementation aspects marked)
-@end itemize
-
-
-@multitable {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxx} 
-@headitem
-
-Supported Aspect
-
-@tab
-
-Source
-
-@item
-
-@code{Ada_2005}
-
-@tab
-
-– GNAT
-
-@item
-
-@code{Ada_2012}
-
-@tab
+`AI-0008 General access to constrained objects (0000-00-00)'
 
-– GNAT
+The wording in the RM implied that if you have a general access to a
+constrained object, it could be used to modify the discriminants. This was
+obviously not intended. @code{Constraint_Error} should be raised, and GNAT
+has always done so in this situation.
 
-@item
+RM References:  3.03 (23)   3.10.02 (26/2)   4.01 (9)   6.04.01 (17)   8.05.01 (5/2)
+@end itemize
 
-@code{Address}
+@geindex AI-0093 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Alignment}
+@item 
+`AI-0093 Additional rules use immutably limited (0000-00-00)'
 
-@tab
+This is an editorial change only, to make more widespread use of the Ada 2012
+‘immutably limited’.
 
-@item
+RM References:  3.03 (23.4/3)
+@end itemize
 
-@code{Atomic}
+@geindex AI-0096 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Atomic_Components}
+@item 
+`AI-0096 Deriving from formal private types (2010-07-20)'
 
-@tab
+In general it is illegal for a type derived from a formal limited type to be
+nonlimited.  This AI makes an exception to this rule: derivation is legal
+if it appears in the private part of the generic, and the formal type is not
+tagged. If the type is tagged, the legality check must be applied to the
+private part of the package.
 
-@item
+RM References:  3.04 (5.1/2)   6.02 (7)
+@end itemize
 
-@code{Bit_Order}
+@geindex AI-0181 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Component_Size}
+@item 
+`AI-0181 Soft hyphen is a non-graphic character (2010-07-23)'
 
-@tab
+From Ada 2005 on, soft hyphen is considered a non-graphic character, which
+means that it has a special name (@code{SOFT_HYPHEN}) in conjunction with the
+@code{Image} and @code{Value} attributes for the character types. Strictly
+speaking this is an inconsistency with Ada 95, but in practice the use of
+these attributes is so obscure that it will not cause problems.
 
-@item
+RM References:  3.05.02 (2/2)   A.01 (35/2)   A.03.03 (21)
+@end itemize
 
-@code{Contract_Cases}
+@geindex AI-0182 (Ada 2012 feature)
 
-@tab
 
-– GNAT
+@itemize *
 
-@item
+@item 
+`AI-0182 Additional forms for' @code{Character'Value} `(0000-00-00)'
 
-@code{Discard_Names}
+This AI allows @code{Character'Value} to accept the string @code{'?'} where
+@code{?} is any character including non-graphic control characters. GNAT has
+always accepted such strings. It also allows strings such as
+@code{HEX_00000041} to be accepted, but GNAT does not take advantage of this
+permission and raises @code{Constraint_Error}, as is certainly still
+permitted.
 
-@tab
+RM References:  3.05 (56/2)
+@end itemize
 
-@item
+@geindex AI-0214 (Ada 2012 feature)
 
-@code{External_Tag}
 
-@tab
+@itemize *
 
-@item
+@item 
+`AI-0214 Defaulted discriminants for limited tagged (2010-10-01)'
 
-@code{Favor_Top_Level}
+Ada 2012 relaxes the restriction that forbids discriminants of tagged types
+to have default expressions by allowing them when the type is limited. It
+is often useful to define a default value for a discriminant even though
+it can’t be changed by assignment.
 
-@tab
+RM References:  3.07 (9.1/2)   3.07.02 (3)
+@end itemize
 
-– GNAT
+@geindex AI-0102 (Ada 2012 feature)
 
-@item
 
-@code{Inline}
+@itemize *
 
-@tab
+@item 
+`AI-0102 Some implicit conversions are illegal (0000-00-00)'
 
-@item
+It is illegal to assign an anonymous access constant to an anonymous access
+variable. The RM did not have a clear rule to prevent this, but GNAT has
+always generated an error for this usage.
 
-@code{Inline_Always}
+RM References:  3.07 (16)   3.07.01 (9)   6.04.01 (6)   8.06 (27/2)
+@end itemize
 
-@tab
+@geindex AI-0158 (Ada 2012 feature)
 
-– GNAT
 
-@item
+@itemize *
 
-@code{Invariant}
+@item 
+`AI-0158 Generalizing membership tests (2010-09-16)'
 
-@tab
+This AI extends the syntax of membership tests to simplify complex conditions
+that can be expressed as membership in a subset of values of any type. It
+introduces syntax for a list of expressions that may be used in loop contexts
+as well.
 
-– GNAT
+RM References:  3.08.01 (5)   4.04 (3)   4.05.02 (3)   4.05.02 (5)   4.05.02 (27)
+@end itemize
 
-@item
+@geindex AI-0173 (Ada 2012 feature)
 
-@code{Machine_Radix}
 
-@tab
+@itemize *
 
-@item
+@item 
+`AI-0173 Testing if tags represent abstract types (2010-07-03)'
 
-@code{No_Return}
+The function @code{Ada.Tags.Type_Is_Abstract} returns @code{True} if invoked
+with the tag of an abstract type, and @code{False} otherwise.
 
-@tab
+RM References:  3.09 (7.4/2)   3.09 (12.4/2)
+@end itemize
 
-@item
+@geindex AI-0076 (Ada 2012 feature)
 
-@code{Object_Size}
 
-@tab
+@itemize *
 
-– GNAT
+@item 
+`AI-0076 function with controlling result (0000-00-00)'
 
-@item
+This is an editorial change only. The RM defines calls with controlling
+results, but uses the term ‘function with controlling result’ without an
+explicit definition.
 
-@code{Pack}
+RM References:  3.09.02 (2/2)
+@end itemize
 
-@tab
+@geindex AI-0126 (Ada 2012 feature)
 
-@item
 
-@code{Persistent_BSS}
+@itemize *
 
-@tab
+@item 
+`AI-0126 Dispatching with no declared operation (0000-00-00)'
 
-– GNAT
+This AI clarifies dispatching rules, and simply confirms that dispatching
+executes the operation of the parent type when there is no explicitly or
+implicitly declared operation for the descendant type. This has always been
+the case in all versions of GNAT.
 
-@item
+RM References:  3.09.02 (20/2)   3.09.02 (20.1/2)   3.09.02 (20.2/2)
+@end itemize
 
-@code{Post}
+@geindex AI-0097 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Pre}
+@item 
+`AI-0097 Treatment of abstract null extension (2010-07-19)'
 
-@tab
+The RM as written implied that in some cases it was possible to create an
+object of an abstract type, by having an abstract extension inherit a non-
+abstract constructor from its parent type. This mistake has been corrected
+in GNAT and in the RM, and this construct is now illegal.
 
-@item
+RM References:  3.09.03 (4/2)
+@end itemize
 
-@code{Predicate}
+@geindex AI-0203 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Preelaborable_Initialization}
+@item 
+`AI-0203 Extended return cannot be abstract (0000-00-00)'
 
-@tab
+A return_subtype_indication cannot denote an abstract subtype. GNAT has never
+permitted such usage.
 
-@item
+RM References:  3.09.03 (8/3)
+@end itemize
 
-@code{Pure_Function}
+@geindex AI-0198 (Ada 2012 feature)
 
-@tab
 
-– GNAT
+@itemize *
 
-@item
+@item 
+`AI-0198 Inheriting abstract operators  (0000-00-00)'
 
-@code{Remote_Access_Type}
+This AI resolves a conflict between two rules involving inherited abstract
+operations and predefined operators. If a derived numeric type inherits
+an abstract operator, it overrides the predefined one. This interpretation
+was always the one implemented in GNAT.
 
-@tab
+RM References:  3.09.03 (4/3)
+@end itemize
 
-– GNAT
+@geindex AI-0073 (Ada 2012 feature)
 
-@item
 
-@code{Shared}
+@itemize *
 
-@tab
+@item 
+`AI-0073 Functions returning abstract types (2010-07-10)'
 
-– GNAT
+This AI covers a number of issues regarding returning abstract types. In
+particular generic functions cannot have abstract result types or access
+result types designated an abstract type. There are some other cases which
+are detailed in the AI. Note that this binding interpretation has not been
+retrofitted to operate before Ada 2012 mode, since it caused a significant
+number of regressions.
 
-@item
+RM References:  3.09.03 (8)   3.09.03 (10)   6.05 (8/2)
+@end itemize
 
-@code{Size}
+@geindex AI-0070 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Storage_Pool}
+@item 
+`AI-0070 Elaboration of interface types (0000-00-00)'
 
-@tab
+This is an editorial change only, there are no testable consequences short of
+checking for the absence of generated code for an interface declaration.
 
-@item
+RM References:  3.09.04 (18/2)
+@end itemize
 
-@code{Storage_Size}
+@geindex AI-0208 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Stream_Size}
+@item 
+`AI-0208 Characteristics of incomplete views (0000-00-00)'
 
-@tab
+The wording in the Ada 2005 RM concerning characteristics of incomplete views
+was incorrect and implied that some programs intended to be legal were now
+illegal. GNAT had never considered such programs illegal, so it has always
+implemented the intent of this AI.
 
-@item
+RM References:  3.10.01 (2.4/2)   3.10.01 (2.6/2)
+@end itemize
 
-@code{Suppress}
+@geindex AI-0162 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Suppress_Debug_Info}
+@item 
+`AI-0162 Incomplete type completed by partial view (2010-09-15)'
 
-@tab
+Incomplete types are made more useful by allowing them to be completed by
+private types and private extensions.
 
-– GNAT
+RM References:  3.10.01 (2.5/2)   3.10.01 (2.6/2)   3.10.01 (3)   3.10.01 (4/2)
+@end itemize
 
-@item
+@geindex AI-0098 (Ada 2012 feature)
 
-@code{Test_Case}
 
-@tab
+@itemize *
 
-– GNAT
+@item 
+`AI-0098 Anonymous subprogram access restrictions (0000-00-00)'
 
-@item
+An unintentional omission in the RM implied some inconsistent restrictions on
+the use of anonymous access to subprogram values. These restrictions were not
+intentional, and have never been enforced by GNAT.
 
-@code{Thread_Local_Storage}
+RM References:  3.10.01 (6)   3.10.01 (9.2/2)
+@end itemize
 
-@tab
+@geindex AI-0199 (Ada 2012 feature)
 
-– GNAT
 
-@item
+@itemize *
 
-@code{Type_Invariant}
+@item 
+`AI-0199 Aggregate with anonymous access components (2010-07-14)'
 
-@tab
+A choice list in a record aggregate can include several components of
+(distinct) anonymous access types as long as they have matching designated
+subtypes.
 
-@item
+RM References:  4.03.01 (16)
+@end itemize
 
-@code{Unchecked_Union}
+@geindex AI-0220 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Universal_Aliasing}
+@item 
+`AI-0220 Needed components for aggregates (0000-00-00)'
 
-@tab
+This AI addresses a wording problem in the RM that appears to permit some
+complex cases of aggregates with nonstatic discriminants. GNAT has always
+implemented the intended semantics.
 
-– GNAT
+RM References:  4.03.01 (17)
+@end itemize
 
-@item
+@geindex AI-0147 (Ada 2012 feature)
 
-@code{Unmodified}
 
-@tab
+@itemize *
 
-– GNAT
+@item 
+`AI-0147 Conditional expressions (2009-03-29)'
 
-@item
+Conditional expressions are permitted. The form of such an expression is:
 
-@code{Unreferenced}
+@example
+(if expr then expr @{elsif expr then expr@} [else expr])
+@end example
 
-@tab
+The parentheses can be omitted in contexts where parentheses are present
+anyway, such as subprogram arguments and pragma arguments. If the `else'
+clause is omitted, `else' `True' is assumed;
+thus @code{(if A then B)} is a way to conveniently represent
+`(A implies B)' in standard logic.
 
-– GNAT
+RM References:  4.03.03 (15)   4.04 (1)   4.04 (7)   4.05.07 (0)   4.07 (2)
+4.07 (3)   4.09 (12)   4.09 (33)   5.03 (3)   5.03 (4)   7.05 (2.1/2)
+@end itemize
 
-@item
+@geindex AI-0037 (Ada 2012 feature)
 
-@code{Unreferenced_Objects}
 
-@tab
+@itemize *
 
-– GNAT
+@item 
+`AI-0037 Out-of-range box associations in aggregate (0000-00-00)'
 
-@item
+This AI confirms that an association of the form @code{Indx => <>} in an
+array aggregate must raise @code{Constraint_Error} if @code{Indx}
+is out of range. The RM specified a range check on other associations, but
+not when the value of the association was defaulted. GNAT has always inserted
+a constraint check on the index value.
 
-@code{Unsuppress}
+RM References:  4.03.03 (29)
+@end itemize
 
-@tab
+@geindex AI-0123 (Ada 2012 feature)
 
-@item
 
-@code{Value_Size}
+@itemize *
 
-@tab
+@item 
+`AI-0123 Composability of equality (2010-04-13)'
 
-– GNAT
+Equality of untagged record composes, so that the predefined equality for a
+composite type that includes a component of some untagged record type
+@code{R} uses the equality operation of @code{R} (which may be user-defined
+or predefined). This makes the behavior of untagged records identical to that
+of tagged types in this respect.
 
-@item
+This change is an incompatibility with previous versions of Ada, but it
+corrects a non-uniformity that was often a source of confusion. Analysis of
+a large number of industrial programs indicates that in those rare cases
+where a composite type had an untagged record component with a user-defined
+equality, either there was no use of the composite equality, or else the code
+expected the same composability as for tagged types, and thus had a bug that
+would be fixed by this change.
 
-@code{Volatile}
+RM References:  4.05.02 (9.7/2)   4.05.02 (14)   4.05.02 (15)   4.05.02 (24)
+8.05.04 (8)
+@end itemize
 
-@tab
+@geindex AI-0088 (Ada 2012 feature)
 
-@item
 
-@code{Volatile_Components}
+@itemize *
 
-@tab
+@item 
+`AI-0088 The value of exponentiation (0000-00-00)'
 
-@item
+This AI clarifies the equivalence rule given for the dynamic semantics of
+exponentiation: the value of the operation can be obtained by repeated
+multiplication, but the operation can be implemented otherwise (for example
+using the familiar divide-by-two-and-square algorithm, even if this is less
+accurate), and does not imply repeated reads of a volatile base.
 
-@code{Warnings}
+RM References:  4.05.06 (11)
+@end itemize
 
-@tab
+@geindex AI-0188 (Ada 2012 feature)
 
-– GNAT
 
-@end multitable
+@itemize *
 
+@item 
+`AI-0188 Case expressions (2010-01-09)'
 
-@quotation
+Case expressions are permitted. This allows use of constructs such as:
 
-Note that for aspects with an expression, e.g. @code{Size}, the expression is
-treated like a default expression (visibility is analyzed at the point of
-occurrence of the aspect, but evaluation of the expression occurs at the
-freeze point of the entity involved).
+@example
+X := (case Y is when 1 => 2, when 2 => 3, when others => 31)
+@end example
 
-RM References:  3.02.01 (3)   3.02.02 (2)   3.03.01 (2/2)   3.08 (6)
-3.09.03 (1.1/2)   6.01 (2/2)   6.07 (2/2)   9.05.02 (2/2)   7.01 (3)   7.03
-(2)   7.03 (3)   9.01 (2/2)   9.01 (3/2)   9.04 (2/2)   9.04 (3/2)
-9.05.02 (2/2)   11.01 (2)   12.01 (3)   12.03 (2/2)   12.04 (2/2)   12.05 (2)
-12.06 (2.1/2)   12.06 (2.2/2)   12.07 (2)   13.01 (0.1/2)   13.03 (5/1)
-13.03.01 (0)
-@end quotation
+RM References:  4.05.07 (0)   4.05.08 (0)   4.09 (12)   4.09 (33)
+@end itemize
 
-@geindex AI-0128 (Ada 2012 feature)
+@geindex AI-0104 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0128 Inequality is a primitive operation (0000-00-00)'
+`AI-0104 Null exclusion and uninitialized allocator (2010-07-15)'
 
-If an equality operator (“=”) is declared for a type, then the implicitly
-declared inequality operator (“/=”) is a primitive operation of the type.
-This is the only reasonable interpretation, and is the one always implemented
-by GNAT, but the RM was not entirely clear in making this point.
+The assignment @code{Ptr := new not null Some_Ptr;} will raise
+@code{Constraint_Error} because the default value of the allocated object is
+`null'. This useless construct is illegal in Ada 2012.
 
-RM References:  3.02.03 (6)   6.06 (6)
+RM References:  4.08 (2)
 @end itemize
 
-@geindex AI-0003 (Ada 2012 feature)
+@geindex AI-0157 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0003 Qualified expressions as names (2010-07-11)'
+`AI-0157 Allocation/Deallocation from empty pool (2010-07-11)'
 
-In Ada 2012, a qualified expression is considered to be syntactically a name,
-meaning that constructs such as @code{A'(F(X)).B} are now legal. This is
-useful in disambiguating some cases of overloading.
+Allocation and Deallocation from an empty storage pool (i.e. allocation or
+deallocation of a pointer for which a static storage size clause of zero
+has been given) is now illegal and is detected as such. GNAT
+previously gave a warning but not an error.
 
-RM References:  3.03 (11)   3.03 (21)   4.01 (2)   4.04 (7)   4.07 (3)
-5.04 (7)
+RM References:  4.08 (5.3/2)   13.11.02 (4)   13.11.02 (17)
 @end itemize
 
-@geindex AI-0120 (Ada 2012 feature)
+@geindex AI-0179 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0120 Constant instance of protected object (0000-00-00)'
+`AI-0179 Statement not required after label (2010-04-10)'
 
-This is an RM editorial change only. The section that lists objects that are
-constant failed to include the current instance of a protected object
-within a protected function. This has always been treated as a constant
-in GNAT.
+It is not necessary to have a statement following a label, so a label
+can appear at the end of a statement sequence without the need for putting a
+null statement afterwards, but it is not allowable to have only labels and
+no real statements in a statement sequence.
 
-RM References:  3.03 (21)
+RM References:  5.01 (2)
 @end itemize
 
-@geindex AI-0008 (Ada 2012 feature)
+@geindex AI-0139-2 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0008 General access to constrained objects (0000-00-00)'
+`AI-0139-2 Syntactic sugar for iterators (2010-09-29)'
 
-The wording in the RM implied that if you have a general access to a
-constrained object, it could be used to modify the discriminants. This was
-obviously not intended. @code{Constraint_Error} should be raised, and GNAT
-has always done so in this situation.
+The new syntax for iterating over arrays and containers is now implemented.
+Iteration over containers is for now limited to read-only iterators. Only
+default iterators are supported, with the syntax:  @code{for Elem of C}.
 
-RM References:  3.03 (23)   3.10.02 (26/2)   4.01 (9)   6.04.01 (17)   8.05.01 (5/2)
+RM References:  5.05
 @end itemize
 
-@geindex AI-0093 (Ada 2012 feature)
+@geindex AI-0134 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0093 Additional rules use immutably limited (0000-00-00)'
+`AI-0134 Profiles must match for full conformance (0000-00-00)'
 
-This is an editorial change only, to make more widespread use of the Ada 2012
-‘immutably limited’.
+For full conformance, the profiles of anonymous-access-to-subprogram
+parameters must match. GNAT has always enforced this rule.
 
-RM References:  3.03 (23.4/3)
+RM References:  6.03.01 (18)
 @end itemize
 
-@geindex AI-0096 (Ada 2012 feature)
+@geindex AI-0207 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0096 Deriving from formal private types (2010-07-20)'
+`AI-0207 Mode conformance and access constant (0000-00-00)'
 
-In general it is illegal for a type derived from a formal limited type to be
-nonlimited.  This AI makes an exception to this rule: derivation is legal
-if it appears in the private part of the generic, and the formal type is not
-tagged. If the type is tagged, the legality check must be applied to the
-private part of the package.
+This AI confirms that access_to_constant indication must match for mode
+conformance. This was implemented in GNAT when the qualifier was originally
+introduced in Ada 2005.
 
-RM References:  3.04 (5.1/2)   6.02 (7)
+RM References:  6.03.01 (16/2)
 @end itemize
 
-@geindex AI-0181 (Ada 2012 feature)
+@geindex AI-0046 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0181 Soft hyphen is a non-graphic character (2010-07-23)'
+`AI-0046 Null exclusion match for full conformance (2010-07-17)'
 
-From Ada 2005 on, soft hyphen is considered a non-graphic character, which
-means that it has a special name (@code{SOFT_HYPHEN}) in conjunction with the
-@code{Image} and @code{Value} attributes for the character types. Strictly
-speaking this is an inconsistency with Ada 95, but in practice the use of
-these attributes is so obscure that it will not cause problems.
+For full conformance, in the case of access parameters, the null exclusion
+must match (either both or neither must have @code{not null}).
 
-RM References:  3.05.02 (2/2)   A.01 (35/2)   A.03.03 (21)
+RM References:  6.03.02 (18)
 @end itemize
 
-@geindex AI-0182 (Ada 2012 feature)
+@geindex AI-0118 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0182 Additional forms for' @code{Character'Value} `(0000-00-00)'
+`AI-0118 The association of parameter associations (0000-00-00)'
 
-This AI allows @code{Character'Value} to accept the string @code{'?'} where
-@code{?} is any character including non-graphic control characters. GNAT has
-always accepted such strings. It also allows strings such as
-@code{HEX_00000041} to be accepted, but GNAT does not take advantage of this
-permission and raises @code{Constraint_Error}, as is certainly still
-permitted.
+This AI clarifies the rules for named associations in subprogram calls and
+generic instantiations. The rules have been in place since Ada 83.
 
-RM References:  3.05 (56/2)
+RM References:  6.04.01 (2)   12.03 (9)
 @end itemize
 
-@geindex AI-0214 (Ada 2012 feature)
+@geindex AI-0196 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0214 Defaulted discriminants for limited tagged (2010-10-01)'
+`AI-0196 Null exclusion tests for out parameters (0000-00-00)'
 
-Ada 2012 relaxes the restriction that forbids discriminants of tagged types
-to have default expressions by allowing them when the type is limited. It
-is often useful to define a default value for a discriminant even though
-it can’t be changed by assignment.
+Null exclusion checks are not made for @code{out} parameters when
+evaluating the actual parameters. GNAT has never generated these checks.
 
-RM References:  3.07 (9.1/2)   3.07.02 (3)
+RM References:  6.04.01 (13)
 @end itemize
 
-@geindex AI-0102 (Ada 2012 feature)
+@geindex AI-0015 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0102 Some implicit conversions are illegal (0000-00-00)'
+`AI-0015 Constant return objects (0000-00-00)'
 
-It is illegal to assign an anonymous access constant to an anonymous access
-variable. The RM did not have a clear rule to prevent this, but GNAT has
-always generated an error for this usage.
+The return object declared in an `extended_return_statement' may be
+declared constant. This was always intended, and GNAT has always allowed it.
 
-RM References:  3.07 (16)   3.07.01 (9)   6.04.01 (6)   8.06 (27/2)
+RM References:  6.05 (2.1/2)   3.03 (10/2)   3.03 (21)   6.05 (5/2)
+6.05 (5.7/2)
 @end itemize
 
-@geindex AI-0158 (Ada 2012 feature)
+@geindex AI-0032 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0158 Generalizing membership tests (2010-09-16)'
+`AI-0032 Extended return for class-wide functions (0000-00-00)'
 
-This AI extends the syntax of membership tests to simplify complex conditions
-that can be expressed as membership in a subset of values of any type. It
-introduces syntax for a list of expressions that may be used in loop contexts
-as well.
+If a function returns a class-wide type, the object of an extended return
+statement can be declared with a specific type that is covered by the class-
+wide type. This has been implemented in GNAT since the introduction of
+extended returns. Note AI-0103 complements this AI by imposing matching
+rules for constrained return types.
 
-RM References:  3.08.01 (5)   4.04 (3)   4.05.02 (3)   4.05.02 (5)   4.05.02 (27)
+RM References:  6.05 (5.2/2)   6.05 (5.3/2)   6.05 (5.6/2)   6.05 (5.8/2)
+6.05 (8/2)
 @end itemize
 
-@geindex AI-0173 (Ada 2012 feature)
+@geindex AI-0103 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0173 Testing if tags represent abstract types (2010-07-03)'
+`AI-0103 Static matching for extended return (2010-07-23)'
 
-The function @code{Ada.Tags.Type_Is_Abstract} returns @code{True} if invoked
-with the tag of an abstract type, and @code{False} otherwise.
+If the return subtype of a function is an elementary type or a constrained
+type, the subtype indication in an extended return statement must match
+statically this return subtype.
 
-RM References:  3.09 (7.4/2)   3.09 (12.4/2)
+RM References:  6.05 (5.2/2)
 @end itemize
 
-@geindex AI-0076 (Ada 2012 feature)
+@geindex AI-0058 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0076 function with controlling result (0000-00-00)'
+`AI-0058 Abnormal completion of an extended return (0000-00-00)'
 
-This is an editorial change only. The RM defines calls with controlling
-results, but uses the term ‘function with controlling result’ without an
-explicit definition.
+The RM had some incorrect wording implying wrong treatment of abnormal
+completion in an extended return. GNAT has always implemented the intended
+correct semantics as described by this AI.
 
-RM References:  3.09.02 (2/2)
+RM References:  6.05 (22/2)
 @end itemize
 
-@geindex AI-0126 (Ada 2012 feature)
+@geindex AI-0050 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0126 Dispatching with no declared operation (0000-00-00)'
+`AI-0050 Raising Constraint_Error early for function call (0000-00-00)'
 
-This AI clarifies dispatching rules, and simply confirms that dispatching
-executes the operation of the parent type when there is no explicitly or
-implicitly declared operation for the descendant type. This has always been
-the case in all versions of GNAT.
+The implementation permissions for raising @code{Constraint_Error} early on a function call
+when it was clear an exception would be raised were over-permissive and allowed
+mishandling of discriminants in some cases. GNAT did
+not take advantage of these incorrect permissions in any case.
 
-RM References:  3.09.02 (20/2)   3.09.02 (20.1/2)   3.09.02 (20.2/2)
+RM References:  6.05 (24/2)
 @end itemize
 
-@geindex AI-0097 (Ada 2012 feature)
+@geindex AI-0125 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0097 Treatment of abstract null extension (2010-07-19)'
+`AI-0125 Nonoverridable operations of an ancestor (2010-09-28)'
 
-The RM as written implied that in some cases it was possible to create an
-object of an abstract type, by having an abstract extension inherit a non-
-abstract constructor from its parent type. This mistake has been corrected
-in GNAT and in the RM, and this construct is now illegal.
+In Ada 2012, the declaration of a primitive operation of a type extension
+or private extension can also override an inherited primitive that is not
+visible at the point of this declaration.
 
-RM References:  3.09.03 (4/2)
+RM References:  7.03.01 (6)   8.03 (23)   8.03.01 (5/2)   8.03.01 (6/2)
 @end itemize
 
-@geindex AI-0203 (Ada 2012 feature)
+@geindex AI-0062 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0203 Extended return cannot be abstract (0000-00-00)'
+`AI-0062 Null exclusions and deferred constants (0000-00-00)'
 
-A return_subtype_indication cannot denote an abstract subtype. GNAT has never
-permitted such usage.
+A full constant may have a null exclusion even if its associated deferred
+constant does not. GNAT has always allowed this.
 
-RM References:  3.09.03 (8/3)
+RM References:  7.04 (6/2)   7.04 (7.1/2)
 @end itemize
 
-@geindex AI-0198 (Ada 2012 feature)
+@geindex AI-0178 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0198 Inheriting abstract operators  (0000-00-00)'
+`AI-0178 Incomplete views are limited (0000-00-00)'
 
-This AI resolves a conflict between two rules involving inherited abstract
-operations and predefined operators. If a derived numeric type inherits
-an abstract operator, it overrides the predefined one. This interpretation
-was always the one implemented in GNAT.
+This AI clarifies the role of incomplete views and plugs an omission in the
+RM. GNAT always correctly restricted the use of incomplete views and types.
 
-RM References:  3.09.03 (4/3)
+RM References:  7.05 (3/2)   7.05 (6/2)
 @end itemize
 
-@geindex AI-0073 (Ada 2012 feature)
+@geindex AI-0087 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0073 Functions returning abstract types (2010-07-10)'
+`AI-0087 Actual for formal nonlimited derived type (2010-07-15)'
 
-This AI covers a number of issues regarding returning abstract types. In
-particular generic functions cannot have abstract result types or access
-result types designated an abstract type. There are some other cases which
-are detailed in the AI. Note that this binding interpretation has not been
-retrofitted to operate before Ada 2012 mode, since it caused a significant
-number of regressions.
+The actual for a formal nonlimited derived type cannot be limited. In
+particular, a formal derived type that extends a limited interface but which
+is not explicitly limited cannot be instantiated with a limited type.
 
-RM References:  3.09.03 (8)   3.09.03 (10)   6.05 (8/2)
+RM References:  7.05 (5/2)   12.05.01 (5.1/2)
 @end itemize
 
-@geindex AI-0070 (Ada 2012 feature)
+@geindex AI-0099 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0070 Elaboration of interface types (0000-00-00)'
+`AI-0099 Tag determines whether finalization needed (0000-00-00)'
 
-This is an editorial change only, there are no testable consequences short of
-checking for the absence of generated code for an interface declaration.
+This AI clarifies that ‘needs finalization’ is part of dynamic semantics,
+and therefore depends on the run-time characteristics of an object (i.e. its
+tag) and not on its nominal type. As the AI indicates: “we do not expect
+this to affect any implementation’’.
 
-RM References:  3.09.04 (18/2)
+RM References:  7.06.01 (6)   7.06.01 (7)   7.06.01 (8)   7.06.01 (9/2)
 @end itemize
 
-@geindex AI-0208 (Ada 2012 feature)
+@geindex AI-0064 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0208 Characteristics of incomplete views (0000-00-00)'
+`AI-0064 Redundant finalization rule (0000-00-00)'
 
-The wording in the Ada 2005 RM concerning characteristics of incomplete views
-was incorrect and implied that some programs intended to be legal were now
-illegal. GNAT had never considered such programs illegal, so it has always
-implemented the intent of this AI.
+This is an editorial change only. The intended behavior is already checked
+by an existing ACATS test, which GNAT has always executed correctly.
 
-RM References:  3.10.01 (2.4/2)   3.10.01 (2.6/2)
+RM References:  7.06.01 (17.1/1)
 @end itemize
 
-@geindex AI-0162 (Ada 2012 feature)
+@geindex AI-0026 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0162 Incomplete type completed by partial view (2010-09-15)'
+`AI-0026 Missing rules for Unchecked_Union (2010-07-07)'
 
-Incomplete types are made more useful by allowing them to be completed by
-private types and private extensions.
+Record representation clauses concerning Unchecked_Union types cannot mention
+the discriminant of the type. The type of a component declared in the variant
+part of an Unchecked_Union cannot be controlled, have controlled components,
+nor have protected or task parts. If an Unchecked_Union type is declared
+within the body of a generic unit or its descendants, then the type of a
+component declared in the variant part cannot be a formal private type or a
+formal private extension declared within the same generic unit.
 
-RM References:  3.10.01 (2.5/2)   3.10.01 (2.6/2)   3.10.01 (3)   3.10.01 (4/2)
+RM References:  7.06 (9.4/2)   B.03.03 (9/2)   B.03.03 (10/2)
 @end itemize
 
-@geindex AI-0098 (Ada 2012 feature)
+@geindex AI-0205 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0098 Anonymous subprogram access restrictions (0000-00-00)'
+`AI-0205 Extended return declares visible name (0000-00-00)'
 
-An unintentional omission in the RM implied some inconsistent restrictions on
-the use of anonymous access to subprogram values. These restrictions were not
-intentional, and have never been enforced by GNAT.
+This AI corrects a simple omission in the RM. Return objects have always
+been visible within an extended return statement.
 
-RM References:  3.10.01 (6)   3.10.01 (9.2/2)
+RM References:  8.03 (17)
 @end itemize
 
-@geindex AI-0199 (Ada 2012 feature)
+@geindex AI-0042 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0199 Aggregate with anonymous access components (2010-07-14)'
+`AI-0042 Overriding versus implemented-by (0000-00-00)'
 
-A choice list in a record aggregate can include several components of
-(distinct) anonymous access types as long as they have matching designated
-subtypes.
+This AI fixes a wording gap in the RM. An operation of a synchronized
+interface can be implemented by a protected or task entry, but the abstract
+operation is not being overridden in the usual sense, and it must be stated
+separately that this implementation is legal. This has always been the case
+in GNAT.
 
-RM References:  4.03.01 (16)
+RM References:  9.01 (9.2/2)   9.04 (11.1/2)
 @end itemize
 
-@geindex AI-0220 (Ada 2012 feature)
+@geindex AI-0030 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0220 Needed components for aggregates (0000-00-00)'
+`AI-0030 Requeue on synchronized interfaces (2010-07-19)'
 
-This AI addresses a wording problem in the RM that appears to permit some
-complex cases of aggregates with nonstatic discriminants. GNAT has always
-implemented the intended semantics.
+Requeue is permitted to a protected, synchronized or task interface primitive
+providing it is known that the overriding operation is an entry. Otherwise
+the requeue statement has the same effect as a procedure call. Use of pragma
+@code{Implemented} provides a way to impose a static requirement on the
+overriding operation by adhering to one of the implementation kinds: entry,
+protected procedure or any of the above.
 
-RM References:  4.03.01 (17)
+RM References:  9.05 (9)   9.05.04 (2)   9.05.04 (3)   9.05.04 (5)
+9.05.04 (6)   9.05.04 (7)   9.05.04 (12)
 @end itemize
 
-@geindex AI-0147 (Ada 2012 feature)
+@geindex AI-0201 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0147 Conditional expressions (2009-03-29)'
-
-Conditional expressions are permitted. The form of such an expression is:
-
-@example
-(if expr then expr @{elsif expr then expr@} [else expr])
-@end example
+`AI-0201 Independence of atomic object components (2010-07-22)'
 
-The parentheses can be omitted in contexts where parentheses are present
-anyway, such as subprogram arguments and pragma arguments. If the `else'
-clause is omitted, `else' `True' is assumed;
-thus @code{(if A then B)} is a way to conveniently represent
-`(A implies B)' in standard logic.
+If an Atomic object has a pragma @code{Pack} or a @code{Component_Size}
+attribute, then individual components may not be addressable by independent
+tasks. However, if the representation clause has no effect (is confirming),
+then independence is not compromised. Furthermore, in GNAT, specification of
+other appropriately addressable component sizes (e.g. 16 for 8-bit
+characters) also preserves independence. GNAT now gives very clear warnings
+both for the declaration of such a type, and for any assignment to its components.
 
-RM References:  4.03.03 (15)   4.04 (1)   4.04 (7)   4.05.07 (0)   4.07 (2)
-4.07 (3)   4.09 (12)   4.09 (33)   5.03 (3)   5.03 (4)   7.05 (2.1/2)
+RM References:  9.10 (1/3)   C.06 (22/2)   C.06 (23/2)
 @end itemize
 
-@geindex AI-0037 (Ada 2012 feature)
+@geindex AI-0009 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0037 Out-of-range box associations in aggregate (0000-00-00)'
+`AI-0009 Pragma Independent[_Components] (2010-07-23)'
 
-This AI confirms that an association of the form @code{Indx => <>} in an
-array aggregate must raise @code{Constraint_Error} if @code{Indx}
-is out of range. The RM specified a range check on other associations, but
-not when the value of the association was defaulted. GNAT has always inserted
-a constraint check on the index value.
+This AI introduces the new pragmas @code{Independent} and
+@code{Independent_Components},
+which control guaranteeing independence of access to objects and components.
+The AI also requires independence not unaffected by confirming rep clauses.
 
-RM References:  4.03.03 (29)
+RM References:  9.10 (1)   13.01 (15/1)   13.02 (9)   13.03 (13)   C.06 (2)
+C.06 (4)   C.06 (6)   C.06 (9)   C.06 (13)   C.06 (14)
 @end itemize
 
-@geindex AI-0123 (Ada 2012 feature)
+@geindex AI-0072 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0123 Composability of equality (2010-04-13)'
-
-Equality of untagged record composes, so that the predefined equality for a
-composite type that includes a component of some untagged record type
-@code{R} uses the equality operation of @code{R} (which may be user-defined
-or predefined). This makes the behavior of untagged records identical to that
-of tagged types in this respect.
+`AI-0072 Task signalling using ‘Terminated (0000-00-00)'
 
-This change is an incompatibility with previous versions of Ada, but it
-corrects a non-uniformity that was often a source of confusion. Analysis of
-a large number of industrial programs indicates that in those rare cases
-where a composite type had an untagged record component with a user-defined
-equality, either there was no use of the composite equality, or else the code
-expected the same composability as for tagged types, and thus had a bug that
-would be fixed by this change.
+This AI clarifies that task signalling for reading @code{'Terminated} only
+occurs if the result is True. GNAT semantics has always been consistent with
+this notion of task signalling.
 
-RM References:  4.05.02 (9.7/2)   4.05.02 (14)   4.05.02 (15)   4.05.02 (24)
-8.05.04 (8)
+RM References:  9.10 (6.1/1)
 @end itemize
 
-@geindex AI-0088 (Ada 2012 feature)
+@geindex AI-0108 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0088 The value of exponentiation (0000-00-00)'
+`AI-0108 Limited incomplete view and discriminants (0000-00-00)'
 
-This AI clarifies the equivalence rule given for the dynamic semantics of
-exponentiation: the value of the operation can be obtained by repeated
-multiplication, but the operation can be implemented otherwise (for example
-using the familiar divide-by-two-and-square algorithm, even if this is less
-accurate), and does not imply repeated reads of a volatile base.
+This AI confirms that an incomplete type from a limited view does not have
+discriminants. This has always been the case in GNAT.
 
-RM References:  4.05.06 (11)
+RM References:  10.01.01 (12.3/2)
 @end itemize
 
-@geindex AI-0188 (Ada 2012 feature)
+@geindex AI-0129 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0188 Case expressions (2010-01-09)'
-
-Case expressions are permitted. This allows use of constructs such as:
+`AI-0129 Limited views and incomplete types (0000-00-00)'
 
-@example
-X := (case Y is when 1 => 2, when 2 => 3, when others => 31)
-@end example
+This AI clarifies the description of limited views: a limited view of a
+package includes only one view of a type that has an incomplete declaration
+and a full declaration (there is no possible ambiguity in a client package).
+This AI also fixes an omission: a nested package in the private part has no
+limited view. GNAT always implemented this correctly.
 
-RM References:  4.05.07 (0)   4.05.08 (0)   4.09 (12)   4.09 (33)
+RM References:  10.01.01 (12.2/2)   10.01.01 (12.3/2)
 @end itemize
 
-@geindex AI-0104 (Ada 2012 feature)
+@geindex AI-0077 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0104 Null exclusion and uninitialized allocator (2010-07-15)'
+`AI-0077 Limited withs and scope of declarations (0000-00-00)'
 
-The assignment @code{Ptr := new not null Some_Ptr;} will raise
-@code{Constraint_Error} because the default value of the allocated object is
-`null'. This useless construct is illegal in Ada 2012.
+This AI clarifies that a declaration does not include a context clause,
+and confirms that it is illegal to have a context in which both a limited
+and a nonlimited view of a package are accessible. Such double visibility
+was always rejected by GNAT.
 
-RM References:  4.08 (2)
+RM References:  10.01.02 (12/2)   10.01.02 (21/2)   10.01.02 (22/2)
 @end itemize
 
-@geindex AI-0157 (Ada 2012 feature)
+@geindex AI-0122 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0157 Allocation/Deallocation from empty pool (2010-07-11)'
+`AI-0122 Private with and children of generics (0000-00-00)'
 
-Allocation and Deallocation from an empty storage pool (i.e. allocation or
-deallocation of a pointer for which a static storage size clause of zero
-has been given) is now illegal and is detected as such. GNAT
-previously gave a warning but not an error.
+This AI clarifies the visibility of private children of generic units within
+instantiations of a parent. GNAT has always handled this correctly.
 
-RM References:  4.08 (5.3/2)   13.11.02 (4)   13.11.02 (17)
+RM References:  10.01.02 (12/2)
 @end itemize
 
-@geindex AI-0179 (Ada 2012 feature)
+@geindex AI-0040 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0179 Statement not required after label (2010-04-10)'
+`AI-0040 Limited with clauses on descendant (0000-00-00)'
 
-It is not necessary to have a statement following a label, so a label
-can appear at the end of a statement sequence without the need for putting a
-null statement afterwards, but it is not allowable to have only labels and
-no real statements in a statement sequence.
+This AI confirms that a limited with clause in a child unit cannot name
+an ancestor of the unit. This has always been checked in GNAT.
 
-RM References:  5.01 (2)
+RM References:  10.01.02 (20/2)
 @end itemize
 
-@geindex AI-0139-2 (Ada 2012 feature)
+@geindex AI-0132 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0139-2 Syntactic sugar for iterators (2010-09-29)'
+`AI-0132 Placement of library unit pragmas (0000-00-00)'
 
-The new syntax for iterating over arrays and containers is now implemented.
-Iteration over containers is for now limited to read-only iterators. Only
-default iterators are supported, with the syntax:  @code{for Elem of C}.
+This AI fills a gap in the description of library unit pragmas. The pragma
+clearly must apply to a library unit, even if it does not carry the name
+of the enclosing unit. GNAT has always enforced the required check.
 
-RM References:  5.05
+RM References:  10.01.05 (7)
 @end itemize
 
-@geindex AI-0134 (Ada 2012 feature)
+@geindex AI-0034 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0134 Profiles must match for full conformance (0000-00-00)'
+`AI-0034 Categorization of limited views (0000-00-00)'
 
-For full conformance, the profiles of anonymous-access-to-subprogram
-parameters must match. GNAT has always enforced this rule.
+The RM makes certain limited with clauses illegal because of categorization
+considerations, when the corresponding normal with would be legal. This is
+not intended, and GNAT has always implemented the recommended behavior.
 
-RM References:  6.03.01 (18)
+RM References:  10.02.01 (11/1)   10.02.01 (17/2)
 @end itemize
 
-@geindex AI-0207 (Ada 2012 feature)
+@geindex AI-0035 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0207 Mode conformance and access constant (0000-00-00)'
+`AI-0035 Inconsistencies with Pure units (0000-00-00)'
 
-This AI confirms that access_to_constant indication must match for mode
-conformance. This was implemented in GNAT when the qualifier was originally
-introduced in Ada 2005.
+This AI remedies some inconsistencies in the legality rules for Pure units.
+Derived access types are legal in a pure unit (on the assumption that the
+rule for a zero storage pool size has been enforced on the ancestor type).
+The rules are enforced in generic instances and in subunits. GNAT has always
+implemented the recommended behavior.
 
-RM References:  6.03.01 (16/2)
+RM References:  10.02.01 (15.1/2)   10.02.01 (15.4/2)   10.02.01 (15.5/2)   10.02.01 (17/2)
 @end itemize
 
-@geindex AI-0046 (Ada 2012 feature)
+@geindex AI-0219 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0046 Null exclusion match for full conformance (2010-07-17)'
+`AI-0219 Pure permissions and limited parameters (2010-05-25)'
 
-For full conformance, in the case of access parameters, the null exclusion
-must match (either both or neither must have @code{not null}).
+This AI refines the rules for the cases with limited parameters which do not
+allow the implementations to omit ‘redundant’. GNAT now properly conforms
+to the requirements of this binding interpretation.
 
-RM References:  6.03.02 (18)
+RM References:  10.02.01 (18/2)
 @end itemize
 
-@geindex AI-0118 (Ada 2012 feature)
+@geindex AI-0043 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0118 The association of parameter associations (0000-00-00)'
+`AI-0043 Rules about raising exceptions (0000-00-00)'
 
-This AI clarifies the rules for named associations in subprogram calls and
-generic instantiations. The rules have been in place since Ada 83.
+This AI covers various omissions in the RM regarding the raising of
+exceptions. GNAT has always implemented the intended semantics.
 
-RM References:  6.04.01 (2)   12.03 (9)
+RM References:  11.04.01 (10.1/2)   11 (2)
 @end itemize
 
-@geindex AI-0196 (Ada 2012 feature)
+@geindex AI-0200 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0196 Null exclusion tests for out parameters (0000-00-00)'
+`AI-0200 Mismatches in formal package declarations (0000-00-00)'
 
-Null exclusion checks are not made for @code{out} parameters when
-evaluating the actual parameters. GNAT has never generated these checks.
+This AI plugs a gap in the RM which appeared to allow some obviously intended
+illegal instantiations. GNAT has never allowed these instantiations.
 
-RM References:  6.04.01 (13)
+RM References:  12.07 (16)
 @end itemize
 
-@geindex AI-0015 (Ada 2012 feature)
+@geindex AI-0112 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0015 Constant return objects (0000-00-00)'
+`AI-0112 Detection of duplicate pragmas (2010-07-24)'
 
-The return object declared in an `extended_return_statement' may be
-declared constant. This was always intended, and GNAT has always allowed it.
+This AI concerns giving names to various representation aspects, but the
+practical effect is simply to make the use of duplicate
+@code{Atomic[_Components]},
+@code{Volatile[_Components]}, and
+@code{Independent[_Components]} pragmas illegal, and GNAT
+now performs this required check.
 
-RM References:  6.05 (2.1/2)   3.03 (10/2)   3.03 (21)   6.05 (5/2)
-6.05 (5.7/2)
+RM References:  13.01 (8)
 @end itemize
 
-@geindex AI-0032 (Ada 2012 feature)
+@geindex AI-0106 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0032 Extended return for class-wide functions (0000-00-00)'
+`AI-0106 No representation pragmas on generic formals (0000-00-00)'
 
-If a function returns a class-wide type, the object of an extended return
-statement can be declared with a specific type that is covered by the class-
-wide type. This has been implemented in GNAT since the introduction of
-extended returns. Note AI-0103 complements this AI by imposing matching
-rules for constrained return types.
+The RM appeared to allow representation pragmas on generic formal parameters,
+but this was not intended, and GNAT has never permitted this usage.
 
-RM References:  6.05 (5.2/2)   6.05 (5.3/2)   6.05 (5.6/2)   6.05 (5.8/2)
-6.05 (8/2)
+RM References:  13.01 (9.1/1)
 @end itemize
 
-@geindex AI-0103 (Ada 2012 feature)
+@geindex AI-0012 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0103 Static matching for extended return (2010-07-23)'
+`AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)'
 
-If the return subtype of a function is an elementary type or a constrained
-type, the subtype indication in an extended return statement must match
-statically this return subtype.
+It is now illegal to give an inappropriate component size or a pragma
+@code{Pack} that attempts to change the component size in the case of atomic
+or aliased components. Previously GNAT ignored such an attempt with a
+warning.
 
-RM References:  6.05 (5.2/2)
+RM References:  13.02 (6.1/2)   13.02 (7)   C.06 (10)   C.06 (11)   C.06 (21)
 @end itemize
 
-@geindex AI-0058 (Ada 2012 feature)
+@geindex AI-0039 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0058 Abnormal completion of an extended return (0000-00-00)'
+`AI-0039 Stream attributes cannot be dynamic (0000-00-00)'
 
-The RM had some incorrect wording implying wrong treatment of abnormal
-completion in an extended return. GNAT has always implemented the intended
-correct semantics as described by this AI.
+The RM permitted the use of dynamic expressions (such as @code{ptr.all})`
+for stream attributes, but these were never useful and are now illegal. GNAT
+has always regarded such expressions as illegal.
 
-RM References:  6.05 (22/2)
+RM References:  13.03 (4)   13.03 (6)   13.13.02 (38/2)
 @end itemize
 
-@geindex AI-0050 (Ada 2012 feature)
+@geindex AI-0095 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0050 Raising Constraint_Error early for function call (0000-00-00)'
+`AI-0095 Address of intrinsic subprograms (0000-00-00)'
 
-The implementation permissions for raising @code{Constraint_Error} early on a function call
-when it was clear an exception would be raised were over-permissive and allowed
-mishandling of discriminants in some cases. GNAT did
-not take advantage of these incorrect permissions in any case.
+The prefix of @code{'Address} cannot statically denote a subprogram with
+convention @code{Intrinsic}. The use of the @code{Address} attribute raises
+@code{Program_Error} if the prefix denotes a subprogram with convention
+@code{Intrinsic}.
 
-RM References:  6.05 (24/2)
+RM References:  13.03 (11/1)
 @end itemize
 
-@geindex AI-0125 (Ada 2012 feature)
+@geindex AI-0116 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0125 Nonoverridable operations of an ancestor (2010-09-28)'
+`AI-0116 Alignment of class-wide objects (0000-00-00)'
 
-In Ada 2012, the declaration of a primitive operation of a type extension
-or private extension can also override an inherited primitive that is not
-visible at the point of this declaration.
+This AI requires that the alignment of a class-wide object be no greater
+than the alignment of any type in the class. GNAT has always followed this
+recommendation.
 
-RM References:  7.03.01 (6)   8.03 (23)   8.03.01 (5/2)   8.03.01 (6/2)
+RM References:  13.03 (29)   13.11 (16)
 @end itemize
 
-@geindex AI-0062 (Ada 2012 feature)
+@geindex AI-0146 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0062 Null exclusions and deferred constants (0000-00-00)'
+`AI-0146 Type invariants (2009-09-21)'
 
-A full constant may have a null exclusion even if its associated deferred
-constant does not. GNAT has always allowed this.
+Type invariants may be specified for private types using the aspect notation.
+Aspect @code{Type_Invariant} may be specified for any private type,
+@code{Type_Invariant'Class} can
+only be specified for tagged types, and is inherited by any descendent of the
+tagged types. The invariant is a boolean expression that is tested for being
+true in the following situations: conversions to the private type, object
+declarations for the private type that are default initialized, and
+[`in'] `out'
+parameters and returned result on return from any primitive operation for
+the type that is visible to a client.
+GNAT defines the synonyms @code{Invariant} for @code{Type_Invariant} and
+@code{Invariant'Class} for @code{Type_Invariant'Class}.
 
-RM References:  7.04 (6/2)   7.04 (7.1/2)
+RM References:  13.03.03 (00)
 @end itemize
 
-@geindex AI-0178 (Ada 2012 feature)
+@geindex AI-0078 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0178 Incomplete views are limited (0000-00-00)'
+`AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)'
 
-This AI clarifies the role of incomplete views and plugs an omission in the
-RM. GNAT always correctly restricted the use of incomplete views and types.
+In Ada 2012, compilers are required to support unchecked conversion where the
+target alignment is a multiple of the source alignment. GNAT always supported
+this case (and indeed all cases of differing alignments, doing copies where
+required if the alignment was reduced).
 
-RM References:  7.05 (3/2)   7.05 (6/2)
+RM References:  13.09 (7)
 @end itemize
 
-@geindex AI-0087 (Ada 2012 feature)
+@geindex AI-0195 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0087 Actual for formal nonlimited derived type (2010-07-15)'
+`AI-0195 Invalid value handling is implementation defined (2010-07-03)'
 
-The actual for a formal nonlimited derived type cannot be limited. In
-particular, a formal derived type that extends a limited interface but which
-is not explicitly limited cannot be instantiated with a limited type.
+The handling of invalid values is now designated to be implementation
+defined. This is a documentation change only, requiring Annex M in the GNAT
+Reference Manual to document this handling.
+In GNAT, checks for invalid values are made
+only when necessary to avoid erroneous behavior. Operations like assignments
+which cannot cause erroneous behavior ignore the possibility of invalid
+values and do not do a check. The date given above applies only to the
+documentation change, this behavior has always been implemented by GNAT.
 
-RM References:  7.05 (5/2)   12.05.01 (5.1/2)
+RM References:  13.09.01 (10)
 @end itemize
 
-@geindex AI-0099 (Ada 2012 feature)
+@geindex AI-0193 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0099 Tag determines whether finalization needed (0000-00-00)'
+`AI-0193 Alignment of allocators (2010-09-16)'
 
-This AI clarifies that ‘needs finalization’ is part of dynamic semantics,
-and therefore depends on the run-time characteristics of an object (i.e. its
-tag) and not on its nominal type. As the AI indicates: “we do not expect
-this to affect any implementation’’.
+This AI introduces a new attribute @code{Max_Alignment_For_Allocation},
+analogous to @code{Max_Size_In_Storage_Elements}, but for alignment instead
+of size.
 
-RM References:  7.06.01 (6)   7.06.01 (7)   7.06.01 (8)   7.06.01 (9/2)
+RM References:  13.11 (16)   13.11 (21)   13.11.01 (0)   13.11.01 (1)
+13.11.01 (2)   13.11.01 (3)
 @end itemize
 
-@geindex AI-0064 (Ada 2012 feature)
+@geindex AI-0177 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0064 Redundant finalization rule (0000-00-00)'
+`AI-0177 Parameterized expressions (2010-07-10)'
 
-This is an editorial change only. The intended behavior is already checked
-by an existing ACATS test, which GNAT has always executed correctly.
+The new Ada 2012 notion of parameterized expressions is implemented. The form
+is:
 
-RM References:  7.06.01 (17.1/1)
+@example
+function-specification is (expression)
+@end example
+
+This is exactly equivalent to the
+corresponding function body that returns the expression, but it can appear
+in a package spec. Note that the expression must be parenthesized.
+
+RM References:  13.11.01 (3/2)
 @end itemize
 
-@geindex AI-0026 (Ada 2012 feature)
+@geindex AI-0033 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0026 Missing rules for Unchecked_Union (2010-07-07)'
+`AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)'
 
-Record representation clauses concerning Unchecked_Union types cannot mention
-the discriminant of the type. The type of a component declared in the variant
-part of an Unchecked_Union cannot be controlled, have controlled components,
-nor have protected or task parts. If an Unchecked_Union type is declared
-within the body of a generic unit or its descendants, then the type of a
-component declared in the variant part cannot be a formal private type or a
-formal private extension declared within the same generic unit.
+Neither of these two pragmas may appear within a generic template, because
+the generic might be instantiated at other than the library level.
 
-RM References:  7.06 (9.4/2)   B.03.03 (9/2)   B.03.03 (10/2)
+RM References:  13.11.02 (16)   C.03.01 (7/2)   C.03.01 (8/2)
 @end itemize
 
-@geindex AI-0205 (Ada 2012 feature)
+@geindex AI-0161 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0205 Extended return declares visible name (0000-00-00)'
+`AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)'
 
-This AI corrects a simple omission in the RM. Return objects have always
-been visible within an extended return statement.
+A new restriction @code{No_Default_Stream_Attributes} prevents the use of any
+of the default stream attributes for elementary types. If this restriction is
+in force, then it is necessary to provide explicit subprograms for any
+stream attributes used.
 
-RM References:  8.03 (17)
+RM References:  13.12.01 (4/2)   13.13.02 (40/2)   13.13.02 (52/2)
 @end itemize
 
-@geindex AI-0042 (Ada 2012 feature)
+@geindex AI-0194 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0042 Overriding versus implemented-by (0000-00-00)'
+`AI-0194 Value of Stream_Size attribute (0000-00-00)'
 
-This AI fixes a wording gap in the RM. An operation of a synchronized
-interface can be implemented by a protected or task entry, but the abstract
-operation is not being overridden in the usual sense, and it must be stated
-separately that this implementation is legal. This has always been the case
-in GNAT.
+The @code{Stream_Size} attribute returns the default number of bits in the
+stream representation of the given type.
+This value is not affected by the presence
+of stream subprogram attributes for the type. GNAT has always implemented
+this interpretation.
 
-RM References:  9.01 (9.2/2)   9.04 (11.1/2)
+RM References:  13.13.02 (1.2/2)
 @end itemize
 
-@geindex AI-0030 (Ada 2012 feature)
+@geindex AI-0109 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0030 Requeue on synchronized interfaces (2010-07-19)'
+`AI-0109 Redundant check in S’Class’Input (0000-00-00)'
 
-Requeue is permitted to a protected, synchronized or task interface primitive
-providing it is known that the overriding operation is an entry. Otherwise
-the requeue statement has the same effect as a procedure call. Use of pragma
-@code{Implemented} provides a way to impose a static requirement on the
-overriding operation by adhering to one of the implementation kinds: entry,
-protected procedure or any of the above.
+This AI is an editorial change only. It removes the need for a tag check
+that can never fail.
 
-RM References:  9.05 (9)   9.05.04 (2)   9.05.04 (3)   9.05.04 (5)
-9.05.04 (6)   9.05.04 (7)   9.05.04 (12)
+RM References:  13.13.02 (34/2)
 @end itemize
 
-@geindex AI-0201 (Ada 2012 feature)
+@geindex AI-0007 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0201 Independence of atomic object components (2010-07-22)'
+`AI-0007 Stream read and private scalar types (0000-00-00)'
 
-If an Atomic object has a pragma @code{Pack} or a @code{Component_Size}
-attribute, then individual components may not be addressable by independent
-tasks. However, if the representation clause has no effect (is confirming),
-then independence is not compromised. Furthermore, in GNAT, specification of
-other appropriately addressable component sizes (e.g. 16 for 8-bit
-characters) also preserves independence. GNAT now gives very clear warnings
-both for the declaration of such a type, and for any assignment to its components.
+The RM as written appeared to limit the possibilities of declaring read
+attribute procedures for private scalar types. This limitation was not
+intended, and has never been enforced by GNAT.
 
-RM References:  9.10 (1/3)   C.06 (22/2)   C.06 (23/2)
+RM References:  13.13.02 (50/2)   13.13.02 (51/2)
 @end itemize
 
-@geindex AI-0009 (Ada 2012 feature)
+@geindex AI-0065 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0009 Pragma Independent[_Components] (2010-07-23)'
+`AI-0065 Remote access types and external streaming (0000-00-00)'
 
-This AI introduces the new pragmas @code{Independent} and
-@code{Independent_Components},
-which control guaranteeing independence of access to objects and components.
-The AI also requires independence not unaffected by confirming rep clauses.
+This AI clarifies the fact that all remote access types support external
+streaming. This fixes an obvious oversight in the definition of the
+language, and GNAT always implemented the intended correct rules.
 
-RM References:  9.10 (1)   13.01 (15/1)   13.02 (9)   13.03 (13)   C.06 (2)
-C.06 (4)   C.06 (6)   C.06 (9)   C.06 (13)   C.06 (14)
+RM References:  13.13.02 (52/2)
 @end itemize
 
-@geindex AI-0072 (Ada 2012 feature)
+@geindex AI-0019 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0072 Task signalling using ‘Terminated (0000-00-00)'
+`AI-0019 Freezing of primitives for tagged types (0000-00-00)'
 
-This AI clarifies that task signalling for reading @code{'Terminated} only
-occurs if the result is True. GNAT semantics has always been consistent with
-this notion of task signalling.
+The RM suggests that primitive subprograms of a specific tagged type are
+frozen when the tagged type is frozen. This would be an incompatible change
+and is not intended. GNAT has never attempted this kind of freezing and its
+behavior is consistent with the recommendation of this AI.
 
-RM References:  9.10 (6.1/1)
+RM References:  13.14 (2)   13.14 (3/1)   13.14 (8.1/1)   13.14 (10)   13.14 (14)   13.14 (15.1/2)
 @end itemize
 
-@geindex AI-0108 (Ada 2012 feature)
+@geindex AI-0017 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0108 Limited incomplete view and discriminants (0000-00-00)'
+`AI-0017 Freezing and incomplete types (0000-00-00)'
 
-This AI confirms that an incomplete type from a limited view does not have
-discriminants. This has always been the case in GNAT.
+So-called ‘Taft-amendment types’ (i.e., types that are completed in package
+bodies) are not frozen by the occurrence of bodies in the
+enclosing declarative part. GNAT always implemented this properly.
 
-RM References:  10.01.01 (12.3/2)
+RM References:  13.14 (3/1)
 @end itemize
 
-@geindex AI-0129 (Ada 2012 feature)
+@geindex AI-0060 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0129 Limited views and incomplete types (0000-00-00)'
+`AI-0060 Extended definition of remote access types (0000-00-00)'
 
-This AI clarifies the description of limited views: a limited view of a
-package includes only one view of a type that has an incomplete declaration
-and a full declaration (there is no possible ambiguity in a client package).
-This AI also fixes an omission: a nested package in the private part has no
-limited view. GNAT always implemented this correctly.
+This AI extends the definition of remote access types to include access
+to limited, synchronized, protected or task class-wide interface types.
+GNAT already implemented this extension.
 
-RM References:  10.01.01 (12.2/2)   10.01.01 (12.3/2)
+RM References:  A (4)   E.02.02 (9/1)   E.02.02 (9.2/1)   E.02.02 (14/2)   E.02.02 (18)
 @end itemize
 
-@geindex AI-0077 (Ada 2012 feature)
+@geindex AI-0114 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0077 Limited withs and scope of declarations (0000-00-00)'
+`AI-0114 Classification of letters (0000-00-00)'
 
-This AI clarifies that a declaration does not include a context clause,
-and confirms that it is illegal to have a context in which both a limited
-and a nonlimited view of a package are accessible. Such double visibility
-was always rejected by GNAT.
+The code points 170 (@code{FEMININE ORDINAL INDICATOR}),
+181 (@code{MICRO SIGN}), and
+186 (@code{MASCULINE ORDINAL INDICATOR}) are technically considered
+lower case letters by Unicode.
+However, they are not allowed in identifiers, and they
+return @code{False} to @code{Ada.Characters.Handling.Is_Letter/Is_Lower}.
+This behavior is consistent with that defined in Ada 95.
 
-RM References:  10.01.02 (12/2)   10.01.02 (21/2)   10.01.02 (22/2)
+RM References:  A.03.02 (59)   A.04.06 (7)
 @end itemize
 
-@geindex AI-0122 (Ada 2012 feature)
+@geindex AI-0185 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0122 Private with and children of generics (0000-00-00)'
+`AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)'
 
-This AI clarifies the visibility of private children of generic units within
-instantiations of a parent. GNAT has always handled this correctly.
+Two new packages @code{Ada.Wide_[Wide_]Characters.Handling} provide
+classification functions for @code{Wide_Character} and
+@code{Wide_Wide_Character}, as well as providing
+case folding routines for @code{Wide_[Wide_]Character} and
+@code{Wide_[Wide_]String}.
 
-RM References:  10.01.02 (12/2)
+RM References:  A.03.05 (0)   A.03.06 (0)
 @end itemize
 
-@geindex AI-0040 (Ada 2012 feature)
+@geindex AI-0031 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0040 Limited with clauses on descendant (0000-00-00)'
+`AI-0031 Add From parameter to Find_Token (2010-07-25)'
 
-This AI confirms that a limited with clause in a child unit cannot name
-an ancestor of the unit. This has always been checked in GNAT.
+A new version of @code{Find_Token} is added to all relevant string packages,
+with an extra parameter @code{From}. Instead of starting at the first
+character of the string, the search for a matching Token starts at the
+character indexed by the value of @code{From}.
+These procedures are available in all versions of Ada
+but if used in versions earlier than Ada 2012 they will generate a warning
+that an Ada 2012 subprogram is being used.
 
-RM References:  10.01.02 (20/2)
+RM References:  A.04.03 (16)   A.04.03 (67)   A.04.03 (68/1)   A.04.04 (51)
+A.04.05 (46)
 @end itemize
 
-@geindex AI-0132 (Ada 2012 feature)
+@geindex AI-0056 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0132 Placement of library unit pragmas (0000-00-00)'
+`AI-0056 Index on null string returns zero (0000-00-00)'
 
-This AI fills a gap in the description of library unit pragmas. The pragma
-clearly must apply to a library unit, even if it does not carry the name
-of the enclosing unit. GNAT has always enforced the required check.
+The wording in the Ada 2005 RM implied an incompatible handling of the
+@code{Index} functions, resulting in raising an exception instead of
+returning zero in some situations.
+This was not intended and has been corrected.
+GNAT always returned zero, and is thus consistent with this AI.
 
-RM References:  10.01.05 (7)
+RM References:  A.04.03 (56.2/2)   A.04.03 (58.5/2)
 @end itemize
 
-@geindex AI-0034 (Ada 2012 feature)
+@geindex AI-0137 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0034 Categorization of limited views (0000-00-00)'
+`AI-0137 String encoding package (2010-03-25)'
 
-The RM makes certain limited with clauses illegal because of categorization
-considerations, when the corresponding normal with would be legal. This is
-not intended, and GNAT has always implemented the recommended behavior.
+The packages @code{Ada.Strings.UTF_Encoding}, together with its child
+packages, @code{Conversions}, @code{Strings}, @code{Wide_Strings},
+and @code{Wide_Wide_Strings} have been
+implemented. These packages (whose documentation can be found in the spec
+files @code{a-stuten.ads}, @code{a-suenco.ads}, @code{a-suenst.ads},
+@code{a-suewst.ads}, @code{a-suezst.ads}) allow encoding and decoding of
+@code{String}, @code{Wide_String}, and @code{Wide_Wide_String}
+values using UTF coding schemes (including UTF-8, UTF-16LE, UTF-16BE, and
+UTF-16), as well as conversions between the different UTF encodings. With
+the exception of @code{Wide_Wide_Strings}, these packages are available in
+Ada 95 and Ada 2005 mode as well as Ada 2012 mode.
+The @code{Wide_Wide_Strings} package
+is available in Ada 2005 mode as well as Ada 2012 mode (but not in Ada 95
+mode since it uses @code{Wide_Wide_Character}).
 
-RM References:  10.02.01 (11/1)   10.02.01 (17/2)
+RM References:  A.04.11
 @end itemize
 
-@geindex AI-0035 (Ada 2012 feature)
+@geindex AI-0038 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0035 Inconsistencies with Pure units (0000-00-00)'
+`AI-0038 Minor errors in Text_IO (0000-00-00)'
 
-This AI remedies some inconsistencies in the legality rules for Pure units.
-Derived access types are legal in a pure unit (on the assumption that the
-rule for a zero storage pool size has been enforced on the ancestor type).
-The rules are enforced in generic instances and in subunits. GNAT has always
-implemented the recommended behavior.
+These are minor errors in the description on three points. The intent on
+all these points has always been clear, and GNAT has always implemented the
+correct intended semantics.
 
-RM References:  10.02.01 (15.1/2)   10.02.01 (15.4/2)   10.02.01 (15.5/2)   10.02.01 (17/2)
+RM References:  A.10.05 (37)   A.10.07 (8/1)   A.10.07 (10)   A.10.07 (12)   A.10.08 (10)   A.10.08 (24)
 @end itemize
 
-@geindex AI-0219 (Ada 2012 feature)
+@geindex AI-0044 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0219 Pure permissions and limited parameters (2010-05-25)'
+`AI-0044 Restrictions on container instantiations (0000-00-00)'
 
-This AI refines the rules for the cases with limited parameters which do not
-allow the implementations to omit ‘redundant’. GNAT now properly conforms
-to the requirements of this binding interpretation.
+This AI places restrictions on allowed instantiations of generic containers.
+These restrictions are not checked by the compiler, so there is nothing to
+change in the implementation. This affects only the RM documentation.
 
-RM References:  10.02.01 (18/2)
+RM References:  A.18 (4/2)   A.18.02 (231/2)   A.18.03 (145/2)   A.18.06 (56/2)   A.18.08 (66/2)   A.18.09 (79/2)   A.18.26 (5/2)   A.18.26 (9/2)
 @end itemize
 
-@geindex AI-0043 (Ada 2012 feature)
+@geindex AI-0127 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0043 Rules about raising exceptions (0000-00-00)'
+`AI-0127 Adding Locale Capabilities (2010-09-29)'
 
-This AI covers various omissions in the RM regarding the raising of
-exceptions. GNAT has always implemented the intended semantics.
+This package provides an interface for identifying the current locale.
 
-RM References:  11.04.01 (10.1/2)   11 (2)
+RM References:  A.19    A.19.01    A.19.02    A.19.03    A.19.05    A.19.06
+A.19.07    A.19.08    A.19.09    A.19.10    A.19.11    A.19.12    A.19.13
 @end itemize
 
-@geindex AI-0200 (Ada 2012 feature)
+@geindex AI-0002 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0200 Mismatches in formal package declarations (0000-00-00)'
+`AI-0002 Export C with unconstrained arrays (0000-00-00)'
 
-This AI plugs a gap in the RM which appeared to allow some obviously intended
-illegal instantiations. GNAT has never allowed these instantiations.
+The compiler is not required to support exporting an Ada subprogram with
+convention C if there are parameters or a return type of an unconstrained
+array type (such as @code{String}). GNAT allows such declarations but
+generates warnings. It is possible, but complicated, to write the
+corresponding C code and certainly such code would be specific to GNAT and
+non-portable.
 
-RM References:  12.07 (16)
+RM References:  B.01 (17)   B.03 (62)   B.03 (71.1/2)
 @end itemize
 
-@geindex AI-0112 (Ada 2012 feature)
+@geindex AI05-0216 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0112 Detection of duplicate pragmas (2010-07-24)'
+`AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)'
 
-This AI concerns giving names to various representation aspects, but the
-practical effect is simply to make the use of duplicate
-@code{Atomic[_Components]},
-@code{Volatile[_Components]}, and
-@code{Independent[_Components]} pragmas illegal, and GNAT
-now performs this required check.
+It is clearly the intention that @code{No_Task_Hierarchy} is intended to
+forbid tasks declared locally within subprograms, or functions returning task
+objects, and that is the implementation that GNAT has always provided.
+However the language in the RM was not sufficiently clear on this point.
+Thus this is a documentation change in the RM only.
 
-RM References:  13.01 (8)
+RM References:  D.07 (3/3)
 @end itemize
 
-@geindex AI-0106 (Ada 2012 feature)
+@geindex AI-0211 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0106 No representation pragmas on generic formals (0000-00-00)'
+`AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)'
 
-The RM appeared to allow representation pragmas on generic formal parameters,
-but this was not intended, and GNAT has never permitted this usage.
+The restriction @code{No_Relative_Delays} forbids any calls to the subprogram
+@code{Ada.Real_Time.Timing_Events.Set_Handler}.
 
-RM References:  13.01 (9.1/1)
+RM References:  D.07 (5)   D.07 (10/2)   D.07 (10.4/2)   D.07 (10.7/2)
 @end itemize
 
-@geindex AI-0012 (Ada 2012 feature)
+@geindex AI-0190 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)'
+`AI-0190 pragma Default_Storage_Pool (2010-09-15)'
 
-It is now illegal to give an inappropriate component size or a pragma
-@code{Pack} that attempts to change the component size in the case of atomic
-or aliased components. Previously GNAT ignored such an attempt with a
-warning.
+This AI introduces a new pragma @code{Default_Storage_Pool}, which can be
+used to control storage pools globally.
+In particular, you can force every access
+type that is used for allocation (`new') to have an explicit storage pool,
+or you can declare a pool globally to be used for all access types that lack
+an explicit one.
 
-RM References:  13.02 (6.1/2)   13.02 (7)   C.06 (10)   C.06 (11)   C.06 (21)
+RM References:  D.07 (8)
 @end itemize
 
-@geindex AI-0039 (Ada 2012 feature)
+@geindex AI-0189 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0039 Stream attributes cannot be dynamic (0000-00-00)'
+`AI-0189 No_Allocators_After_Elaboration (2010-01-23)'
 
-The RM permitted the use of dynamic expressions (such as @code{ptr.all})`
-for stream attributes, but these were never useful and are now illegal. GNAT
-has always regarded such expressions as illegal.
+This AI introduces a new restriction @code{No_Allocators_After_Elaboration},
+which says that no dynamic allocation will occur once elaboration is
+completed.
+In general this requires a run-time check, which is not required, and which
+GNAT does not attempt. But the static cases of allocators in a task body or
+in the body of the main program are detected and flagged at compile or bind
+time.
 
-RM References:  13.03 (4)   13.03 (6)   13.13.02 (38/2)
+RM References:  D.07 (19.1/2)   H.04 (23.3/2)
 @end itemize
 
-@geindex AI-0095 (Ada 2012 feature)
+@geindex AI-0171 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0095 Address of intrinsic subprograms (0000-00-00)'
+`AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)'
 
-The prefix of @code{'Address} cannot statically denote a subprogram with
-convention @code{Intrinsic}. The use of the @code{Address} attribute raises
-@code{Program_Error} if the prefix denotes a subprogram with convention
-@code{Intrinsic}.
+A new package @code{System.Multiprocessors} is added, together with the
+definition of pragma @code{CPU} for controlling task affinity. A new no
+dependence restriction, on @code{System.Multiprocessors.Dispatching_Domains},
+is added to the Ravenscar profile.
 
-RM References:  13.03 (11/1)
+RM References:  D.13.01 (4/2)   D.16
 @end itemize
 
-@geindex AI-0116 (Ada 2012 feature)
+@geindex AI-0210 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0116 Alignment of class-wide objects (0000-00-00)'
+`AI-0210 Correct Timing_Events metric (0000-00-00)'
 
-This AI requires that the alignment of a class-wide object be no greater
-than the alignment of any type in the class. GNAT has always followed this
-recommendation.
+This is a documentation only issue regarding wording of metric requirements,
+that does not affect the implementation of the compiler.
 
-RM References:  13.03 (29)   13.11 (16)
+RM References:  D.15 (24/2)
 @end itemize
 
-@geindex AI-0146 (Ada 2012 feature)
+@geindex AI-0206 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0146 Type invariants (2009-09-21)'
+`AI-0206 Remote types packages and preelaborate (2010-07-24)'
 
-Type invariants may be specified for private types using the aspect notation.
-Aspect @code{Type_Invariant} may be specified for any private type,
-@code{Type_Invariant'Class} can
-only be specified for tagged types, and is inherited by any descendent of the
-tagged types. The invariant is a boolean expression that is tested for being
-true in the following situations: conversions to the private type, object
-declarations for the private type that are default initialized, and
-[`in'] `out'
-parameters and returned result on return from any primitive operation for
-the type that is visible to a client.
-GNAT defines the synonyms @code{Invariant} for @code{Type_Invariant} and
-@code{Invariant'Class} for @code{Type_Invariant'Class}.
+Remote types packages are now allowed to depend on preelaborated packages.
+This was formerly considered illegal.
 
-RM References:  13.03.03 (00)
+RM References:  E.02.02 (6)
 @end itemize
 
-@geindex AI-0078 (Ada 2012 feature)
+@geindex AI-0152 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)'
+`AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)'
 
-In Ada 2012, compilers are required to support unchecked conversion where the
-target alignment is a multiple of the source alignment. GNAT always supported
-this case (and indeed all cases of differing alignments, doing copies where
-required if the alignment was reduced).
+Restriction @code{No_Anonymous_Allocators} prevents the use of allocators
+where the type of the returned value is an anonymous access type.
 
-RM References:  13.09 (7)
+RM References:  H.04 (8/1)
 @end itemize
 
-@geindex AI-0195 (Ada 2012 feature)
+@node GNAT language extensions,Security Hardening Features,Implementation of Ada 2012 Features,Top
+@anchor{gnat_rm/gnat_language_extensions doc}@anchor{42e}@anchor{gnat_rm/gnat_language_extensions gnat-language-extensions}@anchor{42f}@anchor{gnat_rm/gnat_language_extensions id1}@anchor{430}
+@chapter GNAT language extensions
+
+
+The GNAT compiler implements a certain number of language extensions on top of
+the latest Ada standard, implementing its own extended superset of Ada.
+
+There are two sets of language extensions:
 
 
 @itemize *
 
 @item 
-`AI-0195 Invalid value handling is implementation defined (2010-07-03)'
-
-The handling of invalid values is now designated to be implementation
-defined. This is a documentation change only, requiring Annex M in the GNAT
-Reference Manual to document this handling.
-In GNAT, checks for invalid values are made
-only when necessary to avoid erroneous behavior. Operations like assignments
-which cannot cause erroneous behavior ignore the possibility of invalid
-values and do not do a check. The date given above applies only to the
-documentation change, this behavior has always been implemented by GNAT.
+The first is the curated set. The features in that set are features that we
+consider being worthy additions to the Ada language, and that we want to make
+available to users early on.
 
-RM References:  13.09.01 (10)
+@item 
+The second is the experimental set. It includes the first, but also
+experimental features, that are here because they’re still in an early
+prototyping phase.
 @end itemize
 
-@geindex AI-0193 (Ada 2012 feature)
+@menu
+* How to activate the extended GNAT Ada superset:: 
+* Curated Extensions:: 
+* Experimental Language Extensions:: 
 
+@end menu
 
-@itemize *
+@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{431}
+@section How to activate the extended GNAT Ada superset
 
-@item 
-`AI-0193 Alignment of allocators (2010-09-16)'
 
-This AI introduces a new attribute @code{Max_Alignment_For_Allocation},
-analogous to @code{Max_Size_In_Storage_Elements}, but for alignment instead
-of size.
+There are two ways to activate the extended GNAT Ada superset:
 
-RM References:  13.11 (16)   13.11 (21)   13.11.01 (0)   13.11.01 (1)
-13.11.01 (2)   13.11.01 (3)
+
+@itemize *
+
+@item 
+The @ref{65,,Pragma Extensions_Allowed}. To activate
+the curated set of extensions, you should use
 @end itemize
 
-@geindex AI-0177 (Ada 2012 feature)
+@example
+pragma Extensions_Allowed (On)
+@end example
+
+As a configuration pragma, you can either put it at the beginning of a source
+file, or in a @code{.adc} file corresponding to your project.
 
 
 @itemize *
 
 @item 
-`AI-0177 Parameterized expressions (2010-07-10)'
+The @code{-gnatX} option, that you can pass to the compiler directly, will
+activate the curated subset of extensions.
+@end itemize
 
-The new Ada 2012 notion of parameterized expressions is implemented. The form
-is:
+@cartouche
+@quotation Attention 
+You can activate the extended set of extensions by using either
+the @code{-gnatX0} command line flag, or the pragma @code{Extensions_Allowed} with
+@code{All} as an argument. However, it is not recommended you use this subset
+for serious projects, and is only means as a playground/technology preview.
+@end quotation
+@end cartouche
 
-@example
-function-specification is (expression)
-@end example
+@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{432}@anchor{gnat_rm/gnat_language_extensions curated-language-extensions}@anchor{66}
+@section Curated Extensions
 
-This is exactly equivalent to the
-corresponding function body that returns the expression, but it can appear
-in a package spec. Note that the expression must be parenthesized.
 
-RM References:  13.11.01 (3/2)
-@end itemize
+@menu
+* Conditional when constructs:: 
+* Case pattern matching:: 
+* Fixed lower bounds for array types and subtypes:: 
+* Prefixed-view notation for calls to primitive subprograms of untagged types:: 
+* Expression defaults for generic formal functions:: 
+* String interpolation:: 
+* Constrained attribute for generic objects:: 
+* Static aspect on intrinsic functions:: 
 
-@geindex AI-0033 (Ada 2012 feature)
+@end menu
 
+@node Conditional when constructs,Case pattern matching,,Curated Extensions
+@anchor{gnat_rm/gnat_language_extensions conditional-when-constructs}@anchor{433}
+@subsection Conditional when constructs
 
-@itemize *
 
-@item 
-`AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)'
+This feature extends the use of @code{when} as a way to condition a control-flow
+related statement, to all control-flow related statements.
 
-Neither of these two pragmas may appear within a generic template, because
-the generic might be instantiated at other than the library level.
+To do a conditional return in a procedure the following syntax should be used:
 
-RM References:  13.11.02 (16)   C.03.01 (7/2)   C.03.01 (8/2)
-@end itemize
+@example
+procedure P (Condition : Boolean) is
+begin
+   return when Condition;
+end;
+@end example
 
-@geindex AI-0161 (Ada 2012 feature)
+This will return from the procedure if @code{Condition} is true.
 
+When being used in a function the conditional part comes after the return value:
 
-@itemize *
+@example
+function Is_Null (I : Integer) return Boolean is
+begin
+   return True when I = 0;
+   return False;
+end;
+@end example
 
-@item 
-`AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)'
+In a similar way to the @code{exit when} a @code{goto ... when} can be employed:
 
-A new restriction @code{No_Default_Stream_Attributes} prevents the use of any
-of the default stream attributes for elementary types. If this restriction is
-in force, then it is necessary to provide explicit subprograms for any
-stream attributes used.
+@example
+procedure Low_Level_Optimized is
+   Flags : Bitmapping;
+begin
+   Do_1 (Flags);
+   goto Cleanup when Flags (1);
 
-RM References:  13.12.01 (4/2)   13.13.02 (40/2)   13.13.02 (52/2)
-@end itemize
+   Do_2 (Flags);
+   goto Cleanup when Flags (32);
 
-@geindex AI-0194 (Ada 2012 feature)
+   --  ...
 
+<<Cleanup>>
+   --  ...
+end;
+@end example
 
-@itemize *
+@c code-block
 
-@item 
-`AI-0194 Value of Stream_Size attribute (0000-00-00)'
+To use a conditional raise construct:
 
-The @code{Stream_Size} attribute returns the default number of bits in the
-stream representation of the given type.
-This value is not affected by the presence
-of stream subprogram attributes for the type. GNAT has always implemented
-this interpretation.
+@example
+procedure Foo is
+begin
+   raise Error when Imported_C_Func /= 0;
+end;
+@end example
 
-RM References:  13.13.02 (1.2/2)
-@end itemize
+An exception message can also be added:
 
-@geindex AI-0109 (Ada 2012 feature)
+@example
+procedure Foo is
+begin
+   raise Error with "Unix Error"
+     when Imported_C_Func /= 0;
+end;
+@end example
 
+Link to the original RFC:
+@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-conditional-when-constructs.rst}
 
-@itemize *
+@node Case pattern matching,Fixed lower bounds for array types and subtypes,Conditional when constructs,Curated Extensions
+@anchor{gnat_rm/gnat_language_extensions case-pattern-matching}@anchor{434}
+@subsection Case pattern matching
 
-@item 
-`AI-0109 Redundant check in S’Class’Input (0000-00-00)'
 
-This AI is an editorial change only. It removes the need for a tag check
-that can never fail.
+The selector for a case statement may be of a composite type, subject to
+some restrictions (described below). Aggregate syntax is used for choices
+of such a case statement; however, in cases where a “normal” aggregate would
+require a discrete value, a discrete subtype may be used instead; box
+notation can also be used to match all values.
 
-RM References:  13.13.02 (34/2)
-@end itemize
+Consider this example:
 
-@geindex AI-0007 (Ada 2012 feature)
+@example
+type Rec is record
+   F1, F2 : Integer;
+end record;
 
+procedure Caser_1 (X : Rec) is
+begin
+   case X is
+      when (F1 => Positive, F2 => Positive) =>
+         Do_This;
+      when (F1 => Natural, F2 => <>) | (F1 => <>, F2 => Natural) =>
+         Do_That;
+      when others =>
+          Do_The_Other_Thing;
+   end case;
+end Caser_1;
+@end example
 
-@itemize *
+If @code{Caser_1} is called and both components of X are positive, then
+@code{Do_This} will be called; otherwise, if either component is nonnegative
+then @code{Do_That} will be called; otherwise, @code{Do_The_Other_Thing} will be
+called.
 
-@item 
-`AI-0007 Stream read and private scalar types (0000-00-00)'
+In addition, pattern bindings are supported. This is a mechanism
+for binding a name to a component of a matching value for use within
+an alternative of a case statement. For a component association
+that occurs within a case choice, the expression may be followed by
+@code{is <identifier>}. In the special case of a “box” component association,
+the identifier may instead be provided within the box. Either of these
+indicates that the given identifier denotes (a constant view of) the matching
+subcomponent of the case selector.
 
-The RM as written appeared to limit the possibilities of declaring read
-attribute procedures for private scalar types. This limitation was not
-intended, and has never been enforced by GNAT.
+@cartouche
+@quotation Attention 
+Binding is not yet supported for arrays or subcomponents
+thereof.
+@end quotation
+@end cartouche
 
-RM References:  13.13.02 (50/2)   13.13.02 (51/2)
-@end itemize
+Consider this example (which uses type @code{Rec} from the previous example):
 
-@geindex AI-0065 (Ada 2012 feature)
+@example
+procedure Caser_2 (X : Rec) is
+begin
+   case X is
+      when (F1 => Positive is Abc, F2 => Positive) =>
+         Do_This (Abc)
+      when (F1 => Natural is N1, F2 => <N2>) |
+           (F1 => <N2>, F2 => Natural is N1) =>
+         Do_That (Param_1 => N1, Param_2 => N2);
+      when others =>
+         Do_The_Other_Thing;
+   end case;
+end Caser_2;
+@end example
 
+This example is the same as the previous one with respect to determining
+whether @code{Do_This}, @code{Do_That}, or @code{Do_The_Other_Thing} will be called. But
+for this version, @code{Do_This} takes a parameter and @code{Do_That} takes two
+parameters. If @code{Do_This} is called, the actual parameter in the call will be
+@code{X.F1}.
 
-@itemize *
+If @code{Do_That} is called, the situation is more complex because there are two
+choices for that alternative. If @code{Do_That} is called because the first choice
+matched (i.e., because @code{X.F1} is nonnegative and either @code{X.F1} or @code{X.F2}
+is zero or negative), then the actual parameters of the call will be (in order)
+@code{X.F1} and @code{X.F2}. If @code{Do_That} is called because the second choice
+matched (and the first one did not), then the actual parameters will be
+reversed.
 
-@item 
-`AI-0065 Remote access types and external streaming (0000-00-00)'
+Within the choice list for single alternative, each choice must define the same
+set of bindings and the component subtypes for for a given identifer must all
+statically match. Currently, the case of a binding for a nondiscrete component
+is not implemented.
 
-This AI clarifies the fact that all remote access types support external
-streaming. This fixes an obvious oversight in the definition of the
-language, and GNAT always implemented the intended correct rules.
+If the set of values that match the choice(s) of an earlier alternative
+overlaps the corresponding set of a later alternative, then the first set shall
+be a proper subset of the second (and the later alternative will not be
+executed if the earlier alternative “matches”). All possible values of the
+composite type shall be covered. The composite type of the selector shall be an
+array or record type that is neither limited nor class-wide. Currently, a “when
+others =>” case choice is required; it is intended that this requirement will
+be relaxed at some point.
 
-RM References:  13.13.02 (52/2)
-@end itemize
+If a subcomponent’s subtype does not meet certain restrictions, then the only
+value that can be specified for that subcomponent in a case choice expression
+is a “box” component association (which matches all possible values for the
+subcomponent). This restriction applies if:
 
-@geindex AI-0019 (Ada 2012 feature)
 
+@itemize -
 
-@itemize *
+@item 
+the component subtype is not a record, array, or discrete type; or
 
 @item 
-`AI-0019 Freezing of primitives for tagged types (0000-00-00)'
+the component subtype is subject to a non-static constraint or has a
+predicate; or:
 
-The RM suggests that primitive subprograms of a specific tagged type are
-frozen when the tagged type is frozen. This would be an incompatible change
-and is not intended. GNAT has never attempted this kind of freezing and its
-behavior is consistent with the recommendation of this AI.
+@item 
+the component type is an enumeration type that is subject to an enumeration
+representation clause; or
 
-RM References:  13.14 (2)   13.14 (3/1)   13.14 (8.1/1)   13.14 (10)   13.14 (14)   13.14 (15.1/2)
+@item 
+the component type is a multidimensional array type or an array type with a
+nonstatic index subtype.
 @end itemize
 
-@geindex AI-0017 (Ada 2012 feature)
+Support for casing on arrays (and on records that contain arrays) is
+currently subject to some restrictions. Non-positional
+array aggregates are not supported as (or within) case choices. Likewise
+for array type and subtype names. The current implementation exceeds
+compile-time capacity limits in some annoyingly common scenarios; the
+message generated in such cases is usually “Capacity exceeded in compiling
+case statement with composite selector type”.
 
+Link to the original RFC:
+@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-pattern-matching.rst}
 
-@itemize *
+@node Fixed lower bounds for array types and subtypes,Prefixed-view notation for calls to primitive subprograms of untagged types,Case pattern matching,Curated Extensions
+@anchor{gnat_rm/gnat_language_extensions fixed-lower-bounds-for-array-types-and-subtypes}@anchor{435}
+@subsection Fixed lower bounds for array types and subtypes
 
-@item 
-`AI-0017 Freezing and incomplete types (0000-00-00)'
 
-So-called ‘Taft-amendment types’ (i.e., types that are completed in package
-bodies) are not frozen by the occurrence of bodies in the
-enclosing declarative part. GNAT always implemented this properly.
+Unconstrained array types and subtypes can be specified with a lower bound that
+is fixed to a certain value, by writing an index range that uses the syntax
+@code{<lower-bound-expression> .. <>}. This guarantees that all objects of the
+type or subtype will have the specified lower bound.
 
-RM References:  13.14 (3/1)
-@end itemize
+For example, a matrix type with fixed lower bounds of zero for each dimension
+can be declared by the following:
 
-@geindex AI-0060 (Ada 2012 feature)
+@example
+type Matrix is
+  array (Natural range 0 .. <>, Natural range 0 .. <>) of Integer;
+@end example
 
+Objects of type @code{Matrix} declared with an index constraint must have index
+ranges starting at zero:
 
-@itemize *
+@example
+M1 : Matrix (0 .. 9, 0 .. 19);
+M2 : Matrix (2 .. 11, 3 .. 22);  -- Warning about bounds; will raise CE
+@end example
 
-@item 
-`AI-0060 Extended definition of remote access types (0000-00-00)'
+Similarly, a subtype of @code{String} can be declared that specifies the lower
+bound of objects of that subtype to be @code{1}:
 
-This AI extends the definition of remote access types to include access
-to limited, synchronized, protected or task class-wide interface types.
-GNAT already implemented this extension.
+@quotation
 
-RM References:  A (4)   E.02.02 (9/1)   E.02.02 (9.2/1)   E.02.02 (14/2)   E.02.02 (18)
-@end itemize
+@example
+subtype String_1 is String (1 .. <>);
+@end example
+@end quotation
 
-@geindex AI-0114 (Ada 2012 feature)
+If a string slice is passed to a formal of subtype @code{String_1} in a call to a
+subprogram @code{S}, the slice’s bounds will “slide” so that the lower bound is
+@code{1}.
 
+Within @code{S}, the lower bound of the formal is known to be @code{1}, so, unlike a
+normal unconstrained @code{String} formal, there is no need to worry about
+accounting for other possible lower-bound values. Sliding of bounds also occurs
+in other contexts, such as for object declarations with an unconstrained
+subtype with fixed lower bound, as well as in subtype conversions.
 
-@itemize *
+Use of this feature increases safety by simplifying code, and can also improve
+the efficiency of indexing operations, since the compiler statically knows the
+lower bound of unconstrained array formals when the formal’s subtype has index
+ranges with static fixed lower bounds.
 
-@item 
-`AI-0114 Classification of letters (0000-00-00)'
+Link to the original RFC:
+@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-fixed-lower-bound.rst}
 
-The code points 170 (@code{FEMININE ORDINAL INDICATOR}),
-181 (@code{MICRO SIGN}), and
-186 (@code{MASCULINE ORDINAL INDICATOR}) are technically considered
-lower case letters by Unicode.
-However, they are not allowed in identifiers, and they
-return @code{False} to @code{Ada.Characters.Handling.Is_Letter/Is_Lower}.
-This behavior is consistent with that defined in Ada 95.
+@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{436}
+@subsection Prefixed-view notation for calls to primitive subprograms of untagged types
+
+
+When operating on an untagged type, if it has any primitive operations, and the
+first parameter of an operation is of the type (or is an access parameter with
+an anonymous type that designates the type), you may invoke these operations
+using an @code{object.op(...)} notation, where the parameter that would normally be
+the first parameter is brought out front, and the remaining parameters (if any)
+appear within parentheses after the name of the primitive operation.
+
+This same notation is already available for tagged types. This extension allows
+for untagged types. It is allowed for all primitive operations of the type
+independent of whether they were originally declared in a package spec or its
+private part, or were inherited and/or overridden as part of a derived type
+declaration occuring anywhere, so long as the first parameter is of the type,
+or an access parameter designating the type.
+
+For example:
+
+@example
+generic
+   type Elem_Type is private;
+package Vectors is
+    type Vector is private;
+    procedure Add_Element (V : in out Vector; Elem : Elem_Type);
+    function Nth_Element (V : Vector; N : Positive) return Elem_Type;
+    function Length (V : Vector) return Natural;
+private
+    function Capacity (V : Vector) return Natural;
+       --  Return number of elements that may be added without causing
+       --  any new allocation of space
+
+    type Vector is ...
+      with Type_Invariant => Vector.Length <= Vector.Capacity;
+    ...
+end Vectors;
+
+package Int_Vecs is new Vectors(Integer);
 
-RM References:  A.03.02 (59)   A.04.06 (7)
-@end itemize
+V : Int_Vecs.Vector;
+...
+V.Add_Element(42);
+V.Add_Element(-33);
 
-@geindex AI-0185 (Ada 2012 feature)
+pragma Assert (V.Length = 2);
+pragma Assert (V.Nth_Element(1) = 42);
+@end example
 
+Link to the original RFC:
+@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-prefixed-untagged.rst}
 
-@itemize *
+@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{437}
+@subsection Expression defaults for generic formal functions
 
-@item 
-`AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)'
 
-Two new packages @code{Ada.Wide_[Wide_]Characters.Handling} provide
-classification functions for @code{Wide_Character} and
-@code{Wide_Wide_Character}, as well as providing
-case folding routines for @code{Wide_[Wide_]Character} and
-@code{Wide_[Wide_]String}.
+The declaration of a generic formal function is allowed to specify
+an expression as a default, using the syntax of an expression function.
 
-RM References:  A.03.05 (0)   A.03.06 (0)
-@end itemize
+Here is an example of this feature:
 
-@geindex AI-0031 (Ada 2012 feature)
+@example
+generic
+   type T is private;
+   with function Copy (Item : T) return T is (Item); -- Defaults to Item
+package Stacks is
 
+   type Stack is limited private;
 
-@itemize *
+   procedure Push (S : in out Stack; X : T); -- Calls Copy on X
+   function Pop (S : in out Stack) return T; -- Calls Copy to return item
 
-@item 
-`AI-0031 Add From parameter to Find_Token (2010-07-25)'
+private
+   -- ...
+end Stacks;
+@end example
 
-A new version of @code{Find_Token} is added to all relevant string packages,
-with an extra parameter @code{From}. Instead of starting at the first
-character of the string, the search for a matching Token starts at the
-character indexed by the value of @code{From}.
-These procedures are available in all versions of Ada
-but if used in versions earlier than Ada 2012 they will generate a warning
-that an Ada 2012 subprogram is being used.
+Link to the original RFC:
+@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-expression-functions-as-default-for-generic-formal-function-parameters.rst}
 
-RM References:  A.04.03 (16)   A.04.03 (67)   A.04.03 (68/1)   A.04.04 (51)
-A.04.05 (46)
-@end itemize
+@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{438}
+@subsection String interpolation
 
-@geindex AI-0056 (Ada 2012 feature)
 
+The syntax for string literals is extended to support string interpolation.
 
-@itemize *
+Within an interpolated string literal, an arbitrary expression, when
+enclosed in @code{@{ ... @}}, is expanded at run time into the result of calling
+@code{'Image} on the result of evaluating the expression enclosed by the brace
+characters, unless it is already a string or a single character.
 
-@item 
-`AI-0056 Index on null string returns zero (0000-00-00)'
+Here is an example of this feature where the expressions @code{Name} and @code{X + Y}
+will be evaluated and included in the string.
 
-The wording in the Ada 2005 RM implied an incompatible handling of the
-@code{Index} functions, resulting in raising an exception instead of
-returning zero in some situations.
-This was not intended and has been corrected.
-GNAT always returned zero, and is thus consistent with this AI.
+@example
+procedure Test_Interpolation is
+   X    : Integer := 12;
+   Y    : Integer := 15;
+   Name : String := "Leo";
+begin
+   Put_Line (f"The name is @{Name@} and the sum is @{X + Y@}.");
+end Test_Interpolation;
+@end example
 
-RM References:  A.04.03 (56.2/2)   A.04.03 (58.5/2)
-@end itemize
+In addition, an escape character (@code{\}) is provided for inserting certain
+standard control characters (such as @code{\t} for tabulation or @code{\n} for
+newline) or to escape characters with special significance to the
+interpolated string syntax, namely @code{"}, @code{@{}, @code{@}},and @code{\} itself.
 
-@geindex AI-0137 (Ada 2012 feature)
 
+@multitable {xxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxxxxxxxxxxx} 
+@item
 
-@itemize *
+escaped_character
 
-@item 
-`AI-0137 String encoding package (2010-03-25)'
+@tab
 
-The packages @code{Ada.Strings.UTF_Encoding}, together with its child
-packages, @code{Conversions}, @code{Strings}, @code{Wide_Strings},
-and @code{Wide_Wide_Strings} have been
-implemented. These packages (whose documentation can be found in the spec
-files @code{a-stuten.ads}, @code{a-suenco.ads}, @code{a-suenst.ads},
-@code{a-suewst.ads}, @code{a-suezst.ads}) allow encoding and decoding of
-@code{String}, @code{Wide_String}, and @code{Wide_Wide_String}
-values using UTF coding schemes (including UTF-8, UTF-16LE, UTF-16BE, and
-UTF-16), as well as conversions between the different UTF encodings. With
-the exception of @code{Wide_Wide_Strings}, these packages are available in
-Ada 95 and Ada 2005 mode as well as Ada 2012 mode.
-The @code{Wide_Wide_Strings} package
-is available in Ada 2005 mode as well as Ada 2012 mode (but not in Ada 95
-mode since it uses @code{Wide_Wide_Character}).
+meaning
 
-RM References:  A.04.11
-@end itemize
+@item
 
-@geindex AI-0038 (Ada 2012 feature)
+@code{\a}
 
+@tab
 
-@itemize *
+ALERT
 
-@item 
-`AI-0038 Minor errors in Text_IO (0000-00-00)'
+@item
 
-These are minor errors in the description on three points. The intent on
-all these points has always been clear, and GNAT has always implemented the
-correct intended semantics.
+@code{\b}
 
-RM References:  A.10.05 (37)   A.10.07 (8/1)   A.10.07 (10)   A.10.07 (12)   A.10.08 (10)   A.10.08 (24)
-@end itemize
+@tab
 
-@geindex AI-0044 (Ada 2012 feature)
+BACKSPACE
 
+@item
 
-@itemize *
+@code{\f}
 
-@item 
-`AI-0044 Restrictions on container instantiations (0000-00-00)'
+@tab
 
-This AI places restrictions on allowed instantiations of generic containers.
-These restrictions are not checked by the compiler, so there is nothing to
-change in the implementation. This affects only the RM documentation.
+FORM FEED
 
-RM References:  A.18 (4/2)   A.18.02 (231/2)   A.18.03 (145/2)   A.18.06 (56/2)   A.18.08 (66/2)   A.18.09 (79/2)   A.18.26 (5/2)   A.18.26 (9/2)
-@end itemize
+@item
 
-@geindex AI-0127 (Ada 2012 feature)
+@code{\n}
 
+@tab
 
-@itemize *
+LINE FEED
 
-@item 
-`AI-0127 Adding Locale Capabilities (2010-09-29)'
+@item
 
-This package provides an interface for identifying the current locale.
+@code{\r}
 
-RM References:  A.19    A.19.01    A.19.02    A.19.03    A.19.05    A.19.06
-A.19.07    A.19.08    A.19.09    A.19.10    A.19.11    A.19.12    A.19.13
-@end itemize
+@tab
 
-@geindex AI-0002 (Ada 2012 feature)
+CARRIAGE RETURN
 
+@item
 
-@itemize *
+@code{\t}
 
-@item 
-`AI-0002 Export C with unconstrained arrays (0000-00-00)'
+@tab
 
-The compiler is not required to support exporting an Ada subprogram with
-convention C if there are parameters or a return type of an unconstrained
-array type (such as @code{String}). GNAT allows such declarations but
-generates warnings. It is possible, but complicated, to write the
-corresponding C code and certainly such code would be specific to GNAT and
-non-portable.
+CHARACTER TABULATION
 
-RM References:  B.01 (17)   B.03 (62)   B.03 (71.1/2)
-@end itemize
+@item
 
-@geindex AI05-0216 (Ada 2012 feature)
+@code{\v}
 
+@tab
 
-@itemize *
+LINE TABULATION
 
-@item 
-`AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)'
+@item
 
-It is clearly the intention that @code{No_Task_Hierarchy} is intended to
-forbid tasks declared locally within subprograms, or functions returning task
-objects, and that is the implementation that GNAT has always provided.
-However the language in the RM was not sufficiently clear on this point.
-Thus this is a documentation change in the RM only.
+@code{\0}
 
-RM References:  D.07 (3/3)
-@end itemize
+@tab
 
-@geindex AI-0211 (Ada 2012 feature)
+NUL
 
+@item
 
-@itemize *
+@code{\\}
 
-@item 
-`AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)'
+@tab
 
-The restriction @code{No_Relative_Delays} forbids any calls to the subprogram
-@code{Ada.Real_Time.Timing_Events.Set_Handler}.
+@code{\}
 
-RM References:  D.07 (5)   D.07 (10/2)   D.07 (10.4/2)   D.07 (10.7/2)
-@end itemize
+@item
 
-@geindex AI-0190 (Ada 2012 feature)
+@code{\"}
 
+@tab
 
-@itemize *
+@code{"}
 
-@item 
-`AI-0190 pragma Default_Storage_Pool (2010-09-15)'
+@item
 
-This AI introduces a new pragma @code{Default_Storage_Pool}, which can be
-used to control storage pools globally.
-In particular, you can force every access
-type that is used for allocation (`new') to have an explicit storage pool,
-or you can declare a pool globally to be used for all access types that lack
-an explicit one.
+@code{\@{}
 
-RM References:  D.07 (8)
-@end itemize
+@tab
 
-@geindex AI-0189 (Ada 2012 feature)
+@code{@{}
 
+@item
 
-@itemize *
+@code{\@}}
 
-@item 
-`AI-0189 No_Allocators_After_Elaboration (2010-01-23)'
+@tab
 
-This AI introduces a new restriction @code{No_Allocators_After_Elaboration},
-which says that no dynamic allocation will occur once elaboration is
-completed.
-In general this requires a run-time check, which is not required, and which
-GNAT does not attempt. But the static cases of allocators in a task body or
-in the body of the main program are detected and flagged at compile or bind
-time.
+@code{@}}
 
-RM References:  D.07 (19.1/2)   H.04 (23.3/2)
-@end itemize
+@end multitable
 
-@geindex AI-0171 (Ada 2012 feature)
 
+Note that, unlike normal string literals, doubled characters have no
+special significance. So to include a double-quote or a brace character
+in an interpolated string, they must be preceded by a @code{\}.
+For example:
 
-@itemize *
+@example
+Put_Line
+  (f"X = @{X@} and Y = @{Y@} and X+Y = @{X+Y@};\n" &
+   f" a double quote is \" and" &
+   f" an open brace is \@{");
+@end example
 
-@item 
-`AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)'
+Finally, a syntax is provided for creating multi-line string literals,
+without having to explicitly use an escape sequence such as @code{\n}. For
+example:
 
-A new package @code{System.Multiprocessors} is added, together with the
-definition of pragma @code{CPU} for controlling task affinity. A new no
-dependence restriction, on @code{System.Multiprocessors.Dispatching_Domains},
-is added to the Ravenscar profile.
+@example
+Put_Line
+  (f"This is a multi-line"
+    "string literal"
+    "There is no ambiguity about how many"
+    "spaces are included in each line");
+@end example
 
-RM References:  D.13.01 (4/2)   D.16
-@end itemize
+Here is a link to the original RFC   :
+@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-string-interpolation.rst}
 
-@geindex AI-0210 (Ada 2012 feature)
+@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{439}
+@subsection Constrained attribute for generic objects
 
 
-@itemize *
+The @code{Constrained} attribute is permitted for objects of generic types. The
+result indicates whether the corresponding actual is constrained.
 
-@item 
-`AI-0210 Correct Timing_Events metric (0000-00-00)'
+@node Static aspect on intrinsic functions,,Constrained attribute for generic objects,Curated Extensions
+@anchor{gnat_rm/gnat_language_extensions static-aspect-on-intrinsic-functions}@anchor{43a}
+@subsection @code{Static} aspect on intrinsic functions
 
-This is a documentation only issue regarding wording of metric requirements,
-that does not affect the implementation of the compiler.
 
-RM References:  D.15 (24/2)
-@end itemize
+The Ada 202x @code{Static} aspect can be specified on Intrinsic imported functions
+and the compiler will evaluate some of these intrinsics statically, in
+particular the @code{Shift_Left} and @code{Shift_Right} intrinsics.
 
-@geindex AI-0206 (Ada 2012 feature)
+@node Experimental Language Extensions,,Curated Extensions,GNAT language extensions
+@anchor{gnat_rm/gnat_language_extensions experimental-language-extensions}@anchor{67}@anchor{gnat_rm/gnat_language_extensions id2}@anchor{43b}
+@section Experimental Language Extensions
 
 
-@itemize *
+@menu
+* Pragma Storage_Model:: 
+* Simpler accessibility model:: 
 
-@item 
-`AI-0206 Remote types packages and preelaborate (2010-07-24)'
+@end menu
 
-Remote types packages are now allowed to depend on preelaborated packages.
-This was formerly considered illegal.
+@node Pragma Storage_Model,Simpler accessibility model,,Experimental Language Extensions
+@anchor{gnat_rm/gnat_language_extensions pragma-storage-model}@anchor{43c}
+@subsection Pragma Storage_Model
 
-RM References:  E.02.02 (6)
-@end itemize
 
-@geindex AI-0152 (Ada 2012 feature)
+This feature proposes to redesign the concepts of Storage Pools into a more
+efficient model allowing higher performances and easier integration with low
+footprint embedded run-times.
 
+It also extends it to support distributed memory models, in particular to
+support interactions with GPU.
 
-@itemize *
+Here is a link to the full RFC:
+@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-storage-model.rst}
 
-@item 
-`AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)'
+@node Simpler accessibility model,,Pragma Storage_Model,Experimental Language Extensions
+@anchor{gnat_rm/gnat_language_extensions simpler-accessibility-model}@anchor{43d}
+@subsection Simpler accessibility model
 
-Restriction @code{No_Anonymous_Allocators} prevents the use of allocators
-where the type of the returned value is an anonymous access type.
 
-RM References:  H.04 (8/1)
-@end itemize
+The goal of this feature is to restore a common understanding of accessibility
+rules for implementers and users alike. The new rules should both be effective
+at preventing errors and feel natural and compatible in an Ada environment
+while removing dynamic accessibility checking.
+
+Here is a link to the full RFC:
+@indicateurl{https://github.com/AdaCore/ada-spark-rfcs/blob/master/prototyped/rfc-simpler-accessibility.md}
 
-@node Security Hardening Features,Obsolescent Features,Implementation of Ada 2012 Features,Top
-@anchor{gnat_rm/security_hardening_features doc}@anchor{42b}@anchor{gnat_rm/security_hardening_features id1}@anchor{42c}@anchor{gnat_rm/security_hardening_features security-hardening-features}@anchor{15}
+@node Security Hardening Features,Obsolescent Features,GNAT language extensions,Top
+@anchor{gnat_rm/security_hardening_features doc}@anchor{43e}@anchor{gnat_rm/security_hardening_features id1}@anchor{43f}@anchor{gnat_rm/security_hardening_features security-hardening-features}@anchor{15}
 @chapter Security Hardening Features
 
 
@@ -28875,7 +29131,7 @@ change.
 @end menu
 
 @node Register Scrubbing,Stack Scrubbing,,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features register-scrubbing}@anchor{42d}
+@anchor{gnat_rm/security_hardening_features register-scrubbing}@anchor{440}
 @section Register Scrubbing
 
 
@@ -28905,7 +29161,7 @@ programming languages, see @cite{Using the GNU Compiler Collection (GCC)}.
 @c Stack Scrubbing:
 
 @node Stack Scrubbing,Hardened Conditionals,Register Scrubbing,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features stack-scrubbing}@anchor{42e}
+@anchor{gnat_rm/security_hardening_features stack-scrubbing}@anchor{441}
 @section Stack Scrubbing
 
 
@@ -29049,7 +29305,7 @@ Bar_Callable_Ptr.
 @c Hardened Conditionals:
 
 @node Hardened Conditionals,Hardened Booleans,Stack Scrubbing,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features hardened-conditionals}@anchor{42f}
+@anchor{gnat_rm/security_hardening_features hardened-conditionals}@anchor{442}
 @section Hardened Conditionals
 
 
@@ -29139,7 +29395,7 @@ be used with other programming languages supported by GCC.
 @c Hardened Booleans:
 
 @node Hardened Booleans,Control Flow Redundancy,Hardened Conditionals,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features hardened-booleans}@anchor{430}
+@anchor{gnat_rm/security_hardening_features hardened-booleans}@anchor{443}
 @section Hardened Booleans
 
 
@@ -29200,7 +29456,7 @@ and more details on that attribute, see @cite{Using the GNU Compiler Collection
 @c Control Flow Redundancy:
 
 @node Control Flow Redundancy,,Hardened Booleans,Security Hardening Features
-@anchor{gnat_rm/security_hardening_features control-flow-redundancy}@anchor{431}
+@anchor{gnat_rm/security_hardening_features control-flow-redundancy}@anchor{444}
 @section Control Flow Redundancy
 
 
@@ -29360,7 +29616,7 @@ see @cite{Using the GNU Compiler Collection (GCC)}.  These options
 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{432}@anchor{gnat_rm/obsolescent_features id1}@anchor{433}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{16}
+@anchor{gnat_rm/obsolescent_features doc}@anchor{445}@anchor{gnat_rm/obsolescent_features id1}@anchor{446}@anchor{gnat_rm/obsolescent_features obsolescent-features}@anchor{16}
 @chapter Obsolescent Features
 
 
@@ -29379,7 +29635,7 @@ compatibility purposes.
 @end menu
 
 @node pragma No_Run_Time,pragma Ravenscar,,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features id2}@anchor{434}@anchor{gnat_rm/obsolescent_features pragma-no-run-time}@anchor{435}
+@anchor{gnat_rm/obsolescent_features id2}@anchor{447}@anchor{gnat_rm/obsolescent_features pragma-no-run-time}@anchor{448}
 @section pragma No_Run_Time
 
 
@@ -29392,7 +29648,7 @@ preferred usage is to use an appropriately configured run-time that
 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{436}@anchor{gnat_rm/obsolescent_features pragma-ravenscar}@anchor{437}
+@anchor{gnat_rm/obsolescent_features id3}@anchor{449}@anchor{gnat_rm/obsolescent_features pragma-ravenscar}@anchor{44a}
 @section pragma Ravenscar
 
 
@@ -29401,7 +29657,7 @@ The pragma @code{Ravenscar} has exactly the same effect as pragma
 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{438}@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{439}
+@anchor{gnat_rm/obsolescent_features id4}@anchor{44b}@anchor{gnat_rm/obsolescent_features pragma-restricted-run-time}@anchor{44c}
 @section pragma Restricted_Run_Time
 
 
@@ -29411,7 +29667,7 @@ preferred since the Ada 2005 pragma @code{Profile} is intended for
 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{43a}@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{43b}
+@anchor{gnat_rm/obsolescent_features id5}@anchor{44d}@anchor{gnat_rm/obsolescent_features pragma-task-info}@anchor{44e}
 @section pragma Task_Info
 
 
@@ -29437,7 +29693,7 @@ in the spec of package System.Task_Info in the runtime
 library.
 
 @node package System Task_Info s-tasinf ads,,pragma Task_Info,Obsolescent Features
-@anchor{gnat_rm/obsolescent_features package-system-task-info}@anchor{43c}@anchor{gnat_rm/obsolescent_features package-system-task-info-s-tasinf-ads}@anchor{43d}
+@anchor{gnat_rm/obsolescent_features package-system-task-info}@anchor{44f}@anchor{gnat_rm/obsolescent_features package-system-task-info-s-tasinf-ads}@anchor{450}
 @section package System.Task_Info (@code{s-tasinf.ads})
 
 
@@ -29447,7 +29703,7 @@ to support the @code{Task_Info} pragma. The predefined Ada package
 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{43e}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{17}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{43f}
+@anchor{gnat_rm/compatibility_and_porting_guide doc}@anchor{451}@anchor{gnat_rm/compatibility_and_porting_guide compatibility-and-porting-guide}@anchor{17}@anchor{gnat_rm/compatibility_and_porting_guide id1}@anchor{452}
 @chapter Compatibility and Porting Guide
 
 
@@ -29469,7 +29725,7 @@ applications developed in other Ada environments.
 @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{440}@anchor{gnat_rm/compatibility_and_porting_guide writing-portable-fixed-point-declarations}@anchor{441}
+@anchor{gnat_rm/compatibility_and_porting_guide id2}@anchor{453}@anchor{gnat_rm/compatibility_and_porting_guide writing-portable-fixed-point-declarations}@anchor{454}
 @section Writing Portable Fixed-Point Declarations
 
 
@@ -29591,7 +29847,7 @@ If you follow this scheme you will be guaranteed that your fixed-point
 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{442}@anchor{gnat_rm/compatibility_and_porting_guide id3}@anchor{443}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-ada-83}@anchor{455}@anchor{gnat_rm/compatibility_and_porting_guide id3}@anchor{456}
 @section Compatibility with Ada 83
 
 
@@ -29619,7 +29875,7 @@ following subsections treat the most likely issues to be encountered.
 @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{444}@anchor{gnat_rm/compatibility_and_porting_guide legal-ada-83-programs-that-are-illegal-in-ada-95}@anchor{445}
+@anchor{gnat_rm/compatibility_and_porting_guide id4}@anchor{457}@anchor{gnat_rm/compatibility_and_porting_guide legal-ada-83-programs-that-are-illegal-in-ada-95}@anchor{458}
 @subsection Legal Ada 83 programs that are illegal in Ada 95
 
 
@@ -29719,7 +29975,7 @@ the fix is usually simply to add the @code{(<>)} to the generic declaration.
 @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{446}@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{447}
+@anchor{gnat_rm/compatibility_and_porting_guide id5}@anchor{459}@anchor{gnat_rm/compatibility_and_porting_guide more-deterministic-semantics}@anchor{45a}
 @subsection More deterministic semantics
 
 
@@ -29747,7 +30003,7 @@ which open select branches are executed.
 @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{448}@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{449}
+@anchor{gnat_rm/compatibility_and_porting_guide changed-semantics}@anchor{45b}@anchor{gnat_rm/compatibility_and_porting_guide id6}@anchor{45c}
 @subsection Changed semantics
 
 
@@ -29789,7 +30045,7 @@ covers only the restricted range.
 @end itemize
 
 @node Other language compatibility issues,,Changed semantics,Compatibility with Ada 83
-@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{44a}@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{44b}
+@anchor{gnat_rm/compatibility_and_porting_guide id7}@anchor{45d}@anchor{gnat_rm/compatibility_and_porting_guide other-language-compatibility-issues}@anchor{45e}
 @subsection Other language compatibility issues
 
 
@@ -29822,7 +30078,7 @@ include @code{pragma Interface} and the floating point type attributes
 @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{44c}@anchor{gnat_rm/compatibility_and_porting_guide id8}@anchor{44d}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-between-ada-95-and-ada-2005}@anchor{45f}@anchor{gnat_rm/compatibility_and_porting_guide id8}@anchor{460}
 @section Compatibility between Ada 95 and Ada 2005
 
 
@@ -29894,7 +30150,7 @@ can declare a function returning a value from an anonymous access type.
 @end itemize
 
 @node Implementation-dependent characteristics,Compatibility with Other Ada Systems,Compatibility between Ada 95 and Ada 2005,Compatibility and Porting Guide
-@anchor{gnat_rm/compatibility_and_porting_guide id9}@anchor{44e}@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{44f}
+@anchor{gnat_rm/compatibility_and_porting_guide id9}@anchor{461}@anchor{gnat_rm/compatibility_and_porting_guide implementation-dependent-characteristics}@anchor{462}
 @section Implementation-dependent characteristics
 
 
@@ -29917,7 +30173,7 @@ transition from certain Ada 83 compilers.
 @end menu
 
 @node Implementation-defined pragmas,Implementation-defined attributes,,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide id10}@anchor{450}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{451}
+@anchor{gnat_rm/compatibility_and_porting_guide id10}@anchor{463}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-pragmas}@anchor{464}
 @subsection Implementation-defined pragmas
 
 
@@ -29939,7 +30195,7 @@ avoiding compiler rejection of units that contain such pragmas; they are not
 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{452}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-attributes}@anchor{453}
+@anchor{gnat_rm/compatibility_and_porting_guide id11}@anchor{465}@anchor{gnat_rm/compatibility_and_porting_guide implementation-defined-attributes}@anchor{466}
 @subsection Implementation-defined attributes
 
 
@@ -29953,7 +30209,7 @@ Ada 83, GNAT supplies the attributes @code{Bit}, @code{Machine_Size} and
 @code{Type_Class}.
 
 @node Libraries,Elaboration order,Implementation-defined attributes,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide id12}@anchor{454}@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{455}
+@anchor{gnat_rm/compatibility_and_porting_guide id12}@anchor{467}@anchor{gnat_rm/compatibility_and_porting_guide libraries}@anchor{468}
 @subsection Libraries
 
 
@@ -29982,7 +30238,7 @@ be preferable to retrofit the application using modular types.
 @end itemize
 
 @node Elaboration order,Target-specific aspects,Libraries,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide elaboration-order}@anchor{456}@anchor{gnat_rm/compatibility_and_porting_guide id13}@anchor{457}
+@anchor{gnat_rm/compatibility_and_porting_guide elaboration-order}@anchor{469}@anchor{gnat_rm/compatibility_and_porting_guide id13}@anchor{46a}
 @subsection Elaboration order
 
 
@@ -30018,7 +30274,7 @@ pragmas either globally (as an effect of the `-gnatE' switch) or locally
 @end itemize
 
 @node Target-specific aspects,,Elaboration order,Implementation-dependent characteristics
-@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{458}@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{459}
+@anchor{gnat_rm/compatibility_and_porting_guide id14}@anchor{46b}@anchor{gnat_rm/compatibility_and_porting_guide target-specific-aspects}@anchor{46c}
 @subsection Target-specific aspects
 
 
@@ -30031,10 +30287,10 @@ on the robustness of the original design.  Moreover, Ada 95 (and thus
 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{45a,,Representation Clauses}.
+GNAT’s approach to these issues is described in @ref{46d,,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{45b}@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{45c}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-other-ada-systems}@anchor{46e}@anchor{gnat_rm/compatibility_and_porting_guide id15}@anchor{46f}
 @section Compatibility with Other Ada Systems
 
 
@@ -30077,7 +30333,7 @@ far beyond this minimal set, as described in the next section.
 @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{45d}@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{45a}
+@anchor{gnat_rm/compatibility_and_porting_guide id16}@anchor{470}@anchor{gnat_rm/compatibility_and_porting_guide representation-clauses}@anchor{46d}
 @section Representation Clauses
 
 
@@ -30170,7 +30426,7 @@ with thin pointers.
 @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{45e}@anchor{gnat_rm/compatibility_and_porting_guide id17}@anchor{45f}
+@anchor{gnat_rm/compatibility_and_porting_guide compatibility-with-hp-ada-83}@anchor{471}@anchor{gnat_rm/compatibility_and_porting_guide id17}@anchor{472}
 @section Compatibility with HP Ada 83
 
 
@@ -30200,7 +30456,7 @@ extension of package System.
 @end itemize
 
 @node GNU Free Documentation License,Index,Compatibility and Porting Guide,Top
-@anchor{share/gnu_free_documentation_license doc}@anchor{460}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{461}
+@anchor{share/gnu_free_documentation_license doc}@anchor{473}@anchor{share/gnu_free_documentation_license gnu-fdl}@anchor{1}@anchor{share/gnu_free_documentation_license gnu-free-documentation-license}@anchor{474}
 @chapter GNU Free Documentation License