-- Expand loop over arrays and containers that uses the form "for X of C"
-- with an optional subtype mark, or "for Y in C".
+ procedure Expand_Predicated_Loop (N : Node_Id);
+ -- Expand for loop over predicated subtype
+
function Make_Tag_Ctrl_Assignment (N : Node_Id) return List_Id;
-- Generate the necessary code for controlled and tagged assignment, that
-- is to say, finalization of the target before, adjustment of the target
end;
end if;
- -- First deal with generation of range check if required
+ -- Deal with assignment checks unless suppressed
- if Do_Range_Check (Rhs) then
- Set_Do_Range_Check (Rhs, False);
- Generate_Range_Check (Rhs, Typ, CE_Range_Check_Failed);
- end if;
+ if not Suppress_Assignment_Checks (N) then
- -- Generate predicate check if required
+ -- First deal with generation of range check if required
+
+ if Do_Range_Check (Rhs) then
+ Set_Do_Range_Check (Rhs, False);
+ Generate_Range_Check (Rhs, Typ, CE_Range_Check_Failed);
+ end if;
- Apply_Predicate_Check (Rhs, Typ);
+ -- Then generate predicate check if required
+
+ Apply_Predicate_Check (Rhs, Typ);
+ end if;
-- Check for a special case where a high level transformation is
-- required. If we have either of:
-- 2. Deal with while condition for C/Fortran boolean
-- 3. Deal with loops with a non-standard enumeration type range
-- 4. Deal with while loops where Condition_Actions is set
- -- 5. Deal with loops with iterators over arrays and containers
- -- 6. Insert polling call if required
+ -- 5. Deal with loops over predicated subtypes
+ -- 6. Deal with loops with iterators over arrays and containers
+ -- 7. Insert polling call if required
procedure Expand_N_Loop_Statement (N : Node_Id) is
Loc : constant Source_Ptr := Sloc (N);
-- Nothing more to do for plain loop with no iteration scheme
if No (Isc) then
- return;
- end if;
+ null;
+
+ -- Case of for loop (Loop_Parameter_Specfication present)
-- Note: we do not have to worry about validity checking of the for loop
-- range bounds here, since they were frozen with constant declarations
-- and it is during that process that the validity checking is done.
- -- Handle the case where we have a for loop with the range type being an
- -- enumeration type with non-standard representation. In this case we
- -- expand:
-
- -- for x in [reverse] a .. b loop
- -- ...
- -- end loop;
-
- -- to
-
- -- for xP in [reverse] integer
- -- range etype'Pos (a) .. etype'Pos (b) loop
- -- declare
- -- x : constant etype := Pos_To_Rep (xP);
- -- begin
- -- ...
- -- end;
- -- end loop;
-
- if Present (Loop_Parameter_Specification (Isc)) then
+ elsif Present (Loop_Parameter_Specification (Isc)) then
declare
LPS : constant Node_Id := Loop_Parameter_Specification (Isc);
Loop_Id : constant Entity_Id := Defining_Identifier (LPS);
New_Id : Entity_Id;
begin
- if not Is_Enumeration_Type (Btype)
- or else No (Enum_Pos_To_Rep (Btype))
- then
- return;
- end if;
-
- New_Id :=
- Make_Defining_Identifier (Loc,
- Chars => New_External_Name (Chars (Loop_Id), 'P'));
-
- -- If the type has a contiguous representation, successive values
- -- can be generated as offsets from the first literal.
-
- if Has_Contiguous_Rep (Btype) then
- Expr :=
- Unchecked_Convert_To (Btype,
- Make_Op_Add (Loc,
- Left_Opnd =>
- Make_Integer_Literal (Loc,
- Enumeration_Rep (First_Literal (Btype))),
- Right_Opnd => New_Reference_To (New_Id, Loc)));
- else
- -- Use the constructed array Enum_Pos_To_Rep
+ -- Deal with loop over predicates
- Expr :=
- Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (Enum_Pos_To_Rep (Btype), Loc),
- Expressions => New_List (New_Reference_To (New_Id, Loc)));
- end if;
-
- Rewrite (N,
- Make_Loop_Statement (Loc,
- Identifier => Identifier (N),
-
- Iteration_Scheme =>
- Make_Iteration_Scheme (Loc,
- Loop_Parameter_Specification =>
- Make_Loop_Parameter_Specification (Loc,
- Defining_Identifier => New_Id,
- Reverse_Present => Reverse_Present (LPS),
-
- Discrete_Subtype_Definition =>
- Make_Subtype_Indication (Loc,
-
- Subtype_Mark =>
- New_Reference_To (Standard_Natural, Loc),
-
- Constraint =>
- Make_Range_Constraint (Loc,
- Range_Expression =>
- Make_Range (Loc,
-
- Low_Bound =>
- Make_Attribute_Reference (Loc,
- Prefix =>
- New_Reference_To (Btype, Loc),
+ if Is_Discrete_Type (Ltype)
+ and then Present (Predicate_Function (Ltype))
+ then
+ Expand_Predicated_Loop (N);
+
+ -- Handle the case where we have a for loop with the range type
+ -- being an enumeration type with non-standard representation.
+ -- In this case we expand:
+
+ -- for x in [reverse] a .. b loop
+ -- ...
+ -- end loop;
+
+ -- to
+
+ -- for xP in [reverse] integer
+ -- range etype'Pos (a) .. etype'Pos (b)
+ -- loop
+ -- declare
+ -- x : constant etype := Pos_To_Rep (xP);
+ -- begin
+ -- ...
+ -- end;
+ -- end loop;
+
+ elsif Is_Enumeration_Type (Btype)
+ and then Present (Enum_Pos_To_Rep (Btype))
+ then
+ New_Id :=
+ Make_Defining_Identifier (Loc,
+ Chars => New_External_Name (Chars (Loop_Id), 'P'));
- Attribute_Name => Name_Pos,
+ -- If the type has a contiguous representation, successive
+ -- values can be generated as offsets from the first literal.
- Expressions => New_List (
- Relocate_Node
- (Type_Low_Bound (Ltype)))),
+ if Has_Contiguous_Rep (Btype) then
+ Expr :=
+ Unchecked_Convert_To (Btype,
+ Make_Op_Add (Loc,
+ Left_Opnd =>
+ Make_Integer_Literal (Loc,
+ Enumeration_Rep (First_Literal (Btype))),
+ Right_Opnd => New_Reference_To (New_Id, Loc)));
+ else
+ -- Use the constructed array Enum_Pos_To_Rep
- High_Bound =>
- Make_Attribute_Reference (Loc,
- Prefix =>
- New_Reference_To (Btype, Loc),
+ Expr :=
+ Make_Indexed_Component (Loc,
+ Prefix =>
+ New_Reference_To (Enum_Pos_To_Rep (Btype), Loc),
+ Expressions =>
+ New_List (New_Reference_To (New_Id, Loc)));
+ end if;
- Attribute_Name => Name_Pos,
+ Rewrite (N,
+ Make_Loop_Statement (Loc,
+ Identifier => Identifier (N),
- Expressions => New_List (
- Relocate_Node
- (Type_High_Bound (Ltype))))))))),
+ Iteration_Scheme =>
+ Make_Iteration_Scheme (Loc,
+ Loop_Parameter_Specification =>
+ Make_Loop_Parameter_Specification (Loc,
+ Defining_Identifier => New_Id,
+ Reverse_Present => Reverse_Present (LPS),
- Statements => New_List (
- Make_Block_Statement (Loc,
- Declarations => New_List (
- Make_Object_Declaration (Loc,
- Defining_Identifier => Loop_Id,
- Constant_Present => True,
- Object_Definition => New_Reference_To (Ltype, Loc),
- Expression => Expr)),
+ Discrete_Subtype_Definition =>
+ Make_Subtype_Indication (Loc,
+
+ Subtype_Mark =>
+ New_Reference_To (Standard_Natural, Loc),
+
+ Constraint =>
+ Make_Range_Constraint (Loc,
+ Range_Expression =>
+ Make_Range (Loc,
+
+ Low_Bound =>
+ Make_Attribute_Reference (Loc,
+ Prefix =>
+ New_Reference_To (Btype, Loc),
+
+ Attribute_Name => Name_Pos,
+
+ Expressions => New_List (
+ Relocate_Node
+ (Type_Low_Bound (Ltype)))),
+
+ High_Bound =>
+ Make_Attribute_Reference (Loc,
+ Prefix =>
+ New_Reference_To (Btype, Loc),
+
+ Attribute_Name => Name_Pos,
+
+ Expressions => New_List (
+ Relocate_Node
+ (Type_High_Bound
+ (Ltype))))))))),
+
+ Statements => New_List (
+ Make_Block_Statement (Loc,
+ Declarations => New_List (
+ Make_Object_Declaration (Loc,
+ Defining_Identifier => Loop_Id,
+ Constant_Present => True,
+ Object_Definition =>
+ New_Reference_To (Ltype, Loc),
+ Expression => Expr)),
+
+ Handled_Statement_Sequence =>
+ Make_Handled_Sequence_Of_Statements (Loc,
+ Statements => Statements (N)))),
+
+ End_Label => End_Label (N)));
+ Analyze (N);
- Handled_Statement_Sequence =>
- Make_Handled_Sequence_Of_Statements (Loc,
- Statements => Statements (N)))),
+ -- Nothing to do with other cases of for loops
- End_Label => End_Label (N)));
- Analyze (N);
+ else
+ null;
+ end if;
end;
-- Second case, if we have a while loop with Condition_Actions set, then
Analyze (N);
end;
+ -- Here to deal with iterator case
+
elsif Present (Isc)
and then Present (Iterator_Specification (Isc))
then
end if;
end Expand_N_Loop_Statement;
+ ----------------------------
+ -- Expand_Predicated_Loop --
+ ----------------------------
+
+ -- Note: the expander can handle generation of loops over predicated
+ -- subtypes for both the dynamic and static cases. Depending on what
+ -- we decide is allowed in Ada 2012 mode and/or extentions allowed
+ -- mode, the semantic analyzer may disallow one or both forms.
+
+ procedure Expand_Predicated_Loop (N : Node_Id) is
+ Loc : constant Source_Ptr := Sloc (N);
+ Isc : constant Node_Id := Iteration_Scheme (N);
+ LPS : constant Node_Id := Loop_Parameter_Specification (Isc);
+ Loop_Id : constant Entity_Id := Defining_Identifier (LPS);
+ Ltype : constant Entity_Id := Etype (Loop_Id);
+ Stat : constant List_Id := Static_Predicate (Ltype);
+ Stmts : constant List_Id := Statements (N);
+
+ begin
+ -- Case of iteration over non-static predicate. In this case we
+ -- generate the sequence:
+
+ -- for J in Ltype'First .. Ltype'Last loop
+ -- if Ltype_Predicate_Function (J) then
+ -- body;
+ -- end if;
+ -- end loop;
+
+ if No (Stat) then
+
+ -- The analyzer already expanded the First/Last, so all we have
+ -- to do is wrap the body within the predicate function test.
+
+ Set_Statements (N, New_List (
+ Make_If_Statement (Loc,
+ Condition =>
+ Make_Predicate_Call (Ltype, New_Occurrence_Of (Loop_Id, Loc)),
+ Then_Statements => Stmts)));
+ Analyze (First (Statements (N)));
+
+ -- For expansion over a static predicate we generate the following
+
+ -- declare
+ -- J : Ltype := min-val;
+ -- begin
+ -- loop
+ -- body
+ -- case J is
+ -- when endpoint => J := startpoint;
+ -- when endpoint => J := startpoint;
+ -- ...
+ -- when max-val => exit;
+ -- when others => J := Lval'Succ (J);
+ -- end case;
+ -- end loop;
+ -- end;
+
+ -- To make this a little clearer, let's take a specific example:
+
+ -- type Int is range 1 .. 10;
+ -- subtype L is Int with
+ -- predicate => L in 3 | 10 | 5 .. 7;
+ -- ...
+ -- for L in StaticP loop
+ -- Put_Line ("static:" & J'Img);
+ -- end loop;
+
+ -- In this case, the loop is transformed into
+
+ -- begin
+ -- J : L := 3;
+ -- loop
+ -- body
+ -- case J is
+ -- when 3 => J := 5;
+ -- when 7 => J := 10;
+ -- when 10 => exit;
+ -- when others => J := L'Succ (J);
+ -- end case;
+ -- end loop;
+ -- end;
+
+ else
+ Static_Predicate : declare
+ S : Node_Id;
+ D : Node_Id;
+ P : Node_Id;
+ Alts : List_Id;
+ Cstm : Node_Id;
+
+ function Lo_Val (N : Node_Id) return Node_Id;
+ -- Given static expression or static range, returns an identifier
+ -- whose value is the low bound of the expression value or range.
+
+ function Hi_Val (N : Node_Id) return Node_Id;
+ -- Given static expression or static range, returns an identifier
+ -- whose value is the high bound of the expression value or range.
+
+ ------------
+ -- Hi_Val --
+ ------------
+
+ function Hi_Val (N : Node_Id) return Node_Id is
+ begin
+ if Is_Static_Expression (N) then
+ return New_Copy (N);
+ else
+ pragma Assert (Nkind (N) = N_Range);
+ return New_Copy (High_Bound (N));
+ end if;
+ end Hi_Val;
+
+ ------------
+ -- Lo_Val --
+ ------------
+
+ function Lo_Val (N : Node_Id) return Node_Id is
+ begin
+ if Is_Static_Expression (N) then
+ return New_Copy (N);
+ else
+ pragma Assert (Nkind (N) = N_Range);
+ return New_Copy (Low_Bound (N));
+ end if;
+ end Lo_Val;
+
+ -- Start of processing for Static_Predicate
+
+ begin
+ -- Convert loop identifier to normal variable and reanalyze it so
+ -- that this conversion works. We have to use the same defining
+ -- identifier, since there may be references in the loop body.
+
+ Set_Analyzed (Loop_Id, False);
+ Set_Ekind (Loop_Id, E_Variable);
+
+ -- Loop to create branches of case statement
+
+ Alts := New_List;
+ P := First (Stat);
+ while Present (P) loop
+ if No (Next (P)) then
+ S := Make_Exit_Statement (Loc);
+ else
+ S :=
+ Make_Assignment_Statement (Loc,
+ Name => New_Occurrence_Of (Loop_Id, Loc),
+ Expression => Lo_Val (Next (P)));
+ Set_Suppress_Assignment_Checks (S);
+ end if;
+
+ Append_To (Alts,
+ Make_Case_Statement_Alternative (Loc,
+ Statements => New_List (S),
+ Discrete_Choices => New_List (Hi_Val (P))));
+
+ Next (P);
+ end loop;
+
+ -- Add others choice
+
+ S :=
+ Make_Assignment_Statement (Loc,
+ Name => New_Occurrence_Of (Loop_Id, Loc),
+ Expression =>
+ Make_Attribute_Reference (Loc,
+ Prefix => New_Occurrence_Of (Ltype, Loc),
+ Attribute_Name => Name_Succ,
+ Expressions => New_List (
+ New_Occurrence_Of (Loop_Id, Loc))));
+ Set_Suppress_Assignment_Checks (S);
+
+ Append_To (Alts,
+ Make_Case_Statement_Alternative (Loc,
+ Discrete_Choices => New_List (Make_Others_Choice (Loc)),
+ Statements => New_List (S)));
+
+ -- Construct case statement and append to body statements
+
+ Cstm :=
+ Make_Case_Statement (Loc,
+ Expression => New_Occurrence_Of (Loop_Id, Loc),
+ Alternatives => Alts);
+ Append_To (Stmts, Cstm);
+
+ -- Rewrite the loop
+
+ D :=
+ Make_Object_Declaration (Loc,
+ Defining_Identifier => Loop_Id,
+ Object_Definition => New_Occurrence_Of (Ltype, Loc),
+ Expression => Lo_Val (First (Stat)));
+ Set_Suppress_Assignment_Checks (D);
+
+ Rewrite (N,
+ Make_Block_Statement (Loc,
+ Declarations => New_List (D),
+ Handled_Statement_Sequence =>
+ Make_Handled_Sequence_Of_Statements (Loc,
+ Statements => New_List (
+ Make_Loop_Statement (Loc,
+ Statements => Stmts,
+ End_Label => Empty)))));
+
+ Analyze (N);
+ end Static_Predicate;
+ end if;
+ end Expand_Predicated_Loop;
+
------------------------------
-- Make_Tag_Ctrl_Assignment --
------------------------------
* Interfacing to Other Languages::
* Specialized Needs Annexes::
* Implementation of Specific Ada Features::
+* Implementation of Ada 2012 Features::
* Obsolescent Features::
* GNU Free Documentation License::
* Index::
* The Size of Discriminated Records with Default Discriminants::
* Strict Conformance to the Ada Reference Manual::
+Implementation of Ada 2012 Features
+
Obsolescent Features
GNU Free Documentation License
other features.
@item
+@ref{Implementation of Ada 2012 Features}, describes the status of the
+GNAT implementation of the Ada 2012 language standard.
+
+@item
@ref{Obsolescent Features} documents implementation dependent features,
including pragmas and attributes, which are considered obsolescent, since
there are other preferred ways of achieving the same results. These
behavior (although at the cost of a significant performance penalty), so
infinite and and NaN values are properly generated.
+
+@node Implementation of Ada 2012 Features
+@chapter Implementation of Ada 2012 Features
+@cindex Ada 2012 implementation status
+
+This chapter contains a complete list of Ada 2012 features that have been
+implemented as of GNAT version 6.4. Generally, these features are only
+available if the @option{-gnat12} (Ada 2012 features enabled) flag is set
+@cindex @option{-gnat12} option
+or if the configuration pragma @code{Ada_2012} is used.
+@cindex pragma @code{Ada_2012}
+@cindex configuration pragma @code{Ada_2012}
+@cindex @code{Ada_2012} configuration pragma
+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
+@url{www.ada-auth.org/ai05-summary.html}.
+
+@itemize @bullet
+
+@item
+@emph{AI-0176 Quantified expressions (2010-09-29)}
+@cindex AI-0176 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 1.01.04 (12) 2.09 (2/2) 4.04 (7) 4.05.09 (0)
+
+@item
+@emph{AI-0079 Allow @i{other_format} characters in source (2010-07-10)}
+@cindex AI-0079 (Ada 2012 feature)
+
+@noindent
+ Wide characters in the unicode category @i{other_format} are now allowed in
+ source programs between tokens, but not within a token such as an identifier.
+
+@noindent
+ RM References: 2.01 (4/2) 2.02 (7)
+
+@item
+@emph{AI-0091 Do not allow @i{other_format} in identifiers (0000-00-00)}
+@cindex AI-0091 (Ada 2012 feature)
+
+@noindent
+ Wide characters in the unicode category @i{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.
+
+@noindent
+ 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)
+
+@item
+@emph{AI-0100 Placement of pragmas (2010-07-01)}
+@cindex AI-0100 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 2.08 (7)
+
+@item
+@emph{AI-0163 Pragmas in place of null (2010-07-01)}
+@cindex AI-0163 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 2.08 (7) 2.08 (16)
+
+
+@item
+@emph{AI-0080 ``View of'' not needed if clear from context (0000-00-00)}
+@cindex AI-0080 (Ada 2012 feature)
+
+@noindent
+ This is an editorial change only, described as non-testable in the AI.
+
+@noindent
+ RM References: 3.01 (7)
+
+
+@item
+@emph{AI-0183 Aspect specifications (2010-08-16)}
+@cindex AI-0183 (Ada 2012 feature)
+
+@noindent
+ 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)
+
+@multitable {@code{Preelaborable_Initialization}} {--GNAT}
+@item @code{Ada_2005} @tab -- GNAT
+@item @code{Ada_2012} @tab -- GNAT
+@item @code{Address} @tab
+@item @code{Alignment} @tab
+@item @code{Atomic} @tab
+@item @code{Atomic_Components} @tab
+@item @code{Bit_Order} @tab
+@item @code{Component_Size} @tab
+@item @code{Discard_Names} @tab
+@item @code{External_Tag} @tab
+@item @code{Favor_Top_Level} @tab -- GNAT
+@item @code{Inline} @tab
+@item @code{Inline_Always} @tab -- GNAT
+@item @code{Invariant} @tab
+@item @code{Machine_Radix} @tab
+@item @code{No_Return} @tab
+@item @code{Object_Size} @tab -- GNAT
+@item @code{Pack} @tab
+@item @code{Persistent_BSS} @tab -- GNAT
+@item @code{Post} @tab
+@item @code{Pre} @tab
+@item @code{Predicate} @tab
+@item @code{Preelaborable_Initialization} @tab
+@item @code{Pure_Function} @tab -- GNAT
+@item @code{Shared} @tab -- GNAT
+@item @code{Size} @tab
+@item @code{Storage_Pool} @tab
+@item @code{Storage_Size} @tab
+@item @code{Stream_Size} @tab
+@item @code{Suppress} @tab
+@item @code{Suppress_Debug_Info} @tab -- GNAT
+@item @code{Unchecked_Union} @tab
+@item @code{Universal_Aliasing} @tab -- GNAT
+@item @code{Unmodified} @tab -- GNAT
+@item @code{Unreferenced} @tab -- GNAT
+@item @code{Unreferenced_Objects} @tab -- GNAT
+@item @code{Unsuppress} @tab
+@item @code{Value_Size} @tab -- GNAT
+@item @code{Volatile} @tab
+@item @code{Volatile_Components}
+@item @code{Warnings} @tab -- GNAT
+@end multitable
+
+@noindent
+ 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.
+
+@noindent
+ 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)
+
+
+@item
+@emph{AI-0128 Inequality is a primitive operation (0000-00-00)}
+@cindex AI-0128 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.02.03 (6) 6.06 (6)
+
+@item
+@emph{AI-0003 Qualified expressions as names (2010-07-11)}
+@cindex AI-0003 (Ada 2012 feature)
+
+@noindent
+ In Ada 2012, a qualified expression is considered to be syntatically a name,
+ meaning that constructs such as @code{A'(F(X)).B} are now legal. This is
+ useful in disambiguating some cases of overloading.
+
+@noindent
+ RM References: 3.03 (11) 3.03 (21) 4.01 (2) 4.04 (7) 4.07 (3)
+ 5.04 (7)
+
+@item
+@emph{AI-0120 Constant instance of protected object (0000-00-00)}
+@cindex AI-0120 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.03 (21)
+
+@item
+@emph{AI-0008 General access to constrained objects (0000-00-00)}
+@cindex AI-0008 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.03 (23) 3.10.02 (26/2) 4.01 (9) 6.04.01 (17) 8.05.01 (5/2)
+
+
+@item
+@emph{AI-0093 Additional rules use immutably limited (0000-00-00)}
+@cindex AI-0093 (Ada 2012 feature)
+
+@noindent
+ This is an editorial change only, to make more widespread use of the Ada 2012
+ ``immutably limited''.
+
+@noindent
+ RM References: 3.03 (23.4/3)
+
+
+
+@item
+@emph{AI-0096 Deriving from formal private types (2010-07-20)}
+@cindex AI-0096 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.04 (5.1/2) 6.02 (7)
+
+
+@item
+@emph{AI-0181 Soft hyphen is a non-graphic character (2010-07-23)}
+@cindex AI-0181 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.05.02 (2/2) A.01 (35/2) A.03.03 (21)
+
+
+@item
+@emph{AI-0182 Additional forms for @code{Character'Value} (0000-00-00)}
+@cindex AI-0182 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.05 (56/2)
+
+
+@item
+@emph{AI-0214 Defaulted discriminants for limited tagged (2010-10-01)}
+@cindex AI-0214 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.07 (9.1/2) 3.07.02 (3)
+
+
+@item
+@emph{AI-0102 Some implicit conversions are illegal (0000-00-00)}
+@cindex AI-0102 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.07 (16) 3.07.01 (9) 6.04.01 (6) 8.06 (27/2)
+
+
+@item
+@emph{AI-0158 Generalizing membership tests (2010-09-16)}
+@cindex AI-0158 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.08.01 (5) 4.04 (3) 4.05.02 (3) 4.05.02 (5) 4.05.02 (27)
+
+
+@item
+@emph{AI-0173 Testing if tags represent abstract types (2010-07-03)}
+@cindex AI-0173 (Ada 2012 feature)
+
+@noindent
+ The function @code{Ada.Tags.Type_Is_Abstract} returns @code{True} if invoked
+ with the tag of an abstract type, and @code{False} otherwise.
+
+@noindent
+ RM References: 3.09 (7.4/2) 3.09 (12.4/2)
+
+
+
+@item
+@emph{AI-0076 function with controlling result (0000-00-00)}
+@cindex AI-0076 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.09.02 (2/2)
+
+
+@item
+@emph{AI-0126 Dispatching with no declared operation (0000-00-00)}
+@cindex AI-0126 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.09.02 (20/2) 3.09.02 (20.1/2) 3.09.02 (20.2/2)
+
+
+@item
+@emph{AI-0097 Treatment of abstract null extension (2010-07-19)}
+@cindex AI-0097 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.09.03 (4/2)
+
+
+@item
+@emph{AI-0203 Extended return cannot be abstract (0000-00-00)}
+@cindex AI-0203 (Ada 2012 feature)
+
+@noindent
+ A return_subtype_indication cannot denote an abstract subtype. GNAT has never
+ permitted such usage.
+
+@noindent
+ RM References: 3.09.03 (8/3)
+
+
+@item
+@emph{AI-0198 Inheriting abstract operators (0000-00-00)}
+@cindex AI-0198 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.09.03 (4/3)
+
+@item
+@emph{AI-0073 Functions returning abstract types (2010-07-10)}
+@cindex AI-0073 (Ada 2012 feature)
+
+@noindent
+ This AI covers a number of issues regarding returning abstract types. In
+ particular generic fucntions 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.
+
+@noindent
+ RM References: 3.09.03 (8) 3.09.03 (10) 6.05 (8/2)
+
+
+@item
+@emph{AI-0070 Elaboration of interface types (0000-00-00)}
+@cindex AI-0070 (Ada 2012 feature)
+
+@noindent
+ This is an editorial change only, there are no testable consequences short of
+ checking for the absence of generated code for an interface declaration.
+
+@noindent
+ RM References: 3.09.04 (18/2)
+
+
+@item
+@emph{AI-0208 Characteristics of incomplete views (0000-00-00)}
+@cindex AI-0208 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.10.01 (2.4/2) 3.10.01 (2.6/2)
+
+
+@item
+@emph{AI-0162 Incomplete type completed by partial view (2010-09-15)}
+@cindex AI-0162 (Ada 2012 feature)
+
+@noindent
+ Incomplete types are made more useful by allowing them to be completed by
+ private types and private extensions.
+
+@noindent
+ RM References: 3.10.01 (2.5/2) 3.10.01 (2.6/2) 3.10.01 (3) 3.10.01 (4/2)
+
+
+
+@item
+@emph{AI-0098 Anonymous subprogram access restrictions (0000-00-00)}
+@cindex AI-0098 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 3.10.01 (6) 3.10.01 (9.2/2)
+
+
+@item
+@emph{AI-0199 Aggregate with anonymous access components (2010-07-14)}
+@cindex AI-0199 (Ada 2012 feature)
+
+@noindent
+ A choice list in a record aggregate can include several components of
+ (distinct) anonymous access types as long as they have matching designated
+ subtypes.
+
+@noindent
+ RM References: 4.03.01 (16)
+
+
+@item
+@emph{AI-0220 Needed components for aggregates (0000-00-00)}
+@cindex AI-0220 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 4.03.01 (17)
+
+@item
+@emph{AI-0147 Conditional expressions (2009-03-29)}
+@cindex AI-0147 (Ada 2012 feature)
+
+@noindent
+ Conditional expressions are permitted. The form of such an expression is:
+
+@smallexample
+ (@b{if} @i{expr} @b{then} @i{expr} @{@b{elsif} @i{expr} @b{then} @i{expr}@} [@b{else} @i{expr}])
+@end smallexample
+
+ The parentheses can be omitted in contexts where parentheses are present
+ anyway, such as subprogram arguments and pragma arguments. If the @b{else}
+ clause is omitted, @b{else True} is assumed;
+ thus @code{(@b{if} A @b{then} B)} is a way to conveniently represent
+ @emph{(A implies B)} in standard logic.
+
+@noindent
+ 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)
+
+
+@item
+@emph{AI-0037 Out-of-range box associations in aggregate (0000-00-00)}
+@cindex AI-0037 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 4.03.03 (29)
+
+
+@item
+@emph{AI-0123 Composability of equality (2010-04-13)}
+@cindex AI-0123 (Ada 2012 feature)
+
+@noindent
+ Equality of untagged record composes, so that the predefined equality for a
+ composite type that includes a component of some untagged record type
+ @code{R} uses the equality operation of @code{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.
+
+@noindent
+ RM References: 4.05.02 (9.7/2) 4.05.02 (14) 4.05.02 (15) 4.05.02 (24)
+ 8.05.04 (8)
+
+
+@item
+@emph{AI-0088 The value of exponentiation (0000-00-00)}
+@cindex AI-0088 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 4.05.06 (11)
+
+@item
+@emph{AI-0188 Case expressions (2010-01-09)}
+@cindex AI-0188 (Ada 2012 feature)
+
+@noindent
+ Case expressions are permitted. This allows use of constructs such as:
+@smallexample
+ X := (@b{case} Y @b{is when} 1 => 2, @b{when} 2 => 3, @b{when others} => 31)
+@end smallexample
+
+@noindent
+ RM References: 4.05.07 (0) 4.05.08 (0) 4.09 (12) 4.09 (33)
+
+@item
+@emph{AI-0104 Null exclusion and uninitialized allocator (2010-07-15)}
+@cindex AI-0104 (Ada 2012 feature)
+
+@noindent
+ The assignment @code{Ptr := @b{new not null} Some_Ptr;} will raise
+ @code{Constraint_Error} because the default value of the allocated object is
+ @b{null}. This useless construct is illegal in Ada 2012.
+
+@noindent
+ RM References: 4.08 (2)
+
+@item
+@emph{AI-0157 Allocation/Deallocation from empty pool (2010-07-11)}
+@cindex AI-0157 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 4.08 (5.3/2) 13.11.02 (4) 13.11.02 (17)
+
+@item
+@emph{AI-0179 Statement not required after label (2010-04-10)}
+@cindex AI-0179 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 5.01 (2)
+
+
+@item
+@emph{AI-139-2 Syntactic sugar for iterators (2010-09-29)}
+@cindex AI-139-2 (Ada 2012 feature)
+
+@noindent
+ 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{@b{for} Elem @b{of} C}.
+
+@noindent
+ RM References: 5.05
+
+@item
+@emph{AI-0134 Profiles must match for full conformance (0000-00-00)}
+@cindex AI-0134 (Ada 2012 feature)
+
+@noindent
+ For full conformance, the profiles of anonymous-access-to-subprogram
+ parameters must match. GNAT has always enforced this rule.
+
+@noindent
+ RM References: 6.03.01 (18)
+
+@item
+@emph{AI-0207 Mode conformance and access constant (0000-00-00)}
+@cindex AI-0207 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 6.03.01 (16/2)
+
+
+@item
+@emph{AI-0046 Null exclusion match for full conformance (2010-07-17)}
+@cindex AI-0046 (Ada 2012 feature)
+
+@noindent
+ For full conformance, in the case of access parameters, the null exclusion
+ must match (either both or neither must have @code{@b{not null}}).
+
+@noindent
+ RM References: 6.03.02 (18)
+
+
+@item
+@emph{AI-0118 The association of parameter associations (0000-00-00)}
+@cindex AI-0118 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies the rules for named associations in subprogram calls and
+ generic instantiations. The rules have been in place since Ada 83.
+
+@noindent
+ RM References: 6.04.01 (2) 12.03 (9)
+
+
+@item
+@emph{AI-0196 Null exclusion tests for out parameters (0000-00-00)}
+@cindex AI-0196 (Ada 2012 feature)
+
+@noindent
+ Null exclusion checks are not made for @code{@b{out}} parameters when
+ evaluating the actual parameters. GNAT has never generated these checks.
+
+@noindent
+ RM References: 6.04.01 (13)
+
+@item
+@emph{AI-0015 Constant return objects (0000-00-00)}
+@cindex AI-0015 (Ada 2012 feature)
+
+@noindent
+ The return object declared in an @i{extended_return_statement} may be
+ declared constant. This was always intended, and GNAT has always allowed it.
+
+@noindent
+ RM References: 6.05 (2.1/2) 3.03 (10/2) 3.03 (21) 6.05 (5/2)
+ 6.05 (5.7/2)
+
+
+@item
+@emph{AI-0032 Extended return for class-wide functions (0000-00-00)}
+@cindex AI-0032 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ 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)
+
+@item
+@emph{AI-0103 Static matching for extended return (2010-07-23)}
+@cindex AI-0103 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 6.05 (5.2/2)
+
+
+@item
+@emph{AI-0058 Abnormal completion of an extended return (0000-00-00)}
+@cindex AI-0058 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 6.05 (22/2)
+
+
+@item
+@emph{AI-0050 Raising Constraingt_Errpr early for function call (0000-00-00)}
+@cindex AI-0050 (Ada 2012 feature)
+
+@noindent
+ The implementation permissions for raising @code{Constraing_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.
+
+@noindent
+ RM References: 6.05 (24/2)
+
+
+@item
+@emph{AI-0125 Nonoverridable operations of an ancestor (2010-09-28)}
+@cindex AI-0125 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 7.03.01 (6) 8.03 (23) 8.03.01 (5/2) 8.03.01 (6/2)
+
+@item
+@emph{AI-0062 Null exclusions and deferred constants (0000-00-00)}
+@cindex AI-0062 (Ada 2012 feature)
+
+@noindent
+ A full constant may have a null exclusion even if its associated deferred
+ constant does not. GNAT has always allowed this.
+
+@noindent
+ RM References: 7.04 (6/2) 7.04 (7.1/2)
+
+
+@item
+@emph{AI-0178 Incomplete views are limited (0000-00-00)}
+@cindex AI-0178 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 7.05 (3/2) 7.05 (6/2)
+
+@item
+@emph{AI-0087 Actual for formal nonlimited derived type (2010-07-15)}
+@cindex AI-0087 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 7.05 (5/2) 12.05.01 (5.1/2)
+
+@item
+@emph{AI-0099 Tag determines whether finalization needed (0000-00-00)}
+@cindex AI-0099 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies that ``needs finalization'' is part of dynamic semantics,
+ and therefore depends on the run-time charateristics 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''.
+
+@noindent
+ RM References: 7.06.01 (6) 7.06.01 (7) 7.06.01 (8) 7.06.01 (9/2)
+
+
+
+@item
+@emph{AI-0064 Redundant finalization rule (0000-00-00)}
+@cindex AI-0064 (Ada 2012 feature)
+
+@noindent
+ This is an editorial change only. The intended behavior is already checked
+ by an existing ACATS test, which GNAT has always executed correctly.
+
+@noindent
+ RM References: 7.06.01 (17.1/1)
+
+@item
+@emph{AI-0026 Missing rules for Unchecked_Union (2010-07-07)}
+@cindex AI-0026 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 7.06 (9.4/2) B.03.03 (9/2) B.03.03 (10/2)
+
+
+@item
+@emph{AI-0205 Extended return declares visible name (0000-00-00)}
+@cindex AI-0205 (Ada 2012 feature)
+
+@noindent
+ This AI corrects a simple omission in the RM. Return objects have always
+ been visible within an extended return statement.
+
+@noindent
+ RM References: 8.03 (17)
+
+
+@item
+@emph{AI-0042 Overriding versus implemented-by (0000-00-00)}
+@cindex AI-0042 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 9.01 (9.2/2) 9.04 (11.1/2)
+
+@item
+@emph{AI-0030 Requeue on synchronized interfaces (2010-07-19)}
+@cindex AI-0030 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ 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)
+
+
+@item
+@emph{AI-0201 Independence of atomic object components (2010-07-22)}
+@cindex AI-0201 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 9.10 (1/3) C.06 (22/2) C.06 (23/2)
+
+@item
+@emph{AI-0009 Pragma Independent[_Components] (2010-07-23)}
+@cindex AI-0009 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ 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)
+
+
+@item
+@emph{AI-0072 Task signalling using 'Terminated (0000-00-00)}
+@cindex AI-0072 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 9.10 (6.1/1)
+
+@item
+@emph{AI-0108 Limited incomplete view and discriminants (0000-00-00)}
+@cindex AI-0108 (Ada 2012 feature)
+
+@noindent
+ This AI confirms that an incomplete type from a limited view does not have
+ discriminants. This has always been the case in GNAT.
+
+@noindent
+ RM References: 10.01.01 (12.3/2)
+
+@item
+@emph{AI-0129 Limited views and incomplete types (0000-00-00)}
+@cindex AI-0129 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 10.01.01 (12.2/2) 10.01.01 (12.3/2)
+
+
+
+@item
+@emph{AI-0077 Limited withs and scope of declarations (0000-00-00)}
+@cindex AI-0077 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 10.01.02 (12/2) 10.01.02 (21/2) 10.01.02 (22/2)
+
+@item
+@emph{AI-0122 Private with and children of generics (0000-00-00)}
+@cindex AI-0122 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies the visibility of private children of generic units within
+ instantiations of a parent. GNAT has always handled this correctly.
+
+@noindent
+ RM References: 10.01.02 (12/2)
+
+
+
+@item
+@emph{AI-0040 Limited with clauses on descendant (0000-00-00)}
+@cindex AI-0040 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 10.01.02 (20/2)
+
+@item
+@emph{AI-0132 Placement of library unit pragmas (0000-00-00)}
+@cindex AI-0132 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 10.01.05 (7)
+
+
+@item
+@emph{AI-0034 Categorization of limited views (0000-00-00)}
+@cindex AI-0034 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 10.02.01 (11/1) 10.02.01 (17/2)
+
+
+@item
+@emph{AI-0035 Inconsistencies with Pure units (0000-00-00)}
+@cindex AI-0035 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ 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)
+
+
+@item
+@emph{AI-0219 Pure permissions and limited parameters (2010-05-25)}
+@cindex AI-0219 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 10.02.01 (18/2)
+
+@item
+@emph{AI-0043 Rules about raising exceptions (0000-00-00)}
+@cindex AI-0043 (Ada 2012 feature)
+
+@noindent
+ This AI covers various omissions in the RM regarding the raising of
+ exceptions. GNAT has always implemented the intended semantics.
+
+@noindent
+ RM References: 11.04.01 (10.1/2) 11 (2)
+
+
+@item
+@emph{AI-0200 Mismatches in formal package declarations (0000-00-00)}
+@cindex AI-0200 (Ada 2012 feature)
+
+@noindent
+ This AI plugs a gap in the RM which appeared to allow some obviously intended
+ illegal instantiations. GNAT has never allowed these instantiations.
+
+@noindent
+ RM References: 12.07 (16)
+
+
+@item
+@emph{AI-0112 Detection of duplicate pragmas (2010-07-24)}
+@cindex AI-0112 (Ada 2012 feature)
+
+@noindent
+ This AI concerns giving names to various representation aspects, but the
+ practical effect is simply to make the use of duplicate
+ @code{Atomic}[@code{_Components}],
+ @code{Volatile}[@code{_Components}] and
+ @code{Independent}[@code{_Components}] pragmas illegal, and GNAT
+ now performs this required check.
+
+@noindent
+ RM References: 13.01 (8)
+
+@item
+@emph{AI-0106 No representation pragmas on generic formals (0000-00-00)}
+@cindex AI-0106 (Ada 2012 feature)
+
+@noindent
+ The RM appeared to allow representation pragmas on generic formal parameters,
+ but this was not intended, and GNAT has never permitted this usage.
+
+@noindent
+ RM References: 13.01 (9.1/1)
+
+
+@item
+@emph{AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)}
+@cindex AI-0012 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.02 (6.1/2) 13.02 (7) C.06 (10) C.06 (11) C.06 (21)
+
+
+@item
+@emph{AI-0039 Stream attributes cannot be dynamic (0000-00-00)}
+@cindex AI-0039 (Ada 2012 feature)
+
+@noindent
+ The RM permitted the use of dynamic expressions (such as @code{ptr.@b{all})}
+ for stream attributes, but these were never useful and are now illegal. GNAT
+ has always regarded such expressions as illegal.
+
+@noindent
+ RM References: 13.03 (4) 13.03 (6) 13.13.02 (38/2)
+
+
+@item
+@emph{AI-0095 Address of intrinsic subprograms (0000-00-00)}
+@cindex AI-0095 (Ada 2012 feature)
+
+@noindent
+ 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}.
+
+@noindent
+ RM References: 13.03 (11/1)
+
+
+@item
+@emph{AI-0116 Alignment of class-wide objects (0000-00-00)}
+@cindex AI-0116 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.03 (29) 13.11 (16)
+
+
+@item
+@emph{AI-0146 Type invariants (2009-09-21)}
+@cindex AI-0146 (Ada 2012 feature)
+
+@noindent
+ Type invariants may be specified for private types using the aspect notation.
+ Aspect @code{Invariant} may be specified for any private type,
+ @code{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
+ [@b{in}] @b{out}
+ parameters and returned result on return from any primitive operation for
+ the type that is visible to a client.
+
+@noindent
+ RM References: 13.03.03 (00)
+
+@item
+@emph{AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)}
+@cindex AI-0078 (Ada 2012 feature)
+
+@noindent
+ 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).
+
+@noindent
+ RM References: 13.09 (7)
+
+
+@item
+@emph{AI-0195 Invalid value handling is implementation defined (2010-07-03)}
+@cindex AI-0195 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.09.01 (10)
+
+@item
+@emph{AI-0193 Alignment of allocators (2010-09-16)}
+@cindex AI-0193 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.11 (16) 13.11 (21) 13.11.01 (0) 13.11.01 (1)
+ 13.11.01 (2) 13.11.01 (3)
+
+
+@item
+@emph{AI-0177 Parameterized expressions (2010-07-10)}
+@cindex AI-0177 (Ada 2012 feature)
+
+@noindent
+ The new Ada 2012 notion of parameterized expressions is implemented. The form
+ is:
+@smallexample
+ @i{function specification} @b{is} (@i{expression})
+@end smallexample
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.11.01 (3/2)
+
+@item
+@emph{AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)}
+@cindex AI-0033 (Ada 2012 feature)
+
+@noindent
+ Neither of these two pragmas may appear within a generic template, because
+ the generic might be instantiated at other than the library level.
+
+@noindent
+ RM References: 13.11.02 (16) C.03.01 (7/2) C.03.01 (8/2)
+
+
+@item
+@emph{AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)}
+@cindex AI-0161 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.12.01 (4/2) 13.13.02 (40/2) 13.13.02 (52/2)
+
+@item
+@emph{AI-0194 Value of Stream_Size attribute (0000-00-00)}
+@cindex AI-0194 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.13.02 (1.2/2)
+
+@item
+@emph{AI-0109 Redundant check in S'Class'Input (0000-00-00)}
+@cindex AI-0109 (Ada 2012 feature)
+
+@noindent
+ This AI is an editorial change only. It removes the need for a tag check
+ that can never fail.
+
+@noindent
+ RM References: 13.13.02 (34/2)
+
+@item
+@emph{AI-0007 Stream read and private scalar types (0000-00-00)}
+@cindex AI-0007 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.13.02 (50/2) 13.13.02 (51/2)
+
+
+@item
+@emph{AI-0065 Remote access types and external streaming (0000-00-00)}
+@cindex AI-0065 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.13.02 (52/2)
+
+@item
+@emph{AI-0019 Freezing of primitives for tagged types (0000-00-00)}
+@cindex AI-0019 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ 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)
+
+@item
+@emph{AI-0017 Freezing and incomplete types (0000-00-00)}
+@cindex AI-0017 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: 13.14 (3/1)
+
+
+@item
+@emph{AI-0060 Extended definition of remote access types (0000-00-00)}
+@cindex AI-0060 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: A (4) E.02.02 (9/1) E.02.02 (9.2/1) E.02.02 (14/2) E.02.02 (18)
+
+@item
+@emph{AI-0114 Classification of letters (0000-00-00)}
+@cindex AI-0114 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: A.03.02 (59) A.04.06 (7)
+
+
+@item
+@emph{AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)}
+@cindex AI-0185 (Ada 2012 feature)
+
+@noindent
+ 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}.
+
+@noindent
+ RM References: A.03.05 (0) A.03.06 (0)
+
+
+@item
+@emph{AI-0031 Add From parameter to Find_Token (2010-07-25)}
+@cindex AI-0031 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: A.04.03 (16) A.04.03 (67) A.04.03 (68/1) A.04.04 (51)
+ A.04.05 (46)
+
+
+@item
+@emph{AI-0056 Index on null string returns zero (0000-00-00)}
+@cindex AI-0056 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: A.04.03 (56.2/2) A.04.03 (58.5/2)
+
+
+@item
+@emph{AI-0137 String encoding package (2010-03-25)}
+@cindex AI-0137 (Ada 2012 feature)
+
+@noindent
+ 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 @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
+ @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}).
+
+@noindent
+ RM References: A.04.11
+
+@item
+@emph{AI-0038 Minor errors in Text_IO (0000-00-00)}
+@cindex AI-0038 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ 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)
+
+@item
+@emph{AI-0044 Restrictions on container instantiations (0000-00-00)}
+@cindex AI-0044 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ 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)
+
+@item
+@emph{AI-0127 Adding Locale Capabilities (2010-09-29)}
+@cindex AI-0127 (Ada 2012 feature)
+
+@noindent
+ This package provides an interface for identifying the current locale.
+
+@noindent
+ 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
+
+
+
+@item
+@emph{AI-0002 Export C with unconstrained arrays (0000-00-00)}
+@cindex AI-0002 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: B.01 (17) B.03 (62) B.03 (71.1/2)
+
+
+@item
+@emph{AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)}
+@cindex AI-0216 (Ada 2012 feature)
+
+@noindent
+ 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 docmentation change in the RM only.
+
+@noindent
+ RM References: D.07 (3/3)
+
+@item
+@emph{AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)}
+@cindex AI-0211 (Ada 2012 feature)
+
+@noindent
+ The restriction @code{No_Relative_Delays} forbids any calls to the subprogram
+ @code{Ada.Real_Time.Timing_Events.Set_Handler}.
+
+@noindent
+ RM References: D.07 (5) D.07 (10/2) D.07 (10.4/2) D.07 (10.7/2)
+
+@item
+@emph{AI-0190 pragma Default_Storage_Pool (2010-09-15)}
+@cindex AI-0190 (Ada 2012 feature)
+
+@noindent
+ 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 (@b{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.
+
+@noindent
+ RM References: D.07 (8)
+
+@item
+@emph{AI-0189 No_Allocators_After_Elaboration (2010-01-23)}
+@cindex AI-0189 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: D.07 (19.1/2) H.04 (23.3/2)
+
+@item
+@emph{AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)}
+@cindex AI-0171 (Ada 2012 feature)
+
+@noindent
+ 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.
+
+@noindent
+ RM References: D.13.01 (4/2) D.16
+
+
+@item
+@emph{AI-0210 Correct Timing_Events metric (0000-00-00)}
+@cindex AI-0210 (Ada 2012 feature)
+
+@noindent
+ This is a documentation only issue regarding wording of metric requirements,
+ that does not affect the implementation of the compiler.
+
+@noindent
+ RM References: D.15 (24/2)
+
+
+@item
+@emph{AI-0206 Remote types packages and preelaborate (2010-07-24)}
+@cindex AI-0206 (Ada 2012 feature)
+
+@noindent
+ Remote types packages are now allowed to depend on preelaborated packages.
+ This was formerly considered illegal.
+
+@noindent
+ RM References: E.02.02 (6)
+
+
+
+@item
+@emph{AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)}
+@cindex AI-0152 (Ada 2012 feature)
+
+@noindent
+ Restriction @code{No_Anonymous_Allocators} prevents the use of allocators
+ where the type of the returned value is an anonymous access type.
+
+@noindent
+ RM References: H.04 (8/1)
+@end itemize
+
+
@node Obsolescent Features
@chapter Obsolescent Features
OSDN Git Service
