This chapter contains a complete list of Ada 2012 features that have been implemented. Generally, these features are only available if the `-gnat12' (Ada 2012 features enabled) option is set, which is the default behavior, or if the configuration pragma Ada_2012 is used.
However, new pragmas, attributes, and restrictions are unconditionally available, since the Ada 95 standard allows the addition of new pragmas, attributes, and restrictions (there are exceptions, which are documented in the individual descriptions), and also certain packages were made available in earlier versions of Ada.
An ISO date (YYYY-MM-DD) appears in parentheses on the description line. This date shows the implementation date of the feature. Any wavefront subsequent to this date will contain the indicated feature, as will any subsequent releases. A date of 0000-00-00 means that GNAT has always implemented the feature, or implemented it as soon as it appeared as a binding interpretation.
Each feature corresponds to an Ada Issue ('AI') approved by the Ada standardization group (ISO/IEC JTC1/SC22/WG9) for inclusion in Ada 2012. The features are ordered based on the relevant sections of the Ada Reference Manual ("RM"). When a given AI relates to multiple points in the RM, the earliest is used.
A complete description of the AIs may be found in
<http://www.ada-auth.org/ai05-summary.html>.
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)
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: 2.01 (4/2) 2.02 (7)
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: 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)
This AI is an earlier version of AI-163. It simplifies the rules for legal placement of pragmas. In the case of lists that allow pragmas, if the list may have no elements, then the list may consist solely of pragmas.
RM References: 2.08 (7)
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.
RM References: 2.08 (7) 2.08 (16)
This is an editorial change only, described as non-testable in the AI.
RM References: 3.01 (7)
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)
| 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
|
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).
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)
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: 3.02.03 (6) 6.06 (6)
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: 3.03 (11) 3.03 (21) 4.01 (2) 4.04 (7) 4.07 (3) 5.04 (7)
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)
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: 3.03 (23) 3.10.02 (26/2) 4.01 (9) 6.04.01 (17) 8.05.01 (5/2)
This is an editorial change only, to make more widespread use of the Ada 2012 'immutably limited'.
RM References: 3.03 (23.4/3)
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.04 (5.1/2) 6.02 (7)
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: 3.05.02 (2/2) A.01 (35/2) A.03.03 (21)
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: 3.05 (56/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.
RM References: 3.07 (9.1/2) 3.07.02 (3)
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)
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: 3.08.01 (5) 4.04 (3) 4.05.02 (3) 4.05.02 (5) 4.05.02 (27)
The function Ada.Tags.Type_Is_Abstract returns True if invoked with the tag of an abstract type, and False otherwise.
RM References: 3.09 (7.4/2) 3.09 (12.4/2)
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.09.02 (2/2)
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: 3.09.02 (20/2) 3.09.02 (20.1/2) 3.09.02 (20.2/2)
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.03 (4/2)
A return_subtype_indication cannot denote an abstract subtype. GNAT has never permitted such usage.
RM References: 3.09.03 (8/3)
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: 3.09.03 (4/3)
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.09.03 (8) 3.09.03 (10) 6.05 (8/2)
This is an editorial change only, there are no testable consequences short of checking for the absence of generated code for an interface declaration.
RM References: 3.09.04 (18/2)
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)
Incomplete types are made more useful by allowing them to be completed by private types and private extensions.
RM References: 3.10.01 (2.5/2) 3.10.01 (2.6/2) 3.10.01 (3) 3.10.01 (4/2)
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.10.01 (6) 3.10.01 (9.2/2)
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: 4.03.01 (16)
This AI addresses a wording problem in the RM that appears to permit some complex cases of aggregates with non-static discriminants. GNAT has always implemented the intended semantics.
RM References: 4.03.01 (17)
Conditional expressions are permitted. The form of such an expression is:
(if expr then expr {elsif expr then expr} [else expr])
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.
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)
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.
RM References: 4.03.03 (29)
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.
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: 4.05.02 (9.7/2) 4.05.02 (14) 4.05.02 (15) 4.05.02 (24) 8.05.04 (8)
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: 4.05.06 (11)
Case expressions are permitted. This allows use of constructs such as:
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)
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)
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)
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: 5.01 (2)
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: 5.05
For full conformance, the profiles of anonymous-access-to-subprogram parameters must match. GNAT has always enforced this rule.
RM References: 6.03.01 (18)
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: 6.03.01 (16/2)
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)
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)
Null exclusion checks are not made for **out** parameters when evaluating the actual parameters. GNAT has never generated these checks.
RM References: 6.04.01 (13)
The return object declared in an `extended_return_statement' may be declared constant. This was always intended, and GNAT has always allowed it.
RM References: 6.05 (2.1/2) 3.03 (10/2) 3.03 (21) 6.05 (5/2) 6.05 (5.7/2)
If a function returns a class-wide type, the object of an extended return statement can be declared with a specific type that is covered by the class- wide type. This has been implemented in GNAT since the introduction of extended returns. Note AI-0103 complements this AI by imposing matching rules for constrained return types.
RM References: 6.05 (5.2/2) 6.05 (5.3/2) 6.05 (5.6/2) 6.05 (5.8/2) 6.05 (8/2)
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: 6.05 (5.2/2)
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)
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: 6.05 (24/2)
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: 7.03.01 (6) 8.03 (23) 8.03.01 (5/2) 8.03.01 (6/2)
A full constant may have a null exclusion even if its associated deferred constant does not. GNAT has always allowed this.
RM References: 7.04 (6/2) 7.04 (7.1/2)
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.05 (3/2) 7.05 (6/2)
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: 7.05 (5/2) 12.05.01 (5.1/2)
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: 7.06.01 (6) 7.06.01 (7) 7.06.01 (8) 7.06.01 (9/2)
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: 7.06.01 (17.1/1)
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: 7.06 (9.4/2) B.03.03 (9/2) B.03.03 (10/2)
This AI corrects a simple omission in the RM. Return objects have always been visible within an extended return statement.
RM References: 8.03 (17)
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)
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.
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)
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: 9.10 (1/3) C.06 (22/2) C.06 (23/2)
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: 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)
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: 9.10 (6.1/1)
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: 10.01.01 (12.3/2)
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: 10.01.01 (12.2/2) 10.01.01 (12.3/2)
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)
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)
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)
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: 10.01.05 (7)
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)
This AI remedies some inconsistencies in the legality rules for Pure units. Derived access types are legal in a pure unit (on the assumption that the rule for a zero storage pool size has been enforced on the ancestor type). The rules are enforced in generic instances and in subunits. GNAT has always implemented the recommended behavior.
RM References: 10.02.01 (15.1/2) 10.02.01 (15.4/2) 10.02.01 (15.5/2) 10.02.01 (17/2)
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: 10.02.01 (18/2)
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)
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: 12.07 (16)
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.
RM References: 13.01 (8)
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: 13.01 (9.1/1)
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: 13.02 (6.1/2) 13.02 (7) C.06 (10) C.06 (11) C.06 (21)
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: 13.03 (4) 13.03 (6) 13.13.02 (38/2)
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: 13.03 (11/1)
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.03 (29) 13.11 (16)
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: 13.03.03 (00)
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)
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.09.01 (10)
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)
The new Ada 2012 notion of parameterized expressions is implemented. The form is:
function-specification is (expression)
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)
Neither of these two pragmas may appear within a generic template, because the generic might be instantiated at other than the library level.
RM References: 13.11.02 (16) C.03.01 (7/2) C.03.01 (8/2)
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.
RM References: 13.12.01 (4/2) 13.13.02 (40/2) 13.13.02 (52/2)
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.13.02 (1.2/2)
This AI is an editorial change only. It removes the need for a tag check that can never fail.
RM References: 13.13.02 (34/2)
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: 13.13.02 (50/2) 13.13.02 (51/2)
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: 13.13.02 (52/2)
The RM suggests that primitive subprograms of a specific tagged type are frozen when the tagged type is frozen. This would be an incompatible change and is not intended. GNAT has never attempted this kind of freezing and its behavior is consistent with the recommendation of this AI.
RM References: 13.14 (2) 13.14 (3/1) 13.14 (8.1/1) 13.14 (10) 13.14 (14) 13.14 (15.1/2)
So-called 'Taft-amendment types' (i.e., types that are completed in package bodies) are not frozen by the occurrence of bodies in the enclosing declarative part. GNAT always implemented this properly.
RM References: 13.14 (3/1)
This AI extends the definition of remote access types to include access to limited, synchronized, protected or task class-wide interface types. GNAT already implemented this extension.
RM References: A (4) E.02.02 (9/1) E.02.02 (9.2/1) E.02.02 (14/2) E.02.02 (18)
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.
RM References: A.03.02 (59) A.04.06 (7)
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.
RM References: A.03.05 (0) A.03.06 (0)
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.
RM References: A.04.03 (16) A.04.03 (67) A.04.03 (68/1) A.04.04 (51) A.04.05 (46)
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: A.04.03 (56.2/2) A.04.03 (58.5/2)
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 a-stuten.ads, a-suenco.ads, a-suenst.ads,
a-suewst.ads, 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: A.04.11
These are minor errors in the description on three points. The intent on all these points has always been clear, and GNAT has always implemented the correct intended semantics.
RM References: 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 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)
This package provides an interface for identifying the current locale.
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
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: B.01 (17) B.03 (62) B.03 (71.1/2)
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.07 (3/3)
The restriction No_Relative_Delays forbids any calls to the subprogram Ada.Real_Time.Timing_Events.Set_Handler.
RM References: D.07 (5) D.07 (10/2) D.07 (10.4/2) D.07 (10.7/2)
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)
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)
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.
RM References: D.13.01 (4/2) D.16
This is a documentation only issue regarding wording of metric requirements, that does not affect the implementation of the compiler.
RM References: D.15 (24/2)
Remote types packages are now allowed to depend on preelaborated packages. This was formerly considered illegal.
RM References: E.02.02 (6)
Restriction No_Anonymous_Allocators prevents the use of allocators where the type of the returned value is an anonymous access type.
RM References: H.04 (8/1)