+2010-10-11 Bob Duff <duff@adacore.com>
+
+ * sem_aggr.adb, impunit.adb, impunit.ads, switch-c.adb, usage.adb,
+ sem_ch10.adb, sem_prag.adb, sem_ch12.adb, par-ch4.adb, par-ch6.adb,
+ par-ch8.adb, exp_ch4.adb, sem_ch4.adb, sem_ch6.adb, par-prag.adb,
+ opt.ads, par-ch3.adb, lib-xref.adb: Use Ada_2012 instead of Ada_12
+ (Ada_Version_Type).
+
+2010-10-11 Javier Miranda <miranda@adacore.com>
+
+ * exp_util.adb (Safe_Prefixed_Reference): If the prefix is an explicit
+ dereference then do not exclude dereferences of access-to-constant
+ types to handle them as constant view of variables (and hence remove
+ side effects when required).
+ * sem_res.adb (Resolve_Slice): Ensure that side effects in the bounds
+ are properly handled.
+
2010-10-11 Robert Dewar <dewar@adacore.com>
* sem_prag.adb, sem_aggr.adb, sprint.adb: Minor reformatting.
end if;
end if;
- elsif Ada_Version >= Ada_12 then
+ elsif Ada_Version >= Ada_2012 then
-- if no TSS has been created for the type, check whether there is
-- a primitive equality declared for it. If it is abstract replace
or else Ekind (Entity (Prefix (N))) = E_In_Parameter;
end if;
- -- If the prefix is an explicit dereference that is not access-to-
- -- constant then this construct is a variable reference, which means
- -- it is to be considered to have side effects if Variable_Ref is
- -- True.
+ -- If the prefix is an explicit dereference then this construct is a
+ -- variable reference, which means it is to be considered to have
+ -- side effects if Variable_Ref is True.
+
+ -- We do NOT exclude dereferences of access-to-constant types because
+ -- we handle them as constant view of variables.
-- Exception is an access to an entity that is a constant or an
-- in-parameter.
elsif Nkind (Prefix (N)) = N_Explicit_Dereference
- and then not Is_Access_Constant (Etype (Prefix (Prefix (N))))
and then Variable_Ref
then
declare
for J in Non_Imp_File_Names_12'Range loop
if Name_Buffer (1 .. 8) = Non_Imp_File_Names_12 (J) then
- return Ada_12_Unit;
+ return Ada_2012_Unit;
end if;
end loop;
-- Ada 95 mode program will generate a warning (again, strictly speaking
-- this should be an error, but that seems over-strenuous).
- Ada_12_Unit);
+ Ada_2012_Unit);
-- This unit is defined in the Ada 2012 RM. Withing this unit from a Ada
-- 95 mode or Ada 2005 program will generate a warning (again, strictly
-- speaking this should be an error, but that seems over-strenuous).
if Comes_From_Source (N)
and then Is_Ada_2012_Only (E)
- and then Ada_Version < Ada_12
+ and then Ada_Version < Ada_2012
and then Warn_On_Ada_2012_Compatibility
and then (Typ = 'm' or else Typ = 'r')
then
-- GNATBIND, GNATLINK
-- Set True if binder file to be generated in Ada rather than C
- type Ada_Version_Type is (Ada_83, Ada_95, Ada_05, Ada_12);
+ type Ada_Version_Type is (Ada_83, Ada_95, Ada_05, Ada_2012);
pragma Ordered (Ada_Version_Type);
-- Versions of Ada for Ada_Version below. Note that these are ordered,
-- so that tests like Ada_Version >= Ada_95 are legitimate and useful.
Ada_2005 : Ada_Version_Type renames Ada_05;
- Ada_2012 : Ada_Version_Type renames Ada_12;
- -- Renamings with full names (preferred usage)
+ -- Renaming with full name (preferred usage)
Ada_Version_Default : constant Ada_Version_Type := Ada_05;
pragma Warnings (Off, Ada_Version_Default);
-- the rare cases (notably for pragmas Preelaborate_05 and Pure_05)
-- where in the run-time we want the explicit version set.
- Ada_Version_Runtime : Ada_Version_Type := Ada_12;
+ Ada_Version_Runtime : Ada_Version_Type := Ada_2012;
-- GNAT
-- Ada version used to compile the runtime. Used to set Ada_Version (but
-- not Ada_Version_Explicit) when compiling predefined or internal units.
-- Technically in the grammar, the expression must match the
-- grammar for restricted expression.
- if Ada_Version >= Ada_12 then
+ if Ada_Version >= Ada_2012 then
Check_Restricted_Expression (Expr_Node);
-- In Ada 83 mode, the syntax required a simple expression
-- Qualified expression in Ada 2012 mode (treated as a name)
- if Ada_Version >= Ada_12 and then Token = Tok_Left_Paren then
+ if Ada_Version >= Ada_2012 and then Token = Tok_Left_Paren then
goto Scan_Name_Extension_Apostrophe;
-- If left paren not in Ada 2012, then it is not part of the name,
begin
-- Check for qualified expression case in Ada 2012 mode
- if Ada_Version >= Ada_12 and then Token = Tok_Left_Paren then
+ if Ada_Version >= Ada_2012 and then Token = Tok_Left_Paren then
Name_Node := P_Qualified_Expression (Name_Node);
goto Scan_Name_Extension;
-- If qualified expression, comment and continue, otherwise something
-- is pretty nasty so do an Error_Resync call.
- if Ada_Version < Ada_12
+ if Ada_Version < Ada_2012
and then Nkind (Node1) = N_Qualified_Expression
then
Error_Msg_SC ("\would be legal in Ada 2012 mode");
-- If this looks like a conditional expression, then treat it
-- that way with an error message.
- elsif Ada_Version >= Ada_12 then
+ elsif Ada_Version >= Ada_2012 then
Error_Msg_SC
("conditional expression must be parenthesized");
return P_Conditional_Expression;
-- If this looks like a case expression, then treat it that way
-- with an error message.
- elsif Ada_Version >= Ada_12 then
+ elsif Ada_Version >= Ada_2012 then
Error_Msg_SC ("case expression must be parenthesized");
return P_Case_Expression;
Save_State : Saved_Scan_State;
begin
- if Ada_Version < Ada_12 then
+ if Ada_Version < Ada_2012 then
Error_Msg_SC ("|case expression is an Ada 2012 feature");
Error_Msg_SC ("\|unit must be compiled with -gnat2012 switch");
end if;
begin
Inside_Conditional_Expression := Inside_Conditional_Expression + 1;
- if Token = Tok_If and then Ada_Version < Ada_12 then
+ if Token = Tok_If and then Ada_Version < Ada_2012 then
Error_Msg_SC ("|conditional expression is an Ada 2012 feature");
Error_Msg_SC ("\|unit must be compiled with -gnat2012 switch");
end if;
procedure P_Membership_Test (N : Node_Id) is
Alt : constant Node_Id :=
P_Range_Or_Subtype_Mark
- (Allow_Simple_Expression => (Ada_Version >= Ada_12));
+ (Allow_Simple_Expression => (Ada_Version >= Ada_2012));
begin
-- Set case
if Token = Tok_Vertical_Bar then
- if Ada_Version < Ada_12 then
+ if Ada_Version < Ada_2012 then
Error_Msg_SC ("set notation is an Ada 2012 feature");
Error_Msg_SC ("\|unit must be compiled with -gnat2012 switch");
end if;
-- Check we are in Ada 2012 mode
- if Ada_Version < Ada_12 then
+ if Ada_Version < Ada_2012 then
Error_Msg_SC
("parameterized expression is an Ada 2012 feature!");
Error_Msg_SC
begin
if Token = Tok_All then
- if Ada_Version < Ada_12 then
+ if Ada_Version < Ada_2012 then
Error_Msg_SC ("|`USE ALL TYPE` is an Ada 2012 feature");
Error_Msg_SC ("\|unit must be compiled with -gnat2012 switch");
end if;
when Pragma_Ada_12 | Pragma_Ada_2012 =>
if Arg_Count = 0 then
- Ada_Version := Ada_12;
- Ada_Version_Explicit := Ada_12;
+ Ada_Version := Ada_2012;
+ Ada_Version_Explicit := Ada_2012;
end if;
-----------
if Chars (Expression (Arg1)) = Name_On then
Extensions_Allowed := True;
- Ada_Version := Ada_12;
+ Ada_Version := Ada_2012;
else
Extensions_Allowed := False;
Ada_Version := Ada_Version_Explicit;
-- designated types match.
elsif Typech /= Base_Type (Etype (Component)) then
- if Ada_Version >= Ada_12
+ if Ada_Version >= Ada_2012
and then Ekind (Typech) = E_Anonymous_Access_Type
and then
Ekind (Etype (Component)) = E_Anonymous_Access_Type
then
Error_Msg_N ("& is an Ada 2005 unit?", Name (N));
- elsif U_Kind = Ada_12_Unit
- and then Ada_Version < Ada_12
+ elsif U_Kind = Ada_2012_Unit
+ and then Ada_Version < Ada_2012
and then Warn_On_Ada_2012_Compatibility
then
Error_Msg_N ("& is an Ada 2012 unit?", Name (N));
-- versions of Ada as well as Ada 2012???
if Is_Abstract_Type (Designated_Type (Result_Type))
- and then Ada_Version >= Ada_12
+ and then Ada_Version >= Ada_2012
then
Error_Msg_N ("generic function cannot have an access result"
& " that designates an abstract type", Spec);
Typ := Entity (Result_Definition (Spec));
if Is_Abstract_Type (Typ)
- and then Ada_Version >= Ada_12
+ and then Ada_Version >= Ada_2012
then
Error_Msg_N
("generic function cannot have abstract result type", Spec);
if Is_Limited_Type (Act_T)
and then not Is_Limited_Type (A_Gen_T)
- and then Ada_Version >= Ada_12
+ and then Ada_Version >= Ada_2012
then
Error_Msg_NE
("actual for non-limited & cannot be a limited type", Actual,
Reason => CE_Null_Not_Allowed);
begin
- if Ada_Version >= Ada_12 then
+ if Ada_Version >= Ada_2012 then
Error_Msg_N
("an uninitialized allocator cannot have"
& " a null exclusion", N);
Analyze_Expression (L);
if No (R)
- and then Ada_Version >= Ada_12
+ and then Ada_Version >= Ada_2012
then
Analyze_Set_Membership;
return;
and then
not Is_Class_Wide_Type (Designated_Type (Etype (Designator)))
and then Is_Abstract_Type (Designated_Type (Etype (Designator)))
- and then Ada_Version >= Ada_12
+ and then Ada_Version >= Ada_2012
then
Error_Msg_N ("function whose access result designates "
& "abstract type must be abstract", N);
and then Is_Tagged_Type (Designated_Type (Etype (S)))
and then
not Is_Class_Wide_Type (Designated_Type (Etype (S)))
- and then Ada_Version >= Ada_12
+ and then Ada_Version >= Ada_2012
then
Error_Msg_N
("private function with controlling access result "
then
Make_Inequality_Operator (S);
- if Ada_Version >= Ada_12 then
+ if Ada_Version >= Ada_2012 then
Check_Untagged_Equality (S);
end if;
end if;
-- Now set Ada 2012 mode
- Ada_Version := Ada_12;
- Ada_Version_Explicit := Ada_12;
+ Ada_Version := Ada_2012;
+ Ada_Version_Explicit := Ada_2012;
end if;
end;
-- This is one of the few cases where we need to test the value of
-- Ada_Version_Explicit rather than Ada_Version (which is always
- -- set to Ada_12 in a predefined unit), we need to know the
+ -- set to Ada_2012 in a predefined unit), we need to know the
-- explicit version set to know if this pragma is active.
if Ada_Version_Explicit >= Ada_05 then
-- This is one of the few cases where we need to test the value of
-- Ada_Version_Explicit rather than Ada_Version (which is always
- -- set to Ada_12 in a predefined unit), we need to know the
+ -- set to Ada_2012 in a predefined unit), we need to know the
-- explicit version set to know if this pragma is active.
if Ada_Version_Explicit >= Ada_05 then
Index := First_Index (Array_Type);
Resolve (Drange, Base_Type (Etype (Index)));
- if Nkind (Drange) = N_Range
+ if Nkind (Drange) = N_Range then
+
+ -- Ensure that side effects in the bounds are properly handled
+
+ Remove_Side_Effects (Low_Bound (Drange), Variable_Ref => True);
+ Remove_Side_Effects (High_Bound (Drange), Variable_Ref => True);
-- Do not apply the range check to nodes associated with the
-- frontend expansion of the dispatch table. We first check
- -- if Ada.Tags is already loaded to void the addition of an
+ -- if Ada.Tags is already loaded to avoid the addition of an
-- undesired dependence on such run-time unit.
- and then
- (not Tagged_Type_Expansion
- or else not
- (RTU_Loaded (Ada_Tags)
+ if not Tagged_Type_Expansion
+ or else not
+ (RTU_Loaded (Ada_Tags)
and then Nkind (Prefix (N)) = N_Selected_Component
and then Present (Entity (Selector_Name (Prefix (N))))
and then Entity (Selector_Name (Prefix (N))) =
- RTE_Record_Component (RE_Prims_Ptr)))
- then
- Apply_Range_Check (Drange, Etype (Index));
+ RTE_Record_Component (RE_Prims_Ptr))
+ then
+ Apply_Range_Check (Drange, Etype (Index));
+ end if;
end if;
end if;
-- implicit setting here, since for example, we want
-- Preelaborate_05 treated as Preelaborate
- Ada_Version := Ada_12;
+ Ada_Version := Ada_2012;
Ada_Version_Explicit := Ada_Version;
-- Set default warnings and style checks for -gnatg
Bad_Switch ("-gnat1" & Switch_Chars (Ptr .. Max));
else
Ptr := Ptr + 1;
- Ada_Version := Ada_12;
+ Ada_Version := Ada_2012;
Ada_Version_Explicit := Ada_Version;
end if;
Ada_Version := Ada_05;
elsif Switch_Chars (Ptr .. Ptr + 3) = "2012" then
- Ada_Version := Ada_12;
+ Ada_Version := Ada_2012;
else
Bad_Switch ("-gnat" & Switch_Chars (Ptr .. Ptr + 3));
Write_Switch_Char ("12");
- if Ada_Version_Default = Ada_12 then
+ if Ada_Version_Default = Ada_2012 then
Write_Line ("Ada 2012 mode (default)");
else
Write_Line ("Allow Ada 2012 extensions");
projects / thirdparty / gcc.git / commitdiff
