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

Message ID	20240521073035.314024-8-poulhies@adacore.com
State	New
Headers	show Return-Path: <gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org> DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 8F35E3858408 From: =?utf-8?q?Marc_Poulhi=C3=A8s?= <poulhies@adacore.com> To: gcc-patches@gcc.gnu.org Cc: Piotr Trojanek <trojanek@adacore.com> Subject: [COMMITTED 08/31] ada: Sort list of implemented Ada 2012 features Date: Tue, 21 May 2024 09:30:11 +0200 Message-ID: <20240521073035.314024-8-poulhies@adacore.com> In-Reply-To: <20240521073035.314024-1-poulhies@adacore.com> References: <20240521073035.314024-1-poulhies@adacore.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: list Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org
Series	[COMMITTED,01/31] ada: Add new Mingw task priority mapping \| expand [COMMITTED,01/31] ada: Add new Mingw task priority mapping [COMMITTED,02/31] ada: Follow-up fix to previous change for Text_Ptr [COMMITTED,03/31] ada: Remove trailing NUL in minimal expansion of Put_Image attribute [COMMITTED,04/31] ada: Remove conversion from String_Id to String and back to String_Id [COMMITTED,05/31] ada: Do not leak tagged type names when Discard_Names is enabled [COMMITTED,06/31] ada: Update documentation of warning messages [COMMITTED,07/31] ada: Fix index entry for an implemented AI feature [COMMITTED,08/31] ada: Sort list of implemented Ada 2012 features [COMMITTED,09/31] ada: Fix formatting in list of implemented Ada 2012 features [COMMITTED,10/31] ada: Remove some explicit yields in tasking run-time [COMMITTED,11/31] ada: Simplify management of scopes while inlining [COMMITTED,12/31] ada: Add elaboration switch tags to info messages [COMMITTED,13/31] ada: Remove useless trampolines caused by Unchecked_Conversion [COMMITTED,14/31] ada: Remove duplicate statement [COMMITTED,15/31] ada: Fix layout in a list of aspects [COMMITTED,16/31] ada: Missing constraint check for initial value of object with address clause [COMMITTED,17/31] ada: Fix oversight in previous change [COMMITTED,18/31] ada: Fix small inaccuracy for Size attribute applied to objects [COMMITTED,19/31] ada: Fix crash on aliased constant with packed array type and -g switch [COMMITTED,20/31] ada: Fix assembler error for gigantic library-level object on 64-bit Windows [COMMITTED,21/31] ada: Remove unused dependencies from gnatbind object list [COMMITTED,22/31] ada: Avoid temporary for conditional expression of discriminated record type [COMMITTED,23/31] ada: Follow-up adjustment to earlier fix in Build_Allocate_Deallocate_Proc [COMMITTED,24/31] ada: Minor typo fix in comment [COMMITTED,25/31] ada: Fix crash with aliased array and if expression [COMMITTED,26/31] ada: Fix strict aliasing violation in parameter passing [COMMITTED,27/31] ada: Make detection of useless copy for return more robust [COMMITTED,28/31] ada: Fix strict aliasing violation in parameter passing (continued) [COMMITTED,29/31] ada: Fix internal error on discriminated record with Atomic aspect in Ada 2022 [COMMITTED,30/31] ada: Simplify test for propagation of attributes to subtypes [COMMITTED,31/31] ada: Streamline implementation of simple nonbinary modular operations

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

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

Commit Message

Patch