diff options
Diffstat (limited to 'gcc')
| -rw-r--r-- | gcc/ada/ChangeLog | 38 | ||||
| -rw-r--r-- | gcc/ada/checks.adb | 9 | ||||
| -rw-r--r-- | gcc/ada/exp_attr.adb | 32 | ||||
| -rw-r--r-- | gcc/ada/exp_ch3.adb | 9 | ||||
| -rw-r--r-- | gcc/ada/exp_ch4.adb | 97 | ||||
| -rw-r--r-- | gcc/ada/exp_ch5.adb | 458 | ||||
| -rw-r--r-- | gcc/ada/exp_dist.adb | 6 | ||||
| -rw-r--r-- | gcc/ada/gnat_rm.texi | 1616 | ||||
| -rw-r--r-- | gcc/ada/par-ch10.adb | 4 | ||||
| -rw-r--r-- | gcc/ada/sem_case.adb | 4 | ||||
| -rw-r--r-- | gcc/ada/sem_ch12.adb | 2 | ||||
| -rw-r--r-- | gcc/ada/sem_ch13.adb | 41 | ||||
| -rw-r--r-- | gcc/ada/sem_ch5.adb | 26 | ||||
| -rw-r--r-- | gcc/ada/sinfo.adb | 18 | ||||
| -rw-r--r-- | gcc/ada/sinfo.ads | 19 |
15 files changed, 2200 insertions, 179 deletions
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 52be441e179..22b8675d3ba 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,41 @@ +2010-10-22 Ben Brosgol <brosgol@adacore.com> + + * gnat_rm.texi: Add chapter on Ada 2012 support. + +2010-10-22 Robert Dewar <dewar@adacore.com> + + * sem_ch12.adb: Minor reformatting. + +2010-10-22 Thomas Quinot <quinot@adacore.com> + + * exp_dist.adb: Mark missing case of nested package when expanding + stubs. + +2010-10-22 Ed Schonberg <schonberg@adacore.com> + + * par-ch10.adb: Discard incomplete with_clause. + +2010-10-22 Robert Dewar <dewar@adacore.com> + + * checks.adb (Enable_Range_Check): Remove code suppressing range check + if static predicate present, not needed. + * exp_attr.adb (Expand_Pred_Succ): Check Suppress_Assignment_Checks flag + * exp_ch3.adb (Expand_N_Object_Declaration): Check + Suppress_Assignment_Checks flag. + * exp_ch4.adb (Expand_N_In): Make some corrections for proper handling + of ranges when predicates are present. + * exp_ch5.adb (Expand_Predicated_Loop): New procedure + (Expand_N_Assignment_Statement): Check Suppress_Assignment_Checks flag + (Expand_N_Loop_Statement): Handle loops over predicated types + * sem_case.adb (Analyze_Choices): Remove extra blank in error message. + * sem_ch13.adb (Build_Predicate_Function.Add_Call): Suppress info + message for inheritance if within a generic instance, not useful there! + (Build_Static_Predicate): Optimize test in predicate function + based on static ranges determined. + * sem_ch5.adb (Analyze_Iteration_Scheme): Error for loop through + subtype with non-static predicate. + * sinfo.ads, sinfo.adb (Suppress_Assignment_Checks): New flag. + 2010-10-22 Thomas Quinot <quinot@adacore.com> * uname.adb (Get_Unit_Name.Add_Node_Name): If encountering an error diff --git a/gcc/ada/checks.adb b/gcc/ada/checks.adb index 234317ff207..46a28543cf8 100644 --- a/gcc/ada/checks.adb +++ b/gcc/ada/checks.adb @@ -3749,6 +3749,15 @@ package body Checks is return; end if; + -- Do not set range check flag if parent is assignment statement or + -- object declaration with Suppress_Assignment_Checks flag set + + if Nkind_In (Parent (N), N_Assignment_Statement, N_Object_Declaration) + and then Suppress_Assignment_Checks (Parent (N)) + then + return; + end if; + -- Check for various cases where we should suppress the range check -- No check if range checks suppressed for type of node diff --git a/gcc/ada/exp_attr.adb b/gcc/ada/exp_attr.adb index 3f47a3050b7..ca0ae7feed4 100644 --- a/gcc/ada/exp_attr.adb +++ b/gcc/ada/exp_attr.adb @@ -5407,9 +5407,13 @@ package body Exp_Attr is -- These checks are not generated for modular types, since the proper -- semantics for Succ and Pred on modular types is to wrap, not raise CE. + -- We also suppress these checks if we are the right side of an assignment + -- statement or the expression of an object declaration, where the flag + -- Suppress_Assignment_Checks is set for the assignment/declaration. procedure Expand_Pred_Succ (N : Node_Id) is Loc : constant Source_Ptr := Sloc (N); + P : constant Node_Id := Parent (N); Cnam : Name_Id; begin @@ -5419,18 +5423,22 @@ package body Exp_Attr is Cnam := Name_Last; end if; - Insert_Action (N, - Make_Raise_Constraint_Error (Loc, - Condition => - Make_Op_Eq (Loc, - Left_Opnd => - Duplicate_Subexpr_Move_Checks (First (Expressions (N))), - Right_Opnd => - Make_Attribute_Reference (Loc, - Prefix => - New_Reference_To (Base_Type (Etype (Prefix (N))), Loc), - Attribute_Name => Cnam)), - Reason => CE_Overflow_Check_Failed)); + if not Nkind_In (P, N_Assignment_Statement, N_Object_Declaration) + or else not Suppress_Assignment_Checks (P) + then + Insert_Action (N, + Make_Raise_Constraint_Error (Loc, + Condition => + Make_Op_Eq (Loc, + Left_Opnd => + Duplicate_Subexpr_Move_Checks (First (Expressions (N))), + Right_Opnd => + Make_Attribute_Reference (Loc, + Prefix => + New_Reference_To (Base_Type (Etype (Prefix (N))), Loc), + Attribute_Name => Cnam)), + Reason => CE_Overflow_Check_Failed)); + end if; end Expand_Pred_Succ; ------------------- diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb index b7d4c3b0036..7c3c0e76818 100644 --- a/gcc/ada/exp_ch3.adb +++ b/gcc/ada/exp_ch3.adb @@ -4516,7 +4516,8 @@ package body Exp_Ch3 is -- there is an initializing expression, or for default initialization -- when we have at least one case of an explicit default initial value. - if Present (Predicate_Function (Typ)) + if not Suppress_Assignment_Checks (N) + and then Present (Predicate_Function (Typ)) and then (Present (Expr) or else @@ -5029,7 +5030,11 @@ package body Exp_Ch3 is if Do_Range_Check (Expr) then Set_Do_Range_Check (Expr, False); - Generate_Range_Check (Expr, Typ, CE_Range_Check_Failed); + + if not Suppress_Assignment_Checks (N) then + Generate_Range_Check + (Expr, Typ, CE_Range_Check_Failed); + end if; end if; end if; end if; diff --git a/gcc/ada/exp_ch4.adb b/gcc/ada/exp_ch4.adb index 4450a1efc05..086e4036bc9 100644 --- a/gcc/ada/exp_ch4.adb +++ b/gcc/ada/exp_ch4.adb @@ -4398,23 +4398,17 @@ package body Exp_Ch4 is procedure Substitute_Valid_Check is begin - -- Don't do this for type with predicates, since we don't care in - -- this case if it gets optimized away, the critical test is the - -- call to the predicate function - - if not Has_Predicates (Ltyp) then - Rewrite (N, - Make_Attribute_Reference (Loc, - Prefix => Relocate_Node (Lop), - Attribute_Name => Name_Valid)); + Rewrite (N, + Make_Attribute_Reference (Loc, + Prefix => Relocate_Node (Lop), + Attribute_Name => Name_Valid)); - Analyze_And_Resolve (N, Restyp); + Analyze_And_Resolve (N, Restyp); - Error_Msg_N ("?explicit membership test may be optimized away", N); - Error_Msg_N -- CODEFIX - ("\?use ''Valid attribute instead", N); - return; - end if; + Error_Msg_N ("?explicit membership test may be optimized away", N); + Error_Msg_N -- CODEFIX + ("\?use ''Valid attribute instead", N); + return; end Substitute_Valid_Check; -- Start of processing for Expand_N_In @@ -4437,7 +4431,9 @@ package body Exp_Ch4 is -- subtype. This is suspicious usage and we replace it with a 'Valid -- test and give a warning. For floating point types however, this is a -- standard way to check for finite numbers, and using 'Valid would - -- typically be a pessimization. + -- typically be a pessimization. Also skip this test for predicated + -- types, since it is perfectly reasonable to check if a value meets + -- its predicate. if Is_Scalar_Type (Ltyp) and then not Is_Floating_Point_Type (Ltyp) @@ -4445,7 +4441,8 @@ package body Exp_Ch4 is and then Ltyp = Entity (Rop) and then Comes_From_Source (N) and then VM_Target = No_VM - and then No (Predicate_Function (Rtyp)) + and then not (Is_Discrete_Type (Ltyp) + and then Present (Predicate_Function (Ltyp))) then Substitute_Valid_Check; return; @@ -4688,22 +4685,25 @@ package body Exp_Ch4 is -- type if they come from the original type definition. Also this -- way we get all the processing above for an explicit range. - -- Don't do this for a type with predicates, since we would lose - -- the predicate from this rewriting (test goes to base type). + -- Don't do this for predicated types, since in this case we + -- want to check the predicate! - elsif Is_Scalar_Type (Typ) and then not Has_Predicates (Typ) then - Rewrite (Rop, - Make_Range (Loc, - Low_Bound => - Make_Attribute_Reference (Loc, - Attribute_Name => Name_First, - Prefix => New_Reference_To (Typ, Loc)), + elsif Is_Scalar_Type (Typ) then + if No (Predicate_Function (Typ)) then + Rewrite (Rop, + Make_Range (Loc, + Low_Bound => + Make_Attribute_Reference (Loc, + Attribute_Name => Name_First, + Prefix => New_Reference_To (Typ, Loc)), + + High_Bound => + Make_Attribute_Reference (Loc, + Attribute_Name => Name_Last, + Prefix => New_Reference_To (Typ, Loc)))); + Analyze_And_Resolve (N, Restyp); + end if; - High_Bound => - Make_Attribute_Reference (Loc, - Attribute_Name => Name_Last, - Prefix => New_Reference_To (Typ, Loc)))); - Analyze_And_Resolve (N, Restyp); goto Leave; -- Ada 2005 (AI-216): Program_Error is raised when evaluating @@ -4843,24 +4843,33 @@ package body Exp_Ch4 is <<Leave>> - -- If a predicate is present, then we do the predicate test + -- If a predicate is present, then we do the predicate test, but we + -- most certainly want to omit this if we are within the predicate + -- function itself, since otherwise we have an infinite recursion! - if Present (Predicate_Function (Rtyp)) then - Rewrite (N, - Make_And_Then (Loc, - Left_Opnd => Relocate_Node (N), - Right_Opnd => Make_Predicate_Call (Rtyp, Lop))); + declare + PFunc : constant Entity_Id := Predicate_Function (Rtyp); - -- Analyze new expression, mark left operand as analyzed to - -- avoid infinite recursion adding predicate calls. + begin + if Present (PFunc) + and then Current_Scope /= PFunc + then + Rewrite (N, + Make_And_Then (Loc, + Left_Opnd => Relocate_Node (N), + Right_Opnd => Make_Predicate_Call (Rtyp, Lop))); - Set_Analyzed (Left_Opnd (N)); - Analyze_And_Resolve (N, Standard_Boolean); + -- Analyze new expression, mark left operand as analyzed to + -- avoid infinite recursion adding predicate calls. - -- All done, skip attempt at compile time determination of result + Set_Analyzed (Left_Opnd (N)); + Analyze_And_Resolve (N, Standard_Boolean); - return; - end if; + -- All done, skip attempt at compile time determination of result + + return; + end if; + end; end Expand_N_In; -------------------------------- diff --git a/gcc/ada/exp_ch5.adb b/gcc/ada/exp_ch5.adb index 5fe2c484468..5d27a9f1c5f 100644 --- a/gcc/ada/exp_ch5.adb +++ b/gcc/ada/exp_ch5.adb @@ -107,6 +107,9 @@ package body Exp_Ch5 is -- 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 @@ -1623,16 +1626,21 @@ package body Exp_Ch5 is 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: @@ -2960,8 +2968,9 @@ package body Exp_Ch5 is -- 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); @@ -2990,33 +2999,15 @@ package body Exp_Ch5 is -- 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); @@ -3026,95 +3017,129 @@ package body Exp_Ch5 is 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 @@ -3162,6 +3187,8 @@ package body Exp_Ch5 is Analyze (N); end; + -- Here to deal with iterator case + elsif Present (Isc) and then Present (Iterator_Specification (Isc)) then @@ -3169,6 +3196,215 @@ package body Exp_Ch5 is 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 -- ------------------------------ diff --git a/gcc/ada/exp_dist.adb b/gcc/ada/exp_dist.adb index ea105f0437e..fb91ce7a47a 100644 --- a/gcc/ada/exp_dist.adb +++ b/gcc/ada/exp_dist.adb @@ -986,6 +986,8 @@ package body Exp_Dist is Current_Subprogram_Number := Current_Subprogram_Number + 1; end if; + -- Need to handle the case of nested packages??? + Next (Current_Declaration); end loop; end Add_Calling_Stubs_To_Declarations; @@ -3916,6 +3918,8 @@ package body Exp_Dist is Current_Subprogram_Number := Current_Subprogram_Number + 1; end if; + -- Need to handle case of a nested package??? + Next (Current_Declaration); end loop; @@ -6903,6 +6907,8 @@ package body Exp_Dist is Current_Subprogram_Number := Current_Subprogram_Number + 1; end if; + -- Need to handle case of a nested package??? + Next (Current_Declaration); end loop; diff --git a/gcc/ada/gnat_rm.texi b/gcc/ada/gnat_rm.texi index a59bb4e86c4..93a56d374d6 100644 --- a/gcc/ada/gnat_rm.texi +++ b/gcc/ada/gnat_rm.texi @@ -81,6 +81,7 @@ AdaCore * Interfacing to Other Languages:: * Specialized Needs Annexes:: * Implementation of Specific Ada Features:: +* Implementation of Ada 2012 Features:: * Obsolescent Features:: * GNU Free Documentation License:: * Index:: @@ -470,6 +471,8 @@ Implementation of Specific Ada Features * 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 @@ -587,6 +590,10 @@ to GNAT's implementation of machine code insertions, tasking, and several 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 @@ -16336,6 +16343,1615 @@ machines that are not fully compliant with this standard, such as Alpha, the 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 diff --git a/gcc/ada/par-ch10.adb b/gcc/ada/par-ch10.adb index 1b43e1dda41..37992b60059 100644 --- a/gcc/ada/par-ch10.adb +++ b/gcc/ada/par-ch10.adb @@ -913,6 +913,10 @@ package body Ch10 is -- place where such an "error" should be caught. Set_Name (With_Node, P_Qualified_Simple_Name); + if Name (With_Node) = Error then + Remove (With_Node); + end if; + Set_First_Name (With_Node, First_Flag); Set_Limited_Present (With_Node, Has_Limited); Set_Private_Present (With_Node, Has_Private); diff --git a/gcc/ada/sem_case.adb b/gcc/ada/sem_case.adb index 10781c917be..fe97c6bb3ca 100644 --- a/gcc/ada/sem_case.adb +++ b/gcc/ada/sem_case.adb @@ -866,8 +866,8 @@ package body Sem_Case is or else No (Static_Predicate (E)) then Bad_Predicated_Subtype_Use - ("cannot use subtype& with non-static " - & "predicate as case alternative", N, E); + ("cannot use subtype& with non-static " + & "predicate as case alternative", Choice, E); -- Static predicate case diff --git a/gcc/ada/sem_ch12.adb b/gcc/ada/sem_ch12.adb index e51c6c101ae..0cec74f7c42 100644 --- a/gcc/ada/sem_ch12.adb +++ b/gcc/ada/sem_ch12.adb @@ -1375,7 +1375,7 @@ package body Sem_Ch12 is when N_Use_Package_Clause | N_Use_Type_Clause => if Nkind (Original_Node (I_Node)) = - N_Formal_Package_Declaration + N_Formal_Package_Declaration then Append (New_Copy_Tree (Formal), Assoc); else diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb index ec6212e309b..37f9a3e7d48 100644 --- a/gcc/ada/sem_ch13.adb +++ b/gcc/ada/sem_ch13.adb @@ -3890,10 +3890,12 @@ package body Sem_Ch13 is -- Output info message on inheritance if required. Note we do not -- give this information for generic actual types, since it is - -- unwelcome noise in that case in instantiations. + -- unwelcome noise in that case in instantiations. We also + -- generally suppress the message in instantiations. if Opt.List_Inherited_Aspects and then not Is_Generic_Actual_Type (Typ) + and then Instantiation_Depth (Sloc (Typ)) = 0 then Error_Msg_Sloc := Sloc (Predicate_Function (T)); Error_Msg_Node_2 := T; @@ -4317,6 +4319,43 @@ package body Sem_Ch13 is -- now we can store the result as the predicate list. Set_Static_Predicate (Typ, Plist); + + -- The processing for static predicates coalesced ranges and also + -- eliminated duplicates. We might as well replace the alternatives + -- list of the right operand of the membership test with the static + -- predicate list, which will be more efficient. + + declare + New_Alts : constant List_Id := New_List; + Old_Node : Node_Id; + New_Node : Node_Id; + + begin + Old_Node := First (Plist); + while Present (Old_Node) loop + New_Node := New_Copy (Old_Node); + + if Nkind (New_Node) = N_Range then + Set_Low_Bound (New_Node, New_Copy (Low_Bound (Old_Node))); + Set_High_Bound (New_Node, New_Copy (High_Bound (Old_Node))); + end if; + + Append_To (New_Alts, New_Node); + Next (Old_Node); + end loop; + + -- Now update the membership test node + + pragma Assert (Nkind (Expr) = N_In); + + if List_Length (New_Alts) = 1 then + Set_Right_Opnd (Expr, First (New_Alts)); + Set_Alternatives (Expr, No_List); + else + Set_Alternatives (Expr, New_Alts); + Set_Right_Opnd (Expr, Empty); + end if; + end; end Build_Static_Predicate; -- Start of processing for Build_Predicate_Function diff --git a/gcc/ada/sem_ch5.adb b/gcc/ada/sem_ch5.adb index eceb2818477..9265257a9ef 100644 --- a/gcc/ada/sem_ch5.adb +++ b/gcc/ada/sem_ch5.adb @@ -1832,18 +1832,34 @@ package body Sem_Ch5 is return; end if; - -- The subtype indication may denote the completion of an - -- incomplete type declaration. + -- Some additional checks if we are iterating through a type if Is_Entity_Name (DS) and then Present (Entity (DS)) and then Is_Type (Entity (DS)) - and then Ekind (Entity (DS)) = E_Incomplete_Type then - Set_Entity (DS, Get_Full_View (Entity (DS))); - Set_Etype (DS, Entity (DS)); + -- The subtype indication may denote the completion of an + -- incomplete type declaration. + + if Ekind (Entity (DS)) = E_Incomplete_Type then + Set_Entity (DS, Get_Full_View (Entity (DS))); + Set_Etype (DS, Entity (DS)); + end if; + + -- Attempt to iterate through non-static predicate + + if Is_Discrete_Type (Entity (DS)) + and then Present (Predicate_Function (Entity (DS))) + and then No (Static_Predicate (Entity (DS))) + then + Bad_Predicated_Subtype_Use + ("cannot use subtype& with non-static " + & "predicate for loop iteration", DS, Entity (DS)); + end if; end if; + -- Error if not discrete type + if not Is_Discrete_Type (Etype (DS)) then Wrong_Type (DS, Any_Discrete); Set_Etype (DS, Any_Type); diff --git a/gcc/ada/sinfo.adb b/gcc/ada/sinfo.adb index fe6bf8156c8..64d06083292 100644 --- a/gcc/ada/sinfo.adb +++ b/gcc/ada/sinfo.adb @@ -2851,6 +2851,15 @@ package body Sinfo is return Node5 (N); end Subtype_Indication; + function Suppress_Assignment_Checks + (N : Node_Id) return Boolean is + begin + pragma Assert (False + or else NT (N).Nkind = N_Assignment_Statement + or else NT (N).Nkind = N_Object_Declaration); + return Flag18 (N); + end Suppress_Assignment_Checks; + function Suppress_Loop_Warnings (N : Node_Id) return Boolean is begin @@ -5886,6 +5895,15 @@ package body Sinfo is Set_List2_With_Parent (N, Val); end Set_Subtype_Marks; + procedure Set_Suppress_Assignment_Checks + (N : Node_Id; Val : Boolean := True) is + begin + pragma Assert (False + or else NT (N).Nkind = N_Assignment_Statement + or else NT (N).Nkind = N_Object_Declaration); + Set_Flag18 (N, Val); + end Set_Suppress_Assignment_Checks; + procedure Set_Suppress_Loop_Warnings (N : Node_Id; Val : Boolean := True) is begin diff --git a/gcc/ada/sinfo.ads b/gcc/ada/sinfo.ads index d306afe4ccf..4a267fc852b 100644 --- a/gcc/ada/sinfo.ads +++ b/gcc/ada/sinfo.ads @@ -1733,6 +1733,13 @@ package Sinfo is -- value of a type whose size is not known at compile time on the -- secondary stack. + -- Suppress_Assignment_Checks (Flag18-Sem) + -- Used in genererated N_Assignment_Statement nodes to suppress predicate + -- and range checks in cases where the generated code knows that the + -- value being assigned is in range and satisifies any predicate. Also + -- can be set in N_Object_Declaration nodes, to similarly suppress any + -- checks on the initializing value. + -- Suppress_Loop_Warnings (Flag17-Sem) -- Used in N_Loop_Statement node to indicate that warnings within the -- body of the loop should be suppressed. This is set when the range @@ -2331,6 +2338,7 @@ package Sinfo is -- Exception_Junk (Flag8-Sem) -- Is_Subprogram_Descriptor (Flag16-Sem) -- Has_Init_Expression (Flag14) + -- Suppress_Assignment_Checks (Flag18-Sem) ------------------------------------- -- 3.3.1 Defining Identifier List -- @@ -4052,9 +4060,10 @@ package Sinfo is -- Backwards_OK (Flag6-Sem) -- No_Ctrl_Actions (Flag7-Sem) -- Componentwise_Assignment (Flag14-Sem) + -- Suppress_Assignment_Checks (Flag18-Sem) -- Note: if a range check is required, then the Do_Range_Check flag - -- is set in the Expression (right hand side), with the check being + -- is set in the Expression (right hand side), with the check b6ing -- done against the type of the Name (left hand side). -- Note: the back end places some restrictions on the form of the @@ -8844,6 +8853,9 @@ package Sinfo is function Subtype_Marks (N : Node_Id) return List_Id; -- List2 + function Suppress_Assignment_Checks + (N : Node_Id) return Boolean; -- Flag18 + function Suppress_Loop_Warnings (N : Node_Id) return Boolean; -- Flag17 @@ -9804,6 +9816,9 @@ package Sinfo is procedure Set_Subtype_Marks (N : Node_Id; Val : List_Id); -- List2 + procedure Set_Suppress_Assignment_Checks + (N : Node_Id; Val : Boolean := True); -- Flag18 + procedure Set_Suppress_Loop_Warnings (N : Node_Id; Val : Boolean := True); -- Flag17 @@ -11899,6 +11914,7 @@ package Sinfo is pragma Inline (Subtype_Indication); pragma Inline (Subtype_Mark); pragma Inline (Subtype_Marks); + pragma Inline (Suppress_Assignment_Checks); pragma Inline (Suppress_Loop_Warnings); pragma Inline (Synchronized_Present); pragma Inline (Tagged_Present); @@ -12215,6 +12231,7 @@ package Sinfo is pragma Inline (Set_Subtype_Indication); pragma Inline (Set_Subtype_Mark); pragma Inline (Set_Subtype_Marks); + pragma Inline (Set_Suppress_Assignment_Checks); pragma Inline (Set_Suppress_Loop_Warnings); pragma Inline (Set_Synchronized_Present); pragma Inline (Set_Tagged_Present); |