@@ -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)
@@ -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