From: Piotr Trojanek Date: Mon, 18 Mar 2024 17:00:55 +0000 (+0100) Subject: ada: Sort list of implemented Ada 2012 features X-Git-Tag: basepoints/gcc-16~8828 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=ef10ed27e0f3f3777b5c64cb30947e70e6a1c905;p=thirdparty%2Fgcc.git ada: Sort list of implemented Ada 2012 features The list of implemented Ada 2012 features is now ordered by the AI numbers. It has been sorted mechanically using the csplit command with a bit of shell scripting. gcc/ada/ * doc/gnat_rm/implementation_of_ada_2012_features.rst: Order list by AI number. * gnat_rm.texi: Regenerate. --- diff --git a/gcc/ada/doc/gnat_rm/implementation_of_ada_2012_features.rst b/gcc/ada/doc/gnat_rm/implementation_of_ada_2012_features.rst index d7f1fea01f3..706de492301 100644 --- a/gcc/ada/doc/gnat_rm/implementation_of_ada_2012_features.rst +++ b/gcc/ada/doc/gnat_rm/implementation_of_ada_2012_features.rst @@ -43,330 +43,343 @@ in the RM, the earliest is used. A complete description of the AIs may be found in http://www.ada-auth.org/ai05-summary.html. -.. index:: AI-0176 (Ada 2012 feature) +.. index:: AI-0002 (Ada 2012 feature) -* *AI-0176 Quantified expressions (2010-09-29)* +* *AI-0002 Export C with unconstrained arrays (0000-00-00)* - Both universally and existentially quantified expressions are implemented. - They use the new syntax for iterators proposed in AI05-139-2, as well as - the standard Ada loop syntax. + The compiler is not required to support exporting an Ada subprogram with + convention C if there are parameters or a return type of an unconstrained + array type (such as ``String``). GNAT allows such declarations but + generates warnings. It is possible, but complicated, to write the + corresponding C code and certainly such code would be specific to GNAT and + non-portable. - RM References: 1.01.04 (12) 2.09 (2/2) 4.04 (7) 4.05.09 (0) + RM References: B.01 (17) B.03 (62) B.03 (71.1/2) -.. index:: AI-0079 (Ada 2012 feature) +.. index:: AI-0003 (Ada 2012 feature) -* *AI-0079 Allow other_format characters in source (2010-07-10)* +* *AI-0003 Qualified expressions as names (2010-07-11)* - Wide characters in the unicode category *other_format* are now allowed in - source programs between tokens, but not within a token such as an identifier. + In Ada 2012, a qualified expression is considered to be syntactically a name, + meaning that constructs such as ``A'(F(X)).B`` are now legal. This is + useful in disambiguating some cases of overloading. - RM References: 2.01 (4/2) 2.02 (7) + RM References: 3.03 (11) 3.03 (21) 4.01 (2) 4.04 (7) 4.07 (3) + 5.04 (7) -.. index:: AI-0091 (Ada 2012 feature) +.. index:: AI-0007 (Ada 2012 feature) -* *AI-0091 Do not allow other_format in identifiers (0000-00-00)* +* *AI-0007 Stream read and private scalar types (0000-00-00)* - Wide characters in the unicode category *other_format* are not permitted - within an identifier, since this can be a security problem. The error - message for this case has been improved to be more specific, but GNAT has - never allowed such characters to appear in identifiers. + The RM as written appeared to limit the possibilities of declaring read + attribute procedures for private scalar types. This limitation was not + intended, and has never been enforced by GNAT. - RM References: 2.03 (3.1/2) 2.03 (4/2) 2.03 (5/2) 2.03 (5.1/2) 2.03 (5.2/2) 2.03 (5.3/2) 2.09 (2/2) + RM References: 13.13.02 (50/2) 13.13.02 (51/2) -.. index:: AI-0100 (Ada 2012 feature) +.. index:: AI-0008 (Ada 2012 feature) -* *AI-0100 Placement of pragmas (2010-07-01)* +* *AI-0008 General access to constrained objects (0000-00-00)* - This AI is an earlier version of AI-163. It simplifies the rules - for legal placement of pragmas. In the case of lists that allow pragmas, if - the list may have no elements, then the list may consist solely of pragmas. + The wording in the RM implied that if you have a general access to a + constrained object, it could be used to modify the discriminants. This was + obviously not intended. ``Constraint_Error`` should be raised, and GNAT + has always done so in this situation. - RM References: 2.08 (7) + RM References: 3.03 (23) 3.10.02 (26/2) 4.01 (9) 6.04.01 (17) 8.05.01 (5/2) -.. index:: AI-0163 (Ada 2012 feature) +.. index:: AI-0009 (Ada 2012 feature) -* *AI-0163 Pragmas in place of null (2010-07-01)* +* *AI-0009 Pragma Independent[_Components] (2010-07-23)* - A statement sequence may be composed entirely of pragmas. It is no longer - necessary to add a dummy ``null`` statement to make the sequence legal. + This AI introduces the new pragmas ``Independent`` and + ``Independent_Components``, + which control guaranteeing independence of access to objects and components. + The AI also requires independence not unaffected by confirming rep clauses. - RM References: 2.08 (7) 2.08 (16) + RM References: 9.10 (1) 13.01 (15/1) 13.02 (9) 13.03 (13) C.06 (2) + C.06 (4) C.06 (6) C.06 (9) C.06 (13) C.06 (14) -.. index:: AI-0080 (Ada 2012 feature) +.. index:: AI-0012 (Ada 2012 feature) -* *AI-0080 'View of' not needed if clear from context (0000-00-00)* +* *AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)* - This is an editorial change only, described as non-testable in the AI. + It is now illegal to give an inappropriate component size or a pragma + ``Pack`` that attempts to change the component size in the case of atomic + or aliased components. Previously GNAT ignored such an attempt with a + warning. - RM References: 3.01 (7) + RM References: 13.02 (6.1/2) 13.02 (7) C.06 (10) C.06 (11) C.06 (21) -.. index:: AI-0183 (Ada 2012 feature) +.. index:: AI-0015 (Ada 2012 feature) -* *AI-0183 Aspect specifications (2010-08-16)* +* *AI-0015 Constant return objects (0000-00-00)* - Aspect specifications have been fully implemented except for pre and post- - conditions, and type invariants, which have their own separate AI's. All - forms of declarations listed in the AI are supported. The following is a - list of the aspects supported (with GNAT implementation aspects marked) + The return object declared in an *extended_return_statement* may be + declared constant. This was always intended, and GNAT has always allowed it. -==================================== =========== -Supported Aspect Source -==================================== =========== - ``Ada_2005`` -- GNAT - ``Ada_2012`` -- GNAT - ``Address`` - ``Alignment`` - ``Atomic`` - ``Atomic_Components`` - ``Bit_Order`` - ``Component_Size`` - ``Contract_Cases`` -- GNAT - ``Discard_Names`` - ``External_Tag`` - ``Favor_Top_Level`` -- GNAT - ``Inline`` - ``Inline_Always`` -- GNAT - ``Invariant`` -- GNAT - ``Machine_Radix`` - ``No_Return`` - ``Object_Size`` -- GNAT - ``Pack`` - ``Persistent_BSS`` -- GNAT - ``Post`` - ``Pre`` - ``Predicate`` - ``Preelaborable_Initialization`` - ``Pure_Function`` -- GNAT - ``Remote_Access_Type`` -- GNAT - ``Shared`` -- GNAT - ``Size`` - ``Storage_Pool`` - ``Storage_Size`` - ``Stream_Size`` - ``Suppress`` - ``Suppress_Debug_Info`` -- GNAT - ``Test_Case`` -- GNAT - ``Thread_Local_Storage`` -- GNAT - ``Type_Invariant`` - ``Unchecked_Union`` - ``Universal_Aliasing`` -- GNAT - ``Unmodified`` -- GNAT - ``Unreferenced`` -- GNAT - ``Unreferenced_Objects`` -- GNAT - ``Unsuppress`` - ``Value_Size`` -- GNAT - ``Volatile`` - ``Volatile_Components`` - ``Warnings`` -- GNAT -==================================== =========== + RM References: 6.05 (2.1/2) 3.03 (10/2) 3.03 (21) 6.05 (5/2) + 6.05 (5.7/2) - Note that for aspects with an expression, e.g. ``Size``, the expression is - treated like a default expression (visibility is analyzed at the point of - occurrence of the aspect, but evaluation of the expression occurs at the - freeze point of the entity involved). +.. index:: AI-0017 (Ada 2012 feature) - RM References: 3.02.01 (3) 3.02.02 (2) 3.03.01 (2/2) 3.08 (6) - 3.09.03 (1.1/2) 6.01 (2/2) 6.07 (2/2) 9.05.02 (2/2) 7.01 (3) 7.03 - (2) 7.03 (3) 9.01 (2/2) 9.01 (3/2) 9.04 (2/2) 9.04 (3/2) - 9.05.02 (2/2) 11.01 (2) 12.01 (3) 12.03 (2/2) 12.04 (2/2) 12.05 (2) - 12.06 (2.1/2) 12.06 (2.2/2) 12.07 (2) 13.01 (0.1/2) 13.03 (5/1) - 13.03.01 (0) +* *AI-0017 Freezing and incomplete types (0000-00-00)* -.. index:: AI-0128 (Ada 2012 feature) + So-called 'Taft-amendment types' (i.e., types that are completed in package + bodies) are not frozen by the occurrence of bodies in the + enclosing declarative part. GNAT always implemented this properly. -* *AI-0128 Inequality is a primitive operation (0000-00-00)* + RM References: 13.14 (3/1) - If an equality operator ("=") is declared for a type, then the implicitly - declared inequality operator ("/=") is a primitive operation of the type. - This is the only reasonable interpretation, and is the one always implemented - by GNAT, but the RM was not entirely clear in making this point. +.. index:: AI-0019 (Ada 2012 feature) - RM References: 3.02.03 (6) 6.06 (6) +* *AI-0019 Freezing of primitives for tagged types (0000-00-00)* -.. index:: AI-0003 (Ada 2012 feature) + The RM suggests that primitive subprograms of a specific tagged type are + frozen when the tagged type is frozen. This would be an incompatible change + and is not intended. GNAT has never attempted this kind of freezing and its + behavior is consistent with the recommendation of this AI. -* *AI-0003 Qualified expressions as names (2010-07-11)* + RM References: 13.14 (2) 13.14 (3/1) 13.14 (8.1/1) 13.14 (10) 13.14 (14) 13.14 (15.1/2) - In Ada 2012, a qualified expression is considered to be syntactically a name, - meaning that constructs such as ``A'(F(X)).B`` are now legal. This is - useful in disambiguating some cases of overloading. +.. index:: AI-0026 (Ada 2012 feature) - RM References: 3.03 (11) 3.03 (21) 4.01 (2) 4.04 (7) 4.07 (3) - 5.04 (7) +* *AI-0026 Missing rules for Unchecked_Union (2010-07-07)* -.. index:: AI-0120 (Ada 2012 feature) + Record representation clauses concerning Unchecked_Union types cannot mention + the discriminant of the type. The type of a component declared in the variant + part of an Unchecked_Union cannot be controlled, have controlled components, + nor have protected or task parts. If an Unchecked_Union type is declared + within the body of a generic unit or its descendants, then the type of a + component declared in the variant part cannot be a formal private type or a + formal private extension declared within the same generic unit. -* *AI-0120 Constant instance of protected object (0000-00-00)* + RM References: 7.06 (9.4/2) B.03.03 (9/2) B.03.03 (10/2) - This is an RM editorial change only. The section that lists objects that are - constant failed to include the current instance of a protected object - within a protected function. This has always been treated as a constant - in GNAT. +.. index:: AI-0030 (Ada 2012 feature) - RM References: 3.03 (21) +* *AI-0030 Requeue on synchronized interfaces (2010-07-19)* -.. index:: AI-0008 (Ada 2012 feature) + Requeue is permitted to a protected, synchronized or task interface primitive + providing it is known that the overriding operation is an entry. Otherwise + the requeue statement has the same effect as a procedure call. Use of pragma + ``Implemented`` provides a way to impose a static requirement on the + overriding operation by adhering to one of the implementation kinds: entry, + protected procedure or any of the above. -* *AI-0008 General access to constrained objects (0000-00-00)* + RM References: 9.05 (9) 9.05.04 (2) 9.05.04 (3) 9.05.04 (5) + 9.05.04 (6) 9.05.04 (7) 9.05.04 (12) - The wording in the RM implied that if you have a general access to a - constrained object, it could be used to modify the discriminants. This was - obviously not intended. ``Constraint_Error`` should be raised, and GNAT - has always done so in this situation. +.. index:: AI-0031 (Ada 2012 feature) - RM References: 3.03 (23) 3.10.02 (26/2) 4.01 (9) 6.04.01 (17) 8.05.01 (5/2) +* *AI-0031 Add From parameter to Find_Token (2010-07-25)* -.. index:: AI-0093 (Ada 2012 feature) + A new version of ``Find_Token`` is added to all relevant string packages, + with an extra parameter ``From``. Instead of starting at the first + character of the string, the search for a matching Token starts at the + character indexed by the value of ``From``. + These procedures are available in all versions of Ada + but if used in versions earlier than Ada 2012 they will generate a warning + that an Ada 2012 subprogram is being used. -* *AI-0093 Additional rules use immutably limited (0000-00-00)* + RM References: A.04.03 (16) A.04.03 (67) A.04.03 (68/1) A.04.04 (51) + A.04.05 (46) - This is an editorial change only, to make more widespread use of the Ada 2012 - 'immutably limited'. +.. index:: AI-0032 (Ada 2012 feature) - RM References: 3.03 (23.4/3) +* *AI-0032 Extended return for class-wide functions (0000-00-00)* -.. index:: AI-0096 (Ada 2012 feature) + If a function returns a class-wide type, the object of an extended return + statement can be declared with a specific type that is covered by the class- + wide type. This has been implemented in GNAT since the introduction of + extended returns. Note AI-0103 complements this AI by imposing matching + rules for constrained return types. -* *AI-0096 Deriving from formal private types (2010-07-20)* + RM References: 6.05 (5.2/2) 6.05 (5.3/2) 6.05 (5.6/2) 6.05 (5.8/2) + 6.05 (8/2) - In general it is illegal for a type derived from a formal limited type to be - nonlimited. This AI makes an exception to this rule: derivation is legal - if it appears in the private part of the generic, and the formal type is not - tagged. If the type is tagged, the legality check must be applied to the - private part of the package. +.. index:: AI-0033 (Ada 2012 feature) - RM References: 3.04 (5.1/2) 6.02 (7) +* *AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)* -.. index:: AI-0181 (Ada 2012 feature) + Neither of these two pragmas may appear within a generic template, because + the generic might be instantiated at other than the library level. -* *AI-0181 Soft hyphen is a non-graphic character (2010-07-23)* + RM References: 13.11.02 (16) C.03.01 (7/2) C.03.01 (8/2) - From Ada 2005 on, soft hyphen is considered a non-graphic character, which - means that it has a special name (``SOFT_HYPHEN``) in conjunction with the - ``Image`` and ``Value`` attributes for the character types. Strictly - speaking this is an inconsistency with Ada 95, but in practice the use of - these attributes is so obscure that it will not cause problems. +.. index:: AI-0034 (Ada 2012 feature) - RM References: 3.05.02 (2/2) A.01 (35/2) A.03.03 (21) +* *AI-0034 Categorization of limited views (0000-00-00)* -.. index:: AI-0182 (Ada 2012 feature) + The RM makes certain limited with clauses illegal because of categorization + considerations, when the corresponding normal with would be legal. This is + not intended, and GNAT has always implemented the recommended behavior. -* *AI-0182 Additional forms for* ``Character'Value`` *(0000-00-00)* + RM References: 10.02.01 (11/1) 10.02.01 (17/2) - This AI allows ``Character'Value`` to accept the string ``'?'`` where - ``?`` is any character including non-graphic control characters. GNAT has - always accepted such strings. It also allows strings such as - ``HEX_00000041`` to be accepted, but GNAT does not take advantage of this - permission and raises ``Constraint_Error``, as is certainly still - permitted. +.. index:: AI-0035 (Ada 2012 feature) - RM References: 3.05 (56/2) +* *AI-0035 Inconsistencies with Pure units (0000-00-00)* -.. index:: AI-0214 (Ada 2012 feature) + This AI remedies some inconsistencies in the legality rules for Pure units. + Derived access types are legal in a pure unit (on the assumption that the + rule for a zero storage pool size has been enforced on the ancestor type). + The rules are enforced in generic instances and in subunits. GNAT has always + implemented the recommended behavior. -* *AI-0214 Defaulted discriminants for limited tagged (2010-10-01)* + RM References: 10.02.01 (15.1/2) 10.02.01 (15.4/2) 10.02.01 (15.5/2) 10.02.01 (17/2) - Ada 2012 relaxes the restriction that forbids discriminants of tagged types - to have default expressions by allowing them when the type is limited. It - is often useful to define a default value for a discriminant even though - it can't be changed by assignment. +.. index:: AI-0037 (Ada 2012 feature) - RM References: 3.07 (9.1/2) 3.07.02 (3) +* *AI-0037 Out-of-range box associations in aggregate (0000-00-00)* -.. index:: AI-0102 (Ada 2012 feature) + This AI confirms that an association of the form ``Indx => <>`` in an + array aggregate must raise ``Constraint_Error`` if ``Indx`` + is out of range. The RM specified a range check on other associations, but + not when the value of the association was defaulted. GNAT has always inserted + a constraint check on the index value. -* *AI-0102 Some implicit conversions are illegal (0000-00-00)* + RM References: 4.03.03 (29) - It is illegal to assign an anonymous access constant to an anonymous access - variable. The RM did not have a clear rule to prevent this, but GNAT has - always generated an error for this usage. +.. index:: AI-0038 (Ada 2012 feature) - RM References: 3.07 (16) 3.07.01 (9) 6.04.01 (6) 8.06 (27/2) +* *AI-0038 Minor errors in Text_IO (0000-00-00)* -.. index:: AI-0158 (Ada 2012 feature) + These are minor errors in the description on three points. The intent on + all these points has always been clear, and GNAT has always implemented the + correct intended semantics. -* *AI-0158 Generalizing membership tests (2010-09-16)* + RM References: A.10.05 (37) A.10.07 (8/1) A.10.07 (10) A.10.07 (12) A.10.08 (10) A.10.08 (24) - This AI extends the syntax of membership tests to simplify complex conditions - that can be expressed as membership in a subset of values of any type. It - introduces syntax for a list of expressions that may be used in loop contexts - as well. +.. index:: AI-0039 (Ada 2012 feature) - RM References: 3.08.01 (5) 4.04 (3) 4.05.02 (3) 4.05.02 (5) 4.05.02 (27) +* *AI-0039 Stream attributes cannot be dynamic (0000-00-00)* -.. index:: AI-0173 (Ada 2012 feature) + The RM permitted the use of dynamic expressions (such as ``ptr.all``)` + for stream attributes, but these were never useful and are now illegal. GNAT + has always regarded such expressions as illegal. -* *AI-0173 Testing if tags represent abstract types (2010-07-03)* + RM References: 13.03 (4) 13.03 (6) 13.13.02 (38/2) - The function ``Ada.Tags.Type_Is_Abstract`` returns ``True`` if invoked - with the tag of an abstract type, and ``False`` otherwise. +.. index:: AI-0040 (Ada 2012 feature) + +* *AI-0040 Limited with clauses on descendant (0000-00-00)* + + This AI confirms that a limited with clause in a child unit cannot name + an ancestor of the unit. This has always been checked in GNAT. + + RM References: 10.01.02 (20/2) + +.. index:: AI-0042 (Ada 2012 feature) + +* *AI-0042 Overriding versus implemented-by (0000-00-00)* + + This AI fixes a wording gap in the RM. An operation of a synchronized + interface can be implemented by a protected or task entry, but the abstract + operation is not being overridden in the usual sense, and it must be stated + separately that this implementation is legal. This has always been the case + in GNAT. + + RM References: 9.01 (9.2/2) 9.04 (11.1/2) + +.. index:: AI-0043 (Ada 2012 feature) + +* *AI-0043 Rules about raising exceptions (0000-00-00)* + + This AI covers various omissions in the RM regarding the raising of + exceptions. GNAT has always implemented the intended semantics. + + RM References: 11.04.01 (10.1/2) 11 (2) + +.. index:: AI-0044 (Ada 2012 feature) + +* *AI-0044 Restrictions on container instantiations (0000-00-00)* + + This AI places restrictions on allowed instantiations of generic containers. + These restrictions are not checked by the compiler, so there is nothing to + change in the implementation. This affects only the RM documentation. + + RM References: A.18 (4/2) A.18.02 (231/2) A.18.03 (145/2) A.18.06 (56/2) A.18.08 (66/2) A.18.09 (79/2) A.18.26 (5/2) A.18.26 (9/2) + +.. index:: AI-0046 (Ada 2012 feature) + +* *AI-0046 Null exclusion match for full conformance (2010-07-17)* + + For full conformance, in the case of access parameters, the null exclusion + must match (either both or neither must have ``not null``). + + RM References: 6.03.02 (18) + +.. index:: AI-0050 (Ada 2012 feature) + +* *AI-0050 Raising Constraint_Error early for function call (0000-00-00)* + + The implementation permissions for raising ``Constraint_Error`` early on a function call + when it was clear an exception would be raised were over-permissive and allowed + mishandling of discriminants in some cases. GNAT did + not take advantage of these incorrect permissions in any case. - RM References: 3.09 (7.4/2) 3.09 (12.4/2) + RM References: 6.05 (24/2) -.. index:: AI-0076 (Ada 2012 feature) +.. index:: AI-0056 (Ada 2012 feature) -* *AI-0076 function with controlling result (0000-00-00)* +* *AI-0056 Index on null string returns zero (0000-00-00)* - This is an editorial change only. The RM defines calls with controlling - results, but uses the term 'function with controlling result' without an - explicit definition. + The wording in the Ada 2005 RM implied an incompatible handling of the + ``Index`` functions, resulting in raising an exception instead of + returning zero in some situations. + This was not intended and has been corrected. + GNAT always returned zero, and is thus consistent with this AI. - RM References: 3.09.02 (2/2) + RM References: A.04.03 (56.2/2) A.04.03 (58.5/2) -.. index:: AI-0126 (Ada 2012 feature) +.. index:: AI-0058 (Ada 2012 feature) -* *AI-0126 Dispatching with no declared operation (0000-00-00)* +* *AI-0058 Abnormal completion of an extended return (0000-00-00)* - This AI clarifies dispatching rules, and simply confirms that dispatching - executes the operation of the parent type when there is no explicitly or - implicitly declared operation for the descendant type. This has always been - the case in all versions of GNAT. + The RM had some incorrect wording implying wrong treatment of abnormal + completion in an extended return. GNAT has always implemented the intended + correct semantics as described by this AI. - RM References: 3.09.02 (20/2) 3.09.02 (20.1/2) 3.09.02 (20.2/2) + RM References: 6.05 (22/2) -.. index:: AI-0097 (Ada 2012 feature) +.. index:: AI-0060 (Ada 2012 feature) -* *AI-0097 Treatment of abstract null extension (2010-07-19)* +* *AI-0060 Extended definition of remote access types (0000-00-00)* - The RM as written implied that in some cases it was possible to create an - object of an abstract type, by having an abstract extension inherit a non- - abstract constructor from its parent type. This mistake has been corrected - in GNAT and in the RM, and this construct is now illegal. + This AI extends the definition of remote access types to include access + to limited, synchronized, protected or task class-wide interface types. + GNAT already implemented this extension. - RM References: 3.09.03 (4/2) + RM References: A (4) E.02.02 (9/1) E.02.02 (9.2/1) E.02.02 (14/2) E.02.02 (18) -.. index:: AI-0203 (Ada 2012 feature) +.. index:: AI-0062 (Ada 2012 feature) -* *AI-0203 Extended return cannot be abstract (0000-00-00)* +* *AI-0062 Null exclusions and deferred constants (0000-00-00)* - A return_subtype_indication cannot denote an abstract subtype. GNAT has never - permitted such usage. + A full constant may have a null exclusion even if its associated deferred + constant does not. GNAT has always allowed this. - RM References: 3.09.03 (8/3) + RM References: 7.04 (6/2) 7.04 (7.1/2) -.. index:: AI-0198 (Ada 2012 feature) +.. index:: AI-0064 (Ada 2012 feature) -* *AI-0198 Inheriting abstract operators (0000-00-00)* +* *AI-0064 Redundant finalization rule (0000-00-00)* - This AI resolves a conflict between two rules involving inherited abstract - operations and predefined operators. If a derived numeric type inherits - an abstract operator, it overrides the predefined one. This interpretation - was always the one implemented in GNAT. + This is an editorial change only. The intended behavior is already checked + by an existing ACATS test, which GNAT has always executed correctly. - RM References: 3.09.03 (4/3) + RM References: 7.06.01 (17.1/1) -.. index:: AI-0073 (Ada 2012 feature) +.. index:: AI-0065 (Ada 2012 feature) -* *AI-0073 Functions returning abstract types (2010-07-10)* +* *AI-0065 Remote access types and external streaming (0000-00-00)* - This AI covers a number of issues regarding returning abstract types. In - particular generic functions cannot have abstract result types or access - result types designated an abstract type. There are some other cases which - are detailed in the AI. Note that this binding interpretation has not been - retrofitted to operate before Ada 2012 mode, since it caused a significant - number of regressions. + This AI clarifies the fact that all remote access types support external + streaming. This fixes an obvious oversight in the definition of the + language, and GNAT always implemented the intended correct rules. - RM References: 3.09.03 (8) 3.09.03 (10) 6.05 (8/2) + RM References: 13.13.02 (52/2) .. index:: AI-0070 (Ada 2012 feature) @@ -377,107 +390,87 @@ Supported Aspect Source RM References: 3.09.04 (18/2) -.. index:: AI-0208 (Ada 2012 feature) - -* *AI-0208 Characteristics of incomplete views (0000-00-00)* - - The wording in the Ada 2005 RM concerning characteristics of incomplete views - was incorrect and implied that some programs intended to be legal were now - illegal. GNAT had never considered such programs illegal, so it has always - implemented the intent of this AI. - - RM References: 3.10.01 (2.4/2) 3.10.01 (2.6/2) - -.. index:: AI-0162 (Ada 2012 feature) +.. index:: AI-0072 (Ada 2012 feature) -* *AI-0162 Incomplete type completed by partial view (2010-09-15)* +* *AI-0072 Task signalling using 'Terminated (0000-00-00)* - Incomplete types are made more useful by allowing them to be completed by - private types and private extensions. + This AI clarifies that task signalling for reading ``'Terminated`` only + occurs if the result is True. GNAT semantics has always been consistent with + this notion of task signalling. - RM References: 3.10.01 (2.5/2) 3.10.01 (2.6/2) 3.10.01 (3) 3.10.01 (4/2) + RM References: 9.10 (6.1/1) -.. index:: AI-0098 (Ada 2012 feature) +.. index:: AI-0073 (Ada 2012 feature) -* *AI-0098 Anonymous subprogram access restrictions (0000-00-00)* +* *AI-0073 Functions returning abstract types (2010-07-10)* - An unintentional omission in the RM implied some inconsistent restrictions on - the use of anonymous access to subprogram values. These restrictions were not - intentional, and have never been enforced by GNAT. + This AI covers a number of issues regarding returning abstract types. In + particular generic functions cannot have abstract result types or access + result types designated an abstract type. There are some other cases which + are detailed in the AI. Note that this binding interpretation has not been + retrofitted to operate before Ada 2012 mode, since it caused a significant + number of regressions. - RM References: 3.10.01 (6) 3.10.01 (9.2/2) + RM References: 3.09.03 (8) 3.09.03 (10) 6.05 (8/2) -.. index:: AI-0199 (Ada 2012 feature) +.. index:: AI-0076 (Ada 2012 feature) -* *AI-0199 Aggregate with anonymous access components (2010-07-14)* +* *AI-0076 function with controlling result (0000-00-00)* - A choice list in a record aggregate can include several components of - (distinct) anonymous access types as long as they have matching designated - subtypes. + This is an editorial change only. The RM defines calls with controlling + results, but uses the term 'function with controlling result' without an + explicit definition. - RM References: 4.03.01 (16) + RM References: 3.09.02 (2/2) -.. index:: AI-0220 (Ada 2012 feature) +.. index:: AI-0077 (Ada 2012 feature) -* *AI-0220 Needed components for aggregates (0000-00-00)* +* *AI-0077 Limited withs and scope of declarations (0000-00-00)* - This AI addresses a wording problem in the RM that appears to permit some - complex cases of aggregates with nonstatic discriminants. GNAT has always - implemented the intended semantics. + This AI clarifies that a declaration does not include a context clause, + and confirms that it is illegal to have a context in which both a limited + and a nonlimited view of a package are accessible. Such double visibility + was always rejected by GNAT. - RM References: 4.03.01 (17) + RM References: 10.01.02 (12/2) 10.01.02 (21/2) 10.01.02 (22/2) -.. index:: AI-0147 (Ada 2012 feature) +.. index:: AI-0078 (Ada 2012 feature) -* *AI-0147 Conditional expressions (2009-03-29)* +* *AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)* - Conditional expressions are permitted. The form of such an expression is: + In Ada 2012, compilers are required to support unchecked conversion where the + target alignment is a multiple of the source alignment. GNAT always supported + this case (and indeed all cases of differing alignments, doing copies where + required if the alignment was reduced). - :: + RM References: 13.09 (7) - (if expr then expr {elsif expr then expr} [else expr]) +.. index:: AI-0079 (Ada 2012 feature) - The parentheses can be omitted in contexts where parentheses are present - anyway, such as subprogram arguments and pragma arguments. If the **else** - clause is omitted, **else** *True* is assumed; - thus ``(if A then B)`` is a way to conveniently represent - *(A implies B)* in standard logic. +* *AI-0079 Allow other_format characters in source (2010-07-10)* - RM References: 4.03.03 (15) 4.04 (1) 4.04 (7) 4.05.07 (0) 4.07 (2) - 4.07 (3) 4.09 (12) 4.09 (33) 5.03 (3) 5.03 (4) 7.05 (2.1/2) + Wide characters in the unicode category *other_format* are now allowed in + source programs between tokens, but not within a token such as an identifier. -.. index:: AI-0037 (Ada 2012 feature) + RM References: 2.01 (4/2) 2.02 (7) -* *AI-0037 Out-of-range box associations in aggregate (0000-00-00)* +.. index:: AI-0080 (Ada 2012 feature) - This AI confirms that an association of the form ``Indx => <>`` in an - array aggregate must raise ``Constraint_Error`` if ``Indx`` - is out of range. The RM specified a range check on other associations, but - not when the value of the association was defaulted. GNAT has always inserted - a constraint check on the index value. +* *AI-0080 'View of' not needed if clear from context (0000-00-00)* - RM References: 4.03.03 (29) + This is an editorial change only, described as non-testable in the AI. -.. index:: AI-0123 (Ada 2012 feature) + RM References: 3.01 (7) -* *AI-0123 Composability of equality (2010-04-13)* +.. index:: AI-0087 (Ada 2012 feature) - Equality of untagged record composes, so that the predefined equality for a - composite type that includes a component of some untagged record type - ``R`` uses the equality operation of ``R`` (which may be user-defined - or predefined). This makes the behavior of untagged records identical to that - of tagged types in this respect. +* *AI-0087 Actual for formal nonlimited derived type (2010-07-15)* - This change is an incompatibility with previous versions of Ada, but it - corrects a non-uniformity that was often a source of confusion. Analysis of - a large number of industrial programs indicates that in those rare cases - where a composite type had an untagged record component with a user-defined - equality, either there was no use of the composite equality, or else the code - expected the same composability as for tagged types, and thus had a bug that - would be fixed by this change. + The actual for a formal nonlimited derived type cannot be limited. In + particular, a formal derived type that extends a limited interface but which + is not explicitly limited cannot be instantiated with a limited type. - RM References: 4.05.02 (9.7/2) 4.05.02 (14) 4.05.02 (15) 4.05.02 (24) - 8.05.04 (8) + RM References: 7.05 (5/2) 12.05.01 (5.1/2) .. index:: AI-0088 (Ada 2012 feature) @@ -491,128 +484,100 @@ Supported Aspect Source RM References: 4.05.06 (11) -.. index:: AI-0188 (Ada 2012 feature) - -* *AI-0188 Case expressions (2010-01-09)* - - Case expressions are permitted. This allows use of constructs such as: - - .. code-block:: ada - - X := (case Y is when 1 => 2, when 2 => 3, when others => 31) - - RM References: 4.05.07 (0) 4.05.08 (0) 4.09 (12) 4.09 (33) - -.. index:: AI-0104 (Ada 2012 feature) - -* *AI-0104 Null exclusion and uninitialized allocator (2010-07-15)* - - The assignment ``Ptr := new not null Some_Ptr;`` will raise - ``Constraint_Error`` because the default value of the allocated object is - **null**. This useless construct is illegal in Ada 2012. - - RM References: 4.08 (2) - -.. index:: AI-0157 (Ada 2012 feature) - -* *AI-0157 Allocation/Deallocation from empty pool (2010-07-11)* - - Allocation and Deallocation from an empty storage pool (i.e. allocation or - deallocation of a pointer for which a static storage size clause of zero - has been given) is now illegal and is detected as such. GNAT - previously gave a warning but not an error. - - RM References: 4.08 (5.3/2) 13.11.02 (4) 13.11.02 (17) - -.. index:: AI-0179 (Ada 2012 feature) - -* *AI-0179 Statement not required after label (2010-04-10)* +.. index:: AI-0091 (Ada 2012 feature) - It is not necessary to have a statement following a label, so a label - can appear at the end of a statement sequence without the need for putting a - null statement afterwards, but it is not allowable to have only labels and - no real statements in a statement sequence. +* *AI-0091 Do not allow other_format in identifiers (0000-00-00)* - RM References: 5.01 (2) + Wide characters in the unicode category *other_format* are not permitted + within an identifier, since this can be a security problem. The error + message for this case has been improved to be more specific, but GNAT has + never allowed such characters to appear in identifiers. -.. index:: AI-0139-2 (Ada 2012 feature) + RM References: 2.03 (3.1/2) 2.03 (4/2) 2.03 (5/2) 2.03 (5.1/2) 2.03 (5.2/2) 2.03 (5.3/2) 2.09 (2/2) -* *AI-0139-2 Syntactic sugar for iterators (2010-09-29)* +.. index:: AI-0093 (Ada 2012 feature) - The new syntax for iterating over arrays and containers is now implemented. - Iteration over containers is for now limited to read-only iterators. Only - default iterators are supported, with the syntax: ``for Elem of C``. +* *AI-0093 Additional rules use immutably limited (0000-00-00)* - RM References: 5.05 + This is an editorial change only, to make more widespread use of the Ada 2012 + 'immutably limited'. -.. index:: AI-0134 (Ada 2012 feature) + RM References: 3.03 (23.4/3) -* *AI-0134 Profiles must match for full conformance (0000-00-00)* +.. index:: AI-0095 (Ada 2012 feature) - For full conformance, the profiles of anonymous-access-to-subprogram - parameters must match. GNAT has always enforced this rule. +* *AI-0095 Address of intrinsic subprograms (0000-00-00)* - RM References: 6.03.01 (18) + The prefix of ``'Address`` cannot statically denote a subprogram with + convention ``Intrinsic``. The use of the ``Address`` attribute raises + ``Program_Error`` if the prefix denotes a subprogram with convention + ``Intrinsic``. -.. index:: AI-0207 (Ada 2012 feature) + RM References: 13.03 (11/1) -* *AI-0207 Mode conformance and access constant (0000-00-00)* +.. index:: AI-0096 (Ada 2012 feature) - This AI confirms that access_to_constant indication must match for mode - conformance. This was implemented in GNAT when the qualifier was originally - introduced in Ada 2005. +* *AI-0096 Deriving from formal private types (2010-07-20)* - RM References: 6.03.01 (16/2) + In general it is illegal for a type derived from a formal limited type to be + nonlimited. This AI makes an exception to this rule: derivation is legal + if it appears in the private part of the generic, and the formal type is not + tagged. If the type is tagged, the legality check must be applied to the + private part of the package. -.. index:: AI-0046 (Ada 2012 feature) + RM References: 3.04 (5.1/2) 6.02 (7) -* *AI-0046 Null exclusion match for full conformance (2010-07-17)* +.. index:: AI-0097 (Ada 2012 feature) - For full conformance, in the case of access parameters, the null exclusion - must match (either both or neither must have ``not null``). +* *AI-0097 Treatment of abstract null extension (2010-07-19)* - RM References: 6.03.02 (18) + The RM as written implied that in some cases it was possible to create an + object of an abstract type, by having an abstract extension inherit a non- + abstract constructor from its parent type. This mistake has been corrected + in GNAT and in the RM, and this construct is now illegal. -.. index:: AI-0118 (Ada 2012 feature) + RM References: 3.09.03 (4/2) -* *AI-0118 The association of parameter associations (0000-00-00)* +.. index:: AI-0098 (Ada 2012 feature) - This AI clarifies the rules for named associations in subprogram calls and - generic instantiations. The rules have been in place since Ada 83. +* *AI-0098 Anonymous subprogram access restrictions (0000-00-00)* - RM References: 6.04.01 (2) 12.03 (9) + An unintentional omission in the RM implied some inconsistent restrictions on + the use of anonymous access to subprogram values. These restrictions were not + intentional, and have never been enforced by GNAT. -.. index:: AI-0196 (Ada 2012 feature) + RM References: 3.10.01 (6) 3.10.01 (9.2/2) -* *AI-0196 Null exclusion tests for out parameters (0000-00-00)* +.. index:: AI-0099 (Ada 2012 feature) - Null exclusion checks are not made for ``out`` parameters when - evaluating the actual parameters. GNAT has never generated these checks. +* *AI-0099 Tag determines whether finalization needed (0000-00-00)* - RM References: 6.04.01 (13) + This AI clarifies that 'needs finalization' is part of dynamic semantics, + and therefore depends on the run-time characteristics of an object (i.e. its + tag) and not on its nominal type. As the AI indicates: "we do not expect + this to affect any implementation''. -.. index:: AI-0015 (Ada 2012 feature) + RM References: 7.06.01 (6) 7.06.01 (7) 7.06.01 (8) 7.06.01 (9/2) -* *AI-0015 Constant return objects (0000-00-00)* +.. index:: AI-0100 (Ada 2012 feature) - The return object declared in an *extended_return_statement* may be - declared constant. This was always intended, and GNAT has always allowed it. +* *AI-0100 Placement of pragmas (2010-07-01)* - RM References: 6.05 (2.1/2) 3.03 (10/2) 3.03 (21) 6.05 (5/2) - 6.05 (5.7/2) + This AI is an earlier version of AI-163. It simplifies the rules + for legal placement of pragmas. In the case of lists that allow pragmas, if + the list may have no elements, then the list may consist solely of pragmas. -.. index:: AI-0032 (Ada 2012 feature) + RM References: 2.08 (7) -* *AI-0032 Extended return for class-wide functions (0000-00-00)* +.. index:: AI-0102 (Ada 2012 feature) - If a function returns a class-wide type, the object of an extended return - statement can be declared with a specific type that is covered by the class- - wide type. This has been implemented in GNAT since the introduction of - extended returns. Note AI-0103 complements this AI by imposing matching - rules for constrained return types. +* *AI-0102 Some implicit conversions are illegal (0000-00-00)* - RM References: 6.05 (5.2/2) 6.05 (5.3/2) 6.05 (5.6/2) 6.05 (5.8/2) - 6.05 (8/2) + It is illegal to assign an anonymous access constant to an anonymous access + variable. The RM did not have a clear rule to prevent this, but GNAT has + always generated an error for this usage. + + RM References: 3.07 (16) 3.07.01 (9) 6.04.01 (6) 8.06 (27/2) .. index:: AI-0103 (Ada 2012 feature) @@ -624,178 +589,170 @@ Supported Aspect Source RM References: 6.05 (5.2/2) -.. index:: AI-0058 (Ada 2012 feature) - -* *AI-0058 Abnormal completion of an extended return (0000-00-00)* - - The RM had some incorrect wording implying wrong treatment of abnormal - completion in an extended return. GNAT has always implemented the intended - correct semantics as described by this AI. - - RM References: 6.05 (22/2) +.. index:: AI-0104 (Ada 2012 feature) -.. index:: AI-0050 (Ada 2012 feature) +* *AI-0104 Null exclusion and uninitialized allocator (2010-07-15)* -* *AI-0050 Raising Constraint_Error early for function call (0000-00-00)* + The assignment ``Ptr := new not null Some_Ptr;`` will raise + ``Constraint_Error`` because the default value of the allocated object is + **null**. This useless construct is illegal in Ada 2012. - The implementation permissions for raising ``Constraint_Error`` early on a function call - when it was clear an exception would be raised were over-permissive and allowed - mishandling of discriminants in some cases. GNAT did - not take advantage of these incorrect permissions in any case. + RM References: 4.08 (2) - RM References: 6.05 (24/2) +.. index:: AI-0106 (Ada 2012 feature) -.. index:: AI-0125 (Ada 2012 feature) +* *AI-0106 No representation pragmas on generic formals (0000-00-00)* -* *AI-0125 Nonoverridable operations of an ancestor (2010-09-28)* + The RM appeared to allow representation pragmas on generic formal parameters, + but this was not intended, and GNAT has never permitted this usage. - In Ada 2012, the declaration of a primitive operation of a type extension - or private extension can also override an inherited primitive that is not - visible at the point of this declaration. + RM References: 13.01 (9.1/1) - RM References: 7.03.01 (6) 8.03 (23) 8.03.01 (5/2) 8.03.01 (6/2) +.. index:: AI-0108 (Ada 2012 feature) -.. index:: AI-0062 (Ada 2012 feature) +* *AI-0108 Limited incomplete view and discriminants (0000-00-00)* -* *AI-0062 Null exclusions and deferred constants (0000-00-00)* + This AI confirms that an incomplete type from a limited view does not have + discriminants. This has always been the case in GNAT. - A full constant may have a null exclusion even if its associated deferred - constant does not. GNAT has always allowed this. + RM References: 10.01.01 (12.3/2) - RM References: 7.04 (6/2) 7.04 (7.1/2) +.. index:: AI-0109 (Ada 2012 feature) -.. index:: AI-0178 (Ada 2012 feature) +* *AI-0109 Redundant check in S'Class'Input (0000-00-00)* -* *AI-0178 Incomplete views are limited (0000-00-00)* + This AI is an editorial change only. It removes the need for a tag check + that can never fail. - This AI clarifies the role of incomplete views and plugs an omission in the - RM. GNAT always correctly restricted the use of incomplete views and types. + RM References: 13.13.02 (34/2) - RM References: 7.05 (3/2) 7.05 (6/2) +.. index:: AI-0112 (Ada 2012 feature) -.. index:: AI-0087 (Ada 2012 feature) +* *AI-0112 Detection of duplicate pragmas (2010-07-24)* -* *AI-0087 Actual for formal nonlimited derived type (2010-07-15)* + This AI concerns giving names to various representation aspects, but the + practical effect is simply to make the use of duplicate + ``Atomic[_Components]``, + ``Volatile[_Components]``, and + ``Independent[_Components]`` pragmas illegal, and GNAT + now performs this required check. - The actual for a formal nonlimited derived type cannot be limited. In - particular, a formal derived type that extends a limited interface but which - is not explicitly limited cannot be instantiated with a limited type. + RM References: 13.01 (8) - RM References: 7.05 (5/2) 12.05.01 (5.1/2) +.. index:: AI-0114 (Ada 2012 feature) -.. index:: AI-0099 (Ada 2012 feature) +* *AI-0114 Classification of letters (0000-00-00)* -* *AI-0099 Tag determines whether finalization needed (0000-00-00)* + The code points 170 (``FEMININE ORDINAL INDICATOR``), + 181 (``MICRO SIGN``), and + 186 (``MASCULINE ORDINAL INDICATOR``) are technically considered + lower case letters by Unicode. + However, they are not allowed in identifiers, and they + return ``False`` to ``Ada.Characters.Handling.Is_Letter/Is_Lower``. + This behavior is consistent with that defined in Ada 95. - This AI clarifies that 'needs finalization' is part of dynamic semantics, - and therefore depends on the run-time characteristics of an object (i.e. its - tag) and not on its nominal type. As the AI indicates: "we do not expect - this to affect any implementation''. + RM References: A.03.02 (59) A.04.06 (7) - RM References: 7.06.01 (6) 7.06.01 (7) 7.06.01 (8) 7.06.01 (9/2) +.. index:: AI-0116 (Ada 2012 feature) -.. index:: AI-0064 (Ada 2012 feature) +* *AI-0116 Alignment of class-wide objects (0000-00-00)* -* *AI-0064 Redundant finalization rule (0000-00-00)* + This AI requires that the alignment of a class-wide object be no greater + than the alignment of any type in the class. GNAT has always followed this + recommendation. - This is an editorial change only. The intended behavior is already checked - by an existing ACATS test, which GNAT has always executed correctly. + RM References: 13.03 (29) 13.11 (16) - RM References: 7.06.01 (17.1/1) +.. index:: AI-0118 (Ada 2012 feature) -.. index:: AI-0026 (Ada 2012 feature) +* *AI-0118 The association of parameter associations (0000-00-00)* -* *AI-0026 Missing rules for Unchecked_Union (2010-07-07)* + This AI clarifies the rules for named associations in subprogram calls and + generic instantiations. The rules have been in place since Ada 83. - Record representation clauses concerning Unchecked_Union types cannot mention - the discriminant of the type. The type of a component declared in the variant - part of an Unchecked_Union cannot be controlled, have controlled components, - nor have protected or task parts. If an Unchecked_Union type is declared - within the body of a generic unit or its descendants, then the type of a - component declared in the variant part cannot be a formal private type or a - formal private extension declared within the same generic unit. + RM References: 6.04.01 (2) 12.03 (9) - RM References: 7.06 (9.4/2) B.03.03 (9/2) B.03.03 (10/2) +.. index:: AI-0120 (Ada 2012 feature) -.. index:: AI-0205 (Ada 2012 feature) +* *AI-0120 Constant instance of protected object (0000-00-00)* -* *AI-0205 Extended return declares visible name (0000-00-00)* + This is an RM editorial change only. The section that lists objects that are + constant failed to include the current instance of a protected object + within a protected function. This has always been treated as a constant + in GNAT. - This AI corrects a simple omission in the RM. Return objects have always - been visible within an extended return statement. + RM References: 3.03 (21) - RM References: 8.03 (17) +.. index:: AI-0122 (Ada 2012 feature) -.. index:: AI-0042 (Ada 2012 feature) +* *AI-0122 Private with and children of generics (0000-00-00)* -* *AI-0042 Overriding versus implemented-by (0000-00-00)* + This AI clarifies the visibility of private children of generic units within + instantiations of a parent. GNAT has always handled this correctly. - This AI fixes a wording gap in the RM. An operation of a synchronized - interface can be implemented by a protected or task entry, but the abstract - operation is not being overridden in the usual sense, and it must be stated - separately that this implementation is legal. This has always been the case - in GNAT. + RM References: 10.01.02 (12/2) - RM References: 9.01 (9.2/2) 9.04 (11.1/2) +.. index:: AI-0123 (Ada 2012 feature) -.. index:: AI-0030 (Ada 2012 feature) +* *AI-0123 Composability of equality (2010-04-13)* -* *AI-0030 Requeue on synchronized interfaces (2010-07-19)* + Equality of untagged record composes, so that the predefined equality for a + composite type that includes a component of some untagged record type + ``R`` uses the equality operation of ``R`` (which may be user-defined + or predefined). This makes the behavior of untagged records identical to that + of tagged types in this respect. - Requeue is permitted to a protected, synchronized or task interface primitive - providing it is known that the overriding operation is an entry. Otherwise - the requeue statement has the same effect as a procedure call. Use of pragma - ``Implemented`` provides a way to impose a static requirement on the - overriding operation by adhering to one of the implementation kinds: entry, - protected procedure or any of the above. + This change is an incompatibility with previous versions of Ada, but it + corrects a non-uniformity that was often a source of confusion. Analysis of + a large number of industrial programs indicates that in those rare cases + where a composite type had an untagged record component with a user-defined + equality, either there was no use of the composite equality, or else the code + expected the same composability as for tagged types, and thus had a bug that + would be fixed by this change. - RM References: 9.05 (9) 9.05.04 (2) 9.05.04 (3) 9.05.04 (5) - 9.05.04 (6) 9.05.04 (7) 9.05.04 (12) + RM References: 4.05.02 (9.7/2) 4.05.02 (14) 4.05.02 (15) 4.05.02 (24) + 8.05.04 (8) -.. index:: AI-0201 (Ada 2012 feature) +.. index:: AI-0125 (Ada 2012 feature) -* *AI-0201 Independence of atomic object components (2010-07-22)* +* *AI-0125 Nonoverridable operations of an ancestor (2010-09-28)* - If an Atomic object has a pragma ``Pack`` or a ``Component_Size`` - attribute, then individual components may not be addressable by independent - tasks. However, if the representation clause has no effect (is confirming), - then independence is not compromised. Furthermore, in GNAT, specification of - other appropriately addressable component sizes (e.g. 16 for 8-bit - characters) also preserves independence. GNAT now gives very clear warnings - both for the declaration of such a type, and for any assignment to its components. + In Ada 2012, the declaration of a primitive operation of a type extension + or private extension can also override an inherited primitive that is not + visible at the point of this declaration. - RM References: 9.10 (1/3) C.06 (22/2) C.06 (23/2) + RM References: 7.03.01 (6) 8.03 (23) 8.03.01 (5/2) 8.03.01 (6/2) -.. index:: AI-0009 (Ada 2012 feature) +.. index:: AI-0126 (Ada 2012 feature) -* *AI-0009 Pragma Independent[_Components] (2010-07-23)* +* *AI-0126 Dispatching with no declared operation (0000-00-00)* - This AI introduces the new pragmas ``Independent`` and - ``Independent_Components``, - which control guaranteeing independence of access to objects and components. - The AI also requires independence not unaffected by confirming rep clauses. + This AI clarifies dispatching rules, and simply confirms that dispatching + executes the operation of the parent type when there is no explicitly or + implicitly declared operation for the descendant type. This has always been + the case in all versions of GNAT. - RM References: 9.10 (1) 13.01 (15/1) 13.02 (9) 13.03 (13) C.06 (2) - C.06 (4) C.06 (6) C.06 (9) C.06 (13) C.06 (14) + RM References: 3.09.02 (20/2) 3.09.02 (20.1/2) 3.09.02 (20.2/2) -.. index:: AI-0072 (Ada 2012 feature) +.. index:: AI-0127 (Ada 2012 feature) -* *AI-0072 Task signalling using 'Terminated (0000-00-00)* +* *AI-0127 Adding Locale Capabilities (2010-09-29)* - This AI clarifies that task signalling for reading ``'Terminated`` only - occurs if the result is True. GNAT semantics has always been consistent with - this notion of task signalling. + This package provides an interface for identifying the current locale. - RM References: 9.10 (6.1/1) + RM References: A.19 A.19.01 A.19.02 A.19.03 A.19.05 A.19.06 + A.19.07 A.19.08 A.19.09 A.19.10 A.19.11 A.19.12 A.19.13 -.. index:: AI-0108 (Ada 2012 feature) +.. index:: AI-0128 (Ada 2012 feature) -* *AI-0108 Limited incomplete view and discriminants (0000-00-00)* +* *AI-0128 Inequality is a primitive operation (0000-00-00)* - This AI confirms that an incomplete type from a limited view does not have - discriminants. This has always been the case in GNAT. + If an equality operator ("=") is declared for a type, then the implicitly + declared inequality operator ("/=") is a primitive operation of the type. + This is the only reasonable interpretation, and is the one always implemented + by GNAT, but the RM was not entirely clear in making this point. - RM References: 10.01.01 (12.3/2) + RM References: 3.02.03 (6) 6.06 (6) .. index:: AI-0129 (Ada 2012 feature) @@ -809,35 +766,6 @@ Supported Aspect Source RM References: 10.01.01 (12.2/2) 10.01.01 (12.3/2) -.. index:: AI-0077 (Ada 2012 feature) - -* *AI-0077 Limited withs and scope of declarations (0000-00-00)* - - This AI clarifies that a declaration does not include a context clause, - and confirms that it is illegal to have a context in which both a limited - and a nonlimited view of a package are accessible. Such double visibility - was always rejected by GNAT. - - RM References: 10.01.02 (12/2) 10.01.02 (21/2) 10.01.02 (22/2) - -.. index:: AI-0122 (Ada 2012 feature) - -* *AI-0122 Private with and children of generics (0000-00-00)* - - This AI clarifies the visibility of private children of generic units within - instantiations of a parent. GNAT has always handled this correctly. - - RM References: 10.01.02 (12/2) - -.. index:: AI-0040 (Ada 2012 feature) - -* *AI-0040 Limited with clauses on descendant (0000-00-00)* - - This AI confirms that a limited with clause in a child unit cannot name - an ancestor of the unit. This has always been checked in GNAT. - - RM References: 10.01.02 (20/2) - .. index:: AI-0132 (Ada 2012 feature) * *AI-0132 Placement of library unit pragmas (0000-00-00)* @@ -848,175 +776,173 @@ Supported Aspect Source RM References: 10.01.05 (7) -.. index:: AI-0034 (Ada 2012 feature) - -* *AI-0034 Categorization of limited views (0000-00-00)* - - The RM makes certain limited with clauses illegal because of categorization - considerations, when the corresponding normal with would be legal. This is - not intended, and GNAT has always implemented the recommended behavior. - - RM References: 10.02.01 (11/1) 10.02.01 (17/2) - -.. index:: AI-0035 (Ada 2012 feature) +.. index:: AI-0134 (Ada 2012 feature) -* *AI-0035 Inconsistencies with Pure units (0000-00-00)* +* *AI-0134 Profiles must match for full conformance (0000-00-00)* - This AI remedies some inconsistencies in the legality rules for Pure units. - Derived access types are legal in a pure unit (on the assumption that the - rule for a zero storage pool size has been enforced on the ancestor type). - The rules are enforced in generic instances and in subunits. GNAT has always - implemented the recommended behavior. + For full conformance, the profiles of anonymous-access-to-subprogram + parameters must match. GNAT has always enforced this rule. - RM References: 10.02.01 (15.1/2) 10.02.01 (15.4/2) 10.02.01 (15.5/2) 10.02.01 (17/2) + RM References: 6.03.01 (18) -.. index:: AI-0219 (Ada 2012 feature) +.. index:: AI-0137 (Ada 2012 feature) -* *AI-0219 Pure permissions and limited parameters (2010-05-25)* +* *AI-0137 String encoding package (2010-03-25)* - This AI refines the rules for the cases with limited parameters which do not - allow the implementations to omit 'redundant'. GNAT now properly conforms - to the requirements of this binding interpretation. + The packages ``Ada.Strings.UTF_Encoding``, together with its child + packages, ``Conversions``, ``Strings``, ``Wide_Strings``, + and ``Wide_Wide_Strings`` have been + implemented. These packages (whose documentation can be found in the spec + files :file:`a-stuten.ads`, :file:`a-suenco.ads`, :file:`a-suenst.ads`, + :file:`a-suewst.ads`, :file:`a-suezst.ads`) allow encoding and decoding of + ``String``, ``Wide_String``, and ``Wide_Wide_String`` + values using UTF coding schemes (including UTF-8, UTF-16LE, UTF-16BE, and + UTF-16), as well as conversions between the different UTF encodings. With + the exception of ``Wide_Wide_Strings``, these packages are available in + Ada 95 and Ada 2005 mode as well as Ada 2012 mode. + The ``Wide_Wide_Strings`` package + is available in Ada 2005 mode as well as Ada 2012 mode (but not in Ada 95 + mode since it uses ``Wide_Wide_Character``). - RM References: 10.02.01 (18/2) + RM References: A.04.11 -.. index:: AI-0043 (Ada 2012 feature) +.. index:: AI-0139-2 (Ada 2012 feature) -* *AI-0043 Rules about raising exceptions (0000-00-00)* +* *AI-0139-2 Syntactic sugar for iterators (2010-09-29)* - This AI covers various omissions in the RM regarding the raising of - exceptions. GNAT has always implemented the intended semantics. + The new syntax for iterating over arrays and containers is now implemented. + Iteration over containers is for now limited to read-only iterators. Only + default iterators are supported, with the syntax: ``for Elem of C``. - RM References: 11.04.01 (10.1/2) 11 (2) + RM References: 5.05 -.. index:: AI-0200 (Ada 2012 feature) +.. index:: AI-0146 (Ada 2012 feature) -* *AI-0200 Mismatches in formal package declarations (0000-00-00)* +* *AI-0146 Type invariants (2009-09-21)* - This AI plugs a gap in the RM which appeared to allow some obviously intended - illegal instantiations. GNAT has never allowed these instantiations. + Type invariants may be specified for private types using the aspect notation. + Aspect ``Type_Invariant`` may be specified for any private type, + ``Type_Invariant'Class`` can + only be specified for tagged types, and is inherited by any descendent of the + tagged types. The invariant is a boolean expression that is tested for being + true in the following situations: conversions to the private type, object + declarations for the private type that are default initialized, and + [**in**] **out** + parameters and returned result on return from any primitive operation for + the type that is visible to a client. + GNAT defines the synonyms ``Invariant`` for ``Type_Invariant`` and + ``Invariant'Class`` for ``Type_Invariant'Class``. - RM References: 12.07 (16) + RM References: 13.03.03 (00) -.. index:: AI-0112 (Ada 2012 feature) +.. index:: AI-0147 (Ada 2012 feature) -* *AI-0112 Detection of duplicate pragmas (2010-07-24)* +* *AI-0147 Conditional expressions (2009-03-29)* - This AI concerns giving names to various representation aspects, but the - practical effect is simply to make the use of duplicate - ``Atomic[_Components]``, - ``Volatile[_Components]``, and - ``Independent[_Components]`` pragmas illegal, and GNAT - now performs this required check. + Conditional expressions are permitted. The form of such an expression is: - RM References: 13.01 (8) + :: -.. index:: AI-0106 (Ada 2012 feature) + (if expr then expr {elsif expr then expr} [else expr]) -* *AI-0106 No representation pragmas on generic formals (0000-00-00)* + The parentheses can be omitted in contexts where parentheses are present + anyway, such as subprogram arguments and pragma arguments. If the **else** + clause is omitted, **else** *True* is assumed; + thus ``(if A then B)`` is a way to conveniently represent + *(A implies B)* in standard logic. - The RM appeared to allow representation pragmas on generic formal parameters, - but this was not intended, and GNAT has never permitted this usage. + RM References: 4.03.03 (15) 4.04 (1) 4.04 (7) 4.05.07 (0) 4.07 (2) + 4.07 (3) 4.09 (12) 4.09 (33) 5.03 (3) 5.03 (4) 7.05 (2.1/2) - RM References: 13.01 (9.1/1) +.. index:: AI-0152 (Ada 2012 feature) -.. index:: AI-0012 (Ada 2012 feature) +* *AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)* -* *AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)* + Restriction ``No_Anonymous_Allocators`` prevents the use of allocators + where the type of the returned value is an anonymous access type. - It is now illegal to give an inappropriate component size or a pragma - ``Pack`` that attempts to change the component size in the case of atomic - or aliased components. Previously GNAT ignored such an attempt with a - warning. + RM References: H.04 (8/1) - RM References: 13.02 (6.1/2) 13.02 (7) C.06 (10) C.06 (11) C.06 (21) +.. index:: AI-0157 (Ada 2012 feature) -.. index:: AI-0039 (Ada 2012 feature) +* *AI-0157 Allocation/Deallocation from empty pool (2010-07-11)* -* *AI-0039 Stream attributes cannot be dynamic (0000-00-00)* + Allocation and Deallocation from an empty storage pool (i.e. allocation or + deallocation of a pointer for which a static storage size clause of zero + has been given) is now illegal and is detected as such. GNAT + previously gave a warning but not an error. - The RM permitted the use of dynamic expressions (such as ``ptr.all``)` - for stream attributes, but these were never useful and are now illegal. GNAT - has always regarded such expressions as illegal. + RM References: 4.08 (5.3/2) 13.11.02 (4) 13.11.02 (17) - RM References: 13.03 (4) 13.03 (6) 13.13.02 (38/2) +.. index:: AI-0158 (Ada 2012 feature) -.. index:: AI-0095 (Ada 2012 feature) +* *AI-0158 Generalizing membership tests (2010-09-16)* -* *AI-0095 Address of intrinsic subprograms (0000-00-00)* + This AI extends the syntax of membership tests to simplify complex conditions + that can be expressed as membership in a subset of values of any type. It + introduces syntax for a list of expressions that may be used in loop contexts + as well. - The prefix of ``'Address`` cannot statically denote a subprogram with - convention ``Intrinsic``. The use of the ``Address`` attribute raises - ``Program_Error`` if the prefix denotes a subprogram with convention - ``Intrinsic``. + RM References: 3.08.01 (5) 4.04 (3) 4.05.02 (3) 4.05.02 (5) 4.05.02 (27) - RM References: 13.03 (11/1) +.. index:: AI-0161 (Ada 2012 feature) -.. index:: AI-0116 (Ada 2012 feature) +* *AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)* -* *AI-0116 Alignment of class-wide objects (0000-00-00)* + A new restriction ``No_Default_Stream_Attributes`` prevents the use of any + of the default stream attributes for elementary types. If this restriction is + in force, then it is necessary to provide explicit subprograms for any + stream attributes used. - This AI requires that the alignment of a class-wide object be no greater - than the alignment of any type in the class. GNAT has always followed this - recommendation. + RM References: 13.12.01 (4/2) 13.13.02 (40/2) 13.13.02 (52/2) - RM References: 13.03 (29) 13.11 (16) +.. index:: AI-0162 (Ada 2012 feature) -.. index:: AI-0146 (Ada 2012 feature) +* *AI-0162 Incomplete type completed by partial view (2010-09-15)* -* *AI-0146 Type invariants (2009-09-21)* + Incomplete types are made more useful by allowing them to be completed by + private types and private extensions. - Type invariants may be specified for private types using the aspect notation. - Aspect ``Type_Invariant`` may be specified for any private type, - ``Type_Invariant'Class`` can - only be specified for tagged types, and is inherited by any descendent of the - tagged types. The invariant is a boolean expression that is tested for being - true in the following situations: conversions to the private type, object - declarations for the private type that are default initialized, and - [**in**] **out** - parameters and returned result on return from any primitive operation for - the type that is visible to a client. - GNAT defines the synonyms ``Invariant`` for ``Type_Invariant`` and - ``Invariant'Class`` for ``Type_Invariant'Class``. + RM References: 3.10.01 (2.5/2) 3.10.01 (2.6/2) 3.10.01 (3) 3.10.01 (4/2) - RM References: 13.03.03 (00) +.. index:: AI-0163 (Ada 2012 feature) -.. index:: AI-0078 (Ada 2012 feature) +* *AI-0163 Pragmas in place of null (2010-07-01)* -* *AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)* + A statement sequence may be composed entirely of pragmas. It is no longer + necessary to add a dummy ``null`` statement to make the sequence legal. - In Ada 2012, compilers are required to support unchecked conversion where the - target alignment is a multiple of the source alignment. GNAT always supported - this case (and indeed all cases of differing alignments, doing copies where - required if the alignment was reduced). + RM References: 2.08 (7) 2.08 (16) - RM References: 13.09 (7) +.. index:: AI-0171 (Ada 2012 feature) -.. index:: AI-0195 (Ada 2012 feature) +* *AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)* -* *AI-0195 Invalid value handling is implementation defined (2010-07-03)* + A new package ``System.Multiprocessors`` is added, together with the + definition of pragma ``CPU`` for controlling task affinity. A new no + dependence restriction, on ``System.Multiprocessors.Dispatching_Domains``, + is added to the Ravenscar profile. - The handling of invalid values is now designated to be implementation - defined. This is a documentation change only, requiring Annex M in the GNAT - Reference Manual to document this handling. - In GNAT, checks for invalid values are made - only when necessary to avoid erroneous behavior. Operations like assignments - which cannot cause erroneous behavior ignore the possibility of invalid - values and do not do a check. The date given above applies only to the - documentation change, this behavior has always been implemented by GNAT. + RM References: D.13.01 (4/2) D.16 - RM References: 13.09.01 (10) +.. index:: AI-0173 (Ada 2012 feature) -.. index:: AI-0193 (Ada 2012 feature) +* *AI-0173 Testing if tags represent abstract types (2010-07-03)* -* *AI-0193 Alignment of allocators (2010-09-16)* + The function ``Ada.Tags.Type_Is_Abstract`` returns ``True`` if invoked + with the tag of an abstract type, and ``False`` otherwise. - This AI introduces a new attribute ``Max_Alignment_For_Allocation``, - analogous to ``Max_Size_In_Storage_Elements``, but for alignment instead - of size. + RM References: 3.09 (7.4/2) 3.09 (12.4/2) - RM References: 13.11 (16) 13.11 (21) 13.11.01 (0) 13.11.01 (1) - 13.11.01 (2) 13.11.01 (3) +.. index:: AI-0176 (Ada 2012 feature) + +* *AI-0176 Quantified expressions (2010-09-29)* + + Both universally and existentially quantified expressions are implemented. + They use the new syntax for iterators proposed in AI05-139-2, as well as + the standard Ada loop syntax. + + RM References: 1.01.04 (12) 2.09 (2/2) 4.04 (7) 4.05.09 (0) .. index:: AI-0177 (Ada 2012 feature) @@ -1035,225 +961,321 @@ Supported Aspect Source RM References: 13.11.01 (3/2) -.. index:: AI-0033 (Ada 2012 feature) +.. index:: AI-0178 (Ada 2012 feature) -* *AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)* +* *AI-0178 Incomplete views are limited (0000-00-00)* - Neither of these two pragmas may appear within a generic template, because - the generic might be instantiated at other than the library level. + This AI clarifies the role of incomplete views and plugs an omission in the + RM. GNAT always correctly restricted the use of incomplete views and types. - RM References: 13.11.02 (16) C.03.01 (7/2) C.03.01 (8/2) + RM References: 7.05 (3/2) 7.05 (6/2) -.. index:: AI-0161 (Ada 2012 feature) +.. index:: AI-0179 (Ada 2012 feature) -* *AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)* +* *AI-0179 Statement not required after label (2010-04-10)* - A new restriction ``No_Default_Stream_Attributes`` prevents the use of any - of the default stream attributes for elementary types. If this restriction is - in force, then it is necessary to provide explicit subprograms for any - stream attributes used. + It is not necessary to have a statement following a label, so a label + can appear at the end of a statement sequence without the need for putting a + null statement afterwards, but it is not allowable to have only labels and + no real statements in a statement sequence. - RM References: 13.12.01 (4/2) 13.13.02 (40/2) 13.13.02 (52/2) + RM References: 5.01 (2) -.. index:: AI-0194 (Ada 2012 feature) +.. index:: AI-0181 (Ada 2012 feature) -* *AI-0194 Value of Stream_Size attribute (0000-00-00)* +* *AI-0181 Soft hyphen is a non-graphic character (2010-07-23)* - The ``Stream_Size`` attribute returns the default number of bits in the - stream representation of the given type. - This value is not affected by the presence - of stream subprogram attributes for the type. GNAT has always implemented - this interpretation. + From Ada 2005 on, soft hyphen is considered a non-graphic character, which + means that it has a special name (``SOFT_HYPHEN``) in conjunction with the + ``Image`` and ``Value`` attributes for the character types. Strictly + speaking this is an inconsistency with Ada 95, but in practice the use of + these attributes is so obscure that it will not cause problems. - RM References: 13.13.02 (1.2/2) + RM References: 3.05.02 (2/2) A.01 (35/2) A.03.03 (21) -.. index:: AI-0109 (Ada 2012 feature) +.. index:: AI-0182 (Ada 2012 feature) -* *AI-0109 Redundant check in S'Class'Input (0000-00-00)* +* *AI-0182 Additional forms for* ``Character'Value`` *(0000-00-00)* - This AI is an editorial change only. It removes the need for a tag check - that can never fail. + This AI allows ``Character'Value`` to accept the string ``'?'`` where + ``?`` is any character including non-graphic control characters. GNAT has + always accepted such strings. It also allows strings such as + ``HEX_00000041`` to be accepted, but GNAT does not take advantage of this + permission and raises ``Constraint_Error``, as is certainly still + permitted. - RM References: 13.13.02 (34/2) + RM References: 3.05 (56/2) -.. index:: AI-0007 (Ada 2012 feature) +.. index:: AI-0183 (Ada 2012 feature) -* *AI-0007 Stream read and private scalar types (0000-00-00)* +* *AI-0183 Aspect specifications (2010-08-16)* - The RM as written appeared to limit the possibilities of declaring read - attribute procedures for private scalar types. This limitation was not - intended, and has never been enforced by GNAT. + Aspect specifications have been fully implemented except for pre and post- + conditions, and type invariants, which have their own separate AI's. All + forms of declarations listed in the AI are supported. The following is a + list of the aspects supported (with GNAT implementation aspects marked) - RM References: 13.13.02 (50/2) 13.13.02 (51/2) +==================================== =========== +Supported Aspect Source +==================================== =========== + ``Ada_2005`` -- GNAT + ``Ada_2012`` -- GNAT + ``Address`` + ``Alignment`` + ``Atomic`` + ``Atomic_Components`` + ``Bit_Order`` + ``Component_Size`` + ``Contract_Cases`` -- GNAT + ``Discard_Names`` + ``External_Tag`` + ``Favor_Top_Level`` -- GNAT + ``Inline`` + ``Inline_Always`` -- GNAT + ``Invariant`` -- GNAT + ``Machine_Radix`` + ``No_Return`` + ``Object_Size`` -- GNAT + ``Pack`` + ``Persistent_BSS`` -- GNAT + ``Post`` + ``Pre`` + ``Predicate`` + ``Preelaborable_Initialization`` + ``Pure_Function`` -- GNAT + ``Remote_Access_Type`` -- GNAT + ``Shared`` -- GNAT + ``Size`` + ``Storage_Pool`` + ``Storage_Size`` + ``Stream_Size`` + ``Suppress`` + ``Suppress_Debug_Info`` -- GNAT + ``Test_Case`` -- GNAT + ``Thread_Local_Storage`` -- GNAT + ``Type_Invariant`` + ``Unchecked_Union`` + ``Universal_Aliasing`` -- GNAT + ``Unmodified`` -- GNAT + ``Unreferenced`` -- GNAT + ``Unreferenced_Objects`` -- GNAT + ``Unsuppress`` + ``Value_Size`` -- GNAT + ``Volatile`` + ``Volatile_Components`` + ``Warnings`` -- GNAT +==================================== =========== -.. index:: AI-0065 (Ada 2012 feature) + Note that for aspects with an expression, e.g. ``Size``, the expression is + treated like a default expression (visibility is analyzed at the point of + occurrence of the aspect, but evaluation of the expression occurs at the + freeze point of the entity involved). -* *AI-0065 Remote access types and external streaming (0000-00-00)* + RM References: 3.02.01 (3) 3.02.02 (2) 3.03.01 (2/2) 3.08 (6) + 3.09.03 (1.1/2) 6.01 (2/2) 6.07 (2/2) 9.05.02 (2/2) 7.01 (3) 7.03 + (2) 7.03 (3) 9.01 (2/2) 9.01 (3/2) 9.04 (2/2) 9.04 (3/2) + 9.05.02 (2/2) 11.01 (2) 12.01 (3) 12.03 (2/2) 12.04 (2/2) 12.05 (2) + 12.06 (2.1/2) 12.06 (2.2/2) 12.07 (2) 13.01 (0.1/2) 13.03 (5/1) + 13.03.01 (0) - This AI clarifies the fact that all remote access types support external - streaming. This fixes an obvious oversight in the definition of the - language, and GNAT always implemented the intended correct rules. +.. index:: AI-0185 (Ada 2012 feature) - RM References: 13.13.02 (52/2) +* *AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)* -.. index:: AI-0019 (Ada 2012 feature) + Two new packages ``Ada.Wide_[Wide_]Characters.Handling`` provide + classification functions for ``Wide_Character`` and + ``Wide_Wide_Character``, as well as providing + case folding routines for ``Wide_[Wide_]Character`` and + ``Wide_[Wide_]String``. -* *AI-0019 Freezing of primitives for tagged types (0000-00-00)* + RM References: A.03.05 (0) A.03.06 (0) - The RM suggests that primitive subprograms of a specific tagged type are - frozen when the tagged type is frozen. This would be an incompatible change - and is not intended. GNAT has never attempted this kind of freezing and its - behavior is consistent with the recommendation of this AI. +.. index:: AI-0188 (Ada 2012 feature) + +* *AI-0188 Case expressions (2010-01-09)* + + Case expressions are permitted. This allows use of constructs such as: + + .. code-block:: ada + + X := (case Y is when 1 => 2, when 2 => 3, when others => 31) + + RM References: 4.05.07 (0) 4.05.08 (0) 4.09 (12) 4.09 (33) + +.. index:: AI-0189 (Ada 2012 feature) + +* *AI-0189 No_Allocators_After_Elaboration (2010-01-23)* + + This AI introduces a new restriction ``No_Allocators_After_Elaboration``, + which says that no dynamic allocation will occur once elaboration is + completed. + In general this requires a run-time check, which is not required, and which + GNAT does not attempt. But the static cases of allocators in a task body or + in the body of the main program are detected and flagged at compile or bind + time. + + RM References: D.07 (19.1/2) H.04 (23.3/2) + +.. index:: AI-0190 (Ada 2012 feature) + +* *AI-0190 pragma Default_Storage_Pool (2010-09-15)* + + This AI introduces a new pragma ``Default_Storage_Pool``, which can be + used to control storage pools globally. + In particular, you can force every access + type that is used for allocation (**new**) to have an explicit storage pool, + or you can declare a pool globally to be used for all access types that lack + an explicit one. + + RM References: D.07 (8) + +.. index:: AI-0193 (Ada 2012 feature) + +* *AI-0193 Alignment of allocators (2010-09-16)* + + This AI introduces a new attribute ``Max_Alignment_For_Allocation``, + analogous to ``Max_Size_In_Storage_Elements``, but for alignment instead + of size. + + RM References: 13.11 (16) 13.11 (21) 13.11.01 (0) 13.11.01 (1) + 13.11.01 (2) 13.11.01 (3) + +.. index:: AI-0194 (Ada 2012 feature) + +* *AI-0194 Value of Stream_Size attribute (0000-00-00)* + + The ``Stream_Size`` attribute returns the default number of bits in the + stream representation of the given type. + This value is not affected by the presence + of stream subprogram attributes for the type. GNAT has always implemented + this interpretation. - RM References: 13.14 (2) 13.14 (3/1) 13.14 (8.1/1) 13.14 (10) 13.14 (14) 13.14 (15.1/2) + RM References: 13.13.02 (1.2/2) -.. index:: AI-0017 (Ada 2012 feature) +.. index:: AI-0195 (Ada 2012 feature) -* *AI-0017 Freezing and incomplete types (0000-00-00)* +* *AI-0195 Invalid value handling is implementation defined (2010-07-03)* - So-called 'Taft-amendment types' (i.e., types that are completed in package - bodies) are not frozen by the occurrence of bodies in the - enclosing declarative part. GNAT always implemented this properly. + The handling of invalid values is now designated to be implementation + defined. This is a documentation change only, requiring Annex M in the GNAT + Reference Manual to document this handling. + In GNAT, checks for invalid values are made + only when necessary to avoid erroneous behavior. Operations like assignments + which cannot cause erroneous behavior ignore the possibility of invalid + values and do not do a check. The date given above applies only to the + documentation change, this behavior has always been implemented by GNAT. - RM References: 13.14 (3/1) + RM References: 13.09.01 (10) -.. index:: AI-0060 (Ada 2012 feature) +.. index:: AI-0196 (Ada 2012 feature) -* *AI-0060 Extended definition of remote access types (0000-00-00)* +* *AI-0196 Null exclusion tests for out parameters (0000-00-00)* - This AI extends the definition of remote access types to include access - to limited, synchronized, protected or task class-wide interface types. - GNAT already implemented this extension. + Null exclusion checks are not made for ``out`` parameters when + evaluating the actual parameters. GNAT has never generated these checks. - RM References: A (4) E.02.02 (9/1) E.02.02 (9.2/1) E.02.02 (14/2) E.02.02 (18) + RM References: 6.04.01 (13) -.. index:: AI-0114 (Ada 2012 feature) +.. index:: AI-0198 (Ada 2012 feature) -* *AI-0114 Classification of letters (0000-00-00)* +* *AI-0198 Inheriting abstract operators (0000-00-00)* - The code points 170 (``FEMININE ORDINAL INDICATOR``), - 181 (``MICRO SIGN``), and - 186 (``MASCULINE ORDINAL INDICATOR``) are technically considered - lower case letters by Unicode. - However, they are not allowed in identifiers, and they - return ``False`` to ``Ada.Characters.Handling.Is_Letter/Is_Lower``. - This behavior is consistent with that defined in Ada 95. + This AI resolves a conflict between two rules involving inherited abstract + operations and predefined operators. If a derived numeric type inherits + an abstract operator, it overrides the predefined one. This interpretation + was always the one implemented in GNAT. - RM References: A.03.02 (59) A.04.06 (7) + RM References: 3.09.03 (4/3) -.. index:: AI-0185 (Ada 2012 feature) +.. index:: AI-0199 (Ada 2012 feature) -* *AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)* +* *AI-0199 Aggregate with anonymous access components (2010-07-14)* - Two new packages ``Ada.Wide_[Wide_]Characters.Handling`` provide - classification functions for ``Wide_Character`` and - ``Wide_Wide_Character``, as well as providing - case folding routines for ``Wide_[Wide_]Character`` and - ``Wide_[Wide_]String``. + A choice list in a record aggregate can include several components of + (distinct) anonymous access types as long as they have matching designated + subtypes. - RM References: A.03.05 (0) A.03.06 (0) + RM References: 4.03.01 (16) -.. index:: AI-0031 (Ada 2012 feature) +.. index:: AI-0200 (Ada 2012 feature) -* *AI-0031 Add From parameter to Find_Token (2010-07-25)* +* *AI-0200 Mismatches in formal package declarations (0000-00-00)* - A new version of ``Find_Token`` is added to all relevant string packages, - with an extra parameter ``From``. Instead of starting at the first - character of the string, the search for a matching Token starts at the - character indexed by the value of ``From``. - These procedures are available in all versions of Ada - but if used in versions earlier than Ada 2012 they will generate a warning - that an Ada 2012 subprogram is being used. + This AI plugs a gap in the RM which appeared to allow some obviously intended + illegal instantiations. GNAT has never allowed these instantiations. - RM References: A.04.03 (16) A.04.03 (67) A.04.03 (68/1) A.04.04 (51) - A.04.05 (46) + RM References: 12.07 (16) -.. index:: AI-0056 (Ada 2012 feature) +.. index:: AI-0201 (Ada 2012 feature) -* *AI-0056 Index on null string returns zero (0000-00-00)* +* *AI-0201 Independence of atomic object components (2010-07-22)* - The wording in the Ada 2005 RM implied an incompatible handling of the - ``Index`` functions, resulting in raising an exception instead of - returning zero in some situations. - This was not intended and has been corrected. - GNAT always returned zero, and is thus consistent with this AI. + If an Atomic object has a pragma ``Pack`` or a ``Component_Size`` + attribute, then individual components may not be addressable by independent + tasks. However, if the representation clause has no effect (is confirming), + then independence is not compromised. Furthermore, in GNAT, specification of + other appropriately addressable component sizes (e.g. 16 for 8-bit + characters) also preserves independence. GNAT now gives very clear warnings + both for the declaration of such a type, and for any assignment to its components. - RM References: A.04.03 (56.2/2) A.04.03 (58.5/2) + RM References: 9.10 (1/3) C.06 (22/2) C.06 (23/2) -.. index:: AI-0137 (Ada 2012 feature) +.. index:: AI-0203 (Ada 2012 feature) -* *AI-0137 String encoding package (2010-03-25)* +* *AI-0203 Extended return cannot be abstract (0000-00-00)* - The packages ``Ada.Strings.UTF_Encoding``, together with its child - packages, ``Conversions``, ``Strings``, ``Wide_Strings``, - and ``Wide_Wide_Strings`` have been - implemented. These packages (whose documentation can be found in the spec - files :file:`a-stuten.ads`, :file:`a-suenco.ads`, :file:`a-suenst.ads`, - :file:`a-suewst.ads`, :file:`a-suezst.ads`) allow encoding and decoding of - ``String``, ``Wide_String``, and ``Wide_Wide_String`` - values using UTF coding schemes (including UTF-8, UTF-16LE, UTF-16BE, and - UTF-16), as well as conversions between the different UTF encodings. With - the exception of ``Wide_Wide_Strings``, these packages are available in - Ada 95 and Ada 2005 mode as well as Ada 2012 mode. - The ``Wide_Wide_Strings`` package - is available in Ada 2005 mode as well as Ada 2012 mode (but not in Ada 95 - mode since it uses ``Wide_Wide_Character``). + A return_subtype_indication cannot denote an abstract subtype. GNAT has never + permitted such usage. - RM References: A.04.11 + RM References: 3.09.03 (8/3) -.. index:: AI-0038 (Ada 2012 feature) +.. index:: AI-0205 (Ada 2012 feature) -* *AI-0038 Minor errors in Text_IO (0000-00-00)* +* *AI-0205 Extended return declares visible name (0000-00-00)* - These are minor errors in the description on three points. The intent on - all these points has always been clear, and GNAT has always implemented the - correct intended semantics. + This AI corrects a simple omission in the RM. Return objects have always + been visible within an extended return statement. - RM References: A.10.05 (37) A.10.07 (8/1) A.10.07 (10) A.10.07 (12) A.10.08 (10) A.10.08 (24) + RM References: 8.03 (17) -.. index:: AI-0044 (Ada 2012 feature) +.. index:: AI-0206 (Ada 2012 feature) -* *AI-0044 Restrictions on container instantiations (0000-00-00)* +* *AI-0206 Remote types packages and preelaborate (2010-07-24)* - This AI places restrictions on allowed instantiations of generic containers. - These restrictions are not checked by the compiler, so there is nothing to - change in the implementation. This affects only the RM documentation. + Remote types packages are now allowed to depend on preelaborated packages. + This was formerly considered illegal. - RM References: A.18 (4/2) A.18.02 (231/2) A.18.03 (145/2) A.18.06 (56/2) A.18.08 (66/2) A.18.09 (79/2) A.18.26 (5/2) A.18.26 (9/2) + RM References: E.02.02 (6) -.. index:: AI-0127 (Ada 2012 feature) +.. index:: AI-0207 (Ada 2012 feature) -* *AI-0127 Adding Locale Capabilities (2010-09-29)* +* *AI-0207 Mode conformance and access constant (0000-00-00)* - This package provides an interface for identifying the current locale. + This AI confirms that access_to_constant indication must match for mode + conformance. This was implemented in GNAT when the qualifier was originally + introduced in Ada 2005. - RM References: A.19 A.19.01 A.19.02 A.19.03 A.19.05 A.19.06 - A.19.07 A.19.08 A.19.09 A.19.10 A.19.11 A.19.12 A.19.13 + RM References: 6.03.01 (16/2) -.. index:: AI-0002 (Ada 2012 feature) +.. index:: AI-0208 (Ada 2012 feature) -* *AI-0002 Export C with unconstrained arrays (0000-00-00)* +* *AI-0208 Characteristics of incomplete views (0000-00-00)* - The compiler is not required to support exporting an Ada subprogram with - convention C if there are parameters or a return type of an unconstrained - array type (such as ``String``). GNAT allows such declarations but - generates warnings. It is possible, but complicated, to write the - corresponding C code and certainly such code would be specific to GNAT and - non-portable. + The wording in the Ada 2005 RM concerning characteristics of incomplete views + was incorrect and implied that some programs intended to be legal were now + illegal. GNAT had never considered such programs illegal, so it has always + implemented the intent of this AI. - RM References: B.01 (17) B.03 (62) B.03 (71.1/2) + RM References: 3.10.01 (2.4/2) 3.10.01 (2.6/2) -.. index:: AI-0216 (Ada 2012 feature) +.. index:: AI-0210 (Ada 2012 feature) -* *AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)* +* *AI-0210 Correct Timing_Events metric (0000-00-00)* - It is clearly the intention that ``No_Task_Hierarchy`` is intended to - forbid tasks declared locally within subprograms, or functions returning task - objects, and that is the implementation that GNAT has always provided. - However the language in the RM was not sufficiently clear on this point. - Thus this is a documentation change in the RM only. + This is a documentation only issue regarding wording of metric requirements, + that does not affect the implementation of the compiler. - RM References: D.07 (3/3) + RM References: D.15 (24/2) .. index:: AI-0211 (Ada 2012 feature) @@ -1264,67 +1286,45 @@ Supported Aspect Source RM References: D.07 (5) D.07 (10/2) D.07 (10.4/2) D.07 (10.7/2) -.. index:: AI-0190 (Ada 2012 feature) - -* *AI-0190 pragma Default_Storage_Pool (2010-09-15)* - - This AI introduces a new pragma ``Default_Storage_Pool``, which can be - used to control storage pools globally. - In particular, you can force every access - type that is used for allocation (**new**) to have an explicit storage pool, - or you can declare a pool globally to be used for all access types that lack - an explicit one. - - RM References: D.07 (8) - -.. index:: AI-0189 (Ada 2012 feature) - -* *AI-0189 No_Allocators_After_Elaboration (2010-01-23)* - - This AI introduces a new restriction ``No_Allocators_After_Elaboration``, - which says that no dynamic allocation will occur once elaboration is - completed. - In general this requires a run-time check, which is not required, and which - GNAT does not attempt. But the static cases of allocators in a task body or - in the body of the main program are detected and flagged at compile or bind - time. - - RM References: D.07 (19.1/2) H.04 (23.3/2) - -.. index:: AI-0171 (Ada 2012 feature) +.. index:: AI-0214 (Ada 2012 feature) -* *AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)* +* *AI-0214 Defaulted discriminants for limited tagged (2010-10-01)* - A new package ``System.Multiprocessors`` is added, together with the - definition of pragma ``CPU`` for controlling task affinity. A new no - dependence restriction, on ``System.Multiprocessors.Dispatching_Domains``, - is added to the Ravenscar profile. + Ada 2012 relaxes the restriction that forbids discriminants of tagged types + to have default expressions by allowing them when the type is limited. It + is often useful to define a default value for a discriminant even though + it can't be changed by assignment. - RM References: D.13.01 (4/2) D.16 + RM References: 3.07 (9.1/2) 3.07.02 (3) -.. index:: AI-0210 (Ada 2012 feature) +.. index:: AI-0216 (Ada 2012 feature) -* *AI-0210 Correct Timing_Events metric (0000-00-00)* +* *AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)* - This is a documentation only issue regarding wording of metric requirements, - that does not affect the implementation of the compiler. + It is clearly the intention that ``No_Task_Hierarchy`` is intended to + forbid tasks declared locally within subprograms, or functions returning task + objects, and that is the implementation that GNAT has always provided. + However the language in the RM was not sufficiently clear on this point. + Thus this is a documentation change in the RM only. - RM References: D.15 (24/2) + RM References: D.07 (3/3) -.. index:: AI-0206 (Ada 2012 feature) +.. index:: AI-0219 (Ada 2012 feature) -* *AI-0206 Remote types packages and preelaborate (2010-07-24)* +* *AI-0219 Pure permissions and limited parameters (2010-05-25)* - Remote types packages are now allowed to depend on preelaborated packages. - This was formerly considered illegal. + This AI refines the rules for the cases with limited parameters which do not + allow the implementations to omit 'redundant'. GNAT now properly conforms + to the requirements of this binding interpretation. - RM References: E.02.02 (6) + RM References: 10.02.01 (18/2) -.. index:: AI-0152 (Ada 2012 feature) +.. index:: AI-0220 (Ada 2012 feature) -* *AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)* +* *AI-0220 Needed components for aggregates (0000-00-00)* - Restriction ``No_Anonymous_Allocators`` prevents the use of allocators - where the type of the returned value is an anonymous access type. + This AI addresses a wording problem in the RM that appears to permit some + complex cases of aggregates with nonstatic discriminants. GNAT has always + implemented the intended semantics. - RM References: H.04 (8/1) + RM References: 4.03.01 (17) diff --git a/gcc/ada/gnat_rm.texi b/gcc/ada/gnat_rm.texi index 0d38b1a4bc6..df6969f98b7 100644 --- a/gcc/ada/gnat_rm.texi +++ b/gcc/ada/gnat_rm.texi @@ -26607,865 +26607,958 @@ in the RM, the earliest is used. A complete description of the AIs may be found in @indicateurl{http://www.ada-auth.org/ai05-summary.html}. -@geindex AI-0176 (Ada 2012 feature) +@geindex AI-0002 (Ada 2012 feature) @itemize * @item -`AI-0176 Quantified expressions (2010-09-29)' +`AI-0002 Export C with unconstrained arrays (0000-00-00)' -Both universally and existentially quantified expressions are implemented. -They use the new syntax for iterators proposed in AI05-139-2, as well as -the standard Ada loop syntax. +The compiler is not required to support exporting an Ada subprogram with +convention C if there are parameters or a return type of an unconstrained +array type (such as @code{String}). GNAT allows such declarations but +generates warnings. It is possible, but complicated, to write the +corresponding C code and certainly such code would be specific to GNAT and +non-portable. -RM References: 1.01.04 (12) 2.09 (2/2) 4.04 (7) 4.05.09 (0) +RM References: B.01 (17) B.03 (62) B.03 (71.1/2) @end itemize -@geindex AI-0079 (Ada 2012 feature) +@geindex AI-0003 (Ada 2012 feature) @itemize * @item -`AI-0079 Allow other_format characters in source (2010-07-10)' +`AI-0003 Qualified expressions as names (2010-07-11)' -Wide characters in the unicode category `other_format' are now allowed in -source programs between tokens, but not within a token such as an identifier. +In Ada 2012, a qualified expression is considered to be syntactically a name, +meaning that constructs such as @code{A'(F(X)).B} are now legal. This is +useful in disambiguating some cases of overloading. -RM References: 2.01 (4/2) 2.02 (7) +RM References: 3.03 (11) 3.03 (21) 4.01 (2) 4.04 (7) 4.07 (3) +5.04 (7) @end itemize -@geindex AI-0091 (Ada 2012 feature) +@geindex AI-0007 (Ada 2012 feature) @itemize * @item -`AI-0091 Do not allow other_format in identifiers (0000-00-00)' +`AI-0007 Stream read and private scalar types (0000-00-00)' -Wide characters in the unicode category `other_format' are not permitted -within an identifier, since this can be a security problem. The error -message for this case has been improved to be more specific, but GNAT has -never allowed such characters to appear in identifiers. +The RM as written appeared to limit the possibilities of declaring read +attribute procedures for private scalar types. This limitation was not +intended, and has never been enforced by GNAT. -RM References: 2.03 (3.1/2) 2.03 (4/2) 2.03 (5/2) 2.03 (5.1/2) 2.03 (5.2/2) 2.03 (5.3/2) 2.09 (2/2) +RM References: 13.13.02 (50/2) 13.13.02 (51/2) @end itemize -@geindex AI-0100 (Ada 2012 feature) +@geindex AI-0008 (Ada 2012 feature) @itemize * @item -`AI-0100 Placement of pragmas (2010-07-01)' +`AI-0008 General access to constrained objects (0000-00-00)' -This AI is an earlier version of AI-163. It simplifies the rules -for legal placement of pragmas. In the case of lists that allow pragmas, if -the list may have no elements, then the list may consist solely of pragmas. +The wording in the RM implied that if you have a general access to a +constrained object, it could be used to modify the discriminants. This was +obviously not intended. @code{Constraint_Error} should be raised, and GNAT +has always done so in this situation. -RM References: 2.08 (7) +RM References: 3.03 (23) 3.10.02 (26/2) 4.01 (9) 6.04.01 (17) 8.05.01 (5/2) @end itemize -@geindex AI-0163 (Ada 2012 feature) +@geindex AI-0009 (Ada 2012 feature) @itemize * @item -`AI-0163 Pragmas in place of null (2010-07-01)' +`AI-0009 Pragma Independent[_Components] (2010-07-23)' -A statement sequence may be composed entirely of pragmas. It is no longer -necessary to add a dummy @code{null} statement to make the sequence legal. +This AI introduces the new pragmas @code{Independent} and +@code{Independent_Components}, +which control guaranteeing independence of access to objects and components. +The AI also requires independence not unaffected by confirming rep clauses. -RM References: 2.08 (7) 2.08 (16) +RM References: 9.10 (1) 13.01 (15/1) 13.02 (9) 13.03 (13) C.06 (2) +C.06 (4) C.06 (6) C.06 (9) C.06 (13) C.06 (14) @end itemize -@geindex AI-0080 (Ada 2012 feature) +@geindex AI-0012 (Ada 2012 feature) @itemize * @item -`AI-0080 ‘View of’ not needed if clear from context (0000-00-00)' +`AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)' -This is an editorial change only, described as non-testable in the AI. +It is now illegal to give an inappropriate component size or a pragma +@code{Pack} that attempts to change the component size in the case of atomic +or aliased components. Previously GNAT ignored such an attempt with a +warning. -RM References: 3.01 (7) +RM References: 13.02 (6.1/2) 13.02 (7) C.06 (10) C.06 (11) C.06 (21) @end itemize -@geindex AI-0183 (Ada 2012 feature) +@geindex AI-0015 (Ada 2012 feature) @itemize * @item -`AI-0183 Aspect specifications (2010-08-16)' - -Aspect specifications have been fully implemented except for pre and post- -conditions, and type invariants, which have their own separate AI’s. All -forms of declarations listed in the AI are supported. The following is a -list of the aspects supported (with GNAT implementation aspects marked) -@end itemize +`AI-0015 Constant return objects (0000-00-00)' +The return object declared in an `extended_return_statement' may be +declared constant. This was always intended, and GNAT has always allowed it. -@multitable {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxx} -@headitem +RM References: 6.05 (2.1/2) 3.03 (10/2) 3.03 (21) 6.05 (5/2) +6.05 (5.7/2) +@end itemize -Supported Aspect +@geindex AI-0017 (Ada 2012 feature) -@tab -Source +@itemize * -@item +@item +`AI-0017 Freezing and incomplete types (0000-00-00)' -@code{Ada_2005} +So-called ‘Taft-amendment types’ (i.e., types that are completed in package +bodies) are not frozen by the occurrence of bodies in the +enclosing declarative part. GNAT always implemented this properly. -@tab +RM References: 13.14 (3/1) +@end itemize -– GNAT +@geindex AI-0019 (Ada 2012 feature) -@item -@code{Ada_2012} +@itemize * -@tab +@item +`AI-0019 Freezing of primitives for tagged types (0000-00-00)' -– GNAT +The RM suggests that primitive subprograms of a specific tagged type are +frozen when the tagged type is frozen. This would be an incompatible change +and is not intended. GNAT has never attempted this kind of freezing and its +behavior is consistent with the recommendation of this AI. -@item +RM References: 13.14 (2) 13.14 (3/1) 13.14 (8.1/1) 13.14 (10) 13.14 (14) 13.14 (15.1/2) +@end itemize -@code{Address} +@geindex AI-0026 (Ada 2012 feature) -@tab -@item +@itemize * -@code{Alignment} +@item +`AI-0026 Missing rules for Unchecked_Union (2010-07-07)' -@tab +Record representation clauses concerning Unchecked_Union types cannot mention +the discriminant of the type. The type of a component declared in the variant +part of an Unchecked_Union cannot be controlled, have controlled components, +nor have protected or task parts. If an Unchecked_Union type is declared +within the body of a generic unit or its descendants, then the type of a +component declared in the variant part cannot be a formal private type or a +formal private extension declared within the same generic unit. -@item +RM References: 7.06 (9.4/2) B.03.03 (9/2) B.03.03 (10/2) +@end itemize -@code{Atomic} +@geindex AI-0030 (Ada 2012 feature) -@tab -@item +@itemize * -@code{Atomic_Components} +@item +`AI-0030 Requeue on synchronized interfaces (2010-07-19)' -@tab +Requeue is permitted to a protected, synchronized or task interface primitive +providing it is known that the overriding operation is an entry. Otherwise +the requeue statement has the same effect as a procedure call. Use of pragma +@code{Implemented} provides a way to impose a static requirement on the +overriding operation by adhering to one of the implementation kinds: entry, +protected procedure or any of the above. -@item +RM References: 9.05 (9) 9.05.04 (2) 9.05.04 (3) 9.05.04 (5) +9.05.04 (6) 9.05.04 (7) 9.05.04 (12) +@end itemize -@code{Bit_Order} +@geindex AI-0031 (Ada 2012 feature) -@tab -@item +@itemize * -@code{Component_Size} +@item +`AI-0031 Add From parameter to Find_Token (2010-07-25)' -@tab +A new version of @code{Find_Token} is added to all relevant string packages, +with an extra parameter @code{From}. Instead of starting at the first +character of the string, the search for a matching Token starts at the +character indexed by the value of @code{From}. +These procedures are available in all versions of Ada +but if used in versions earlier than Ada 2012 they will generate a warning +that an Ada 2012 subprogram is being used. -@item +RM References: A.04.03 (16) A.04.03 (67) A.04.03 (68/1) A.04.04 (51) +A.04.05 (46) +@end itemize -@code{Contract_Cases} +@geindex AI-0032 (Ada 2012 feature) -@tab -– GNAT +@itemize * -@item +@item +`AI-0032 Extended return for class-wide functions (0000-00-00)' -@code{Discard_Names} +If a function returns a class-wide type, the object of an extended return +statement can be declared with a specific type that is covered by the class- +wide type. This has been implemented in GNAT since the introduction of +extended returns. Note AI-0103 complements this AI by imposing matching +rules for constrained return types. -@tab +RM References: 6.05 (5.2/2) 6.05 (5.3/2) 6.05 (5.6/2) 6.05 (5.8/2) +6.05 (8/2) +@end itemize -@item +@geindex AI-0033 (Ada 2012 feature) -@code{External_Tag} -@tab +@itemize * -@item +@item +`AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)' -@code{Favor_Top_Level} +Neither of these two pragmas may appear within a generic template, because +the generic might be instantiated at other than the library level. -@tab +RM References: 13.11.02 (16) C.03.01 (7/2) C.03.01 (8/2) +@end itemize -– GNAT +@geindex AI-0034 (Ada 2012 feature) -@item -@code{Inline} +@itemize * -@tab +@item +`AI-0034 Categorization of limited views (0000-00-00)' -@item +The RM makes certain limited with clauses illegal because of categorization +considerations, when the corresponding normal with would be legal. This is +not intended, and GNAT has always implemented the recommended behavior. -@code{Inline_Always} +RM References: 10.02.01 (11/1) 10.02.01 (17/2) +@end itemize -@tab +@geindex AI-0035 (Ada 2012 feature) -– GNAT -@item +@itemize * -@code{Invariant} +@item +`AI-0035 Inconsistencies with Pure units (0000-00-00)' -@tab +This AI remedies some inconsistencies in the legality rules for Pure units. +Derived access types are legal in a pure unit (on the assumption that the +rule for a zero storage pool size has been enforced on the ancestor type). +The rules are enforced in generic instances and in subunits. GNAT has always +implemented the recommended behavior. -– GNAT +RM References: 10.02.01 (15.1/2) 10.02.01 (15.4/2) 10.02.01 (15.5/2) 10.02.01 (17/2) +@end itemize -@item +@geindex AI-0037 (Ada 2012 feature) -@code{Machine_Radix} -@tab +@itemize * -@item +@item +`AI-0037 Out-of-range box associations in aggregate (0000-00-00)' -@code{No_Return} +This AI confirms that an association of the form @code{Indx => <>} in an +array aggregate must raise @code{Constraint_Error} if @code{Indx} +is out of range. The RM specified a range check on other associations, but +not when the value of the association was defaulted. GNAT has always inserted +a constraint check on the index value. -@tab +RM References: 4.03.03 (29) +@end itemize -@item +@geindex AI-0038 (Ada 2012 feature) -@code{Object_Size} -@tab +@itemize * -– GNAT +@item +`AI-0038 Minor errors in Text_IO (0000-00-00)' -@item +These are minor errors in the description on three points. The intent on +all these points has always been clear, and GNAT has always implemented the +correct intended semantics. -@code{Pack} +RM References: A.10.05 (37) A.10.07 (8/1) A.10.07 (10) A.10.07 (12) A.10.08 (10) A.10.08 (24) +@end itemize -@tab +@geindex AI-0039 (Ada 2012 feature) -@item -@code{Persistent_BSS} +@itemize * -@tab +@item +`AI-0039 Stream attributes cannot be dynamic (0000-00-00)' -– GNAT +The RM permitted the use of dynamic expressions (such as @code{ptr.all})` +for stream attributes, but these were never useful and are now illegal. GNAT +has always regarded such expressions as illegal. -@item +RM References: 13.03 (4) 13.03 (6) 13.13.02 (38/2) +@end itemize -@code{Post} +@geindex AI-0040 (Ada 2012 feature) -@tab -@item +@itemize * -@code{Pre} +@item +`AI-0040 Limited with clauses on descendant (0000-00-00)' -@tab +This AI confirms that a limited with clause in a child unit cannot name +an ancestor of the unit. This has always been checked in GNAT. -@item +RM References: 10.01.02 (20/2) +@end itemize -@code{Predicate} +@geindex AI-0042 (Ada 2012 feature) -@tab -@item +@itemize * -@code{Preelaborable_Initialization} +@item +`AI-0042 Overriding versus implemented-by (0000-00-00)' -@tab +This AI fixes a wording gap in the RM. An operation of a synchronized +interface can be implemented by a protected or task entry, but the abstract +operation is not being overridden in the usual sense, and it must be stated +separately that this implementation is legal. This has always been the case +in GNAT. -@item +RM References: 9.01 (9.2/2) 9.04 (11.1/2) +@end itemize -@code{Pure_Function} +@geindex AI-0043 (Ada 2012 feature) -@tab -– GNAT +@itemize * -@item +@item +`AI-0043 Rules about raising exceptions (0000-00-00)' -@code{Remote_Access_Type} +This AI covers various omissions in the RM regarding the raising of +exceptions. GNAT has always implemented the intended semantics. -@tab +RM References: 11.04.01 (10.1/2) 11 (2) +@end itemize -– GNAT +@geindex AI-0044 (Ada 2012 feature) -@item -@code{Shared} +@itemize * -@tab +@item +`AI-0044 Restrictions on container instantiations (0000-00-00)' -– GNAT +This AI places restrictions on allowed instantiations of generic containers. +These restrictions are not checked by the compiler, so there is nothing to +change in the implementation. This affects only the RM documentation. -@item +RM References: A.18 (4/2) A.18.02 (231/2) A.18.03 (145/2) A.18.06 (56/2) A.18.08 (66/2) A.18.09 (79/2) A.18.26 (5/2) A.18.26 (9/2) +@end itemize -@code{Size} +@geindex AI-0046 (Ada 2012 feature) -@tab -@item +@itemize * -@code{Storage_Pool} +@item +`AI-0046 Null exclusion match for full conformance (2010-07-17)' -@tab +For full conformance, in the case of access parameters, the null exclusion +must match (either both or neither must have @code{not null}). -@item +RM References: 6.03.02 (18) +@end itemize -@code{Storage_Size} +@geindex AI-0050 (Ada 2012 feature) -@tab -@item +@itemize * -@code{Stream_Size} +@item +`AI-0050 Raising Constraint_Error early for function call (0000-00-00)' -@tab +The implementation permissions for raising @code{Constraint_Error} early on a function call +when it was clear an exception would be raised were over-permissive and allowed +mishandling of discriminants in some cases. GNAT did +not take advantage of these incorrect permissions in any case. -@item +RM References: 6.05 (24/2) +@end itemize -@code{Suppress} +@geindex AI-0056 (Ada 2012 feature) -@tab -@item +@itemize * -@code{Suppress_Debug_Info} +@item +`AI-0056 Index on null string returns zero (0000-00-00)' -@tab +The wording in the Ada 2005 RM implied an incompatible handling of the +@code{Index} functions, resulting in raising an exception instead of +returning zero in some situations. +This was not intended and has been corrected. +GNAT always returned zero, and is thus consistent with this AI. -– GNAT +RM References: A.04.03 (56.2/2) A.04.03 (58.5/2) +@end itemize -@item +@geindex AI-0058 (Ada 2012 feature) -@code{Test_Case} -@tab +@itemize * -– GNAT +@item +`AI-0058 Abnormal completion of an extended return (0000-00-00)' -@item +The RM had some incorrect wording implying wrong treatment of abnormal +completion in an extended return. GNAT has always implemented the intended +correct semantics as described by this AI. -@code{Thread_Local_Storage} +RM References: 6.05 (22/2) +@end itemize -@tab +@geindex AI-0060 (Ada 2012 feature) -– GNAT -@item +@itemize * -@code{Type_Invariant} +@item +`AI-0060 Extended definition of remote access types (0000-00-00)' -@tab +This AI extends the definition of remote access types to include access +to limited, synchronized, protected or task class-wide interface types. +GNAT already implemented this extension. -@item +RM References: A (4) E.02.02 (9/1) E.02.02 (9.2/1) E.02.02 (14/2) E.02.02 (18) +@end itemize -@code{Unchecked_Union} +@geindex AI-0062 (Ada 2012 feature) -@tab -@item +@itemize * -@code{Universal_Aliasing} +@item +`AI-0062 Null exclusions and deferred constants (0000-00-00)' -@tab +A full constant may have a null exclusion even if its associated deferred +constant does not. GNAT has always allowed this. -– GNAT +RM References: 7.04 (6/2) 7.04 (7.1/2) +@end itemize -@item +@geindex AI-0064 (Ada 2012 feature) -@code{Unmodified} -@tab +@itemize * -– GNAT +@item +`AI-0064 Redundant finalization rule (0000-00-00)' -@item +This is an editorial change only. The intended behavior is already checked +by an existing ACATS test, which GNAT has always executed correctly. -@code{Unreferenced} +RM References: 7.06.01 (17.1/1) +@end itemize -@tab +@geindex AI-0065 (Ada 2012 feature) -– GNAT -@item +@itemize * -@code{Unreferenced_Objects} +@item +`AI-0065 Remote access types and external streaming (0000-00-00)' -@tab +This AI clarifies the fact that all remote access types support external +streaming. This fixes an obvious oversight in the definition of the +language, and GNAT always implemented the intended correct rules. -– GNAT +RM References: 13.13.02 (52/2) +@end itemize -@item +@geindex AI-0070 (Ada 2012 feature) -@code{Unsuppress} -@tab +@itemize * -@item +@item +`AI-0070 Elaboration of interface types (0000-00-00)' -@code{Value_Size} +This is an editorial change only, there are no testable consequences short of +checking for the absence of generated code for an interface declaration. -@tab +RM References: 3.09.04 (18/2) +@end itemize -– GNAT +@geindex AI-0072 (Ada 2012 feature) -@item -@code{Volatile} +@itemize * -@tab +@item +`AI-0072 Task signalling using ‘Terminated (0000-00-00)' -@item +This AI clarifies that task signalling for reading @code{'Terminated} only +occurs if the result is True. GNAT semantics has always been consistent with +this notion of task signalling. -@code{Volatile_Components} +RM References: 9.10 (6.1/1) +@end itemize -@tab +@geindex AI-0073 (Ada 2012 feature) -@item -@code{Warnings} +@itemize * -@tab +@item +`AI-0073 Functions returning abstract types (2010-07-10)' -– GNAT - -@end multitable - - -@quotation - -Note that for aspects with an expression, e.g. @code{Size}, the expression is -treated like a default expression (visibility is analyzed at the point of -occurrence of the aspect, but evaluation of the expression occurs at the -freeze point of the entity involved). +This AI covers a number of issues regarding returning abstract types. In +particular generic functions cannot have abstract result types or access +result types designated an abstract type. There are some other cases which +are detailed in the AI. Note that this binding interpretation has not been +retrofitted to operate before Ada 2012 mode, since it caused a significant +number of regressions. -RM References: 3.02.01 (3) 3.02.02 (2) 3.03.01 (2/2) 3.08 (6) -3.09.03 (1.1/2) 6.01 (2/2) 6.07 (2/2) 9.05.02 (2/2) 7.01 (3) 7.03 -(2) 7.03 (3) 9.01 (2/2) 9.01 (3/2) 9.04 (2/2) 9.04 (3/2) -9.05.02 (2/2) 11.01 (2) 12.01 (3) 12.03 (2/2) 12.04 (2/2) 12.05 (2) -12.06 (2.1/2) 12.06 (2.2/2) 12.07 (2) 13.01 (0.1/2) 13.03 (5/1) -13.03.01 (0) -@end quotation +RM References: 3.09.03 (8) 3.09.03 (10) 6.05 (8/2) +@end itemize -@geindex AI-0128 (Ada 2012 feature) +@geindex AI-0076 (Ada 2012 feature) @itemize * @item -`AI-0128 Inequality is a primitive operation (0000-00-00)' +`AI-0076 function with controlling result (0000-00-00)' -If an equality operator (“=”) is declared for a type, then the implicitly -declared inequality operator (“/=”) is a primitive operation of the type. -This is the only reasonable interpretation, and is the one always implemented -by GNAT, but the RM was not entirely clear in making this point. +This is an editorial change only. The RM defines calls with controlling +results, but uses the term ‘function with controlling result’ without an +explicit definition. -RM References: 3.02.03 (6) 6.06 (6) +RM References: 3.09.02 (2/2) @end itemize -@geindex AI-0003 (Ada 2012 feature) +@geindex AI-0077 (Ada 2012 feature) @itemize * @item -`AI-0003 Qualified expressions as names (2010-07-11)' +`AI-0077 Limited withs and scope of declarations (0000-00-00)' -In Ada 2012, a qualified expression is considered to be syntactically a name, -meaning that constructs such as @code{A'(F(X)).B} are now legal. This is -useful in disambiguating some cases of overloading. +This AI clarifies that a declaration does not include a context clause, +and confirms that it is illegal to have a context in which both a limited +and a nonlimited view of a package are accessible. Such double visibility +was always rejected by GNAT. -RM References: 3.03 (11) 3.03 (21) 4.01 (2) 4.04 (7) 4.07 (3) -5.04 (7) +RM References: 10.01.02 (12/2) 10.01.02 (21/2) 10.01.02 (22/2) @end itemize -@geindex AI-0120 (Ada 2012 feature) +@geindex AI-0078 (Ada 2012 feature) @itemize * @item -`AI-0120 Constant instance of protected object (0000-00-00)' +`AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)' -This is an RM editorial change only. The section that lists objects that are -constant failed to include the current instance of a protected object -within a protected function. This has always been treated as a constant -in GNAT. +In Ada 2012, compilers are required to support unchecked conversion where the +target alignment is a multiple of the source alignment. GNAT always supported +this case (and indeed all cases of differing alignments, doing copies where +required if the alignment was reduced). -RM References: 3.03 (21) +RM References: 13.09 (7) @end itemize -@geindex AI-0008 (Ada 2012 feature) +@geindex AI-0079 (Ada 2012 feature) @itemize * @item -`AI-0008 General access to constrained objects (0000-00-00)' +`AI-0079 Allow other_format characters in source (2010-07-10)' -The wording in the RM implied that if you have a general access to a -constrained object, it could be used to modify the discriminants. This was -obviously not intended. @code{Constraint_Error} should be raised, and GNAT -has always done so in this situation. +Wide characters in the unicode category `other_format' are now allowed in +source programs between tokens, but not within a token such as an identifier. -RM References: 3.03 (23) 3.10.02 (26/2) 4.01 (9) 6.04.01 (17) 8.05.01 (5/2) +RM References: 2.01 (4/2) 2.02 (7) @end itemize -@geindex AI-0093 (Ada 2012 feature) +@geindex AI-0080 (Ada 2012 feature) @itemize * @item -`AI-0093 Additional rules use immutably limited (0000-00-00)' +`AI-0080 ‘View of’ not needed if clear from context (0000-00-00)' -This is an editorial change only, to make more widespread use of the Ada 2012 -‘immutably limited’. +This is an editorial change only, described as non-testable in the AI. -RM References: 3.03 (23.4/3) +RM References: 3.01 (7) @end itemize -@geindex AI-0096 (Ada 2012 feature) +@geindex AI-0087 (Ada 2012 feature) @itemize * @item -`AI-0096 Deriving from formal private types (2010-07-20)' +`AI-0087 Actual for formal nonlimited derived type (2010-07-15)' -In general it is illegal for a type derived from a formal limited type to be -nonlimited. This AI makes an exception to this rule: derivation is legal -if it appears in the private part of the generic, and the formal type is not -tagged. If the type is tagged, the legality check must be applied to the -private part of the package. +The actual for a formal nonlimited derived type cannot be limited. In +particular, a formal derived type that extends a limited interface but which +is not explicitly limited cannot be instantiated with a limited type. -RM References: 3.04 (5.1/2) 6.02 (7) +RM References: 7.05 (5/2) 12.05.01 (5.1/2) @end itemize -@geindex AI-0181 (Ada 2012 feature) +@geindex AI-0088 (Ada 2012 feature) @itemize * @item -`AI-0181 Soft hyphen is a non-graphic character (2010-07-23)' +`AI-0088 The value of exponentiation (0000-00-00)' -From Ada 2005 on, soft hyphen is considered a non-graphic character, which -means that it has a special name (@code{SOFT_HYPHEN}) in conjunction with the -@code{Image} and @code{Value} attributes for the character types. Strictly -speaking this is an inconsistency with Ada 95, but in practice the use of -these attributes is so obscure that it will not cause problems. +This AI clarifies the equivalence rule given for the dynamic semantics of +exponentiation: the value of the operation can be obtained by repeated +multiplication, but the operation can be implemented otherwise (for example +using the familiar divide-by-two-and-square algorithm, even if this is less +accurate), and does not imply repeated reads of a volatile base. -RM References: 3.05.02 (2/2) A.01 (35/2) A.03.03 (21) +RM References: 4.05.06 (11) @end itemize -@geindex AI-0182 (Ada 2012 feature) +@geindex AI-0091 (Ada 2012 feature) @itemize * @item -`AI-0182 Additional forms for' @code{Character'Value} `(0000-00-00)' +`AI-0091 Do not allow other_format in identifiers (0000-00-00)' -This AI allows @code{Character'Value} to accept the string @code{'?'} where -@code{?} is any character including non-graphic control characters. GNAT has -always accepted such strings. It also allows strings such as -@code{HEX_00000041} to be accepted, but GNAT does not take advantage of this -permission and raises @code{Constraint_Error}, as is certainly still -permitted. +Wide characters in the unicode category `other_format' are not permitted +within an identifier, since this can be a security problem. The error +message for this case has been improved to be more specific, but GNAT has +never allowed such characters to appear in identifiers. -RM References: 3.05 (56/2) +RM References: 2.03 (3.1/2) 2.03 (4/2) 2.03 (5/2) 2.03 (5.1/2) 2.03 (5.2/2) 2.03 (5.3/2) 2.09 (2/2) @end itemize -@geindex AI-0214 (Ada 2012 feature) +@geindex AI-0093 (Ada 2012 feature) @itemize * @item -`AI-0214 Defaulted discriminants for limited tagged (2010-10-01)' +`AI-0093 Additional rules use immutably limited (0000-00-00)' -Ada 2012 relaxes the restriction that forbids discriminants of tagged types -to have default expressions by allowing them when the type is limited. It -is often useful to define a default value for a discriminant even though -it can’t be changed by assignment. +This is an editorial change only, to make more widespread use of the Ada 2012 +‘immutably limited’. -RM References: 3.07 (9.1/2) 3.07.02 (3) +RM References: 3.03 (23.4/3) @end itemize -@geindex AI-0102 (Ada 2012 feature) +@geindex AI-0095 (Ada 2012 feature) @itemize * @item -`AI-0102 Some implicit conversions are illegal (0000-00-00)' +`AI-0095 Address of intrinsic subprograms (0000-00-00)' -It is illegal to assign an anonymous access constant to an anonymous access -variable. The RM did not have a clear rule to prevent this, but GNAT has -always generated an error for this usage. +The prefix of @code{'Address} cannot statically denote a subprogram with +convention @code{Intrinsic}. The use of the @code{Address} attribute raises +@code{Program_Error} if the prefix denotes a subprogram with convention +@code{Intrinsic}. -RM References: 3.07 (16) 3.07.01 (9) 6.04.01 (6) 8.06 (27/2) +RM References: 13.03 (11/1) @end itemize -@geindex AI-0158 (Ada 2012 feature) +@geindex AI-0096 (Ada 2012 feature) @itemize * @item -`AI-0158 Generalizing membership tests (2010-09-16)' +`AI-0096 Deriving from formal private types (2010-07-20)' -This AI extends the syntax of membership tests to simplify complex conditions -that can be expressed as membership in a subset of values of any type. It -introduces syntax for a list of expressions that may be used in loop contexts -as well. +In general it is illegal for a type derived from a formal limited type to be +nonlimited. This AI makes an exception to this rule: derivation is legal +if it appears in the private part of the generic, and the formal type is not +tagged. If the type is tagged, the legality check must be applied to the +private part of the package. -RM References: 3.08.01 (5) 4.04 (3) 4.05.02 (3) 4.05.02 (5) 4.05.02 (27) +RM References: 3.04 (5.1/2) 6.02 (7) @end itemize -@geindex AI-0173 (Ada 2012 feature) +@geindex AI-0097 (Ada 2012 feature) @itemize * @item -`AI-0173 Testing if tags represent abstract types (2010-07-03)' +`AI-0097 Treatment of abstract null extension (2010-07-19)' -The function @code{Ada.Tags.Type_Is_Abstract} returns @code{True} if invoked -with the tag of an abstract type, and @code{False} otherwise. +The RM as written implied that in some cases it was possible to create an +object of an abstract type, by having an abstract extension inherit a non- +abstract constructor from its parent type. This mistake has been corrected +in GNAT and in the RM, and this construct is now illegal. -RM References: 3.09 (7.4/2) 3.09 (12.4/2) +RM References: 3.09.03 (4/2) @end itemize -@geindex AI-0076 (Ada 2012 feature) +@geindex AI-0098 (Ada 2012 feature) @itemize * @item -`AI-0076 function with controlling result (0000-00-00)' +`AI-0098 Anonymous subprogram access restrictions (0000-00-00)' -This is an editorial change only. The RM defines calls with controlling -results, but uses the term ‘function with controlling result’ without an -explicit definition. +An unintentional omission in the RM implied some inconsistent restrictions on +the use of anonymous access to subprogram values. These restrictions were not +intentional, and have never been enforced by GNAT. -RM References: 3.09.02 (2/2) +RM References: 3.10.01 (6) 3.10.01 (9.2/2) @end itemize -@geindex AI-0126 (Ada 2012 feature) +@geindex AI-0099 (Ada 2012 feature) @itemize * @item -`AI-0126 Dispatching with no declared operation (0000-00-00)' +`AI-0099 Tag determines whether finalization needed (0000-00-00)' -This AI clarifies dispatching rules, and simply confirms that dispatching -executes the operation of the parent type when there is no explicitly or -implicitly declared operation for the descendant type. This has always been -the case in all versions of GNAT. +This AI clarifies that ‘needs finalization’ is part of dynamic semantics, +and therefore depends on the run-time characteristics of an object (i.e. its +tag) and not on its nominal type. As the AI indicates: “we do not expect +this to affect any implementation’’. -RM References: 3.09.02 (20/2) 3.09.02 (20.1/2) 3.09.02 (20.2/2) +RM References: 7.06.01 (6) 7.06.01 (7) 7.06.01 (8) 7.06.01 (9/2) @end itemize -@geindex AI-0097 (Ada 2012 feature) +@geindex AI-0100 (Ada 2012 feature) @itemize * @item -`AI-0097 Treatment of abstract null extension (2010-07-19)' +`AI-0100 Placement of pragmas (2010-07-01)' -The RM as written implied that in some cases it was possible to create an -object of an abstract type, by having an abstract extension inherit a non- -abstract constructor from its parent type. This mistake has been corrected -in GNAT and in the RM, and this construct is now illegal. +This AI is an earlier version of AI-163. It simplifies the rules +for legal placement of pragmas. In the case of lists that allow pragmas, if +the list may have no elements, then the list may consist solely of pragmas. -RM References: 3.09.03 (4/2) +RM References: 2.08 (7) @end itemize -@geindex AI-0203 (Ada 2012 feature) +@geindex AI-0102 (Ada 2012 feature) @itemize * @item -`AI-0203 Extended return cannot be abstract (0000-00-00)' +`AI-0102 Some implicit conversions are illegal (0000-00-00)' -A return_subtype_indication cannot denote an abstract subtype. GNAT has never -permitted such usage. +It is illegal to assign an anonymous access constant to an anonymous access +variable. The RM did not have a clear rule to prevent this, but GNAT has +always generated an error for this usage. -RM References: 3.09.03 (8/3) +RM References: 3.07 (16) 3.07.01 (9) 6.04.01 (6) 8.06 (27/2) @end itemize -@geindex AI-0198 (Ada 2012 feature) +@geindex AI-0103 (Ada 2012 feature) @itemize * @item -`AI-0198 Inheriting abstract operators (0000-00-00)' +`AI-0103 Static matching for extended return (2010-07-23)' -This AI resolves a conflict between two rules involving inherited abstract -operations and predefined operators. If a derived numeric type inherits -an abstract operator, it overrides the predefined one. This interpretation -was always the one implemented in GNAT. +If the return subtype of a function is an elementary type or a constrained +type, the subtype indication in an extended return statement must match +statically this return subtype. -RM References: 3.09.03 (4/3) +RM References: 6.05 (5.2/2) @end itemize -@geindex AI-0073 (Ada 2012 feature) +@geindex AI-0104 (Ada 2012 feature) @itemize * @item -`AI-0073 Functions returning abstract types (2010-07-10)' +`AI-0104 Null exclusion and uninitialized allocator (2010-07-15)' -This AI covers a number of issues regarding returning abstract types. In -particular generic functions cannot have abstract result types or access -result types designated an abstract type. There are some other cases which -are detailed in the AI. Note that this binding interpretation has not been -retrofitted to operate before Ada 2012 mode, since it caused a significant -number of regressions. +The assignment @code{Ptr := new not null Some_Ptr;} will raise +@code{Constraint_Error} because the default value of the allocated object is +`null'. This useless construct is illegal in Ada 2012. -RM References: 3.09.03 (8) 3.09.03 (10) 6.05 (8/2) +RM References: 4.08 (2) @end itemize -@geindex AI-0070 (Ada 2012 feature) +@geindex AI-0106 (Ada 2012 feature) @itemize * @item -`AI-0070 Elaboration of interface types (0000-00-00)' +`AI-0106 No representation pragmas on generic formals (0000-00-00)' -This is an editorial change only, there are no testable consequences short of -checking for the absence of generated code for an interface declaration. +The RM appeared to allow representation pragmas on generic formal parameters, +but this was not intended, and GNAT has never permitted this usage. -RM References: 3.09.04 (18/2) +RM References: 13.01 (9.1/1) @end itemize -@geindex AI-0208 (Ada 2012 feature) +@geindex AI-0108 (Ada 2012 feature) @itemize * @item -`AI-0208 Characteristics of incomplete views (0000-00-00)' +`AI-0108 Limited incomplete view and discriminants (0000-00-00)' -The wording in the Ada 2005 RM concerning characteristics of incomplete views -was incorrect and implied that some programs intended to be legal were now -illegal. GNAT had never considered such programs illegal, so it has always -implemented the intent of this AI. +This AI confirms that an incomplete type from a limited view does not have +discriminants. This has always been the case in GNAT. -RM References: 3.10.01 (2.4/2) 3.10.01 (2.6/2) +RM References: 10.01.01 (12.3/2) @end itemize -@geindex AI-0162 (Ada 2012 feature) +@geindex AI-0109 (Ada 2012 feature) @itemize * @item -`AI-0162 Incomplete type completed by partial view (2010-09-15)' +`AI-0109 Redundant check in S’Class’Input (0000-00-00)' -Incomplete types are made more useful by allowing them to be completed by -private types and private extensions. +This AI is an editorial change only. It removes the need for a tag check +that can never fail. -RM References: 3.10.01 (2.5/2) 3.10.01 (2.6/2) 3.10.01 (3) 3.10.01 (4/2) +RM References: 13.13.02 (34/2) @end itemize -@geindex AI-0098 (Ada 2012 feature) +@geindex AI-0112 (Ada 2012 feature) @itemize * @item -`AI-0098 Anonymous subprogram access restrictions (0000-00-00)' +`AI-0112 Detection of duplicate pragmas (2010-07-24)' -An unintentional omission in the RM implied some inconsistent restrictions on -the use of anonymous access to subprogram values. These restrictions were not -intentional, and have never been enforced by GNAT. +This AI concerns giving names to various representation aspects, but the +practical effect is simply to make the use of duplicate +@code{Atomic[_Components]}, +@code{Volatile[_Components]}, and +@code{Independent[_Components]} pragmas illegal, and GNAT +now performs this required check. -RM References: 3.10.01 (6) 3.10.01 (9.2/2) +RM References: 13.01 (8) @end itemize -@geindex AI-0199 (Ada 2012 feature) +@geindex AI-0114 (Ada 2012 feature) @itemize * @item -`AI-0199 Aggregate with anonymous access components (2010-07-14)' +`AI-0114 Classification of letters (0000-00-00)' -A choice list in a record aggregate can include several components of -(distinct) anonymous access types as long as they have matching designated -subtypes. +The code points 170 (@code{FEMININE ORDINAL INDICATOR}), +181 (@code{MICRO SIGN}), and +186 (@code{MASCULINE ORDINAL INDICATOR}) are technically considered +lower case letters by Unicode. +However, they are not allowed in identifiers, and they +return @code{False} to @code{Ada.Characters.Handling.Is_Letter/Is_Lower}. +This behavior is consistent with that defined in Ada 95. -RM References: 4.03.01 (16) +RM References: A.03.02 (59) A.04.06 (7) @end itemize -@geindex AI-0220 (Ada 2012 feature) +@geindex AI-0116 (Ada 2012 feature) @itemize * @item -`AI-0220 Needed components for aggregates (0000-00-00)' +`AI-0116 Alignment of class-wide objects (0000-00-00)' -This AI addresses a wording problem in the RM that appears to permit some -complex cases of aggregates with nonstatic discriminants. GNAT has always -implemented the intended semantics. +This AI requires that the alignment of a class-wide object be no greater +than the alignment of any type in the class. GNAT has always followed this +recommendation. -RM References: 4.03.01 (17) +RM References: 13.03 (29) 13.11 (16) @end itemize -@geindex AI-0147 (Ada 2012 feature) +@geindex AI-0118 (Ada 2012 feature) @itemize * @item -`AI-0147 Conditional expressions (2009-03-29)' +`AI-0118 The association of parameter associations (0000-00-00)' -Conditional expressions are permitted. The form of such an expression is: +This AI clarifies the rules for named associations in subprogram calls and +generic instantiations. The rules have been in place since Ada 83. -@example -(if expr then expr @{elsif expr then expr@} [else expr]) -@end example +RM References: 6.04.01 (2) 12.03 (9) +@end itemize -The parentheses can be omitted in contexts where parentheses are present -anyway, such as subprogram arguments and pragma arguments. If the `else' -clause is omitted, `else' `True' is assumed; -thus @code{(if A then B)} is a way to conveniently represent -`(A implies B)' in standard logic. +@geindex AI-0120 (Ada 2012 feature) -RM References: 4.03.03 (15) 4.04 (1) 4.04 (7) 4.05.07 (0) 4.07 (2) -4.07 (3) 4.09 (12) 4.09 (33) 5.03 (3) 5.03 (4) 7.05 (2.1/2) + +@itemize * + +@item +`AI-0120 Constant instance of protected object (0000-00-00)' + +This is an RM editorial change only. The section that lists objects that are +constant failed to include the current instance of a protected object +within a protected function. This has always been treated as a constant +in GNAT. + +RM References: 3.03 (21) @end itemize -@geindex AI-0037 (Ada 2012 feature) +@geindex AI-0122 (Ada 2012 feature) @itemize * @item -`AI-0037 Out-of-range box associations in aggregate (0000-00-00)' +`AI-0122 Private with and children of generics (0000-00-00)' -This AI confirms that an association of the form @code{Indx => <>} in an -array aggregate must raise @code{Constraint_Error} if @code{Indx} -is out of range. The RM specified a range check on other associations, but -not when the value of the association was defaulted. GNAT has always inserted -a constraint check on the index value. +This AI clarifies the visibility of private children of generic units within +instantiations of a parent. GNAT has always handled this correctly. -RM References: 4.03.03 (29) +RM References: 10.01.02 (12/2) @end itemize @geindex AI-0123 (Ada 2012 feature) @@ -27494,100 +27587,97 @@ RM References: 4.05.02 (9.7/2) 4.05.02 (14) 4.05.02 (15) 4.05.02 (24) 8.05.04 (8) @end itemize -@geindex AI-0088 (Ada 2012 feature) +@geindex AI-0125 (Ada 2012 feature) @itemize * @item -`AI-0088 The value of exponentiation (0000-00-00)' +`AI-0125 Nonoverridable operations of an ancestor (2010-09-28)' -This AI clarifies the equivalence rule given for the dynamic semantics of -exponentiation: the value of the operation can be obtained by repeated -multiplication, but the operation can be implemented otherwise (for example -using the familiar divide-by-two-and-square algorithm, even if this is less -accurate), and does not imply repeated reads of a volatile base. +In Ada 2012, the declaration of a primitive operation of a type extension +or private extension can also override an inherited primitive that is not +visible at the point of this declaration. -RM References: 4.05.06 (11) +RM References: 7.03.01 (6) 8.03 (23) 8.03.01 (5/2) 8.03.01 (6/2) @end itemize -@geindex AI-0188 (Ada 2012 feature) +@geindex AI-0126 (Ada 2012 feature) @itemize * @item -`AI-0188 Case expressions (2010-01-09)' - -Case expressions are permitted. This allows use of constructs such as: +`AI-0126 Dispatching with no declared operation (0000-00-00)' -@example -X := (case Y is when 1 => 2, when 2 => 3, when others => 31) -@end example +This AI clarifies dispatching rules, and simply confirms that dispatching +executes the operation of the parent type when there is no explicitly or +implicitly declared operation for the descendant type. This has always been +the case in all versions of GNAT. -RM References: 4.05.07 (0) 4.05.08 (0) 4.09 (12) 4.09 (33) +RM References: 3.09.02 (20/2) 3.09.02 (20.1/2) 3.09.02 (20.2/2) @end itemize -@geindex AI-0104 (Ada 2012 feature) +@geindex AI-0127 (Ada 2012 feature) @itemize * @item -`AI-0104 Null exclusion and uninitialized allocator (2010-07-15)' +`AI-0127 Adding Locale Capabilities (2010-09-29)' -The assignment @code{Ptr := new not null Some_Ptr;} will raise -@code{Constraint_Error} because the default value of the allocated object is -`null'. This useless construct is illegal in Ada 2012. +This package provides an interface for identifying the current locale. -RM References: 4.08 (2) +RM References: A.19 A.19.01 A.19.02 A.19.03 A.19.05 A.19.06 +A.19.07 A.19.08 A.19.09 A.19.10 A.19.11 A.19.12 A.19.13 @end itemize -@geindex AI-0157 (Ada 2012 feature) +@geindex AI-0128 (Ada 2012 feature) @itemize * @item -`AI-0157 Allocation/Deallocation from empty pool (2010-07-11)' +`AI-0128 Inequality is a primitive operation (0000-00-00)' -Allocation and Deallocation from an empty storage pool (i.e. allocation or -deallocation of a pointer for which a static storage size clause of zero -has been given) is now illegal and is detected as such. GNAT -previously gave a warning but not an error. +If an equality operator (“=”) is declared for a type, then the implicitly +declared inequality operator (“/=”) is a primitive operation of the type. +This is the only reasonable interpretation, and is the one always implemented +by GNAT, but the RM was not entirely clear in making this point. -RM References: 4.08 (5.3/2) 13.11.02 (4) 13.11.02 (17) +RM References: 3.02.03 (6) 6.06 (6) @end itemize -@geindex AI-0179 (Ada 2012 feature) +@geindex AI-0129 (Ada 2012 feature) @itemize * @item -`AI-0179 Statement not required after label (2010-04-10)' +`AI-0129 Limited views and incomplete types (0000-00-00)' -It is not necessary to have a statement following a label, so a label -can appear at the end of a statement sequence without the need for putting a -null statement afterwards, but it is not allowable to have only labels and -no real statements in a statement sequence. +This AI clarifies the description of limited views: a limited view of a +package includes only one view of a type that has an incomplete declaration +and a full declaration (there is no possible ambiguity in a client package). +This AI also fixes an omission: a nested package in the private part has no +limited view. GNAT always implemented this correctly. -RM References: 5.01 (2) +RM References: 10.01.01 (12.2/2) 10.01.01 (12.3/2) @end itemize -@geindex AI-0139-2 (Ada 2012 feature) +@geindex AI-0132 (Ada 2012 feature) @itemize * @item -`AI-0139-2 Syntactic sugar for iterators (2010-09-29)' +`AI-0132 Placement of library unit pragmas (0000-00-00)' -The new syntax for iterating over arrays and containers is now implemented. -Iteration over containers is for now limited to read-only iterators. Only -default iterators are supported, with the syntax: @code{for Elem of C}. +This AI fills a gap in the description of library unit pragmas. The pragma +clearly must apply to a library unit, even if it does not carry the name +of the enclosing unit. GNAT has always enforced the required check. -RM References: 5.05 +RM References: 10.01.05 (7) @end itemize @geindex AI-0134 (Ada 2012 feature) @@ -27604,1129 +27694,1039 @@ parameters must match. GNAT has always enforced this rule. RM References: 6.03.01 (18) @end itemize -@geindex AI-0207 (Ada 2012 feature) +@geindex AI-0137 (Ada 2012 feature) @itemize * @item -`AI-0207 Mode conformance and access constant (0000-00-00)' +`AI-0137 String encoding package (2010-03-25)' -This AI confirms that access_to_constant indication must match for mode -conformance. This was implemented in GNAT when the qualifier was originally -introduced in Ada 2005. +The packages @code{Ada.Strings.UTF_Encoding}, together with its child +packages, @code{Conversions}, @code{Strings}, @code{Wide_Strings}, +and @code{Wide_Wide_Strings} have been +implemented. These packages (whose documentation can be found in the spec +files @code{a-stuten.ads}, @code{a-suenco.ads}, @code{a-suenst.ads}, +@code{a-suewst.ads}, @code{a-suezst.ads}) allow encoding and decoding of +@code{String}, @code{Wide_String}, and @code{Wide_Wide_String} +values using UTF coding schemes (including UTF-8, UTF-16LE, UTF-16BE, and +UTF-16), as well as conversions between the different UTF encodings. With +the exception of @code{Wide_Wide_Strings}, these packages are available in +Ada 95 and Ada 2005 mode as well as Ada 2012 mode. +The @code{Wide_Wide_Strings} package +is available in Ada 2005 mode as well as Ada 2012 mode (but not in Ada 95 +mode since it uses @code{Wide_Wide_Character}). -RM References: 6.03.01 (16/2) +RM References: A.04.11 @end itemize -@geindex AI-0046 (Ada 2012 feature) +@geindex AI-0139-2 (Ada 2012 feature) @itemize * @item -`AI-0046 Null exclusion match for full conformance (2010-07-17)' +`AI-0139-2 Syntactic sugar for iterators (2010-09-29)' -For full conformance, in the case of access parameters, the null exclusion -must match (either both or neither must have @code{not null}). +The new syntax for iterating over arrays and containers is now implemented. +Iteration over containers is for now limited to read-only iterators. Only +default iterators are supported, with the syntax: @code{for Elem of C}. -RM References: 6.03.02 (18) +RM References: 5.05 @end itemize -@geindex AI-0118 (Ada 2012 feature) +@geindex AI-0146 (Ada 2012 feature) @itemize * @item -`AI-0118 The association of parameter associations (0000-00-00)' - -This AI clarifies the rules for named associations in subprogram calls and -generic instantiations. The rules have been in place since Ada 83. - -RM References: 6.04.01 (2) 12.03 (9) -@end itemize - -@geindex AI-0196 (Ada 2012 feature) - +`AI-0146 Type invariants (2009-09-21)' -@itemize * - -@item -`AI-0196 Null exclusion tests for out parameters (0000-00-00)' - -Null exclusion checks are not made for @code{out} parameters when -evaluating the actual parameters. GNAT has never generated these checks. +Type invariants may be specified for private types using the aspect notation. +Aspect @code{Type_Invariant} may be specified for any private type, +@code{Type_Invariant'Class} can +only be specified for tagged types, and is inherited by any descendent of the +tagged types. The invariant is a boolean expression that is tested for being +true in the following situations: conversions to the private type, object +declarations for the private type that are default initialized, and +[`in'] `out' +parameters and returned result on return from any primitive operation for +the type that is visible to a client. +GNAT defines the synonyms @code{Invariant} for @code{Type_Invariant} and +@code{Invariant'Class} for @code{Type_Invariant'Class}. -RM References: 6.04.01 (13) +RM References: 13.03.03 (00) @end itemize -@geindex AI-0015 (Ada 2012 feature) +@geindex AI-0147 (Ada 2012 feature) @itemize * @item -`AI-0015 Constant return objects (0000-00-00)' +`AI-0147 Conditional expressions (2009-03-29)' -The return object declared in an `extended_return_statement' may be -declared constant. This was always intended, and GNAT has always allowed it. +Conditional expressions are permitted. The form of such an expression is: -RM References: 6.05 (2.1/2) 3.03 (10/2) 3.03 (21) 6.05 (5/2) -6.05 (5.7/2) +@example +(if expr then expr @{elsif expr then expr@} [else expr]) +@end example + +The parentheses can be omitted in contexts where parentheses are present +anyway, such as subprogram arguments and pragma arguments. If the `else' +clause is omitted, `else' `True' is assumed; +thus @code{(if A then B)} is a way to conveniently represent +`(A implies B)' in standard logic. + +RM References: 4.03.03 (15) 4.04 (1) 4.04 (7) 4.05.07 (0) 4.07 (2) +4.07 (3) 4.09 (12) 4.09 (33) 5.03 (3) 5.03 (4) 7.05 (2.1/2) @end itemize -@geindex AI-0032 (Ada 2012 feature) +@geindex AI-0152 (Ada 2012 feature) @itemize * @item -`AI-0032 Extended return for class-wide functions (0000-00-00)' +`AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)' -If a function returns a class-wide type, the object of an extended return -statement can be declared with a specific type that is covered by the class- -wide type. This has been implemented in GNAT since the introduction of -extended returns. Note AI-0103 complements this AI by imposing matching -rules for constrained return types. +Restriction @code{No_Anonymous_Allocators} prevents the use of allocators +where the type of the returned value is an anonymous access type. -RM References: 6.05 (5.2/2) 6.05 (5.3/2) 6.05 (5.6/2) 6.05 (5.8/2) -6.05 (8/2) +RM References: H.04 (8/1) @end itemize -@geindex AI-0103 (Ada 2012 feature) +@geindex AI-0157 (Ada 2012 feature) @itemize * @item -`AI-0103 Static matching for extended return (2010-07-23)' +`AI-0157 Allocation/Deallocation from empty pool (2010-07-11)' -If the return subtype of a function is an elementary type or a constrained -type, the subtype indication in an extended return statement must match -statically this return subtype. +Allocation and Deallocation from an empty storage pool (i.e. allocation or +deallocation of a pointer for which a static storage size clause of zero +has been given) is now illegal and is detected as such. GNAT +previously gave a warning but not an error. -RM References: 6.05 (5.2/2) +RM References: 4.08 (5.3/2) 13.11.02 (4) 13.11.02 (17) @end itemize -@geindex AI-0058 (Ada 2012 feature) +@geindex AI-0158 (Ada 2012 feature) @itemize * @item -`AI-0058 Abnormal completion of an extended return (0000-00-00)' +`AI-0158 Generalizing membership tests (2010-09-16)' -The RM had some incorrect wording implying wrong treatment of abnormal -completion in an extended return. GNAT has always implemented the intended -correct semantics as described by this AI. +This AI extends the syntax of membership tests to simplify complex conditions +that can be expressed as membership in a subset of values of any type. It +introduces syntax for a list of expressions that may be used in loop contexts +as well. -RM References: 6.05 (22/2) +RM References: 3.08.01 (5) 4.04 (3) 4.05.02 (3) 4.05.02 (5) 4.05.02 (27) @end itemize -@geindex AI-0050 (Ada 2012 feature) +@geindex AI-0161 (Ada 2012 feature) @itemize * @item -`AI-0050 Raising Constraint_Error early for function call (0000-00-00)' +`AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)' -The implementation permissions for raising @code{Constraint_Error} early on a function call -when it was clear an exception would be raised were over-permissive and allowed -mishandling of discriminants in some cases. GNAT did -not take advantage of these incorrect permissions in any case. +A new restriction @code{No_Default_Stream_Attributes} prevents the use of any +of the default stream attributes for elementary types. If this restriction is +in force, then it is necessary to provide explicit subprograms for any +stream attributes used. -RM References: 6.05 (24/2) +RM References: 13.12.01 (4/2) 13.13.02 (40/2) 13.13.02 (52/2) @end itemize -@geindex AI-0125 (Ada 2012 feature) +@geindex AI-0162 (Ada 2012 feature) @itemize * @item -`AI-0125 Nonoverridable operations of an ancestor (2010-09-28)' +`AI-0162 Incomplete type completed by partial view (2010-09-15)' -In Ada 2012, the declaration of a primitive operation of a type extension -or private extension can also override an inherited primitive that is not -visible at the point of this declaration. +Incomplete types are made more useful by allowing them to be completed by +private types and private extensions. -RM References: 7.03.01 (6) 8.03 (23) 8.03.01 (5/2) 8.03.01 (6/2) +RM References: 3.10.01 (2.5/2) 3.10.01 (2.6/2) 3.10.01 (3) 3.10.01 (4/2) @end itemize -@geindex AI-0062 (Ada 2012 feature) +@geindex AI-0163 (Ada 2012 feature) @itemize * @item -`AI-0062 Null exclusions and deferred constants (0000-00-00)' +`AI-0163 Pragmas in place of null (2010-07-01)' -A full constant may have a null exclusion even if its associated deferred -constant does not. GNAT has always allowed this. +A statement sequence may be composed entirely of pragmas. It is no longer +necessary to add a dummy @code{null} statement to make the sequence legal. -RM References: 7.04 (6/2) 7.04 (7.1/2) +RM References: 2.08 (7) 2.08 (16) @end itemize -@geindex AI-0178 (Ada 2012 feature) +@geindex AI-0171 (Ada 2012 feature) @itemize * @item -`AI-0178 Incomplete views are limited (0000-00-00)' +`AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)' -This AI clarifies the role of incomplete views and plugs an omission in the -RM. GNAT always correctly restricted the use of incomplete views and types. +A new package @code{System.Multiprocessors} is added, together with the +definition of pragma @code{CPU} for controlling task affinity. A new no +dependence restriction, on @code{System.Multiprocessors.Dispatching_Domains}, +is added to the Ravenscar profile. -RM References: 7.05 (3/2) 7.05 (6/2) +RM References: D.13.01 (4/2) D.16 @end itemize -@geindex AI-0087 (Ada 2012 feature) +@geindex AI-0173 (Ada 2012 feature) @itemize * @item -`AI-0087 Actual for formal nonlimited derived type (2010-07-15)' +`AI-0173 Testing if tags represent abstract types (2010-07-03)' -The actual for a formal nonlimited derived type cannot be limited. In -particular, a formal derived type that extends a limited interface but which -is not explicitly limited cannot be instantiated with a limited type. +The function @code{Ada.Tags.Type_Is_Abstract} returns @code{True} if invoked +with the tag of an abstract type, and @code{False} otherwise. -RM References: 7.05 (5/2) 12.05.01 (5.1/2) +RM References: 3.09 (7.4/2) 3.09 (12.4/2) @end itemize -@geindex AI-0099 (Ada 2012 feature) +@geindex AI-0176 (Ada 2012 feature) @itemize * @item -`AI-0099 Tag determines whether finalization needed (0000-00-00)' +`AI-0176 Quantified expressions (2010-09-29)' -This AI clarifies that ‘needs finalization’ is part of dynamic semantics, -and therefore depends on the run-time characteristics of an object (i.e. its -tag) and not on its nominal type. As the AI indicates: “we do not expect -this to affect any implementation’’. +Both universally and existentially quantified expressions are implemented. +They use the new syntax for iterators proposed in AI05-139-2, as well as +the standard Ada loop syntax. -RM References: 7.06.01 (6) 7.06.01 (7) 7.06.01 (8) 7.06.01 (9/2) +RM References: 1.01.04 (12) 2.09 (2/2) 4.04 (7) 4.05.09 (0) @end itemize -@geindex AI-0064 (Ada 2012 feature) +@geindex AI-0177 (Ada 2012 feature) @itemize * @item -`AI-0064 Redundant finalization rule (0000-00-00)' +`AI-0177 Parameterized expressions (2010-07-10)' -This is an editorial change only. The intended behavior is already checked -by an existing ACATS test, which GNAT has always executed correctly. +The new Ada 2012 notion of parameterized expressions is implemented. The form +is: -RM References: 7.06.01 (17.1/1) +@example +function-specification is (expression) +@end example + +This is exactly equivalent to the +corresponding function body that returns the expression, but it can appear +in a package spec. Note that the expression must be parenthesized. + +RM References: 13.11.01 (3/2) @end itemize -@geindex AI-0026 (Ada 2012 feature) +@geindex AI-0178 (Ada 2012 feature) @itemize * @item -`AI-0026 Missing rules for Unchecked_Union (2010-07-07)' +`AI-0178 Incomplete views are limited (0000-00-00)' -Record representation clauses concerning Unchecked_Union types cannot mention -the discriminant of the type. The type of a component declared in the variant -part of an Unchecked_Union cannot be controlled, have controlled components, -nor have protected or task parts. If an Unchecked_Union type is declared -within the body of a generic unit or its descendants, then the type of a -component declared in the variant part cannot be a formal private type or a -formal private extension declared within the same generic unit. +This AI clarifies the role of incomplete views and plugs an omission in the +RM. GNAT always correctly restricted the use of incomplete views and types. -RM References: 7.06 (9.4/2) B.03.03 (9/2) B.03.03 (10/2) +RM References: 7.05 (3/2) 7.05 (6/2) @end itemize -@geindex AI-0205 (Ada 2012 feature) +@geindex AI-0179 (Ada 2012 feature) @itemize * @item -`AI-0205 Extended return declares visible name (0000-00-00)' +`AI-0179 Statement not required after label (2010-04-10)' -This AI corrects a simple omission in the RM. Return objects have always -been visible within an extended return statement. +It is not necessary to have a statement following a label, so a label +can appear at the end of a statement sequence without the need for putting a +null statement afterwards, but it is not allowable to have only labels and +no real statements in a statement sequence. -RM References: 8.03 (17) +RM References: 5.01 (2) @end itemize -@geindex AI-0042 (Ada 2012 feature) +@geindex AI-0181 (Ada 2012 feature) @itemize * @item -`AI-0042 Overriding versus implemented-by (0000-00-00)' +`AI-0181 Soft hyphen is a non-graphic character (2010-07-23)' -This AI fixes a wording gap in the RM. An operation of a synchronized -interface can be implemented by a protected or task entry, but the abstract -operation is not being overridden in the usual sense, and it must be stated -separately that this implementation is legal. This has always been the case -in GNAT. +From Ada 2005 on, soft hyphen is considered a non-graphic character, which +means that it has a special name (@code{SOFT_HYPHEN}) in conjunction with the +@code{Image} and @code{Value} attributes for the character types. Strictly +speaking this is an inconsistency with Ada 95, but in practice the use of +these attributes is so obscure that it will not cause problems. -RM References: 9.01 (9.2/2) 9.04 (11.1/2) +RM References: 3.05.02 (2/2) A.01 (35/2) A.03.03 (21) @end itemize -@geindex AI-0030 (Ada 2012 feature) +@geindex AI-0182 (Ada 2012 feature) @itemize * @item -`AI-0030 Requeue on synchronized interfaces (2010-07-19)' +`AI-0182 Additional forms for' @code{Character'Value} `(0000-00-00)' -Requeue is permitted to a protected, synchronized or task interface primitive -providing it is known that the overriding operation is an entry. Otherwise -the requeue statement has the same effect as a procedure call. Use of pragma -@code{Implemented} provides a way to impose a static requirement on the -overriding operation by adhering to one of the implementation kinds: entry, -protected procedure or any of the above. +This AI allows @code{Character'Value} to accept the string @code{'?'} where +@code{?} is any character including non-graphic control characters. GNAT has +always accepted such strings. It also allows strings such as +@code{HEX_00000041} to be accepted, but GNAT does not take advantage of this +permission and raises @code{Constraint_Error}, as is certainly still +permitted. -RM References: 9.05 (9) 9.05.04 (2) 9.05.04 (3) 9.05.04 (5) -9.05.04 (6) 9.05.04 (7) 9.05.04 (12) +RM References: 3.05 (56/2) @end itemize -@geindex AI-0201 (Ada 2012 feature) +@geindex AI-0183 (Ada 2012 feature) @itemize * @item -`AI-0201 Independence of atomic object components (2010-07-22)' - -If an Atomic object has a pragma @code{Pack} or a @code{Component_Size} -attribute, then individual components may not be addressable by independent -tasks. However, if the representation clause has no effect (is confirming), -then independence is not compromised. Furthermore, in GNAT, specification of -other appropriately addressable component sizes (e.g. 16 for 8-bit -characters) also preserves independence. GNAT now gives very clear warnings -both for the declaration of such a type, and for any assignment to its components. +`AI-0183 Aspect specifications (2010-08-16)' -RM References: 9.10 (1/3) C.06 (22/2) C.06 (23/2) +Aspect specifications have been fully implemented except for pre and post- +conditions, and type invariants, which have their own separate AI’s. All +forms of declarations listed in the AI are supported. The following is a +list of the aspects supported (with GNAT implementation aspects marked) @end itemize -@geindex AI-0009 (Ada 2012 feature) +@multitable {xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx} {xxxxxxxxxxxxx} +@headitem -@itemize * +Supported Aspect -@item -`AI-0009 Pragma Independent[_Components] (2010-07-23)' +@tab -This AI introduces the new pragmas @code{Independent} and -@code{Independent_Components}, -which control guaranteeing independence of access to objects and components. -The AI also requires independence not unaffected by confirming rep clauses. +Source -RM References: 9.10 (1) 13.01 (15/1) 13.02 (9) 13.03 (13) C.06 (2) -C.06 (4) C.06 (6) C.06 (9) C.06 (13) C.06 (14) -@end itemize +@item -@geindex AI-0072 (Ada 2012 feature) +@code{Ada_2005} +@tab -@itemize * +– GNAT -@item -`AI-0072 Task signalling using ‘Terminated (0000-00-00)' +@item -This AI clarifies that task signalling for reading @code{'Terminated} only -occurs if the result is True. GNAT semantics has always been consistent with -this notion of task signalling. +@code{Ada_2012} -RM References: 9.10 (6.1/1) -@end itemize +@tab -@geindex AI-0108 (Ada 2012 feature) +– GNAT +@item -@itemize * +@code{Address} -@item -`AI-0108 Limited incomplete view and discriminants (0000-00-00)' +@tab -This AI confirms that an incomplete type from a limited view does not have -discriminants. This has always been the case in GNAT. +@item -RM References: 10.01.01 (12.3/2) -@end itemize +@code{Alignment} -@geindex AI-0129 (Ada 2012 feature) +@tab +@item -@itemize * +@code{Atomic} -@item -`AI-0129 Limited views and incomplete types (0000-00-00)' +@tab -This AI clarifies the description of limited views: a limited view of a -package includes only one view of a type that has an incomplete declaration -and a full declaration (there is no possible ambiguity in a client package). -This AI also fixes an omission: a nested package in the private part has no -limited view. GNAT always implemented this correctly. +@item -RM References: 10.01.01 (12.2/2) 10.01.01 (12.3/2) -@end itemize +@code{Atomic_Components} -@geindex AI-0077 (Ada 2012 feature) +@tab +@item -@itemize * +@code{Bit_Order} -@item -`AI-0077 Limited withs and scope of declarations (0000-00-00)' +@tab -This AI clarifies that a declaration does not include a context clause, -and confirms that it is illegal to have a context in which both a limited -and a nonlimited view of a package are accessible. Such double visibility -was always rejected by GNAT. +@item -RM References: 10.01.02 (12/2) 10.01.02 (21/2) 10.01.02 (22/2) -@end itemize +@code{Component_Size} -@geindex AI-0122 (Ada 2012 feature) +@tab +@item -@itemize * +@code{Contract_Cases} -@item -`AI-0122 Private with and children of generics (0000-00-00)' +@tab -This AI clarifies the visibility of private children of generic units within -instantiations of a parent. GNAT has always handled this correctly. +– GNAT -RM References: 10.01.02 (12/2) -@end itemize +@item -@geindex AI-0040 (Ada 2012 feature) +@code{Discard_Names} +@tab -@itemize * +@item -@item -`AI-0040 Limited with clauses on descendant (0000-00-00)' +@code{External_Tag} -This AI confirms that a limited with clause in a child unit cannot name -an ancestor of the unit. This has always been checked in GNAT. +@tab -RM References: 10.01.02 (20/2) -@end itemize +@item -@geindex AI-0132 (Ada 2012 feature) +@code{Favor_Top_Level} +@tab -@itemize * +– GNAT -@item -`AI-0132 Placement of library unit pragmas (0000-00-00)' +@item -This AI fills a gap in the description of library unit pragmas. The pragma -clearly must apply to a library unit, even if it does not carry the name -of the enclosing unit. GNAT has always enforced the required check. +@code{Inline} -RM References: 10.01.05 (7) -@end itemize +@tab -@geindex AI-0034 (Ada 2012 feature) +@item +@code{Inline_Always} -@itemize * +@tab -@item -`AI-0034 Categorization of limited views (0000-00-00)' +– GNAT -The RM makes certain limited with clauses illegal because of categorization -considerations, when the corresponding normal with would be legal. This is -not intended, and GNAT has always implemented the recommended behavior. +@item -RM References: 10.02.01 (11/1) 10.02.01 (17/2) -@end itemize +@code{Invariant} -@geindex AI-0035 (Ada 2012 feature) +@tab +– GNAT -@itemize * +@item -@item -`AI-0035 Inconsistencies with Pure units (0000-00-00)' +@code{Machine_Radix} -This AI remedies some inconsistencies in the legality rules for Pure units. -Derived access types are legal in a pure unit (on the assumption that the -rule for a zero storage pool size has been enforced on the ancestor type). -The rules are enforced in generic instances and in subunits. GNAT has always -implemented the recommended behavior. +@tab -RM References: 10.02.01 (15.1/2) 10.02.01 (15.4/2) 10.02.01 (15.5/2) 10.02.01 (17/2) -@end itemize +@item -@geindex AI-0219 (Ada 2012 feature) +@code{No_Return} +@tab -@itemize * +@item -@item -`AI-0219 Pure permissions and limited parameters (2010-05-25)' +@code{Object_Size} -This AI refines the rules for the cases with limited parameters which do not -allow the implementations to omit ‘redundant’. GNAT now properly conforms -to the requirements of this binding interpretation. +@tab -RM References: 10.02.01 (18/2) -@end itemize +– GNAT -@geindex AI-0043 (Ada 2012 feature) +@item +@code{Pack} -@itemize * +@tab -@item -`AI-0043 Rules about raising exceptions (0000-00-00)' +@item -This AI covers various omissions in the RM regarding the raising of -exceptions. GNAT has always implemented the intended semantics. +@code{Persistent_BSS} -RM References: 11.04.01 (10.1/2) 11 (2) -@end itemize +@tab -@geindex AI-0200 (Ada 2012 feature) +– GNAT +@item -@itemize * +@code{Post} -@item -`AI-0200 Mismatches in formal package declarations (0000-00-00)' +@tab -This AI plugs a gap in the RM which appeared to allow some obviously intended -illegal instantiations. GNAT has never allowed these instantiations. +@item -RM References: 12.07 (16) -@end itemize +@code{Pre} -@geindex AI-0112 (Ada 2012 feature) +@tab +@item -@itemize * +@code{Predicate} -@item -`AI-0112 Detection of duplicate pragmas (2010-07-24)' +@tab -This AI concerns giving names to various representation aspects, but the -practical effect is simply to make the use of duplicate -@code{Atomic[_Components]}, -@code{Volatile[_Components]}, and -@code{Independent[_Components]} pragmas illegal, and GNAT -now performs this required check. +@item -RM References: 13.01 (8) -@end itemize +@code{Preelaborable_Initialization} -@geindex AI-0106 (Ada 2012 feature) +@tab +@item -@itemize * +@code{Pure_Function} -@item -`AI-0106 No representation pragmas on generic formals (0000-00-00)' +@tab -The RM appeared to allow representation pragmas on generic formal parameters, -but this was not intended, and GNAT has never permitted this usage. +– GNAT -RM References: 13.01 (9.1/1) -@end itemize +@item -@geindex AI-0012 (Ada 2012 feature) +@code{Remote_Access_Type} +@tab -@itemize * +– GNAT -@item -`AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)' +@item -It is now illegal to give an inappropriate component size or a pragma -@code{Pack} that attempts to change the component size in the case of atomic -or aliased components. Previously GNAT ignored such an attempt with a -warning. +@code{Shared} -RM References: 13.02 (6.1/2) 13.02 (7) C.06 (10) C.06 (11) C.06 (21) -@end itemize +@tab -@geindex AI-0039 (Ada 2012 feature) +– GNAT +@item -@itemize * +@code{Size} -@item -`AI-0039 Stream attributes cannot be dynamic (0000-00-00)' +@tab -The RM permitted the use of dynamic expressions (such as @code{ptr.all})` -for stream attributes, but these were never useful and are now illegal. GNAT -has always regarded such expressions as illegal. +@item -RM References: 13.03 (4) 13.03 (6) 13.13.02 (38/2) -@end itemize +@code{Storage_Pool} -@geindex AI-0095 (Ada 2012 feature) +@tab + +@item + +@code{Storage_Size} + +@tab + +@item +@code{Stream_Size} -@itemize * +@tab -@item -`AI-0095 Address of intrinsic subprograms (0000-00-00)' +@item -The prefix of @code{'Address} cannot statically denote a subprogram with -convention @code{Intrinsic}. The use of the @code{Address} attribute raises -@code{Program_Error} if the prefix denotes a subprogram with convention -@code{Intrinsic}. +@code{Suppress} -RM References: 13.03 (11/1) -@end itemize +@tab -@geindex AI-0116 (Ada 2012 feature) +@item +@code{Suppress_Debug_Info} -@itemize * +@tab -@item -`AI-0116 Alignment of class-wide objects (0000-00-00)' +– GNAT -This AI requires that the alignment of a class-wide object be no greater -than the alignment of any type in the class. GNAT has always followed this -recommendation. +@item -RM References: 13.03 (29) 13.11 (16) -@end itemize +@code{Test_Case} -@geindex AI-0146 (Ada 2012 feature) +@tab +– GNAT -@itemize * +@item -@item -`AI-0146 Type invariants (2009-09-21)' +@code{Thread_Local_Storage} -Type invariants may be specified for private types using the aspect notation. -Aspect @code{Type_Invariant} may be specified for any private type, -@code{Type_Invariant'Class} can -only be specified for tagged types, and is inherited by any descendent of the -tagged types. The invariant is a boolean expression that is tested for being -true in the following situations: conversions to the private type, object -declarations for the private type that are default initialized, and -[`in'] `out' -parameters and returned result on return from any primitive operation for -the type that is visible to a client. -GNAT defines the synonyms @code{Invariant} for @code{Type_Invariant} and -@code{Invariant'Class} for @code{Type_Invariant'Class}. +@tab -RM References: 13.03.03 (00) -@end itemize +– GNAT -@geindex AI-0078 (Ada 2012 feature) +@item +@code{Type_Invariant} -@itemize * +@tab -@item -`AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)' +@item -In Ada 2012, compilers are required to support unchecked conversion where the -target alignment is a multiple of the source alignment. GNAT always supported -this case (and indeed all cases of differing alignments, doing copies where -required if the alignment was reduced). +@code{Unchecked_Union} -RM References: 13.09 (7) -@end itemize +@tab -@geindex AI-0195 (Ada 2012 feature) +@item +@code{Universal_Aliasing} -@itemize * +@tab -@item -`AI-0195 Invalid value handling is implementation defined (2010-07-03)' +– GNAT -The handling of invalid values is now designated to be implementation -defined. This is a documentation change only, requiring Annex M in the GNAT -Reference Manual to document this handling. -In GNAT, checks for invalid values are made -only when necessary to avoid erroneous behavior. Operations like assignments -which cannot cause erroneous behavior ignore the possibility of invalid -values and do not do a check. The date given above applies only to the -documentation change, this behavior has always been implemented by GNAT. +@item -RM References: 13.09.01 (10) -@end itemize +@code{Unmodified} -@geindex AI-0193 (Ada 2012 feature) +@tab +– GNAT -@itemize * +@item -@item -`AI-0193 Alignment of allocators (2010-09-16)' +@code{Unreferenced} -This AI introduces a new attribute @code{Max_Alignment_For_Allocation}, -analogous to @code{Max_Size_In_Storage_Elements}, but for alignment instead -of size. +@tab -RM References: 13.11 (16) 13.11 (21) 13.11.01 (0) 13.11.01 (1) -13.11.01 (2) 13.11.01 (3) -@end itemize +– GNAT -@geindex AI-0177 (Ada 2012 feature) +@item +@code{Unreferenced_Objects} -@itemize * +@tab -@item -`AI-0177 Parameterized expressions (2010-07-10)' +– GNAT -The new Ada 2012 notion of parameterized expressions is implemented. The form -is: +@item -@example -function-specification is (expression) -@end example +@code{Unsuppress} -This is exactly equivalent to the -corresponding function body that returns the expression, but it can appear -in a package spec. Note that the expression must be parenthesized. +@tab -RM References: 13.11.01 (3/2) -@end itemize +@item -@geindex AI-0033 (Ada 2012 feature) +@code{Value_Size} +@tab -@itemize * +– GNAT -@item -`AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)' +@item -Neither of these two pragmas may appear within a generic template, because -the generic might be instantiated at other than the library level. +@code{Volatile} -RM References: 13.11.02 (16) C.03.01 (7/2) C.03.01 (8/2) -@end itemize +@tab -@geindex AI-0161 (Ada 2012 feature) +@item +@code{Volatile_Components} -@itemize * +@tab -@item -`AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)' +@item -A new restriction @code{No_Default_Stream_Attributes} prevents the use of any -of the default stream attributes for elementary types. If this restriction is -in force, then it is necessary to provide explicit subprograms for any -stream attributes used. +@code{Warnings} -RM References: 13.12.01 (4/2) 13.13.02 (40/2) 13.13.02 (52/2) -@end itemize +@tab -@geindex AI-0194 (Ada 2012 feature) +– GNAT +@end multitable -@itemize * -@item -`AI-0194 Value of Stream_Size attribute (0000-00-00)' +@quotation -The @code{Stream_Size} attribute returns the default number of bits in the -stream representation of the given type. -This value is not affected by the presence -of stream subprogram attributes for the type. GNAT has always implemented -this interpretation. +Note that for aspects with an expression, e.g. @code{Size}, the expression is +treated like a default expression (visibility is analyzed at the point of +occurrence of the aspect, but evaluation of the expression occurs at the +freeze point of the entity involved). -RM References: 13.13.02 (1.2/2) -@end itemize +RM References: 3.02.01 (3) 3.02.02 (2) 3.03.01 (2/2) 3.08 (6) +3.09.03 (1.1/2) 6.01 (2/2) 6.07 (2/2) 9.05.02 (2/2) 7.01 (3) 7.03 +(2) 7.03 (3) 9.01 (2/2) 9.01 (3/2) 9.04 (2/2) 9.04 (3/2) +9.05.02 (2/2) 11.01 (2) 12.01 (3) 12.03 (2/2) 12.04 (2/2) 12.05 (2) +12.06 (2.1/2) 12.06 (2.2/2) 12.07 (2) 13.01 (0.1/2) 13.03 (5/1) +13.03.01 (0) +@end quotation -@geindex AI-0109 (Ada 2012 feature) +@geindex AI-0185 (Ada 2012 feature) @itemize * @item -`AI-0109 Redundant check in S’Class’Input (0000-00-00)' +`AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)' -This AI is an editorial change only. It removes the need for a tag check -that can never fail. +Two new packages @code{Ada.Wide_[Wide_]Characters.Handling} provide +classification functions for @code{Wide_Character} and +@code{Wide_Wide_Character}, as well as providing +case folding routines for @code{Wide_[Wide_]Character} and +@code{Wide_[Wide_]String}. -RM References: 13.13.02 (34/2) +RM References: A.03.05 (0) A.03.06 (0) @end itemize -@geindex AI-0007 (Ada 2012 feature) +@geindex AI-0188 (Ada 2012 feature) @itemize * @item -`AI-0007 Stream read and private scalar types (0000-00-00)' +`AI-0188 Case expressions (2010-01-09)' -The RM as written appeared to limit the possibilities of declaring read -attribute procedures for private scalar types. This limitation was not -intended, and has never been enforced by GNAT. +Case expressions are permitted. This allows use of constructs such as: -RM References: 13.13.02 (50/2) 13.13.02 (51/2) +@example +X := (case Y is when 1 => 2, when 2 => 3, when others => 31) +@end example + +RM References: 4.05.07 (0) 4.05.08 (0) 4.09 (12) 4.09 (33) @end itemize -@geindex AI-0065 (Ada 2012 feature) +@geindex AI-0189 (Ada 2012 feature) @itemize * @item -`AI-0065 Remote access types and external streaming (0000-00-00)' +`AI-0189 No_Allocators_After_Elaboration (2010-01-23)' -This AI clarifies the fact that all remote access types support external -streaming. This fixes an obvious oversight in the definition of the -language, and GNAT always implemented the intended correct rules. +This AI introduces a new restriction @code{No_Allocators_After_Elaboration}, +which says that no dynamic allocation will occur once elaboration is +completed. +In general this requires a run-time check, which is not required, and which +GNAT does not attempt. But the static cases of allocators in a task body or +in the body of the main program are detected and flagged at compile or bind +time. -RM References: 13.13.02 (52/2) +RM References: D.07 (19.1/2) H.04 (23.3/2) @end itemize -@geindex AI-0019 (Ada 2012 feature) +@geindex AI-0190 (Ada 2012 feature) @itemize * @item -`AI-0019 Freezing of primitives for tagged types (0000-00-00)' +`AI-0190 pragma Default_Storage_Pool (2010-09-15)' -The RM suggests that primitive subprograms of a specific tagged type are -frozen when the tagged type is frozen. This would be an incompatible change -and is not intended. GNAT has never attempted this kind of freezing and its -behavior is consistent with the recommendation of this AI. +This AI introduces a new pragma @code{Default_Storage_Pool}, which can be +used to control storage pools globally. +In particular, you can force every access +type that is used for allocation (`new') to have an explicit storage pool, +or you can declare a pool globally to be used for all access types that lack +an explicit one. -RM References: 13.14 (2) 13.14 (3/1) 13.14 (8.1/1) 13.14 (10) 13.14 (14) 13.14 (15.1/2) +RM References: D.07 (8) @end itemize -@geindex AI-0017 (Ada 2012 feature) +@geindex AI-0193 (Ada 2012 feature) @itemize * @item -`AI-0017 Freezing and incomplete types (0000-00-00)' +`AI-0193 Alignment of allocators (2010-09-16)' -So-called ‘Taft-amendment types’ (i.e., types that are completed in package -bodies) are not frozen by the occurrence of bodies in the -enclosing declarative part. GNAT always implemented this properly. +This AI introduces a new attribute @code{Max_Alignment_For_Allocation}, +analogous to @code{Max_Size_In_Storage_Elements}, but for alignment instead +of size. -RM References: 13.14 (3/1) +RM References: 13.11 (16) 13.11 (21) 13.11.01 (0) 13.11.01 (1) +13.11.01 (2) 13.11.01 (3) @end itemize -@geindex AI-0060 (Ada 2012 feature) +@geindex AI-0194 (Ada 2012 feature) @itemize * @item -`AI-0060 Extended definition of remote access types (0000-00-00)' +`AI-0194 Value of Stream_Size attribute (0000-00-00)' -This AI extends the definition of remote access types to include access -to limited, synchronized, protected or task class-wide interface types. -GNAT already implemented this extension. +The @code{Stream_Size} attribute returns the default number of bits in the +stream representation of the given type. +This value is not affected by the presence +of stream subprogram attributes for the type. GNAT has always implemented +this interpretation. -RM References: A (4) E.02.02 (9/1) E.02.02 (9.2/1) E.02.02 (14/2) E.02.02 (18) +RM References: 13.13.02 (1.2/2) @end itemize -@geindex AI-0114 (Ada 2012 feature) +@geindex AI-0195 (Ada 2012 feature) @itemize * @item -`AI-0114 Classification of letters (0000-00-00)' +`AI-0195 Invalid value handling is implementation defined (2010-07-03)' -The code points 170 (@code{FEMININE ORDINAL INDICATOR}), -181 (@code{MICRO SIGN}), and -186 (@code{MASCULINE ORDINAL INDICATOR}) are technically considered -lower case letters by Unicode. -However, they are not allowed in identifiers, and they -return @code{False} to @code{Ada.Characters.Handling.Is_Letter/Is_Lower}. -This behavior is consistent with that defined in Ada 95. +The handling of invalid values is now designated to be implementation +defined. This is a documentation change only, requiring Annex M in the GNAT +Reference Manual to document this handling. +In GNAT, checks for invalid values are made +only when necessary to avoid erroneous behavior. Operations like assignments +which cannot cause erroneous behavior ignore the possibility of invalid +values and do not do a check. The date given above applies only to the +documentation change, this behavior has always been implemented by GNAT. -RM References: A.03.02 (59) A.04.06 (7) +RM References: 13.09.01 (10) @end itemize -@geindex AI-0185 (Ada 2012 feature) +@geindex AI-0196 (Ada 2012 feature) @itemize * @item -`AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)' +`AI-0196 Null exclusion tests for out parameters (0000-00-00)' -Two new packages @code{Ada.Wide_[Wide_]Characters.Handling} provide -classification functions for @code{Wide_Character} and -@code{Wide_Wide_Character}, as well as providing -case folding routines for @code{Wide_[Wide_]Character} and -@code{Wide_[Wide_]String}. +Null exclusion checks are not made for @code{out} parameters when +evaluating the actual parameters. GNAT has never generated these checks. -RM References: A.03.05 (0) A.03.06 (0) +RM References: 6.04.01 (13) @end itemize -@geindex AI-0031 (Ada 2012 feature) +@geindex AI-0198 (Ada 2012 feature) @itemize * @item -`AI-0031 Add From parameter to Find_Token (2010-07-25)' +`AI-0198 Inheriting abstract operators (0000-00-00)' -A new version of @code{Find_Token} is added to all relevant string packages, -with an extra parameter @code{From}. Instead of starting at the first -character of the string, the search for a matching Token starts at the -character indexed by the value of @code{From}. -These procedures are available in all versions of Ada -but if used in versions earlier than Ada 2012 they will generate a warning -that an Ada 2012 subprogram is being used. +This AI resolves a conflict between two rules involving inherited abstract +operations and predefined operators. If a derived numeric type inherits +an abstract operator, it overrides the predefined one. This interpretation +was always the one implemented in GNAT. -RM References: A.04.03 (16) A.04.03 (67) A.04.03 (68/1) A.04.04 (51) -A.04.05 (46) +RM References: 3.09.03 (4/3) @end itemize -@geindex AI-0056 (Ada 2012 feature) +@geindex AI-0199 (Ada 2012 feature) @itemize * @item -`AI-0056 Index on null string returns zero (0000-00-00)' +`AI-0199 Aggregate with anonymous access components (2010-07-14)' -The wording in the Ada 2005 RM implied an incompatible handling of the -@code{Index} functions, resulting in raising an exception instead of -returning zero in some situations. -This was not intended and has been corrected. -GNAT always returned zero, and is thus consistent with this AI. +A choice list in a record aggregate can include several components of +(distinct) anonymous access types as long as they have matching designated +subtypes. -RM References: A.04.03 (56.2/2) A.04.03 (58.5/2) +RM References: 4.03.01 (16) @end itemize -@geindex AI-0137 (Ada 2012 feature) +@geindex AI-0200 (Ada 2012 feature) @itemize * @item -`AI-0137 String encoding package (2010-03-25)' +`AI-0200 Mismatches in formal package declarations (0000-00-00)' -The packages @code{Ada.Strings.UTF_Encoding}, together with its child -packages, @code{Conversions}, @code{Strings}, @code{Wide_Strings}, -and @code{Wide_Wide_Strings} have been -implemented. These packages (whose documentation can be found in the spec -files @code{a-stuten.ads}, @code{a-suenco.ads}, @code{a-suenst.ads}, -@code{a-suewst.ads}, @code{a-suezst.ads}) allow encoding and decoding of -@code{String}, @code{Wide_String}, and @code{Wide_Wide_String} -values using UTF coding schemes (including UTF-8, UTF-16LE, UTF-16BE, and -UTF-16), as well as conversions between the different UTF encodings. With -the exception of @code{Wide_Wide_Strings}, these packages are available in -Ada 95 and Ada 2005 mode as well as Ada 2012 mode. -The @code{Wide_Wide_Strings} package -is available in Ada 2005 mode as well as Ada 2012 mode (but not in Ada 95 -mode since it uses @code{Wide_Wide_Character}). +This AI plugs a gap in the RM which appeared to allow some obviously intended +illegal instantiations. GNAT has never allowed these instantiations. -RM References: A.04.11 +RM References: 12.07 (16) @end itemize -@geindex AI-0038 (Ada 2012 feature) +@geindex AI-0201 (Ada 2012 feature) @itemize * @item -`AI-0038 Minor errors in Text_IO (0000-00-00)' +`AI-0201 Independence of atomic object components (2010-07-22)' -These are minor errors in the description on three points. The intent on -all these points has always been clear, and GNAT has always implemented the -correct intended semantics. +If an Atomic object has a pragma @code{Pack} or a @code{Component_Size} +attribute, then individual components may not be addressable by independent +tasks. However, if the representation clause has no effect (is confirming), +then independence is not compromised. Furthermore, in GNAT, specification of +other appropriately addressable component sizes (e.g. 16 for 8-bit +characters) also preserves independence. GNAT now gives very clear warnings +both for the declaration of such a type, and for any assignment to its components. -RM References: A.10.05 (37) A.10.07 (8/1) A.10.07 (10) A.10.07 (12) A.10.08 (10) A.10.08 (24) +RM References: 9.10 (1/3) C.06 (22/2) C.06 (23/2) @end itemize -@geindex AI-0044 (Ada 2012 feature) +@geindex AI-0203 (Ada 2012 feature) @itemize * @item -`AI-0044 Restrictions on container instantiations (0000-00-00)' +`AI-0203 Extended return cannot be abstract (0000-00-00)' -This AI places restrictions on allowed instantiations of generic containers. -These restrictions are not checked by the compiler, so there is nothing to -change in the implementation. This affects only the RM documentation. +A return_subtype_indication cannot denote an abstract subtype. GNAT has never +permitted such usage. -RM References: A.18 (4/2) A.18.02 (231/2) A.18.03 (145/2) A.18.06 (56/2) A.18.08 (66/2) A.18.09 (79/2) A.18.26 (5/2) A.18.26 (9/2) +RM References: 3.09.03 (8/3) @end itemize -@geindex AI-0127 (Ada 2012 feature) +@geindex AI-0205 (Ada 2012 feature) @itemize * @item -`AI-0127 Adding Locale Capabilities (2010-09-29)' +`AI-0205 Extended return declares visible name (0000-00-00)' -This package provides an interface for identifying the current locale. +This AI corrects a simple omission in the RM. Return objects have always +been visible within an extended return statement. -RM References: A.19 A.19.01 A.19.02 A.19.03 A.19.05 A.19.06 -A.19.07 A.19.08 A.19.09 A.19.10 A.19.11 A.19.12 A.19.13 +RM References: 8.03 (17) @end itemize -@geindex AI-0002 (Ada 2012 feature) +@geindex AI-0206 (Ada 2012 feature) @itemize * @item -`AI-0002 Export C with unconstrained arrays (0000-00-00)' +`AI-0206 Remote types packages and preelaborate (2010-07-24)' -The compiler is not required to support exporting an Ada subprogram with -convention C if there are parameters or a return type of an unconstrained -array type (such as @code{String}). GNAT allows such declarations but -generates warnings. It is possible, but complicated, to write the -corresponding C code and certainly such code would be specific to GNAT and -non-portable. +Remote types packages are now allowed to depend on preelaborated packages. +This was formerly considered illegal. -RM References: B.01 (17) B.03 (62) B.03 (71.1/2) +RM References: E.02.02 (6) @end itemize -@geindex AI-0216 (Ada 2012 feature) +@geindex AI-0207 (Ada 2012 feature) @itemize * @item -`AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)' +`AI-0207 Mode conformance and access constant (0000-00-00)' -It is clearly the intention that @code{No_Task_Hierarchy} is intended to -forbid tasks declared locally within subprograms, or functions returning task -objects, and that is the implementation that GNAT has always provided. -However the language in the RM was not sufficiently clear on this point. -Thus this is a documentation change in the RM only. +This AI confirms that access_to_constant indication must match for mode +conformance. This was implemented in GNAT when the qualifier was originally +introduced in Ada 2005. -RM References: D.07 (3/3) +RM References: 6.03.01 (16/2) @end itemize -@geindex AI-0211 (Ada 2012 feature) +@geindex AI-0208 (Ada 2012 feature) @itemize * @item -`AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)' +`AI-0208 Characteristics of incomplete views (0000-00-00)' -The restriction @code{No_Relative_Delays} forbids any calls to the subprogram -@code{Ada.Real_Time.Timing_Events.Set_Handler}. +The wording in the Ada 2005 RM concerning characteristics of incomplete views +was incorrect and implied that some programs intended to be legal were now +illegal. GNAT had never considered such programs illegal, so it has always +implemented the intent of this AI. -RM References: D.07 (5) D.07 (10/2) D.07 (10.4/2) D.07 (10.7/2) +RM References: 3.10.01 (2.4/2) 3.10.01 (2.6/2) @end itemize -@geindex AI-0190 (Ada 2012 feature) +@geindex AI-0210 (Ada 2012 feature) @itemize * @item -`AI-0190 pragma Default_Storage_Pool (2010-09-15)' +`AI-0210 Correct Timing_Events metric (0000-00-00)' -This AI introduces a new pragma @code{Default_Storage_Pool}, which can be -used to control storage pools globally. -In particular, you can force every access -type that is used for allocation (`new') to have an explicit storage pool, -or you can declare a pool globally to be used for all access types that lack -an explicit one. +This is a documentation only issue regarding wording of metric requirements, +that does not affect the implementation of the compiler. -RM References: D.07 (8) +RM References: D.15 (24/2) @end itemize -@geindex AI-0189 (Ada 2012 feature) +@geindex AI-0211 (Ada 2012 feature) @itemize * @item -`AI-0189 No_Allocators_After_Elaboration (2010-01-23)' +`AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)' -This AI introduces a new restriction @code{No_Allocators_After_Elaboration}, -which says that no dynamic allocation will occur once elaboration is -completed. -In general this requires a run-time check, which is not required, and which -GNAT does not attempt. But the static cases of allocators in a task body or -in the body of the main program are detected and flagged at compile or bind -time. +The restriction @code{No_Relative_Delays} forbids any calls to the subprogram +@code{Ada.Real_Time.Timing_Events.Set_Handler}. -RM References: D.07 (19.1/2) H.04 (23.3/2) +RM References: D.07 (5) D.07 (10/2) D.07 (10.4/2) D.07 (10.7/2) @end itemize -@geindex AI-0171 (Ada 2012 feature) +@geindex AI-0214 (Ada 2012 feature) @itemize * @item -`AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)' +`AI-0214 Defaulted discriminants for limited tagged (2010-10-01)' -A new package @code{System.Multiprocessors} is added, together with the -definition of pragma @code{CPU} for controlling task affinity. A new no -dependence restriction, on @code{System.Multiprocessors.Dispatching_Domains}, -is added to the Ravenscar profile. +Ada 2012 relaxes the restriction that forbids discriminants of tagged types +to have default expressions by allowing them when the type is limited. It +is often useful to define a default value for a discriminant even though +it can’t be changed by assignment. -RM References: D.13.01 (4/2) D.16 +RM References: 3.07 (9.1/2) 3.07.02 (3) @end itemize -@geindex AI-0210 (Ada 2012 feature) +@geindex AI-0216 (Ada 2012 feature) @itemize * @item -`AI-0210 Correct Timing_Events metric (0000-00-00)' +`AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)' -This is a documentation only issue regarding wording of metric requirements, -that does not affect the implementation of the compiler. +It is clearly the intention that @code{No_Task_Hierarchy} is intended to +forbid tasks declared locally within subprograms, or functions returning task +objects, and that is the implementation that GNAT has always provided. +However the language in the RM was not sufficiently clear on this point. +Thus this is a documentation change in the RM only. -RM References: D.15 (24/2) +RM References: D.07 (3/3) @end itemize -@geindex AI-0206 (Ada 2012 feature) +@geindex AI-0219 (Ada 2012 feature) @itemize * @item -`AI-0206 Remote types packages and preelaborate (2010-07-24)' +`AI-0219 Pure permissions and limited parameters (2010-05-25)' -Remote types packages are now allowed to depend on preelaborated packages. -This was formerly considered illegal. +This AI refines the rules for the cases with limited parameters which do not +allow the implementations to omit ‘redundant’. GNAT now properly conforms +to the requirements of this binding interpretation. -RM References: E.02.02 (6) +RM References: 10.02.01 (18/2) @end itemize -@geindex AI-0152 (Ada 2012 feature) +@geindex AI-0220 (Ada 2012 feature) @itemize * @item -`AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)' +`AI-0220 Needed components for aggregates (0000-00-00)' -Restriction @code{No_Anonymous_Allocators} prevents the use of allocators -where the type of the returned value is an anonymous access type. +This AI addresses a wording problem in the RM that appears to permit some +complex cases of aggregates with nonstatic discriminants. GNAT has always +implemented the intended semantics. -RM References: H.04 (8/1) +RM References: 4.03.01 (17) @end itemize @node GNAT language extensions,Security Hardening Features,Implementation of Ada 2012 Features,Top