[COMMITTED,08/31] ada: Sort list of implemented Ada 2012 features

Message ID 20240521073035.314024-8-poulhies@adacore.com
State Committed
Headers
Series [COMMITTED,01/31] ada: Add new Mingw task priority mapping |

Commit Message

Marc Poulhiès May 21, 2024, 7:30 a.m. UTC
  From: Piotr Trojanek <trojanek@adacore.com>

The list of implemented Ada 2012 features is now ordered by the AI
numbers. It has been sorted mechanically using the csplit command with
a bit of shell scripting.

gcc/ada/

	* doc/gnat_rm/implementation_of_ada_2012_features.rst:
	Order list by AI number.
	* gnat_rm.texi: Regenerate.

Tested on x86_64-pc-linux-gnu, committed on master.

---
 .../implementation_of_ada_2012_features.rst   | 1658 ++++++-------
 gcc/ada/gnat_rm.texi                          | 2054 ++++++++---------
 2 files changed, 1856 insertions(+), 1856 deletions(-)
  

Patch

diff --git a/gcc/ada/doc/gnat_rm/implementation_of_ada_2012_features.rst b/gcc/ada/doc/gnat_rm/implementation_of_ada_2012_features.rst
index d7f1fea01f3..706de492301 100644
--- a/gcc/ada/doc/gnat_rm/implementation_of_ada_2012_features.rst
+++ b/gcc/ada/doc/gnat_rm/implementation_of_ada_2012_features.rst
@@ -43,330 +43,343 @@  in the RM, the earliest is used.
 A complete description of the AIs may be found in
 http://www.ada-auth.org/ai05-summary.html.
 
-.. index:: AI-0176 (Ada 2012 feature)
+.. index:: AI-0002 (Ada 2012 feature)
 
-* *AI-0176 Quantified expressions (2010-09-29)*
+* *AI-0002 Export C with unconstrained arrays (0000-00-00)*
 
-  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.
+  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 ``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:  1.01.04 (12)   2.09 (2/2)   4.04 (7)   4.05.09 (0)
+  RM References:  B.01 (17)   B.03 (62)   B.03 (71.1/2)
 
-.. index:: AI-0079 (Ada 2012 feature)
+.. index:: AI-0003 (Ada 2012 feature)
 
-* *AI-0079 Allow other_format characters in source (2010-07-10)*
+* *AI-0003 Qualified expressions as names (2010-07-11)*
 
-  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.
+  In Ada 2012, a qualified expression is considered to be syntactically a name,
+  meaning that constructs such as ``A'(F(X)).B`` are now legal. This is
+  useful in disambiguating some cases of overloading.
 
-  RM References:  2.01 (4/2)   2.02 (7)
+  RM References:  3.03 (11)   3.03 (21)   4.01 (2)   4.04 (7)   4.07 (3)
+  5.04 (7)
 
-.. index:: AI-0091 (Ada 2012 feature)
+.. index:: AI-0007 (Ada 2012 feature)
 
-* *AI-0091 Do not allow other_format in identifiers (0000-00-00)*
+* *AI-0007 Stream read and private scalar types (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.
+  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:  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)
+  RM References:  13.13.02 (50/2)   13.13.02 (51/2)
 
-.. index:: AI-0100 (Ada 2012 feature)
+.. index:: AI-0008 (Ada 2012 feature)
 
-* *AI-0100 Placement of pragmas  (2010-07-01)*
+* *AI-0008 General access to constrained objects (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.
+  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. ``Constraint_Error`` should be raised, and GNAT
+  has always done so in this situation.
 
-  RM References:  2.08 (7)
+  RM References:  3.03 (23)   3.10.02 (26/2)   4.01 (9)   6.04.01 (17)   8.05.01 (5/2)
 
-.. index:: AI-0163 (Ada 2012 feature)
+.. index:: AI-0009 (Ada 2012 feature)
 
-* *AI-0163 Pragmas in place of null (2010-07-01)*
+* *AI-0009 Pragma Independent[_Components] (2010-07-23)*
 
-  A statement sequence may be composed entirely of pragmas. It is no longer
-  necessary to add a dummy ``null`` statement to make the sequence legal.
+  This AI introduces the new pragmas ``Independent`` and
+  ``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:  2.08 (7)   2.08 (16)
+  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)
 
-.. index:: AI-0080 (Ada 2012 feature)
+.. index:: AI-0012 (Ada 2012 feature)
 
-* *AI-0080 'View of' not needed if clear from context (0000-00-00)*
+* *AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)*
 
-  This is an editorial change only, described as non-testable in the AI.
+  It is now illegal to give an inappropriate component size or a pragma
+  ``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:  3.01 (7)
+  RM References:  13.02 (6.1/2)   13.02 (7)   C.06 (10)   C.06 (11)   C.06 (21)
 
-.. index:: AI-0183 (Ada 2012 feature)
+.. index:: AI-0015 (Ada 2012 feature)
 
-* *AI-0183 Aspect specifications (2010-08-16)*
+* *AI-0015 Constant return objects (0000-00-00)*
 
-  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)
+  The return object declared in an *extended_return_statement* may be
+  declared constant. This was always intended, and GNAT has always allowed it.
 
-==================================== ===========
-Supported Aspect                     Source
-==================================== ===========
-  ``Ada_2005``                           -- GNAT
-  ``Ada_2012``                           -- GNAT
-  ``Address``
-  ``Alignment``
-  ``Atomic``
-  ``Atomic_Components``
-  ``Bit_Order``
-  ``Component_Size``
-  ``Contract_Cases``                     -- GNAT
-  ``Discard_Names``
-  ``External_Tag``
-  ``Favor_Top_Level``                    -- GNAT
-  ``Inline``
-  ``Inline_Always``                      -- GNAT
-  ``Invariant``                          -- GNAT
-  ``Machine_Radix``
-  ``No_Return``
-  ``Object_Size``                        -- GNAT
-  ``Pack``
-  ``Persistent_BSS``                     -- GNAT
-  ``Post``
-  ``Pre``
-  ``Predicate``
-  ``Preelaborable_Initialization``
-  ``Pure_Function``                      -- GNAT
-  ``Remote_Access_Type``                 -- GNAT
-  ``Shared``                             -- GNAT
-  ``Size``
-  ``Storage_Pool``
-  ``Storage_Size``
-  ``Stream_Size``
-  ``Suppress``
-  ``Suppress_Debug_Info``                -- GNAT
-  ``Test_Case``                          -- GNAT
-  ``Thread_Local_Storage``               -- GNAT
-  ``Type_Invariant``
-  ``Unchecked_Union``
-  ``Universal_Aliasing``                 -- GNAT
-  ``Unmodified``                         -- GNAT
-  ``Unreferenced``                       -- GNAT
-  ``Unreferenced_Objects``               -- GNAT
-  ``Unsuppress``
-  ``Value_Size``                         -- GNAT
-  ``Volatile``
-  ``Volatile_Components``
-  ``Warnings``                           -- GNAT
-==================================== ===========
+  RM References:  6.05 (2.1/2)   3.03 (10/2)   3.03 (21)   6.05 (5/2)
+  6.05 (5.7/2)
 
-  Note that for aspects with an expression, e.g. ``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).
+.. index:: AI-0017 (Ada 2012 feature)
 
-  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)
+* *AI-0017 Freezing and incomplete types (0000-00-00)*
 
-.. index:: AI-0128 (Ada 2012 feature)
+  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.
 
-* *AI-0128 Inequality is a primitive operation (0000-00-00)*
+  RM References:  13.14 (3/1)
 
-  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.
+.. index:: AI-0019 (Ada 2012 feature)
 
-  RM References:  3.02.03 (6)   6.06 (6)
+* *AI-0019 Freezing of primitives for tagged types (0000-00-00)*
 
-.. index:: AI-0003 (Ada 2012 feature)
+  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.
 
-* *AI-0003 Qualified expressions as names (2010-07-11)*
+  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)
 
-  In Ada 2012, a qualified expression is considered to be syntactically a name,
-  meaning that constructs such as ``A'(F(X)).B`` are now legal. This is
-  useful in disambiguating some cases of overloading.
+.. index:: AI-0026 (Ada 2012 feature)
 
-  RM References:  3.03 (11)   3.03 (21)   4.01 (2)   4.04 (7)   4.07 (3)
-  5.04 (7)
+* *AI-0026 Missing rules for Unchecked_Union (2010-07-07)*
 
-.. index:: AI-0120 (Ada 2012 feature)
+  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.
 
-* *AI-0120 Constant instance of protected object (0000-00-00)*
+  RM References:  7.06 (9.4/2)   B.03.03 (9/2)   B.03.03 (10/2)
 
-  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.
+.. index:: AI-0030 (Ada 2012 feature)
 
-  RM References:  3.03 (21)
+* *AI-0030 Requeue on synchronized interfaces (2010-07-19)*
 
-.. index:: AI-0008 (Ada 2012 feature)
+  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
+  ``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.
 
-* *AI-0008 General access to constrained objects (0000-00-00)*
+  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)
 
-  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. ``Constraint_Error`` should be raised, and GNAT
-  has always done so in this situation.
+.. index:: AI-0031 (Ada 2012 feature)
 
-  RM References:  3.03 (23)   3.10.02 (26/2)   4.01 (9)   6.04.01 (17)   8.05.01 (5/2)
+* *AI-0031 Add From parameter to Find_Token (2010-07-25)*
 
-.. index:: AI-0093 (Ada 2012 feature)
+  A new version of ``Find_Token`` is added to all relevant string packages,
+  with an extra parameter ``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 ``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.
 
-* *AI-0093 Additional rules use immutably limited (0000-00-00)*
+  RM References:  A.04.03 (16)   A.04.03 (67)   A.04.03 (68/1)   A.04.04 (51)
+  A.04.05 (46)
 
-  This is an editorial change only, to make more widespread use of the Ada 2012
-  'immutably limited'.
+.. index:: AI-0032 (Ada 2012 feature)
 
-  RM References:  3.03 (23.4/3)
+* *AI-0032 Extended return for class-wide functions (0000-00-00)*
 
-.. index:: AI-0096 (Ada 2012 feature)
+  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.
 
-* *AI-0096 Deriving from formal private types (2010-07-20)*
+  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)
 
-  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.
+.. index:: AI-0033 (Ada 2012 feature)
 
-  RM References:  3.04 (5.1/2)   6.02 (7)
+* *AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)*
 
-.. index:: AI-0181 (Ada 2012 feature)
+  Neither of these two pragmas may appear within a generic template, because
+  the generic might be instantiated at other than the library level.
 
-* *AI-0181 Soft hyphen is a non-graphic character (2010-07-23)*
+  RM References:  13.11.02 (16)   C.03.01 (7/2)   C.03.01 (8/2)
 
-  From Ada 2005 on, soft hyphen is considered a non-graphic character, which
-  means that it has a special name (``SOFT_HYPHEN``) in conjunction with the
-  ``Image`` and ``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.
+.. index:: AI-0034 (Ada 2012 feature)
 
-  RM References:  3.05.02 (2/2)   A.01 (35/2)   A.03.03 (21)
+* *AI-0034 Categorization of limited views (0000-00-00)*
 
-.. index:: AI-0182 (Ada 2012 feature)
+  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.
 
-* *AI-0182 Additional forms for* ``Character'Value`` *(0000-00-00)*
+  RM References:  10.02.01 (11/1)   10.02.01 (17/2)
 
-  This AI allows ``Character'Value`` to accept the string ``'?'`` where
-  ``?`` is any character including non-graphic control characters. GNAT has
-  always accepted such strings. It also allows strings such as
-  ``HEX_00000041`` to be accepted, but GNAT does not take advantage of this
-  permission and raises ``Constraint_Error``, as is certainly still
-  permitted.
+.. index:: AI-0035 (Ada 2012 feature)
 
-  RM References:  3.05 (56/2)
+* *AI-0035 Inconsistencies with Pure units (0000-00-00)*
 
-.. index:: AI-0214 (Ada 2012 feature)
+  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.
 
-* *AI-0214 Defaulted discriminants for limited tagged (2010-10-01)*
+  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)
 
-  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.
+.. index:: AI-0037 (Ada 2012 feature)
 
-  RM References:  3.07 (9.1/2)   3.07.02 (3)
+* *AI-0037 Out-of-range box associations in aggregate (0000-00-00)*
 
-.. index:: AI-0102 (Ada 2012 feature)
+  This AI confirms that an association of the form ``Indx => <>`` in an
+  array aggregate must raise ``Constraint_Error`` if ``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.
 
-* *AI-0102 Some implicit conversions are illegal (0000-00-00)*
+  RM References:  4.03.03 (29)
 
-  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.
+.. index:: AI-0038 (Ada 2012 feature)
 
-  RM References:  3.07 (16)   3.07.01 (9)   6.04.01 (6)   8.06 (27/2)
+* *AI-0038 Minor errors in Text_IO (0000-00-00)*
 
-.. index:: AI-0158 (Ada 2012 feature)
+  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.
 
-* *AI-0158 Generalizing membership tests (2010-09-16)*
+  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)
 
-  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.
+.. index:: AI-0039 (Ada 2012 feature)
 
-  RM References:  3.08.01 (5)   4.04 (3)   4.05.02 (3)   4.05.02 (5)   4.05.02 (27)
+* *AI-0039 Stream attributes cannot be dynamic (0000-00-00)*
 
-.. index:: AI-0173 (Ada 2012 feature)
+  The RM permitted the use of dynamic expressions (such as ``ptr.all``)`
+  for stream attributes, but these were never useful and are now illegal. GNAT
+  has always regarded such expressions as illegal.
 
-* *AI-0173 Testing if tags represent abstract types (2010-07-03)*
+  RM References:  13.03 (4)   13.03 (6)   13.13.02 (38/2)
 
-  The function ``Ada.Tags.Type_Is_Abstract`` returns ``True`` if invoked
-  with the tag of an abstract type, and ``False`` otherwise.
+.. index:: AI-0040 (Ada 2012 feature)
+
+* *AI-0040 Limited with clauses on descendant (0000-00-00)*
+
+  This AI confirms that a limited with clause in a child unit cannot name
+  an ancestor of the unit. This has always been checked in GNAT.
+
+  RM References:  10.01.02 (20/2)
+
+.. index:: AI-0042 (Ada 2012 feature)
+
+* *AI-0042 Overriding versus implemented-by (0000-00-00)*
+
+  This AI fixes a wording gap in the RM. An operation of a synchronized
+  interface can be implemented by a protected or task entry, but the abstract
+  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:  9.01 (9.2/2)   9.04 (11.1/2)
+
+.. index:: AI-0043 (Ada 2012 feature)
+
+* *AI-0043 Rules about raising exceptions (0000-00-00)*
+
+  This AI covers various omissions in the RM regarding the raising of
+  exceptions. GNAT has always implemented the intended semantics.
+
+  RM References:  11.04.01 (10.1/2)   11 (2)
+
+.. index:: AI-0044 (Ada 2012 feature)
+
+* *AI-0044 Restrictions on container instantiations (0000-00-00)*
+
+  This AI places restrictions on allowed instantiations of generic containers.
+  These restrictions are not checked by the compiler, so there is nothing to
+  change in the implementation. This affects only the RM documentation.
+
+  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)
+
+.. index:: AI-0046 (Ada 2012 feature)
+
+* *AI-0046 Null exclusion match for full conformance (2010-07-17)*
+
+  For full conformance, in the case of access parameters, the null exclusion
+  must match (either both or neither must have ``not null``).
+
+  RM References:  6.03.02 (18)
+
+.. index:: AI-0050 (Ada 2012 feature)
+
+* *AI-0050 Raising Constraint_Error early for function call (0000-00-00)*
+
+  The implementation permissions for raising ``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 (7.4/2)   3.09 (12.4/2)
+  RM References:  6.05 (24/2)
 
-.. index:: AI-0076 (Ada 2012 feature)
+.. index:: AI-0056 (Ada 2012 feature)
 
-* *AI-0076 function with controlling result (0000-00-00)*
+* *AI-0056 Index on null string returns zero (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 wording in the Ada 2005 RM implied an incompatible handling of the
+  ``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:  3.09.02 (2/2)
+  RM References:  A.04.03 (56.2/2)   A.04.03 (58.5/2)
 
-.. index:: AI-0126 (Ada 2012 feature)
+.. index:: AI-0058 (Ada 2012 feature)
 
-* *AI-0126 Dispatching with no declared operation (0000-00-00)*
+* *AI-0058 Abnormal completion of an extended return (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 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 (20/2)   3.09.02 (20.1/2)   3.09.02 (20.2/2)
+  RM References:  6.05 (22/2)
 
-.. index:: AI-0097 (Ada 2012 feature)
+.. index:: AI-0060 (Ada 2012 feature)
 
-* *AI-0097 Treatment of abstract null extension (2010-07-19)*
+* *AI-0060 Extended definition of remote access types (0000-00-00)*
 
-  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.
+  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:  3.09.03 (4/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)
 
-.. index:: AI-0203 (Ada 2012 feature)
+.. index:: AI-0062 (Ada 2012 feature)
 
-* *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)
 
-.. index:: AI-0198 (Ada 2012 feature)
+.. index:: AI-0064 (Ada 2012 feature)
 
-* *AI-0198 Inheriting abstract operators  (0000-00-00)*
+* *AI-0064 Redundant finalization rule (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 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.09.03 (4/3)
+  RM References:  7.06.01 (17.1/1)
 
-.. index:: AI-0073 (Ada 2012 feature)
+.. index:: AI-0065 (Ada 2012 feature)
 
-* *AI-0073 Functions returning abstract types (2010-07-10)*
+* *AI-0065 Remote access types and external streaming (0000-00-00)*
 
-  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.
+  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:  3.09.03 (8)   3.09.03 (10)   6.05 (8/2)
+  RM References:  13.13.02 (52/2)
 
 .. index:: AI-0070 (Ada 2012 feature)
 
@@ -377,107 +390,87 @@  Supported Aspect                     Source
 
   RM References:  3.09.04 (18/2)
 
-.. index:: AI-0208 (Ada 2012 feature)
-
-* *AI-0208 Characteristics of incomplete views (0000-00-00)*
-
-  The wording in the Ada 2005 RM concerning characteristics of incomplete views
-  was incorrect and implied that some programs intended to be legal were now
-  illegal. GNAT had never considered such programs illegal, so it has always
-  implemented the intent of this AI.
-
-  RM References:  3.10.01 (2.4/2)   3.10.01 (2.6/2)
-
-.. index:: AI-0162 (Ada 2012 feature)
+.. index:: AI-0072 (Ada 2012 feature)
 
-* *AI-0162 Incomplete type completed by partial view (2010-09-15)*
+* *AI-0072 Task signalling using 'Terminated (0000-00-00)*
 
-  Incomplete types are made more useful by allowing them to be completed by
-  private types and private extensions.
+  This AI clarifies that task signalling for reading ``'Terminated`` only
+  occurs if the result is True. GNAT semantics has always been consistent with
+  this notion of task signalling.
 
-  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:  9.10 (6.1/1)
 
-.. index:: AI-0098 (Ada 2012 feature)
+.. index:: AI-0073 (Ada 2012 feature)
 
-* *AI-0098 Anonymous subprogram access restrictions (0000-00-00)*
+* *AI-0073 Functions returning abstract types (2010-07-10)*
 
-  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 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.
 
-  RM References:  3.10.01 (6)   3.10.01 (9.2/2)
+  RM References:  3.09.03 (8)   3.09.03 (10)   6.05 (8/2)
 
-.. index:: AI-0199 (Ada 2012 feature)
+.. index:: AI-0076 (Ada 2012 feature)
 
-* *AI-0199 Aggregate with anonymous access components (2010-07-14)*
+* *AI-0076 function with controlling result (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 is an editorial change only. The RM defines calls with controlling
+  results, but uses the term 'function with controlling result' without an
+  explicit definition.
 
-  RM References:  4.03.01 (16)
+  RM References:  3.09.02 (2/2)
 
-.. index:: AI-0220 (Ada 2012 feature)
+.. index:: AI-0077 (Ada 2012 feature)
 
-* *AI-0220 Needed components for aggregates (0000-00-00)*
+* *AI-0077 Limited withs and scope of declarations (0000-00-00)*
 
-  This AI addresses a wording problem in the RM that appears to permit some
-  complex cases of aggregates with nonstatic discriminants. GNAT has always
-  implemented the intended semantics.
+  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.03.01 (17)
+  RM References:  10.01.02 (12/2)   10.01.02 (21/2)   10.01.02 (22/2)
 
-.. index:: AI-0147 (Ada 2012 feature)
+.. index:: AI-0078 (Ada 2012 feature)
 
-* *AI-0147 Conditional expressions (2009-03-29)*
+* *AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)*
 
-  Conditional expressions are permitted. The form of such an expression is:
+  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:  13.09 (7)
 
-        (if expr then expr {elsif expr then expr} [else expr])
+.. index:: AI-0079 (Ada 2012 feature)
 
-  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 ``(if A then B)`` is a way to conveniently represent
-  *(A implies B)* in standard logic.
+* *AI-0079 Allow other_format characters in source (2010-07-10)*
 
-  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)
+  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.
 
-.. index:: AI-0037 (Ada 2012 feature)
+  RM References:  2.01 (4/2)   2.02 (7)
 
-* *AI-0037 Out-of-range box associations in aggregate (0000-00-00)*
+.. index:: AI-0080 (Ada 2012 feature)
 
-  This AI confirms that an association of the form ``Indx => <>`` in an
-  array aggregate must raise ``Constraint_Error`` if ``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.
+* *AI-0080 'View of' not needed if clear from context (0000-00-00)*
 
-  RM References:  4.03.03 (29)
+  This is an editorial change only, described as non-testable in the AI.
 
-.. index:: AI-0123 (Ada 2012 feature)
+  RM References:  3.01 (7)
 
-* *AI-0123 Composability of equality (2010-04-13)*
+.. index:: AI-0087 (Ada 2012 feature)
 
-  Equality of untagged record composes, so that the predefined equality for a
-  composite type that includes a component of some untagged record type
-  ``R`` uses the equality operation of ``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-0087 Actual for formal nonlimited derived type (2010-07-15)*
 
-  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.
+  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:  4.05.02 (9.7/2)   4.05.02 (14)   4.05.02 (15)   4.05.02 (24)
-  8.05.04 (8)
+  RM References:  7.05 (5/2)   12.05.01 (5.1/2)
 
 .. index:: AI-0088 (Ada 2012 feature)
 
@@ -491,128 +484,100 @@  Supported Aspect                     Source
 
   RM References:  4.05.06 (11)
 
-.. index:: AI-0188 (Ada 2012 feature)
-
-* *AI-0188 Case expressions (2010-01-09)*
-
-  Case expressions are permitted. This allows use of constructs such as:
-
-  .. code-block:: ada
-
-      X := (case Y is when 1 => 2, when 2 => 3, when others => 31)
-
-  RM References:  4.05.07 (0)   4.05.08 (0)   4.09 (12)   4.09 (33)
-
-.. index:: AI-0104 (Ada 2012 feature)
-
-* *AI-0104 Null exclusion and uninitialized allocator (2010-07-15)*
-
-  The assignment ``Ptr := new not null Some_Ptr;`` will raise
-  ``Constraint_Error`` because the default value of the allocated object is
-  **null**. This useless construct is illegal in Ada 2012.
-
-  RM References:  4.08 (2)
-
-.. index:: AI-0157 (Ada 2012 feature)
-
-* *AI-0157 Allocation/Deallocation from empty pool (2010-07-11)*
-
-  Allocation and Deallocation from an empty storage pool (i.e. allocation or
-  deallocation of a pointer for which a static storage size clause of zero
-  has been given) is now illegal and is detected as such. GNAT
-  previously gave a warning but not an error.
-
-  RM References:  4.08 (5.3/2)   13.11.02 (4)   13.11.02 (17)
-
-.. index:: AI-0179 (Ada 2012 feature)
-
-* *AI-0179 Statement not required after label (2010-04-10)*
+.. index:: AI-0091 (Ada 2012 feature)
 
-  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.
+* *AI-0091 Do not allow other_format in identifiers (0000-00-00)*
 
-  RM References:  5.01 (2)
+  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.
 
-.. index:: AI-0139-2 (Ada 2012 feature)
+  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)
 
-* *AI-0139-2 Syntactic sugar for iterators (2010-09-29)*
+.. index:: AI-0093 (Ada 2012 feature)
 
-  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:  ``for Elem of C``.
+* *AI-0093 Additional rules use immutably limited (0000-00-00)*
 
-  RM References:  5.05
+  This is an editorial change only, to make more widespread use of the Ada 2012
+  'immutably limited'.
 
-.. index:: AI-0134 (Ada 2012 feature)
+  RM References:  3.03 (23.4/3)
 
-* *AI-0134 Profiles must match for full conformance (0000-00-00)*
+.. index:: AI-0095 (Ada 2012 feature)
 
-  For full conformance, the profiles of anonymous-access-to-subprogram
-  parameters must match. GNAT has always enforced this rule.
+* *AI-0095 Address of intrinsic subprograms (0000-00-00)*
 
-  RM References:  6.03.01 (18)
+  The prefix of ``'Address`` cannot statically denote a subprogram with
+  convention ``Intrinsic``. The use of the ``Address`` attribute raises
+  ``Program_Error`` if the prefix denotes a subprogram with convention
+  ``Intrinsic``.
 
-.. index:: AI-0207 (Ada 2012 feature)
+  RM References:  13.03 (11/1)
 
-* *AI-0207 Mode conformance and access constant (0000-00-00)*
+.. index:: AI-0096 (Ada 2012 feature)
 
-  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.
+* *AI-0096 Deriving from formal private types (2010-07-20)*
 
-  RM References:  6.03.01 (16/2)
+  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.
 
-.. index:: AI-0046 (Ada 2012 feature)
+  RM References:  3.04 (5.1/2)   6.02 (7)
 
-* *AI-0046 Null exclusion match for full conformance (2010-07-17)*
+.. index:: AI-0097 (Ada 2012 feature)
 
-  For full conformance, in the case of access parameters, the null exclusion
-  must match (either both or neither must have ``not null``).
+* *AI-0097 Treatment of abstract null extension (2010-07-19)*
 
-  RM References:  6.03.02 (18)
+  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.
 
-.. index:: AI-0118 (Ada 2012 feature)
+  RM References:  3.09.03 (4/2)
 
-* *AI-0118 The association of parameter associations (0000-00-00)*
+.. index:: AI-0098 (Ada 2012 feature)
 
-  This AI clarifies the rules for named associations in subprogram calls and
-  generic instantiations. The rules have been in place since Ada 83.
+* *AI-0098 Anonymous subprogram access restrictions (0000-00-00)*
 
-  RM References:  6.04.01 (2)   12.03 (9)
+  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.
 
-.. index:: AI-0196 (Ada 2012 feature)
+  RM References:  3.10.01 (6)   3.10.01 (9.2/2)
 
-* *AI-0196 Null exclusion tests for out parameters (0000-00-00)*
+.. index:: AI-0099 (Ada 2012 feature)
 
-  Null exclusion checks are not made for ``out`` parameters when
-  evaluating the actual parameters. GNAT has never generated these checks.
+* *AI-0099 Tag determines whether finalization needed (0000-00-00)*
 
-  RM References:  6.04.01 (13)
+  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''.
 
-.. index:: AI-0015 (Ada 2012 feature)
+  RM References:  7.06.01 (6)   7.06.01 (7)   7.06.01 (8)   7.06.01 (9/2)
 
-* *AI-0015 Constant return objects (0000-00-00)*
+.. index:: AI-0100 (Ada 2012 feature)
 
-  The return object declared in an *extended_return_statement* may be
-  declared constant. This was always intended, and GNAT has always allowed it.
+* *AI-0100 Placement of pragmas  (2010-07-01)*
 
-  RM References:  6.05 (2.1/2)   3.03 (10/2)   3.03 (21)   6.05 (5/2)
-  6.05 (5.7/2)
+  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.
 
-.. index:: AI-0032 (Ada 2012 feature)
+  RM References:  2.08 (7)
 
-* *AI-0032 Extended return for class-wide functions (0000-00-00)*
+.. index:: AI-0102 (Ada 2012 feature)
 
-  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.
+* *AI-0102 Some implicit conversions are illegal (0000-00-00)*
 
-  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)
+  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.
+
+  RM References:  3.07 (16)   3.07.01 (9)   6.04.01 (6)   8.06 (27/2)
 
 .. index:: AI-0103 (Ada 2012 feature)
 
@@ -624,178 +589,170 @@  Supported Aspect                     Source
 
   RM References:  6.05 (5.2/2)
 
-.. index:: AI-0058 (Ada 2012 feature)
-
-* *AI-0058 Abnormal completion of an extended return (0000-00-00)*
-
-  The RM had some incorrect wording implying wrong treatment of abnormal
-  completion in an extended return. GNAT has always implemented the intended
-  correct semantics as described by this AI.
-
-  RM References:  6.05 (22/2)
+.. index:: AI-0104 (Ada 2012 feature)
 
-.. index:: AI-0050 (Ada 2012 feature)
+* *AI-0104 Null exclusion and uninitialized allocator (2010-07-15)*
 
-* *AI-0050 Raising Constraint_Error early for function call (0000-00-00)*
+  The assignment ``Ptr := new not null Some_Ptr;`` will raise
+  ``Constraint_Error`` because the default value of the allocated object is
+  **null**. This useless construct is illegal in Ada 2012.
 
-  The implementation permissions for raising ``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:  4.08 (2)
 
-  RM References:  6.05 (24/2)
+.. index:: AI-0106 (Ada 2012 feature)
 
-.. index:: AI-0125 (Ada 2012 feature)
+* *AI-0106 No representation pragmas on generic formals (0000-00-00)*
 
-* *AI-0125 Nonoverridable operations of an ancestor (2010-09-28)*
+  The RM appeared to allow representation pragmas on generic formal parameters,
+  but this was not intended, and GNAT has never permitted this usage.
 
-  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:  13.01 (9.1/1)
 
-  RM References:  7.03.01 (6)   8.03 (23)   8.03.01 (5/2)   8.03.01 (6/2)
+.. index:: AI-0108 (Ada 2012 feature)
 
-.. index:: AI-0062 (Ada 2012 feature)
+* *AI-0108 Limited incomplete view and discriminants (0000-00-00)*
 
-* *AI-0062 Null exclusions and deferred constants (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.
 
-  A full constant may have a null exclusion even if its associated deferred
-  constant does not. GNAT has always allowed this.
+  RM References:  10.01.01 (12.3/2)
 
-  RM References:  7.04 (6/2)   7.04 (7.1/2)
+.. index:: AI-0109 (Ada 2012 feature)
 
-.. index:: AI-0178 (Ada 2012 feature)
+* *AI-0109 Redundant check in S'Class'Input (0000-00-00)*
 
-* *AI-0178 Incomplete views are limited (0000-00-00)*
+  This AI is an editorial change only. It removes the need for a tag check
+  that can never fail.
 
-  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:  13.13.02 (34/2)
 
-  RM References:  7.05 (3/2)   7.05 (6/2)
+.. index:: AI-0112 (Ada 2012 feature)
 
-.. index:: AI-0087 (Ada 2012 feature)
+* *AI-0112 Detection of duplicate pragmas (2010-07-24)*
 
-* *AI-0087 Actual for formal nonlimited derived type (2010-07-15)*
+  This AI concerns giving names to various representation aspects, but the
+  practical effect is simply to make the use of duplicate
+  ``Atomic[_Components]``,
+  ``Volatile[_Components]``, and
+  ``Independent[_Components]`` pragmas illegal, and GNAT
+  now performs this required check.
 
-  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:  13.01 (8)
 
-  RM References:  7.05 (5/2)   12.05.01 (5.1/2)
+.. index:: AI-0114 (Ada 2012 feature)
 
-.. index:: AI-0099 (Ada 2012 feature)
+* *AI-0114 Classification of letters (0000-00-00)*
 
-* *AI-0099 Tag determines whether finalization needed (0000-00-00)*
+  The code points 170 (``FEMININE ORDINAL INDICATOR``),
+  181 (``MICRO SIGN``), and
+  186 (``MASCULINE ORDINAL INDICATOR``) are technically considered
+  lower case letters by Unicode.
+  However, they are not allowed in identifiers, and they
+  return ``False`` to ``Ada.Characters.Handling.Is_Letter/Is_Lower``.
+  This behavior is consistent with that defined in Ada 95.
 
-  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:  A.03.02 (59)   A.04.06 (7)
 
-  RM References:  7.06.01 (6)   7.06.01 (7)   7.06.01 (8)   7.06.01 (9/2)
+.. index:: AI-0116 (Ada 2012 feature)
 
-.. index:: AI-0064 (Ada 2012 feature)
+* *AI-0116 Alignment of class-wide objects (0000-00-00)*
 
-* *AI-0064 Redundant finalization rule (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 an editorial change only. The intended behavior is already checked
-  by an existing ACATS test, which GNAT has always executed correctly.
+  RM References:  13.03 (29)   13.11 (16)
 
-  RM References:  7.06.01 (17.1/1)
+.. index:: AI-0118 (Ada 2012 feature)
 
-.. index:: AI-0026 (Ada 2012 feature)
+* *AI-0118 The association of parameter associations (0000-00-00)*
 
-* *AI-0026 Missing rules for Unchecked_Union (2010-07-07)*
+  This AI clarifies the rules for named associations in subprogram calls and
+  generic instantiations. The rules have been in place since Ada 83.
 
-  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:  6.04.01 (2)   12.03 (9)
 
-  RM References:  7.06 (9.4/2)   B.03.03 (9/2)   B.03.03 (10/2)
+.. index:: AI-0120 (Ada 2012 feature)
 
-.. index:: AI-0205 (Ada 2012 feature)
+* *AI-0120 Constant instance of protected object (0000-00-00)*
 
-* *AI-0205 Extended return declares visible name (0000-00-00)*
+  This is an RM editorial change only. The section that lists objects that are
+  constant failed to include the current instance of a protected object
+  within a protected function. This has always been treated as a constant
+  in GNAT.
 
-  This AI corrects a simple omission in the RM. Return objects have always
-  been visible within an extended return statement.
+  RM References:  3.03 (21)
 
-  RM References:  8.03 (17)
+.. index:: AI-0122 (Ada 2012 feature)
 
-.. index:: AI-0042 (Ada 2012 feature)
+* *AI-0122 Private with and children of generics (0000-00-00)*
 
-* *AI-0042 Overriding versus implemented-by (0000-00-00)*
+  This AI clarifies the visibility of private children of generic units within
+  instantiations of a parent. GNAT has always handled this correctly.
 
-  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:  10.01.02 (12/2)
 
-  RM References:  9.01 (9.2/2)   9.04 (11.1/2)
+.. index:: AI-0123 (Ada 2012 feature)
 
-.. index:: AI-0030 (Ada 2012 feature)
+* *AI-0123 Composability of equality (2010-04-13)*
 
-* *AI-0030 Requeue on synchronized interfaces (2010-07-19)*
+  Equality of untagged record composes, so that the predefined equality for a
+  composite type that includes a component of some untagged record type
+  ``R`` uses the equality operation of ``R`` (which may be user-defined
+  or predefined). This makes the behavior of untagged records identical to that
+  of tagged types in this respect.
 
-  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
-  ``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 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.
 
-  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:  4.05.02 (9.7/2)   4.05.02 (14)   4.05.02 (15)   4.05.02 (24)
+  8.05.04 (8)
 
-.. index:: AI-0201 (Ada 2012 feature)
+.. index:: AI-0125 (Ada 2012 feature)
 
-* *AI-0201 Independence of atomic object components (2010-07-22)*
+* *AI-0125 Nonoverridable operations of an ancestor (2010-09-28)*
 
-  If an Atomic object has a pragma ``Pack`` or a ``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.
+  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:  9.10 (1/3)   C.06 (22/2)   C.06 (23/2)
+  RM References:  7.03.01 (6)   8.03 (23)   8.03.01 (5/2)   8.03.01 (6/2)
 
-.. index:: AI-0009 (Ada 2012 feature)
+.. index:: AI-0126 (Ada 2012 feature)
 
-* *AI-0009 Pragma Independent[_Components] (2010-07-23)*
+* *AI-0126 Dispatching with no declared operation (0000-00-00)*
 
-  This AI introduces the new pragmas ``Independent`` and
-  ``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 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.
 
-  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:  3.09.02 (20/2)   3.09.02 (20.1/2)   3.09.02 (20.2/2)
 
-.. index:: AI-0072 (Ada 2012 feature)
+.. index:: AI-0127 (Ada 2012 feature)
 
-* *AI-0072 Task signalling using 'Terminated (0000-00-00)*
+* *AI-0127 Adding Locale Capabilities (2010-09-29)*
 
-  This AI clarifies that task signalling for reading ``'Terminated`` only
-  occurs if the result is True. GNAT semantics has always been consistent with
-  this notion of task signalling.
+  This package provides an interface for identifying the current locale.
 
-  RM References:  9.10 (6.1/1)
+  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
 
-.. index:: AI-0108 (Ada 2012 feature)
+.. index:: AI-0128 (Ada 2012 feature)
 
-* *AI-0108 Limited incomplete view and discriminants (0000-00-00)*
+* *AI-0128 Inequality is a primitive operation (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.
+  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:  10.01.01 (12.3/2)
+  RM References:  3.02.03 (6)   6.06 (6)
 
 .. index:: AI-0129 (Ada 2012 feature)
 
@@ -809,35 +766,6 @@  Supported Aspect                     Source
 
   RM References:  10.01.01 (12.2/2)   10.01.01 (12.3/2)
 
-.. index:: AI-0077 (Ada 2012 feature)
-
-* *AI-0077 Limited withs and scope of declarations (0000-00-00)*
-
-  This AI clarifies that a declaration does not include a context clause,
-  and confirms that it is illegal to have a context in which both a limited
-  and a nonlimited view of a package are accessible. Such double visibility
-  was always rejected by GNAT.
-
-  RM References:  10.01.02 (12/2)   10.01.02 (21/2)   10.01.02 (22/2)
-
-.. index:: AI-0122 (Ada 2012 feature)
-
-* *AI-0122 Private with and children of generics (0000-00-00)*
-
-  This AI clarifies the visibility of private children of generic units within
-  instantiations of a parent. GNAT has always handled this correctly.
-
-  RM References:  10.01.02 (12/2)
-
-.. index:: AI-0040 (Ada 2012 feature)
-
-* *AI-0040 Limited with clauses on descendant (0000-00-00)*
-
-  This AI confirms that a limited with clause in a child unit cannot name
-  an ancestor of the unit. This has always been checked in GNAT.
-
-  RM References:  10.01.02 (20/2)
-
 .. index:: AI-0132 (Ada 2012 feature)
 
 * *AI-0132 Placement of library unit pragmas (0000-00-00)*
@@ -848,175 +776,173 @@  Supported Aspect                     Source
 
   RM References:  10.01.05 (7)
 
-.. index:: AI-0034 (Ada 2012 feature)
-
-* *AI-0034 Categorization of limited views (0000-00-00)*
-
-  The RM makes certain limited with clauses illegal because of categorization
-  considerations, when the corresponding normal with would be legal. This is
-  not intended, and GNAT has always implemented the recommended behavior.
-
-  RM References:  10.02.01 (11/1)   10.02.01 (17/2)
-
-.. index:: AI-0035 (Ada 2012 feature)
+.. index:: AI-0134 (Ada 2012 feature)
 
-* *AI-0035 Inconsistencies with Pure units (0000-00-00)*
+* *AI-0134 Profiles must match for full conformance (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.
+  For full conformance, the profiles of anonymous-access-to-subprogram
+  parameters must match. GNAT has always enforced this rule.
 
-  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:  6.03.01 (18)
 
-.. index:: AI-0219 (Ada 2012 feature)
+.. index:: AI-0137 (Ada 2012 feature)
 
-* *AI-0219 Pure permissions and limited parameters (2010-05-25)*
+* *AI-0137 String encoding package (2010-03-25)*
 
-  This AI refines the rules for the cases with limited parameters which do not
-  allow the implementations to omit 'redundant'. GNAT now properly conforms
-  to the requirements of this binding interpretation.
+  The packages ``Ada.Strings.UTF_Encoding``, together with its child
+  packages, ``Conversions``, ``Strings``, ``Wide_Strings``,
+  and ``Wide_Wide_Strings`` have been
+  implemented. These packages (whose documentation can be found in the spec
+  files :file:`a-stuten.ads`, :file:`a-suenco.ads`, :file:`a-suenst.ads`,
+  :file:`a-suewst.ads`, :file:`a-suezst.ads`) allow encoding and decoding of
+  ``String``, ``Wide_String``, and ``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 ``Wide_Wide_Strings``, these packages are available in
+  Ada 95 and Ada 2005 mode as well as Ada 2012 mode.
+  The ``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 ``Wide_Wide_Character``).
 
-  RM References:  10.02.01 (18/2)
+  RM References:  A.04.11
 
-.. index:: AI-0043 (Ada 2012 feature)
+.. index:: AI-0139-2 (Ada 2012 feature)
 
-* *AI-0043 Rules about raising exceptions (0000-00-00)*
+* *AI-0139-2 Syntactic sugar for iterators (2010-09-29)*
 
-  This AI covers various omissions in the RM regarding the raising of
-  exceptions. GNAT has always implemented the intended semantics.
+  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:  ``for Elem of C``.
 
-  RM References:  11.04.01 (10.1/2)   11 (2)
+  RM References:  5.05
 
-.. index:: AI-0200 (Ada 2012 feature)
+.. index:: AI-0146 (Ada 2012 feature)
 
-* *AI-0200 Mismatches in formal package declarations (0000-00-00)*
+* *AI-0146 Type invariants (2009-09-21)*
 
-  This AI plugs a gap in the RM which appeared to allow some obviously intended
-  illegal instantiations. GNAT has never allowed these instantiations.
+  Type invariants may be specified for private types using the aspect notation.
+  Aspect ``Type_Invariant`` may be specified for any private type,
+  ``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 ``Invariant`` for ``Type_Invariant`` and
+  ``Invariant'Class`` for ``Type_Invariant'Class``.
 
-  RM References:  12.07 (16)
+  RM References:  13.03.03 (00)
 
-.. index:: AI-0112 (Ada 2012 feature)
+.. index:: AI-0147 (Ada 2012 feature)
 
-* *AI-0112 Detection of duplicate pragmas (2010-07-24)*
+* *AI-0147 Conditional expressions (2009-03-29)*
 
-  This AI concerns giving names to various representation aspects, but the
-  practical effect is simply to make the use of duplicate
-  ``Atomic[_Components]``,
-  ``Volatile[_Components]``, and
-  ``Independent[_Components]`` pragmas illegal, and GNAT
-  now performs this required check.
+  Conditional expressions are permitted. The form of such an expression is:
 
-  RM References:  13.01 (8)
+  ::
 
-.. index:: AI-0106 (Ada 2012 feature)
+        (if expr then expr {elsif expr then expr} [else expr])
 
-* *AI-0106 No representation pragmas on generic formals (0000-00-00)*
+  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 ``(if A then B)`` is a way to conveniently represent
+  *(A implies B)* in standard logic.
 
-  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:  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:  13.01 (9.1/1)
+.. index:: AI-0152 (Ada 2012 feature)
 
-.. index:: AI-0012 (Ada 2012 feature)
+* *AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)*
 
-* *AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)*
+  Restriction ``No_Anonymous_Allocators`` prevents the use of allocators
+  where the type of the returned value is an anonymous access type.
 
-  It is now illegal to give an inappropriate component size or a pragma
-  ``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:  H.04 (8/1)
 
-  RM References:  13.02 (6.1/2)   13.02 (7)   C.06 (10)   C.06 (11)   C.06 (21)
+.. index:: AI-0157 (Ada 2012 feature)
 
-.. index:: AI-0039 (Ada 2012 feature)
+* *AI-0157 Allocation/Deallocation from empty pool (2010-07-11)*
 
-* *AI-0039 Stream attributes cannot be dynamic (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.
 
-  The RM permitted the use of dynamic expressions (such as ``ptr.all``)`
-  for stream attributes, but these were never useful and are now illegal. GNAT
-  has always regarded such expressions as illegal.
+  RM References:  4.08 (5.3/2)   13.11.02 (4)   13.11.02 (17)
 
-  RM References:  13.03 (4)   13.03 (6)   13.13.02 (38/2)
+.. index:: AI-0158 (Ada 2012 feature)
 
-.. index:: AI-0095 (Ada 2012 feature)
+* *AI-0158 Generalizing membership tests (2010-09-16)*
 
-* *AI-0095 Address of intrinsic subprograms (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.
 
-  The prefix of ``'Address`` cannot statically denote a subprogram with
-  convention ``Intrinsic``. The use of the ``Address`` attribute raises
-  ``Program_Error`` if the prefix denotes a subprogram with convention
-  ``Intrinsic``.
+  RM References:  3.08.01 (5)   4.04 (3)   4.05.02 (3)   4.05.02 (5)   4.05.02 (27)
 
-  RM References:  13.03 (11/1)
+.. index:: AI-0161 (Ada 2012 feature)
 
-.. index:: AI-0116 (Ada 2012 feature)
+* *AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)*
 
-* *AI-0116 Alignment of class-wide objects (0000-00-00)*
+  A new restriction ``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.
 
-  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:  13.12.01 (4/2)   13.13.02 (40/2)   13.13.02 (52/2)
 
-  RM References:  13.03 (29)   13.11 (16)
+.. index:: AI-0162 (Ada 2012 feature)
 
-.. index:: AI-0146 (Ada 2012 feature)
+* *AI-0162 Incomplete type completed by partial view (2010-09-15)*
 
-* *AI-0146 Type invariants (2009-09-21)*
+  Incomplete types are made more useful by allowing them to be completed by
+  private types and private extensions.
 
-  Type invariants may be specified for private types using the aspect notation.
-  Aspect ``Type_Invariant`` may be specified for any private type,
-  ``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 ``Invariant`` for ``Type_Invariant`` and
-  ``Invariant'Class`` for ``Type_Invariant'Class``.
+  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:  13.03.03 (00)
+.. index:: AI-0163 (Ada 2012 feature)
 
-.. index:: AI-0078 (Ada 2012 feature)
+* *AI-0163 Pragmas in place of null (2010-07-01)*
 
-* *AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)*
+  A statement sequence may be composed entirely of pragmas. It is no longer
+  necessary to add a dummy ``null`` statement to make the sequence legal.
 
-  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:  2.08 (7)   2.08 (16)
 
-  RM References:  13.09 (7)
+.. index:: AI-0171 (Ada 2012 feature)
 
-.. index:: AI-0195 (Ada 2012 feature)
+* *AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)*
 
-* *AI-0195 Invalid value handling is implementation defined (2010-07-03)*
+  A new package ``System.Multiprocessors`` is added, together with the
+  definition of pragma ``CPU`` for controlling task affinity. A new no
+  dependence restriction, on ``System.Multiprocessors.Dispatching_Domains``,
+  is added to the Ravenscar profile.
 
-  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:  D.13.01 (4/2)   D.16
 
-  RM References:  13.09.01 (10)
+.. index:: AI-0173 (Ada 2012 feature)
 
-.. index:: AI-0193 (Ada 2012 feature)
+* *AI-0173 Testing if tags represent abstract types (2010-07-03)*
 
-* *AI-0193 Alignment of allocators (2010-09-16)*
+  The function ``Ada.Tags.Type_Is_Abstract`` returns ``True`` if invoked
+  with the tag of an abstract type, and ``False`` otherwise.
 
-  This AI introduces a new attribute ``Max_Alignment_For_Allocation``,
-  analogous to ``Max_Size_In_Storage_Elements``, but for alignment instead
-  of size.
+  RM References:  3.09 (7.4/2)   3.09 (12.4/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)
+.. index:: AI-0176 (Ada 2012 feature)
+
+* *AI-0176 Quantified expressions (2010-09-29)*
+
+  Both universally and existentially quantified expressions are implemented.
+  They use the new syntax for iterators proposed in AI05-139-2, as well as
+  the standard Ada loop syntax.
+
+  RM References:  1.01.04 (12)   2.09 (2/2)   4.04 (7)   4.05.09 (0)
 
 .. index:: AI-0177 (Ada 2012 feature)
 
@@ -1035,225 +961,321 @@  Supported Aspect                     Source
 
   RM References:  13.11.01 (3/2)
 
-.. index:: AI-0033 (Ada 2012 feature)
+.. index:: AI-0178 (Ada 2012 feature)
 
-* *AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)*
+* *AI-0178 Incomplete views are limited (0000-00-00)*
 
-  Neither of these two pragmas may appear within a generic template, because
-  the generic might be instantiated at other than the library level.
+  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:  13.11.02 (16)   C.03.01 (7/2)   C.03.01 (8/2)
+  RM References:  7.05 (3/2)   7.05 (6/2)
 
-.. index:: AI-0161 (Ada 2012 feature)
+.. index:: AI-0179 (Ada 2012 feature)
 
-* *AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)*
+* *AI-0179 Statement not required after label (2010-04-10)*
 
-  A new restriction ``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.
+  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:  13.12.01 (4/2)   13.13.02 (40/2)   13.13.02 (52/2)
+  RM References:  5.01 (2)
 
-.. index:: AI-0194 (Ada 2012 feature)
+.. index:: AI-0181 (Ada 2012 feature)
 
-* *AI-0194 Value of Stream_Size attribute (0000-00-00)*
+* *AI-0181 Soft hyphen is a non-graphic character (2010-07-23)*
 
-  The ``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.
+  From Ada 2005 on, soft hyphen is considered a non-graphic character, which
+  means that it has a special name (``SOFT_HYPHEN``) in conjunction with the
+  ``Image`` and ``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.
 
-  RM References:  13.13.02 (1.2/2)
+  RM References:  3.05.02 (2/2)   A.01 (35/2)   A.03.03 (21)
 
-.. index:: AI-0109 (Ada 2012 feature)
+.. index:: AI-0182 (Ada 2012 feature)
 
-* *AI-0109 Redundant check in S'Class'Input (0000-00-00)*
+* *AI-0182 Additional forms for* ``Character'Value`` *(0000-00-00)*
 
-  This AI is an editorial change only. It removes the need for a tag check
-  that can never fail.
+  This AI allows ``Character'Value`` to accept the string ``'?'`` where
+  ``?`` is any character including non-graphic control characters. GNAT has
+  always accepted such strings. It also allows strings such as
+  ``HEX_00000041`` to be accepted, but GNAT does not take advantage of this
+  permission and raises ``Constraint_Error``, as is certainly still
+  permitted.
 
-  RM References:  13.13.02 (34/2)
+  RM References:  3.05 (56/2)
 
-.. index:: AI-0007 (Ada 2012 feature)
+.. index:: AI-0183 (Ada 2012 feature)
 
-* *AI-0007 Stream read and private scalar types (0000-00-00)*
+* *AI-0183 Aspect specifications (2010-08-16)*
 
-  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.
+  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)
 
-  RM References:  13.13.02 (50/2)   13.13.02 (51/2)
+==================================== ===========
+Supported Aspect                     Source
+==================================== ===========
+  ``Ada_2005``                           -- GNAT
+  ``Ada_2012``                           -- GNAT
+  ``Address``
+  ``Alignment``
+  ``Atomic``
+  ``Atomic_Components``
+  ``Bit_Order``
+  ``Component_Size``
+  ``Contract_Cases``                     -- GNAT
+  ``Discard_Names``
+  ``External_Tag``
+  ``Favor_Top_Level``                    -- GNAT
+  ``Inline``
+  ``Inline_Always``                      -- GNAT
+  ``Invariant``                          -- GNAT
+  ``Machine_Radix``
+  ``No_Return``
+  ``Object_Size``                        -- GNAT
+  ``Pack``
+  ``Persistent_BSS``                     -- GNAT
+  ``Post``
+  ``Pre``
+  ``Predicate``
+  ``Preelaborable_Initialization``
+  ``Pure_Function``                      -- GNAT
+  ``Remote_Access_Type``                 -- GNAT
+  ``Shared``                             -- GNAT
+  ``Size``
+  ``Storage_Pool``
+  ``Storage_Size``
+  ``Stream_Size``
+  ``Suppress``
+  ``Suppress_Debug_Info``                -- GNAT
+  ``Test_Case``                          -- GNAT
+  ``Thread_Local_Storage``               -- GNAT
+  ``Type_Invariant``
+  ``Unchecked_Union``
+  ``Universal_Aliasing``                 -- GNAT
+  ``Unmodified``                         -- GNAT
+  ``Unreferenced``                       -- GNAT
+  ``Unreferenced_Objects``               -- GNAT
+  ``Unsuppress``
+  ``Value_Size``                         -- GNAT
+  ``Volatile``
+  ``Volatile_Components``
+  ``Warnings``                           -- GNAT
+==================================== ===========
 
-.. index:: AI-0065 (Ada 2012 feature)
+  Note that for aspects with an expression, e.g. ``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).
 
-* *AI-0065 Remote access types and external streaming (0000-00-00)*
+  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)
 
-  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.
+.. index:: AI-0185 (Ada 2012 feature)
 
-  RM References:  13.13.02 (52/2)
+* *AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)*
 
-.. index:: AI-0019 (Ada 2012 feature)
+  Two new packages ``Ada.Wide_[Wide_]Characters.Handling`` provide
+  classification functions for ``Wide_Character`` and
+  ``Wide_Wide_Character``, as well as providing
+  case folding routines for ``Wide_[Wide_]Character`` and
+  ``Wide_[Wide_]String``.
 
-* *AI-0019 Freezing of primitives for tagged types (0000-00-00)*
+  RM References:  A.03.05 (0)   A.03.06 (0)
 
-  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.
+.. index:: AI-0188 (Ada 2012 feature)
+
+* *AI-0188 Case expressions (2010-01-09)*
+
+  Case expressions are permitted. This allows use of constructs such as:
+
+  .. code-block:: ada
+
+      X := (case Y is when 1 => 2, when 2 => 3, when others => 31)
+
+  RM References:  4.05.07 (0)   4.05.08 (0)   4.09 (12)   4.09 (33)
+
+.. index:: AI-0189 (Ada 2012 feature)
+
+* *AI-0189 No_Allocators_After_Elaboration (2010-01-23)*
+
+  This AI introduces a new restriction ``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:  D.07 (19.1/2)   H.04 (23.3/2)
+
+.. index:: AI-0190 (Ada 2012 feature)
+
+* *AI-0190 pragma Default_Storage_Pool (2010-09-15)*
+
+  This AI introduces a new pragma ``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:  D.07 (8)
+
+.. index:: AI-0193 (Ada 2012 feature)
+
+* *AI-0193 Alignment of allocators (2010-09-16)*
+
+  This AI introduces a new attribute ``Max_Alignment_For_Allocation``,
+  analogous to ``Max_Size_In_Storage_Elements``, but for alignment instead
+  of size.
+
+  RM References:  13.11 (16)   13.11 (21)   13.11.01 (0)   13.11.01 (1)
+  13.11.01 (2)   13.11.01 (3)
+
+.. index:: AI-0194 (Ada 2012 feature)
+
+* *AI-0194 Value of Stream_Size attribute (0000-00-00)*
+
+  The ``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:  13.14 (2)   13.14 (3/1)   13.14 (8.1/1)   13.14 (10)   13.14 (14)   13.14 (15.1/2)
+  RM References:  13.13.02 (1.2/2)
 
-.. index:: AI-0017 (Ada 2012 feature)
+.. index:: AI-0195 (Ada 2012 feature)
 
-* *AI-0017 Freezing and incomplete types (0000-00-00)*
+* *AI-0195 Invalid value handling is implementation defined (2010-07-03)*
 
-  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.
+  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:  13.14 (3/1)
+  RM References:  13.09.01 (10)
 
-.. index:: AI-0060 (Ada 2012 feature)
+.. index:: AI-0196 (Ada 2012 feature)
 
-* *AI-0060 Extended definition of remote access types (0000-00-00)*
+* *AI-0196 Null exclusion tests for out parameters (0000-00-00)*
 
-  This AI extends the definition of remote access types to include access
-  to limited, synchronized, protected or task class-wide interface types.
-  GNAT already implemented this extension.
+  Null exclusion checks are not made for ``out`` parameters when
+  evaluating the actual parameters. GNAT has never generated these checks.
 
-  RM References:  A (4)   E.02.02 (9/1)   E.02.02 (9.2/1)   E.02.02 (14/2)   E.02.02 (18)
+  RM References:  6.04.01 (13)
 
-.. index:: AI-0114 (Ada 2012 feature)
+.. index:: AI-0198 (Ada 2012 feature)
 
-* *AI-0114 Classification of letters (0000-00-00)*
+* *AI-0198 Inheriting abstract operators  (0000-00-00)*
 
-  The code points 170 (``FEMININE ORDINAL INDICATOR``),
-  181 (``MICRO SIGN``), and
-  186 (``MASCULINE ORDINAL INDICATOR``) are technically considered
-  lower case letters by Unicode.
-  However, they are not allowed in identifiers, and they
-  return ``False`` to ``Ada.Characters.Handling.Is_Letter/Is_Lower``.
-  This behavior is consistent with that defined in Ada 95.
+  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.
 
-  RM References:  A.03.02 (59)   A.04.06 (7)
+  RM References:  3.09.03 (4/3)
 
-.. index:: AI-0185 (Ada 2012 feature)
+.. index:: AI-0199 (Ada 2012 feature)
 
-* *AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)*
+* *AI-0199 Aggregate with anonymous access components (2010-07-14)*
 
-  Two new packages ``Ada.Wide_[Wide_]Characters.Handling`` provide
-  classification functions for ``Wide_Character`` and
-  ``Wide_Wide_Character``, as well as providing
-  case folding routines for ``Wide_[Wide_]Character`` and
-  ``Wide_[Wide_]String``.
+  A choice list in a record aggregate can include several components of
+  (distinct) anonymous access types as long as they have matching designated
+  subtypes.
 
-  RM References:  A.03.05 (0)   A.03.06 (0)
+  RM References:  4.03.01 (16)
 
-.. index:: AI-0031 (Ada 2012 feature)
+.. index:: AI-0200 (Ada 2012 feature)
 
-* *AI-0031 Add From parameter to Find_Token (2010-07-25)*
+* *AI-0200 Mismatches in formal package declarations (0000-00-00)*
 
-  A new version of ``Find_Token`` is added to all relevant string packages,
-  with an extra parameter ``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 ``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.
+  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:  A.04.03 (16)   A.04.03 (67)   A.04.03 (68/1)   A.04.04 (51)
-  A.04.05 (46)
+  RM References:  12.07 (16)
 
-.. index:: AI-0056 (Ada 2012 feature)
+.. index:: AI-0201 (Ada 2012 feature)
 
-* *AI-0056 Index on null string returns zero (0000-00-00)*
+* *AI-0201 Independence of atomic object components (2010-07-22)*
 
-  The wording in the Ada 2005 RM implied an incompatible handling of the
-  ``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.
+  If an Atomic object has a pragma ``Pack`` or a ``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:  A.04.03 (56.2/2)   A.04.03 (58.5/2)
+  RM References:  9.10 (1/3)   C.06 (22/2)   C.06 (23/2)
 
-.. index:: AI-0137 (Ada 2012 feature)
+.. index:: AI-0203 (Ada 2012 feature)
 
-* *AI-0137 String encoding package (2010-03-25)*
+* *AI-0203 Extended return cannot be abstract (0000-00-00)*
 
-  The packages ``Ada.Strings.UTF_Encoding``, together with its child
-  packages, ``Conversions``, ``Strings``, ``Wide_Strings``,
-  and ``Wide_Wide_Strings`` have been
-  implemented. These packages (whose documentation can be found in the spec
-  files :file:`a-stuten.ads`, :file:`a-suenco.ads`, :file:`a-suenst.ads`,
-  :file:`a-suewst.ads`, :file:`a-suezst.ads`) allow encoding and decoding of
-  ``String``, ``Wide_String``, and ``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 ``Wide_Wide_Strings``, these packages are available in
-  Ada 95 and Ada 2005 mode as well as Ada 2012 mode.
-  The ``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 ``Wide_Wide_Character``).
+  A return_subtype_indication cannot denote an abstract subtype. GNAT has never
+  permitted such usage.
 
-  RM References:  A.04.11
+  RM References:  3.09.03 (8/3)
 
-.. index:: AI-0038 (Ada 2012 feature)
+.. index:: AI-0205 (Ada 2012 feature)
 
-* *AI-0038 Minor errors in Text_IO (0000-00-00)*
+* *AI-0205 Extended return declares visible name (0000-00-00)*
 
-  These are minor errors in the description on three points. The intent on
-  all these points has always been clear, and GNAT has always implemented the
-  correct intended semantics.
+  This AI corrects a simple omission in the RM. Return objects have always
+  been visible within an extended return statement.
 
-  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)
+  RM References:  8.03 (17)
 
-.. index:: AI-0044 (Ada 2012 feature)
+.. index:: AI-0206 (Ada 2012 feature)
 
-* *AI-0044 Restrictions on container instantiations (0000-00-00)*
+* *AI-0206 Remote types packages and preelaborate (2010-07-24)*
 
-  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.
+  Remote types packages are now allowed to depend on preelaborated packages.
+  This was formerly considered illegal.
 
-  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)
+  RM References:  E.02.02 (6)
 
-.. index:: AI-0127 (Ada 2012 feature)
+.. index:: AI-0207 (Ada 2012 feature)
 
-* *AI-0127 Adding Locale Capabilities (2010-09-29)*
+* *AI-0207 Mode conformance and access constant (0000-00-00)*
 
-  This package provides an interface for identifying the current locale.
+  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:  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
+  RM References:  6.03.01 (16/2)
 
-.. index:: AI-0002 (Ada 2012 feature)
+.. index:: AI-0208 (Ada 2012 feature)
 
-* *AI-0002 Export C with unconstrained arrays (0000-00-00)*
+* *AI-0208 Characteristics of incomplete views (0000-00-00)*
 
-  The compiler is not required to support exporting an Ada subprogram with
-  convention C if there are parameters or a return type of an unconstrained
-  array type (such as ``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.
+  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.
 
-  RM References:  B.01 (17)   B.03 (62)   B.03 (71.1/2)
+  RM References:  3.10.01 (2.4/2)   3.10.01 (2.6/2)
 
-.. index:: AI-0216 (Ada 2012 feature)
+.. index:: AI-0210 (Ada 2012 feature)
 
-* *AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)*
+* *AI-0210 Correct Timing_Events metric (0000-00-00)*
 
-  It is clearly the intention that ``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.
+  This is a documentation only issue regarding wording of metric requirements,
+  that does not affect the implementation of the compiler.
 
-  RM References:  D.07 (3/3)
+  RM References:  D.15 (24/2)
 
 .. index:: AI-0211 (Ada 2012 feature)
 
@@ -1264,67 +1286,45 @@  Supported Aspect                     Source
 
   RM References:  D.07 (5)   D.07 (10/2)   D.07 (10.4/2)   D.07 (10.7/2)
 
-.. index:: AI-0190 (Ada 2012 feature)
-
-* *AI-0190 pragma Default_Storage_Pool (2010-09-15)*
-
-  This AI introduces a new pragma ``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:  D.07 (8)
-
-.. index:: AI-0189 (Ada 2012 feature)
-
-* *AI-0189 No_Allocators_After_Elaboration (2010-01-23)*
-
-  This AI introduces a new restriction ``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:  D.07 (19.1/2)   H.04 (23.3/2)
-
-.. index:: AI-0171 (Ada 2012 feature)
+.. index:: AI-0214 (Ada 2012 feature)
 
-* *AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)*
+* *AI-0214 Defaulted discriminants for limited tagged (2010-10-01)*
 
-  A new package ``System.Multiprocessors`` is added, together with the
-  definition of pragma ``CPU`` for controlling task affinity. A new no
-  dependence restriction, on ``System.Multiprocessors.Dispatching_Domains``,
-  is added to the Ravenscar profile.
+  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.
 
-  RM References:  D.13.01 (4/2)   D.16
+  RM References:  3.07 (9.1/2)   3.07.02 (3)
 
-.. index:: AI-0210 (Ada 2012 feature)
+.. index:: AI-0216 (Ada 2012 feature)
 
-* *AI-0210 Correct Timing_Events metric (0000-00-00)*
+* *AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)*
 
-  This is a documentation only issue regarding wording of metric requirements,
-  that does not affect the implementation of the compiler.
+  It is clearly the intention that ``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:  D.15 (24/2)
+  RM References:  D.07 (3/3)
 
-.. index:: AI-0206 (Ada 2012 feature)
+.. index:: AI-0219 (Ada 2012 feature)
 
-* *AI-0206 Remote types packages and preelaborate (2010-07-24)*
+* *AI-0219 Pure permissions and limited parameters (2010-05-25)*
 
-  Remote types packages are now allowed to depend on preelaborated packages.
-  This was formerly considered illegal.
+  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:  E.02.02 (6)
+  RM References:  10.02.01 (18/2)
 
-.. index:: AI-0152 (Ada 2012 feature)
+.. index:: AI-0220 (Ada 2012 feature)
 
-* *AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)*
+* *AI-0220 Needed components for aggregates (0000-00-00)*
 
-  Restriction ``No_Anonymous_Allocators`` prevents the use of allocators
-  where the type of the returned value is an anonymous access type.
+  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.
 
-  RM References:  H.04 (8/1)
+  RM References:  4.03.01 (17)
diff --git a/gcc/ada/gnat_rm.texi b/gcc/ada/gnat_rm.texi
index 0d38b1a4bc6..df6969f98b7 100644
--- a/gcc/ada/gnat_rm.texi
+++ b/gcc/ada/gnat_rm.texi
@@ -26607,865 +26607,958 @@  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)
+@geindex AI-0002 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0176 Quantified expressions (2010-09-29)'
+`AI-0002 Export C with unconstrained arrays (0000-00-00)'
 
-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.
+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:  1.01.04 (12)   2.09 (2/2)   4.04 (7)   4.05.09 (0)
+RM References:  B.01 (17)   B.03 (62)   B.03 (71.1/2)
 @end itemize
 
-@geindex AI-0079 (Ada 2012 feature)
+@geindex AI-0003 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0079 Allow other_format characters in source (2010-07-10)'
+`AI-0003 Qualified expressions as names (2010-07-11)'
 
-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.
+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.01 (4/2)   2.02 (7)
+RM References:  3.03 (11)   3.03 (21)   4.01 (2)   4.04 (7)   4.07 (3)
+5.04 (7)
 @end itemize
 
-@geindex AI-0091 (Ada 2012 feature)
+@geindex AI-0007 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0091 Do not allow other_format in identifiers (0000-00-00)'
+`AI-0007 Stream read and private scalar types (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.
+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:  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)
+RM References:  13.13.02 (50/2)   13.13.02 (51/2)
 @end itemize
 
-@geindex AI-0100 (Ada 2012 feature)
+@geindex AI-0008 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0100 Placement of pragmas  (2010-07-01)'
+`AI-0008 General access to constrained objects (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.
+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.
 
-RM References:  2.08 (7)
+RM References:  3.03 (23)   3.10.02 (26/2)   4.01 (9)   6.04.01 (17)   8.05.01 (5/2)
 @end itemize
 
-@geindex AI-0163 (Ada 2012 feature)
+@geindex AI-0009 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0163 Pragmas in place of null (2010-07-01)'
+`AI-0009 Pragma Independent[_Components] (2010-07-23)'
 
-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.
+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:  2.08 (7)   2.08 (16)
+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-0080 (Ada 2012 feature)
+@geindex AI-0012 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0080 ‘View of’ not needed if clear from context (0000-00-00)'
+`AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)'
 
-This is an editorial change only, described as non-testable in the AI.
+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:  3.01 (7)
+RM References:  13.02 (6.1/2)   13.02 (7)   C.06 (10)   C.06 (11)   C.06 (21)
 @end itemize
 
-@geindex AI-0183 (Ada 2012 feature)
+@geindex AI-0015 (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
+`AI-0015 Constant return objects (0000-00-00)'
 
+The return object declared in an `extended_return_statement' may be
+declared constant. This was always intended, and GNAT has always allowed it.
 
-@multitable {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxx} 
-@headitem
+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
 
-Supported Aspect
+@geindex AI-0017 (Ada 2012 feature)
 
-@tab
 
-Source
+@itemize *
 
-@item
+@item 
+`AI-0017 Freezing and incomplete types (0000-00-00)'
 
-@code{Ada_2005}
+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.
 
-@tab
+RM References:  13.14 (3/1)
+@end itemize
 
-– GNAT
+@geindex AI-0019 (Ada 2012 feature)
 
-@item
 
-@code{Ada_2012}
+@itemize *
 
-@tab
+@item 
+`AI-0019 Freezing of primitives for tagged types (0000-00-00)'
 
-– GNAT
+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
+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
 
-@code{Address}
+@geindex AI-0026 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Alignment}
+@item 
+`AI-0026 Missing rules for Unchecked_Union (2010-07-07)'
 
-@tab
+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.
 
-@item
+RM References:  7.06 (9.4/2)   B.03.03 (9/2)   B.03.03 (10/2)
+@end itemize
 
-@code{Atomic}
+@geindex AI-0030 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Atomic_Components}
+@item 
+`AI-0030 Requeue on synchronized interfaces (2010-07-19)'
 
-@tab
+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.
 
-@item
+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
 
-@code{Bit_Order}
+@geindex AI-0031 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Component_Size}
+@item 
+`AI-0031 Add From parameter to Find_Token (2010-07-25)'
 
-@tab
+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.
 
-@item
+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
 
-@code{Contract_Cases}
+@geindex AI-0032 (Ada 2012 feature)
 
-@tab
 
-– GNAT
+@itemize *
 
-@item
+@item 
+`AI-0032 Extended return for class-wide functions (0000-00-00)'
 
-@code{Discard_Names}
+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.
 
-@tab
+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
 
-@item
+@geindex AI-0033 (Ada 2012 feature)
 
-@code{External_Tag}
 
-@tab
+@itemize *
 
-@item
+@item 
+`AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)'
 
-@code{Favor_Top_Level}
+Neither of these two pragmas may appear within a generic template, because
+the generic might be instantiated at other than the library level.
 
-@tab
+RM References:  13.11.02 (16)   C.03.01 (7/2)   C.03.01 (8/2)
+@end itemize
 
-– GNAT
+@geindex AI-0034 (Ada 2012 feature)
 
-@item
 
-@code{Inline}
+@itemize *
 
-@tab
+@item 
+`AI-0034 Categorization of limited views (0000-00-00)'
 
-@item
+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.
 
-@code{Inline_Always}
+RM References:  10.02.01 (11/1)   10.02.01 (17/2)
+@end itemize
 
-@tab
+@geindex AI-0035 (Ada 2012 feature)
 
-– GNAT
 
-@item
+@itemize *
 
-@code{Invariant}
+@item 
+`AI-0035 Inconsistencies with Pure units (0000-00-00)'
 
-@tab
+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.
 
-– GNAT
+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
 
-@item
+@geindex AI-0037 (Ada 2012 feature)
 
-@code{Machine_Radix}
 
-@tab
+@itemize *
 
-@item
+@item 
+`AI-0037 Out-of-range box associations in aggregate (0000-00-00)'
 
-@code{No_Return}
+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.
 
-@tab
+RM References:  4.03.03 (29)
+@end itemize
 
-@item
+@geindex AI-0038 (Ada 2012 feature)
 
-@code{Object_Size}
 
-@tab
+@itemize *
 
-– GNAT
+@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{Pack}
+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-0039 (Ada 2012 feature)
 
-@item
 
-@code{Persistent_BSS}
+@itemize *
 
-@tab
+@item 
+`AI-0039 Stream attributes cannot be dynamic (0000-00-00)'
 
-– GNAT
+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.
 
-@item
+RM References:  13.03 (4)   13.03 (6)   13.13.02 (38/2)
+@end itemize
 
-@code{Post}
+@geindex AI-0040 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Pre}
+@item 
+`AI-0040 Limited with clauses on descendant (0000-00-00)'
 
-@tab
+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.
 
-@item
+RM References:  10.01.02 (20/2)
+@end itemize
 
-@code{Predicate}
+@geindex AI-0042 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Preelaborable_Initialization}
+@item 
+`AI-0042 Overriding versus implemented-by (0000-00-00)'
 
-@tab
+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.
 
-@item
+RM References:  9.01 (9.2/2)   9.04 (11.1/2)
+@end itemize
 
-@code{Pure_Function}
+@geindex AI-0043 (Ada 2012 feature)
 
-@tab
 
-– GNAT
+@itemize *
 
-@item
+@item 
+`AI-0043 Rules about raising exceptions (0000-00-00)'
 
-@code{Remote_Access_Type}
+This AI covers various omissions in the RM regarding the raising of
+exceptions. GNAT has always implemented the intended semantics.
 
-@tab
+RM References:  11.04.01 (10.1/2)   11 (2)
+@end itemize
 
-– GNAT
+@geindex AI-0044 (Ada 2012 feature)
 
-@item
 
-@code{Shared}
+@itemize *
 
-@tab
+@item 
+`AI-0044 Restrictions on container instantiations (0000-00-00)'
 
-– GNAT
+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.
 
-@item
+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
 
-@code{Size}
+@geindex AI-0046 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Storage_Pool}
+@item 
+`AI-0046 Null exclusion match for full conformance (2010-07-17)'
 
-@tab
+For full conformance, in the case of access parameters, the null exclusion
+must match (either both or neither must have @code{not null}).
 
-@item
+RM References:  6.03.02 (18)
+@end itemize
 
-@code{Storage_Size}
+@geindex AI-0050 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Stream_Size}
+@item 
+`AI-0050 Raising Constraint_Error early for function call (0000-00-00)'
 
-@tab
+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.
 
-@item
+RM References:  6.05 (24/2)
+@end itemize
 
-@code{Suppress}
+@geindex AI-0056 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Suppress_Debug_Info}
+@item 
+`AI-0056 Index on null string returns zero (0000-00-00)'
 
-@tab
+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.
 
-– GNAT
+RM References:  A.04.03 (56.2/2)   A.04.03 (58.5/2)
+@end itemize
 
-@item
+@geindex AI-0058 (Ada 2012 feature)
 
-@code{Test_Case}
 
-@tab
+@itemize *
 
-– GNAT
+@item 
+`AI-0058 Abnormal completion of an extended return (0000-00-00)'
 
-@item
+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.
 
-@code{Thread_Local_Storage}
+RM References:  6.05 (22/2)
+@end itemize
 
-@tab
+@geindex AI-0060 (Ada 2012 feature)
 
-– GNAT
 
-@item
+@itemize *
 
-@code{Type_Invariant}
+@item 
+`AI-0060 Extended definition of remote access types (0000-00-00)'
 
-@tab
+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.
 
-@item
+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
 
-@code{Unchecked_Union}
+@geindex AI-0062 (Ada 2012 feature)
 
-@tab
 
-@item
+@itemize *
 
-@code{Universal_Aliasing}
+@item 
+`AI-0062 Null exclusions and deferred constants (0000-00-00)'
 
-@tab
+A full constant may have a null exclusion even if its associated deferred
+constant does not. GNAT has always allowed this.
 
-– GNAT
+RM References:  7.04 (6/2)   7.04 (7.1/2)
+@end itemize
 
-@item
+@geindex AI-0064 (Ada 2012 feature)
 
-@code{Unmodified}
 
-@tab
+@itemize *
 
-– GNAT
+@item 
+`AI-0064 Redundant finalization rule (0000-00-00)'
 
-@item
+This is an editorial change only. The intended behavior is already checked
+by an existing ACATS test, which GNAT has always executed correctly.
 
-@code{Unreferenced}
+RM References:  7.06.01 (17.1/1)
+@end itemize
 
-@tab
+@geindex AI-0065 (Ada 2012 feature)
 
-– GNAT
 
-@item
+@itemize *
 
-@code{Unreferenced_Objects}
+@item 
+`AI-0065 Remote access types and external streaming (0000-00-00)'
 
-@tab
+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.
 
-– GNAT
+RM References:  13.13.02 (52/2)
+@end itemize
 
-@item
+@geindex AI-0070 (Ada 2012 feature)
 
-@code{Unsuppress}
 
-@tab
+@itemize *
 
-@item
+@item 
+`AI-0070 Elaboration of interface types (0000-00-00)'
 
-@code{Value_Size}
+This is an editorial change only, there are no testable consequences short of
+checking for the absence of generated code for an interface declaration.
 
-@tab
+RM References:  3.09.04 (18/2)
+@end itemize
 
-– GNAT
+@geindex AI-0072 (Ada 2012 feature)
 
-@item
 
-@code{Volatile}
+@itemize *
 
-@tab
+@item 
+`AI-0072 Task signalling using ‘Terminated (0000-00-00)'
 
-@item
+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.
 
-@code{Volatile_Components}
+RM References:  9.10 (6.1/1)
+@end itemize
 
-@tab
+@geindex AI-0073 (Ada 2012 feature)
 
-@item
 
-@code{Warnings}
+@itemize *
 
-@tab
+@item 
+`AI-0073 Functions returning abstract types (2010-07-10)'
 
-– GNAT
-
-@end multitable
-
-
-@quotation
-
-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).
+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.
 
-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:  3.09.03 (8)   3.09.03 (10)   6.05 (8/2)
+@end itemize
 
-@geindex AI-0128 (Ada 2012 feature)
+@geindex AI-0076 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0128 Inequality is a primitive operation (0000-00-00)'
+`AI-0076 function with controlling result (0000-00-00)'
 
-If an equality operator (“=”) is declared for a type, then the implicitly
-declared inequality operator (“/=”) is a primitive operation of the type.
-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.
+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.
 
-RM References:  3.02.03 (6)   6.06 (6)
+RM References:  3.09.02 (2/2)
 @end itemize
 
-@geindex AI-0003 (Ada 2012 feature)
+@geindex AI-0077 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0003 Qualified expressions as names (2010-07-11)'
+`AI-0077 Limited withs and scope of declarations (0000-00-00)'
 
-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.
+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:  3.03 (11)   3.03 (21)   4.01 (2)   4.04 (7)   4.07 (3)
-5.04 (7)
+RM References:  10.01.02 (12/2)   10.01.02 (21/2)   10.01.02 (22/2)
 @end itemize
 
-@geindex AI-0120 (Ada 2012 feature)
+@geindex AI-0078 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0120 Constant instance of protected object (0000-00-00)'
+`AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)'
 
-This is an RM editorial change only. The section that lists objects that are
-constant failed to include the current instance of a protected object
-within a protected function. This has always been treated as a constant
-in GNAT.
+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:  3.03 (21)
+RM References:  13.09 (7)
 @end itemize
 
-@geindex AI-0008 (Ada 2012 feature)
+@geindex AI-0079 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0008 General access to constrained objects (0000-00-00)'
+`AI-0079 Allow other_format characters in source (2010-07-10)'
 
-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.
+Wide characters in the unicode category `other_format' are now allowed in
+source programs between tokens, but not within a token such as an identifier.
 
-RM References:  3.03 (23)   3.10.02 (26/2)   4.01 (9)   6.04.01 (17)   8.05.01 (5/2)
+RM References:  2.01 (4/2)   2.02 (7)
 @end itemize
 
-@geindex AI-0093 (Ada 2012 feature)
+@geindex AI-0080 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0093 Additional rules use immutably limited (0000-00-00)'
+`AI-0080 ‘View of’ not needed if clear from context (0000-00-00)'
 
-This is an editorial change only, to make more widespread use of the Ada 2012
-‘immutably limited’.
+This is an editorial change only, described as non-testable in the AI.
 
-RM References:  3.03 (23.4/3)
+RM References:  3.01 (7)
 @end itemize
 
-@geindex AI-0096 (Ada 2012 feature)
+@geindex AI-0087 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0096 Deriving from formal private types (2010-07-20)'
+`AI-0087 Actual for formal nonlimited derived type (2010-07-15)'
 
-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.
+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.04 (5.1/2)   6.02 (7)
+RM References:  7.05 (5/2)   12.05.01 (5.1/2)
 @end itemize
 
-@geindex AI-0181 (Ada 2012 feature)
+@geindex AI-0088 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0181 Soft hyphen is a non-graphic character (2010-07-23)'
+`AI-0088 The value of exponentiation (0000-00-00)'
 
-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.
+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.
 
-RM References:  3.05.02 (2/2)   A.01 (35/2)   A.03.03 (21)
+RM References:  4.05.06 (11)
 @end itemize
 
-@geindex AI-0182 (Ada 2012 feature)
+@geindex AI-0091 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0182 Additional forms for' @code{Character'Value} `(0000-00-00)'
+`AI-0091 Do not allow other_format in identifiers (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.
+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.
 
-RM References:  3.05 (56/2)
+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-0214 (Ada 2012 feature)
+@geindex AI-0093 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0214 Defaulted discriminants for limited tagged (2010-10-01)'
+`AI-0093 Additional rules use immutably limited (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.
+This is an editorial change only, to make more widespread use of the Ada 2012
+‘immutably limited’.
 
-RM References:  3.07 (9.1/2)   3.07.02 (3)
+RM References:  3.03 (23.4/3)
 @end itemize
 
-@geindex AI-0102 (Ada 2012 feature)
+@geindex AI-0095 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0102 Some implicit conversions are illegal (0000-00-00)'
+`AI-0095 Address of intrinsic subprograms (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 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:  3.07 (16)   3.07.01 (9)   6.04.01 (6)   8.06 (27/2)
+RM References:  13.03 (11/1)
 @end itemize
 
-@geindex AI-0158 (Ada 2012 feature)
+@geindex AI-0096 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0158 Generalizing membership tests (2010-09-16)'
+`AI-0096 Deriving from formal private types (2010-07-20)'
 
-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.
+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.
 
-RM References:  3.08.01 (5)   4.04 (3)   4.05.02 (3)   4.05.02 (5)   4.05.02 (27)
+RM References:  3.04 (5.1/2)   6.02 (7)
 @end itemize
 
-@geindex AI-0173 (Ada 2012 feature)
+@geindex AI-0097 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0173 Testing if tags represent abstract types (2010-07-03)'
+`AI-0097 Treatment of abstract null extension (2010-07-19)'
 
-The function @code{Ada.Tags.Type_Is_Abstract} returns @code{True} if invoked
-with the tag of an abstract type, and @code{False} otherwise.
+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.
 
-RM References:  3.09 (7.4/2)   3.09 (12.4/2)
+RM References:  3.09.03 (4/2)
 @end itemize
 
-@geindex AI-0076 (Ada 2012 feature)
+@geindex AI-0098 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0076 function with controlling result (0000-00-00)'
+`AI-0098 Anonymous subprogram access restrictions (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.
+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.
 
-RM References:  3.09.02 (2/2)
+RM References:  3.10.01 (6)   3.10.01 (9.2/2)
 @end itemize
 
-@geindex AI-0126 (Ada 2012 feature)
+@geindex AI-0099 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0126 Dispatching with no declared operation (0000-00-00)'
+`AI-0099 Tag determines whether finalization needed (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.
+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.02 (20/2)   3.09.02 (20.1/2)   3.09.02 (20.2/2)
+RM References:  7.06.01 (6)   7.06.01 (7)   7.06.01 (8)   7.06.01 (9/2)
 @end itemize
 
-@geindex AI-0097 (Ada 2012 feature)
+@geindex AI-0100 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0097 Treatment of abstract null extension (2010-07-19)'
+`AI-0100 Placement of pragmas  (2010-07-01)'
 
-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.
+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:  3.09.03 (4/2)
+RM References:  2.08 (7)
 @end itemize
 
-@geindex AI-0203 (Ada 2012 feature)
+@geindex AI-0102 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0203 Extended return cannot be abstract (0000-00-00)'
+`AI-0102 Some implicit conversions are illegal (0000-00-00)'
 
-A return_subtype_indication cannot denote an abstract subtype. GNAT has never
-permitted such usage.
+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.
 
-RM References:  3.09.03 (8/3)
+RM References:  3.07 (16)   3.07.01 (9)   6.04.01 (6)   8.06 (27/2)
 @end itemize
 
-@geindex AI-0198 (Ada 2012 feature)
+@geindex AI-0103 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0198 Inheriting abstract operators  (0000-00-00)'
+`AI-0103 Static matching for extended return (2010-07-23)'
 
-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.
+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.03 (4/3)
+RM References:  6.05 (5.2/2)
 @end itemize
 
-@geindex AI-0073 (Ada 2012 feature)
+@geindex AI-0104 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0073 Functions returning abstract types (2010-07-10)'
+`AI-0104 Null exclusion and uninitialized allocator (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 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.09.03 (8)   3.09.03 (10)   6.05 (8/2)
+RM References:  4.08 (2)
 @end itemize
 
-@geindex AI-0070 (Ada 2012 feature)
+@geindex AI-0106 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0070 Elaboration of interface types (0000-00-00)'
+`AI-0106 No representation pragmas on generic formals (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.
+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:  3.09.04 (18/2)
+RM References:  13.01 (9.1/1)
 @end itemize
 
-@geindex AI-0208 (Ada 2012 feature)
+@geindex AI-0108 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0208 Characteristics of incomplete views (0000-00-00)'
+`AI-0108 Limited incomplete view and discriminants (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 AI confirms that an incomplete type from a limited view does not have
+discriminants. This has always been the case in GNAT.
 
-RM References:  3.10.01 (2.4/2)   3.10.01 (2.6/2)
+RM References:  10.01.01 (12.3/2)
 @end itemize
 
-@geindex AI-0162 (Ada 2012 feature)
+@geindex AI-0109 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0162 Incomplete type completed by partial view (2010-09-15)'
+`AI-0109 Redundant check in S’Class’Input (0000-00-00)'
 
-Incomplete types are made more useful by allowing them to be completed by
-private types and private extensions.
+This AI is an editorial change only. It removes the need for a tag check
+that can never fail.
 
-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:  13.13.02 (34/2)
 @end itemize
 
-@geindex AI-0098 (Ada 2012 feature)
+@geindex AI-0112 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0098 Anonymous subprogram access restrictions (0000-00-00)'
+`AI-0112 Detection of duplicate pragmas (2010-07-24)'
 
-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 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:  3.10.01 (6)   3.10.01 (9.2/2)
+RM References:  13.01 (8)
 @end itemize
 
-@geindex AI-0199 (Ada 2012 feature)
+@geindex AI-0114 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0199 Aggregate with anonymous access components (2010-07-14)'
+`AI-0114 Classification of letters (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.
+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:  4.03.01 (16)
+RM References:  A.03.02 (59)   A.04.06 (7)
 @end itemize
 
-@geindex AI-0220 (Ada 2012 feature)
+@geindex AI-0116 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0220 Needed components for aggregates (0000-00-00)'
+`AI-0116 Alignment of class-wide objects (0000-00-00)'
 
-This AI addresses a wording problem in the RM that appears to permit some
-complex cases of aggregates with nonstatic discriminants. GNAT has always
-implemented the intended semantics.
+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:  4.03.01 (17)
+RM References:  13.03 (29)   13.11 (16)
 @end itemize
 
-@geindex AI-0147 (Ada 2012 feature)
+@geindex AI-0118 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0147 Conditional expressions (2009-03-29)'
+`AI-0118 The association of parameter associations (0000-00-00)'
 
-Conditional expressions are permitted. The form of such an expression is:
+This AI clarifies the rules for named associations in subprogram calls and
+generic instantiations. The rules have been in place since Ada 83.
 
-@example
-(if expr then expr @{elsif expr then expr@} [else expr])
-@end example
+RM References:  6.04.01 (2)   12.03 (9)
+@end itemize
 
-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.
+@geindex AI-0120 (Ada 2012 feature)
 
-RM References:  4.03.03 (15)   4.04 (1)   4.04 (7)   4.05.07 (0)   4.07 (2)
-4.07 (3)   4.09 (12)   4.09 (33)   5.03 (3)   5.03 (4)   7.05 (2.1/2)
+
+@itemize *
+
+@item 
+`AI-0120 Constant instance of protected object (0000-00-00)'
+
+This is an RM editorial change only. The section that lists objects that are
+constant failed to include the current instance of a protected object
+within a protected function. This has always been treated as a constant
+in GNAT.
+
+RM References:  3.03 (21)
 @end itemize
 
-@geindex AI-0037 (Ada 2012 feature)
+@geindex AI-0122 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0037 Out-of-range box associations in aggregate (0000-00-00)'
+`AI-0122 Private with and children of generics (0000-00-00)'
 
-This AI confirms that an association of the form @code{Indx => <>} in an
-array aggregate must raise @code{Constraint_Error} if @code{Indx}
-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 clarifies the visibility of private children of generic units within
+instantiations of a parent. GNAT has always handled this correctly.
 
-RM References:  4.03.03 (29)
+RM References:  10.01.02 (12/2)
 @end itemize
 
 @geindex AI-0123 (Ada 2012 feature)
@@ -27494,100 +27587,97 @@  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
 
-@geindex AI-0088 (Ada 2012 feature)
+@geindex AI-0125 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0088 The value of exponentiation (0000-00-00)'
+`AI-0125 Nonoverridable operations of an ancestor (2010-09-28)'
 
-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.
+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:  4.05.06 (11)
+RM References:  7.03.01 (6)   8.03 (23)   8.03.01 (5/2)   8.03.01 (6/2)
 @end itemize
 
-@geindex AI-0188 (Ada 2012 feature)
+@geindex AI-0126 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0188 Case expressions (2010-01-09)'
-
-Case expressions are permitted. This allows use of constructs such as:
+`AI-0126 Dispatching with no declared operation (0000-00-00)'
 
-@example
-X := (case Y is when 1 => 2, when 2 => 3, when others => 31)
-@end example
+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.
 
-RM References:  4.05.07 (0)   4.05.08 (0)   4.09 (12)   4.09 (33)
+RM References:  3.09.02 (20/2)   3.09.02 (20.1/2)   3.09.02 (20.2/2)
 @end itemize
 
-@geindex AI-0104 (Ada 2012 feature)
+@geindex AI-0127 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0104 Null exclusion and uninitialized allocator (2010-07-15)'
+`AI-0127 Adding Locale Capabilities (2010-09-29)'
 
-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 package provides an interface for identifying the current locale.
 
-RM References:  4.08 (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-0157 (Ada 2012 feature)
+@geindex AI-0128 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0157 Allocation/Deallocation from empty pool (2010-07-11)'
+`AI-0128 Inequality is a primitive operation (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.
+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:  4.08 (5.3/2)   13.11.02 (4)   13.11.02 (17)
+RM References:  3.02.03 (6)   6.06 (6)
 @end itemize
 
-@geindex AI-0179 (Ada 2012 feature)
+@geindex AI-0129 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0179 Statement not required after label (2010-04-10)'
+`AI-0129 Limited views and incomplete types (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 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:  5.01 (2)
+RM References:  10.01.01 (12.2/2)   10.01.01 (12.3/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)
@@ -27604,1129 +27694,1039 @@  parameters must match. GNAT has always enforced this rule.
 RM References:  6.03.01 (18)
 @end itemize
 
-@geindex AI-0207 (Ada 2012 feature)
+@geindex AI-0137 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0207 Mode conformance and access constant (0000-00-00)'
+`AI-0137 String encoding package (2010-03-25)'
 
-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.
+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:  6.03.01 (16/2)
+RM References:  A.04.11
 @end itemize
 
-@geindex AI-0046 (Ada 2012 feature)
+@geindex AI-0139-2 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0046 Null exclusion match for full conformance (2010-07-17)'
+`AI-0139-2 Syntactic sugar for iterators (2010-09-29)'
 
-For full conformance, in the case of access parameters, the null exclusion
-must match (either both or neither must have @code{not null}).
+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:  6.03.02 (18)
+RM References:  5.05
 @end itemize
 
-@geindex AI-0118 (Ada 2012 feature)
+@geindex AI-0146 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0118 The association of parameter associations (0000-00-00)'
-
-This AI clarifies the rules for named associations in subprogram calls and
-generic instantiations. The rules have been in place since Ada 83.
-
-RM References:  6.04.01 (2)   12.03 (9)
-@end itemize
-
-@geindex AI-0196 (Ada 2012 feature)
-
+`AI-0146 Type invariants (2009-09-21)'
 
-@itemize *
-
-@item 
-`AI-0196 Null exclusion tests for out parameters (0000-00-00)'
-
-Null exclusion checks are not made for @code{out} parameters when
-evaluating the actual parameters. GNAT has never generated these checks.
+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:  6.04.01 (13)
+RM References:  13.03.03 (00)
 @end itemize
 
-@geindex AI-0015 (Ada 2012 feature)
+@geindex AI-0147 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0015 Constant return objects (0000-00-00)'
+`AI-0147 Conditional expressions (2009-03-29)'
 
-The return object declared in an `extended_return_statement' may be
-declared constant. This was always intended, and GNAT has always allowed it.
+Conditional expressions are permitted. The form of such an expression is:
 
-RM References:  6.05 (2.1/2)   3.03 (10/2)   3.03 (21)   6.05 (5/2)
-6.05 (5.7/2)
+@example
+(if expr then expr @{elsif expr then expr@} [else expr])
+@end example
+
+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.
+
+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
 
-@geindex AI-0032 (Ada 2012 feature)
+@geindex AI-0152 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0032 Extended return for class-wide functions (0000-00-00)'
+`AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)'
 
-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.
+Restriction @code{No_Anonymous_Allocators} prevents the use of allocators
+where the type of the returned value is an anonymous access type.
 
-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:  H.04 (8/1)
 @end itemize
 
-@geindex AI-0103 (Ada 2012 feature)
+@geindex AI-0157 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0103 Static matching for extended return (2010-07-23)'
+`AI-0157 Allocation/Deallocation from empty pool (2010-07-11)'
 
-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.
+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:  6.05 (5.2/2)
+RM References:  4.08 (5.3/2)   13.11.02 (4)   13.11.02 (17)
 @end itemize
 
-@geindex AI-0058 (Ada 2012 feature)
+@geindex AI-0158 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0058 Abnormal completion of an extended return (0000-00-00)'
+`AI-0158 Generalizing membership tests (2010-09-16)'
 
-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.
+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.
 
-RM References:  6.05 (22/2)
+RM References:  3.08.01 (5)   4.04 (3)   4.05.02 (3)   4.05.02 (5)   4.05.02 (27)
 @end itemize
 
-@geindex AI-0050 (Ada 2012 feature)
+@geindex AI-0161 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0050 Raising Constraint_Error early for function call (0000-00-00)'
+`AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)'
 
-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.
+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:  6.05 (24/2)
+RM References:  13.12.01 (4/2)   13.13.02 (40/2)   13.13.02 (52/2)
 @end itemize
 
-@geindex AI-0125 (Ada 2012 feature)
+@geindex AI-0162 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0125 Nonoverridable operations of an ancestor (2010-09-28)'
+`AI-0162 Incomplete type completed by partial view (2010-09-15)'
 
-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.
+Incomplete types are made more useful by allowing them to be completed by
+private types and private extensions.
 
-RM References:  7.03.01 (6)   8.03 (23)   8.03.01 (5/2)   8.03.01 (6/2)
+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
 
-@geindex AI-0062 (Ada 2012 feature)
+@geindex AI-0163 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0062 Null exclusions and deferred constants (0000-00-00)'
+`AI-0163 Pragmas in place of null (2010-07-01)'
 
-A full constant may have a null exclusion even if its associated deferred
-constant does not. GNAT has always allowed this.
+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:  7.04 (6/2)   7.04 (7.1/2)
+RM References:  2.08 (7)   2.08 (16)
 @end itemize
 
-@geindex AI-0178 (Ada 2012 feature)
+@geindex AI-0171 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0178 Incomplete views are limited (0000-00-00)'
+`AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)'
 
-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.
+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:  7.05 (3/2)   7.05 (6/2)
+RM References:  D.13.01 (4/2)   D.16
 @end itemize
 
-@geindex AI-0087 (Ada 2012 feature)
+@geindex AI-0173 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0087 Actual for formal nonlimited derived type (2010-07-15)'
+`AI-0173 Testing if tags represent abstract types (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 function @code{Ada.Tags.Type_Is_Abstract} returns @code{True} if invoked
+with the tag of an abstract type, and @code{False} otherwise.
 
-RM References:  7.05 (5/2)   12.05.01 (5.1/2)
+RM References:  3.09 (7.4/2)   3.09 (12.4/2)
 @end itemize
 
-@geindex AI-0099 (Ada 2012 feature)
+@geindex AI-0176 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0099 Tag determines whether finalization needed (0000-00-00)'
+`AI-0176 Quantified expressions (2010-09-29)'
 
-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’’.
+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.
 
-RM References:  7.06.01 (6)   7.06.01 (7)   7.06.01 (8)   7.06.01 (9/2)
+RM References:  1.01.04 (12)   2.09 (2/2)   4.04 (7)   4.05.09 (0)
 @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-0178 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0026 Missing rules for Unchecked_Union (2010-07-07)'
+`AI-0178 Incomplete views are limited (0000-00-00)'
 
-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.
+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:  7.06 (9.4/2)   B.03.03 (9/2)   B.03.03 (10/2)
+RM References:  7.05 (3/2)   7.05 (6/2)
 @end itemize
 
-@geindex AI-0205 (Ada 2012 feature)
+@geindex AI-0179 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0205 Extended return declares visible name (0000-00-00)'
+`AI-0179 Statement not required after label (2010-04-10)'
 
-This AI corrects a simple omission in the RM. Return objects have always
-been visible within an extended return statement.
+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:  8.03 (17)
+RM References:  5.01 (2)
 @end itemize
 
-@geindex AI-0042 (Ada 2012 feature)
+@geindex AI-0181 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0042 Overriding versus implemented-by (0000-00-00)'
+`AI-0181 Soft hyphen is a non-graphic character (2010-07-23)'
 
-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.
+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.
 
-RM References:  9.01 (9.2/2)   9.04 (11.1/2)
+RM References:  3.05.02 (2/2)   A.01 (35/2)   A.03.03 (21)
 @end itemize
 
-@geindex AI-0030 (Ada 2012 feature)
+@geindex AI-0182 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0030 Requeue on synchronized interfaces (2010-07-19)'
+`AI-0182 Additional forms for' @code{Character'Value} `(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 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.
 
-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:  3.05 (56/2)
 @end itemize
 
-@geindex AI-0201 (Ada 2012 feature)
+@geindex AI-0183 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0201 Independence of atomic object components (2010-07-22)'
-
-If an Atomic object has a pragma @code{Pack} or a @code{Component_Size}
-attribute, then individual components may not be addressable by independent
-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.
+`AI-0183 Aspect specifications (2010-08-16)'
 
-RM References:  9.10 (1/3)   C.06 (22/2)   C.06 (23/2)
+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
 
-@geindex AI-0009 (Ada 2012 feature)
 
+@multitable {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxx} 
+@headitem
 
-@itemize *
+Supported Aspect
 
-@item 
-`AI-0009 Pragma Independent[_Components] (2010-07-23)'
+@tab
 
-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.
+Source
 
-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
+@item
 
-@geindex AI-0072 (Ada 2012 feature)
+@code{Ada_2005}
 
+@tab
 
-@itemize *
+– GNAT
 
-@item 
-`AI-0072 Task signalling using ‘Terminated (0000-00-00)'
+@item
 
-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.
+@code{Ada_2012}
 
-RM References:  9.10 (6.1/1)
-@end itemize
+@tab
 
-@geindex AI-0108 (Ada 2012 feature)
+– GNAT
 
+@item
 
-@itemize *
+@code{Address}
 
-@item 
-`AI-0108 Limited incomplete view and discriminants (0000-00-00)'
+@tab
 
-This AI confirms that an incomplete type from a limited view does not have
-discriminants. This has always been the case in GNAT.
+@item
 
-RM References:  10.01.01 (12.3/2)
-@end itemize
+@code{Alignment}
 
-@geindex AI-0129 (Ada 2012 feature)
+@tab
 
+@item
 
-@itemize *
+@code{Atomic}
 
-@item 
-`AI-0129 Limited views and incomplete types (0000-00-00)'
+@tab
 
-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.
+@item
 
-RM References:  10.01.01 (12.2/2)   10.01.01 (12.3/2)
-@end itemize
+@code{Atomic_Components}
 
-@geindex AI-0077 (Ada 2012 feature)
+@tab
 
+@item
 
-@itemize *
+@code{Bit_Order}
 
-@item 
-`AI-0077 Limited withs and scope of declarations (0000-00-00)'
+@tab
 
-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.
+@item
 
-RM References:  10.01.02 (12/2)   10.01.02 (21/2)   10.01.02 (22/2)
-@end itemize
+@code{Component_Size}
 
-@geindex AI-0122 (Ada 2012 feature)
+@tab
 
+@item
 
-@itemize *
+@code{Contract_Cases}
 
-@item 
-`AI-0122 Private with and children of generics (0000-00-00)'
+@tab
 
-This AI clarifies the visibility of private children of generic units within
-instantiations of a parent. GNAT has always handled this correctly.
+– GNAT
 
-RM References:  10.01.02 (12/2)
-@end itemize
+@item
 
-@geindex AI-0040 (Ada 2012 feature)
+@code{Discard_Names}
 
+@tab
 
-@itemize *
+@item
 
-@item 
-`AI-0040 Limited with clauses on descendant (0000-00-00)'
+@code{External_Tag}
 
-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.
+@tab
 
-RM References:  10.01.02 (20/2)
-@end itemize
+@item
 
-@geindex AI-0132 (Ada 2012 feature)
+@code{Favor_Top_Level}
 
+@tab
 
-@itemize *
+– GNAT
 
-@item 
-`AI-0132 Placement of library unit pragmas (0000-00-00)'
+@item
 
-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.
+@code{Inline}
 
-RM References:  10.01.05 (7)
-@end itemize
+@tab
 
-@geindex AI-0034 (Ada 2012 feature)
+@item
 
+@code{Inline_Always}
 
-@itemize *
+@tab
 
-@item 
-`AI-0034 Categorization of limited views (0000-00-00)'
+– GNAT
 
-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.
+@item
 
-RM References:  10.02.01 (11/1)   10.02.01 (17/2)
-@end itemize
+@code{Invariant}
 
-@geindex AI-0035 (Ada 2012 feature)
+@tab
 
+– GNAT
 
-@itemize *
+@item
 
-@item 
-`AI-0035 Inconsistencies with Pure units (0000-00-00)'
+@code{Machine_Radix}
 
-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.
+@tab
 
-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
+@item
 
-@geindex AI-0219 (Ada 2012 feature)
+@code{No_Return}
 
+@tab
 
-@itemize *
+@item
 
-@item 
-`AI-0219 Pure permissions and limited parameters (2010-05-25)'
+@code{Object_Size}
 
-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.
+@tab
 
-RM References:  10.02.01 (18/2)
-@end itemize
+– GNAT
 
-@geindex AI-0043 (Ada 2012 feature)
+@item
 
+@code{Pack}
 
-@itemize *
+@tab
 
-@item 
-`AI-0043 Rules about raising exceptions (0000-00-00)'
+@item
 
-This AI covers various omissions in the RM regarding the raising of
-exceptions. GNAT has always implemented the intended semantics.
+@code{Persistent_BSS}
 
-RM References:  11.04.01 (10.1/2)   11 (2)
-@end itemize
+@tab
 
-@geindex AI-0200 (Ada 2012 feature)
+– GNAT
 
+@item
 
-@itemize *
+@code{Post}
 
-@item 
-`AI-0200 Mismatches in formal package declarations (0000-00-00)'
+@tab
 
-This AI plugs a gap in the RM which appeared to allow some obviously intended
-illegal instantiations. GNAT has never allowed these instantiations.
+@item
 
-RM References:  12.07 (16)
-@end itemize
+@code{Pre}
 
-@geindex AI-0112 (Ada 2012 feature)
+@tab
 
+@item
 
-@itemize *
+@code{Predicate}
 
-@item 
-`AI-0112 Detection of duplicate pragmas (2010-07-24)'
+@tab
 
-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.
+@item
 
-RM References:  13.01 (8)
-@end itemize
+@code{Preelaborable_Initialization}
 
-@geindex AI-0106 (Ada 2012 feature)
+@tab
 
+@item
 
-@itemize *
+@code{Pure_Function}
 
-@item 
-`AI-0106 No representation pragmas on generic formals (0000-00-00)'
+@tab
 
-The RM appeared to allow representation pragmas on generic formal parameters,
-but this was not intended, and GNAT has never permitted this usage.
+– GNAT
 
-RM References:  13.01 (9.1/1)
-@end itemize
+@item
 
-@geindex AI-0012 (Ada 2012 feature)
+@code{Remote_Access_Type}
 
+@tab
 
-@itemize *
+– GNAT
 
-@item 
-`AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)'
+@item
 
-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.
+@code{Shared}
 
-RM References:  13.02 (6.1/2)   13.02 (7)   C.06 (10)   C.06 (11)   C.06 (21)
-@end itemize
+@tab
 
-@geindex AI-0039 (Ada 2012 feature)
+– GNAT
 
+@item
 
-@itemize *
+@code{Size}
 
-@item 
-`AI-0039 Stream attributes cannot be dynamic (0000-00-00)'
+@tab
 
-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.
+@item
 
-RM References:  13.03 (4)   13.03 (6)   13.13.02 (38/2)
-@end itemize
+@code{Storage_Pool}
 
-@geindex AI-0095 (Ada 2012 feature)
+@tab
+
+@item
+
+@code{Storage_Size}
+
+@tab
+
+@item
 
+@code{Stream_Size}
 
-@itemize *
+@tab
 
-@item 
-`AI-0095 Address of intrinsic subprograms (0000-00-00)'
+@item
 
-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}.
+@code{Suppress}
 
-RM References:  13.03 (11/1)
-@end itemize
+@tab
 
-@geindex AI-0116 (Ada 2012 feature)
+@item
 
+@code{Suppress_Debug_Info}
 
-@itemize *
+@tab
 
-@item 
-`AI-0116 Alignment of class-wide objects (0000-00-00)'
+– GNAT
 
-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.
+@item
 
-RM References:  13.03 (29)   13.11 (16)
-@end itemize
+@code{Test_Case}
 
-@geindex AI-0146 (Ada 2012 feature)
+@tab
 
+– GNAT
 
-@itemize *
+@item
 
-@item 
-`AI-0146 Type invariants (2009-09-21)'
+@code{Thread_Local_Storage}
 
-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}.
+@tab
 
-RM References:  13.03.03 (00)
-@end itemize
+– GNAT
 
-@geindex AI-0078 (Ada 2012 feature)
+@item
 
+@code{Type_Invariant}
 
-@itemize *
+@tab
 
-@item 
-`AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)'
+@item
 
-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).
+@code{Unchecked_Union}
 
-RM References:  13.09 (7)
-@end itemize
+@tab
 
-@geindex AI-0195 (Ada 2012 feature)
+@item
 
+@code{Universal_Aliasing}
 
-@itemize *
+@tab
 
-@item 
-`AI-0195 Invalid value handling is implementation defined (2010-07-03)'
+– GNAT
 
-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.
+@item
 
-RM References:  13.09.01 (10)
-@end itemize
+@code{Unmodified}
 
-@geindex AI-0193 (Ada 2012 feature)
+@tab
 
+– GNAT
 
-@itemize *
+@item
 
-@item 
-`AI-0193 Alignment of allocators (2010-09-16)'
+@code{Unreferenced}
 
-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.
+@tab
 
-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
+– GNAT
 
-@geindex AI-0177 (Ada 2012 feature)
+@item
 
+@code{Unreferenced_Objects}
 
-@itemize *
+@tab
 
-@item 
-`AI-0177 Parameterized expressions (2010-07-10)'
+– GNAT
 
-The new Ada 2012 notion of parameterized expressions is implemented. The form
-is:
+@item
 
-@example
-function-specification is (expression)
-@end example
+@code{Unsuppress}
 
-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.
+@tab
 
-RM References:  13.11.01 (3/2)
-@end itemize
+@item
 
-@geindex AI-0033 (Ada 2012 feature)
+@code{Value_Size}
 
+@tab
 
-@itemize *
+– GNAT
 
-@item 
-`AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)'
+@item
 
-Neither of these two pragmas may appear within a generic template, because
-the generic might be instantiated at other than the library level.
+@code{Volatile}
 
-RM References:  13.11.02 (16)   C.03.01 (7/2)   C.03.01 (8/2)
-@end itemize
+@tab
 
-@geindex AI-0161 (Ada 2012 feature)
+@item
 
+@code{Volatile_Components}
 
-@itemize *
+@tab
 
-@item 
-`AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)'
+@item
 
-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.
+@code{Warnings}
 
-RM References:  13.12.01 (4/2)   13.13.02 (40/2)   13.13.02 (52/2)
-@end itemize
+@tab
 
-@geindex AI-0194 (Ada 2012 feature)
+– GNAT
 
+@end multitable
 
-@itemize *
 
-@item 
-`AI-0194 Value of Stream_Size attribute (0000-00-00)'
+@quotation
 
-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.
+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:  13.13.02 (1.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-0109 (Ada 2012 feature)
+@geindex AI-0185 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0109 Redundant check in S’Class’Input (0000-00-00)'
+`AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)'
 
-This AI is an editorial change only. It removes the need for a tag check
-that can never fail.
+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:  13.13.02 (34/2)
+RM References:  A.03.05 (0)   A.03.06 (0)
 @end itemize
 
-@geindex AI-0007 (Ada 2012 feature)
+@geindex AI-0188 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0007 Stream read and private scalar types (0000-00-00)'
+`AI-0188 Case expressions (2010-01-09)'
 
-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.
+Case expressions are permitted. This allows use of constructs such as:
 
-RM References:  13.13.02 (50/2)   13.13.02 (51/2)
+@example
+X := (case Y is when 1 => 2, when 2 => 3, when others => 31)
+@end example
+
+RM References:  4.05.07 (0)   4.05.08 (0)   4.09 (12)   4.09 (33)
 @end itemize
 
-@geindex AI-0065 (Ada 2012 feature)
+@geindex AI-0189 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0065 Remote access types and external streaming (0000-00-00)'
+`AI-0189 No_Allocators_After_Elaboration (2010-01-23)'
 
-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.
+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.13.02 (52/2)
+RM References:  D.07 (19.1/2)   H.04 (23.3/2)
 @end itemize
 
-@geindex AI-0019 (Ada 2012 feature)
+@geindex AI-0190 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0019 Freezing of primitives for tagged types (0000-00-00)'
+`AI-0190 pragma Default_Storage_Pool (2010-09-15)'
 
-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.
+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.14 (2)   13.14 (3/1)   13.14 (8.1/1)   13.14 (10)   13.14 (14)   13.14 (15.1/2)
+RM References:  D.07 (8)
 @end itemize
 
-@geindex AI-0017 (Ada 2012 feature)
+@geindex AI-0193 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0017 Freezing and incomplete types (0000-00-00)'
+`AI-0193 Alignment of allocators (2010-09-16)'
 
-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.
+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:  13.14 (3/1)
+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-0060 (Ada 2012 feature)
+@geindex AI-0194 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0060 Extended definition of remote access types (0000-00-00)'
+`AI-0194 Value of Stream_Size attribute (0000-00-00)'
 
-This AI extends the definition of remote access types to include access
-to limited, synchronized, protected or task class-wide interface types.
-GNAT already implemented this extension.
+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:  A (4)   E.02.02 (9/1)   E.02.02 (9.2/1)   E.02.02 (14/2)   E.02.02 (18)
+RM References:  13.13.02 (1.2/2)
 @end itemize
 
-@geindex AI-0114 (Ada 2012 feature)
+@geindex AI-0195 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0114 Classification of letters (0000-00-00)'
+`AI-0195 Invalid value handling is implementation defined (2010-07-03)'
 
-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.
+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:  A.03.02 (59)   A.04.06 (7)
+RM References:  13.09.01 (10)
 @end itemize
 
-@geindex AI-0185 (Ada 2012 feature)
+@geindex AI-0196 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)'
+`AI-0196 Null exclusion tests for out parameters (0000-00-00)'
 
-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}.
+Null exclusion checks are not made for @code{out} parameters when
+evaluating the actual parameters. GNAT has never generated these checks.
 
-RM References:  A.03.05 (0)   A.03.06 (0)
+RM References:  6.04.01 (13)
 @end itemize
 
-@geindex AI-0031 (Ada 2012 feature)
+@geindex AI-0198 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0031 Add From parameter to Find_Token (2010-07-25)'
+`AI-0198 Inheriting abstract operators  (0000-00-00)'
 
-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.
+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.
 
-RM References:  A.04.03 (16)   A.04.03 (67)   A.04.03 (68/1)   A.04.04 (51)
-A.04.05 (46)
+RM References:  3.09.03 (4/3)
 @end itemize
 
-@geindex AI-0056 (Ada 2012 feature)
+@geindex AI-0199 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0056 Index on null string returns zero (0000-00-00)'
+`AI-0199 Aggregate with anonymous access components (2010-07-14)'
 
-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.
+A choice list in a record aggregate can include several components of
+(distinct) anonymous access types as long as they have matching designated
+subtypes.
 
-RM References:  A.04.03 (56.2/2)   A.04.03 (58.5/2)
+RM References:  4.03.01 (16)
 @end itemize
 
-@geindex AI-0137 (Ada 2012 feature)
+@geindex AI-0200 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0137 String encoding package (2010-03-25)'
+`AI-0200 Mismatches in formal package declarations (0000-00-00)'
 
-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}).
+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:  A.04.11
+RM References:  12.07 (16)
 @end itemize
 
-@geindex AI-0038 (Ada 2012 feature)
+@geindex AI-0201 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0038 Minor errors in Text_IO (0000-00-00)'
+`AI-0201 Independence of atomic object components (2010-07-22)'
 
-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.
+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:  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)
+RM References:  9.10 (1/3)   C.06 (22/2)   C.06 (23/2)
 @end itemize
 
-@geindex AI-0044 (Ada 2012 feature)
+@geindex AI-0203 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0044 Restrictions on container instantiations (0000-00-00)'
+`AI-0203 Extended return cannot be abstract (0000-00-00)'
 
-This AI places restrictions on allowed instantiations of generic containers.
-These restrictions are not checked by the compiler, so there is nothing to
-change in the implementation. This affects only the RM documentation.
+A return_subtype_indication cannot denote an abstract subtype. GNAT has never
+permitted such usage.
 
-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)
+RM References:  3.09.03 (8/3)
 @end itemize
 
-@geindex AI-0127 (Ada 2012 feature)
+@geindex AI-0205 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0127 Adding Locale Capabilities (2010-09-29)'
+`AI-0205 Extended return declares visible name (0000-00-00)'
 
-This package provides an interface for identifying the current locale.
+This AI corrects a simple omission in the RM. Return objects have always
+been visible within an extended return statement.
 
-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
+RM References:  8.03 (17)
 @end itemize
 
-@geindex AI-0002 (Ada 2012 feature)
+@geindex AI-0206 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0002 Export C with unconstrained arrays (0000-00-00)'
+`AI-0206 Remote types packages and preelaborate (2010-07-24)'
 
-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.
+Remote types packages are now allowed to depend on preelaborated packages.
+This was formerly considered illegal.
 
-RM References:  B.01 (17)   B.03 (62)   B.03 (71.1/2)
+RM References:  E.02.02 (6)
 @end itemize
 
-@geindex AI-0216 (Ada 2012 feature)
+@geindex AI-0207 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)'
+`AI-0207 Mode conformance and access constant (0000-00-00)'
 
-It is clearly the intention that @code{No_Task_Hierarchy} is intended to
-forbid tasks declared locally within subprograms, or functions returning task
-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.
+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:  D.07 (3/3)
+RM References:  6.03.01 (16/2)
 @end itemize
 
-@geindex AI-0211 (Ada 2012 feature)
+@geindex AI-0208 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)'
+`AI-0208 Characteristics of incomplete views (0000-00-00)'
 
-The restriction @code{No_Relative_Delays} forbids any calls to the subprogram
-@code{Ada.Real_Time.Timing_Events.Set_Handler}.
+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.
 
-RM References:  D.07 (5)   D.07 (10/2)   D.07 (10.4/2)   D.07 (10.7/2)
+RM References:  3.10.01 (2.4/2)   3.10.01 (2.6/2)
 @end itemize
 
-@geindex AI-0190 (Ada 2012 feature)
+@geindex AI-0210 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0190 pragma Default_Storage_Pool (2010-09-15)'
+`AI-0210 Correct Timing_Events metric (0000-00-00)'
 
-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.
+This is a documentation only issue regarding wording of metric requirements,
+that does not affect the implementation of the compiler.
 
-RM References:  D.07 (8)
+RM References:  D.15 (24/2)
 @end itemize
 
-@geindex AI-0189 (Ada 2012 feature)
+@geindex AI-0211 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0189 No_Allocators_After_Elaboration (2010-01-23)'
+`AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)'
 
-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.
+The restriction @code{No_Relative_Delays} forbids any calls to the subprogram
+@code{Ada.Real_Time.Timing_Events.Set_Handler}.
 
-RM References:  D.07 (19.1/2)   H.04 (23.3/2)
+RM References:  D.07 (5)   D.07 (10/2)   D.07 (10.4/2)   D.07 (10.7/2)
 @end itemize
 
-@geindex AI-0171 (Ada 2012 feature)
+@geindex AI-0214 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)'
+`AI-0214 Defaulted discriminants for limited tagged (2010-10-01)'
 
-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.
+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.
 
-RM References:  D.13.01 (4/2)   D.16
+RM References:  3.07 (9.1/2)   3.07.02 (3)
 @end itemize
 
-@geindex AI-0210 (Ada 2012 feature)
+@geindex AI-0216 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0210 Correct Timing_Events metric (0000-00-00)'
+`AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)'
 
-This is a documentation only issue regarding wording of metric requirements,
-that does not affect the implementation of the compiler.
+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:  D.15 (24/2)
+RM References:  D.07 (3/3)
 @end itemize
 
-@geindex AI-0206 (Ada 2012 feature)
+@geindex AI-0219 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0206 Remote types packages and preelaborate (2010-07-24)'
+`AI-0219 Pure permissions and limited parameters (2010-05-25)'
 
-Remote types packages are now allowed to depend on preelaborated packages.
-This was formerly considered illegal.
+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:  E.02.02 (6)
+RM References:  10.02.01 (18/2)
 @end itemize
 
-@geindex AI-0152 (Ada 2012 feature)
+@geindex AI-0220 (Ada 2012 feature)
 
 
 @itemize *
 
 @item 
-`AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)'
+`AI-0220 Needed components for aggregates (0000-00-00)'
 
-Restriction @code{No_Anonymous_Allocators} prevents the use of allocators
-where the type of the returned value is an anonymous access type.
+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.
 
-RM References:  H.04 (8/1)
+RM References:  4.03.01 (17)
 @end itemize
 
 @node GNAT language extensions,Security Hardening Features,Implementation of Ada 2012 Features,Top