+2014-02-20 Robert Dewar <dewar@adacore.com>
+
+ * einfo.ads: Minor comment addition: Etype of package is
+ Standard_Void_Type.
+ * checks.adb, exp_aggr.adb, exp_atag.adb, exp_attr.adb, exp_ch13.adb,
+ exp_ch2.adb, exp_ch3.adb, exp_ch4.adb, exp_ch5.adb, exp_ch6.adb,
+ exp_ch7.adb, exp_ch9.adb, exp_dbug.adb, exp_disp.adb, exp_imgv.adb,
+ exp_intr.adb, exp_prag.adb, exp_sel.adb, exp_strm.adb, exp_util.adb,
+ freeze.adb, rtsfind.adb, sem_aggr.adb, sem_attr.adb, sem_ch10.adb,
+ sem_ch12.adb, sem_ch13.adb, sem_ch3.adb, sem_ch4.adb, sem_ch5.adb,
+ sem_ch6.adb, sem_ch8.adb, sem_dim.adb, sem_prag.adb, sem_res.adb,
+ sem_util.adb, tbuild.adb, tbuild.ads: Remove New_Reference_To.
+ Replace all calls with calls to New_Occurrence_Of.
+
+2014-02-20 Robert Dewar <dewar@adacore.com>
+
+ * par-util.adb (Ignore, case of right paren): Make this a
+ serious error.
+
2014-02-19 Robert Dewar <dewar@adacore.com>
* sem_ch5.adb, sem_prag.adb, sem_attr.adb: Minor reformatting.
Rewrite (N,
OK_Convert_To (Typ,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (Cent), Loc),
+ Name => New_Occurrence_Of (RTE (Cent), Loc),
Parameter_Associations => New_List (
OK_Convert_To (RTE (RE_Integer_64), Left_Opnd (N)),
OK_Convert_To (RTE (RE_Integer_64), Right_Opnd (N))))));
Then_Statements => New_List (
Make_Raise_Statement (Loc,
Name =>
- New_Reference_To (Standard_Program_Error, Loc),
+ New_Occurrence_Of (Standard_Program_Error, Loc),
Expression => Make_String_Literal (Loc, End_String)))));
-- Create a sequence of overlapping checks by and-ing them all
-- Step 1: Create the expression to verify the validity of the
-- context.
- Check := New_Reference_To (Context, Loc);
+ Check := New_Occurrence_Of (Context, Loc);
-- When processing a function result, use 'Result. Generate
-- Context'Result
Duplicate_Subexpr_Move_Checks (Sub)),
Right_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Etype (A), Loc),
+ Prefix => New_Occurrence_Of (Etype (A), Loc),
Attribute_Name => Name_Range)),
Reason => CE_Index_Check_Failed));
end if;
Range_N :=
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Etype (A_Idx), Loc),
+ New_Occurrence_Of (Etype (A_Idx), Loc),
Attribute_Name => Name_Range);
-- For arrays with non-constant bounds we cannot generate
New_Occurrence_Of (RTE (RE_Mark_Id), Loc),
Expression =>
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_SS_Mark), Loc)))),
+ Name => New_Occurrence_Of (RTE (RE_SS_Mark), Loc)))),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
Make_Procedure_Call_Statement (Loc,
Name => New_Occurrence_Of (RTE (RE_SS_Release), Loc),
Parameter_Associations => New_List (
- New_Reference_To (M, Loc))))));
+ New_Occurrence_Of (M, Loc))))));
end Make_Bignum_Block;
----------------------------------
-- itself. For a subtype entity, Etype points to the base type. For
-- a class wide type, points to the corresponding specific type. For a
-- subprogram or subprogram type, Etype has the return type of a function
--- or is set to Standard_Void_Type to represent a procedure.
+-- or is set to Standard_Void_Type to represent a procedure. The Etype
+-- field of a package is also set to Standard_Void_Type.
--
-- Note one obscure case: for pragma Default_Storage_Pool (null), the
-- Etype of the N_Null node is Empty.
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Indexed_Comp),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Full_Typ), Loc)),
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Full_Typ))),
Loc)));
-- Construct the statements to execute in the loop body
- L_Body := Gen_Assign (New_Reference_To (L_J, Loc), Expr);
+ L_Body := Gen_Assign (New_Occurrence_Of (L_J, Loc), Expr);
-- Construct the final loop
(Loc,
Condition => Make_Op_Lt
(Loc,
- Left_Opnd => New_Reference_To (W_J, Loc),
+ Left_Opnd => New_Occurrence_Of (W_J, Loc),
Right_Opnd => New_Copy_Tree (H)));
-- Construct the statements to execute in the loop body
(Loc,
Prefix => Index_Base_Name,
Attribute_Name => Name_Succ,
- Expressions => New_List (New_Reference_To (W_J, Loc)));
+ Expressions => New_List (New_Occurrence_Of (W_J, Loc)));
W_Increment :=
Make_OK_Assignment_Statement
(Loc,
- Name => New_Reference_To (W_J, Loc),
+ Name => New_Occurrence_Of (W_J, Loc),
Expression => W_Index_Succ);
Append_To (W_Body, W_Increment);
Append_List_To (W_Body,
- Gen_Assign (New_Reference_To (W_J, Loc), Expr));
+ Gen_Assign (New_Occurrence_Of (W_J, Loc), Expr));
-- Construct the final loop
function Index_Base_Name return Node_Id is
begin
- return New_Reference_To (Index_Base, Sloc (N));
+ return New_Occurrence_Of (Index_Base, Sloc (N));
end Index_Base_Name;
------------------------------------
Append_To (L,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(Find_Prim_Op (Init_Typ, Name_Initialize), Loc),
Parameter_Associations => New_List (New_Copy_Tree (Ref))));
end if;
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Target),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Base_Type (Typ)), Loc)),
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt
(Access_Disp_Table (Base_Type (Typ)))),
Loc)));
if Present (CPP_Init_Proc (T)) then
Append_To (L,
Make_Procedure_Call_Statement (Loc,
- New_Reference_To (CPP_Init_Proc (T), Loc)));
+ New_Occurrence_Of (CPP_Init_Proc (T), Loc)));
end if;
end Invoke_IC_Proc;
Append_To (L,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(Base_Init_Proc (CPP_Parent), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (CPP_Parent,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To (Etype (Comp_Type), Loc),
+ New_Occurrence_Of (Etype (Comp_Type), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint
(Loc,
TmpD : constant Node_Id :=
Make_Object_Declaration (Loc,
Defining_Identifier => TmpE,
- Object_Definition => New_Reference_To (SubE, Loc));
+ Object_Definition => New_Occurrence_Of (SubE, Loc));
begin
Set_No_Initialization (TmpD);
Append_List_To (L,
Late_Expansion (Expr_Q, Comp_Type,
- New_Reference_To (TmpE, Loc)));
+ New_Occurrence_Of (TmpE, Loc)));
-- Slide
Append_To (L,
Make_Assignment_Statement (Loc,
Name => New_Copy_Tree (Comp_Expr),
- Expression => New_Reference_To (TmpE, Loc)));
+ Expression => New_Occurrence_Of (TmpE, Loc)));
end;
-- Normal case (sliding not required)
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Comp_Expr),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Comp_Type), Loc)),
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Comp_Type))),
Loc)));
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Target),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Base_Type (Typ)), Loc)),
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Base_Type (Typ)))),
Loc)));
Occ : constant Node_Id :=
Unchecked_Convert_To (Typ,
- Make_Explicit_Dereference (Loc, New_Reference_To (Temp, Loc)));
+ Make_Explicit_Dereference (Loc, New_Occurrence_Of (Temp, Loc)));
begin
if Is_Array_Type (Typ) then
Make_Op_Add (Loc,
Left_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ind_Typ, Loc),
+ Prefix => New_Occurrence_Of (Ind_Typ, Loc),
Attribute_Name => Name_Pos,
Expressions =>
New_List
Right_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ind_Typ, Loc),
+ Prefix => New_Occurrence_Of (Ind_Typ, Loc),
Attribute_Name => Name_Pos,
Expressions => New_List (
Duplicate_Subexpr_Move_Checks (Aggr_Hi))));
begin
if Nkind (Tmp) = N_Defining_Identifier then
- Target := New_Reference_To (Tmp, Loc);
+ Target := New_Occurrence_Of (Tmp, Loc);
else
-- Call init proc to set discriminants.
-- There should eventually be a special procedure for this ???
- Ref := New_Reference_To (Defining_Identifier (N), Loc);
+ Ref := New_Occurrence_Of (Defining_Identifier (N), Loc);
Insert_Actions_After (N,
Build_Initialization_Call (Sloc (N), Ref, Typ));
end if;
-- --
-- S p e c --
-- --
--- Copyright (C) 2006-2011, Free Software Foundation, Inc. --
+-- Copyright (C) 2006-2013, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
if Tagged_Type_Expansion then
Tag_Node :=
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Typ))), Loc));
else
Tag_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag);
end if;
Make_Op_Eq (Loc,
Left_Opnd => Make_Identifier (Loc, Name_uC),
Right_Opnd =>
- New_Reference_To (RTE (RE_POK_Procedure), Loc)),
+ New_Occurrence_Of (RTE (RE_POK_Procedure), Loc)),
Right_Opnd =>
Make_Or_Else (Loc,
Left_Opnd =>
Make_Op_Eq (Loc,
Left_Opnd => Make_Identifier (Loc, Name_uC),
Right_Opnd =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_POK_Protected_Procedure), Loc)),
Right_Opnd =>
Make_Op_Eq (Loc,
Left_Opnd => Make_Identifier (Loc, Name_uC),
Right_Opnd =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_POK_Task_Procedure), Loc)))),
Then_Statements =>
New_List (
Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uF),
- Expression => New_Reference_To (Standard_True, Loc)),
+ Expression => New_Occurrence_Of (Standard_True, Loc)),
Make_Simple_Return_Statement (Loc))));
end Build_Common_Dispatching_Select_Statements;
Make_Object_Declaration (Loc,
Defining_Identifier => Tag_Addr,
Constant_Present => True,
- Object_Definition => New_Reference_To (RTE (RE_Address), Loc),
+ Object_Definition => New_Occurrence_Of (RTE (RE_Address), Loc),
Expression => Unchecked_Convert_To
(RTE (RE_Address), Obj_Tag_Node)));
Make_Object_Declaration (Loc,
Defining_Identifier => Obj_TSD,
Constant_Present => True,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(RTE (RE_Type_Specific_Data_Ptr), Loc),
- Expression => Build_TSD (Loc, New_Reference_To (Tag_Addr, Loc))));
+ Expression => Build_TSD (Loc, New_Occurrence_Of (Tag_Addr, Loc))));
Insert_Action (Related_Nod,
Make_Object_Declaration (Loc,
Defining_Identifier => Typ_TSD,
Constant_Present => True,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(RTE (RE_Type_Specific_Data_Ptr), Loc),
Expression => Build_TSD (Loc,
Unchecked_Convert_To (RTE (RE_Address),
Make_Op_Subtract (Loc,
Left_Opnd =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Obj_TSD, Loc),
+ Prefix => New_Occurrence_Of (Obj_TSD, Loc),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE_Record_Component (RE_Idepth), Loc)),
Right_Opnd =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Typ_TSD, Loc),
+ Prefix => New_Occurrence_Of (Typ_TSD, Loc),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE_Record_Component (RE_Idepth), Loc)))));
New_Node :=
Make_Indexed_Component (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Obj_TSD, Loc),
+ Prefix => New_Occurrence_Of (Obj_TSD, Loc),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE_Record_Component (RE_Tags_Table), Loc)),
Expressions =>
New_List (New_Occurrence_Of (Index, Loc))),
begin
return
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_DT), Loc),
+ Name => New_Occurrence_Of (RTE (RE_DT), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Tag), Tag_Node)));
end Build_DT;
Build_TSD (Loc,
Unchecked_Convert_To (RTE (RE_Address), Tag_Node)),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE_Record_Component (RE_Access_Level), Loc));
end Build_Get_Access_Level;
Prefix =>
Build_TSD (Loc, Unchecked_Convert_To (RTE (RE_Address), Tag_Node)),
Selector_Name =>
- New_Reference_To (RTE_Record_Component (RE_Alignment), Loc));
+ New_Occurrence_Of (RTE_Record_Component (RE_Alignment), Loc));
end Build_Get_Alignment;
------------------------------------------
Make_Expanded_Name (Loc,
Chars => Name_Op_Subtract,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(RTU_Entity (System_Storage_Elements), Loc),
Selector_Name =>
Make_Identifier (Loc, Name_Op_Subtract)),
Parameter_Associations => New_List (
Ctrl_Tag,
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_DT_Predef_Prims_Offset), Loc)))))),
Expressions =>
New_List (Make_Integer_Literal (Loc, Position)));
Make_Explicit_Dereference (Loc,
Unchecked_Convert_To
(Node (Last_Elmt (Access_Disp_Table (Typ))),
- New_Reference_To (Typ_Tag, Loc))),
+ New_Occurrence_Of (Typ_Tag, Loc))),
Expressions =>
New_List (Make_Integer_Literal (Loc, Prim_Pos))),
Expression =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (E, Loc),
+ Prefix => New_Occurrence_Of (E, Loc),
Attribute_Name => Name_Unrestricted_Access))));
end if;
Make_Explicit_Dereference (Loc,
Unchecked_Convert_To
(Node (Last_Elmt (Access_Disp_Table (CPP_Typ))),
- New_Reference_To (Typ_Tag, Loc))),
+ New_Occurrence_Of (Typ_Tag, Loc))),
Expression =>
Make_Explicit_Dereference (Loc,
Unchecked_Convert_To
(Node (Last_Elmt (Access_Disp_Table (CPP_Typ))),
- New_Reference_To (Parent_Tag, Loc)))));
+ New_Occurrence_Of (Parent_Tag, Loc)))));
exit;
end if;
end loop;
(Node
(Last_Elmt
(Access_Disp_Table (Iface))),
- New_Reference_To (Typ_Tag, Loc))),
+ New_Occurrence_Of (Typ_Tag, Loc))),
Expressions =>
New_List
(Make_Integer_Literal (Loc, Prim_Pos))),
Expression =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (E, Loc),
+ Prefix => New_Occurrence_Of (E, Loc),
Attribute_Name =>
Name_Unrestricted_Access))));
end if;
Make_Explicit_Dereference (Loc,
Unchecked_Convert_To
(Node (Last_Elmt (Access_Disp_Table (Iface))),
- New_Reference_To (Typ_Tag, Loc))),
+ New_Occurrence_Of (Typ_Tag, Loc))),
Expression =>
Make_Explicit_Dereference (Loc,
Unchecked_Convert_To
(Node (Last_Elmt (Access_Disp_Table (Iface))),
- New_Reference_To (Parent_Tag, Loc)))));
+ New_Occurrence_Of (Parent_Tag, Loc)))));
exit;
end if;
end loop;
Prefix =>
Build_DT (Loc, New_Tag_Node),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE_Record_Component (RE_Prims_Ptr), Loc)),
Discrete_Range =>
Make_Range (Loc,
Prefix =>
Build_DT (Loc, Old_Tag_Node),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE_Record_Component (RE_Prims_Ptr), Loc)),
Discrete_Range =>
Make_Range (Loc,
Build_TSD (Loc,
Unchecked_Convert_To (RTE (RE_Address), Tag_Node)),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE_Record_Component (RE_Transportable), Loc));
end Build_Get_Transportable;
New_Tag_Node)))),
Discrete_Range => Make_Range (Loc,
Make_Integer_Literal (Loc, Uint_1),
- New_Reference_To (RTE (RE_Max_Predef_Prims), Loc))),
+ New_Occurrence_Of (RTE (RE_Max_Predef_Prims), Loc))),
Expression =>
Make_Slice (Loc,
Discrete_Range =>
Make_Range (Loc,
Make_Integer_Literal (Loc, 1),
- New_Reference_To (RTE (RE_Max_Predef_Prims), Loc))));
+ New_Occurrence_Of (RTE (RE_Max_Predef_Prims), Loc))));
end Build_Inherit_Predefined_Prims;
-------------------------
Make_Expanded_Name (Loc,
Chars => Name_Op_Subtract,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(RTU_Entity (System_Storage_Elements), Loc),
Selector_Name => Make_Identifier (Loc, Name_Op_Subtract)),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Address), Tag_Node),
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_DT_Offset_To_Top_Offset), Loc)))));
end Build_Offset_To_Top;
Build_TSD (Loc,
Unchecked_Convert_To (RTE (RE_Address), Tag_Node)),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE_Record_Component (RE_Size_Func), Loc)),
Expression =>
Unchecked_Convert_To (RTE (RE_Size_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Size_Func, Loc),
+ Prefix => New_Occurrence_Of (Size_Func, Loc),
Attribute_Name => Name_Unrestricted_Access)));
end Build_Set_Size_Function;
Make_Expanded_Name (Loc,
Chars => Name_Op_Subtract,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(RTU_Entity (System_Storage_Elements), Loc),
Selector_Name => Make_Identifier (Loc, Name_Op_Subtract)),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Address), Iface_Tag),
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_DT_Offset_To_Top_Offset), Loc))))),
Offset_Value);
end Build_Set_Static_Offset_To_Top;
Make_Expanded_Name (Loc,
Chars => Name_Op_Subtract,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(RTU_Entity (System_Storage_Elements), Loc),
Selector_Name => Make_Identifier (Loc, Name_Op_Subtract)),
Parameter_Associations => New_List (
Tag_Node_Addr,
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_DT_Typeinfo_Ptr_Size), Loc))))));
end Build_TSD;
Index :=
Make_Defining_Identifier (Loc, New_External_Name ('J', N));
- Append (New_Reference_To (Index, Loc), Index_List);
+ Append (New_Occurrence_Of (Index, Loc), Index_List);
return New_List (
Make_Implicit_Loop_Statement (Nod,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_uA),
In_Present => True,
Out_Present => False,
- Parameter_Type => New_Reference_To (A_Type, Loc)));
+ Parameter_Type => New_Occurrence_Of (A_Type, Loc)));
-- Build body
Fnm :=
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (RTE (Pkg), Loc),
+ Prefix => New_Occurrence_Of (RTE (Pkg), Loc),
Selector_Name => Make_Identifier (Loc, Nam));
-- The generated call is given the provided set of parameters, and then
Make_Op_Gt (Loc,
Left_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Array_Nam, Loc),
+ Prefix => New_Occurrence_Of (Array_Nam, Loc),
Attribute_Name => Name_Length,
Expressions => New_List (
Make_Integer_Literal (Loc, Dim))),
Make_Object_Declaration (Loc,
Defining_Identifier => Temp_Id,
Constant_Present => True,
- Object_Definition => New_Reference_To (Typ, Loc),
+ Object_Definition => New_Occurrence_Of (Typ, Loc),
Expression => Relocate_Node (Pref));
Append_To (Decls, Temp_Decl);
-- Step 4: Analyze all bits
- Rewrite (N, New_Reference_To (Temp_Id, Loc));
+ Rewrite (N, New_Occurrence_Of (Temp_Id, Loc));
Installed := Current_Scope = Scope (Loop_Id);
then
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Base_Address), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Base_Address), Loc),
Parameter_Associations => New_List (
Relocate_Node (N))));
Analyze (N);
else
New_Node :=
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Alignment), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Alignment), Loc),
Parameter_Associations => New_List (New_Node));
end if;
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Version_String), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Version_String), Loc),
Parameter_Associations => New_List (
New_Occurrence_Of (E, Loc))));
end if;
Rewrite (N,
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Callable), Loc),
+ New_Occurrence_Of (RTE (RE_Callable), Loc),
Parameter_Associations => New_List (
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RO_ST_Task_Id), Loc),
+ New_Occurrence_Of (RTE (RO_ST_Task_Id), Loc),
Expression =>
Make_Selected_Component (Loc,
Prefix =>
case Corresponding_Runtime_Package (Conctype) is
when System_Tasking_Protected_Objects_Entries =>
Name :=
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Protected_Entry_Caller), Loc);
when System_Tasking_Protected_Objects_Single_Entry =>
Name :=
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Protected_Single_Entry_Caller), Loc);
when others =>
Make_Function_Call (Loc,
Name => Name,
Parameter_Associations => New_List (
- New_Reference_To
+ New_Occurrence_Of
(Find_Protection_Object (Current_Scope), Loc)))));
-- Task case
Unchecked_Convert_To (Id_Kind,
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Task_Entry_Caller), Loc),
+ New_Occurrence_Of (RTE (RE_Task_Entry_Caller), Loc),
Parameter_Associations => New_List (
Make_Integer_Literal (Loc,
Intval => Int (Nest_Depth))))));
and then Is_Limited_Type (Ptyp));
end if;
- Rewrite (N, New_Reference_To (Boolean_Literals (Res), Loc));
+ Rewrite (N, New_Occurrence_Of (Boolean_Literals (Res), Loc));
end;
-- Prefix is not an entity name. These are also cases where we can
else
Rewrite (N,
- New_Reference_To (
+ New_Occurrence_Of (
Boolean_Literals (
not Is_Variable (Pref)
or else
if Is_Protected_Type (Conctyp) then
case Corresponding_Runtime_Package (Conctyp) is
when System_Tasking_Protected_Objects_Entries =>
- Name := New_Reference_To (RTE (RE_Protected_Count), Loc);
+ Name := New_Occurrence_Of (RTE (RE_Protected_Count), Loc);
Call :=
Make_Function_Call (Loc,
Name => Name,
Parameter_Associations => New_List (
- New_Reference_To
+ New_Occurrence_Of
(Find_Protection_Object (Current_Scope), Loc),
Entry_Index_Expression
(Loc, Entry_Id, Index, Scope (Entry_Id))));
when System_Tasking_Protected_Objects_Single_Entry =>
Name :=
- New_Reference_To (RTE (RE_Protected_Count_Entry), Loc);
+ New_Occurrence_Of (RTE (RE_Protected_Count_Entry), Loc);
Call :=
Make_Function_Call (Loc,
Name => Name,
Parameter_Associations => New_List (
- New_Reference_To
+ New_Occurrence_Of
(Find_Protection_Object (Current_Scope), Loc)));
when others =>
else
Call :=
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Task_Count), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Task_Count), Loc),
Parameter_Associations => New_List (
Entry_Index_Expression (Loc,
Entry_Id, Index, Scope (Entry_Id))));
Left_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (TSS (Btyp, TSS_Rep_To_Pos), Loc),
+ New_Occurrence_Of (TSS (Btyp, TSS_Rep_To_Pos), Loc),
Parameter_Associations => New_List (
Relocate_Node (Duplicate_Subexpr (Expr)),
New_Occurrence_Of (Standard_False, Loc))),
begin
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_External_Tag), Loc),
+ Name => New_Occurrence_Of (RTE (RE_External_Tag), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Tag,
Rewrite (N,
Make_Attribute_Reference (Loc,
Attribute_Name => Name_First,
- Prefix => New_Reference_To (Get_Index_Subtype (N), Loc)));
+ Prefix => New_Occurrence_Of (Get_Index_Subtype (N), Loc)));
Analyze_And_Resolve (N, Typ);
elsif Is_Access_Type (Ptyp) then
Rewrite (N,
Convert_To (Typ,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Fore), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Fore), Loc),
Parameter_Associations => New_List (
Convert_To (Universal_Real,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_First)),
Convert_To (Universal_Real,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Last))))));
Analyze_And_Resolve (N, Typ);
begin
Rewrite (N,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Image,
Expressions => New_List (Relocate_Node (Pref))));
Expressions => New_List (
Relocate_Node (Duplicate_Subexpr (Strm)))),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (P_Type, Loc),
+ Prefix => New_Occurrence_Of (P_Type, Loc),
Attribute_Name => Name_Tag)));
Dnn := Make_Temporary (Loc, 'D', Expr);
Rewrite (N,
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Last,
- Prefix => New_Reference_To (Get_Index_Subtype (N), Loc)));
+ Prefix => New_Occurrence_Of (Get_Index_Subtype (N), Loc)));
Analyze_And_Resolve (N, Typ);
elsif Is_Access_Type (Ptyp) then
Rewrite (N,
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Range_Length,
- Prefix => New_Reference_To (Ityp, Loc)));
+ Prefix => New_Occurrence_Of (Ityp, Loc)));
Analyze_And_Resolve (N, Typ);
end if;
Convert_To (Universal_Integer,
Make_Function_Call (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Header_Size_With_Padding), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Ptyp, Loc),
+ New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Alignment))))));
-- Add a conversion to the target type
if not Conversion_Added then
Rewrite (Attr,
Make_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (Typ, Loc),
+ Subtype_Mark => New_Occurrence_Of (Typ, Loc),
Expression => Relocate_Node (Attr)));
end if;
Convert_To (Typ,
Make_Function_Call (Loc,
Name =>
- New_Reference_To (TSS (Etyp, TSS_Rep_To_Pos), Loc),
+ New_Occurrence_Of (TSS (Etyp, TSS_Rep_To_Pos), Loc),
Parameter_Associations => Exprs)));
Analyze_And_Resolve (N, Typ);
Right_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(TSS (Etyp, TSS_Rep_To_Pos), Loc),
Parameter_Associations =>
Rewrite (N,
Make_Indexed_Component (Loc,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(Enum_Pos_To_Rep (Etyp), Loc),
Expressions => New_List (
Make_Op_Subtract (Loc,
Left_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(TSS (Etyp, TSS_Rep_To_Pos), Loc),
Parameter_Associations => Exprs),
Right_Opnd => Make_Integer_Literal (Loc, 1)))));
Make_Selected_Component (Loc,
Prefix =>
Unchecked_Convert_To (New_Itype,
- New_Reference_To
+ New_Occurrence_Of
(First_Entity
(Protected_Body_Subprogram (Subprg)),
Loc)),
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To
+ Prefix => New_Occurrence_Of
(First_Entity
(Protected_Body_Subprogram (Subprg)),
Loc),
if Number_Entries (Conctyp) = 0 then
RT_Subprg_Name :=
- New_Reference_To (RTE (RE_Get_Ceiling), Loc);
+ New_Occurrence_Of (RTE (RE_Get_Ceiling), Loc);
else
RT_Subprg_Name :=
- New_Reference_To (RTE (RO_PE_Get_Ceiling), Loc);
+ New_Occurrence_Of (RTE (RO_PE_Get_Ceiling), Loc);
end if;
Call :=
when Attribute_Simple_Storage_Pool =>
Rewrite (N,
Make_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (Etype (N), Loc),
- Expression => New_Reference_To (Entity (N), Loc)));
+ Subtype_Mark => New_Occurrence_Of (Etype (N), Loc),
+ Expression => New_Occurrence_Of (Entity (N), Loc)));
Analyze_And_Resolve (N, Typ);
----------
New_Node :=
Make_Function_Call (Loc,
- Name => New_Reference_To
+ Name => New_Occurrence_Of
(Find_Prim_Op (Ptyp, Name_uSize), Loc),
Parameter_Associations => New_List (Pref));
when Attribute_Storage_Pool =>
Rewrite (N,
Make_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (Etype (N), Loc),
- Expression => New_Reference_To (Entity (N), Loc)));
+ Subtype_Mark => New_Occurrence_Of (Etype (N), Loc),
+ Expression => New_Occurrence_Of (Entity (N), Loc)));
Analyze_And_Resolve (N, Typ);
------------------
if Present (Storage_Size_Variable (Root_Type (Ptyp))) then
Rewrite (N,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Max,
Expressions => New_List (
Make_Integer_Literal (Loc, 0),
Convert_To (Typ,
- New_Reference_To
+ New_Occurrence_Of
(Storage_Size_Variable (Root_Type (Ptyp)), Loc)))));
elsif Present (Associated_Storage_Pool (Root_Type (Ptyp))) then
OK_Convert_To (Typ,
Make_Function_Call (Loc,
Name =>
- New_Reference_To (Alloc_Op, Loc),
+ New_Occurrence_Of (Alloc_Op, Loc),
Parameter_Associations => New_List (
- New_Reference_To
+ New_Occurrence_Of
(Associated_Storage_Pool
(Root_Type (Ptyp)), Loc)))));
end if;
New_List (
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Self), Loc))))));
+ New_Occurrence_Of (RTE (RE_Self), Loc))))));
elsif not Is_Entity_Name (Pref)
or else not Is_Type (Entity (Pref))
RTE (RE_Adjust_Storage_Size), Loc),
Parameter_Associations =>
New_List (
- New_Reference_To (
+ New_Occurrence_Of (
Storage_Size_Variable (Ptyp), Loc)))));
else
-- Get system default
Right_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(TSS (Etyp, TSS_Rep_To_Pos), Loc),
Parameter_Associations =>
Rewrite (N,
Make_Indexed_Component (Loc,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(Enum_Pos_To_Rep (Etyp), Loc),
Expressions => New_List (
Make_Op_Add (Loc,
Left_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(TSS (Etyp, TSS_Rep_To_Pos), Loc),
Parameter_Associations => Exprs),
Right_Opnd => Make_Integer_Literal (Loc, 1)))));
if Tagged_Type_Expansion then
Rewrite (N,
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Ttyp))), Loc)));
Analyze_And_Resolve (N, RTE (RE_Tag));
end if;
Make_Selected_Component (Loc,
Prefix => Relocate_Node (Pref),
Selector_Name =>
- New_Reference_To (First_Tag_Component (Ttyp), Loc)));
+ New_Occurrence_Of (First_Tag_Component (Ttyp), Loc)));
Analyze_And_Resolve (N, RTE (RE_Tag));
end if;
end Tag;
Rewrite (N,
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Terminated), Loc),
+ New_Occurrence_Of (RTE (RE_Terminated), Loc),
Parameter_Associations => New_List (
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RO_ST_Task_Id), Loc),
+ New_Occurrence_Of (RTE (RO_ST_Task_Id), Loc),
Expression =>
Make_Selected_Component (Loc,
Prefix =>
Right_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(TSS (Etyp, TSS_Rep_To_Pos), Loc),
Parameter_Associations => New_List (
Rep_Node,
else
Rewrite (N,
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (Enum_Pos_To_Rep (Etyp), Loc),
+ Prefix => New_Occurrence_Of (Enum_Pos_To_Rep (Etyp), Loc),
Expressions => New_List (
Convert_To (Standard_Integer,
Relocate_Node (First (Exprs))))));
Left_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (TSS (Btyp, TSS_Rep_To_Pos), Loc),
+ New_Occurrence_Of (TSS (Btyp, TSS_Rep_To_Pos), Loc),
Parameter_Associations => New_List (
Pref,
New_Occurrence_Of (Standard_False, Loc))),
Expressions => New_List (
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Wide_String_To_String), Loc),
+ New_Occurrence_Of (RTE (RE_Wide_String_To_String), Loc),
Parameter_Associations => New_List (
Relocate_Node (First (Exprs)),
Expressions => New_List (
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Wide_Wide_String_To_String), Loc),
+ New_Occurrence_Of
+ (RTE (RE_Wide_Wide_String_To_String), Loc),
Parameter_Associations => New_List (
Relocate_Node (First (Exprs)),
Right_Opnd =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Base_Type (Etype (Prefix (N))), Loc),
+ New_Occurrence_Of (Base_Type (Etype (Prefix (N))), Loc),
Attribute_Name => Cnam)),
Reason => CE_Overflow_Check_Failed));
end if;
LHS :=
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (Temp, Loc),
+ Prefix => New_Occurrence_Of (Temp, Loc),
Expressions => Exprs);
-- A record component update appears in the following form:
else pragma Assert (Is_Record_Type (Typ));
LHS :=
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Temp, Loc),
+ Prefix => New_Occurrence_Of (Temp, Loc),
Selector_Name => Relocate_Node (Comp));
end if;
Make_Assignment_Statement (Loc,
Name =>
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (Temp, Loc),
+ Prefix => New_Occurrence_Of (Temp, Loc),
Expressions => New_List (
- Convert_To (Index_Typ, New_Reference_To (Index, Loc)))),
+ Convert_To (Index_Typ,
+ New_Occurrence_Of (Index, Loc)))),
Expression => Relocate_Node (Expr))),
End_Label => Empty));
Insert_Action (N,
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
- Object_Definition => New_Reference_To (Typ, Loc),
+ Object_Definition => New_Occurrence_Of (Typ, Loc),
Expression => Relocate_Node (Pref)));
-- Process the update aggregate
-- The attribute is replaced by a reference to the anonymous object
- Rewrite (N, New_Reference_To (Temp, Loc));
+ Rewrite (N, New_Occurrence_Of (Temp, Loc));
Analyze (N);
end Expand_Update_Attribute;
Assign :=
Make_Assignment_Statement (Loc,
Name =>
- New_Reference_To (Storage_Size_Variable (Ent), Loc),
+ New_Occurrence_Of (Storage_Size_Variable (Ent), Loc),
Expression =>
Convert_To (RTE (RE_Size_Type), Expression (N)));
Make_Object_Declaration (Loc,
Defining_Identifier => V,
Object_Definition =>
- New_Reference_To (RTE (RE_Storage_Offset), Loc),
+ New_Occurrence_Of (RTE (RE_Storage_Offset), Loc),
Expression =>
Convert_To (RTE (RE_Storage_Offset), Expression (N))));
Make_Object_Declaration (Loc,
Defining_Identifier => Temp_Id,
Object_Definition =>
- New_Reference_To (Expr_Typ, Loc),
+ New_Occurrence_Of (Expr_Typ, Loc),
Expression =>
Relocate_Node (Expr)));
- New_Expr := New_Reference_To (Temp_Id, Loc);
+ New_Expr := New_Occurrence_Of (Temp_Id, Loc);
Set_Etype (New_Expr, Expr_Typ);
Set_Expression (N, New_Expr);
AtM_Nod :=
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (Base_Type (Rectype), Loc),
+ Name => New_Occurrence_Of (Base_Type (Rectype), Loc),
Chars => Name_Alignment,
Expression => Make_Integer_Literal (Loc, Mod_Val));
Prefix =>
Make_Explicit_Dereference (Loc,
Unchecked_Convert_To (Parm_Type,
- New_Reference_To (Addr_Ent, Loc))),
+ New_Occurrence_Of (Addr_Ent, Loc))),
Selector_Name =>
- New_Reference_To (Entry_Component (Ent_Formal), Loc));
+ New_Occurrence_Of (Entry_Component (Ent_Formal), Loc));
-- For all types of parameters, the constructed parameter record object
-- contains a pointer to the parameter. Thus we must dereference them to
Index :=
Make_Defining_Identifier (Loc, New_External_Name ('J', N));
- Append (New_Reference_To (Index, Loc), Index_List);
+ Append (New_Occurrence_Of (Index, Loc), Index_List);
return New_List (
Make_Implicit_Loop_Statement (Nod,
Index :=
Make_Defining_Identifier (Loc, New_External_Name ('J', N));
- Append (New_Reference_To (Index, Loc), Index_List);
+ Append (New_Occurrence_Of (Index, Loc), Index_List);
return New_List (
Make_Implicit_Loop_Statement (Nod,
Expression =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (Enclosing_Func_Id, Loc),
+ New_Occurrence_Of (Enclosing_Func_Id, Loc),
Parameter_Associations =>
Actuals_List));
Return_Node :=
Make_Simple_Return_Statement (Loc,
Expression =>
- New_Reference_To (Standard_False, Loc));
+ New_Occurrence_Of (Standard_False, Loc));
end if;
Set_Statements (Case_Alt_Node, New_List (Return_Node));
Return_Node :=
Make_Simple_Return_Statement (Loc,
Expression =>
- New_Reference_To (Standard_True, Loc));
+ New_Occurrence_Of (Standard_True, Loc));
Set_Statements (Case_Alt_Node, New_List (Return_Node));
Append (Case_Alt_Node, Alt_List);
Set_Parameter_Specifications (Spec_Node, Parameter_List);
Set_Result_Definition (Spec_Node,
- New_Reference_To (Standard_Boolean, Loc));
+ New_Occurrence_Of (Standard_Boolean, Loc));
Set_Specification (Body_Node, Spec_Node);
Set_Declarations (Body_Node, New_List);
Make_Parameter_Specification (Loc,
Defining_Identifier => Formal,
Parameter_Type =>
- New_Reference_To (Formal_Type, Loc));
+ New_Occurrence_Of (Formal_Type, Loc));
Append (Param_Spec_Node, Parameter_List);
Next_Discriminant (D);
end loop;
if Nkind (Arg) = N_Identifier
and then Ekind (Entity (Arg)) = E_Discriminant
then
- Arg := New_Reference_To (Discriminal (Entity (Arg)), Loc);
+ Arg := New_Occurrence_Of (Discriminal (Entity (Arg)), Loc);
-- Otherwise make a copy of the default expression. Note that
-- we use the current Sloc for this, because we do not want the
Prefix =>
New_Copy_Tree (Lhs, New_Scope => Proc_Id),
Selector_Name =>
- New_Reference_To (First_Tag_Component (Typ), N_Loc)),
+ New_Occurrence_Of (First_Tag_Component (Typ), N_Loc)),
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node
(First_Elmt
(Access_Disp_Table (Underlying_Type (Typ)))),
D_Loc := Sloc (D);
Append_List_To (Statement_List,
Build_Assignment (D,
- New_Reference_To (Discriminal (D), D_Loc)));
+ New_Occurrence_Of (Discriminal (D), D_Loc)));
end if;
Next_Discriminant (D);
First_Arg :=
OK_Convert_To (Parent_Type,
- New_Reference_To (Defining_Identifier (First (Parameters)), Loc));
+ New_Occurrence_Of
+ (Defining_Identifier (First (Parameters)), Loc));
Set_Etype (First_Arg, Parent_Type);
and then Ekind (Entity (Arg)) = E_Discriminant
then
Append_To (Args,
- New_Reference_To (Discriminal (Entity (Arg)), Loc));
+ New_Occurrence_Of (Discriminal (Entity (Arg)), Loc));
-- Case of access discriminants. We replace the reference
-- to the type by a reference to the actual object.
Make_Defining_Identifier (Loc, Name_uO),
In_Present => True,
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc))));
+ New_Occurrence_Of (RTE (RE_Address), Loc))));
Set_Result_Definition (Spec_Node,
- New_Reference_To (RTE (RE_Storage_Offset), Loc));
+ New_Occurrence_Of (RTE (RE_Storage_Offset), Loc));
-- Generate
-- function Fxx (O : in Rec_Typ) return Storage_Offset is
Null_Exclusion_Present => False,
Constant_Present => False,
Subtype_Indication =>
- New_Reference_To (Rec_Type, Loc)))));
+ New_Occurrence_Of (Rec_Type, Loc)))));
Set_Handled_Statement_Sequence (Body_Node,
Make_Handled_Sequence_Of_Statements (Loc,
Unchecked_Convert_To (Acc_Type,
Make_Identifier (Loc, Name_uO)),
Selector_Name =>
- New_Reference_To (Iface_Comp, Loc)),
+ New_Occurrence_Of (Iface_Comp, Loc)),
Attribute_Name => Name_Position)))));
Set_Ekind (Func_Id, E_Function);
Make_Object_Declaration (Loc,
Defining_Identifier => Flag_Id,
Object_Definition =>
- New_Reference_To (Standard_Boolean, Loc),
+ New_Occurrence_Of (Standard_Boolean, Loc),
Expression =>
- New_Reference_To (Standard_True, Loc));
+ New_Occurrence_Of (Standard_True, Loc));
Analyze (Flag_Decl);
Append_Freeze_Action (Rec_Type, Flag_Decl);
Append_To (Init_Tags_List,
Make_Assignment_Statement (Loc,
Name =>
- New_Reference_To (Flag_Id, Loc),
+ New_Occurrence_Of (Flag_Id, Loc),
Expression =>
- New_Reference_To (Standard_False, Loc)));
+ New_Occurrence_Of (Standard_False, Loc)));
Append_To (Body_Stmts,
Make_If_Statement (Loc,
Make_Selected_Component (Loc,
Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Rec_Type), Loc)),
Expression =>
- New_Reference_To
+ New_Occurrence_Of
(Node
(First_Elmt (Access_Disp_Table (Rec_Type))), Loc)));
Make_Selected_Component (Loc,
Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Rec_Type), Loc)),
Expression =>
- New_Reference_To
+ New_Occurrence_Of
(Node
(First_Elmt (Access_Disp_Table (Rec_Type))), Loc)));
New_Nod :=
Make_Procedure_Call_Statement (Loc,
- New_Reference_To (Init_DT, Loc));
+ New_Occurrence_Of (Init_DT, Loc));
Insert_After (Ins_Nod, New_Nod);
-- Update location of init tag statements
Statements => New_List (
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (Local_DF_Id, Loc),
+ New_Occurrence_Of (Local_DF_Id, Loc),
Parameter_Associations => New_List (
Make_Identifier (Loc, Name_uInit),
- New_Reference_To (Standard_False, Loc))),
+ New_Occurrence_Of (Standard_False, Loc))),
Make_Raise_Statement (Loc)))));
end;
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Counter_Id, Loc),
+ Name => New_Occurrence_Of (Counter_Id, Loc),
Expression =>
Make_Op_Add (Loc,
- Left_Opnd => New_Reference_To (Counter_Id, Loc),
+ Left_Opnd => New_Occurrence_Of (Counter_Id, Loc),
Right_Opnd => Make_Integer_Literal (Loc, 1))));
end Increment_Counter;
Make_Object_Declaration (Loc,
Defining_Identifier => Counter_Id,
Object_Definition =>
- New_Reference_To (Standard_Integer, Loc),
+ New_Occurrence_Of (Standard_Integer, Loc),
Expression =>
Make_Integer_Literal (Loc, 0)));
end Make_Counter;
Append_To (Stmts,
Make_Procedure_Call_Statement (Decl_Loc,
Name =>
- New_Reference_To (RTE (
+ New_Occurrence_Of (RTE (
RE_Bind_Interrupt_To_Entry), Decl_Loc),
Parameter_Associations => New_List (
Make_Selected_Component (Decl_Loc,
Append_To (Stmts,
Make_Case_Statement (Var_Loc,
Expression =>
- New_Reference_To (Discriminal (
+ New_Occurrence_Of (Discriminal (
Entity (Name (Variant_Part (Comp_List)))), Var_Loc),
Alternatives => Variant_Alts));
end;
Defining_Identifier => Larray,
Out_Present => True,
Parameter_Type =>
- New_Reference_To (Base_Type (Typ), Loc)),
+ New_Occurrence_Of (Base_Type (Typ), Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => Rarray,
Parameter_Type =>
- New_Reference_To (Base_Type (Typ), Loc)),
+ New_Occurrence_Of (Base_Type (Typ), Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => Left_Lo,
Parameter_Type =>
- New_Reference_To (Index, Loc)),
+ New_Occurrence_Of (Index, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => Left_Hi,
Parameter_Type =>
- New_Reference_To (Index, Loc)),
+ New_Occurrence_Of (Index, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => Right_Lo,
Parameter_Type =>
- New_Reference_To (Index, Loc)),
+ New_Occurrence_Of (Index, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => Right_Hi,
Parameter_Type =>
- New_Reference_To (Index, Loc)));
+ New_Occurrence_Of (Index, Loc)));
Append_To (Formals,
Make_Parameter_Specification (Loc,
Defining_Identifier => Rev,
Parameter_Type =>
- New_Reference_To (Standard_Boolean, Loc)));
+ New_Occurrence_Of (Standard_Boolean, Loc)));
Spec :=
Make_Procedure_Specification (Loc,
Make_Function_Specification (Loc,
Defining_Unit_Name => F,
Parameter_Specifications => Pspecs,
- Result_Definition => New_Reference_To (Standard_Boolean, Loc)),
+ Result_Definition => New_Occurrence_Of (Standard_Boolean, Loc)),
Declarations => New_List,
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc, Statements => Stmts)));
Append_To (Pspecs,
Make_Parameter_Specification (Loc,
Defining_Identifier => X,
- Parameter_Type => New_Reference_To (Typ, Loc)));
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)));
Append_To (Pspecs,
Make_Parameter_Specification (Loc,
Defining_Identifier => Y,
- Parameter_Type => New_Reference_To (Typ, Loc)));
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)));
-- Unchecked_Unions require additional machinery to support equality.
-- Two extra parameters (A and B) are added to the equality function
Append_To (Pspecs,
Make_Parameter_Specification (Loc,
Defining_Identifier => A,
- Parameter_Type => New_Reference_To (Discr_Type, Loc)));
+ Parameter_Type =>
+ New_Occurrence_Of (Discr_Type, Loc)));
Append_To (Pspecs,
Make_Parameter_Specification (Loc,
Defining_Identifier => B,
- Parameter_Type => New_Reference_To (Discr_Type, Loc)));
+ Parameter_Type =>
+ New_Occurrence_Of (Discr_Type, Loc)));
Append_Elmt (A, New_Discrs);
Make_If_Statement (Loc,
Condition =>
Make_Op_Ne (Loc,
- Left_Opnd => New_Reference_To (A, Loc),
- Right_Opnd => New_Reference_To (B, Loc)),
+ Left_Opnd => New_Occurrence_Of (A, Loc),
+ Right_Opnd => New_Occurrence_Of (B, Loc)),
Then_Statements => New_List (
Make_Simple_Return_Statement (Loc,
Expression =>
Append_To (Stmts,
Make_Simple_Return_Statement (Loc,
- Expression => New_Reference_To (Standard_True, Loc)));
+ Expression => New_Occurrence_Of (Standard_True, Loc)));
Set_TSS (Typ, F);
Set_Is_Pure (F);
Par_Subtype :=
Process_Subtype (
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Entity (Indic), Loc),
+ Subtype_Mark => New_Occurrence_Of (Entity (Indic), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => List_Constr)),
Component_Definition =>
Make_Component_Definition (Loc,
Aliased_Present => False,
- Subtype_Indication => New_Reference_To (Par_Subtype, Loc)));
+ Subtype_Indication => New_Occurrence_Of (Par_Subtype, Loc)));
if Null_Present (Rec_Ext_Part) then
Set_Component_List (Rec_Ext_Part,
-- address clause is applied to the object, causing it to get
-- delayed freezing).
- Id_Ref := New_Reference_To (Def_Id, Loc);
+ Id_Ref := New_Occurrence_Of (Def_Id, Loc);
Set_Must_Not_Freeze (Id_Ref);
Set_Assignment_OK (Id_Ref);
Make_Selected_Component (Loc,
Prefix => New_Occurrence_Of (Obj_Id, Loc),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(Find_Interface_Tag (Expr_Typ, Iface), Loc));
-- Replace
Tag_Comp :=
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Displace), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Displace), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => New_Occurrence_Of (Obj_Id, Loc),
Attribute_Name => Name_Address),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Iface))),
Loc)));
end if;
then
Insert_Action_After (Init_After,
Make_Adjust_Call (
- Obj_Ref => New_Reference_To (Def_Id, Loc),
+ Obj_Ref => New_Occurrence_Of (Def_Id, Loc),
Typ => Base_Typ));
end if;
Make_Selected_Component (Loc,
Prefix => New_Occurrence_Of (Def_Id, Loc),
Selector_Name =>
- New_Reference_To (First_Tag_Component (Full_Typ),
+ New_Occurrence_Of (First_Tag_Component (Full_Typ),
Loc));
Set_Assignment_OK (New_Ref);
Name => New_Ref,
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Full_Typ))),
Loc))));
end;
-- The call to the initialization procedure does NOT freeze the
-- object being initialized.
- Id_Ref := New_Reference_To (Def_Id, Loc);
+ Id_Ref := New_Occurrence_Of (Def_Id, Loc);
Set_Must_Not_Freeze (Id_Ref);
Set_Assignment_OK (Id_Ref);
declare
Stat : constant Node_Id :=
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Def_Id, Loc),
+ Name => New_Occurrence_Of (Def_Id, Loc),
Expression => Relocate_Node (Expr));
begin
Set_Expression (N, Empty);
Component_Definition =>
Make_Component_Definition (Sloc_N,
Aliased_Present => False,
- Subtype_Indication => New_Reference_To (RTE (RE_Tag), Sloc_N)));
+ Subtype_Indication => New_Occurrence_Of (RTE (RE_Tag), Sloc_N)));
if Null_Present (Comp_List)
or else Is_Empty_List (Component_Items (Comp_List))
Set_Has_Contiguous_Rep (Typ);
Ent := First_Literal (Typ);
Num := 1;
- Lst := New_List (New_Reference_To (Ent, Sloc (Ent)));
+ Lst := New_List (New_Occurrence_Of (Ent, Sloc (Ent)));
else
-- Build list of literal references
Ent := First_Literal (Typ);
while Present (Ent) loop
- Append_To (Lst, New_Reference_To (Ent, Sloc (Ent)));
+ Append_To (Lst, New_Occurrence_Of (Ent, Sloc (Ent)));
Num := Num + 1;
Next_Literal (Ent);
end loop;
Make_Constrained_Array_Definition (Loc,
Discrete_Subtype_Definitions => New_List (
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Standard_Natural, Loc),
+ Subtype_Mark => New_Occurrence_Of (Standard_Natural, Loc),
Constraint =>
Make_Range_Constraint (Loc,
Range_Expression =>
Component_Definition =>
Make_Component_Definition (Loc,
Aliased_Present => False,
- Subtype_Indication => New_Reference_To (Typ, Loc))),
+ Subtype_Indication => New_Occurrence_Of (Typ, Loc))),
Expression =>
Make_Aggregate (Loc,
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uA),
- Parameter_Type => New_Reference_To (Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uF),
- Parameter_Type => New_Reference_To (Standard_Boolean, Loc))),
+ Parameter_Type =>
+ New_Occurrence_Of (Standard_Boolean, Loc))),
- Result_Definition => New_Reference_To (Standard_Integer, Loc)),
+ Result_Definition => New_Occurrence_Of (Standard_Integer, Loc)),
Declarations => Empty_List,
Insert_Action (Ins_Node,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Set_Is_Heterogeneous), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Fin_Mas_Id, Loc))));
+ New_Occurrence_Of (Fin_Mas_Id, Loc))));
end if;
end if;
else
DT_Size :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Desig_Type, Loc),
+ Prefix => New_Occurrence_Of (Desig_Type, Loc),
Attribute_Name => Name_Max_Size_In_Storage_Elements);
DT_Align :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Desig_Type, Loc),
+ Prefix => New_Occurrence_Of (Desig_Type, Loc),
Attribute_Name => Name_Alignment);
end if;
Object_Definition =>
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Stack_Bounded_Pool), Loc),
Constraint =>
-- First discriminant is the Pool Size
- New_Reference_To (
+ New_Occurrence_Of (
Storage_Size_Variable (Def_Id), Loc),
-- Second discriminant is the element size
Condition =>
Make_In (Loc,
Left_Opnd =>
- New_Reference_To (Pool, Loc),
+ New_Occurrence_Of (Pool, Loc),
Right_Opnd =>
- New_Reference_To
+ New_Occurrence_Of
(Class_Wide_Type (RSPWS), Loc)),
Then_Statements => New_List (
Name => New_Occurrence_Of (Proc_Id, Loc),
Parameter_Associations =>
New_List
- (New_Reference_To (First_Formal (Inv_Id), Loc)));
+ (New_Occurrence_Of (First_Formal (Inv_Id), Loc)));
begin
Make_Defining_Identifier (Loc, Name_uInit),
In_Present => True,
Out_Present => True,
- Parameter_Type => New_Reference_To (Typ, Loc)));
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)));
-- For task record value, or type that contains tasks, add two more
-- formals, _Master : Master_Id and _Chain : in out Activation_Chain
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uMaster),
Parameter_Type =>
- New_Reference_To (RTE (RE_Master_Id), Loc)));
+ New_Occurrence_Of (RTE (RE_Master_Id), Loc)));
-- Add _Chain (not done for sequential elaboration policy, see
-- comment for Create_Restricted_Task_Sequential in s-tarest.ads).
In_Present => True,
Out_Present => True,
Parameter_Type =>
- New_Reference_To (RTE (RE_Activation_Chain), Loc)));
+ New_Occurrence_Of (RTE (RE_Activation_Chain), Loc)));
end if;
Append_To (Formals,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uTask_Name),
In_Present => True,
- Parameter_Type => New_Reference_To (Standard_String, Loc)));
+ Parameter_Type => New_Occurrence_Of (Standard_String, Loc)));
end if;
return Formals;
Name =>
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Target),
- Selector_Name => New_Reference_To (Tag_Comp, Loc)),
+ Selector_Name => New_Occurrence_Of (Tag_Comp, Loc)),
Expression =>
- New_Reference_To (Iface_Tag, Loc)));
+ New_Occurrence_Of (Iface_Tag, Loc)));
end if;
Comp_Typ := Scope (Tag_Comp);
Append_To (Stmts_List,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To
+ Name => New_Occurrence_Of
(RTE (RE_Set_Dynamic_Offset_To_Top), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Address),
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Iface))),
Loc)),
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Target),
Selector_Name =>
- New_Reference_To (Tag_Comp, Loc)),
+ New_Occurrence_Of (Tag_Comp, Loc)),
Attribute_Name => Name_Position)),
Unchecked_Convert_To (RTE (RE_Offset_To_Top_Function_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To
+ Prefix => New_Occurrence_Of
(DT_Offset_To_Top_Func (Tag_Comp), Loc),
Attribute_Name => Name_Address)))));
Name =>
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Target),
- Selector_Name => New_Reference_To
+ Selector_Name => New_Occurrence_Of
(Offset_To_Top_Comp, Loc)),
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Target),
- Selector_Name => New_Reference_To (Tag_Comp, Loc)),
+ Selector_Name => New_Occurrence_Of (Tag_Comp, Loc)),
Attribute_Name => Name_Position)));
-- Normal case: No discriminants in the parent type
if not Is_Ancestor (Iface, Typ, Use_Full_View => True) then
Append_To (Stmts_List,
Build_Set_Static_Offset_To_Top (Loc,
- Iface_Tag => New_Reference_To (Iface_Tag, Loc),
+ Iface_Tag => New_Occurrence_Of (Iface_Tag, Loc),
Offset_Value =>
Unchecked_Convert_To (RTE (RE_Storage_Offset),
Make_Attribute_Reference (Loc,
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Target),
Selector_Name =>
- New_Reference_To (Tag_Comp, Loc)),
+ New_Occurrence_Of (Tag_Comp, Loc)),
Attribute_Name => Name_Position))));
end if;
if RTE_Available (RE_Register_Interface_Offset) then
Append_To (Stmts_List,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To
+ Name => New_Occurrence_Of
(RTE (RE_Register_Interface_Offset), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Address),
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Iface))), Loc)),
New_Occurrence_Of (Standard_True, Loc),
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Target),
Selector_Name =>
- New_Reference_To (Tag_Comp, Loc)),
+ New_Occurrence_Of (Tag_Comp, Loc)),
Attribute_Name => Name_Position)),
Make_Null (Loc))));
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Target),
Selector_Name =>
- New_Reference_To (Node (Iface_Comp_Elmt), Loc)),
+ New_Occurrence_Of (Node (Iface_Comp_Elmt), Loc)),
Expression =>
- New_Reference_To (Node (Iface_Tag_Elmt), Loc)));
+ New_Occurrence_Of (Node (Iface_Tag_Elmt), Loc)));
end if;
-- Otherwise generate code to initialize the tag
Null_Exclusion_Present =>
Null_Exclusion_Present (Parent (Formal)),
Parameter_Type =>
- New_Reference_To (Etype (Formal), Loc),
+ New_Occurrence_Of (Etype (Formal), Loc),
Expression =>
New_Copy_Tree (Expression (Parent (Formal)))),
Formal_List);
Chars => Chars (Subp)),
Parameter_Specifications => Formal_List,
Result_Definition =>
- New_Reference_To (Etype (Subp), Loc));
+ New_Occurrence_Of (Etype (Subp), Loc));
Func_Decl := Make_Subprogram_Declaration (Loc, Func_Spec);
Append_To (Decl_List, Func_Decl);
Subtype_Mark =>
New_Occurrence_Of (Etype (Par_Formal), Loc),
Expression =>
- New_Reference_To
+ New_Occurrence_Of
(Defining_Identifier (Formal_Node), Loc)));
else
Append_To
(Actual_List,
- New_Reference_To
+ New_Occurrence_Of
(Defining_Identifier (Formal_Node), Loc));
end if;
Make_Extension_Aggregate (Loc,
Ancestor_Part =>
Make_Function_Call (Loc,
- Name => New_Reference_To (Alias (Subp), Loc),
+ Name => New_Occurrence_Of (Alias (Subp), Loc),
Parameter_Associations => Actual_List),
Null_Record_Present => True));
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_X),
- Parameter_Type => New_Reference_To (Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_Y),
- Parameter_Type => New_Reference_To (Typ, Loc))),
+ Parameter_Type => New_Occurrence_Of (Typ, Loc))),
Ret_Type => Standard_Boolean,
For_Body => True);
Append_List_To (Stmts, Make_Eq_Case (Typ, Comps));
Append_To (Stmts,
Make_Simple_Return_Statement (Loc,
- Expression => New_Reference_To (Standard_True, Loc)));
+ Expression => New_Occurrence_Of (Standard_True, Loc)));
else
Append_To (Stmts,
Append_To (Result,
Make_Case_Statement (Loc,
Expression =>
- New_Reference_To (Corresponding_Formal (CL), Loc),
+ New_Occurrence_Of (Corresponding_Formal (CL), Loc),
Alternatives => Alt_List));
else
-- abstract.
-- Note also that in the following, we use Make_Identifier for
- -- the component names. Use of New_Reference_To to identify the
+ -- the component names. Use of New_Occurrence_Of to identify the
-- components would be incorrect because the wrong entities for
-- discriminants could be picked up in the private type case.
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Chars (Left_Op)),
- Parameter_Type => New_Reference_To (Tag_Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Chars (Right_Op)),
- Parameter_Type => New_Reference_To (Tag_Typ, Loc))),
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc))),
Ret_Type => Standard_Boolean,
For_Body => True);
Expression =>
Make_Op_Not (Loc,
Make_Function_Call (Loc,
- Name => New_Reference_To (Target, Loc),
+ Name => New_Occurrence_Of (Target, Loc),
Parameter_Associations => New_List (
Make_Identifier (Loc, Chars (Left_Op)),
Make_Identifier (Loc, Chars (Right_Op)))))));
Profile => New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_X),
- Parameter_Type => New_Reference_To (Tag_Typ, Loc))),
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc))),
Ret_Type => Standard_Long_Long_Integer));
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_X),
- Parameter_Type => New_Reference_To (Tag_Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_Y),
- Parameter_Type => New_Reference_To (Tag_Typ, Loc))),
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc))),
Ret_Type => Standard_Boolean);
Append_To (Res, Eq_Spec);
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_X),
Out_Present => True,
- Parameter_Type => New_Reference_To (Tag_Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_Y),
- Parameter_Type => New_Reference_To (Tag_Typ, Loc)))));
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc)))));
end if;
-- Ada 2005: Generate declarations for the following primitive
Defining_Identifier => Make_Defining_Identifier (Loc, Name_V),
In_Present => True,
Out_Present => True,
- Parameter_Type => New_Reference_To (Tag_Typ, Loc)));
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc)));
-- F : Boolean := True
Append_To (Formals,
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_F),
- Parameter_Type => New_Reference_To (Standard_Boolean, Loc),
- Expression => New_Reference_To (Standard_True, Loc)));
+ Parameter_Type => New_Occurrence_Of (Standard_Boolean, Loc),
+ Expression => New_Occurrence_Of (Standard_True, Loc)));
end if;
return
Make_Function_Specification (Loc,
Defining_Unit_Name => Id,
Parameter_Specifications => Profile,
- Result_Definition => New_Reference_To (Ret_Type, Loc));
+ Result_Definition => New_Occurrence_Of (Ret_Type, Loc));
end if;
if Is_Interface (Tag_Typ) then
Profile => New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_X),
- Parameter_Type => New_Reference_To (Tag_Typ, Loc))),
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc))),
Ret_Type => Standard_Long_Long_Integer,
For_Body => True);
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_X),
Out_Present => True,
- Parameter_Type => New_Reference_To (Tag_Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_Y),
- Parameter_Type => New_Reference_To (Tag_Typ, Loc))),
+ Parameter_Type => New_Occurrence_Of (Tag_Typ, Loc))),
For_Body => True);
Set_Handled_Statement_Sequence (Decl,
Make_Object_Declaration (Loc,
Defining_Identifier => Fin_Mas_Id,
Object_Definition =>
- New_Reference_To (RTE (RE_Finalization_Master), Loc));
+ New_Occurrence_Of (RTE (RE_Finalization_Master), Loc));
Insert_Before_And_Analyze (First_Decl, Action);
Action :=
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Set_Base_Pool), Loc),
+ New_Occurrence_Of (RTE (RE_Set_Base_Pool), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Fin_Mas_Id, Loc),
+ New_Occurrence_Of (Fin_Mas_Id, Loc),
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Global_Pool_Object), Loc),
+ New_Occurrence_Of (RTE (RE_Global_Pool_Object), Loc),
Attribute_Name => Name_Unrestricted_Access)));
Insert_Before_And_Analyze (First_Decl, Action);
Action :=
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Set_Is_Heterogeneous), Loc),
+ New_Occurrence_Of (RTE (RE_Set_Is_Heterogeneous), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Fin_Mas_Id, Loc)));
+ New_Occurrence_Of (Fin_Mas_Id, Loc)));
Insert_Before_And_Analyze (First_Decl, Action);
end if;
Rewrite (N,
Unchecked_Convert_To (PtrT,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Displace), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Displace), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Address),
Relocate_Node (N)),
Remove_Side_Effects (Ref);
Obj_Ref := New_Copy_Tree (Ref);
else
- Obj_Ref := New_Reference_To (Ref, Loc);
+ Obj_Ref := New_Occurrence_Of (Ref, Loc);
end if;
-- Step 1: Create the object clean up code
Append_To (Stmts,
Make_Raise_Program_Error (Loc,
- Condition => New_Reference_To (Standard_True, Loc),
+ Condition => New_Occurrence_Of (Standard_True, Loc),
Reason => PE_Accessibility_Check_Failed));
-- Step 2: Create the accessibility comparison
Cond :=
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Get_Access_Level), Loc),
+ New_Occurrence_Of (RTE (RE_Get_Access_Level), Loc),
Parameter_Associations => New_List (Obj_Ref));
end if;
Temp_Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
- Object_Definition => New_Reference_To (PtrT, Loc),
+ Object_Definition => New_Occurrence_Of (PtrT, Loc),
Expression =>
Make_Allocator (Loc,
Expression =>
- New_Reference_To (Etype (Exp), Loc)));
+ New_Occurrence_Of (Etype (Exp), Loc)));
-- Copy the Comes_From_Source flag for the allocator we just
-- built, since logically this allocator is a replacement of
then
Insert_Action (N,
Make_Attach_Call (
- Obj_Ref => New_Reference_To (Temp, Loc),
+ Obj_Ref => New_Occurrence_Of (Temp, Loc),
Ptr_Typ => PtrT));
end if;
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
Constant_Present => True,
- Object_Definition => New_Reference_To (PtrT, Loc),
+ Object_Definition => New_Occurrence_Of (PtrT, Loc),
Expression => Node);
Insert_Action (N, Temp_Decl);
Insert_Action (N,
Make_Attach_Call (
Obj_Ref =>
- New_Reference_To (Temp, Loc),
+ New_Occurrence_Of (Temp, Loc),
Ptr_Typ => PtrT));
end if;
end if;
Constant_Present =>
Is_Access_Constant (Etype (N)),
Subtype_Indication =>
- New_Reference_To (Etype (Exp), Loc)));
+ New_Occurrence_Of (Etype (Exp), Loc)));
Insert_Action (N, New_Decl);
Temp_Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
- Object_Definition => New_Reference_To (Def_Id, Loc),
+ Object_Definition => New_Occurrence_Of (Def_Id, Loc),
Expression =>
Make_Allocator (Loc,
- New_Reference_To (Etype (Exp), Loc)));
+ New_Occurrence_Of (Etype (Exp), Loc)));
-- Copy the Comes_From_Source flag for the allocator we just
-- built, since logically this allocator is a replacement of
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
Constant_Present => True,
- Object_Definition => New_Reference_To (Def_Id, Loc),
+ Object_Definition => New_Occurrence_Of (Def_Id, Loc),
Expression => Node);
Insert_Action (N, Temp_Decl);
New_Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Make_Temporary (Loc, 'P'),
- Object_Definition => New_Reference_To (PtrT, Loc),
+ Object_Definition => New_Occurrence_Of (PtrT, Loc),
Expression =>
Unchecked_Convert_To (PtrT,
- New_Reference_To (Temp, Loc)));
+ New_Occurrence_Of (Temp, Loc)));
Insert_Action (N, New_Decl);
elsif Is_Tagged_Type (T) and then not Is_Class_Wide_Type (T) then
TagT := T;
- TagR := New_Reference_To (Temp, Loc);
+ TagR := New_Occurrence_Of (Temp, Loc);
elsif Is_Private_Type (T)
and then Is_Tagged_Type (Underlying_Type (T))
TagR :=
Unchecked_Convert_To (Underlying_Type (T),
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Temp, Loc)));
+ Prefix => New_Occurrence_Of (Temp, Loc)));
end if;
if Present (TagT) then
declare
Full_T : constant Entity_Id := Underlying_Type (TagT);
+
begin
Tag_Assign :=
Make_Assignment_Statement (Loc,
Make_Selected_Component (Loc,
Prefix => TagR,
Selector_Name =>
- New_Reference_To (First_Tag_Component (Full_T), Loc)),
+ New_Occurrence_Of
+ (First_Tag_Component (Full_T), Loc)),
+
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Elists.Node
(First_Elmt (Access_Disp_Table (Full_T))), Loc)));
end;
(Obj_Ref =>
Unchecked_Convert_To (T,
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Temp, Loc))),
+ Prefix => New_Occurrence_Of (Temp, Loc))),
Typ => T));
end if;
end if;
end if;
- Rewrite (N, New_Reference_To (Temp, Loc));
+ Rewrite (N, New_Occurrence_Of (Temp, Loc));
Analyze_And_Resolve (N, PtrT);
-- Ada 2005 (AI-251): Displace the pointer to reference the record
Temp_Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
- Object_Definition => New_Reference_To (PtrT, Loc),
+ Object_Definition => New_Occurrence_Of (PtrT, Loc),
Expression =>
Make_Allocator (Loc,
- Expression => New_Reference_To (Etype (Exp), Loc)));
+ Expression => New_Occurrence_Of (Etype (Exp), Loc)));
-- Copy the Comes_From_Source flag for the allocator we just built,
-- since logically this allocator is a replacement of the original
then
Insert_Action (N,
Make_Attach_Call
- (Obj_Ref => New_Reference_To (Temp, Loc),
+ (Obj_Ref => New_Occurrence_Of (Temp, Loc),
Ptr_Typ => PtrT));
end if;
- Rewrite (N, New_Reference_To (Temp, Loc));
+ Rewrite (N, New_Occurrence_Of (Temp, Loc));
Analyze_And_Resolve (N, PtrT);
elsif Is_Access_Type (T) and then Can_Never_Be_Null (T) then
Func_Name := Defining_Unit_Name (Specification (Func_Body));
Expr :=
Make_Function_Call (Loc,
- Name => New_Reference_To (Func_Name, Loc),
+ Name => New_Occurrence_Of (Func_Name, Loc),
Parameter_Associations => New_List (Op1, Op2));
Insert_Action (N, Func_Body);
return
Make_Attribute_Reference (Loc,
Attribute_Name => Nam,
- Prefix => New_Reference_To (Arr, Loc),
+ Prefix => New_Occurrence_Of (Arr, Loc),
Expressions => New_List (Make_Integer_Literal (Loc, Num)));
end Arr_Attr;
Bn := An;
end if;
- Append (New_Reference_To (An, Loc), Index_List1);
- Append (New_Reference_To (Bn, Loc), Index_List2);
+ Append (New_Occurrence_Of (An, Loc), Index_List1);
+ Append (New_Occurrence_Of (Bn, Loc), Index_List2);
Stm_List := New_List (
Handle_One_Dimension (N + 1, Next_Index (Index)));
Make_Exit_Statement (Loc,
Condition =>
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (An, Loc),
+ Left_Opnd => New_Occurrence_Of (An, Loc),
Right_Opnd => Arr_Attr (A, Name_Last, N))));
Append_To (Stm_List,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (An, Loc),
+ Name => New_Occurrence_Of (An, Loc),
Expression =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Index_T, Loc),
+ Prefix => New_Occurrence_Of (Index_T, Loc),
Attribute_Name => Name_Succ,
- Expressions => New_List (New_Reference_To (An, Loc)))));
+ Expressions => New_List (
+ New_Occurrence_Of (An, Loc)))));
Append_To (Stm_List,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Bn, Loc),
+ Name => New_Occurrence_Of (Bn, Loc),
Expression =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Index_T, Loc),
+ Prefix => New_Occurrence_Of (Index_T, Loc),
Attribute_Name => Name_Succ,
- Expressions => New_List (New_Reference_To (Bn, Loc)))));
+ Expressions => New_List (
+ New_Occurrence_Of (Bn, Loc)))));
end if;
-- If separate indexes, we need a declare block for An and Bn, and a
Declarations => New_List (
Make_Object_Declaration (Loc,
Defining_Identifier => An,
- Object_Definition => New_Reference_To (Index_T, Loc),
+ Object_Definition => New_Occurrence_Of (Index_T, Loc),
Expression => Arr_Attr (A, Name_First, N)),
Make_Object_Declaration (Loc,
Defining_Identifier => Bn,
- Object_Definition => New_Reference_To (Index_T, Loc),
+ Object_Definition => New_Occurrence_Of (Index_T, Loc),
Expression => Arr_Attr (B, Name_First, N))),
Handled_Statement_Sequence =>
Formals := New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier => A,
- Parameter_Type => New_Reference_To (Ltyp, Loc)),
+ Parameter_Type => New_Occurrence_Of (Ltyp, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => B,
- Parameter_Type => New_Reference_To (Rtyp, Loc)));
+ Parameter_Type => New_Occurrence_Of (Rtyp, Loc)));
Func_Name := Make_Temporary (Loc, 'E');
Make_Function_Specification (Loc,
Defining_Unit_Name => Func_Name,
Parameter_Specifications => Formals,
- Result_Definition => New_Reference_To (Standard_Boolean, Loc)),
+ Result_Definition => New_Occurrence_Of (Standard_Boolean, Loc)),
Declarations => Decls,
return
Make_Function_Call (Loc,
- Name => New_Reference_To (Func_Name, Loc),
+ Name => New_Occurrence_Of (Func_Name, Loc),
Parameter_Associations => Actuals);
end Expand_Array_Equality;
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (Func_Name, Loc),
+ Name => New_Occurrence_Of (Func_Name, Loc),
Parameter_Associations =>
New_List (
L,
Make_Type_Conversion
- (Loc, New_Reference_To (Etype (L), Loc), R))));
+ (Loc, New_Occurrence_Of (Etype (L), Loc), R))));
Analyze_And_Resolve (N, Typ);
end if;
else
return
Make_Function_Call (Loc,
- Name => New_Reference_To (Prim, Loc),
+ Name => New_Occurrence_Of (Prim, Loc),
Parameter_Associations => New_List (Lhs, Rhs));
end if;
end if;
return
Make_Function_Call (Loc,
- Name => New_Reference_To (Eq_Op, Loc),
+ Name => New_Occurrence_Of (Eq_Op, Loc),
Parameter_Associations =>
New_List
(Unchecked_Convert_To (Etype (First_Formal (Eq_Op)), Lhs),
begin
return
Make_Function_Call (Loc,
- Name => New_Reference_To (Eq_Op, Loc),
+ Name => New_Occurrence_Of (Eq_Op, Loc),
Parameter_Associations => New_List (
OK_Convert_To (T, Lhs),
OK_Convert_To (T, Rhs)));
return
Make_Function_Call (Loc,
- Name => New_Reference_To (Eq_Op, Loc),
+ Name => New_Occurrence_Of (Eq_Op, Loc),
Parameter_Associations => New_List (
Lhs,
Rhs,
else
return
Make_Function_Call (Loc,
- Name => New_Reference_To (Eq_Op, Loc),
+ Name => New_Occurrence_Of (Eq_Op, Loc),
Parameter_Associations => New_List (Lhs, Rhs));
end if;
end if;
Opnd_Low_Bound (NN) :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Istyp, Loc),
+ Prefix => New_Occurrence_Of (Istyp, Loc),
Attribute_Name => Name_First);
Set := True;
if Is_Fixed_Length (1) then
Aggr_Length (1) := Make_Integer_Literal (Loc, Fixed_Length (1));
else
- Aggr_Length (1) := New_Reference_To (Var_Length (1), Loc);
+ Aggr_Length (1) := New_Occurrence_Of (Var_Length (1), Loc);
end if;
-- If entry is fixed length and only fixed lengths so far, make
if Is_Fixed_Length (NN) then
Clen := Make_Integer_Literal (Loc, Fixed_Length (NN));
else
- Clen := New_Reference_To (Var_Length (NN), Loc);
+ Clen := New_Occurrence_Of (Var_Length (NN), Loc);
end if;
Append_To (Actions,
Expressions => New_List (
Make_Op_Ne (Loc,
- Left_Opnd => New_Reference_To (Var_Length (J), Loc),
- Right_Opnd => Make_Integer_Literal (Loc, 0)),
+ Left_Opnd =>
+ New_Occurrence_Of (Var_Length (J), Loc),
+ Right_Opnd =>
+ Make_Integer_Literal (Loc, 0)),
New_Copy (Opnd_Low_Bound (J)),
Get_Known_Bound (J + 1)));
Object_Definition => New_Occurrence_Of (Ityp, Loc),
Expression => Get_Known_Bound (1)));
- Low_Bound := New_Reference_To (Ent, Loc);
+ Low_Bound := New_Occurrence_Of (Ent, Loc);
end;
end if;
Insert_Action (Cnode,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RR (NN)), Loc),
+ Name => New_Occurrence_Of (RTE (RR (NN)), Loc),
Parameter_Associations => Opnds));
- Result := New_Reference_To (Ent, Loc);
+ Result := New_Occurrence_Of (Ent, Loc);
goto Done;
end;
end if;
-- Finally we build the result, which is a reference to the array object
- Result := New_Reference_To (Ent, Loc);
+ Result := New_Occurrence_Of (Ent, Loc);
<<Done>>
Rewrite (Cnode, Result);
Low_Bound =>
Make_Attribute_Reference (Loc,
Attribute_Name => Name_First,
- Prefix => New_Reference_To (Rtyp, Loc)),
+ Prefix => New_Occurrence_Of (Rtyp, Loc)),
High_Bound =>
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Last,
- Prefix => New_Reference_To (Rtyp, Loc))));
+ Prefix => New_Occurrence_Of (Rtyp, Loc))));
Analyze_And_Resolve (Rop, Rtyp, Suppress => All_Checks);
end;
end if;
Init_Arg1 :=
Make_Explicit_Dereference (Loc,
Prefix =>
- New_Reference_To (Temp, Loc));
+ New_Occurrence_Of (Temp, Loc));
Set_Assignment_OK (Init_Arg1);
Temp_Type := PtrT;
New_Occurrence_Of (RTE (RE_Library_Task_Level), Loc));
else
Append_To (Args,
- New_Reference_To
+ New_Occurrence_Of
(Master_Id (Base_Type (Root_Type (PtrT))), Loc));
end if;
(Typ, Current_Scope))
then
Typ := Build_Default_Subtype (Typ, N);
- Set_Expression (N, New_Reference_To (Typ, Loc));
+ Set_Expression (N, New_Occurrence_Of (Typ, Loc));
end if;
Discr := First_Elmt (Discriminant_Constraint (Typ));
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
Constant_Present => True,
- Object_Definition => New_Reference_To (Temp_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Temp_Type, Loc),
Expression => Nod);
Set_Assignment_OK (Temp_Decl);
else
Insert_Action (N,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Init, Loc),
+ Name => New_Occurrence_Of (Init, Loc),
Parameter_Associations => Args));
end if;
end if;
end if;
- Rewrite (N, New_Reference_To (Temp, Loc));
+ Rewrite (N, New_Occurrence_Of (Temp, Loc));
Analyze_And_Resolve (N, PtrT);
end if;
end if;
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
All_Present => True,
- Subtype_Indication => New_Reference_To (Typ, Loc))));
+ Subtype_Indication => New_Occurrence_Of (Typ, Loc))));
Ttyp := Pnn;
end if;
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
All_Present => True,
- Subtype_Indication => New_Reference_To (Typ, Loc))));
+ Subtype_Indication => New_Occurrence_Of (Typ, Loc))));
-- Generate:
-- Cnn : Ann;
Condition => Relocate_Node (Cond),
Then_Statements => New_List (
Make_Assignment_Statement (Sloc (Thenx),
- Name => New_Reference_To (Cnn, Sloc (Thenx)),
+ Name => New_Occurrence_Of (Cnn, Sloc (Thenx)),
Expression =>
Make_Attribute_Reference (Loc,
Prefix => Relocate_Node (Thenx),
Else_Statements => New_List (
Make_Assignment_Statement (Sloc (Elsex),
- Name => New_Reference_To (Cnn, Sloc (Elsex)),
+ Name => New_Occurrence_Of (Cnn, Sloc (Elsex)),
Expression =>
Make_Attribute_Reference (Loc,
Prefix => Relocate_Node (Elsex),
Error_Msg_N ("\?c?value is known to be out of range", N);
end if;
- Rewrite (N, New_Reference_To (Standard_False, Loc));
+ Rewrite (N, New_Occurrence_Of (Standard_False, Loc));
Analyze_And_Resolve (N, Restyp);
Set_Is_Static_Expression (N, Static);
goto Leave;
Error_Msg_N ("\?c?value is known to be in range", N);
end if;
- Rewrite (N, New_Reference_To (Standard_True, Loc));
+ Rewrite (N, New_Occurrence_Of (Standard_True, Loc));
Analyze_And_Resolve (N, Restyp);
Set_Is_Static_Expression (N, Static);
goto Leave;
Low_Bound =>
Make_Attribute_Reference (Loc,
Attribute_Name => Name_First,
- Prefix => New_Reference_To (Typ, Loc)),
+ Prefix => New_Occurrence_Of (Typ, Loc)),
High_Bound =>
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Last,
- Prefix => New_Reference_To (Typ, Loc))));
+ Prefix => New_Occurrence_Of (Typ, Loc))));
Analyze_And_Resolve (N, Restyp);
end if;
end if;
if not Is_Constrained (Typ) then
- Rewrite (N, New_Reference_To (Standard_True, Loc));
+ Rewrite (N, New_Occurrence_Of (Standard_True, Loc));
Analyze_And_Resolve (N, Restyp);
-- For the constrained array case, we have to check the subscripts
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (Eq, Loc),
+ Name => New_Occurrence_Of (Eq, Loc),
Parameter_Associations => Params));
end;
end;
else
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (Eq, Loc),
+ Name => New_Occurrence_Of (Eq, Loc),
Parameter_Associations => New_List (L_Exp, R_Exp)));
end if;
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
Constant_Present => True,
- Object_Definition => New_Reference_To (Typ, Loc),
+ Object_Definition => New_Occurrence_Of (Typ, Loc),
Expression =>
Make_Op_Multiply (Loc,
Left_Opnd =>
Expression =>
Make_Op_Multiply (Loc,
- Left_Opnd => New_Reference_To (Temp, Loc),
- Right_Opnd => New_Reference_To (Temp, Loc)));
+ Left_Opnd => New_Occurrence_Of (Temp, Loc),
+ Right_Opnd => New_Occurrence_Of (Temp, Loc)));
end if;
Rewrite (N, Xnode);
Rewrite (N,
Convert_To (Typ,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Exp_Modular), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Exp_Modular), Loc),
Parameter_Associations => New_List (
Convert_To (Standard_Integer, Base),
Make_Integer_Literal (Loc, Modulus (Rtyp)),
Make_Op_And (Loc,
Left_Opnd =>
Make_Function_Call (Loc,
- Name => New_Reference_To (Ent, Loc),
+ Name => New_Occurrence_Of (Ent, Loc),
Parameter_Associations => New_List (
Convert_To (Etype (First_Formal (Ent)), Base),
Exp)),
then
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (Rent), Loc),
+ Name => New_Occurrence_Of (RTE (Rent), Loc),
Parameter_Associations => New_List (Base, Exp)));
-- Otherwise we have to introduce conversions (conversions are also
Rewrite (N,
Convert_To (Typ,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (Rent), Loc),
+ Name => New_Occurrence_Of (RTE (Rent), Loc),
Parameter_Associations => New_List (
Convert_To (Etyp, Base),
Exp))));
A_J :=
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (A, Loc),
- Expressions => New_List (New_Reference_To (J, Loc)));
+ Prefix => New_Occurrence_Of (A, Loc),
+ Expressions => New_List (New_Occurrence_Of (J, Loc)));
B_J :=
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (B, Loc),
- Expressions => New_List (New_Reference_To (J, Loc)));
+ Prefix => New_Occurrence_Of (B, Loc),
+ Expressions => New_List (New_Occurrence_Of (J, Loc)));
Loop_Statement :=
Make_Implicit_Loop_Statement (N,
Parameter_Specifications => New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier => A,
- Parameter_Type => New_Reference_To (Typ, Loc))),
- Result_Definition => New_Reference_To (Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Typ, Loc))),
+ Result_Definition => New_Occurrence_Of (Typ, Loc)),
Declarations => New_List (
Make_Object_Declaration (Loc,
Defining_Identifier => B,
- Object_Definition => New_Reference_To (Arr, Loc))),
+ Object_Definition => New_Occurrence_Of (Arr, Loc))),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (Func_Name, Loc),
+ Name => New_Occurrence_Of (Func_Name, Loc),
Parameter_Associations => New_List (Opnd)));
Analyze_And_Resolve (N, Typ);
begin
R :=
Make_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (Standard_Integer, Loc),
+ Subtype_Mark => New_Occurrence_Of (Standard_Integer, Loc),
Expression => Relocate_Node (Right_Opnd (Operand)));
Opnd := New_Op_Node (Nkind (Operand), Loc);
if Nkind (Operand) in N_Binary_Op then
L :=
Make_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (Standard_Integer, Loc),
+ Subtype_Mark => New_Occurrence_Of (Standard_Integer, Loc),
Expression => Relocate_Node (Left_Opnd (Operand)));
Set_Left_Opnd (Opnd, L);
Left_Opnd =>
Make_Explicit_Dereference (Loc,
Prefix => Duplicate_Subexpr_No_Checks (Operand)),
- Right_Opnd => New_Reference_To (Targ_Typ, Loc)));
+ Right_Opnd => New_Occurrence_Of (Targ_Typ, Loc)));
-- Generate:
-- [Constraint_Error when Operand not in Targ_Typ]
Cond :=
Make_Not_In (Loc,
Left_Opnd => Duplicate_Subexpr_No_Checks (Operand),
- Right_Opnd => New_Reference_To (Targ_Typ, Loc));
+ Right_Opnd => New_Occurrence_Of (Targ_Typ, Loc));
end if;
Insert_Action (N,
-- and then ...
-- and then Lhs.Cmpn = Rhs.Cmpn
- Result := New_Reference_To (Standard_True, Loc);
+ Result := New_Occurrence_Of (Standard_True, Loc);
C := Element_To_Compare (First_Entity (Typ));
while Present (C) loop
declare
Lhs =>
Make_Selected_Component (Loc,
Prefix => New_Lhs,
- Selector_Name => New_Reference_To (C, Loc)),
+ Selector_Name => New_Occurrence_Of (C, Loc)),
Rhs =>
Make_Selected_Component (Loc,
Prefix => New_Rhs,
- Selector_Name => New_Reference_To (C, Loc)),
+ Selector_Name => New_Occurrence_Of (C, Loc)),
Bodies => Bodies);
-- If some (sub)component is an unchecked_union, the whole
Make_Object_Declaration (Loc,
Defining_Identifier => Addr,
Object_Definition =>
- New_Reference_To (RTE (RE_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Address), Loc),
Expression =>
Make_Attribute_Reference (Loc,
Prefix => Duplicate_Subexpr_Move_Checks (N),
Defining_Identifier => Size,
Object_Definition =>
- New_Reference_To (RTE (RE_Storage_Count), Loc),
+ New_Occurrence_Of (RTE (RE_Storage_Count), Loc),
Expression =>
Make_Op_Divide (Loc,
Make_Object_Declaration (Loc,
Defining_Identifier => Alig,
Object_Definition =>
- New_Reference_To (RTE (RE_Storage_Count), Loc),
+ New_Occurrence_Of (RTE (RE_Storage_Count), Loc),
Expression =>
Make_Attribute_Reference (Loc,
Prefix => Deref,
Stmt :=
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Adjust_Controlled_Dereference), Loc),
+ New_Occurrence_Of (RTE (RE_Adjust_Controlled_Dereference), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Addr, Loc),
- New_Reference_To (Size, Loc),
- New_Reference_To (Alig, Loc)));
+ New_Occurrence_Of (Addr, Loc),
+ New_Occurrence_Of (Size, Loc),
+ New_Occurrence_Of (Alig, Loc)));
-- Class-wide types complicate things because we cannot determine
-- statically whether the actual object is truly controlled. We must
Condition =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Needs_Finalization), Loc),
+ New_Occurrence_Of (RTE (RE_Needs_Finalization), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => Deref,
Insert_Action (N,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(Find_Prim_Op (Etype (Pool), Name_Dereference), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Pool, Loc),
- New_Reference_To (Addr, Loc),
- New_Reference_To (Size, Loc),
- New_Reference_To (Alig, Loc))));
+ New_Occurrence_Of (Pool, Loc),
+ New_Occurrence_Of (Addr, Loc),
+ New_Occurrence_Of (Size, Loc),
+ New_Occurrence_Of (Alig, Loc))));
-- Mark the explicit dereference as processed to avoid potential
-- infinite expansion.
Make_Implicit_If_Statement (Nod,
Condition =>
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (J, Loc),
+ Left_Opnd => New_Occurrence_Of (J, Loc),
Right_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Y, Loc),
+ Prefix => New_Occurrence_Of (Y, Loc),
Attribute_Name => Name_Last)),
Then_Statements => New_List (
Else_Statements =>
New_List (
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (J, Loc),
+ Name => New_Occurrence_Of (J, Loc),
Expression =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Index, Loc),
+ Prefix => New_Occurrence_Of (Index, Loc),
Attribute_Name => Name_Succ,
- Expressions => New_List (New_Reference_To (J, Loc))))));
+ Expressions => New_List (New_Occurrence_Of (J, Loc))))));
-- if X (I) = Y (J) then
-- if ... end if;
Make_Op_Eq (Loc,
Left_Opnd =>
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (X, Loc),
- Expressions => New_List (New_Reference_To (I, Loc))),
+ Prefix => New_Occurrence_Of (X, Loc),
+ Expressions => New_List (New_Occurrence_Of (I, Loc))),
Right_Opnd =>
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (Y, Loc),
- Expressions => New_List (New_Reference_To (J, Loc)))),
+ Prefix => New_Occurrence_Of (Y, Loc),
+ Expressions => New_List (New_Occurrence_Of (J, Loc)))),
Then_Statements => New_List (Inner_If),
Make_Op_Gt (Loc,
Left_Opnd =>
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (X, Loc),
- Expressions => New_List (New_Reference_To (I, Loc))),
+ Prefix => New_Occurrence_Of (X, Loc),
+ Expressions => New_List (New_Occurrence_Of (I, Loc))),
Right_Opnd =>
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (Y, Loc),
+ Prefix => New_Occurrence_Of (Y, Loc),
Expressions => New_List (
- New_Reference_To (J, Loc)))))));
+ New_Occurrence_Of (J, Loc)))))));
-- for I in X'range loop
-- if ... end if;
Defining_Identifier => I,
Discrete_Subtype_Definition =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (X, Loc),
+ Prefix => New_Occurrence_Of (X, Loc),
Attribute_Name => Name_Range))),
Statements => New_List (Loop_Body));
Length1 :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (X, Loc),
+ Prefix => New_Occurrence_Of (X, Loc),
Attribute_Name => Name_Length);
Length2 :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Y, Loc),
+ Prefix => New_Occurrence_Of (Y, Loc),
Attribute_Name => Name_Length);
Final_Expr :=
Make_Op_Eq (Loc,
Left_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (X, Loc),
+ Prefix => New_Occurrence_Of (X, Loc),
Attribute_Name => Name_Length),
Right_Opnd =>
Make_Integer_Literal (Loc, 0)),
Then_Statements =>
New_List (
Make_Simple_Return_Statement (Loc,
- Expression => New_Reference_To (Standard_False, Loc))),
+ Expression => New_Occurrence_Of (Standard_False, Loc))),
Elsif_Parts => New_List (
Make_Elsif_Part (Loc,
Make_Op_Eq (Loc,
Left_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Y, Loc),
+ Prefix => New_Occurrence_Of (Y, Loc),
Attribute_Name => Name_Length),
Right_Opnd =>
Make_Integer_Literal (Loc, 0)),
Then_Statements =>
New_List (
Make_Simple_Return_Statement (Loc,
- Expression => New_Reference_To (Standard_True, Loc))))),
+ Expression => New_Occurrence_Of (Standard_True, Loc))))),
Else_Statements => New_List (
Loop_Statement,
Formals := New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier => X,
- Parameter_Type => New_Reference_To (Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => Y,
- Parameter_Type => New_Reference_To (Typ, Loc)));
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)));
-- function Gnnn (...) return boolean is
-- J : index := Y'first;
Make_Function_Specification (Loc,
Defining_Unit_Name => Func_Name,
Parameter_Specifications => Formals,
- Result_Definition => New_Reference_To (Standard_Boolean, Loc)),
+ Result_Definition => New_Occurrence_Of (Standard_Boolean, Loc)),
Declarations => New_List (
Make_Object_Declaration (Loc,
Defining_Identifier => J,
- Object_Definition => New_Reference_To (Index, Loc),
+ Object_Definition => New_Occurrence_Of (Index, Loc),
Expression =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Y, Loc),
+ Prefix => New_Occurrence_Of (Y, Loc),
Attribute_Name => Name_First))),
Handled_Statement_Sequence =>
begin
A_J :=
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (A, Loc),
- Expressions => New_List (New_Reference_To (J, Loc)));
+ Prefix => New_Occurrence_Of (A, Loc),
+ Expressions => New_List (New_Occurrence_Of (J, Loc)));
B_J :=
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (B, Loc),
- Expressions => New_List (New_Reference_To (J, Loc)));
+ Prefix => New_Occurrence_Of (B, Loc),
+ Expressions => New_List (New_Occurrence_Of (J, Loc)));
C_J :=
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (C, Loc),
- Expressions => New_List (New_Reference_To (J, Loc)));
+ Prefix => New_Occurrence_Of (C, Loc),
+ Expressions => New_List (New_Occurrence_Of (J, Loc)));
if Nkind (N) = N_Op_And then
Op :=
Defining_Identifier => J,
Discrete_Subtype_Definition =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (A, Loc),
+ Prefix => New_Occurrence_Of (A, Loc),
Attribute_Name => Name_Range))),
Statements => New_List (
Formals := New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier => A,
- Parameter_Type => New_Reference_To (Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => B,
- Parameter_Type => New_Reference_To (Typ, Loc)));
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)));
Func_Name := Make_Temporary (Loc, 'A');
Set_Is_Inlined (Func_Name);
Make_Function_Specification (Loc,
Defining_Unit_Name => Func_Name,
Parameter_Specifications => Formals,
- Result_Definition => New_Reference_To (Typ, Loc)),
+ Result_Definition => New_Occurrence_Of (Typ, Loc)),
Declarations => New_List (
Make_Object_Declaration (Loc,
Defining_Identifier => C,
- Object_Definition => New_Reference_To (Typ, Loc))),
+ Object_Definition => New_Occurrence_Of (Typ, Loc))),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
Statements => New_List (
Loop_Statement,
Make_Simple_Return_Statement (Loc,
- Expression => New_Reference_To (C, Loc)))));
+ Expression => New_Occurrence_Of (C, Loc)))));
return Func_Body;
end Make_Boolean_Array_Op;
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
All_Present => Ekind (Obj_Typ) = E_General_Access_Type,
- Subtype_Indication => New_Reference_To (Desig_Typ, Loc))));
+ Subtype_Indication => New_Occurrence_Of (Desig_Typ, Loc))));
-- Step 2: Create a temporary which acts as a hook to the transient
-- controlled object. Generate:
Insert_Action (Hook_Context,
Make_Object_Declaration (Loc,
Defining_Identifier => Temp_Id,
- Object_Definition => New_Reference_To (Ptr_Id, Loc)));
+ Object_Definition => New_Occurrence_Of (Ptr_Id, Loc)));
-- Mark the temporary as created for the purposes of exporting the
-- transient controlled object out of the expression_with_action or if
-- points to an existing object.
if Is_Access_Type (Obj_Typ) then
- Expr := Unchecked_Convert_To (Ptr_Id, New_Reference_To (Obj_Id, Loc));
+ Expr :=
+ Unchecked_Convert_To (Ptr_Id, New_Occurrence_Of (Obj_Id, Loc));
else
Expr :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Obj_Id, Loc),
+ Prefix => New_Occurrence_Of (Obj_Id, Loc),
Attribute_Name => Name_Unrestricted_Access);
end if;
Insert_After_And_Analyze (Temp_Ins,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Temp_Id, Loc),
+ Name => New_Occurrence_Of (Temp_Id, Loc),
Expression => Expr));
-- Step 4: Finalize the transient controlled object after the context
Make_Final_Call
(Obj_Ref =>
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Temp_Id, Loc)),
+ Prefix => New_Occurrence_Of (Temp_Id, Loc)),
Typ => Desig_Typ),
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Temp_Id, Loc),
+ Name => New_Occurrence_Of (Temp_Id, Loc),
Expression => Make_Null (Loc)));
if not Finalize_Always then
Make_Implicit_If_Statement (Decl,
Condition =>
Make_Op_Ne (Loc,
- Left_Opnd => New_Reference_To (Temp_Id, Loc),
+ Left_Opnd => New_Occurrence_Of (Temp_Id, Loc),
Right_Opnd => Make_Null (Loc)),
Then_Statements => Fin_Stmts));
end if;
Make_Selected_Component (Loc,
Prefix => Relocate_Node (Left),
Selector_Name =>
- New_Reference_To (First_Tag_Component (Left_Type), Loc));
+ New_Occurrence_Of (First_Tag_Component (Left_Type), Loc));
if Is_Class_Wide_Type (Right_Type) then
(Typ => Left_Type,
Iface => Etype (Right_Type))))
then
- Result := New_Reference_To (Standard_True, Loc);
+ Result := New_Occurrence_Of (Standard_True, Loc);
return;
end if;
Make_Attribute_Reference (Loc,
Prefix => Obj_Tag,
Attribute_Name => Name_Address),
- New_Reference_To (
+ New_Occurrence_Of (
Node (First_Elmt (Access_Disp_Table (Full_R_Typ))),
Loc)));
Build_CW_Membership (Loc,
Obj_Tag_Node => Obj_Tag,
Typ_Tag_Node =>
- New_Reference_To (
+ New_Occurrence_Of (
Node (First_Elmt (Access_Disp_Table (Full_R_Typ))), Loc),
Related_Nod => N,
New_Node => New_Node);
-- No need to check the tag of the object if Right_Typ is abstract
if Is_Abstract_Type (Right_Type) then
- Result := New_Reference_To (Standard_False, Loc);
+ Result := New_Occurrence_Of (Standard_False, Loc);
else
Result :=
Make_Op_Eq (Loc,
Left_Opnd => Obj_Tag,
Right_Opnd =>
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Full_R_Typ))), Loc));
end if;
end if;
Rewrite (N,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Proc, Loc),
+ Name => New_Occurrence_Of (Proc, Loc),
Parameter_Associations => Actuals));
end;
Expressions => New_List (
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(L_Index_Typ, Loc),
Attribute_Name => Name_First))),
Attribute_Name => Name_Address)),
Expressions => New_List (
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(R_Index_Typ, Loc),
Attribute_Name => Name_First))),
Attribute_Name => Name_Address)));
Rewrite (N,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Proc, Loc),
+ Name => New_Occurrence_Of (Proc, Loc),
Parameter_Associations => Actuals));
end;
Defining_Identifier => Lnn (J),
Reverse_Present => Rev,
Discrete_Subtype_Definition =>
- New_Reference_To (L_Index_Type (J), Loc))),
+ New_Occurrence_Of (L_Index_Type (J), Loc))),
Statements => New_List (Assign, Build_Step (J))))));
end loop;
if Number_Entries (Conctyp) = 0 then
RT_Subprg_Name :=
- New_Reference_To (RTE (RE_Set_Ceiling), Loc);
+ New_Occurrence_Of (RTE (RE_Set_Ceiling), Loc);
else
RT_Subprg_Name :=
- New_Reference_To (RTE (RO_PE_Set_Ceiling), Loc);
+ New_Occurrence_Of (RTE (RO_PE_Set_Ceiling), Loc);
end if;
Call :=
Append_To (L,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Op, Loc),
+ Name => New_Occurrence_Of (Op, Loc),
Parameter_Associations => New_List (
Node1 => Left_N,
Node2 => Right_N)));
New_Occurrence_Of (Has_Element_Op, Loc),
Parameter_Associations =>
New_List
- (New_Reference_To (Container, Loc),
- New_Reference_To (Cursor, Loc)))),
+ (New_Occurrence_Of (Container, Loc),
+ New_Occurrence_Of (Cursor, Loc)))),
Statements => Stats,
End_Label => Empty);
Rewrite (N, New_Loop);
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Id,
Subtype_Mark =>
- New_Reference_To (Element_Type, Loc),
+ New_Occurrence_Of (Element_Type, Loc),
Name =>
Make_Indexed_Component (Loc,
Prefix => Relocate_Node (Container_Arg),
Make_Function_Call (Loc,
Name =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Iterator, Loc),
+ Prefix => New_Occurrence_Of (Iterator, Loc),
Selector_Name => Make_Identifier (Loc, Name_Step)),
Parameter_Associations => New_List (
- New_Reference_To (Cursor, Loc)));
+ New_Occurrence_Of (Cursor, Loc)));
Append_To (Stats,
Make_Assignment_Statement (Loc,
New_Occurrence_Of (
Next_Entity (First_Entity (Pack)), Loc),
Parameter_Associations =>
- New_List (New_Reference_To (Cursor, Loc)))),
+ New_List (New_Occurrence_Of (Cursor, Loc)))),
Statements => Stats,
End_Label => Empty);
New_Occurrence_Of (Etype (Cursor), Loc),
Expression =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Iterator, Loc),
+ Prefix => New_Occurrence_Of (Iterator, Loc),
Selector_Name =>
Make_Identifier (Loc, Name_Init)));
Ind_Comp :=
Make_Indexed_Component (Loc,
Prefix => Relocate_Node (Array_Node),
- Expressions => New_List (New_Reference_To (Iterator, Loc)));
+ Expressions => New_List (New_Occurrence_Of (Iterator, Loc)));
Prepend_To (Stats,
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Id,
Subtype_Mark =>
- New_Reference_To (Component_Type (Array_Typ), Loc),
+ New_Occurrence_Of (Component_Type (Array_Typ), Loc),
Name => Ind_Comp));
-- Mark the loop variable as needing debug info, so that expansion
-- the new iterator.
Prepend_To (Expressions (Ind_Comp),
- New_Reference_To (Iterator, Loc));
+ New_Occurrence_Of (Iterator, Loc));
end loop;
end if;
Left_Opnd =>
Make_Integer_Literal (Loc,
Enumeration_Rep (First_Literal (Btype))),
- Right_Opnd => New_Reference_To (New_Id, Loc)));
+ Right_Opnd => New_Occurrence_Of (New_Id, Loc)));
else
-- Use the constructed array Enum_Pos_To_Rep
Expr :=
Make_Indexed_Component (Loc,
Prefix =>
- New_Reference_To (Enum_Pos_To_Rep (Btype), Loc),
+ New_Occurrence_Of (Enum_Pos_To_Rep (Btype), Loc),
Expressions =>
- New_List (New_Reference_To (New_Id, Loc)));
+ New_List (New_Occurrence_Of (New_Id, Loc)));
end if;
-- Build declaration for loop identifier
Make_Object_Declaration (Loc,
Defining_Identifier => Loop_Id,
Constant_Present => True,
- Object_Definition => New_Reference_To (Ltype, Loc),
+ Object_Definition => New_Occurrence_Of (Ltype, Loc),
Expression => Expr));
Rewrite (N,
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To (Standard_Natural, Loc),
+ New_Occurrence_Of (Standard_Natural, Loc),
Constraint =>
Make_Range_Constraint (Loc,
Low_Bound =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Btype, Loc),
+ New_Occurrence_Of (Btype, Loc),
Attribute_Name => Name_Pos,
High_Bound =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Btype, Loc),
+ New_Occurrence_Of (Btype, Loc),
Attribute_Name => Name_Pos,
Append_To (Res,
Make_Object_Declaration (Loc,
Defining_Identifier => Tag_Id,
- Object_Definition => New_Reference_To (RTE (RE_Tag), Loc),
+ Object_Definition => New_Occurrence_Of (RTE (RE_Tag), Loc),
Expression =>
Make_Selected_Component (Loc,
Prefix => Duplicate_Subexpr_No_Checks (L),
Selector_Name =>
- New_Reference_To (First_Tag_Component (T), Loc))));
+ New_Occurrence_Of (First_Tag_Component (T), Loc))));
-- Otherwise Tag_Id is not used
Make_Object_Declaration (Loc,
Defining_Identifier => Prev_Id,
Object_Definition =>
- New_Reference_To (RTE (RE_Root_Controlled_Ptr), Loc),
+ New_Occurrence_Of (RTE (RE_Root_Controlled_Ptr), Loc),
Expression =>
Make_Selected_Component (Loc,
Prefix =>
Make_Object_Declaration (Loc,
Defining_Identifier => Next_Id,
Object_Definition =>
- New_Reference_To (RTE (RE_Root_Controlled_Ptr), Loc),
+ New_Occurrence_Of (RTE (RE_Root_Controlled_Ptr), Loc),
Expression =>
Make_Selected_Component (Loc,
Prefix =>
Make_Selected_Component (Loc,
Prefix => Duplicate_Subexpr_No_Checks (L),
Selector_Name =>
- New_Reference_To (First_Tag_Component (T), Loc)),
- Expression => New_Reference_To (Tag_Id, Loc)));
+ New_Occurrence_Of (First_Tag_Component (T), Loc)),
+ Expression => New_Occurrence_Of (Tag_Id, Loc)));
end if;
-- Restore the Prev and Next fields on .NET/JVM
(RTE (RE_Root_Controlled), New_Copy_Tree (L)),
Selector_Name =>
Make_Identifier (Loc, Name_Prev)),
- Expression => New_Reference_To (Prev_Id, Loc)));
+ Expression => New_Occurrence_Of (Prev_Id, Loc)));
-- Generate:
-- Root_Controlled (L).Next := Next_Id;
Unchecked_Convert_To
(RTE (RE_Root_Controlled), New_Copy_Tree (L)),
Selector_Name => Make_Identifier (Loc, Name_Next)),
- Expression => New_Reference_To (Next_Id, Loc)));
+ Expression => New_Occurrence_Of (Next_Id, Loc)));
end if;
-- Adjust the target after the assignment when controlled (not in the
Actual :=
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Finalization_Master (Ptr_Typ), Loc),
+ New_Occurrence_Of (Finalization_Master (Ptr_Typ), Loc),
Attribute_Name => Name_Unrestricted_Access);
-- Tagged types
-- the actual is an entity and requires an explicit reference.
elsif Nkind (Actual) = N_Defining_Identifier then
- Actual := New_Reference_To (Actual, Loc);
+ Actual := New_Occurrence_Of (Actual, Loc);
end if;
-- Locate the implicit master parameter in the called function
-- For IN parameter, all we do is to replace the actual
if Ekind (Formal) = E_In_Parameter then
- Rewrite (Actual, New_Reference_To (Temp, Loc));
+ Rewrite (Actual, New_Occurrence_Of (Temp, Loc));
Analyze (Actual);
-- Processing for OUT or IN OUT parameter
Expr := New_Occurrence_Of (Temp, Loc);
end if;
- Rewrite (Actual, New_Reference_To (Temp, Loc));
+ Rewrite (Actual, New_Occurrence_Of (Temp, Loc));
Analyze (Actual);
-- If the actual is a conversion of a packed reference, it may
if In_Open_Scopes (Entity (Actual)) then
Rewrite (Actual,
(Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Self), Loc))));
+ Name => New_Occurrence_Of (RTE (RE_Self), Loc))));
Analyze (Actual);
-- A task type cannot otherwise appear as an actual
Rewrite (N,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (Deep_Fin, Loc),
+ New_Occurrence_Of (Deep_Fin, Loc),
Parameter_Associations =>
New_Copy_List_Tree (Parameter_Associations (N))));
Make_Selected_Component (Loc,
Prefix => New_Value (Param),
Selector_Name =>
- New_Reference_To (First_Tag_Component (Typ),
- Loc)),
+ New_Occurrence_Of
+ (First_Tag_Component (Typ), Loc)),
Right_Opnd =>
Make_Selected_Component (Loc,
Unchecked_Convert_To (Typ,
New_Value (Next_Actual (Param))),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Typ), Loc))),
Right_Opnd => Prev_Call);
begin
if No (Exit_Lab) then
Lab_Ent := Make_Temporary (Loc, 'L');
- Lab_Id := New_Reference_To (Lab_Ent, Loc);
+ Lab_Id := New_Occurrence_Of (Lab_Ent, Loc);
Exit_Lab := Make_Label (Loc, Lab_Id);
Lab_Decl :=
Make_Implicit_Label_Declaration (Loc,
Remove (First (Parameter_Associations (Blk_Call_Stmt)));
Prepend_To (Parameter_Associations (Blk_Call_Stmt),
- New_Reference_To (Targ, Loc));
+ New_Occurrence_Of (Targ, Loc));
end;
-- Remove the return statement
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Pool_Id,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Root_Storage_Pool), Loc),
+ New_Occurrence_Of (RTE (RE_Root_Storage_Pool), Loc),
Name =>
Make_Explicit_Dereference (Loc,
Prefix =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Base_Pool), Loc),
+ New_Occurrence_Of (RTE (RE_Base_Pool), Loc),
Parameter_Associations => New_List (
Make_Explicit_Dereference (Loc,
Prefix =>
- New_Reference_To (Fin_Mas_Id, Loc)))))));
+ New_Occurrence_Of (Fin_Mas_Id, Loc)))))));
-- Create an access type which uses the storage pool of the
-- caller's master. This additional type is necessary because
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
Subtype_Indication =>
- New_Reference_To (Desig_Typ, Loc))));
+ New_Occurrence_Of (Desig_Typ, Loc))));
-- Perform minor decoration in order to set the master and the
-- storage pool attributes.
Make_Object_Declaration (Loc,
Defining_Identifier => Local_Id,
Object_Definition =>
- New_Reference_To (Ptr_Typ, Loc)));
+ New_Occurrence_Of (Ptr_Typ, Loc)));
-- Allocate the object, generate:
-- Local_Id := <Alloc_Expr>;
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Local_Id, Loc),
+ Name => New_Occurrence_Of (Local_Id, Loc),
Expression => Alloc_Expr));
-- Generate:
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Temp_Id, Loc),
+ Name => New_Occurrence_Of (Temp_Id, Loc),
Expression =>
Unchecked_Convert_To (Temp_Typ,
- New_Reference_To (Local_Id, Loc))));
+ New_Occurrence_Of (Local_Id, Loc))));
-- Wrap the allocation in a block. This is further conditioned
-- by checking the caller finalization master at runtime. A
Make_If_Statement (Loc,
Condition =>
Make_Op_Ne (Loc,
- Left_Opnd => New_Reference_To (Fin_Mas_Id, Loc),
+ Left_Opnd => New_Occurrence_Of (Fin_Mas_Id, Loc),
Right_Opnd => Make_Null (Loc)),
Then_Statements => New_List (
else
return
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Temp_Id, Loc),
+ Name => New_Occurrence_Of (Temp_Id, Loc),
Expression => Alloc_Expr);
end if;
end Build_Heap_Allocator;
return
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Move_Activation_Chain), Loc),
+ New_Occurrence_Of (RTE (RE_Move_Activation_Chain), Loc),
Parameter_Associations => New_List (
-- Destination chain
- New_Reference_To
+ New_Occurrence_Of
(Build_In_Place_Formal (Par_Func, BIP_Activation_Chain), Loc),
-- New master
- New_Reference_To
+ New_Occurrence_Of
(Build_In_Place_Formal (Par_Func, BIP_Task_Master), Loc)));
end Move_Activation_Chain;
Make_Object_Declaration (Loc,
Defining_Identifier => Flag_Id,
Object_Definition =>
- New_Reference_To (Standard_Boolean, Loc),
- Expression => New_Reference_To (Standard_False, Loc));
+ New_Occurrence_Of (Standard_Boolean, Loc),
+ Expression =>
+ New_Occurrence_Of (Standard_False, Loc));
Prepend_To (Declarations (Func_Bod), Flag_Decl);
Analyze (Flag_Decl);
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Flag_Id, Loc),
- Expression => New_Reference_To (Standard_True, Loc)));
+ Name => New_Occurrence_Of (Flag_Id, Loc),
+ Expression => New_Occurrence_Of (Standard_True, Loc)));
end;
end if;
then
Init_Assignment :=
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Return_Obj_Id, Loc),
+ Name => New_Occurrence_Of (Return_Obj_Id, Loc),
Expression => Relocate_Node (Return_Obj_Expr));
Set_Etype (Name (Init_Assignment), Etype (Return_Obj_Id));
Make_Access_To_Object_Definition (Loc,
All_Present => True,
Subtype_Indication =>
- New_Reference_To (Return_Obj_Typ, Loc)));
+ New_Occurrence_Of (Return_Obj_Typ, Loc)));
Insert_Before (Ret_Obj_Decl, Ptr_Type_Decl);
Make_Object_Declaration (Loc,
Defining_Identifier => Alloc_Obj_Id,
Object_Definition =>
- New_Reference_To (Ref_Type, Loc));
+ New_Occurrence_Of (Ref_Type, Loc));
Insert_Before (Ret_Obj_Decl, Alloc_Obj_Decl);
Expression =>
Make_Qualified_Expression (Loc,
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(Etype (Return_Obj_Expr), Loc),
Expression =>
New_Copy_Tree (Return_Obj_Expr)));
Heap_Allocator :=
Make_Allocator (Loc,
Expression =>
- New_Reference_To
+ New_Occurrence_Of
(Etype (Return_Obj_Expr), Loc));
else
Heap_Allocator :=
Make_Allocator (Loc,
Expression =>
- New_Reference_To (Return_Obj_Typ, Loc));
+ New_Occurrence_Of (Return_Obj_Typ, Loc));
end if;
-- If the object requires default initialization then
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Pool_Id,
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Root_Storage_Pool), Loc),
Name =>
Make_Explicit_Dereference (Loc,
- New_Reference_To
+ New_Occurrence_Of
(Build_In_Place_Formal
(Par_Func, BIP_Storage_Pool), Loc)));
Set_Storage_Pool (Pool_Allocator, Pool_Id);
Condition =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (Obj_Alloc_Formal, Loc),
+ New_Occurrence_Of (Obj_Alloc_Formal, Loc),
Right_Opnd =>
Make_Integer_Literal (Loc,
UI_From_Int (BIP_Allocation_Form'Pos
Then_Statements => New_List (
Make_Assignment_Statement (Loc,
Name =>
- New_Reference_To (Alloc_Obj_Id, Loc),
+ New_Occurrence_Of (Alloc_Obj_Id, Loc),
Expression =>
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
- New_Reference_To (Ref_Type, Loc),
+ New_Occurrence_Of (Ref_Type, Loc),
Expression =>
- New_Reference_To (Object_Access, Loc)))),
+ New_Occurrence_Of (Object_Access, Loc)))),
Elsif_Parts => New_List (
Make_Elsif_Part (Loc,
Condition =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (Obj_Alloc_Formal, Loc),
+ New_Occurrence_Of (Obj_Alloc_Formal, Loc),
Right_Opnd =>
Make_Integer_Literal (Loc,
UI_From_Int (BIP_Allocation_Form'Pos
Then_Statements => New_List (
Make_Assignment_Statement (Loc,
Name =>
- New_Reference_To (Alloc_Obj_Id, Loc),
+ New_Occurrence_Of (Alloc_Obj_Id, Loc),
Expression => SS_Allocator))),
Make_Elsif_Part (Loc,
Condition =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (Obj_Alloc_Formal, Loc),
+ New_Occurrence_Of (Obj_Alloc_Formal, Loc),
Right_Opnd =>
Make_Integer_Literal (Loc,
UI_From_Int (BIP_Allocation_Form'Pos
if Present (Init_Assignment) then
Rewrite (Name (Init_Assignment),
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Alloc_Obj_Id, Loc)));
+ Prefix => New_Occurrence_Of (Alloc_Obj_Id, Loc)));
Set_Etype
(Name (Init_Assignment), Etype (Return_Obj_Id));
Obj_Acc_Deref :=
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Object_Access, Loc));
+ Prefix => New_Occurrence_Of (Object_Access, Loc));
Rewrite (Ret_Obj_Decl,
Make_Object_Renaming_Declaration (Loc,
Insert_Action (Rtn,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (Postcondition_Proc (Spec_Id), Loc)));
+ New_Occurrence_Of
+ (Postcondition_Proc (Spec_Id), Loc)));
end if;
end;
end if;
pragma Assert (Present (Postcondition_Proc (Scope_Id)));
Insert_Action (N,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Postcondition_Proc (Scope_Id), Loc)));
+ Name => New_Occurrence_Of (Postcondition_Proc (Scope_Id), Loc)));
end if;
-- If it is a return from a procedure do no extra steps
Call :=
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Complete_Rendezvous), Loc));
+ Name => New_Occurrence_Of (RTE (RE_Complete_Rendezvous), Loc));
Insert_Before (N, Call);
-- why not insert actions here???
Analyze (Call);
Call :=
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Complete_Entry_Body), Loc),
+ New_Occurrence_Of (RTE (RE_Complete_Entry_Body), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(Find_Protection_Object (Current_Scope), Loc),
Attribute_Name => Name_Unchecked_Access)));
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
Subtype_Indication =>
- New_Reference_To
+ New_Occurrence_Of
(Corresponding_Record_Type (Scop), Loc))));
Insert_Actions (N, Decls);
Make_Allocator (Loc,
Expression =>
Make_Qualified_Expression (Loc,
- Subtype_Mark => New_Reference_To (Etype (Exp), Loc),
+ Subtype_Mark => New_Occurrence_Of (Etype (Exp), Loc),
Expression => Relocate_Node (Exp)));
-- We do not want discriminant checks on the declaration,
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
- Object_Definition => New_Reference_To (Acc_Typ, Loc),
+ Object_Definition => New_Occurrence_Of (Acc_Typ, Loc),
Expression => Alloc_Node)));
Rewrite (Exp,
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Temp, Loc)));
+ Prefix => New_Occurrence_Of (Temp, Loc)));
-- Ada 2005 (AI-251): If the type of the returned object is
-- an interface then add an implicit type conversion to force
Result_Id : constant Entity_Id :=
Make_Temporary (Loc, 'R', ExpR);
Result_Exp : constant Node_Id :=
- New_Reference_To (Result_Id, Loc);
+ New_Occurrence_Of (Result_Id, Loc);
Result_Obj : constant Node_Id :=
Make_Object_Declaration (Loc,
Defining_Identifier => Result_Id,
Object_Definition =>
- New_Reference_To (R_Type, Loc),
+ New_Occurrence_Of (R_Type, Loc),
Constant_Present => True,
Expression => ExpR);
Unchecked_Convert_To (RTE (RE_Tag_Ptr),
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Base_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Base_Address), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Address),
Duplicate_Subexpr (Prefix (Exp)))))));
Append_Enabled_Item
(Item =>
Make_Predicate_Check
- (Typ, New_Reference_To (Formal, Loc)),
+ (Typ, New_Occurrence_Of (Formal, Loc)),
List => Stmts);
end if;
end if;
Make_Parameter_Specification (Loc,
Defining_Identifier => Result,
Parameter_Type =>
- New_Reference_To (Etype (Result), Loc)));
+ New_Occurrence_Of (Etype (Result), Loc)));
end if;
-- Insert _Postconditions before the first source declaration of the
Build_Set_Predefined_Prim_Op_Address (Loc,
Tag_Node =>
- New_Reference_To (Node (Next_Elmt (Iface_DT_Ptr)), Loc),
+ New_Occurrence_Of (Node (Next_Elmt (Iface_DT_Ptr)), Loc),
Position => DT_Position (Prim),
Address_Node =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Thunk_Id, Loc),
+ Prefix => New_Occurrence_Of (Thunk_Id, Loc),
Attribute_Name => Name_Unrestricted_Access))),
Build_Set_Predefined_Prim_Op_Address (Loc,
Tag_Node =>
- New_Reference_To
+ New_Occurrence_Of
(Node (Next_Elmt (Next_Elmt (Next_Elmt (Iface_DT_Ptr)))),
Loc),
Position => DT_Position (Prim),
Address_Node =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Prim, Loc),
+ Prefix => New_Occurrence_Of (Prim, Loc),
Attribute_Name => Name_Unrestricted_Access)))));
end if;
New_Allocator :=
Make_Allocator (Loc,
- Expression => New_Reference_To (Result_Subt, Loc));
+ Expression => New_Occurrence_Of (Result_Subt, Loc));
Set_No_Initialization (New_Allocator);
-- Copy attributes to new allocator. Note that the new allocator
Insert_Action (Allocator,
Make_Object_Declaration (Loc,
Defining_Identifier => Return_Obj_Access,
- Object_Definition => New_Reference_To (Acc_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Acc_Type, Loc),
Expression => Relocate_Node (Allocator)));
-- When the function has a controlling result, an allocation-form
(Func_Call,
Function_Id,
Make_Unchecked_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (Result_Subt, Loc),
+ Subtype_Mark => New_Occurrence_Of (Result_Subt, Loc),
Expression =>
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Return_Obj_Access, Loc))));
+ Prefix => New_Occurrence_Of (Return_Obj_Access, Loc))));
-- When the result subtype is unconstrained, the function itself must
-- perform the allocation of the return object, so we pass parameters
Pool_Actual =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(Associated_Storage_Pool (Acc_Type), Loc),
Attribute_Name => Name_Unrestricted_Access));
Make_Object_Declaration (Loc,
Defining_Identifier => Temp_Id,
Object_Definition =>
- New_Reference_To (Result_Subt, Loc),
+ New_Occurrence_Of (Result_Subt, Loc),
Expression =>
New_Copy_Tree (Function_Call));
Insert_Action (Function_Call, Temp_Decl);
- Rewrite (Function_Call, New_Reference_To (Temp_Id, Loc));
+ Rewrite (Function_Call, New_Occurrence_Of (Temp_Id, Loc));
Analyze (Function_Call);
end;
Make_Object_Declaration (Loc,
Defining_Identifier => Return_Obj_Id,
Aliased_Present => True,
- Object_Definition => New_Reference_To (Result_Subt, Loc));
+ Object_Definition => New_Occurrence_Of (Result_Subt, Loc));
Set_No_Initialization (Return_Obj_Decl);
-- to the caller's return object.
Add_Access_Actual_To_Build_In_Place_Call
- (Func_Call, Function_Id, New_Reference_To (Return_Obj_Id, Loc));
+ (Func_Call, Function_Id, New_Occurrence_Of (Return_Obj_Id, Loc));
-- When the result subtype is unconstrained, the function must allocate
-- the return object in the secondary stack, so appropriate implicit
(Func_Call,
Func_Id,
Make_Unchecked_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (Result_Subt, Loc),
+ Subtype_Mark => New_Occurrence_Of (Result_Subt, Loc),
Expression => Relocate_Node (Lhs)));
-- Create an access type designating the function's result subtype
Make_Access_To_Object_Definition (Loc,
All_Present => True,
Subtype_Indication =>
- New_Reference_To (Result_Subt, Loc)));
+ New_Occurrence_Of (Result_Subt, Loc)));
Insert_After_And_Analyze (Assign, Ptr_Typ_Decl);
-- Finally, create an access object initialized to a reference to the
Obj_Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Obj_Id,
- Object_Definition => New_Reference_To (Ptr_Typ, Loc),
+ Object_Definition => New_Occurrence_Of (Ptr_Typ, Loc),
Expression => New_Expr);
Insert_After_And_Analyze (Ptr_Typ_Decl, Obj_Decl);
RTE_Available (RE_Root_Storage_Pool_Ptr)
then
Pool_Actual :=
- New_Reference_To (Build_In_Place_Formal
+ New_Occurrence_Of (Build_In_Place_Formal
(Enclosing_Func, BIP_Storage_Pool), Loc);
-- The build-in-place pool formal is not built on .NET/JVM
(Func_Call,
Function_Id,
Alloc_Form_Exp =>
- New_Reference_To
+ New_Occurrence_Of
(Build_In_Place_Formal (Enclosing_Func, BIP_Alloc_Form),
Loc),
Pool_Actual => Pool_Actual);
if Needs_BIP_Finalization_Master (Enclosing_Func) then
Fmaster_Actual :=
- New_Reference_To
+ New_Occurrence_Of
(Build_In_Place_Formal
(Enclosing_Func, BIP_Finalization_Master), Loc);
end if;
Caller_Object :=
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(Etype
(Build_In_Place_Formal (Function_Id, BIP_Object_Access)),
Loc),
Expression =>
- New_Reference_To
+ New_Occurrence_Of
(Build_In_Place_Formal (Enclosing_Func, BIP_Object_Access),
Loc));
elsif Is_Constrained (Underlying_Type (Result_Subt)) then
Caller_Object :=
Make_Unchecked_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (Result_Subt, Loc),
- Expression => New_Reference_To (Obj_Def_Id, Loc));
+ Subtype_Mark => New_Occurrence_Of (Result_Subt, Loc),
+ Expression => New_Occurrence_Of (Obj_Def_Id, Loc));
-- When the function has a controlling result, an allocation-form
-- parameter must be passed indicating that the caller is allocating
Add_Task_Actuals_To_Build_In_Place_Call
(Func_Call, Function_Id,
Master_Actual =>
- New_Reference_To (Build_In_Place_Formal
+ New_Occurrence_Of (Build_In_Place_Formal
(Enclosing_Func, BIP_Task_Master), Loc));
else
Make_Access_To_Object_Definition (Loc,
All_Present => True,
Subtype_Indication =>
- New_Reference_To (Etype (Function_Call), Loc)));
+ New_Occurrence_Of (Etype (Function_Call), Loc)));
-- The access type and its accompanying object must be inserted after
-- the object declaration in the constrained case, so that the function
Res_Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Def_Id,
- Object_Definition => New_Reference_To (Ref_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Ref_Type, Loc),
Expression => New_Expr);
Insert_After_And_Analyze (Ptr_Typ_Decl, Res_Decl);
else
Call_Deref :=
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Def_Id, Loc));
+ Prefix => New_Occurrence_Of (Def_Id, Loc));
Loc := Sloc (Object_Decl);
Rewrite (Object_Decl,
New_Allocator :=
Make_Allocator (Loc,
- Expression => New_Reference_To (Result_Subt, Loc));
+ Expression => New_Occurrence_Of (Result_Subt, Loc));
Set_No_Initialization (New_Allocator);
-- Copy attributes to new allocator. Note that the new allocator
Make_Object_Declaration (Loc,
Defining_Identifier => Return_Obj_Access,
Constant_Present => True,
- Object_Definition => New_Reference_To (Acc_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Acc_Type, Loc),
Expression => Relocate_Node (Allocator));
Insert_Action (Allocator, Tmp_Obj);
Build_Initialization_Call (Loc,
Id_Ref =>
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Return_Obj_Access, Loc)),
+ Prefix => New_Occurrence_Of (Return_Obj_Access, Loc)),
Typ => Etype (Function_Id),
Constructor_Ref => Function_Call));
-- the function call itself (which will effectively be an access to the
-- object created by the allocator).
- Rewrite (Allocator, New_Reference_To (Return_Obj_Access, Loc));
+ Rewrite (Allocator, New_Occurrence_Of (Return_Obj_Access, Loc));
-- Ada 2005 (AI-251): If the type of the allocator is an interface then
-- generate an implicit conversion to force displacement of the "this"
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Expunge_Unactivated_Tasks), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Activation_Chain_Entity (N), Loc))));
+ New_Occurrence_Of (Activation_Chain_Entity (N), Loc))));
-- Attempt to cancel an asynchronous entry call whenever the block which
-- contains the abortable part is exited.
Condition =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Enqueued), Loc),
+ New_Occurrence_Of (RTE (RE_Enqueued), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Cancel_Param, Loc))),
+ New_Occurrence_Of (Cancel_Param, Loc))),
Then_Statements => New_List (
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Cancel_Protected_Entry_Call), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Cancel_Param, Loc))))));
+ New_Occurrence_Of (Cancel_Param, Loc))))));
-- Asynchronous delay, generate:
-- Cancel_Async_Delay (Cancel_Param);
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Cancel_Async_Delay), Loc),
+ New_Occurrence_Of (RTE (RE_Cancel_Async_Delay), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Cancel_Param, Loc),
+ New_Occurrence_Of (Cancel_Param, Loc),
Attribute_Name => Name_Unchecked_Access))));
-- Task entry call, generate:
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Cancel_Task_Entry_Call), Loc),
+ New_Occurrence_Of (RTE (RE_Cancel_Task_Entry_Call), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Cancel_Param, Loc))));
+ New_Occurrence_Of (Cancel_Param, Loc))));
end if;
end;
end if;
Name =>
Make_Explicit_Dereference (Data.Loc,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Get_Current_Excep), Data.Loc)));
else
Actuals :=
New_List (
- New_Reference_To (Data.E_Id, Data.Loc),
+ New_Occurrence_Of (Data.E_Id, Data.Loc),
Make_Explicit_Dereference (Data.Loc, Except));
end if;
Make_If_Statement (Data.Loc,
Condition =>
Make_Op_Not (Data.Loc,
- Right_Opnd => New_Reference_To (Data.Raised_Id, Data.Loc)),
+ Right_Opnd => New_Occurrence_Of (Data.Raised_Id, Data.Loc)),
Then_Statements => New_List (
Make_Assignment_Statement (Data.Loc,
- Name => New_Reference_To (Data.Raised_Id, Data.Loc),
- Expression => New_Reference_To (Standard_True, Data.Loc)),
+ Name => New_Occurrence_Of (Data.Raised_Id, Data.Loc),
+ Expression => New_Occurrence_Of (Standard_True, Data.Loc)),
Make_Procedure_Call_Statement (Data.Loc,
Name =>
- New_Reference_To (Proc_To_Call, Data.Loc),
+ New_Occurrence_Of (Proc_To_Call, Data.Loc),
Parameter_Associations => Actuals))));
else
Stmts := New_List (
Make_Assignment_Statement (Data.Loc,
- Name => New_Reference_To (Data.Raised_Id, Data.Loc),
- Expression => New_Reference_To (Standard_True, Data.Loc)));
+ Name => New_Occurrence_Of (Data.Raised_Id, Data.Loc),
+ Expression => New_Occurrence_Of (Standard_True, Data.Loc)));
end if;
-- Generate:
Defining_Identifier => Fin_Mas_Id,
Aliased_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Finalization_Master), Loc)));
+ New_Occurrence_Of (RTE (RE_Finalization_Master), Loc)));
-- Storage pool selection and attribute decoration of the generated
-- master. Since .NET/JVM compilers do not support pools, this step
Append_To (Actions,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Set_Base_Pool), Loc),
+ New_Occurrence_Of (RTE (RE_Set_Base_Pool), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Fin_Mas_Id, Loc),
+ New_Occurrence_Of (Fin_Mas_Id, Loc),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Pool_Id, Loc),
+ Prefix => New_Occurrence_Of (Pool_Id, Loc),
Attribute_Name => Name_Unrestricted_Access))));
end if;
Defining_Identifier => Counter_Typ,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Standard_Natural, Loc),
+ Subtype_Mark => New_Occurrence_Of (Standard_Natural, Loc),
Constraint =>
Make_Range_Constraint (Loc,
Range_Expression =>
Counter_Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Counter_Id,
- Object_Definition => New_Reference_To (Counter_Typ, Loc),
+ Object_Definition => New_Occurrence_Of (Counter_Typ, Loc),
Expression => Make_Integer_Literal (Loc, 0));
-- Set the type of the counter explicitly to prevent errors when
Discrete_Choices => New_List (Make_Others_Choice (Loc)),
Statements => New_List (
Make_Goto_Statement (Loc,
- Name => New_Reference_To (Entity (Label_Id), Loc)))));
+ Name => New_Occurrence_Of (Entity (Label_Id), Loc)))));
-- Generate:
-- <<L0>>
Append_To (Finalizer_Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_SS_Release), Loc),
+ New_Occurrence_Of (RTE (RE_SS_Release), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Mark_Id, Loc))));
+ New_Occurrence_Of (Mark_Id, Loc))));
end if;
-- Protect the statements with abort defer/undefer. This is only when
then
Prepend_To (Finalizer_Stmts,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Defer), Loc)));
+ Name => New_Occurrence_Of (RTE (RE_Abort_Defer), Loc)));
Append_To (Finalizer_Stmts,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Undefer), Loc)));
+ Name => New_Occurrence_Of (RTE (RE_Abort_Undefer), Loc)));
end if;
-- The local exception does not need to be reraised for library-level
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Pool_Id,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Root_Storage_Pool), Loc),
+ New_Occurrence_Of (RTE (RE_Root_Storage_Pool), Loc),
Name =>
Make_Explicit_Dereference (Loc,
Prefix =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Base_Pool), Loc),
+ New_Occurrence_Of (RTE (RE_Base_Pool), Loc),
Parameter_Associations => New_List (
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Fin_Mas_Id, Loc)))))));
+ Prefix =>
+ New_Occurrence_Of (Fin_Mas_Id, Loc)))))));
-- Create an access type which uses the storage pool of the
-- caller's finalization master.
Defining_Identifier => Ptr_Typ,
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
- Subtype_Indication => New_Reference_To (Obj_Typ, Loc))));
+ Subtype_Indication => New_Occurrence_Of (Obj_Typ, Loc))));
-- Perform minor decoration in order to set the master and the
-- storage pool attributes.
Make_Free_Statement (Loc,
Expression =>
Unchecked_Convert_To (Ptr_Typ,
- New_Reference_To (Temp_Id, Loc)));
+ New_Occurrence_Of (Temp_Id, Loc)));
Set_Storage_Pool (Free_Stmt, Pool_Id);
Cond :=
Make_Op_Ne (Loc,
- Left_Opnd => New_Reference_To (Fin_Mas_Id, Loc),
+ Left_Opnd => New_Occurrence_Of (Fin_Mas_Id, Loc),
Right_Opnd => Make_Null (Loc));
-- For constrained or tagged results escalate the condition to
Make_And_Then (Loc,
Left_Opnd =>
Make_Op_Gt (Loc,
- Left_Opnd => New_Reference_To (Alloc, Loc),
+ Left_Opnd => New_Occurrence_Of (Alloc, Loc),
Right_Opnd =>
Make_Integer_Literal (Loc,
UI_From_Int
-- Start of processing for Process_Object_Declaration
begin
- Obj_Ref := New_Reference_To (Obj_Id, Loc);
+ Obj_Ref := New_Occurrence_Of (Obj_Id, Loc);
Obj_Typ := Base_Type (Etype (Obj_Id));
-- Handle access types
Inc_Decl :=
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Counter_Id, Loc),
+ Name => New_Occurrence_Of (Counter_Id, Loc),
Expression => Make_Integer_Literal (Loc, Counter_Val));
-- Insert the counter after all initialization has been done. The
Make_Integer_Literal (Loc, Counter_Val)),
Statements => New_List (
Make_Goto_Statement (Loc,
- Name => New_Reference_To (Entity (Label_Id), Loc)))));
+ Name => New_Occurrence_Of (Entity (Label_Id), Loc)))));
-- Insert the jump destination, generate:
--
Make_If_Statement (Loc,
Condition =>
Make_Op_Ne (Loc,
- Left_Opnd => New_Reference_To (Obj_Id, Loc),
+ Left_Opnd => New_Occurrence_Of (Obj_Id, Loc),
Right_Opnd => Make_Null (Loc)),
Then_Statements => Fin_Stmts));
Condition =>
Make_Op_Not (Loc,
Right_Opnd =>
- New_Reference_To
+ New_Occurrence_Of
(Status_Flag_Or_Transient_Decl (Obj_Id), Loc)),
Then_Statements => Fin_Stmts));
Append_To (Tagged_Type_Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Unregister_Tag), Loc),
+ New_Occurrence_Of (RTE (RE_Unregister_Tag), Loc),
Parameter_Associations => New_List (
- New_Reference_To (DT_Ptr, Loc))));
+ New_Occurrence_Of (DT_Ptr, Loc))));
end Process_Tagged_Type_Declaration;
-- Start of processing for Build_Finalizer
end;
end if;
- Set_At_End_Proc (HSS, New_Reference_To (Fin_Id, Loc));
+ Set_At_End_Proc (HSS, New_Occurrence_Of (Fin_Id, Loc));
Analyze (At_End_Proc (HSS));
Expand_At_End_Handler (HSS, Empty);
then
Data.Abort_Id := Make_Temporary (Loc, 'A');
- A_Expr := New_Reference_To (RTE (RE_Triggered_By_Abort), Loc);
+ A_Expr := New_Occurrence_Of (RTE (RE_Triggered_By_Abort), Loc);
-- Generate:
Make_Object_Declaration (Loc,
Defining_Identifier => Data.Abort_Id,
Constant_Present => True,
- Object_Definition => New_Reference_To (Standard_Boolean, Loc),
+ Object_Definition => New_Occurrence_Of (Standard_Boolean, Loc),
Expression => A_Expr));
else
Make_Object_Declaration (Loc,
Defining_Identifier => Data.E_Id,
Object_Definition =>
- New_Reference_To (RTE (RE_Exception_Occurrence), Loc));
+ New_Occurrence_Of (RTE (RE_Exception_Occurrence), Loc));
Set_No_Initialization (E_Decl);
Append_To (Decls, E_Decl);
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => Data.Raised_Id,
- Object_Definition => New_Reference_To (Standard_Boolean, Loc),
- Expression => New_Reference_To (Standard_False, Loc)));
+ Object_Definition => New_Occurrence_Of (Standard_Boolean, Loc),
+ Expression => New_Occurrence_Of (Standard_False, Loc)));
end Build_Object_Declarations;
---------------------------
Stmt :=
Make_Procedure_Call_Statement (Data.Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Raise_From_Controlled_Operation), Data.Loc),
Parameter_Associations =>
- New_List (New_Reference_To (Data.E_Id, Data.Loc)));
+ New_List (New_Occurrence_Of (Data.E_Id, Data.Loc)));
-- Restricted run-time: exception messages are not supported and hence
-- Raise_From_Controlled_Operation is not supported. Raise Program_Error
-- <or>
-- Raised_Id
- Expr := New_Reference_To (Data.Raised_Id, Data.Loc);
+ Expr := New_Occurrence_Of (Data.Raised_Id, Data.Loc);
if Present (Data.Abort_Id) then
Expr := Make_And_Then (Data.Loc,
Left_Opnd => Expr,
Right_Opnd =>
Make_Op_Not (Data.Loc,
- Right_Opnd => New_Reference_To (Data.Abort_Id, Data.Loc)));
+ Right_Opnd => New_Occurrence_Of (Data.Abort_Id, Data.Loc)));
end if;
-- Generate:
else
Index := Make_Temporary (Loc, 'J');
- Append (New_Reference_To (Index, Loc), Index_List);
+ Append (New_Occurrence_Of (Index, Loc), Index_List);
return New_List (
Make_Implicit_Loop_Statement (N,
return
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Finalize_Protection), Loc),
+ New_Occurrence_Of (RTE (RE_Finalize_Protection), Loc),
Parameter_Associations => New_List (Concurrent_Ref (Ref)));
end if;
end Cleanup_Protected_Object;
return
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Free_Task), Loc),
+ New_Occurrence_Of (RTE (RE_Free_Task), Loc),
Parameter_Associations => New_List (Concurrent_Ref (Ref)));
end if;
end Cleanup_Task;
Make_Object_Declaration (Loc,
Defining_Identifier => Mark,
Object_Definition =>
- New_Reference_To (RTE (RE_Mark_Id), Loc),
+ New_Occurrence_Of (RTE (RE_Mark_Id), Loc),
Expression =>
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_SS_Mark), Loc))));
+ Name => New_Occurrence_Of (RTE (RE_SS_Mark), Loc))));
Set_Uses_Sec_Stack (Scop, False);
end if;
All_Present =>
Ekind (Obj_Typ) = E_General_Access_Type,
Subtype_Indication =>
- New_Reference_To (Desig_Typ, Loc))));
+ New_Occurrence_Of (Desig_Typ, Loc))));
-- Step 2: Create a temporary which acts as a hook to the
-- transient object. Generate:
Make_Object_Declaration (Loc,
Defining_Identifier => Temp_Id,
Object_Definition =>
- New_Reference_To (Ptr_Id, Loc)));
+ New_Occurrence_Of (Ptr_Id, Loc)));
-- Mark the temporary as a transient hook. This signals the
-- machinery in Build_Finalizer to recognize this special
if Is_Access_Type (Obj_Typ) then
Expr :=
- Convert_To (Ptr_Id, New_Reference_To (Obj_Id, Loc));
+ Convert_To (Ptr_Id, New_Occurrence_Of (Obj_Id, Loc));
else
Expr :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Obj_Id, Loc),
+ Prefix => New_Occurrence_Of (Obj_Id, Loc),
Attribute_Name => Name_Unrestricted_Access);
end if;
Insert_After_And_Analyze (Temp_Ins,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Temp_Id, Loc),
+ Name => New_Occurrence_Of (Temp_Id, Loc),
Expression => Expr));
end if;
if Must_Hook then
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Temp_Id, Loc),
+ Name => New_Occurrence_Of (Temp_Id, Loc),
Expression => Make_Null (Loc)));
end if;
-- Generate:
-- [Deep_]Finalize (Obj_Ref);
- Obj_Ref := New_Reference_To (Obj_Id, Loc);
+ Obj_Ref := New_Occurrence_Of (Obj_Id, Loc);
if Is_Access_Type (Obj_Typ) then
Obj_Ref := Make_Explicit_Dereference (Loc, Obj_Ref);
return
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Attach), Loc),
+ New_Occurrence_Of (RTE (RE_Attach), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Finalization_Master (Ptr_Typ), Loc),
+ New_Occurrence_Of (Finalization_Master (Ptr_Typ), Loc),
Unchecked_Convert_To (RTE (RE_Root_Controlled_Ptr), Obj_Ref)));
end Make_Attach_Call;
return
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Detach), Loc),
+ New_Occurrence_Of (RTE (RE_Detach), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Root_Controlled_Ptr), Obj_Ref)));
end Make_Detach_Call;
-- the corresponding flag a False value.
if For_Parent then
- Append_To (Params, New_Reference_To (Standard_False, Loc));
+ Append_To (Params, New_Occurrence_Of (Standard_False, Loc));
end if;
return
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Proc_Id, Loc),
+ Name => New_Occurrence_Of (Proc_Id, Loc),
Parameter_Associations => Params);
end Make_Call;
return
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Counter_Id, Loc),
+ Name => New_Occurrence_Of (Counter_Id, Loc),
Expression =>
Make_Op_Subtract (Loc,
Left_Opnd => Expr,
- Right_Opnd => New_Reference_To (Counter_Id, Loc)));
+ Right_Opnd => New_Occurrence_Of (Counter_Id, Loc)));
end Build_Counter_Assignment;
-----------------------------
Make_If_Statement (Loc,
Condition =>
Make_Op_Gt (Loc,
- Left_Opnd => New_Reference_To (Counter_Id, Loc),
+ Left_Opnd => New_Occurrence_Of (Counter_Id, Loc),
Right_Opnd => Make_Integer_Literal (Loc, 0)),
Then_Statements => New_List (
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Counter_Id, Loc),
+ Name => New_Occurrence_Of (Counter_Id, Loc),
Expression =>
Make_Op_Subtract (Loc,
- Left_Opnd => New_Reference_To (Counter_Id, Loc),
+ Left_Opnd => New_Occurrence_Of (Counter_Id, Loc),
Right_Opnd => Make_Integer_Literal (Loc, 1)))),
Else_Statements => New_List (Fin_Stmt));
Append_To (Statements (Handled_Statement_Sequence (Init_Loop)),
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Counter_Id, Loc),
+ Name => New_Occurrence_Of (Counter_Id, Loc),
Expression =>
Make_Op_Add (Loc,
- Left_Opnd => New_Reference_To (Counter_Id, Loc),
+ Left_Opnd => New_Occurrence_Of (Counter_Id, Loc),
Right_Opnd => Make_Integer_Literal (Loc, 1))));
-- Generate all initialization loops starting from the innermost
Make_Object_Declaration (Loc,
Defining_Identifier => Counter_Id,
Object_Definition =>
- New_Reference_To (Standard_Integer, Loc),
+ New_Occurrence_Of (Standard_Integer, Loc),
Expression => Make_Integer_Literal (Loc, 0))),
Handled_Statement_Sequence =>
begin
Id := First (L);
while Present (Id) loop
- Append_To (Refs, New_Reference_To (Id, Loc));
+ Append_To (Refs, New_Occurrence_Of (Id, Loc));
Next (Id);
end loop;
Formals := New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_V),
- Parameter_Type => New_Reference_To (RTE (RE_Address), Loc)));
+ Parameter_Type =>
+ New_Occurrence_Of (RTE (RE_Address), Loc)));
-- Default case
Defining_Identifier => Make_Defining_Identifier (Loc, Name_V),
In_Present => True,
Out_Present => True,
- Parameter_Type => New_Reference_To (Typ, Loc)));
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)));
-- F : Boolean := True
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_F),
Parameter_Type =>
- New_Reference_To (Standard_Boolean, Loc),
+ New_Occurrence_Of (Standard_Boolean, Loc),
Expression =>
- New_Reference_To (Standard_True, Loc)));
+ New_Occurrence_Of (Standard_True, Loc)));
end if;
end if;
if Present (Proc) then
Adj_Stmt :=
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Proc, Loc),
+ Name => New_Occurrence_Of (Proc, Loc),
Parameter_Associations => New_List (
Make_Identifier (Loc, Name_V)));
Statements => New_List (
Make_Goto_Statement (Loc,
Name =>
- New_Reference_To (Entity (Label_Id), Loc)))));
+ New_Occurrence_Of (Entity (Label_Id), Loc)))));
-- Generate:
-- <<LN>>
Statements => New_List (
Make_Goto_Statement (Loc,
- Name => New_Reference_To (Entity (Label_Id), Loc)))));
+ Name => New_Occurrence_Of (Entity (Label_Id), Loc)))));
Append_To (Stmts, Label); -- statement
if Present (Proc) then
Fin_Stmt :=
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Proc, Loc),
+ Name => New_Occurrence_Of (Proc, Loc),
Parameter_Associations => New_List (
Make_Identifier (Loc, Name_V)));
return New_List (
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(Find_Prim_Op (Typ, Name_Of (Prim)), Loc),
Parameter_Associations => New_List (
Make_Identifier (Loc, Name_V))));
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_V),
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)))),
+ New_Occurrence_Of (RTE (RE_Address), Loc)))),
Declarations => No_List,
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
All_Present => True,
- Subtype_Indication => New_Reference_To (Desg_Typ, Loc))),
+ Subtype_Indication => New_Occurrence_Of (Desg_Typ, Loc))),
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (Ptr_Typ, Loc),
+ Name => New_Occurrence_Of (Ptr_Typ, Loc),
Chars => Name_Storage_Size,
Expression => Make_Integer_Literal (Loc, 0)));
Append_To (Decls,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (Ptr_Typ, Loc),
+ Name => New_Occurrence_Of (Ptr_Typ, Loc),
Chars => Name_Size,
Expression =>
Make_Integer_Literal (Loc, System_Address_Size)));
Defining_Identifier => Dope_Id,
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Storage_Offset), Loc),
+ New_Occurrence_Of (RTE (RE_Storage_Offset), Loc),
Expression =>
Make_Op_Divide (Loc,
Left_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Desg_Typ, Loc),
+ Prefix => New_Occurrence_Of (Desg_Typ, Loc),
Attribute_Name => Name_Descriptor_Size),
Right_Opnd =>
Make_Integer_Literal (Loc, System_Storage_Unit))));
Obj_Expr :=
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Add_Offset_To_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Add_Offset_To_Address), Loc),
Parameter_Associations => New_List (
Obj_Expr,
- New_Reference_To (Dope_Id, Loc)));
+ New_Occurrence_Of (Dope_Id, Loc)));
end;
end if;
Raise_Node :=
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Raise_From_Controlled_Operation), Loc),
Parameter_Associations => New_List (
- New_Reference_To (E_Occ, Loc)));
+ New_Occurrence_Of (E_Occ, Loc)));
-- Restricted run-time: exception messages are not supported
return
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (Proc, Loc),
+ New_Occurrence_Of (Proc, Loc),
Parameter_Associations => New_List (Ref));
end Make_Init_Call;
Defining_Identifier => Make_Defining_Identifier (Loc, Name_V),
In_Present => True,
Out_Present => True,
- Parameter_Type => New_Reference_To (Typ, Loc)),
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)),
-- F : Boolean := True
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_F),
- Parameter_Type => New_Reference_To (Standard_Boolean, Loc),
- Expression => New_Reference_To (Standard_True, Loc)));
+ Parameter_Type => New_Occurrence_Of (Standard_Boolean, Loc),
+ Expression => New_Occurrence_Of (Standard_True, Loc)));
-- Add the necessary number of counters to represent the initialization
-- state of an object.
return
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Set_Finalize_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Set_Finalize_Address), Loc),
Parameter_Associations => New_List (
Fin_Mas_Ref,
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (TSS (Utyp, TSS_Finalize_Address), Loc),
+ New_Occurrence_Of (TSS (Utyp, TSS_Finalize_Address), Loc),
Attribute_Name => Name_Unrestricted_Access)));
end Make_Set_Finalize_Address_Call;
Block :=
Make_Block_Statement (Loc,
- Identifier => New_Reference_To (Current_Scope, Loc),
+ Identifier => New_Occurrence_Of (Current_Scope, Loc),
Declarations => Decls,
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc, Statements => Instrs),
Insert_Actions (N, New_List (
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
- Object_Definition => New_Reference_To (Typ, Loc)),
+ Object_Definition => New_Occurrence_Of (Typ, Loc)),
Make_Transient_Block (Loc,
Action =>
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Temp, Loc),
+ Name => New_Occurrence_Of (Temp, Loc),
Expression => Expr),
Par => Parent (N))));
- Rewrite (N, New_Reference_To (Temp, Loc));
+ Rewrite (N, New_Occurrence_Of (Temp, Loc));
Analyze_And_Resolve (N, Typ);
end Wrap_Transient_Expression;
Actual_Family_Offset (
Make_Attribute_Reference (Sloc,
Attribute_Name => Name_Pos,
- Prefix => New_Reference_To (Base_Type (S), Sloc),
+ Prefix => New_Occurrence_Of (Base_Type (S), Sloc),
Expressions => New_List (Relocate_Node (Index))),
Type_Low_Bound (S)));
else
Prefix =>
Unchecked_Convert_To (Entry_Parameters_Type (Ent),
Make_Identifier (Loc, Chars (Ptr))),
- Selector_Name => New_Reference_To (Comp, Loc));
+ Selector_Name => New_Occurrence_Of (Comp, Loc));
Decl :=
Build_Renamed_Formal_Declaration
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uObject),
Object_Definition =>
- New_Reference_To (Obj_Ptr, Loc),
+ New_Occurrence_Of (Obj_Ptr, Loc),
Expression =>
Unchecked_Convert_To (Obj_Ptr, Make_Identifier (Loc, Name_uO)));
Set_Debug_Info_Needed (Defining_Identifier (Decl));
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
Subtype_Indication =>
- New_Reference_To (Rec_Typ, Loc)));
+ New_Occurrence_Of (Rec_Typ, Loc)));
Set_Debug_Info_Needed (Defining_Identifier (Decl));
Prepend_To (Decls, Decl);
end Add_Object_Pointer;
Statements => New_List (
Make_Procedure_Call_Statement (Sloc (Stats),
- Name => New_Reference_To (
+ Name => New_Occurrence_Of (
RTE (RE_Exceptional_Complete_Rendezvous), Sloc (Stats)),
Parameter_Associations => New_List (
Make_Function_Call (Sloc (Stats),
- Name => New_Reference_To (
+ Name => New_Occurrence_Of (
RTE (RE_Get_GNAT_Exception), Sloc (Stats)))))))));
Set_Parent (New_S, Astat); -- temp parent for Analyze call
Defining_Identifier => Chain,
Aliased_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Activation_Chain), Loc));
+ New_Occurrence_Of (RTE (RE_Activation_Chain), Loc));
Prepend_To (Decls, Decl);
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uO),
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)),
+ New_Occurrence_Of (RTE (RE_Address), Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uE),
Parameter_Type =>
- New_Reference_To (RTE (RE_Protected_Entry_Index), Loc))),
+ New_Occurrence_Of (RTE (RE_Protected_Entry_Index), Loc))),
Result_Definition =>
- New_Reference_To (Standard_Boolean, Loc));
+ New_Occurrence_Of (Standard_Boolean, Loc));
end Build_Barrier_Function_Specification;
--------------------------
begin
return
Make_Function_Call (Loc,
- Name => New_Reference_To (E, Loc),
+ Name => New_Occurrence_Of (E, Loc),
Parameter_Associations => New_List (Concurrent_Ref (N)));
end Build_Call_With_Task;
Make_Defining_Identifier (Loc, Name_uMaster),
Constant_Present => True,
Object_Definition =>
- New_Reference_To (Standard_Integer, Loc),
+ New_Occurrence_Of (Standard_Integer, Loc),
Expression =>
Make_Explicit_Dereference (Loc,
- New_Reference_To (RTE (RE_Current_Master), Loc)));
+ New_Occurrence_Of (RTE (RE_Current_Master), Loc)));
Insert_Action (Related_Node, Master_Decl);
Analyze (Master_Decl);
Ren_Decl :=
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Master_Id,
- Subtype_Mark => New_Reference_To (Standard_Integer, Loc),
+ Subtype_Mark => New_Occurrence_Of (Standard_Integer, Loc),
Name => Name_Id);
Insert_Action (Related_Node, Ren_Decl);
N : Node_Id) return Node_Id
is
Loc : constant Source_Ptr := Sloc (N);
+
begin
return
Make_Op_Or (Loc,
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (K, Loc),
- Right_Opnd => New_Reference_To (RTE (RE_TK_Limited_Tagged), Loc)),
+ Left_Opnd =>
+ New_Occurrence_Of (K, Loc),
+ Right_Opnd =>
+ New_Occurrence_Of (RTE (RE_TK_Limited_Tagged), Loc)),
+
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (K, Loc),
- Right_Opnd => New_Reference_To (RTE (RE_TK_Tagged), Loc)));
+ Left_Opnd =>
+ New_Occurrence_Of (K, Loc),
+ Right_Opnd =>
+ New_Occurrence_Of (RTE (RE_TK_Tagged), Loc)));
end Build_Dispatching_Tag_Check;
----------------------------------
Make_Object_Declaration (Loc,
Defining_Identifier => Index,
Object_Definition =>
- New_Reference_To (RTE (RE_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Entry_Index), Loc),
Expression => Make_Integer_Literal (Loc, 1)));
-- Step 2: Generate the declaration of an array to house all
Defining_Identifier => Size,
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Entry_Index), Loc),
Expression =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (Count), Loc),
+ New_Occurrence_Of (RTE (Count), Loc),
Parameter_Associations =>
New_List (Object_Reference))));
Defining_Identifier => Data,
Aliased_Present => True,
Object_Definition =>
- New_Reference_To (RTE (Data_Typ), Loc),
+ New_Occurrence_Of (RTE (Data_Typ), Loc),
Expression =>
Make_Aggregate (Loc,
Component_Associations => New_List (
Make_Component_Association (Loc,
Choices => New_List (
Make_Range (Loc,
- Low_Bound => Make_Integer_Literal (Loc, 1),
- High_Bound => New_Reference_To (Size, Loc))),
+ Low_Bound =>
+ Make_Integer_Literal (Loc, 1),
+ High_Bound =>
+ New_Occurrence_Of (Size, Loc))),
Expression => Make_Null (Loc))))));
end;
end if;
begin
return
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Index, Loc),
+ Name => New_Occurrence_Of (Index, Loc),
Expression =>
Make_Op_Add (Loc,
- Left_Opnd => New_Reference_To (Index, Loc),
+ Left_Opnd => New_Occurrence_Of (Index, Loc),
Right_Opnd => Make_Integer_Literal (Loc, 1)));
end Increment_Index;
Defining_Identifier => Def_Id,
Aliased_Present => True,
Constant_Present => True,
- Object_Definition => New_Reference_To (Standard_String, Loc),
+ Object_Definition =>
+ New_Occurrence_Of (Standard_String, Loc),
Expression =>
Make_String_Literal (Loc, String_From_Name_Buffer));
end Name_Declaration;
Make_Assignment_Statement (Loc,
Name =>
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (Data, Loc),
- Expressions => New_List (New_Reference_To (Index, Loc))),
+ Prefix => New_Occurrence_Of (Data, Loc),
+ Expressions => New_List (New_Occurrence_Of (Index, Loc))),
Expression =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Def_Id, Loc),
+ Prefix => New_Occurrence_Of (Def_Id, Loc),
Attribute_Name => Name_Unchecked_Access));
end Set_Entry_Name;
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (Proc), Loc),
+ Name => New_Occurrence_Of (RTE (Proc), Loc),
Parameter_Associations => New_List (
Object_Reference,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Data, Loc),
+ Prefix => New_Occurrence_Of (Data, Loc),
Attribute_Name => Name_Unchecked_Access))));
end if;
end Build_Entry_Names;
All_Present => True,
Constant_Present => Ekind (Formal) = E_In_Parameter,
Subtype_Indication =>
- New_Reference_To (Etype (Actual), Loc))));
+ New_Occurrence_Of (Etype (Actual), Loc))));
-- Generate:
-- Param : Ann;
Aliased_Present =>
False,
Subtype_Indication =>
- New_Reference_To (Comp_Nam, Loc))));
+ New_Occurrence_Of (Comp_Nam, Loc))));
Has_Comp := True;
end if;
Decl :=
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => New_F,
- Subtype_Mark => New_Reference_To (Etype (Comp), Loc),
+ Subtype_Mark => New_Occurrence_Of (Etype (Comp), Loc),
Name => Renamed_Formal);
else
Decl :=
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => New_F,
- Subtype_Mark => New_Reference_To (Etype (Formal), Loc),
+ Subtype_Mark => New_Occurrence_Of (Etype (Formal), Loc),
Name =>
Make_Explicit_Dereference (Loc, Renamed_Formal));
end if;
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Chars (D)),
- Subtype_Mark => New_Reference_To (Etype (D), Loc),
+ Subtype_Mark => New_Occurrence_Of (Etype (D), Loc),
Name =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Synch_Id, Loc),
+ Prefix => New_Occurrence_Of (Synch_Id, Loc),
Selector_Name => Make_Identifier (Loc, Chars (D))));
Prepend (Decl, Decls);
Next_Discriminant (D);
Chars => Chars (Defining_Identifier (First_Form))));
end if;
- Nam := New_Reference_To (Subp_Id, Loc);
+ Nam := New_Occurrence_Of (Subp_Id, Loc);
else
-- An access-to-variable object parameter requires an explicit
-- dereference in the unchecked conversion. This case occurs
Prefix =>
Unchecked_Convert_To
(Corresponding_Concurrent_Type (Obj_Typ), Conv_Id),
- Selector_Name => New_Reference_To (Subp_Id, Loc));
+ Selector_Name => New_Occurrence_Of (Subp_Id, Loc));
end if;
-- Create the subprogram body. For a function, the call to the
Param_Type := Copy_Separate_Tree (Parameter_Type (Formal));
else
Param_Type :=
- New_Reference_To (Etype (Parameter_Type (Formal)), Loc);
+ New_Occurrence_Of (Etype (Parameter_Type (Formal)), Loc);
end if;
Append_To (New_Formals,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_uO),
In_Present => True,
Out_Present => False,
- Parameter_Type => New_Reference_To (Obj_Typ, Loc));
+ Parameter_Type => New_Occurrence_Of (Obj_Typ, Loc));
-- For entries and procedures of protected types the mode of
-- the controlling argument must be in-out.
Chars => Name_uO),
In_Present => True,
Out_Present => (Ekind (Subp_Id) /= E_Function),
- Parameter_Type => New_Reference_To (Obj_Typ, Loc));
+ Parameter_Type => New_Occurrence_Of (Obj_Typ, Loc));
end if;
end if;
Obj_Param_Typ :=
Make_Access_Definition (Loc,
Subtype_Mark =>
- New_Reference_To (Obj_Typ, Loc));
+ New_Occurrence_Of (Obj_Typ, Loc));
Set_Null_Exclusion_Present (Obj_Param_Typ,
Null_Exclusion_Present (Parameter_Type (First_Param)));
else
- Obj_Param_Typ := New_Reference_To (Obj_Typ, Loc);
+ Obj_Param_Typ := New_Occurrence_Of (Obj_Typ, Loc);
end if;
Obj_Param :=
Make_Defining_Identifier (Loc, Name_uO),
In_Present => In_Present (Parent (First_Entity (Subp_Id))),
Out_Present => Ekind (Subp_Id) /= E_Function,
- Parameter_Type => New_Reference_To (Obj_Typ, Loc));
+ Parameter_Type => New_Occurrence_Of (Obj_Typ, Loc));
Prepend_To (New_Formals, Obj_Param);
end if;
Make_Parameter_Specification (Loc,
Defining_Identifier => Parm1,
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)),
+ New_Occurrence_Of (RTE (RE_Address), Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => Parm2,
Parameter_Type =>
- New_Reference_To (RTE (RE_Protected_Entry_Index), Loc))),
+ New_Occurrence_Of (RTE (RE_Protected_Entry_Index), Loc))),
Result_Definition => New_Occurrence_Of (
RTE (RE_Protected_Entry_Index), Loc));
Condition =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (Try_Write, Loc),
+ New_Occurrence_Of (Try_Write, Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => Relocate_Node (Comp_Sel_Nam),
Attribute_Name => Name_Address),
Unchecked_Convert_To (Unsigned,
- New_Reference_To (Expected_Comp, Loc)),
+ New_Occurrence_Of (Expected_Comp, Loc)),
Unchecked_Convert_To (Unsigned,
- New_Reference_To (Desired_Comp, Loc)))),
+ New_Occurrence_Of (Desired_Comp, Loc)))),
Then_Statements => New_List (Relocate_Node (Stmt)),
Else_Statements => New_List (
Make_Goto_Statement (Loc,
Name =>
- New_Reference_To (Entity (Label_Id), Loc)))));
+ New_Occurrence_Of (Entity (Label_Id), Loc)))));
end Wrap_Statement;
-- Start of processing for Process_Node
Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Expected_Comp,
- Object_Definition => New_Reference_To (Comp_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Comp_Type, Loc),
Constant_Present => True,
Expression =>
Unchecked_Convert_To (Comp_Type,
Make_Function_Call (Loc,
- Name => New_Reference_To (Read, Loc),
+ Name => New_Occurrence_Of (Read, Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => Relocate_Node (Comp_Sel_Nam),
Insert_Before (Comp_Decl,
Make_Object_Declaration (Loc,
Defining_Identifier => Desired_Comp,
- Object_Definition => New_Reference_To (Comp_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Comp_Type, Loc),
Expression =>
- New_Reference_To (Expected_Comp, Loc)));
+ New_Occurrence_Of (Expected_Comp, Loc)));
-- Protected function
Subtype_Mark =>
New_Occurrence_Of (Comp_Type, Loc),
Name =>
- New_Reference_To (Desired_Comp, Loc)));
+ New_Occurrence_Of (Desired_Comp, Loc)));
-- Wrap any return or raise statements in Stmts in same the manner
-- described in Process_Stmts.
Condition =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (Try_Write, Loc),
+ New_Occurrence_Of (Try_Write, Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => Relocate_Node (Comp_Sel_Nam),
Attribute_Name => Name_Address),
Unchecked_Convert_To (Unsigned,
- New_Reference_To (Expected_Comp, Loc)),
+ New_Occurrence_Of (Expected_Comp, Loc)),
Unchecked_Convert_To (Unsigned,
- New_Reference_To (Desired_Comp, Loc)))));
+ New_Occurrence_Of (Desired_Comp, Loc)))));
-- Small optimization: transform the default return statement
-- of a procedure into the atomic exit statement.
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uMaster),
Constant_Present => True,
- Object_Definition => New_Reference_To (RTE (RE_Master_Id), Loc),
+ Object_Definition => New_Occurrence_Of (RTE (RE_Master_Id), Loc),
Expression =>
Make_Explicit_Dereference (Loc,
- New_Reference_To (RTE (RE_Current_Master), Loc)));
+ New_Occurrence_Of (RTE (RE_Current_Master), Loc)));
-- The master is inserted at the start of the declarative list of the
-- context.
Master_Decl :=
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Master_Id,
- Subtype_Mark => New_Reference_To (RTE (RE_Master_Id), Loc),
+ Subtype_Mark => New_Occurrence_Of (RTE (RE_Master_Id), Loc),
Name => Make_Identifier (Loc, Name_uMaster));
Insert_Action (Context, Master_Decl);
Append_To (Op_Stats,
Make_Procedure_Call_Statement (End_Loc,
Name =>
- New_Reference_To (RTE (RE_Complete_Entry_Body), Loc),
+ New_Occurrence_Of (RTE (RE_Complete_Entry_Body), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (End_Loc,
Prefix =>
case Corresponding_Runtime_Package (Pid) is
when System_Tasking_Protected_Objects_Entries =>
Complete :=
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Exceptional_Complete_Entry_Body), Loc);
when System_Tasking_Protected_Objects_Single_Entry =>
Complete :=
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Exceptional_Complete_Single_Entry_Body), Loc);
when others =>
Attribute_Name => Name_Unchecked_Access),
Make_Function_Call (Han_Loc,
- Name => New_Reference_To (
+ Name => New_Occurrence_Of (
RTE (RE_Get_GNAT_Exception), Loc)))))))));
end if;
end Build_Protected_Entry;
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uO),
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)),
+ New_Occurrence_Of (RTE (RE_Address), Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier => P,
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)),
+ New_Occurrence_Of (RTE (RE_Address), Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uE),
Parameter_Type =>
- New_Reference_To (RTE (RE_Protected_Entry_Index), Loc))));
+ New_Occurrence_Of (RTE (RE_Protected_Entry_Index), Loc))));
end Build_Protected_Entry_Specification;
--------------------------
Make_Defining_Identifier (Sloc (Formal), Chars (Formal)),
In_Present => In_Present (Parent (Formal)),
Out_Present => Out_Present (Parent (Formal)),
- Parameter_Type => New_Reference_To (Etype (Formal), Loc));
+ Parameter_Type => New_Occurrence_Of (Etype (Formal), Loc));
if Unprotected then
Set_Protected_Formal (Formal, Defining_Identifier (New_Param));
(Etype (Ident) = Standard_Void_Type
and then not Is_RTE (Obj_Type, RE_Address)),
Parameter_Type =>
- New_Reference_To (Obj_Type, Loc));
+ New_Occurrence_Of (Obj_Type, Loc));
Set_Debug_Info_Needed (Defining_Identifier (Decl));
Prepend_To (New_Plist, Decl);
Return_Stmt :=
Make_Simple_Return_Statement (Loc,
- Expression => New_Reference_To (R, Loc));
+ Expression => New_Occurrence_Of (R, Loc));
else
Unprot_Call := Make_Simple_Return_Statement (Loc,
case Corresponding_Runtime_Package (Pid) is
when System_Tasking_Protected_Objects_Entries =>
- Lock_Name := New_Reference_To (RTE (RE_Lock_Entries), Loc);
+ Lock_Name := New_Occurrence_Of (RTE (RE_Lock_Entries), Loc);
when System_Tasking_Protected_Objects_Single_Entry =>
- Lock_Name := New_Reference_To (RTE (RE_Lock_Entry), Loc);
+ Lock_Name := New_Occurrence_Of (RTE (RE_Lock_Entry), Loc);
when System_Tasking_Protected_Objects =>
- Lock_Name := New_Reference_To (RTE (Lock_Kind), Loc);
+ Lock_Name := New_Occurrence_Of (RTE (Lock_Kind), Loc);
when others =>
raise Program_Error;
if Abort_Allowed then
Stmts := New_List (
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Defer), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Abort_Defer), Loc),
Parameter_Associations => Empty_List),
Lock_Stmt);
then
case Corresponding_Runtime_Package (Conc_Typ) is
when System_Tasking_Protected_Objects_Entries =>
- Nam := New_Reference_To (RTE (RE_Service_Entries), Loc);
+ Nam := New_Occurrence_Of (RTE (RE_Service_Entries), Loc);
when System_Tasking_Protected_Objects_Single_Entry =>
- Nam := New_Reference_To (RTE (RE_Service_Entry), Loc);
+ Nam := New_Occurrence_Of (RTE (RE_Service_Entry), Loc);
when others =>
raise Program_Error;
case Corresponding_Runtime_Package (Conc_Typ) is
when System_Tasking_Protected_Objects_Entries =>
- Nam := New_Reference_To (RTE (RE_Unlock_Entries), Loc);
+ Nam := New_Occurrence_Of (RTE (RE_Unlock_Entries), Loc);
when System_Tasking_Protected_Objects_Single_Entry =>
- Nam := New_Reference_To (RTE (RE_Unlock_Entry), Loc);
+ Nam := New_Occurrence_Of (RTE (RE_Unlock_Entry), Loc);
when System_Tasking_Protected_Objects =>
- Nam := New_Reference_To (RTE (RE_Unlock), Loc);
+ Nam := New_Occurrence_Of (RTE (RE_Unlock), Loc);
when others =>
raise Program_Error;
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Abort_Undefer), Loc),
+ New_Occurrence_Of (RTE (RE_Abort_Undefer), Loc),
Parameter_Associations => Empty_List));
end if;
end Build_Protected_Subprogram_Call_Cleanup;
Make_Object_Declaration (Loc,
Defining_Identifier => X,
Object_Definition =>
- New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Task_Entry_Index), Loc),
Expression => Actual_Index_Expression (
Loc, Entity (Ename), Index, Concval));
Append_To (Decls, Xdecl);
- Parm2 := New_Reference_To (X, Loc);
+ Parm2 := New_Occurrence_Of (X, Loc);
else
Xdecl := Empty;
-- none, then it is just the null address, since nothing is passed.
if No (Parms) then
- Parm3 := New_Reference_To (RTE (RE_Null_Address), Loc);
+ Parm3 := New_Occurrence_Of (RTE (RE_Null_Address), Loc);
P := Empty;
-- Case of parameters present, where third argument is the address
Defining_Identifier => Make_Temporary (Loc, 'J'),
Aliased_Present => True,
Object_Definition =>
- New_Reference_To (Etype (Formal), Loc));
+ New_Occurrence_Of (Etype (Formal), Loc));
-- Mark the object as not needing initialization since the
-- initialization is performed separately, avoiding errors
or else Is_Access_Type (Etype (Formal))
then
N_Var :=
- New_Reference_To (Defining_Identifier (N_Node), Loc);
+ New_Occurrence_Of (Defining_Identifier (N_Node), Loc);
Set_Assignment_OK (N_Var);
Append_To (Stats,
Make_Assignment_Statement (Loc,
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Unchecked_Access,
Prefix =>
- New_Reference_To (Defining_Identifier (N_Node), Loc)));
+ New_Occurrence_Of (Defining_Identifier (N_Node), Loc)));
-- If it is a VM_By_Copy_Actual, copy it to a new variable
Defining_Identifier => Make_Temporary (Loc, 'J'),
Aliased_Present => True,
Object_Definition =>
- New_Reference_To (Etype (Formal), Loc),
+ New_Occurrence_Of (Etype (Formal), Loc),
Expression => New_Copy_Tree (Actual));
Set_Assignment_OK (N_Node);
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Unchecked_Access,
Prefix =>
- New_Reference_To (Defining_Identifier (N_Node), Loc)));
+ New_Occurrence_Of (Defining_Identifier (N_Node), Loc)));
else
-- Interface class-wide formal
Prefix =>
Relocate_Node (Actual),
Selector_Name =>
- New_Reference_To (Iface_Tag, Loc)))));
+ New_Occurrence_Of (Iface_Tag, Loc)))));
else
-- Generate:
-- actual'reference
Make_Object_Declaration (Loc,
Defining_Identifier => P,
Object_Definition =>
- New_Reference_To (Designated_Type (Ent_Acc), Loc),
+ New_Occurrence_Of (Designated_Type (Ent_Acc), Loc),
Expression =>
Make_Aggregate (Loc, Expressions => Plist));
Parm3 :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (P, Loc),
+ Prefix => New_Occurrence_Of (P, Loc),
Attribute_Name => Name_Address);
Append (Pdecl, Decls);
-- Change the type of the index declaration
Set_Object_Definition (Xdecl,
- New_Reference_To (RTE (RE_Protected_Entry_Index), Loc));
+ New_Occurrence_Of (RTE (RE_Protected_Entry_Index), Loc));
-- Some additional declarations for protected entry calls
Make_Object_Declaration (Loc,
Defining_Identifier => Comm_Name,
Object_Definition =>
- New_Reference_To (RTE (RE_Communication_Block), Loc)));
+ New_Occurrence_Of
+ (RTE (RE_Communication_Block), Loc)));
-- Some additional statements for protected entry calls
Call :=
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Protected_Entry_Call), Loc),
+ New_Occurrence_Of (RTE (RE_Protected_Entry_Call), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => Parm1),
Parm2,
Parm3,
- New_Reference_To (RTE (RE_Simple_Call), Loc),
+ New_Occurrence_Of (RTE (RE_Simple_Call), Loc),
New_Occurrence_Of (Comm_Name, Loc)));
when System_Tasking_Protected_Objects_Single_Entry =>
Call :=
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (
+ Name => New_Occurrence_Of (
RTE (RE_Protected_Single_Entry_Call), Loc),
Parameter_Associations => New_List (
else
Call :=
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Call_Simple), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Call_Simple), Loc),
Parameter_Associations => New_List (Parm1, Parm2, Parm3));
end if;
Expression =>
Make_Explicit_Dereference (Loc,
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (P, Loc),
+ Prefix => New_Occurrence_Of (P, Loc),
Selector_Name =>
Make_Identifier (Loc, Chars (Formal)))));
if Present (Chain) then
if Restricted_Profile then
- Name := New_Reference_To (RTE (RE_Activate_Restricted_Tasks), Loc);
+ Name := New_Occurrence_Of
+ (RTE (RE_Activate_Restricted_Tasks), Loc);
else
- Name := New_Reference_To (RTE (RE_Activate_Tasks), Loc);
+ Name := New_Occurrence_Of
+ (RTE (RE_Activate_Tasks), Loc);
end if;
Call :=
begin
Block :=
Make_Block_Statement (Loc,
- Identifier => New_Reference_To (Blkent, Loc),
+ Identifier => New_Occurrence_Of (Blkent, Loc),
Declarations => New_List (
-- _Chain : Activation_Chain;
Defining_Identifier => Chain,
Aliased_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Activation_Chain), Loc))),
+ New_Occurrence_Of (RTE (RE_Activation_Chain), Loc))),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
-- Init (Args);
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Init, Loc),
+ Name => New_Occurrence_Of (Init, Loc),
Parameter_Associations => Args),
-- Activate_Tasks (_Chain);
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Activate_Tasks), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Activate_Tasks), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Chain, Loc),
+ Prefix => New_Occurrence_Of (Chain, Loc),
Attribute_Name => Name_Unchecked_Access))))),
Has_Created_Identifier => True,
begin
Append_To (Init_Stmts,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Activate_Tasks), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Activate_Tasks), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Chain, Loc),
+ Prefix => New_Occurrence_Of (Chain, Loc),
Attribute_Name => Name_Unchecked_Access))));
Block :=
Make_Block_Statement (Loc,
- Identifier => New_Reference_To (Blkent, Loc),
+ Identifier => New_Occurrence_Of (Blkent, Loc),
Declarations => New_List (
-- _Chain : Activation_Chain;
Defining_Identifier => Chain,
Aliased_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Activation_Chain), Loc))),
+ New_Occurrence_Of (RTE (RE_Activation_Chain), Loc))),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc, Init_Stmts),
Parameter_Type =>
Make_Access_Definition (Loc,
Subtype_Mark =>
- New_Reference_To (Corresponding_Record_Type (T), Loc)))));
+ New_Occurrence_Of (Corresponding_Record_Type (T), Loc)))));
end Build_Task_Proc_Specification;
---------------------------------------
Make_Component_Definition (Loc,
Aliased_Present => False,
Subtype_Indication =>
- New_Reference_To (Standard_Character, Loc))));
+ New_Occurrence_Of (Standard_Character, Loc))));
end;
Insert_After (Current_Node, Efam_Decl);
if Is_Current_Task (Entity (N)) then
return
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Self), Loc));
+ Name => New_Occurrence_Of (RTE (RE_Self), Loc));
else
declare
New_Occurrence_Of (RTE (RO_ST_Task_Id), Loc),
Expression =>
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Self), Loc)));
+ Name => New_Occurrence_Of (RTE (RE_Self), Loc)));
Prepend (Decl, Declarations (T_Body));
Analyze (Decl);
Set_Scope (T_Self, Entity (N));
pragma Assert (Is_Protected_Type (Entity (N)));
return
- New_Reference_To (Find_Protection_Object (Current_Scope), Loc);
+ New_Occurrence_Of (Find_Protection_Object (Current_Scope), Loc);
end if;
else
Sloc,
Make_Attribute_Reference (Sloc,
Attribute_Name => Name_Pos,
- Prefix => New_Reference_To (Base_Type (S), Sloc),
+ Prefix => New_Occurrence_Of (Base_Type (S), Sloc),
Expressions => New_List (Relocate_Node (Index))),
Type_Low_Bound (S),
Ttyp,
begin
Ent := Make_Temporary (Loc, 'L');
- Lab := Make_Label (Loc, New_Reference_To (Ent, Loc));
+ Lab := Make_Label (Loc, New_Occurrence_Of (Ent, Loc));
Ldecl :=
Make_Implicit_Label_Declaration (Loc,
Defining_Identifier => Ent,
Append (Lab, Statements (Handled_Statement_Sequence (N)));
Ent := Make_Temporary (Loc, 'L');
- Lab := Make_Label (Loc, New_Reference_To (Ent, Loc));
+ Lab := Make_Label (Loc, New_Occurrence_Of (Ent, Loc));
Ldecl2 :=
Make_Implicit_Label_Declaration (Loc,
Defining_Identifier => Ent,
Make_Object_Declaration (Loc,
Defining_Identifier => Ann,
Object_Definition =>
- New_Reference_To (RTE (RE_Address), Loc));
+ New_Occurrence_Of (RTE (RE_Address), Loc));
Insert_Before_And_Analyze (N, Adecl);
Insert_Before_And_Analyze (N, Ldecl);
Make_Object_Declaration (Loc,
Defining_Identifier => Ann,
Object_Definition =>
- New_Reference_To (RTE (RE_Address), Loc));
+ New_Occurrence_Of (RTE (RE_Address), Loc));
Insert_Before_And_Analyze (Sel_Acc, Adecl);
Prefix =>
Unchecked_Convert_To (
Entry_Parameters_Type (Ent),
- New_Reference_To (Ann, Loc)),
+ New_Occurrence_Of (Ann, Loc)),
Selector_Name =>
- New_Reference_To (Comp, Loc));
+ New_Occurrence_Of (Comp, Loc));
Decl :=
Build_Renamed_Formal_Declaration
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RO_ST_Task_Id), Loc),
+ New_Occurrence_Of (RTE (RO_ST_Task_Id), Loc),
Expression =>
Make_Selected_Component (Loc,
Prefix => New_Copy_Tree (Tasknm),
Rewrite (N,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Tasks), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Abort_Tasks), Loc),
Parameter_Associations => New_List (
Make_Qualified_Expression (Loc,
- Subtype_Mark => New_Reference_To (RTE (RE_Task_List), Loc),
+ Subtype_Mark => New_Occurrence_Of (RTE (RE_Task_List), Loc),
Expression => Aggr))));
Analyze (N);
Rewrite (N,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Accept_Trivial), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Accept_Trivial), Loc),
Parameter_Associations => New_List (
Entry_Index_Expression (Loc, Entity (Ename), Eindx, Ttyp))));
Block :=
Make_Block_Statement (Loc,
- Identifier => New_Reference_To (Blkent, Loc),
+ Identifier => New_Occurrence_Of (Blkent, Loc),
Declarations => Declarations (N),
Handled_Statement_Sequence => Build_Accept_Body (N));
Call :=
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Accept_Call), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Accept_Call), Loc),
Parameter_Associations => New_List (
Entry_Index_Expression (Loc, Entity (Ename), Eindx, Ttyp),
- New_Reference_To (Ann, Loc)));
+ New_Occurrence_Of (Ann, Loc)));
if Parent (Stats) = N then
Prepend (Call, Statements (Stats));
Make_Object_Declaration (Loc,
Defining_Identifier => Bnn,
Object_Definition =>
- New_Reference_To (RTE (RE_Communication_Block), Loc)));
+ New_Occurrence_Of (RTE (RE_Communication_Block), Loc)));
-- Call kind processing, generate:
-- C : Ada.Tags.Prim_Op_Kind;
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uD),
Object_Definition =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Dummy_Communication_Block), Loc)));
K := Build_K (Loc, Decls, Obj);
Make_Object_Declaration (Loc,
Defining_Identifier => T,
Object_Definition =>
- New_Reference_To (Standard_Boolean, Loc)));
+ New_Occurrence_Of (Standard_Boolean, Loc)));
------------------------------
-- Protected entry handling --
Prepend_To (Cleanup_Stmts,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Bnn, Loc),
+ Name => New_Occurrence_Of (Bnn, Loc),
Expression =>
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Communication_Block), Loc),
+ New_Occurrence_Of (RTE (RE_Communication_Block), Loc),
Expression => Make_Identifier (Loc, Name_uD))));
-- Generate:
Prepend_To (Cleanup_Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(Find_Prim_Op
(Etype (Etype (Obj)), Name_uDisp_Asynchronous_Select),
Loc),
Parameter_Associations =>
New_List (
New_Copy_Tree (Obj), -- <object>
- New_Reference_To (S, Loc), -- S
+ New_Occurrence_Of (S, Loc), -- S
Make_Attribute_Reference (Loc, -- P'Address
- Prefix => New_Reference_To (P, Loc),
+ Prefix => New_Occurrence_Of (P, Loc),
Attribute_Name => Name_Address),
Make_Identifier (Loc, Name_uD), -- D
- New_Reference_To (B, Loc)))); -- B
+ New_Occurrence_Of (B, Loc)))); -- B
-- Generate:
-- if Enqueued (Bnn) then
Condition =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Enqueued), Loc),
+ New_Occurrence_Of (RTE (RE_Enqueued), Loc),
Parameter_Associations =>
- New_List (New_Reference_To (Bnn, Loc))),
+ New_List (New_Occurrence_Of (Bnn, Loc))),
Then_Statements =>
New_Copy_List_Tree (Astats)));
Right_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Cancelled), Loc),
+ New_Occurrence_Of (RTE (RE_Cancelled), Loc),
Parameter_Associations =>
- New_List (New_Reference_To (Bnn, Loc)))),
+ New_List (New_Occurrence_Of (Bnn, Loc)))),
Then_Statements =>
New_Copy_List_Tree (Tstats)));
Append_To (TaskE_Stmts,
Make_Assignment_Statement (Loc,
Name =>
- New_Reference_To (Bnn, Loc),
+ New_Occurrence_Of (Bnn, Loc),
Expression =>
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Communication_Block), Loc),
+ New_Occurrence_Of (RTE (RE_Communication_Block), Loc),
Expression => Make_Identifier (Loc, Name_uD))));
-- Generate:
Prepend_To (TaskE_Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (
+ New_Occurrence_Of (
Find_Prim_Op (Etype (Etype (Obj)),
Name_uDisp_Asynchronous_Select),
Loc),
Parameter_Associations =>
New_List (
New_Copy_Tree (Obj), -- <object>
- New_Reference_To (S, Loc), -- S
+ New_Occurrence_Of (S, Loc), -- S
Make_Attribute_Reference (Loc, -- P'Address
- Prefix => New_Reference_To (P, Loc),
+ Prefix => New_Occurrence_Of (P, Loc),
Attribute_Name => Name_Address),
Make_Identifier (Loc, Name_uD), -- D
- New_Reference_To (B, Loc)))); -- B
+ New_Occurrence_Of (B, Loc)))); -- B
-- Generate:
-- Abort_Defer;
Prepend_To (TaskE_Stmts,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Defer), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Abort_Defer), Loc),
Parameter_Associations => No_List));
-- Generate:
Prepend_To (Cleanup_Stmts,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Undefer), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Abort_Undefer), Loc),
Parameter_Associations => No_List));
-- Wrap the statements in a block. Exp_Ch7.Expand_Cleanup_Actions
Append_To (TaskE_Stmts,
Make_Implicit_If_Statement (N,
Condition =>
- Make_Op_Not (Loc, Right_Opnd => New_Reference_To (T, Loc)),
+ Make_Op_Not (Loc, Right_Opnd => New_Occurrence_Of (T, Loc)),
Then_Statements =>
New_Copy_List_Tree (Tstats)));
Append_To (Conc_Typ_Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(Find_Prim_Op (Etype (Etype (Obj)),
Name_uDisp_Get_Prim_Op_Kind),
Loc),
Parameter_Associations =>
New_List (
New_Copy_Tree (Obj),
- New_Reference_To (S, Loc),
- New_Reference_To (C, Loc))));
+ New_Occurrence_Of (S, Loc),
+ New_Occurrence_Of (C, Loc))));
-- Generate:
-- if C = POK_Procedure_Entry then
Condition =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_POK_Protected_Entry), Loc)),
+ New_Occurrence_Of (RTE (RE_POK_Protected_Entry), Loc)),
Then_Statements =>
ProtE_Stmts,
Condition =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_POK_Task_Entry), Loc)),
+ New_Occurrence_Of (RTE (RE_POK_Task_Entry), Loc)),
Then_Statements =>
TaskE_Stmts)),
if Is_RTE (Pdef, RO_CA_Delay_For) then
Enqueue_Call :=
- New_Reference_To (RTE (RE_Enqueue_Duration), Loc);
+ New_Occurrence_Of (RTE (RE_Enqueue_Duration), Loc);
elsif Is_RTE (Pdef, RO_CA_Delay_Until) then
Enqueue_Call :=
- New_Reference_To (RTE (RE_Enqueue_Calendar), Loc);
+ New_Occurrence_Of (RTE (RE_Enqueue_Calendar), Loc);
else pragma Assert (Is_RTE (Pdef, RO_RT_Delay_Until));
- Enqueue_Call := New_Reference_To (RTE (RE_Enqueue_RT), Loc);
+ Enqueue_Call := New_Occurrence_Of (RTE (RE_Enqueue_RT), Loc);
end if;
Append_To (Parameter_Associations (Ecall),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Dblock_Ent, Loc),
+ Prefix => New_Occurrence_Of (Dblock_Ent, Loc),
Attribute_Name => Name_Unchecked_Access));
-- Create the inner block to protect the abortable part
Prepend_To (Astats,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Undefer), Loc)));
+ Name => New_Occurrence_Of (RTE (RE_Abort_Undefer), Loc)));
Abortable_Block :=
Make_Block_Statement (Loc,
- Identifier => New_Reference_To (Blk_Ent, Loc),
+ Identifier => New_Occurrence_Of (Blk_Ent, Loc),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
Statements => Astats),
Make_Implicit_If_Statement (N,
Condition =>
Make_Function_Call (Loc,
- Name => New_Reference_To (
+ Name => New_Occurrence_Of (
RTE (RE_Timed_Out), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Dblock_Ent, Loc),
+ Prefix => New_Occurrence_Of (Dblock_Ent, Loc),
Attribute_Name => Name_Unchecked_Access))),
Then_Statements => Tstats));
Defining_Identifier => Dblock_Ent,
Aliased_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Delay_Block), Loc))),
+ New_Occurrence_Of (RTE (RE_Delay_Block), Loc))),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc, Stmts)));
end loop;
pragma Assert (Present (Param));
- Rewrite (Param, New_Reference_To (RTE (RE_Asynchronous_Call), Loc));
+ Rewrite (Param, New_Occurrence_Of (RTE (RE_Asynchronous_Call), Loc));
Analyze (Param);
-- Append an if statement to execute the abortable part
Make_Implicit_If_Statement (N,
Condition =>
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Enqueued), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Enqueued), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Cancel_Param, Loc))),
+ New_Occurrence_Of (Cancel_Param, Loc))),
Then_Statements => Astats));
Abortable_Block :=
Make_Block_Statement (Loc,
- Identifier => New_Reference_To (Blk_Ent, Loc),
+ Identifier => New_Occurrence_Of (Blk_Ent, Loc),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc, Statements => Stmts),
Has_Created_Identifier => True,
else
Handler_Stmt := Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Undefer), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Abort_Undefer), Loc),
Parameter_Associations => No_List);
end if;
else
Handler_Stmt := Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Update_Exception), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Update_Exception), Loc),
Parameter_Associations => New_List (
Make_Function_Call (Loc,
Name => New_Occurrence_Of
-- Abort_Undefer.all;
Exception_Choices =>
- New_List (New_Reference_To (Stand.Abort_Signal, Loc)),
+ New_List (New_Occurrence_Of (Stand.Abort_Signal, Loc)),
Statements => New_List (Handler_Stmt))))),
-- if not Cancelled (Bnn) then
Prepend_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => B,
- Object_Definition => New_Reference_To (Standard_Boolean, Loc)));
+ Object_Definition =>
+ New_Occurrence_Of (Standard_Boolean, Loc)));
Cancel_Param := Make_Defining_Identifier (Loc, Name_uC);
Prepend_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => Cancel_Param,
- Object_Definition => New_Reference_To (Standard_Boolean, Loc)));
+ Object_Definition =>
+ New_Occurrence_Of (Standard_Boolean, Loc)));
-- Remove and save the call to Call_Simple
Prepend_To (Astats,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Undefer), Loc)));
+ Name => New_Occurrence_Of (RTE (RE_Abort_Undefer), Loc)));
Abortable_Block :=
Make_Block_Statement (Loc,
- Identifier => New_Reference_To (Blk_Ent, Loc),
+ Identifier => New_Occurrence_Of (Blk_Ent, Loc),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc, Statements => Astats),
Has_Created_Identifier => True,
Params := Parameter_Associations (Call);
Append_To (Params,
- New_Reference_To (RTE (RE_Asynchronous_Call), Loc));
- Append_To (Params, New_Reference_To (B, Loc));
+ New_Occurrence_Of (RTE (RE_Asynchronous_Call), Loc));
+ Append_To (Params, New_Occurrence_Of (B, Loc));
Rewrite (Call,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Task_Entry_Call), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Task_Entry_Call), Loc),
Parameter_Associations => Params));
-- Construct statement sequence for new block
Append_To (Stmts,
Make_Implicit_If_Statement (N,
Condition =>
- Make_Op_Not (Loc, New_Reference_To (Cancel_Param, Loc)),
+ Make_Op_Not (Loc, New_Occurrence_Of (Cancel_Param, Loc)),
Then_Statements => Tstats));
-- Protected the call against abort
Prepend_To (Stmts,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Defer), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Abort_Defer), Loc),
Parameter_Associations => Empty_List));
end if;
Append_To (Conc_Typ_Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (
+ New_Occurrence_Of (
Find_Prim_Op (Etype (Etype (Obj)),
Name_uDisp_Conditional_Select),
Loc),
Parameter_Associations =>
New_List (
New_Copy_Tree (Obj), -- <object>
- New_Reference_To (S, Loc), -- S
+ New_Occurrence_Of (S, Loc), -- S
Make_Attribute_Reference (Loc, -- P'Address
- Prefix => New_Reference_To (P, Loc),
+ Prefix => New_Occurrence_Of (P, Loc),
Attribute_Name => Name_Address),
- New_Reference_To (C, Loc), -- C
- New_Reference_To (B, Loc)))); -- B
+ New_Occurrence_Of (C, Loc), -- C
+ New_Occurrence_Of (B, Loc)))); -- B
-- Generate:
-- if C = POK_Protected_Entry
Left_Opnd =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (
+ New_Occurrence_Of (RTE (
RE_POK_Protected_Entry), Loc)),
Right_Opnd =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_POK_Task_Entry), Loc))),
+ New_Occurrence_Of (RTE (RE_POK_Task_Entry), Loc))),
Then_Statements => Unpack));
end if;
Left_Opnd =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_POK_Procedure), Loc)),
+ New_Occurrence_Of (RTE (RE_POK_Procedure), Loc)),
Right_Opnd =>
Make_Or_Else (Loc,
Left_Opnd =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (
+ New_Occurrence_Of (RTE (
RE_POK_Protected_Procedure), Loc)),
Right_Opnd =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (
+ New_Occurrence_Of (RTE (
RE_POK_Task_Procedure), Loc)))),
Then_Statements =>
Append_To (Conc_Typ_Stmts,
Make_Implicit_If_Statement (N,
- Condition => New_Reference_To (B, Loc),
+ Condition => New_Occurrence_Of (B, Loc),
Then_Statements => N_Stats,
Else_Statements => Else_Statements (N)));
end loop;
pragma Assert (Present (Param));
- Rewrite (Param, New_Reference_To (RTE (RE_Conditional_Call), Loc));
+ Rewrite (Param,
+ New_Occurrence_Of (RTE (RE_Conditional_Call), Loc));
Analyze (Param);
Append_To (Stmts,
Make_Implicit_If_Statement (N,
Condition => Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Cancelled), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Cancelled), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Defining_Identifier (Decl), Loc))),
+ New_Occurrence_Of (Defining_Identifier (Decl), Loc))),
Then_Statements => Else_Statements (N),
Else_Statements => Statements (Alt)));
Make_Object_Declaration (Loc,
Defining_Identifier => B,
Object_Definition =>
- New_Reference_To (Standard_Boolean, Loc)));
+ New_Occurrence_Of (Standard_Boolean, Loc)));
-- Create new call statement
Append_To (Params,
- New_Reference_To (RTE (RE_Conditional_Call), Loc));
- Append_To (Params, New_Reference_To (B, Loc));
+ New_Occurrence_Of (RTE (RE_Conditional_Call), Loc));
+ Append_To (Params, New_Occurrence_Of (B, Loc));
Rewrite (Call,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Task_Entry_Call), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Task_Entry_Call), Loc),
Parameter_Associations => Params));
-- Construct statement sequence for new block
Append_To (Stmts,
Make_Implicit_If_Statement (N,
- Condition => New_Reference_To (B, Loc),
+ Condition => New_Occurrence_Of (B, Loc),
Then_Statements => Statements (Alt),
Else_Statements => Else_Statements (N)));
end if;
begin
Rewrite (N,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RO_CA_Delay_For), Loc),
+ Name => New_Occurrence_Of (RTE (RO_CA_Delay_For), Loc),
Parameter_Associations => New_List (Expression (N))));
Analyze (N);
end Expand_N_Delay_Relative_Statement;
Rewrite (N,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Typ, Loc),
+ Name => New_Occurrence_Of (Typ, Loc),
Parameter_Associations => New_List (Expression (N))));
Analyze (N);
Make_Access_To_Object_Definition (Loc,
All_Present => True,
Constant_Present => Ekind (Formal) = E_In_Parameter,
- Subtype_Indication => New_Reference_To (Ftype, Loc)));
+ Subtype_Indication => New_Occurrence_Of (Ftype, Loc)));
Insert_After (Last_Decl, Decl);
Last_Decl := Decl;
Component_Definition =>
Make_Component_Definition (Loc,
Aliased_Present => False,
- Subtype_Indication => New_Reference_To (Ctype, Loc))));
+ Subtype_Indication => New_Occurrence_Of (Ctype, Loc))));
Next_Formal_With_Extras (Formal);
end loop;
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
All_Present => True,
- Subtype_Indication => New_Reference_To (Rec_Ent, Loc)));
+ Subtype_Indication => New_Occurrence_Of (Rec_Ent, Loc)));
Insert_After (Last_Decl, Decl);
end if;
New_List (
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (Corresponding_Spec (Prot_Bod), Loc),
+ New_Occurrence_Of (Corresponding_Spec (Prot_Bod), Loc),
Parameter_Associations => Actuals));
else
Expression =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (Corresponding_Spec (Prot_Bod), Loc),
+ New_Occurrence_Of (Corresponding_Spec (Prot_Bod), Loc),
Parameter_Associations => Actuals)));
end if;
Make_Aggregate (Loc,
Expressions => New_List (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Bdef, Loc),
+ Prefix => New_Occurrence_Of (Bdef, Loc),
Attribute_Name => Name_Unrestricted_Access),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Edef, Loc),
+ Prefix => New_Occurrence_Of (Edef, Loc),
Attribute_Name => Name_Unrestricted_Access))));
end Expand_Entry_Declaration;
Proc_Address : constant Node_Id :=
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Prot_Proc, Loc),
+ New_Occurrence_Of (Prot_Proc, Loc),
Attribute_Name => Name_Address);
RTS_Call : constant Entity_Id :=
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Register_Interrupt_Handler), Loc),
Parameter_Associations => New_List (Proc_Address));
begin
Protection_Subtype :=
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Static_Interrupt_Protection), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Protection_Subtype :=
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Dynamic_Interrupt_Protection), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Protection_Subtype :=
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Protection_Entries), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
when System_Tasking_Protected_Objects_Single_Entry =>
Protection_Subtype :=
- New_Reference_To (RTE (RE_Protection_Entry), Loc);
+ New_Occurrence_Of (RTE (RE_Protection_Entry), Loc);
when System_Tasking_Protected_Objects =>
Protection_Subtype :=
- New_Reference_To (RTE (RE_Protection), Loc);
+ New_Occurrence_Of (RTE (RE_Protection), Loc);
when others =>
raise Program_Error;
Aliased_Present => True,
Object_Definition =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (
+ Subtype_Mark => New_Occurrence_Of (
RTE (RE_Protected_Entry_Body_Array), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Body_Arr := Make_Object_Declaration (Loc,
Defining_Identifier => Body_Id,
Aliased_Present => True,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(RTE (RE_Entry_Body), Loc),
Expression => Remove_Head (Expressions (Entries_Aggr)));
-- Process the "with abort" parameter
Prepend_To (Params,
- New_Reference_To (Boolean_Literals (Abort_Present (N)), Loc));
+ New_Occurrence_Of (Boolean_Literals (Abort_Present (N)), Loc));
-- Process the entry wrapper's position in the primary dispatch
-- table parameter. Generate:
if Tagged_Type_Expansion then
Prepend_To (Params,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Entry_Index), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Entry_Index), Loc),
Parameter_Associations => New_List (
Make_Explicit_Dereference (Loc,
Attribute_Name => Name_Address))),
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Offset_Index), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Offset_Index), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Tag), Concval),
Make_Integer_Literal (Loc,
else
Prepend_To (Params,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Entry_Index), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Entry_Index), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Tag),
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Offset_Index), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Offset_Index), Loc),
Parameter_Associations => New_List (
-- Tag_Typ
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Etype (Concval), Loc),
+ Prefix => New_Occurrence_Of (Etype (Concval), Loc),
Attribute_Name => Name_Tag),
-- Position
Attribute_Name => Name_Address));
Prepend_To (Params, -- True
- New_Reference_To (Standard_True, Loc));
+ New_Occurrence_Of (Standard_True, Loc));
-- Specific actuals for task to XXX requeue
pragma Assert (Is_Task_Type (Old_Typ));
Prepend_To (Params, -- null
- New_Reference_To (RTE (RE_Null_Address), Loc));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc));
Prepend_To (Params, -- False
- New_Reference_To (Standard_False, Loc));
+ New_Occurrence_Of (Standard_False, Loc));
end if;
-- Add the object parameter
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (
+ New_Occurrence_Of (
Find_Prim_Op (Etype (Etype (Obj)),
Name_uDisp_Get_Prim_Op_Kind),
Loc),
Parameter_Associations => New_List (
New_Copy_Tree (Obj),
- New_Reference_To (S, Loc),
- New_Reference_To (C, Loc))));
+ New_Occurrence_Of (S, Loc),
+ New_Occurrence_Of (C, Loc))));
Append_To (Stmts,
Left_Opnd =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_POK_Protected_Entry), Loc)),
+ New_Occurrence_Of (RTE (RE_POK_Protected_Entry), Loc)),
Right_Opnd =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_POK_Task_Entry), Loc))),
+ New_Occurrence_Of (RTE (RE_POK_Task_Entry), Loc))),
-- Dispatching requeue equivalent
Condition =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To (C, Loc),
+ New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_POK_Protected_Procedure), Loc)),
-- Dispatching call equivalent
-- Process the "with abort" parameter
Prepend_To (Params,
- New_Reference_To (Boolean_Literals (Abort_Present (N)), Loc));
+ New_Occurrence_Of (Boolean_Literals (Abort_Present (N)), Loc));
-- Add the index expression to the parameters. It is common among all
-- four cases.
if Is_Protected_Type (Conc_Typ) then
RT_Call :=
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_Requeue_Protected_Entry), Loc);
Param :=
else pragma Assert (Is_Task_Type (Conc_Typ));
RT_Call :=
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_Requeue_Protected_To_Task_Entry), Loc);
Param := Concurrent_Ref (Concval);
if Is_Protected_Type (Conc_Typ) then
RT_Call :=
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_Requeue_Task_To_Protected_Entry), Loc);
Param :=
else pragma Assert (Is_Task_Type (Conc_Typ));
RT_Call :=
- New_Reference_To (RTE (RE_Requeue_Task_Entry), Loc);
+ New_Occurrence_Of (RTE (RE_Requeue_Task_Entry), Loc);
Param := Concurrent_Ref (Concval);
end if;
Make_Selected_Component (Loc,
Prefix =>
Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (Qnam, Loc),
- Expressions => New_List (New_Reference_To (J, Loc))),
+ Prefix => New_Occurrence_Of (Qnam, Loc),
+ Expressions => New_List (New_Occurrence_Of (J, Loc))),
Selector_Name => Make_Identifier (Loc, Name_S)),
Right_Opnd =>
- New_Reference_To (RTE (RE_Null_Task_Entry), Loc));
+ New_Occurrence_Of (RTE (RE_Null_Task_Entry), Loc));
Stats := New_List (
Make_Implicit_Loop_Statement (N,
Defining_Identifier => J,
Discrete_Subtype_Definition =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Qnam, Loc),
+ Prefix => New_Occurrence_Of (Qnam, Loc),
Attribute_Name => Name_Range,
Expressions => New_List (
Make_Integer_Literal (Loc, 1))))),
Condition => Cond,
Then_Statements => New_List (
Make_Select_Call (
- New_Reference_To (RTE (RE_Simple_Mode), Loc)),
+ New_Occurrence_Of (RTE (RE_Simple_Mode), Loc)),
Make_Exit_Statement (Loc))))));
Append_To (Stats,
Make_Raise_Program_Error (Loc,
Condition => Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (Xnam, Loc),
+ Left_Opnd => New_Occurrence_Of (Xnam, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_No_Rendezvous), Loc)),
+ New_Occurrence_Of (RTE (RE_No_Rendezvous), Loc)),
Reason => PE_All_Guards_Closed));
return Stats;
Make_If_Expression (Eloc, New_List (
Condition (Alt),
Entry_Index_Expression (Eloc, Eent, Index, Scope (Eent)),
- New_Reference_To (RTE (RE_Null_Task_Entry), Eloc)));
+ New_Occurrence_Of (RTE (RE_Null_Task_Entry), Eloc)));
else
Expr :=
Entry_Index_Expression
end if;
if Present (Handled_Statement_Sequence (Accept_Statement (Alt))) then
- Null_Body := New_Reference_To (Standard_False, Eloc);
+ Null_Body := New_Occurrence_Of (Standard_False, Eloc);
-- Always add call to Abort_Undefer when generating code, since
-- this is what the runtime expects (abort deferred in
if not CodePeer_Mode then
Call :=
Make_Procedure_Call_Statement (Eloc,
- Name => New_Reference_To (RTE (RE_Abort_Undefer), Eloc));
+ Name => New_Occurrence_Of (RTE (RE_Abort_Undefer), Eloc));
Insert_Before
(First (Statements (Handled_Statement_Sequence
(Accept_Statement (Alt)))),
Append (Proc_Body, Body_List);
else
- Null_Body := New_Reference_To (Standard_True, Eloc);
+ Null_Body := New_Occurrence_Of (Standard_True, Eloc);
-- if accept statement has declarations, insert above, given that
-- we are not creating a body for the accept.
begin
Append (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Qnam, Loc),
+ Prefix => New_Occurrence_Of (Qnam, Loc),
Attribute_Name => Name_Unchecked_Access),
Params);
Append (Select_Mode, Params);
- Append (New_Reference_To (Ann, Loc), Params);
- Append (New_Reference_To (Xnam, Loc), Params);
+ Append (New_Occurrence_Of (Ann, Loc), Params);
+ Append (New_Occurrence_Of (Xnam, Loc), Params);
return
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Selective_Wait), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Selective_Wait), Loc),
Parameter_Associations => Params);
end Make_Select_Call;
New_List (
Make_Procedure_Call_Statement (Sloc (Proc),
Name =>
- New_Reference_To
+ New_Occurrence_Of
(Defining_Unit_Name (Specification (Proc)),
Sloc (Proc))));
Delay_Alt := New_List (
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Delay_Min, Loc),
+ Name => New_Occurrence_Of (Delay_Min, Loc),
Expression => Expression (Delay_Statement (Alt))));
if Delay_Count > 1 then
Append_To (Delay_Alt,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Delay_Index, Loc),
+ Name => New_Occurrence_Of (Delay_Index, Loc),
Expression => Make_Integer_Literal (Loc, Index)));
end if;
else
Delay_Alt := New_List (
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Delay_Val, Loc),
+ Name => New_Occurrence_Of (Delay_Val, Loc),
Expression => Expression (Delay_Statement (Alt))));
if Time_Type = Standard_Duration then
Cond :=
Make_Op_Lt (Loc,
- Left_Opnd => New_Reference_To (Delay_Val, Loc),
- Right_Opnd => New_Reference_To (Delay_Min, Loc));
+ Left_Opnd => New_Occurrence_Of (Delay_Val, Loc),
+ Right_Opnd => New_Occurrence_Of (Delay_Min, Loc));
else
-- The scope of the time type must define a comparison
Make_Function_Call (Loc,
Name => Make_Selected_Component (Loc,
Prefix =>
- New_Reference_To (Scope (Time_Type), Loc),
+ New_Occurrence_Of (Scope (Time_Type), Loc),
Selector_Name =>
Make_Operator_Symbol (Loc,
Chars => Name_Op_Lt,
Strval => No_String)),
Parameter_Associations =>
New_List (
- New_Reference_To (Delay_Val, Loc),
- New_Reference_To (Delay_Min, Loc)));
+ New_Occurrence_Of (Delay_Val, Loc),
+ New_Occurrence_Of (Delay_Min, Loc)));
Set_Entity (Prefix (Name (Cond)), Scope (Time_Type));
end if;
Condition => Cond,
Then_Statements => New_List (
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Delay_Min, Loc),
- Expression => New_Reference_To (Delay_Val, Loc)),
+ Name => New_Occurrence_Of (Delay_Min, Loc),
+ Expression => New_Occurrence_Of (Delay_Val, Loc)),
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Delay_Index, Loc),
+ Name => New_Occurrence_Of (Delay_Index, Loc),
Expression => Make_Integer_Literal (Loc, Index)))));
end if;
if Check_Guard then
Append_To (Delay_Alt,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Guard_Open, Loc),
- Expression => New_Reference_To (Standard_True, Loc)));
+ Name => New_Occurrence_Of (Guard_Open, Loc),
+ Expression => New_Occurrence_Of (Standard_True, Loc)));
end if;
if Present (Condition (Alt)) then
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => Qnam,
- Object_Definition => New_Reference_To (RTE (RE_Accept_List), Loc),
+ Object_Definition => New_Occurrence_Of (RTE (RE_Accept_List), Loc),
Aliased_Present => True,
Expression =>
Make_Qualified_Expression (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Accept_List), Loc),
+ New_Occurrence_Of (RTE (RE_Accept_List), Loc),
Expression =>
Make_Aggregate (Loc, Expressions => Accept_List))));
Make_Object_Declaration (Loc,
Defining_Identifier => Xnam,
Object_Definition =>
- New_Reference_To (RTE (RE_Select_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Select_Index), Loc),
Expression =>
- New_Reference_To (RTE (RE_No_Rendezvous), Loc)));
+ New_Occurrence_Of (RTE (RE_No_Rendezvous), Loc)));
-- After this follow procedure declarations for each accept body
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => Delay_Val,
- Object_Definition => New_Reference_To (Time_Type, Loc)));
+ Object_Definition => New_Occurrence_Of (Time_Type, Loc)));
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => Delay_Index,
- Object_Definition => New_Reference_To (Standard_Integer, Loc),
+ Object_Definition => New_Occurrence_Of (Standard_Integer, Loc),
Expression => Make_Integer_Literal (Loc, 0)));
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => Delay_Min,
- Object_Definition => New_Reference_To (Time_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Time_Type, Loc),
Expression =>
Unchecked_Convert_To (Time_Type,
Make_Attribute_Reference (Loc,
Make_Object_Declaration (Loc,
Defining_Identifier => D,
Object_Definition =>
- New_Reference_To (Standard_Duration, Loc)));
+ New_Occurrence_Of (Standard_Duration, Loc)));
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => M,
Object_Definition =>
- New_Reference_To (Standard_Integer, Loc),
+ New_Occurrence_Of (Standard_Integer, Loc),
Expression => Discr));
end;
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => Guard_Open,
- Object_Definition => New_Reference_To (Standard_Boolean, Loc),
- Expression => New_Reference_To (Standard_False, Loc)));
+ Object_Definition =>
+ New_Occurrence_Of (Standard_Boolean, Loc),
+ Expression =>
+ New_Occurrence_Of (Standard_False, Loc)));
end if;
-- Delay_Count is zero, don't need M and D set (suppress warning)
if Present (Condition (Terminate_Alt)) then
Select_Mode := Make_If_Expression (Loc,
New_List (Condition (Terminate_Alt),
- New_Reference_To (RTE (RE_Terminate_Mode), Loc),
- New_Reference_To (RTE (RE_Simple_Mode), Loc)));
+ New_Occurrence_Of (RTE (RE_Terminate_Mode), Loc),
+ New_Occurrence_Of (RTE (RE_Simple_Mode), Loc)));
else
- Select_Mode := New_Reference_To (RTE (RE_Terminate_Mode), Loc);
+ Select_Mode := New_Occurrence_Of (RTE (RE_Terminate_Mode), Loc);
end if;
elsif Else_Present or Delay_Count > 0 then
- Select_Mode := New_Reference_To (RTE (RE_Else_Mode), Loc);
+ Select_Mode := New_Occurrence_Of (RTE (RE_Else_Mode), Loc);
else
- Select_Mode := New_Reference_To (RTE (RE_Simple_Mode), Loc);
+ Select_Mode := New_Occurrence_Of (RTE (RE_Simple_Mode), Loc);
end if;
Select_Call := Make_Select_Call (Select_Mode);
-- First entry is the default case, when no rendezvous is possible
- Choices := New_List (New_Reference_To (RTE (RE_No_Rendezvous), Loc));
+ Choices := New_List (New_Occurrence_Of (RTE (RE_No_Rendezvous), Loc));
if Else_Present then
Accept_Case := New_List (
Make_Case_Statement (Loc,
- Expression => New_Reference_To (Xnam, Loc),
+ Expression => New_Occurrence_Of (Xnam, Loc),
Alternatives => Alt_List));
Append_List (Trailing_List, Accept_Case);
Delay_Case := New_List (
Make_Case_Statement (Loc,
- Expression => New_Reference_To (Delay_Index, Loc),
+ Expression => New_Occurrence_Of (Delay_Index, Loc),
Alternatives => Delay_Alt_List));
else
Delay_Case := Delay_Alt_List;
-- The type of the delay expression is known to be legal
if Time_Type = Standard_Duration then
- Conv := New_Reference_To (Delay_Min, Loc);
+ Conv := New_Occurrence_Of (Delay_Min, Loc);
elsif Is_RTE (Base_Type (Etype (Time_Type)), RO_CA_Time) then
Conv := Make_Function_Call (Loc,
- New_Reference_To (RTE (RO_CA_To_Duration), Loc),
- New_List (New_Reference_To (Delay_Min, Loc)));
+ New_Occurrence_Of (RTE (RO_CA_To_Duration), Loc),
+ New_List (New_Occurrence_Of (Delay_Min, Loc)));
else
pragma Assert
(Is_RTE (Base_Type (Etype (Time_Type)), RO_RT_Time));
Conv := Make_Function_Call (Loc,
- New_Reference_To (RTE (RO_RT_To_Duration), Loc),
- New_List (New_Reference_To (Delay_Min, Loc)));
+ New_Occurrence_Of (RTE (RO_RT_To_Duration), Loc),
+ New_List (New_Occurrence_Of (Delay_Min, Loc)));
end if;
Stmt := Make_Assignment_Statement (Loc,
- Name => New_Reference_To (D, Loc),
+ Name => New_Occurrence_Of (D, Loc),
Expression => Conv);
-- Change the value for Accept_Modes. (Else_Mode -> Delay_Mode)
end loop;
pragma Assert (Present (Parm));
- Rewrite (Parm, New_Reference_To (RTE (RE_Delay_Mode), Loc));
+ Rewrite (Parm, New_Occurrence_Of (RTE (RE_Delay_Mode), Loc));
Analyze (Parm);
-- Prepare two new parameters of Duration and Delay_Mode type
-- which represent the value and the mode of the minimum delay.
Next (Parm);
- Insert_After (Parm, New_Reference_To (M, Loc));
- Insert_After (Parm, New_Reference_To (D, Loc));
+ Insert_After (Parm, New_Occurrence_Of (M, Loc));
+ Insert_After (Parm, New_Occurrence_Of (D, Loc));
-- Create a call to RTS
Rewrite (Select_Call,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Timed_Selective_Wait), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Timed_Selective_Wait), Loc),
Parameter_Associations => Parms));
-- This new call should follow the calculation of the minimum
if Check_Guard then
Stmt :=
Make_Implicit_If_Statement (N,
- Condition => New_Reference_To (Guard_Open, Loc),
+ Condition => New_Occurrence_Of (Guard_Open, Loc),
Then_Statements => New_List (
New_Copy_Tree (Stmt),
New_Copy_Tree (Select_Call)),
Cases :=
Make_Implicit_If_Statement (N,
Condition => Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (Xnam, Loc),
+ Left_Opnd => New_Occurrence_Of (Xnam, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_No_Rendezvous), Loc)),
+ New_Occurrence_Of (RTE (RE_No_Rendezvous), Loc)),
Then_Statements => Delay_Case,
Else_Statements => Accept_Case);
Make_Assignment_Statement (Loc,
Name =>
Make_Identifier (Loc, New_External_Name (Chars (Ttyp), 'E')),
- Expression => New_Reference_To (Standard_True, Loc)));
+ Expression => New_Occurrence_Of (Standard_True, Loc)));
end if;
-- Ada 2005 (AI-345): Construct the primitive entry wrapper bodies after
Make_Defining_Identifier (Sloc (Tasktyp),
Chars => New_External_Name (Tasknm, 'E')),
Aliased_Present => True,
- Object_Definition => New_Reference_To (Standard_Boolean, Loc),
- Expression => New_Reference_To (Standard_False, Loc));
+ Object_Definition => New_Occurrence_Of (Standard_Boolean, Loc),
+ Expression => New_Occurrence_Of (Standard_False, Loc));
Insert_After (N, Elab_Decl);
Size_Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Storage_Size_Variable (Tasktyp),
- Object_Definition => New_Reference_To (RTE (RE_Size_Type), Loc),
+ Object_Definition =>
+ New_Occurrence_Of (RTE (RE_Size_Type), Loc),
Expression =>
Convert_To (RTE (RE_Size_Type),
Relocate_Node
Make_Object_Declaration (Loc,
Defining_Identifier => Storage_Size_Variable (Tasktyp),
Object_Definition =>
- New_Reference_To (RTE (RE_Size_Type), Loc),
+ New_Occurrence_Of (RTE (RE_Size_Type), Loc),
Expression =>
- New_Reference_To (RTE (RE_Unspecified_Size), Loc));
+ New_Occurrence_Of (RTE (RE_Unspecified_Size), Loc));
end if;
Insert_After (Elab_Decl, Size_Decl);
Component_Definition =>
Make_Component_Definition (Loc,
Aliased_Present => False,
- Subtype_Indication => New_Reference_To (RTE (RO_ST_Task_Id),
+ Subtype_Indication => New_Occurrence_Of (RTE (RO_ST_Task_Id),
Loc))));
-- Declare static ATCB (that is, created by the expander) if we are
and then Present (Discriminal_Link (Entity (Expr_N)))
then
Task_Size :=
- New_Reference_To
+ New_Occurrence_Of
(CR_Discriminant (Discriminal_Link (Entity (Expr_N))),
Loc);
Set_Parent (Task_Size, P);
else
Task_Size :=
- New_Reference_To (RTE (RE_Default_Stack_Size), Loc);
+ New_Occurrence_Of (RTE (RE_Default_Stack_Size), Loc);
end if;
Decl_Stack := Make_Component_Declaration (Loc,
Make_Component_Definition (Loc,
Aliased_Present => False,
Subtype_Indication =>
- New_Reference_To (Standard_Integer, Loc))));
+ New_Occurrence_Of (Standard_Integer, Loc))));
end if;
-- Add the _Size component if a Storage_Size pragma is present
Make_Component_Definition (Loc,
Aliased_Present => False,
Subtype_Indication =>
- New_Reference_To (RTE (RE_Size_Type), Loc)),
+ New_Occurrence_Of (RTE (RE_Size_Type), Loc)),
Expression =>
Convert_To (RTE (RE_Size_Type),
Make_Component_Definition (Loc,
Aliased_Present => False,
Subtype_Indication =>
- New_Reference_To (RTE (RE_Task_Info_Type), Loc)),
+ New_Occurrence_Of (RTE (RE_Task_Info_Type), Loc)),
Expression => New_Copy (
Expression (First (
Make_Component_Definition (Loc,
Aliased_Present => False,
Subtype_Indication =>
- New_Reference_To (RTE (RE_CPU_Range), Loc))));
+ New_Occurrence_Of (RTE (RE_CPU_Range), Loc))));
end if;
-- Add the _Relative_Deadline component if a Relative_Deadline pragma is
Make_Component_Definition (Loc,
Aliased_Present => False,
Subtype_Indication =>
- New_Reference_To (RTE (RE_Time_Span), Loc)),
+ New_Occurrence_Of (RTE (RE_Time_Span), Loc)),
Expression =>
Convert_To (RTE (RE_Time_Span),
Make_Component_Definition (Loc,
Aliased_Present => False,
Subtype_Indication =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Dispatching_Domain_Access), Loc))));
end if;
Prepend_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => B,
- Object_Definition => New_Reference_To (Standard_Boolean, Loc)));
+ Object_Definition =>
+ New_Occurrence_Of (Standard_Boolean, Loc)));
end if;
-- Duration and mode processing
D_Disc := Make_Integer_Literal (Loc, 1);
D_Conv :=
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RO_CA_To_Duration), Loc),
+ Name => New_Occurrence_Of (RTE (RO_CA_To_Duration), Loc),
Parameter_Associations =>
New_List (New_Copy (Expression (D_Stat))));
D_Disc := Make_Integer_Literal (Loc, 2);
D_Conv :=
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RO_RT_To_Duration), Loc),
+ Name => New_Occurrence_Of (RTE (RO_RT_To_Duration), Loc),
Parameter_Associations =>
New_List (New_Copy (Expression (D_Stat))));
end if;
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => D,
- Object_Definition => New_Reference_To (Standard_Duration, Loc)));
+ Object_Definition => New_Occurrence_Of (Standard_Duration, Loc)));
M := Make_Temporary (Loc, 'M');
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => M,
- Object_Definition => New_Reference_To (Standard_Integer, Loc),
+ Object_Definition => New_Occurrence_Of (Standard_Integer, Loc),
Expression => D_Disc));
-- Do the assignment at this stage only because the evaluation of the
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (D, Loc),
+ Name => New_Occurrence_Of (D, Loc),
Expression => D_Conv));
-- Parameter block processing
Params := New_List;
Append_To (Params, New_Copy_Tree (Obj));
- Append_To (Params, New_Reference_To (S, Loc));
+ Append_To (Params, New_Occurrence_Of (S, Loc));
Append_To (Params,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (P, Loc),
+ Prefix => New_Occurrence_Of (P, Loc),
Attribute_Name => Name_Address));
- Append_To (Params, New_Reference_To (D, Loc));
- Append_To (Params, New_Reference_To (M, Loc));
- Append_To (Params, New_Reference_To (C, Loc));
- Append_To (Params, New_Reference_To (B, Loc));
+ Append_To (Params, New_Occurrence_Of (D, Loc));
+ Append_To (Params, New_Occurrence_Of (M, Loc));
+ Append_To (Params, New_Occurrence_Of (C, Loc));
+ Append_To (Params, New_Occurrence_Of (B, Loc));
Append_To (Conc_Typ_Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(Find_Prim_Op
(Etype (Etype (Obj)), Name_uDisp_Timed_Select), Loc),
Parameter_Associations => Params));
Make_Or_Else (Loc,
Left_Opnd =>
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (C, Loc),
+ Left_Opnd => New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_POK_Protected_Entry), Loc)),
Right_Opnd =>
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (C, Loc),
+ Left_Opnd => New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_POK_Task_Entry), Loc))),
+ New_Occurrence_Of (RTE (RE_POK_Task_Entry), Loc))),
Then_Statements => Unpack));
end if;
Make_Or_Else (Loc,
Left_Opnd =>
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (C, Loc),
+ Left_Opnd => New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (RE_POK_Procedure), Loc)),
+ New_Occurrence_Of (RTE (RE_POK_Procedure), Loc)),
Right_Opnd =>
Make_Or_Else (Loc,
Left_Opnd =>
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (C, Loc),
+ Left_Opnd => New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To (RTE (
+ New_Occurrence_Of (RTE (
RE_POK_Protected_Procedure), Loc)),
Right_Opnd =>
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (C, Loc),
+ Left_Opnd => New_Occurrence_Of (C, Loc),
Right_Opnd =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_POK_Task_Procedure), Loc)))),
Then_Statements => New_List (E_Call)));
Append_To (Conc_Typ_Stmts,
Make_Implicit_If_Statement (N,
- Condition => New_Reference_To (B, Loc),
+ Condition => New_Occurrence_Of (B, Loc),
Then_Statements => N_Stats));
-- Generate:
Insert_Before (Stmt,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (D, Loc),
+ Name => New_Occurrence_Of (D, Loc),
Expression => D_Conv));
Call := Stmt;
-- finally add Duration and a Delay_Mode parameter
pragma Assert (Present (Param));
- Rewrite (Param, New_Reference_To (D, Loc));
+ Rewrite (Param, New_Occurrence_Of (D, Loc));
- Rewrite (Dummy, New_Reference_To (M, Loc));
+ Rewrite (Dummy, New_Occurrence_Of (M, Loc));
-- Add a Boolean flag for successful entry call
- Append_To (Params, New_Reference_To (B, Loc));
+ Append_To (Params, New_Occurrence_Of (B, Loc));
case Corresponding_Runtime_Package (Etype (Concval)) is
when System_Tasking_Protected_Objects_Entries =>
Rewrite (Call,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Timed_Protected_Entry_Call), Loc),
Parameter_Associations => Params));
else
-- Create a new call statement
- Append_To (Params, New_Reference_To (D, Loc));
- Append_To (Params, New_Reference_To (M, Loc));
- Append_To (Params, New_Reference_To (B, Loc));
+ Append_To (Params, New_Occurrence_Of (D, Loc));
+ Append_To (Params, New_Occurrence_Of (M, Loc));
+ Append_To (Params, New_Occurrence_Of (B, Loc));
Rewrite (Call,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Timed_Task_Entry_Call), Loc),
+ New_Occurrence_Of (RTE (RE_Timed_Task_Entry_Call), Loc),
Parameter_Associations => Params));
end if;
Append_To (Stmts,
Make_Implicit_If_Statement (N,
- Condition => New_Reference_To (B, Loc),
+ Condition => New_Occurrence_Of (B, Loc),
Then_Statements => E_Stats,
Else_Statements => D_Stats));
end if;
Next_Discriminant (D);
end loop;
- B := New_Reference_To (Discriminal (D), Loc);
+ B := New_Occurrence_Of (Discriminal (D), Loc);
else
- B := New_Reference_To (Discriminal (Entity (Bound)), Loc);
+ B := New_Occurrence_Of (Discriminal (Entity (Bound)), Loc);
end if;
elsif Nkind (Bound) = N_Attribute_Reference then
Real_Hi :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ityp, Loc),
+ Prefix => New_Occurrence_Of (Ityp, Loc),
Attribute_Name => Name_Min,
Expressions => New_List (
Real_Hi,
Real_Lo :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ityp, Loc),
+ Prefix => New_Occurrence_Of (Ityp, Loc),
Attribute_Name => Name_Max,
Expressions => New_List (
Real_Lo,
return
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ityp, Loc),
+ Prefix => New_Occurrence_Of (Ityp, Loc),
Attribute_Name => Name_Max,
Expressions => New_List (
Make_Op_Add (Loc,
Type_Definition =>
Make_Access_To_Object_Definition (Loc,
Subtype_Indication =>
- New_Reference_To (Conc_Rec, Loc)));
+ New_Occurrence_Of (Conc_Rec, Loc)));
Add (Decl);
-- Generate:
Make_Object_Declaration (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uObject),
- Object_Definition => New_Reference_To (Typ_Id, Loc),
+ Object_Definition => New_Occurrence_Of (Typ_Id, Loc),
Expression =>
Unchecked_Convert_To (Typ_Id,
- New_Reference_To (Obj_Ent, Loc)));
+ New_Occurrence_Of (Obj_Ent, Loc)));
Add (Decl);
-- Set the reference to the concurrent object
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Prot_Ent,
Subtype_Mark =>
- New_Reference_To (RTE (Prot_Typ), Loc),
+ New_Occurrence_Of (RTE (Prot_Typ), Loc),
Name =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Obj_Ent, Loc),
+ Prefix => New_Occurrence_Of (Obj_Ent, Loc),
Selector_Name => Make_Identifier (Loc, Name_uObject)));
Add (Decl);
end;
Decl :=
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Discriminal (D),
- Subtype_Mark => New_Reference_To (Etype (D), Loc),
+ Subtype_Mark => New_Occurrence_Of (Etype (D), Loc),
Name =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Obj_Ent, Loc),
+ Prefix => New_Occurrence_Of (Obj_Ent, Loc),
Selector_Name => Make_Identifier (Loc, Chars (D))));
Add (Decl);
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Decl_Id,
Subtype_Mark =>
- New_Reference_To (Etype (Comp_Id), Loc),
+ New_Occurrence_Of (Etype (Comp_Id), Loc),
Name =>
Make_Selected_Component (Loc,
Prefix =>
- New_Reference_To (Obj_Ent, Loc),
+ New_Occurrence_Of (Obj_Ent, Loc),
Selector_Name =>
Make_Identifier (Loc, Chars (Comp_Id))));
Add (Decl);
Subtype_Indication =>
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To (Base_Type (Etype (Index)), Loc),
+ New_Occurrence_Of (Base_Type (Etype (Index)), Loc),
Constraint =>
Make_Range_Constraint (Loc,
Range_Expression =>
Defining_Identifier => Index_Con,
Constant_Present => True,
Object_Definition =>
- New_Reference_To (Index_Typ, Loc),
+ New_Occurrence_Of (Index_Typ, Loc),
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Index_Typ, Loc),
+ New_Occurrence_Of (Index_Typ, Loc),
Attribute_Name => Name_Val,
Expressions => New_List (
Left_Opnd =>
Make_Op_Subtract (Loc,
Left_Opnd =>
- New_Reference_To (E, Loc),
+ New_Occurrence_Of (E, Loc),
Right_Opnd =>
Entry_Index_Expression (Loc,
Defining_Identifier (Body_Nod),
Right_Opnd =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Index_Typ, Loc),
+ New_Occurrence_Of (Index_Typ, Loc),
Attribute_Name => Name_Pos,
Expressions => New_List (
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Index_Typ, Loc),
+ New_Occurrence_Of (Index_Typ, Loc),
Attribute_Name => Name_First)))))));
Add (Decl);
end;
or else Has_Interrupt_Handler (Ptyp)
then
Append_To (Args,
- New_Reference_To (RTE (RE_Default_Interrupt_Priority), Loc));
+ New_Occurrence_Of (RTE (RE_Default_Interrupt_Priority), Loc));
-- Normal case, no priority or xx_Handler specified, default priority
else
Append_To (Args,
- New_Reference_To (RTE (RE_Unspecified_Priority), Loc));
+ New_Occurrence_Of (RTE (RE_Unspecified_Priority), Loc));
end if;
-- Test for Compiler_Info parameter. This parameter allows entry body
Append_To (Args,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (P_Arr, Loc),
+ Prefix => New_Occurrence_Of (P_Arr, Loc),
Attribute_Name => Name_Unrestricted_Access));
if Pkg_Id = System_Tasking_Protected_Objects_Entries then
Append_To (Args,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (P_Arr, Loc),
+ Prefix => New_Occurrence_Of (P_Arr, Loc),
Attribute_Name => Name_Unrestricted_Access));
end if;
Append_To (L,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (Called_Subp), Loc),
+ Name => New_Occurrence_Of (RTE (Called_Subp), Loc),
Parameter_Associations => Args));
end;
end if;
else
Append_To (Args,
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Default_Interrupt_Priority), Loc));
end if;
end if;
Append_To (L,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Install_Restricted_Handlers), Loc),
Parameter_Associations => Args));
Append_To (L,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Install_Handlers), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Install_Handlers), Loc),
Parameter_Associations => Args));
end if;
end;
Selector_Name => Make_Identifier (Loc, Name_uPriority)));
else
Append_To (Args,
- New_Reference_To (RTE (RE_Unspecified_Priority), Loc));
+ New_Occurrence_Of (RTE (RE_Unspecified_Priority), Loc));
end if;
-- Optional Stack parameter
else
Append_To (Args,
- New_Reference_To (RTE (RE_Null_Address), Loc));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc));
end if;
end if;
else
Append_To (Args,
- New_Reference_To (Storage_Size_Variable (Ttyp), Loc));
+ New_Occurrence_Of (Storage_Size_Variable (Ttyp), Loc));
end if;
-- Task_Info parameter. Set to Unspecified_Task_Info unless there is a
else
Append_To (Args,
- New_Reference_To (RTE (RE_Unspecified_Task_Info), Loc));
+ New_Occurrence_Of (RTE (RE_Unspecified_Task_Info), Loc));
end if;
-- CPU parameter. Set to Unspecified_CPU unless there is a CPU rep item,
Selector_Name => Make_Identifier (Loc, Name_uCPU))));
else
Append_To (Args,
- New_Reference_To (RTE (RE_Unspecified_CPU), Loc));
+ New_Occurrence_Of (RTE (RE_Unspecified_CPU), Loc));
end if;
if not Restricted_Profile then
else
Append_To (Args,
- New_Reference_To (RTE (RE_Time_Span_Zero), Loc));
+ New_Occurrence_Of (RTE (RE_Time_Span_Zero), Loc));
end if;
-- Dispatching_Domain parameter. If no Dispatching_Domain rep item is
Append_To (Args,
Unchecked_Convert_To (RTE (RE_Task_Procedure_Access),
Make_Qualified_Expression (Loc,
- Subtype_Mark => New_Reference_To (Subp_Ptr_Typ, Loc),
+ Subtype_Mark => New_Occurrence_Of (Subp_Ptr_Typ, Loc),
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
Create_RE := RE_Create_Task;
end if;
- Name := New_Reference_To (RTE (Create_RE), Loc);
+ Name := New_Occurrence_Of (RTE (Create_RE), Loc);
end;
return
Defining_Identifier =>
Temp_Nam,
Object_Definition =>
- New_Reference_To (Etype (Formal), Loc)));
+ New_Occurrence_Of (Etype (Formal), Loc)));
if Ekind (Formal) /= E_Out_Parameter then
-- Jnn := <actual>
Temp_Asn :=
- New_Reference_To (Temp_Nam, Loc);
+ New_Occurrence_Of (Temp_Nam, Loc);
Set_Assignment_OK (Temp_Asn);
Attribute_Name =>
Name_Unchecked_Access,
Prefix =>
- New_Reference_To (Temp_Nam, Loc)));
+ New_Occurrence_Of (Temp_Nam, Loc)));
Has_Param := True;
Defining_Identifier =>
P,
Object_Definition =>
- New_Reference_To (Blk_Typ, Loc),
+ New_Occurrence_Of (Blk_Typ, Loc),
Expression =>
Expr));
Make_Explicit_Dereference (Loc,
Make_Selected_Component (Loc,
Prefix =>
- New_Reference_To (P, Loc),
+ New_Occurrence_Of (P, Loc),
Selector_Name =>
Make_Identifier (Loc, Chars (Formal)))));
Res :=
Make_Object_Declaration (Loc,
Defining_Identifier => Obj,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(Standard_Debug_Renaming_Type, Loc));
Set_Debug_Renaming_Link (Obj, Entity (Ren));
Make_Selected_Component (Loc,
Prefix => New_Value (Ctrl_Arg),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Typ), Loc)),
Right_Opnd =>
Prefix =>
Unchecked_Convert_To (Typ, New_Value (Param)),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Typ), Loc))),
Then_Statements =>
Controlling_Tag :=
Make_Selected_Component (Loc,
Prefix => Duplicate_Subexpr_Move_Checks (Ctrl_Arg),
- Selector_Name => New_Reference_To (DTC_Entity (Subp), Loc));
+ Selector_Name => New_Occurrence_Of (DTC_Entity (Subp), Loc));
end if;
-- Handle dispatching calls to predefined primitives
Make_Selected_Component (Loc,
Prefix => New_Value (Param),
Selector_Name =>
- New_Reference_To (First_Tag_Component (Typ),
+ New_Occurrence_Of (First_Tag_Component (Typ),
Loc)),
Right_Opnd =>
Unchecked_Convert_To (Typ,
New_Value (Next_Actual (Param))),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(First_Tag_Component (Typ), Loc))),
Right_Opnd => New_Call);
Prefix => Duplicate_Subexpr (Expression (N)),
Attribute_Name => Name_Tag),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Iface_Typ, Loc),
+ Prefix => New_Occurrence_Of (Iface_Typ, Loc),
Attribute_Name => Name_Tag))));
end if;
Rewrite (N,
Unchecked_Convert_To (Etype (N),
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Displace), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Displace), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Address),
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Displace), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Displace), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => Relocate_Node (Expression (N)),
Null_Exclusion_Present => False,
Constant_Present => False,
Subtype_Indication =>
- New_Reference_To (Desig_Typ, Loc)));
+ New_Occurrence_Of (Desig_Typ, Loc)));
Stats := New_List (
Make_Simple_Return_Statement (Loc,
Condition =>
Make_Op_Eq (Loc,
Left_Opnd => Make_Identifier (Loc, Name_uO),
- Right_Opnd => New_Reference_To
+ Right_Opnd => New_Occurrence_Of
(RTE (RE_Null_Address), Loc)),
Then_Statements => New_List (
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uO),
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc))),
+ New_Occurrence_Of (RTE (RE_Address), Loc))),
Result_Definition =>
- New_Reference_To (Etype (N), Loc)),
+ New_Occurrence_Of (Etype (N), Loc)),
Declarations => New_List (New_Typ_Decl),
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (Fent, Loc),
+ Name => New_Occurrence_Of (Fent, Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Address),
Relocate_Node (Expression (N))))));
Rewrite (N,
Make_Function_Call (Loc,
- Name => New_Reference_To (Fent, Loc),
+ Name => New_Occurrence_Of (Fent, Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => Unchecked_Convert_To (Operand_Typ,
Chars => Chars (Formal)),
In_Present => In_Present (Parent (Formal)),
Out_Present => Out_Present (Parent (Formal)),
- Parameter_Type => New_Reference_To (Ftyp, Loc),
+ Parameter_Type => New_Occurrence_Of (Ftyp, Loc),
Expression => Expr));
if not Is_Predefined_Dispatching_Operation (Prim) then
Null_Exclusion_Present => False,
Constant_Present => False,
Subtype_Indication =>
- New_Reference_To (Ftyp, Loc)));
+ New_Occurrence_Of (Ftyp, Loc)));
New_Arg :=
Unchecked_Convert_To (RTE (RE_Address),
- New_Reference_To (Defining_Identifier (Formal), Loc));
+ New_Occurrence_Of (Defining_Identifier (Formal), Loc));
if not RTE_Available (RE_Offset_To_Top) then
Offset_To_Top :=
else
Offset_To_Top :=
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Offset_To_Top), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Offset_To_Top), Loc),
Parameter_Associations => New_List (New_Arg));
end if;
Defining_Identifier => Make_Temporary (Loc, 'S'),
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Storage_Offset), Loc),
+ New_Occurrence_Of (RTE (RE_Storage_Offset), Loc),
Expression =>
Make_Op_Subtract (Loc,
Left_Opnd =>
Unchecked_Convert_To
(RTE (RE_Storage_Offset),
- New_Reference_To (Defining_Identifier (Formal), Loc)),
+ New_Occurrence_Of
+ (Defining_Identifier (Formal), Loc)),
Right_Opnd =>
Offset_To_Top));
Append_To (Actuals,
Unchecked_Convert_To
(Defining_Identifier (Decl_2),
- New_Reference_To (Defining_Identifier (Decl_1), Loc)));
+ New_Occurrence_Of (Defining_Identifier (Decl_1), Loc)));
elsif Is_Controlling_Formal (Target_Formal) then
New_Arg :=
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Defining_Identifier (Formal), Loc),
+ New_Occurrence_Of (Defining_Identifier (Formal), Loc),
Attribute_Name =>
Name_Address);
else
Offset_To_Top :=
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Offset_To_Top), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Offset_To_Top), Loc),
Parameter_Associations => New_List (New_Arg));
end if;
Defining_Identifier => Make_Temporary (Loc, 'S'),
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Storage_Offset), Loc),
+ New_Occurrence_Of (RTE (RE_Storage_Offset), Loc),
Expression =>
Make_Op_Subtract (Loc,
Left_Opnd =>
(RTE (RE_Storage_Offset),
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To
+ New_Occurrence_Of
(Defining_Identifier (Formal), Loc),
Attribute_Name => Name_Address)),
Right_Opnd =>
Defining_Identifier => Make_Temporary (Loc, 'S'),
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Addr_Ptr), Loc),
+ New_Occurrence_Of (RTE (RE_Addr_Ptr), Loc),
Expression =>
Unchecked_Convert_To
(RTE (RE_Addr_Ptr),
- New_Reference_To (Defining_Identifier (Decl_1), Loc)));
+ New_Occurrence_Of (Defining_Identifier (Decl_1), Loc)));
Append_To (Decl, Decl_1);
Append_To (Decl, Decl_2);
Append_To (Actuals,
Unchecked_Convert_To (Ftyp,
Make_Explicit_Dereference (Loc,
- New_Reference_To (Defining_Identifier (Decl_2), Loc))));
+ New_Occurrence_Of (Defining_Identifier (Decl_2), Loc))));
-- Ensure proper matching of access types. Required to avoid
-- reporting spurious errors.
elsif Is_Access_Type (Etype (Target_Formal)) then
Append_To (Actuals,
Unchecked_Convert_To (Base_Type (Etype (Target_Formal)),
- New_Reference_To (Defining_Identifier (Formal), Loc)));
+ New_Occurrence_Of (Defining_Identifier (Formal), Loc)));
-- No special management required for this actual
else
Append_To (Actuals,
- New_Reference_To (Defining_Identifier (Formal), Loc));
+ New_Occurrence_Of (Defining_Identifier (Formal), Loc));
end if;
Next_Formal (Target_Formal);
Make_Handled_Sequence_Of_Statements (Loc,
New_List (Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uF),
- Expression => New_Reference_To (Standard_False, Loc)))));
+ Expression => New_Occurrence_Of (Standard_False, Loc)))));
end if;
if Is_Concurrent_Record_Type (Typ) then
if Tagged_Type_Expansion then
Tag_Node :=
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Typ))), Loc));
else
Tag_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag);
end if;
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uI),
Object_Definition =>
- New_Reference_To (Standard_Integer, Loc),
+ New_Occurrence_Of (Standard_Integer, Loc),
Expression =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Get_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Get_Entry_Index), Loc),
Parameter_Associations =>
New_List (
Tag_Node,
Defining_Identifier =>
Com_Block,
Object_Definition =>
- New_Reference_To (RTE (RE_Communication_Block), Loc)));
+ New_Occurrence_Of (RTE (RE_Communication_Block), Loc)));
-- Build T._object'Access for calls below
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Protected_Entry_Call), Loc),
+ New_Occurrence_Of (RTE (RE_Protected_Entry_Call), Loc),
Parameter_Associations =>
New_List (
Obj_Ref,
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Protected_Entry_Index), Loc),
Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uP), -- parameter block
- New_Reference_To -- Asynchronous_Call
+ New_Occurrence_Of -- Asynchronous_Call
(RTE (RE_Asynchronous_Call), Loc),
-
- New_Reference_To (Com_Block, Loc)))); -- comm block
+ New_Occurrence_Of -- comm block
+ (Com_Block, Loc))));
when others =>
raise Program_Error;
Expression =>
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_Dummy_Communication_Block), Loc),
Expression =>
- New_Reference_To (Com_Block, Loc))));
+ New_Occurrence_Of (Com_Block, Loc))));
-- Generate:
-- F := False;
Append_To (Stmts,
Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uF),
- Expression => New_Reference_To (Standard_False, Loc)));
+ Expression => New_Occurrence_Of (Standard_False, Loc)));
else
pragma Assert (Ekind (Conc_Typ) = E_Task_Type);
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Task_Entry_Call), Loc),
+ New_Occurrence_Of (RTE (RE_Task_Entry_Call), Loc),
Parameter_Associations =>
New_List (
Make_Selected_Component (Loc, -- T._task_id
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Task_Entry_Index), Loc),
Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uP), -- parameter block
- New_Reference_To -- Asynchronous_Call
+ New_Occurrence_Of -- Asynchronous_Call
(RTE (RE_Asynchronous_Call), Loc),
Make_Identifier (Loc, Name_uF)))); -- status flag
end if;
Append_To (Stmts,
Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uF),
- Expression => New_Reference_To (Standard_False, Loc)));
+ Expression => New_Occurrence_Of (Standard_False, Loc)));
end if;
return
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uT),
Parameter_Type =>
- New_Reference_To (Typ, Loc),
+ New_Occurrence_Of (Typ, Loc),
In_Present => True,
Out_Present => True),
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uS),
Parameter_Type =>
- New_Reference_To (Standard_Integer, Loc)),
+ New_Occurrence_Of (Standard_Integer, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uP),
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)),
+ New_Occurrence_Of (RTE (RE_Address), Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uB),
Parameter_Type =>
- New_Reference_To (RTE (RE_Dummy_Communication_Block), Loc),
+ New_Occurrence_Of (RTE (RE_Dummy_Communication_Block), Loc),
Out_Present => True),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uF),
Parameter_Type =>
- New_Reference_To (Standard_Boolean, Loc),
+ New_Occurrence_Of (Standard_Boolean, Loc),
Out_Present => True)));
return
Make_Handled_Sequence_Of_Statements (Loc,
New_List (Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uF),
- Expression => New_Reference_To (Standard_False, Loc)))));
+ Expression => New_Occurrence_Of (Standard_False, Loc)))));
end if;
if Is_Concurrent_Record_Type (Typ) then
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uI),
Object_Definition =>
- New_Reference_To (Standard_Integer, Loc)));
+ New_Occurrence_Of (Standard_Integer, Loc)));
-- Generate:
-- C := Ada.Tags.Get_Prim_Op_Kind (Ada.Tags.Tag! (<type>VP), S);
Defining_Identifier =>
Blk_Nam,
Object_Definition =>
- New_Reference_To (RTE (RE_Communication_Block), Loc)));
+ New_Occurrence_Of (RTE (RE_Communication_Block), Loc)));
-- Generate:
-- I := Ada.Tags.Get_Entry_Index (Ada.Tags.Tag! (<type>VP), S);
if Tagged_Type_Expansion then
Tag_Node :=
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Typ))), Loc));
else
Tag_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag);
end if;
Expression =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Get_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Get_Entry_Index), Loc),
Parameter_Associations =>
New_List (
Tag_Node,
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Protected_Entry_Call), Loc),
+ New_Occurrence_Of (RTE (RE_Protected_Entry_Call), Loc),
Parameter_Associations =>
New_List (
Obj_Ref,
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Protected_Entry_Index), Loc),
Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uP), -- parameter block
- New_Reference_To ( -- Conditional_Call
- RTE (RE_Conditional_Call), Loc),
- New_Reference_To ( -- Bnn
- Blk_Nam, Loc))));
+ New_Occurrence_Of -- Conditional_Call
+ (RTE (RE_Conditional_Call), Loc),
+ New_Occurrence_Of -- Bnn
+ (Blk_Nam, Loc))));
when System_Tasking_Protected_Objects_Single_Entry =>
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Protected_Single_Entry_Call), Loc),
Parameter_Associations =>
New_List (
Prefix => Make_Identifier (Loc, Name_uP),
Attribute_Name => Name_Address),
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Conditional_Call), Loc))));
when others =>
raise Program_Error;
Right_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Cancelled), Loc),
+ New_Occurrence_Of (RTE (RE_Cancelled), Loc),
Parameter_Associations =>
New_List (
- New_Reference_To (Blk_Nam, Loc))))));
+ New_Occurrence_Of (Blk_Nam, Loc))))));
else
pragma Assert (Ekind (Conc_Typ) = E_Task_Type);
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Task_Entry_Call), Loc),
+ New_Occurrence_Of (RTE (RE_Task_Entry_Call), Loc),
Parameter_Associations =>
New_List (
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Task_Entry_Index), Loc),
Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uP), -- parameter block
- New_Reference_To -- Conditional_Call
+ New_Occurrence_Of -- Conditional_Call
(RTE (RE_Conditional_Call), Loc),
Make_Identifier (Loc, Name_uF)))); -- status flag
end if;
Append_To (Stmts,
Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uF),
- Expression => New_Reference_To (Standard_False, Loc)));
+ Expression => New_Occurrence_Of (Standard_False, Loc)));
Append_To (Stmts,
Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uC),
- Expression => New_Reference_To (RTE (RE_POK_Function), Loc)));
+ Expression => New_Occurrence_Of (RTE (RE_POK_Function), Loc)));
end if;
return
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uT),
Parameter_Type =>
- New_Reference_To (Typ, Loc),
+ New_Occurrence_Of (Typ, Loc),
In_Present => True,
Out_Present => True),
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uS),
Parameter_Type =>
- New_Reference_To (Standard_Integer, Loc)),
+ New_Occurrence_Of (Standard_Integer, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uP),
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)),
+ New_Occurrence_Of (RTE (RE_Address), Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uC),
Parameter_Type =>
- New_Reference_To (RTE (RE_Prim_Op_Kind), Loc),
+ New_Occurrence_Of (RTE (RE_Prim_Op_Kind), Loc),
Out_Present => True),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uF),
Parameter_Type =>
- New_Reference_To (Standard_Boolean, Loc),
+ New_Occurrence_Of (Standard_Boolean, Loc),
Out_Present => True)));
return
if Tagged_Type_Expansion then
Tag_Node :=
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Typ))), Loc));
else
Tag_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag);
end if;
Expression =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Get_Prim_Op_Kind), Loc),
+ New_Occurrence_Of (RTE (RE_Get_Prim_Op_Kind), Loc),
Parameter_Associations => New_List (
Tag_Node,
Make_Identifier (Loc, Name_uS)))))));
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uT),
Parameter_Type =>
- New_Reference_To (Typ, Loc),
+ New_Occurrence_Of (Typ, Loc),
In_Present => True,
Out_Present => True),
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uS),
Parameter_Type =>
- New_Reference_To (Standard_Integer, Loc)),
+ New_Occurrence_Of (Standard_Integer, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uC),
Parameter_Type =>
- New_Reference_To (RTE (RE_Prim_Op_Kind), Loc),
+ New_Occurrence_Of (RTE (RE_Prim_Op_Kind), Loc),
Out_Present => True)));
return
Expression =>
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Address), Loc),
Expression =>
Make_Selected_Component (Loc,
Prefix => Make_Identifier (Loc, Name_uT),
Ret :=
Make_Simple_Return_Statement (Loc,
Expression =>
- New_Reference_To (RTE (RE_Null_Address), Loc));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc));
end if;
return
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uT),
Parameter_Type =>
- New_Reference_To (Typ, Loc))),
+ New_Occurrence_Of (Typ, Loc))),
Result_Definition =>
- New_Reference_To (RTE (RE_Address), Loc));
+ New_Occurrence_Of (RTE (RE_Address), Loc));
end Make_Disp_Get_Task_Id_Spec;
----------------------------
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_Requeue_Protected_Entry), Loc),
Parameter_Associations =>
New_List (
Make_Unchecked_Type_Conversion (Loc, -- PEA (P)
Subtype_Mark =>
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_Protection_Entries_Access), Loc),
Expression =>
Make_Identifier (Loc, Name_uP)),
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_Protected_Entry_Index), Loc),
Expression => Make_Identifier (Loc, Name_uI)),
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_Requeue_Task_To_Protected_Entry), Loc),
Parameter_Associations =>
New_List (
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To (
+ New_Occurrence_Of (
RTE (RE_Protected_Entry_Index), Loc),
Expression =>
Make_Identifier (Loc, Name_uI)),
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Requeue_Protected_To_Task_Entry), Loc),
Parameter_Associations => New_List (
Make_Unchecked_Type_Conversion (Loc, -- PEA (P)
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Protection_Entries_Access), Loc),
Expression => Make_Identifier (Loc, Name_uP)),
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Task_Entry_Index), Loc),
Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uA)))), -- abort status
-- Call to Requeue_Task_Entry
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Requeue_Task_Entry), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Requeue_Task_Entry), Loc),
Parameter_Associations => New_List (
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Task_Entry_Index), Loc),
Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uA)))))); -- abort status
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uO),
Parameter_Type =>
- New_Reference_To (Typ, Loc),
+ New_Occurrence_Of (Typ, Loc),
In_Present => True,
Out_Present => True),
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uF),
Parameter_Type =>
- New_Reference_To (Standard_Boolean, Loc)),
+ New_Occurrence_Of (Standard_Boolean, Loc)),
Make_Parameter_Specification (Loc, -- P
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uP),
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)),
+ New_Occurrence_Of (RTE (RE_Address), Loc)),
Make_Parameter_Specification (Loc, -- I
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uI),
Parameter_Type =>
- New_Reference_To (Standard_Integer, Loc)),
+ New_Occurrence_Of (Standard_Integer, Loc)),
Make_Parameter_Specification (Loc, -- A
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uA),
Parameter_Type =>
- New_Reference_To (Standard_Boolean, Loc))));
+ New_Occurrence_Of (Standard_Boolean, Loc))));
end Make_Disp_Requeue_Spec;
---------------------------------
New_List (
Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uF),
- Expression => New_Reference_To (Standard_False, Loc)))));
+ Expression => New_Occurrence_Of (Standard_False, Loc)))));
end if;
if Is_Concurrent_Record_Type (Typ) then
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_uI),
- Object_Definition => New_Reference_To (Standard_Integer, Loc)));
+ Object_Definition =>
+ New_Occurrence_Of (Standard_Integer, Loc)));
-- Generate:
-- C := Get_Prim_Op_Kind (tag! (<type>VP), S);
if Tagged_Type_Expansion then
Tag_Node :=
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Typ))), Loc));
else
Tag_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag);
end if;
Name => Make_Identifier (Loc, Name_uI),
Expression =>
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Entry_Index), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Entry_Index), Loc),
Parameter_Associations =>
New_List (
Tag_Node,
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Timed_Protected_Entry_Call), Loc),
Parameter_Associations =>
New_List (
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Protected_Entry_Index), Loc),
Expression =>
Make_Identifier (Loc, Name_uI)),
Append_To (Stmts,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Timed_Task_Entry_Call), Loc),
+ New_Occurrence_Of (RTE (RE_Timed_Task_Entry_Call), Loc),
Parameter_Associations =>
New_List (
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
- New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Task_Entry_Index), Loc),
Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uP), -- parameter block
Append_To (Stmts,
Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uF),
- Expression => New_Reference_To (Standard_False, Loc)));
+ Expression => New_Occurrence_Of (Standard_False, Loc)));
Append_To (Stmts,
Make_Assignment_Statement (Loc,
Name => Make_Identifier (Loc, Name_uC),
- Expression => New_Reference_To (RTE (RE_POK_Function), Loc)));
+ Expression => New_Occurrence_Of (RTE (RE_POK_Function), Loc)));
end if;
return
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uT),
Parameter_Type =>
- New_Reference_To (Typ, Loc),
+ New_Occurrence_Of (Typ, Loc),
In_Present => True,
Out_Present => True),
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uS),
Parameter_Type =>
- New_Reference_To (Standard_Integer, Loc)),
+ New_Occurrence_Of (Standard_Integer, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uP),
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)),
+ New_Occurrence_Of (RTE (RE_Address), Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uD),
Parameter_Type =>
- New_Reference_To (Standard_Duration, Loc)),
+ New_Occurrence_Of (Standard_Duration, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uM),
Parameter_Type =>
- New_Reference_To (Standard_Integer, Loc)),
+ New_Occurrence_Of (Standard_Integer, Loc)),
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uC),
Parameter_Type =>
- New_Reference_To (RTE (RE_Prim_Op_Kind), Loc),
+ New_Occurrence_Of (RTE (RE_Prim_Op_Kind), Loc),
Out_Present => True)));
Append_To (Params,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uF),
Parameter_Type =>
- New_Reference_To (Standard_Boolean, Loc),
+ New_Occurrence_Of (Standard_Boolean, Loc),
Out_Present => True));
return
New_Node :=
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Prim_Table (J), Loc),
+ Prefix => New_Occurrence_Of (Prim_Table (J), Loc),
Attribute_Name => Name_Unrestricted_Access));
else
New_Node := Make_Null (Loc);
Make_Subtype_Declaration (Loc,
Defining_Identifier => Make_Temporary (Loc, 'S'),
Subtype_Indication =>
- New_Reference_To (RTE (RE_Address_Array), Loc));
+ New_Occurrence_Of (RTE (RE_Address_Array), Loc));
Append_To (Result, Decl);
Defining_Identifier => Predef_Prims,
Constant_Present => Building_Static_DT (Typ),
Aliased_Present => True,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(Defining_Identifier (Decl), Loc),
Expression => New_Node));
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (Predef_Prims, Loc),
+ Name => New_Occurrence_Of (Predef_Prims, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
end;
if RTE_Record_Component_Available (RE_Signature) then
Append_To (DT_Aggr_List,
- New_Reference_To (RTE (RE_Secondary_DT), Loc));
+ New_Occurrence_Of (RTE (RE_Secondary_DT), Loc));
end if;
-- Tag_Kind
Append_To (DT_Aggr_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Predef_Prims, Loc),
+ Prefix => New_Occurrence_Of (Predef_Prims, Loc),
Attribute_Name => Name_Address));
-- Note: The correct value of Offset_To_Top will be set by the init
-- No OSD table required
Append_To (DT_Aggr_List,
- New_Reference_To (RTE (RE_Null_Address), Loc));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc));
else
OSD_Aggr_List := New_List;
Object_Definition =>
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Object_Specific_Data), Loc),
+ New_Occurrence_Of (RTE (RE_Object_Specific_Data), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => New_List (
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (OSD, Loc),
+ Name => New_Occurrence_Of (OSD, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
-- In secondary dispatch tables the Typeinfo component contains
Append_To (DT_Aggr_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (OSD, Loc),
+ Prefix => New_Occurrence_Of (OSD, Loc),
Attribute_Name => Name_Address));
end if;
New_Node :=
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Prim_Table (J), Loc),
+ Prefix => New_Occurrence_Of (Prim_Table (J), Loc),
Attribute_Name => Name_Unrestricted_Access));
else
Object_Definition =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To
+ Subtype_Mark => New_Occurrence_Of
(RTE (RE_Dispatch_Table_Wrapper), Loc),
Constraint => Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => DT_Constr_List)),
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (Iface_DT, Loc),
+ Name => New_Occurrence_Of (Iface_DT, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
if Exporting_Table then
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Interface_Tag), Loc),
+ New_Occurrence_Of (RTE (RE_Interface_Tag), Loc),
Expression =>
Unchecked_Convert_To (RTE (RE_Interface_Tag),
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Iface_DT, Loc),
+ Prefix => New_Occurrence_Of (Iface_DT, Loc),
Selector_Name =>
New_Occurrence_Of
(RTE_Record_Component (RE_Prims_Ptr), Loc)),
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Address), Loc),
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (Iface_DT, Loc),
+ Prefix => New_Occurrence_Of (Iface_DT, Loc),
Selector_Name =>
New_Occurrence_Of
(RTE_Record_Component (RE_Predef_Prims), Loc)),
Make_Object_Declaration (Loc,
Defining_Identifier => Node (First_Elmt
(Access_Disp_Table (Typ))),
- Object_Definition => New_Reference_To (RTE (RE_Tag), Loc),
+ Object_Definition => New_Occurrence_Of (RTE (RE_Tag), Loc),
Constant_Present => True,
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To (RTE (RE_Null_Address), Loc))));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc))));
Analyze_List (Result, Suppress => All_Checks);
Error_Msg_CRT ("tagged types", Typ);
Aliased_Present => True,
Constant_Present => False,
Object_Definition =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_No_Dispatch_Table_Wrapper), Loc)));
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (DT, Loc),
+ Name => New_Occurrence_Of (DT, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
Append_To (Result,
Make_Object_Declaration (Loc,
Defining_Identifier => DT_Ptr,
- Object_Definition => New_Reference_To (RTE (RE_Tag), Loc),
+ Object_Definition => New_Occurrence_Of (RTE (RE_Tag), Loc),
Constant_Present => True,
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (DT, Loc),
+ Prefix => New_Occurrence_Of (DT, Loc),
Selector_Name =>
New_Occurrence_Of
(RTE_Record_Component (RE_NDT_Prims_Ptr), Loc)),
Object_Definition =>
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Dispatch_Table_Wrapper), Loc),
+ New_Occurrence_Of (RTE (RE_Dispatch_Table_Wrapper), Loc),
Constraint => Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => DT_Constr_List))));
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (DT, Loc),
+ Name => New_Occurrence_Of (DT, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
Append_To (Result,
Make_Object_Declaration (Loc,
Defining_Identifier => DT_Ptr,
- Object_Definition => New_Reference_To (RTE (RE_Tag), Loc),
+ Object_Definition => New_Occurrence_Of (RTE (RE_Tag), Loc),
Constant_Present => True,
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (DT, Loc),
+ Prefix => New_Occurrence_Of (DT, Loc),
Selector_Name =>
New_Occurrence_Of
(RTE_Record_Component (RE_Prims_Ptr), Loc)),
Defining_Identifier =>
Node (Next_Elmt (First_Elmt (Access_Disp_Table (Typ)))),
Constant_Present => True,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(RTE (RE_Address), Loc),
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (DT, Loc),
+ Prefix => New_Occurrence_Of (DT, Loc),
Selector_Name =>
New_Occurrence_Of
(RTE_Record_Component (RE_Predef_Prims), Loc)),
Make_Object_Declaration (Loc,
Defining_Identifier => Exname,
Constant_Present => True,
- Object_Definition => New_Reference_To (Standard_String, Loc),
+ Object_Definition => New_Occurrence_Of (Standard_String, Loc),
Expression =>
Make_String_Literal (Loc,
Fully_Qualified_Name_String (First_Subtype (Typ)))));
Append_To (Result,
Make_Object_Declaration (Loc,
Defining_Identifier => HT_Link,
- Object_Definition => New_Reference_To (RTE (RE_Tag), Loc)));
+ Object_Definition => New_Occurrence_Of (RTE (RE_Tag), Loc)));
end if;
-- Generate code to create the storage for the type specific data object
else
Append_To (TSD_Aggr_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Alignment));
end if;
Append_To (TSD_Aggr_List,
Unchecked_Convert_To (RTE (RE_Cstring_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Exname, Loc),
+ Prefix => New_Occurrence_Of (Exname, Loc),
Attribute_Name => Name_Address)));
-- External_Tag of a local tagged type
Make_Object_Declaration (Loc,
Defining_Identifier => Exname,
Constant_Present => True,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(Standard_String, Loc),
Expression =>
Make_Op_Concat (Loc,
Left_Opnd =>
Make_Function_Call (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Address_Image), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Address),
- New_Reference_To (DT_Ptr, Loc)))),
+ New_Occurrence_Of (DT_Ptr, Loc)))),
Right_Opnd =>
Make_String_Literal (Loc, Str2_Id)))));
Make_Object_Declaration (Loc,
Defining_Identifier => Exname,
Constant_Present => True,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(Standard_String, Loc),
Expression =>
Make_Op_Concat (Loc,
New_Node :=
Unchecked_Convert_To (RTE (RE_Cstring_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Exname, Loc),
+ Prefix => New_Occurrence_Of (Exname, Loc),
Attribute_Name => Name_Address));
end;
New_Node :=
Unchecked_Convert_To (RTE (RE_Cstring_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Exname, Loc),
+ Prefix => New_Occurrence_Of (Exname, Loc),
Attribute_Name => Name_Address));
else
Old_Val := Strval (Expr_Value_S (Expression (Def)));
Defining_Identifier => E,
Constant_Present => True,
Object_Definition =>
- New_Reference_To (Standard_String, Loc),
+ New_Occurrence_Of (Standard_String, Loc),
Expression =>
Make_String_Literal (Loc, New_Val)));
New_Node :=
Unchecked_Convert_To (RTE (RE_Cstring_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (E, Loc),
+ Prefix => New_Occurrence_Of (E, Loc),
Attribute_Name => Name_Address));
end if;
end;
Append_To (TSD_Aggr_List,
Unchecked_Convert_To (RTE (RE_Tag_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (HT_Link, Loc),
+ Prefix => New_Occurrence_Of (HT_Link, Loc),
Attribute_Name => Name_Address)));
else
Append_To (TSD_Aggr_List,
Unchecked_Convert_To (RTE (RE_Tag_Ptr),
- New_Reference_To (RTE (RE_Null_Address), Loc)));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc)));
end if;
-- Transportable: Set for types that can be used in remote calls
if not Building_Static_DT (Typ) or else not Has_DT (Typ) then
Append_To (TSD_Aggr_List,
Unchecked_Convert_To (RTE (RE_Size_Ptr),
- New_Reference_To (RTE (RE_Null_Address), Loc)));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc)));
else
declare
if Is_Abstract_Subprogram (Prim) then
Size_Comp :=
Unchecked_Convert_To (RTE (RE_Size_Ptr),
- New_Reference_To (RTE (RE_Null_Address), Loc));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc));
else
Size_Comp :=
Unchecked_Convert_To (RTE (RE_Size_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Prim, Loc),
+ Prefix => New_Occurrence_Of (Prim, Loc),
Attribute_Name => Name_Unrestricted_Access));
end if;
while Present (AI) loop
if Is_Ancestor (Node (AI), Typ, Use_Full_View => True) then
Sec_DT_Tag :=
- New_Reference_To (DT_Ptr, Loc);
+ New_Occurrence_Of (DT_Ptr, Loc);
else
Elmt :=
Next_Elmt
and then not
Has_Thunks (Node (Next_Elmt (Next_Elmt (Elmt)))));
Sec_DT_Tag :=
- New_Reference_To (Node (Next_Elmt (Next_Elmt (Elmt))),
+ New_Occurrence_Of (Node (Next_Elmt (Next_Elmt (Elmt))),
Loc);
end if;
-- Iface_Tag
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Node (AI)))),
Loc)),
-- Static_Offset_To_Top
- New_Reference_To (Standard_True, Loc),
+ New_Occurrence_Of (Standard_True, Loc),
-- Offset_To_Top_Value
Object_Definition =>
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Interface_Data), Loc),
+ New_Occurrence_Of (RTE (RE_Interface_Data), Loc),
Constraint => Make_Index_Or_Discriminant_Constraint
(Loc,
Constraints => New_List (
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (ITable, Loc),
+ Name => New_Occurrence_Of (ITable, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
Iface_Table_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (ITable, Loc),
+ Prefix => New_Occurrence_Of (ITable, Loc),
Attribute_Name => Name_Unchecked_Access);
end;
end if;
Aliased_Present => True,
Object_Definition =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (
+ Subtype_Mark => New_Occurrence_Of (
RTE (RE_Select_Specific_Data), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (SSD, Loc),
+ Name => New_Occurrence_Of (SSD, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
-- This table is initialized by Make_Select_Specific_Data_Table,
Append_To (TSD_Aggr_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (SSD, Loc),
+ Prefix => New_Occurrence_Of (SSD, Loc),
Attribute_Name => Name_Unchecked_Access));
else
Append_To (TSD_Aggr_List, Make_Null (Loc));
then
Append_To (TSD_Tags_List,
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To (RTE (RE_Null_Address), Loc)));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc)));
-- Otherwise we can safely reference the tag
else
Append_To (TSD_Tags_List,
- New_Reference_To (DT_Ptr, Loc));
+ New_Occurrence_Of (DT_Ptr, Loc));
end if;
-- Fill the rest of the table with the tags of the ancestors
Append_To (TSD_Tags_List,
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To (RTE (RE_Null_Address), Loc)));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc)));
else
Append_To (TSD_Tags_List,
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Parent_Typ))),
Loc));
end if;
Constant_Present => Building_Static_DT (Typ),
Object_Definition =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (
+ Subtype_Mark => New_Occurrence_Of (
RTE (RE_Type_Specific_Data), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (TSD, Loc),
+ Name => New_Occurrence_Of (TSD, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (RTE (RE_Integer_Address), Loc),
+ Prefix => New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
-- Initialize or declare the dispatch table object
New_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (TSD, Loc),
+ Prefix => New_Occurrence_Of (TSD, Loc),
Attribute_Name => Name_Address);
Append_To (DT_Constr_List, New_Node);
if not Building_Static_DT (Typ) then
Append_To (Result,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (DT, Loc),
+ Name => New_Occurrence_Of (DT, Loc),
Expression => Make_Aggregate (Loc,
Expressions => DT_Aggr_List)));
Aliased_Present => True,
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_No_Dispatch_Table_Wrapper), Loc),
+ New_Occurrence_Of (RTE (RE_No_Dispatch_Table_Wrapper), Loc),
Expression => Make_Aggregate (Loc,
Expressions => DT_Aggr_List)));
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (DT, Loc),
+ Name => New_Occurrence_Of (DT, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
Export_DT (Typ, DT);
New_Node :=
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Prim_Table (J), Loc),
+ Prefix => New_Occurrence_Of (Prim_Table (J), Loc),
Attribute_Name => Name_Unrestricted_Access));
else
New_Node := Make_Null (Loc);
Make_Subtype_Declaration (Loc,
Defining_Identifier => Make_Temporary (Loc, 'S'),
Subtype_Indication =>
- New_Reference_To (RTE (RE_Address_Array), Loc));
+ New_Occurrence_Of (RTE (RE_Address_Array), Loc));
Append_To (Result, Decl);
Defining_Identifier => Predef_Prims,
Aliased_Present => True,
Constant_Present => Building_Static_DT (Typ),
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(Defining_Identifier (Decl), Loc),
Expression => New_Node));
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (Predef_Prims, Loc),
+ Name => New_Occurrence_Of (Predef_Prims, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
end;
end;
if RTE_Record_Component_Available (RE_Signature) then
Append_To (DT_Aggr_List,
- New_Reference_To (RTE (RE_Primary_DT), Loc));
+ New_Occurrence_Of (RTE (RE_Primary_DT), Loc));
end if;
-- Tag_Kind
Append_To (DT_Aggr_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Predef_Prims, Loc),
+ Prefix => New_Occurrence_Of (Predef_Prims, Loc),
Attribute_Name => Name_Address));
-- Offset_To_Top
Append_To (DT_Aggr_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (TSD, Loc),
+ Prefix => New_Occurrence_Of (TSD, Loc),
Attribute_Name => Name_Address));
-- Stage 2: Initialize the table of user-defined primitive operations
New_Node :=
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Prim_Table (J), Loc),
+ Prefix => New_Occurrence_Of (Prim_Table (J), Loc),
Attribute_Name => Name_Unrestricted_Access));
else
New_Node := Make_Null (Loc);
if not Building_Static_DT (Typ) then
Append_To (Result,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (DT, Loc),
+ Name => New_Occurrence_Of (DT, Loc),
Expression => Make_Aggregate (Loc,
Expressions => DT_Aggr_List)));
Constant_Present => True,
Object_Definition =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To
+ Subtype_Mark => New_Occurrence_Of
(RTE (RE_Dispatch_Table_Wrapper), Loc),
Constraint => Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => DT_Constr_List)),
Append_To (Result,
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (DT, Loc),
+ Name => New_Occurrence_Of (DT, Loc),
Chars => Name_Alignment,
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (RTE (RE_Integer_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Integer_Address), Loc),
Attribute_Name => Name_Alignment)));
Export_DT (Typ, DT);
Prefix =>
Make_Selected_Component (Loc,
Prefix =>
- New_Reference_To (TSD, Loc),
+ New_Occurrence_Of (TSD, Loc),
Selector_Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE_Record_Component (RE_Tags_Table), Loc)),
Expressions =>
New_List (Make_Integer_Literal (Loc, 0))),
Expression =>
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Typ))), Loc)));
end if;
Append_To (Elab_Code,
Build_Inherit_Predefined_Prims (Loc,
Old_Tag_Node =>
- New_Reference_To
+ New_Occurrence_Of
(Node
(Next_Elmt
(First_Elmt
(Access_Disp_Table (Parent_Typ)))), Loc),
New_Tag_Node =>
- New_Reference_To
+ New_Occurrence_Of
(Node
(Next_Elmt
(First_Elmt
Build_Inherit_Prims (Loc,
Typ => Typ,
Old_Tag_Node =>
- New_Reference_To
+ New_Occurrence_Of
(Node
(First_Elmt
(Access_Disp_Table (Parent_Typ))), Loc),
- New_Tag_Node => New_Reference_To (DT_Ptr, Loc),
+ New_Tag_Node => New_Occurrence_Of (DT_Ptr, Loc),
Num_Prims => Nb_Prims));
end if;
end;
Build_Inherit_Predefined_Prims (Loc,
Old_Tag_Node =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node
(Next_Elmt (Sec_DT_Ancestor)),
Loc)),
New_Tag_Node =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (Next_Elmt (Sec_DT_Typ)),
Loc))));
Old_Tag_Node =>
Unchecked_Convert_To
(RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (Sec_DT_Ancestor),
Loc)),
New_Tag_Node =>
Unchecked_Convert_To
(RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (Sec_DT_Typ), Loc)),
Num_Prims => Num_Prims));
end if;
Build_Inherit_Predefined_Prims (Loc,
Old_Tag_Node =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node
(Next_Elmt (Sec_DT_Ancestor)),
Loc)),
New_Tag_Node =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (Next_Elmt (Sec_DT_Typ)),
Loc))));
Old_Tag_Node =>
Unchecked_Convert_To
(RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (Sec_DT_Ancestor),
Loc)),
New_Tag_Node =>
Unchecked_Convert_To
(RTE (RE_Tag),
- New_Reference_To
+ New_Occurrence_Of
(Node (Sec_DT_Typ), Loc)),
Num_Prims => Num_Prims));
end if;
then
Append_To (Elab_Code,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Check_TSD), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Check_TSD), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (TSD, Loc),
+ Prefix => New_Occurrence_Of (TSD, Loc),
Attribute_Name => Name_Unchecked_Access))));
end if;
then
Append_To (Elab_Code,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Register_Tag), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Register_Tag), Loc),
Parameter_Associations =>
- New_List (New_Reference_To (DT_Ptr, Loc))));
+ New_List (New_Occurrence_Of (DT_Ptr, Loc))));
end if;
if not Is_Empty_List (Elab_Code) then
Object_Definition =>
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Object_Specific_Data), Loc),
+ New_Occurrence_Of (RTE (RE_Object_Specific_Data), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => New_List (
return
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (OSD, Loc),
+ Prefix => New_Occurrence_Of (OSD, Loc),
Attribute_Name => Name_Unchecked_Access);
end if;
end Make_OSD;
else
Append_To (TSD_Aggr_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Alignment));
end if;
-- Iface_Tag
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Iface, Loc),
+ Prefix => New_Occurrence_Of (Iface, Loc),
Attribute_Name => Name_Tag),
-- OSD
Object_Definition =>
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Interface_Data), Loc),
+ New_Occurrence_Of (RTE (RE_Interface_Data), Loc),
Constraint => Make_Index_Or_Discriminant_Constraint
(Loc,
Constraints => New_List (
Iface_Table_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (ITable, Loc),
+ Prefix => New_Occurrence_Of (ITable, Loc),
Attribute_Name => Name_Unchecked_Access);
end;
end if;
Aliased_Present => True,
Object_Definition =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (
+ Subtype_Mark => New_Occurrence_Of (
RTE (RE_Select_Specific_Data), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Append_To (TSD_Aggr_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (SSD, Loc),
+ Prefix => New_Occurrence_Of (SSD, Loc),
Attribute_Name => Name_Unchecked_Access));
else
Append_To (TSD_Aggr_List, Make_Null (Loc));
Append_To (TSD_Tags_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag));
-- Fill the rest of the table with the tags of the ancestors
Append_To (TSD_Tags_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Parent_Typ, Loc),
+ Prefix => New_Occurrence_Of (Parent_Typ, Loc),
Attribute_Name => Name_Tag));
Pos := Pos + 1;
Constant_Present => True,
Object_Definition =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (
+ Subtype_Mark => New_Occurrence_Of (
RTE (RE_Type_Specific_Data), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
then
Append_To (Result,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Check_TSD), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Check_TSD), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (TSD, Loc),
+ Prefix => New_Occurrence_Of (TSD, Loc),
Attribute_Name => Name_Unrestricted_Access))));
end if;
Append_To (Result,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Register_TSD), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Register_TSD), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (TSD, Loc),
+ Prefix => New_Occurrence_Of (TSD, Loc),
Attribute_Name => Name_Unrestricted_Access))));
-- Populate the two auxiliary tables used for dispatching asynchronous,
if Tagged_Type_Expansion then
Tag_Node :=
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Typ))), Loc);
else
Tag_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag);
end if;
Append_To (Assignments,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Set_Prim_Op_Kind), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Set_Prim_Op_Kind), Loc),
Parameter_Associations => New_List (
Tag_Node,
Make_Integer_Literal (Loc, Prim_Pos),
if Tagged_Type_Expansion then
Tag_Node :=
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Typ))), Loc);
else
Tag_Node :=
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag);
end if;
Append_To (Assignments,
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Set_Entry_Index), Loc),
+ New_Occurrence_Of (RTE (RE_Set_Entry_Index), Loc),
Parameter_Associations => New_List (
Tag_Node,
Make_Integer_Literal (Loc, Prim_Pos),
Aliased_Present => True,
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_No_Dispatch_Table_Wrapper), Loc)));
+ New_Occurrence_Of
+ (RTE (RE_No_Dispatch_Table_Wrapper), Loc)));
else
-- Calculate the number of primitives of the dispatch table and
Object_Definition =>
Make_Subtype_Indication (Loc,
Subtype_Mark =>
- New_Reference_To (RTE (RE_Dispatch_Table_Wrapper), Loc),
+ New_Occurrence_Of (RTE (RE_Dispatch_Table_Wrapper), Loc),
Constraint => Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => DT_Constr_List))));
end if;
Append_To (Result,
Make_Object_Declaration (Loc,
Defining_Identifier => DT_Ptr,
- Object_Definition => New_Reference_To (RTE (RE_Tag), Loc),
+ Object_Definition => New_Occurrence_Of (RTE (RE_Tag), Loc),
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To (RTE (RE_Null_Address), Loc))));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc))));
Set_Is_Statically_Allocated (DT_Ptr,
Is_Library_Level_Tagged_Type (Typ));
Make_Object_Declaration (Loc,
Defining_Identifier => DT_Ptr,
Constant_Present => True,
- Object_Definition => New_Reference_To (RTE (RE_Tag), Loc),
+ Object_Definition =>
+ New_Occurrence_Of (RTE (RE_Tag), Loc),
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (DT, Loc),
+ Prefix => New_Occurrence_Of (DT, Loc),
Selector_Name =>
New_Occurrence_Of
(RTE_Record_Component (RE_Prims_Ptr), Loc)),
Defining_Identifier => Predef_Prims_Ptr,
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Address), Loc),
Expression =>
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (DT, Loc),
+ Prefix => New_Occurrence_Of (DT, Loc),
Selector_Name =>
New_Occurrence_Of
(RTE_Record_Component (RE_Predef_Prims), Loc)),
Make_Object_Declaration (Loc,
Defining_Identifier => DT_Ptr,
Constant_Present => True,
- Object_Definition => New_Reference_To (RTE (RE_Tag), Loc),
+ Object_Definition =>
+ New_Occurrence_Of (RTE (RE_Tag), Loc),
Expression =>
Unchecked_Convert_To (RTE (RE_Tag),
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (DT, Loc),
+ Prefix => New_Occurrence_Of (DT, Loc),
Selector_Name =>
New_Occurrence_Of
(RTE_Record_Component (RE_NDT_Prims_Ptr),
Append_To (Result,
Make_Object_Declaration (Loc,
Defining_Identifier => Iface_DT_Ptr,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(RTE (RE_Interface_Tag), Loc),
Expression =>
Unchecked_Convert_To (RTE (RE_Interface_Tag),
- New_Reference_To (RTE (RE_Null_Address), Loc))));
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc))));
Set_Is_Statically_Allocated (Iface_DT_Ptr,
Is_Library_Level_Tagged_Type (Typ));
Make_Object_Declaration (Loc,
Defining_Identifier => Iface_DT_Ptr,
Constant_Present => True,
- Object_Definition => New_Reference_To
+ Object_Definition => New_Occurrence_Of
(RTE (RE_Interface_Tag), Loc),
Expression =>
Unchecked_Convert_To (RTE (RE_Interface_Tag),
Prefix =>
Make_Selected_Component (Loc,
Prefix =>
- New_Reference_To (Iface_DT, Loc),
+ New_Occurrence_Of (Iface_DT, Loc),
Selector_Name =>
New_Occurrence_Of
(RTE_Record_Component (RE_Prims_Ptr),
Component_Definition =>
Make_Component_Definition (Loc,
Subtype_Indication =>
- New_Reference_To (RTE (RE_Prim_Ptr), Loc)))));
+ New_Occurrence_Of (RTE (RE_Prim_Ptr), Loc)))));
Append_To (Result,
Make_Full_Type_Declaration (Loc,
-- Protected function
if Ekind (Full_Typ) = E_Protected_Type then
- return New_Reference_To (RTE (RE_POK_Protected_Function), Loc);
+ return New_Occurrence_Of (RTE (RE_POK_Protected_Function), Loc);
-- Task function
elsif Ekind (Full_Typ) = E_Task_Type then
- return New_Reference_To (RTE (RE_POK_Task_Function), Loc);
+ return New_Occurrence_Of (RTE (RE_POK_Task_Function), Loc);
-- Regular function
else
- return New_Reference_To (RTE (RE_POK_Function), Loc);
+ return New_Occurrence_Of (RTE (RE_POK_Function), Loc);
end if;
else
if Is_Primitive_Wrapper (Prim_Op)
and then Ekind (Wrapped_Entity (Prim_Op)) = E_Entry
then
- return New_Reference_To (RTE (RE_POK_Protected_Entry), Loc);
+ return New_Occurrence_Of (RTE (RE_POK_Protected_Entry), Loc);
-- Protected procedure
else
- return New_Reference_To (RTE (RE_POK_Protected_Procedure), Loc);
+ return
+ New_Occurrence_Of (RTE (RE_POK_Protected_Procedure), Loc);
end if;
elsif Ekind (Full_Typ) = E_Task_Type then
if Is_Primitive_Wrapper (Prim_Op)
and then Ekind (Wrapped_Entity (Prim_Op)) = E_Entry
then
- return New_Reference_To (RTE (RE_POK_Task_Entry), Loc);
+ return New_Occurrence_Of (RTE (RE_POK_Task_Entry), Loc);
-- Task "procedure". These are the internally Expander-generated
-- procedures (task body for instance).
else
- return New_Reference_To (RTE (RE_POK_Task_Procedure), Loc);
+ return New_Occurrence_Of (RTE (RE_POK_Task_Procedure), Loc);
end if;
-- Regular procedure
else
- return New_Reference_To (RTE (RE_POK_Procedure), Loc);
+ return New_Occurrence_Of (RTE (RE_POK_Procedure), Loc);
end if;
end if;
end Prim_Op_Kind;
Append_To (L,
Build_Set_Predefined_Prim_Op_Address (Loc,
- Tag_Node => New_Reference_To (DT_Ptr, Loc),
+ Tag_Node => New_Occurrence_Of (DT_Ptr, Loc),
Position => Pos,
Address_Node =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Prim, Loc),
+ Prefix => New_Occurrence_Of (Prim, Loc),
Attribute_Name => Name_Unrestricted_Access))));
-- Register copy of the pointer to the 'size primitive in the TSD
DT_Ptr := Node (First_Elmt (Access_Disp_Table (Tag_Typ)));
Append_To (L,
Build_Set_Size_Function (Loc,
- Tag_Node => New_Reference_To (DT_Ptr, Loc),
+ Tag_Node => New_Occurrence_Of (DT_Ptr, Loc),
Size_Func => Prim));
end if;
Append_To (L,
Build_Set_Prim_Op_Address (Loc,
Typ => Tag_Typ,
- Tag_Node => New_Reference_To (DT_Ptr, Loc),
+ Tag_Node => New_Occurrence_Of (DT_Ptr, Loc),
Position => Pos,
Address_Node =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Prim, Loc),
+ Prefix => New_Occurrence_Of (Prim, Loc),
Attribute_Name => Name_Unrestricted_Access))));
end if;
end if;
Append_To (L,
Build_Set_Predefined_Prim_Op_Address (Loc,
Tag_Node =>
- New_Reference_To (Node (Next_Elmt (Iface_DT_Elmt)), Loc),
+ New_Occurrence_Of (Node (Next_Elmt (Iface_DT_Elmt)), Loc),
Position => Pos,
Address_Node =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Thunk_Id, Loc),
+ Prefix => New_Occurrence_Of (Thunk_Id, Loc),
Attribute_Name => Name_Unrestricted_Access))));
Next_Elmt (Iface_DT_Elmt);
Append_To (L,
Build_Set_Predefined_Prim_Op_Address (Loc,
Tag_Node =>
- New_Reference_To (Node (Next_Elmt (Iface_DT_Elmt)), Loc),
+ New_Occurrence_Of (Node (Next_Elmt (Iface_DT_Elmt)), Loc),
Position => Pos,
Address_Node =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Alias (Prim), Loc),
+ New_Occurrence_Of (Alias (Prim), Loc),
Attribute_Name => Name_Unrestricted_Access))));
else
Append_To (L,
Build_Set_Prim_Op_Address (Loc,
Typ => Iface_Typ,
- Tag_Node => New_Reference_To (Iface_DT_Ptr, Loc),
+ Tag_Node => New_Occurrence_Of (Iface_DT_Ptr, Loc),
Position => Pos,
Address_Node =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Thunk_Id, Loc),
+ Prefix => New_Occurrence_Of (Thunk_Id, Loc),
Attribute_Name => Name_Unrestricted_Access))));
Next_Elmt (Iface_DT_Elmt);
Append_To (L,
Build_Set_Prim_Op_Address (Loc,
Typ => Iface_Typ,
- Tag_Node => New_Reference_To (Iface_DT_Ptr, Loc),
+ Tag_Node => New_Occurrence_Of (Iface_DT_Ptr, Loc),
Position => Pos,
Address_Node =>
Unchecked_Convert_To (RTE (RE_Prim_Ptr),
Make_Attribute_Reference (Loc,
Prefix =>
- New_Reference_To (Alias (Prim), Loc),
+ New_Occurrence_Of (Alias (Prim), Loc),
Attribute_Name => Name_Unrestricted_Access))));
end if;
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uInit),
- Parameter_Type => New_Reference_To (Typ, Loc)));
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)));
if Present (Parameter_Specifications (Parent (E))) then
P := First (Parameter_Specifications (Parent (E)));
P := First (Parms);
while Present (P) loop
Append_To (Actuals,
- New_Reference_To (Defining_Identifier (P), Loc));
+ New_Occurrence_Of (Defining_Identifier (P), Loc));
Next (P);
end loop;
Append_To (Body_Stmts,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Constructor_Id, Loc),
+ Name => New_Occurrence_Of (Constructor_Id, Loc),
Parameter_Associations => Actuals));
end;
Append_To (Init_Tags_List,
Make_Assignment_Statement (Loc,
Name =>
- New_Reference_To (Node (Tag_Elmt), Loc),
+ New_Occurrence_Of (Node (Tag_Elmt), Loc),
Expression =>
Make_Selected_Component (Loc,
Prefix =>
Make_Identifier (Loc, Name_uInit),
Selector_Name =>
- New_Reference_To (Tag_Comp, Loc))));
+ New_Occurrence_Of (Tag_Comp, Loc))));
Tag_Comp := Next_Tag_Component (Tag_Comp);
Next_Elmt (Tag_Elmt);
Condition =>
Make_Op_Eq (Loc,
Left_Opnd =>
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table (Typ))),
Loc),
Right_Opnd =>
Unchecked_Convert_To (RTE (RE_Tag),
- New_Reference_To (RTE (RE_Null_Address), Loc))),
+ New_Occurrence_Of (RTE (RE_Null_Address), Loc))),
Then_Statements => Init_Tags_List));
IP_Body :=
Body_Stmts := New_List (
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (Covers_Default_Constructor, Loc),
+ New_Occurrence_Of (Covers_Default_Constructor, Loc),
Parameter_Associations => New_List (
Make_Identifier (Loc, Name_uInit))));
Make_Parameter_Specification (Loc,
Defining_Identifier =>
Make_Defining_Identifier (Loc, Name_uInit),
- Parameter_Type => New_Reference_To (Typ, Loc)))),
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)))),
Declarations => No_List,
if Is_Abstract_Type (T) then
if Is_Limited_Record (T) then
- return New_Reference_To (RTE (RE_TK_Abstract_Limited_Tagged), Loc);
+ return New_Occurrence_Of
+ (RTE (RE_TK_Abstract_Limited_Tagged), Loc);
else
- return New_Reference_To (RTE (RE_TK_Abstract_Tagged), Loc);
+ return New_Occurrence_Of
+ (RTE (RE_TK_Abstract_Tagged), Loc);
end if;
-- Concurrent kinds
end if;
if Ekind (Conc_Typ) = E_Protected_Type then
- return New_Reference_To (RTE (RE_TK_Protected), Loc);
+ return New_Occurrence_Of (RTE (RE_TK_Protected), Loc);
else
pragma Assert (Ekind (Conc_Typ) = E_Task_Type);
- return New_Reference_To (RTE (RE_TK_Task), Loc);
+ return New_Occurrence_Of (RTE (RE_TK_Task), Loc);
end if;
-- Regular tagged kinds
else
if Is_Limited_Record (T) then
- return New_Reference_To (RTE (RE_TK_Limited_Tagged), Loc);
+ return New_Occurrence_Of (RTE (RE_TK_Limited_Tagged), Loc);
else
- return New_Reference_To (RTE (RE_TK_Tagged), Loc);
+ return New_Occurrence_Of (RTE (RE_TK_Tagged), Loc);
end if;
end if;
end Tagged_Kind;
elsif Is_Floating_Point_Type (Rtyp) then
Append_To (Arg_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Digits));
-- For ordinary fixed-point types, append Aft parameter
elsif Is_Ordinary_Fixed_Point_Type (Rtyp) then
Append_To (Arg_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Aft));
if Has_Decimal_Small (Rtyp) then
elsif Is_Decimal_Fixed_Point_Type (Rtyp) then
Append_To (Arg_List,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Scale));
Set_Conversion_OK (First (Arg_List));
elsif Rtyp = Standard_Wide_Character then
Append_To (Arg_List,
- New_Reference_To (Boolean_Literals (Ada_Version >= Ada_2005), Loc));
+ New_Occurrence_Of
+ (Boolean_Literals (Ada_Version >= Ada_2005), Loc));
end if;
-- Now append the procedure call to the insert list
Append_To (Ins_List,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Proc_Ent, Loc),
+ Name => New_Occurrence_Of (Proc_Ent, Loc),
Parameter_Associations => Arg_List));
-- Insert declarations of Snn, Pnn, and the procedure call. We suppress
Append_To (Args,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Scale));
Rewrite (N,
OK_Convert_To (Btyp,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (Vid), Loc),
+ Name => New_Occurrence_Of (RTE (Vid), Loc),
Parameter_Associations => Args)));
Set_Etype (N, Btyp);
then
Rewrite (N,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Btyp, Loc),
+ Prefix => New_Occurrence_Of (Btyp, Loc),
Attribute_Name => Name_Val,
Expressions => New_List (
Make_Attribute_Reference (Loc,
Rewrite (N,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Val,
Expressions => New_List (
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (Func), Loc),
+ New_Occurrence_Of (RTE (Func), Loc),
Parameter_Associations => Args))));
Analyze_And_Resolve (N, Btyp);
Rewrite (N,
Convert_To (Btyp,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (Vid), Loc),
+ Name => New_Occurrence_Of (RTE (Vid), Loc),
Parameter_Associations => Args)));
end if;
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_String_To_Wide_String), Loc),
+ New_Occurrence_Of (RTE (RE_String_To_Wide_String), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => Prefix (N),
Attribute_Name => Name_Image,
Expressions => Expressions (N)),
- New_Reference_To (Rnn, Loc),
- New_Reference_To (Lnn, Loc),
+ New_Occurrence_Of (Rnn, Loc),
+ New_Occurrence_Of (Lnn, Loc),
Make_Integer_Literal (Loc,
Intval => Int (Wide_Character_Encoding_Method))))),
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_String_To_Wide_Wide_String), Loc),
+ New_Occurrence_Of (RTE (RE_String_To_Wide_Wide_String), Loc),
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
Prefix => Prefix (N),
Attribute_Name => Name_Image,
Expressions => Expressions (N)),
- New_Reference_To (Rnn, Loc),
- New_Reference_To (Lnn, Loc),
+ New_Occurrence_Of (Rnn, Loc),
+ New_Occurrence_Of (Lnn, Loc),
Make_Integer_Literal (Loc,
Intval => Int (Wide_Character_Encoding_Method))))),
Make_Op_Gt (Loc,
Left_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_First),
Right_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Last)),
Make_Integer_Literal (Loc, 0),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Base_Type (Ptyp), Loc),
+ Prefix => New_Occurrence_Of (Base_Type (Ptyp), Loc),
Attribute_Name => Name_Width))));
Analyze_And_Resolve (N, Typ);
Attribute_Name => Name_Address),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Pos,
Expressions => New_List (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_First))),
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Pos,
Expressions => New_List (
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Last))));
Rewrite (N,
Convert_To (Typ,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (XX), Loc),
+ Name => New_Occurrence_Of (RTE (XX), Loc),
Parameter_Associations => Arglist)));
Analyze_And_Resolve (N, Typ);
Arglist := New_List (
Convert_To (YY,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_First)),
Convert_To (YY,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Ptyp, Loc),
+ Prefix => New_Occurrence_Of (Ptyp, Loc),
Attribute_Name => Name_Last)));
Rewrite (N,
Convert_To (Typ,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (XX), Loc),
+ Name => New_Occurrence_Of (RTE (XX), Loc),
Parameter_Associations => Arglist)));
Analyze_And_Resolve (N, Typ);
declare
Fname : constant Node_Id :=
- New_Reference_To (RTE (RE_Secondary_Tag), Loc);
+ New_Occurrence_Of (RTE (RE_Secondary_Tag), Loc);
begin
pragma Assert (not Is_Interface (Etype (Tag_Arg)));
Make_Object_Declaration (Loc,
Defining_Identifier => Make_Temporary (Loc, 'V'),
Object_Definition =>
- New_Reference_To (RTE (RE_Tag), Loc),
+ New_Occurrence_Of (RTE (RE_Tag), Loc),
Expression =>
Make_Function_Call (Loc,
Name => Fname,
Parameter_Associations => New_List (
Relocate_Node (Tag_Arg),
- New_Reference_To
+ New_Occurrence_Of
(Node (First_Elmt (Access_Disp_Table
(Etype (Etype (Act_Constr))))),
Loc))));
Build_CW_Membership (Loc,
Obj_Tag_Node => Obj_Tag_Node,
Typ_Tag_Node =>
- New_Reference_To (
+ New_Occurrence_Of (
Node (First_Elmt (Access_Disp_Table (
Root_Type (Result_Typ)))), Loc),
Related_Nod => N,
Prefix => New_Copy_Tree (Tag_Arg),
Attribute_Name => Name_Address),
- New_Reference_To (
+ New_Occurrence_Of (
Node (First_Elmt (Access_Disp_Table (
Root_Type (Result_Typ)))), Loc)))),
Then_Statements =>
Set_Expression (Free_Node,
Unchecked_Convert_To (Typ,
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Base_Address), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Base_Address), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Address), Free_Arg)))));
Make_Object_Declaration (Loc,
Defining_Identifier => New_Msg,
Constant_Present => True,
- Object_Definition => New_Reference_To (Standard_String, Loc),
+ Object_Definition => New_Occurrence_Of (Standard_String, Loc),
Expression =>
Make_If_Expression (Loc,
Expressions => New_List (
- New_Reference_To (Flag, Loc),
+ New_Occurrence_Of (Flag, Loc),
Make_Op_Concat (Loc,
- Left_Opnd => New_Reference_To (Msg, Loc),
+ Left_Opnd => New_Occurrence_Of (Msg, Loc),
Right_Opnd => Make_String_Literal (Loc, End_String)),
- New_Reference_To (Msg, Loc)))));
+ New_Occurrence_Of (Msg, Loc)))));
Msg := New_Msg;
end Case_Guard_Error;
Cond :=
Make_And_Then (Loc,
- Left_Opnd => New_Reference_To (Flag, Loc),
+ Left_Opnd => New_Occurrence_Of (Flag, Loc),
Right_Opnd =>
Make_Op_Not (Loc,
Right_Opnd => Relocate_Node (Conseq)));
Error :=
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Raise_Assert_Failure), Loc),
+ New_Occurrence_Of (RTE (RE_Raise_Assert_Failure), Loc),
Parameter_Associations => New_List (
Make_String_Literal (Loc, End_String)));
return
Make_Object_Declaration (Loc,
Defining_Identifier => Id,
- Object_Definition => New_Reference_To (Standard_Boolean, Loc),
- Expression => New_Reference_To (Standard_False, Loc));
+ Object_Definition => New_Occurrence_Of (Standard_Boolean, Loc),
+ Expression => New_Occurrence_Of (Standard_False, Loc));
end Declaration_Of;
-------------------------------
Make_Object_Declaration (Loc,
Defining_Identifier => Temp,
Object_Definition =>
- New_Reference_To (Etype (Pref), Loc));
+ New_Occurrence_Of (Etype (Pref), Loc));
Set_No_Initialization (Decl);
Append_To (Decls, Decl);
Append_To (Eval_Stmts,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Temp, Loc),
+ Name => New_Occurrence_Of (Temp, Loc),
Expression => Pref));
-- Ensure that the prefix is valid
-- Replace the original attribute 'Old by a reference to the
-- generated temporary.
- Rewrite (N, New_Reference_To (Temp, Loc));
+ Rewrite (N, New_Occurrence_Of (Temp, Loc));
end if;
return OK;
if No (Evals) then
Evals :=
Make_Implicit_If_Statement (CCs,
- Condition => New_Reference_To (Flag, Loc),
+ Condition => New_Occurrence_Of (Flag, Loc),
Then_Statements => Eval_Stmts);
-- Otherwise generate:
Append_To (Elsif_Parts (Evals),
Make_Elsif_Part (Loc,
- Condition => New_Reference_To (Flag, Loc),
+ Condition => New_Occurrence_Of (Flag, Loc),
Then_Statements => Eval_Stmts));
end if;
end Expand_Old_In_Consequence;
begin
return
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Id, Loc),
+ Name => New_Occurrence_Of (Id, Loc),
Expression =>
Make_Op_Add (Loc,
- Left_Opnd => New_Reference_To (Id, Loc),
+ Left_Opnd => New_Occurrence_Of (Id, Loc),
Right_Opnd => Make_Integer_Literal (Loc, 1)));
end Increment;
begin
return
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Id, Loc),
- Expression => New_Reference_To (Standard_True, Loc));
+ Name => New_Occurrence_Of (Id, Loc),
+ Expression => New_Occurrence_Of (Standard_True, Loc));
end Set;
-- Local variables
Prepend_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => Count,
- Object_Definition => New_Reference_To (Standard_Natural, Loc),
+ Object_Definition => New_Occurrence_Of (Standard_Natural, Loc),
Expression => Make_Integer_Literal (Loc, 0)));
-- Create the base error message for multiple overlapping case guards
Make_Object_Declaration (Loc,
Defining_Identifier => Msg_Str,
Constant_Present => True,
- Object_Definition => New_Reference_To (Standard_String, Loc),
+ Object_Definition => New_Occurrence_Of (Standard_String, Loc),
Expression => Make_String_Literal (Loc, End_String)));
end if;
CG_Stmts := New_List (
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Raise_Assert_Failure), Loc),
+ New_Occurrence_Of (RTE (RE_Raise_Assert_Failure), Loc),
Parameter_Associations => New_List (
Make_String_Literal (Loc, End_String))));
end if;
Make_Implicit_If_Statement (CCs,
Condition =>
Make_Op_Eq (Loc,
- Left_Opnd => New_Reference_To (Count, Loc),
+ Left_Opnd => New_Occurrence_Of (Count, Loc),
Right_Opnd => Make_Integer_Literal (Loc, 0)),
Then_Statements => CG_Stmts);
Make_Elsif_Part (Loc,
Condition =>
Make_Op_Gt (Loc,
- Left_Opnd => New_Reference_To (Count, Loc),
+ Left_Opnd => New_Occurrence_Of (Count, Loc),
Right_Opnd => Make_Integer_Literal (Loc, 1)),
Then_Statements => New_List (
Statements => New_List (
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To
+ New_Occurrence_Of
(RTE (RE_Raise_Assert_Failure), Loc),
Parameter_Associations => New_List (
- New_Reference_To (Msg_Str, Loc))))))))));
+ New_Occurrence_Of (Msg_Str, Loc))))))))));
end if;
Append_To (Decls, CG_Checks);
Then_Statements => New_List (
Make_Raise_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Assert_Failure), Loc)))));
+ New_Occurrence_Of (RTE (RE_Assert_Failure), Loc)))));
-- Case where we call the procedure
Then_Statements => New_List (
Make_Procedure_Call_Statement (Loc,
Name =>
- New_Reference_To (RTE (RE_Raise_Assert_Failure), Loc),
+ New_Occurrence_Of (RTE (RE_Raise_Assert_Failure), Loc),
Parameter_Associations => New_List (Relocate_Node (Msg))))));
end if;
Make_Object_Declaration (Loc,
Defining_Identifier => Excep_Internal,
Object_Definition =>
- New_Reference_To (RTE (RE_Address), Loc));
+ New_Occurrence_Of (RTE (RE_Address), Loc));
Insert_Action (N, Excep_Object);
Analyze (Excep_Object);
Pragma_Argument_Associations => New_List (
Make_Pragma_Argument_Association (Loc,
Expression =>
- New_Reference_To (Excep_Internal, Loc)),
+ New_Occurrence_Of (Excep_Internal, Loc)),
Make_Pragma_Argument_Association (Loc,
Expression =>
Make_Pragma_Argument_Association (Loc,
Expression =>
- New_Reference_To (Excep_Internal, Loc)),
+ New_Occurrence_Of (Excep_Internal, Loc)),
Make_Pragma_Argument_Association (Loc,
Expression =>
Code :=
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Import_Address), Loc),
+ New_Occurrence_Of (RTE (RE_Import_Address), Loc),
Parameter_Associations => New_List
(Make_String_Literal (Loc,
Strval => Excep_Image)));
Rewrite (Call,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To
+ Name => New_Occurrence_Of
(RTE (RE_Register_VMS_Exception), Loc),
Parameter_Associations => New_List (
Code,
Make_Object_Declaration (Loop_Loc,
Defining_Identifier => Flag_Id,
Object_Definition =>
- New_Reference_To (Standard_Boolean, Loop_Loc),
+ New_Occurrence_Of (Standard_Boolean, Loop_Loc),
Expression =>
- New_Reference_To (Standard_False, Loop_Loc)));
+ New_Occurrence_Of (Standard_False, Loop_Loc)));
-- Prevent an unwanted optimization where the Current_Value of
-- the flag eliminates the if statement which stores the variant
Insert_Action (Loop_Stmt,
Make_Object_Declaration (Loop_Loc,
Defining_Identifier => Curr_Id,
- Object_Definition => New_Reference_To (Expr_Typ, Loop_Loc)));
+ Object_Definition => New_Occurrence_Of (Expr_Typ, Loop_Loc)));
-- Generate:
-- Old : <type of Expr>;
Insert_Action (Loop_Stmt,
Make_Object_Declaration (Loop_Loc,
Defining_Identifier => Old_Id,
- Object_Definition => New_Reference_To (Expr_Typ, Loop_Loc)));
+ Object_Definition => New_Occurrence_Of (Expr_Typ, Loop_Loc)));
-- Restore original scope after all temporaries have been analyzed
Append_To (Old_Assign,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Old_Id, Loc),
- Expression => New_Reference_To (Curr_Id, Loc)));
+ Name => New_Occurrence_Of (Old_Id, Loc),
+ Expression => New_Occurrence_Of (Curr_Id, Loc)));
-- Step 4: Store the current value of the expression
Append_To (Curr_Assign,
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Curr_Id, Loc),
+ Name => New_Occurrence_Of (Curr_Id, Loc),
Expression => Relocate_Node (Expr)));
-- Step 5: Create corresponding assertion to verify change of value
Make_Pragma_Argument_Association (Loc,
Expression =>
Make_Op (Loc,
- Curr_Val => New_Reference_To (Curr_Id, Loc),
- Old_Val => New_Reference_To (Old_Id, Loc)))));
+ Curr_Val => New_Occurrence_Of (Curr_Id, Loc),
+ Old_Val => New_Occurrence_Of (Old_Id, Loc)))));
-- Generate:
-- if Curr /= Old then
Make_If_Statement (Loc,
Condition =>
Make_Op_Ne (Loc,
- Left_Opnd => New_Reference_To (Curr_Id, Loc),
- Right_Opnd => New_Reference_To (Old_Id, Loc)),
+ Left_Opnd => New_Occurrence_Of (Curr_Id, Loc),
+ Right_Opnd => New_Occurrence_Of (Old_Id, Loc)),
Then_Statements => New_List (Prag));
end if;
Make_Elsif_Part (Loc,
Condition =>
Make_Op_Ne (Loc,
- Left_Opnd => New_Reference_To (Curr_Id, Loc),
- Right_Opnd => New_Reference_To (Old_Id, Loc)),
+ Left_Opnd => New_Occurrence_Of (Curr_Id, Loc),
+ Right_Opnd => New_Occurrence_Of (Old_Id, Loc)),
Then_Statements => New_List (Prag)));
end if;
end Process_Variant;
Insert_Action (N,
Make_If_Statement (Loc,
- Condition => New_Reference_To (Flag_Id, Loc),
+ Condition => New_Occurrence_Of (Flag_Id, Loc),
Then_Statements => Old_Assign));
-- Update the values of all expressions
Insert_Action (N,
Make_If_Statement (Loc,
- Condition => New_Reference_To (Flag_Id, Loc),
+ Condition => New_Occurrence_Of (Flag_Id, Loc),
Then_Statements => New_List (If_Stmt),
Else_Statements => New_List (
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (Flag_Id, Loc),
- Expression => New_Reference_To (Standard_True, Loc)))));
+ Name => New_Occurrence_Of (Flag_Id, Loc),
+ Expression => New_Occurrence_Of (Standard_True, Loc)))));
-- Note: the pragma has been completely transformed into a sequence of
-- corresponding declarations and statements. We leave it in the tree
Rewrite
(N,
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Set_Deadline), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Set_Deadline), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RO_RT_Time),
Make_Op_Add (Loc,
Left_Opnd =>
Make_Function_Call (Loc,
- New_Reference_To (RTE (RO_RT_To_Duration), Loc),
+ New_Occurrence_Of (RTE (RO_RT_To_Duration), Loc),
New_List (Make_Function_Call (Loc,
- New_Reference_To (RTE (RE_Clock), Loc)))),
+ New_Occurrence_Of (RTE (RE_Clock), Loc)))),
Right_Opnd =>
Unchecked_Convert_To (Standard_Duration, Arg1 (N)))))));
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2013, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
begin
return
Make_Block_Statement (Loc,
- Identifier => New_Reference_To (Abr_Blk_Ent, Loc),
+ Identifier => New_Occurrence_Of (Abr_Blk_Ent, Loc),
Declarations => No_List,
Stmt :=
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE_Abort_Undefer), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Abort_Undefer), Loc),
Parameter_Associations => No_List);
end if;
return Make_Implicit_Exception_Handler (Loc,
Exception_Choices =>
- New_List (New_Reference_To (Stand.Abort_Signal, Loc)),
+ New_List (New_Occurrence_Of (Stand.Abort_Signal, Loc)),
Statements => New_List (Stmt));
end Build_Abort_Block_Handler;
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => B,
- Object_Definition => New_Reference_To (Standard_Boolean, Loc),
- Expression => New_Reference_To (Standard_False, Loc)));
+ Object_Definition => New_Occurrence_Of (Standard_Boolean, Loc),
+ Expression => New_Occurrence_Of (Standard_False, Loc)));
return B;
end Build_B;
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => C,
- Object_Definition => New_Reference_To (RTE (RE_Prim_Op_Kind), Loc)));
+ Object_Definition =>
+ New_Occurrence_Of (RTE (RE_Prim_Op_Kind), Loc)));
return C;
end Build_C;
Cleanup_Block : constant Node_Id :=
Make_Block_Statement (Loc,
Identifier =>
- New_Reference_To (Blk_Ent, Loc),
+ New_Occurrence_Of (Blk_Ent, Loc),
Declarations => No_List,
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
Make_Object_Declaration (Loc,
Defining_Identifier => K,
Object_Definition =>
- New_Reference_To (RTE (RE_Tagged_Kind), Loc),
+ New_Occurrence_Of (RTE (RE_Tagged_Kind), Loc),
Expression =>
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Tagged_Kind), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Tagged_Kind), Loc),
Parameter_Associations => New_List (Tag_Node))));
return K;
end Build_K;
Append_To (Decls,
Make_Object_Declaration (Loc,
Defining_Identifier => S,
- Object_Definition => New_Reference_To (Standard_Integer, Loc)));
+ Object_Definition => New_Occurrence_Of (Standard_Integer, Loc)));
return S;
end Build_S;
if Tagged_Type_Expansion then
return
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (S, Loc),
+ Name => New_Occurrence_Of (S, Loc),
Expression =>
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Offset_Index), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Offset_Index), Loc),
Parameter_Associations => New_List (
Unchecked_Convert_To (RTE (RE_Tag), Obj),
Make_Integer_Literal (Loc, DT_Position (Call_Ent)))));
else
return
Make_Assignment_Statement (Loc,
- Name => New_Reference_To (S, Loc),
+ Name => New_Occurrence_Of (S, Loc),
Expression =>
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Get_Offset_Index), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Get_Offset_Index), Loc),
Parameter_Associations => New_List (
-- Iface_Typ
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Typ, Loc),
+ Prefix => New_Occurrence_Of (Typ, Loc),
Attribute_Name => Name_Tag),
-- Position
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2013, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
Make_Raise_Constraint_Error (Loc,
Condition => Make_Op_Ne (Loc,
Left_Opnd =>
- New_Reference_To
+ New_Occurrence_Of
(Defining_Identifier (Decl), Loc),
Right_Opnd =>
New_Copy_Tree (Node (Discr_Elmt))),
Parameter_Type =>
Make_Access_Definition (Loc,
Null_Exclusion_Present => True,
- Subtype_Mark => New_Reference_To (
+ Subtype_Mark => New_Occurrence_Of (
Class_Wide_Type (RTE (RE_Root_Stream_Type)), Loc))));
if Nam /= TSS_Stream_Input then
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Defining_Identifier (Loc, Name_V),
Out_Present => (Nam = TSS_Stream_Read),
- Parameter_Type => New_Reference_To (Typ, Loc)));
+ Parameter_Type => New_Occurrence_Of (Typ, Loc)));
end if;
return Profile;
Parameter_Type =>
Make_Access_Definition (Loc,
Null_Exclusion_Present => True,
- Subtype_Mark => New_Reference_To (
+ Subtype_Mark => New_Occurrence_Of (
Class_Wide_Type (RTE (RE_Root_Stream_Type)), Loc)))),
Result_Definition => New_Occurrence_Of (Typ, Loc));
Parameter_Type =>
Make_Access_Definition (Loc,
Null_Exclusion_Present => True,
- Subtype_Mark => New_Reference_To (
+ Subtype_Mark => New_Occurrence_Of (
Class_Wide_Type (RTE (RE_Root_Stream_Type)), Loc))),
Make_Parameter_Specification (Loc,
-- a) Storage pool
- Actuals := New_List (New_Reference_To (Pool_Id, Loc));
+ Actuals := New_List (New_Occurrence_Of (Pool_Id, Loc));
if Is_Allocate then
if Needs_Finalization (Desig_Typ) then
Fin_Mas_Id := Finalization_Master (Ptr_Typ);
- Fin_Mas_Act := New_Reference_To (Fin_Mas_Id, Loc);
+ Fin_Mas_Act := New_Occurrence_Of (Fin_Mas_Id, Loc);
-- Handle the case where the master is actually a pointer to a
-- master. This case arises in build-in-place functions.
Append_To (Actuals,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Fin_Addr_Id, Loc),
+ Prefix => New_Occurrence_Of (Fin_Addr_Id, Loc),
Attribute_Name => Name_Unrestricted_Access));
else
Append_To (Actuals, Make_Null (Loc));
-- f) Storage_Size
-- g) Alignment
- Append_To (Actuals, New_Reference_To (Addr_Id, Loc));
- Append_To (Actuals, New_Reference_To (Size_Id, Loc));
+ Append_To (Actuals, New_Occurrence_Of (Addr_Id, Loc));
+ Append_To (Actuals, New_Occurrence_Of (Size_Id, Loc));
if Is_Allocate or else not Is_Class_Wide_Type (Desig_Typ) then
- Append_To (Actuals, New_Reference_To (Alig_Id, Loc));
+ Append_To (Actuals, New_Occurrence_Of (Alig_Id, Loc));
-- For deallocation of class wide types we obtain the value of
-- alignment from the Type Specific Record of the deallocated object.
and then Is_Type (Entity (Temp))
then
Flag_Expr :=
- New_Reference_To
+ New_Occurrence_Of
(Boolean_Literals
(Needs_Finalization (Entity (Temp))), Loc);
Flag_Expr :=
Make_Function_Call (Loc,
Name =>
- New_Reference_To (RTE (RE_Needs_Finalization), Loc),
+ New_Occurrence_Of (RTE (RE_Needs_Finalization), Loc),
Parameter_Associations => New_List (Param));
-- Processing for generic actuals
elsif Is_Generic_Actual_Type (Desig_Typ) then
Flag_Expr :=
- New_Reference_To (Boolean_Literals
+ New_Occurrence_Of (Boolean_Literals
(Needs_Finalization (Base_Type (Desig_Typ))), Loc);
-- The object does not require any specialized checks, it is
-- known to be controlled.
else
- Flag_Expr := New_Reference_To (Standard_True, Loc);
+ Flag_Expr := New_Occurrence_Of (Standard_True, Loc);
end if;
-- Create the temporary which represents the finalization state
Defining_Identifier => Flag_Id,
Constant_Present => True,
Object_Definition =>
- New_Reference_To (Standard_Boolean, Loc),
+ New_Occurrence_Of (Standard_Boolean, Loc),
Expression => Flag_Expr));
- Append_To (Actuals, New_Reference_To (Flag_Id, Loc));
+ Append_To (Actuals, New_Occurrence_Of (Flag_Id, Loc));
end;
-- The object is not controlled
else
- Append_To (Actuals, New_Reference_To (Standard_False, Loc));
+ Append_To (Actuals, New_Occurrence_Of (Standard_False, Loc));
end if;
-- i) On_Subpool
if Is_Allocate then
Append_To (Actuals,
- New_Reference_To (Boolean_Literals (Present (Subpool)), Loc));
+ New_Occurrence_Of (Boolean_Literals (Present (Subpool)), Loc));
end if;
-- Step 2: Build a wrapper Allocate / Deallocate which internally
Make_Parameter_Specification (Loc,
Defining_Identifier => Make_Temporary (Loc, 'P'),
Parameter_Type =>
- New_Reference_To (RTE (RE_Root_Storage_Pool), Loc)),
+ New_Occurrence_Of (RTE (RE_Root_Storage_Pool), Loc)),
-- A : [out] Address
Defining_Identifier => Addr_Id,
Out_Present => Is_Allocate,
Parameter_Type =>
- New_Reference_To (RTE (RE_Address), Loc)),
+ New_Occurrence_Of (RTE (RE_Address), Loc)),
-- S : Storage_Count
Make_Parameter_Specification (Loc,
Defining_Identifier => Size_Id,
Parameter_Type =>
- New_Reference_To (RTE (RE_Storage_Count), Loc)),
+ New_Occurrence_Of (RTE (RE_Storage_Count), Loc)),
-- L : Storage_Count
Make_Parameter_Specification (Loc,
Defining_Identifier => Alig_Id,
Parameter_Type =>
- New_Reference_To (RTE (RE_Storage_Count), Loc)))),
+ New_Occurrence_Of (RTE (RE_Storage_Count), Loc)))),
Declarations => No_List,
Make_Handled_Sequence_Of_Statements (Loc,
Statements => New_List (
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Proc_To_Call, Loc),
+ Name => New_Occurrence_Of (Proc_To_Call, Loc),
Parameter_Associations => Actuals)))));
-- The newly generated Allocate / Deallocate becomes the default
else
return
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (RTE (RE), Loc));
+ Name => New_Occurrence_Of (RTE (RE), Loc));
end if;
end Build_Runtime_Call;
begin
Rewrite (Subtype_Indic,
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Unc_Type, Loc),
+ Subtype_Mark => New_Occurrence_Of (Unc_Type, Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => New_List
- (New_Reference_To (Slice_Type, Loc)))));
+ (New_Occurrence_Of (Slice_Type, Loc)))));
-- This subtype indication may be used later for constraint checks
-- we better make sure that if a variable was used as a bound of
elsif Ekind (Exp_Typ) = E_String_Literal_Subtype then
Rewrite (Subtype_Indic,
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Unc_Type, Loc),
+ Subtype_Mark => New_Occurrence_Of (Unc_Type, Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => New_List (
Insert_Action (N,
Make_Subtype_Declaration (Loc,
Defining_Identifier => T,
- Subtype_Indication => New_Reference_To (Exp_Typ, Loc)));
+ Subtype_Indication => New_Occurrence_Of (Exp_Typ, Loc)));
-- This type is marked as an itype even though it has an explicit
-- declaration since otherwise Is_Generic_Actual_Type can get
Set_Associated_Node_For_Itype (T, Exp);
end if;
- Rewrite (Subtype_Indic, New_Reference_To (T, Loc));
+ Rewrite (Subtype_Indic, New_Occurrence_Of (T, Loc));
-- Nothing needs to be done for private types with unknown discriminants
-- if the underlying type is not an unconstrained composite type or it
Attribute_Name => Name_Size),
Right_Opnd =>
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Constr_Root, Loc),
+ Prefix => New_Occurrence_Of (Constr_Root, Loc),
Attribute_Name => Name_Object_Size));
else
-- subtype rg__xx is
Defining_Identifier => Range_Type,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (RTE (RE_Storage_Offset), Loc),
+ Subtype_Mark => New_Occurrence_Of (RTE (RE_Storage_Offset), Loc),
Constraint => Make_Range_Constraint (Loc,
Range_Expression =>
Make_Range (Loc,
Defining_Identifier => Str_Type,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (RTE (RE_Storage_Array), Loc),
+ Subtype_Mark => New_Occurrence_Of (RTE (RE_Storage_Array), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Constraints =>
- New_List (New_Reference_To (Range_Type, Loc))))));
+ New_List (New_Occurrence_Of (Range_Type, Loc))))));
-- type Equiv_T is record
-- [ _parent : Tnn; ]
Component_Definition =>
Make_Component_Definition (Loc,
Aliased_Present => False,
- Subtype_Indication => New_Reference_To (Constr_Root, Loc))));
+ Subtype_Indication => New_Occurrence_Of (Constr_Root, Loc))));
end if;
Append_To (Comp_List,
Component_Definition =>
Make_Component_Definition (Loc,
Aliased_Present => False,
- Subtype_Indication => New_Reference_To (Str_Type, Loc))));
+ Subtype_Indication => New_Occurrence_Of (Str_Type, Loc))));
Append_To (List_Def,
Make_Full_Type_Declaration (Loc,
Set_Full_View (Priv_Subtyp, Full_Subtyp);
- return New_Reference_To (Priv_Subtyp, Loc);
+ return New_Occurrence_Of (Priv_Subtyp, Loc);
elsif Is_Array_Type (Unc_Typ) then
for J in 1 .. Number_Dimensions (Unc_Typ) loop
Append_To (List_Constr,
Make_Selected_Component (Loc,
Prefix => Duplicate_Subexpr_No_Checks (E),
- Selector_Name => New_Reference_To (D, Loc)));
+ Selector_Name => New_Occurrence_Of (D, Loc)));
Next_Discriminant (D);
end loop;
return
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Unc_Typ, Loc),
+ Subtype_Mark => New_Occurrence_Of (Unc_Typ, Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => List_Constr));
then
Def_Id := Make_Temporary (Loc, 'R', Exp);
Set_Etype (Def_Id, Exp_Type);
- Res := New_Reference_To (Def_Id, Loc);
+ Res := New_Occurrence_Of (Def_Id, Loc);
-- If the expression is a packed reference, it must be reanalyzed and
-- expanded, depending on context. This is the case for actuals where
E :=
Make_Object_Declaration (Loc,
Defining_Identifier => Def_Id,
- Object_Definition => New_Reference_To (Exp_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Exp_Type, Loc),
Constant_Present => True,
Expression => Relocate_Node (Exp));
elsif Nkind (Exp) = N_Explicit_Dereference then
Def_Id := Make_Temporary (Loc, 'R', Exp);
Res :=
- Make_Explicit_Dereference (Loc, New_Reference_To (Def_Id, Loc));
+ Make_Explicit_Dereference (Loc, New_Occurrence_Of (Def_Id, Loc));
Insert_Action (Exp,
Make_Object_Declaration (Loc,
Defining_Identifier => Def_Id,
Object_Definition =>
- New_Reference_To (Etype (Prefix (Exp)), Loc),
+ New_Occurrence_Of (Etype (Prefix (Exp)), Loc),
Constant_Present => True,
Expression => Relocate_Node (Prefix (Exp))));
-- a controlled temporary.
Def_Id := Make_Temporary (Loc, 'R', Exp);
- Res := New_Reference_To (Def_Id, Loc);
+ Res := New_Occurrence_Of (Def_Id, Loc);
Insert_Action (Exp,
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Def_Id,
- Subtype_Mark => New_Reference_To (Exp_Type, Loc),
+ Subtype_Mark => New_Occurrence_Of (Exp_Type, Loc),
Name => Relocate_Node (Exp)));
else
Def_Id := Make_Temporary (Loc, 'R', Exp);
Set_Etype (Def_Id, Exp_Type);
- Res := New_Reference_To (Def_Id, Loc);
+ Res := New_Occurrence_Of (Def_Id, Loc);
E :=
Make_Object_Declaration (Loc,
Defining_Identifier => Def_Id,
- Object_Definition => New_Reference_To (Exp_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Exp_Type, Loc),
Constant_Present => not Is_Variable (Exp),
Expression => Relocate_Node (Exp));
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Def_Id,
Subtype_Mark =>
- New_Reference_To (Base_Type (Etype (Prefix (Exp))), Loc),
+ New_Occurrence_Of (Base_Type (Etype (Prefix (Exp))), Loc),
Name => Relocate_Node (Prefix (Exp))));
else
- Res := New_Reference_To (Def_Id, Loc);
+ Res := New_Occurrence_Of (Def_Id, Loc);
Insert_Action (Exp,
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => Def_Id,
- Subtype_Mark => New_Reference_To (Exp_Type, Loc),
+ Subtype_Mark => New_Occurrence_Of (Exp_Type, Loc),
Name => Relocate_Node (Exp)));
end if;
-- and "copies" the returned object.
if GNATprove_Mode then
- Res := New_Reference_To (Def_Id, Loc);
+ Res := New_Occurrence_Of (Def_Id, Loc);
Ref_Type := Exp_Type;
-- Regular expansion utilizing an access type and 'reference
else
Res :=
Make_Explicit_Dereference (Loc,
- Prefix => New_Reference_To (Def_Id, Loc));
+ Prefix => New_Occurrence_Of (Def_Id, Loc));
-- Generate:
-- type Ann is access all <Exp_Type>;
Make_Access_To_Object_Definition (Loc,
All_Present => True,
Subtype_Indication =>
- New_Reference_To (Exp_Type, Loc)));
+ New_Occurrence_Of (Exp_Type, Loc)));
Insert_Action (Exp, Ptr_Typ_Decl);
end if;
Insert_Action (Exp,
Make_Object_Declaration (Loc,
Defining_Identifier => Def_Id,
- Object_Definition => New_Reference_To (Ref_Type, Loc),
+ Object_Definition => New_Occurrence_Of (Ref_Type, Loc),
Constant_Present => True,
Expression => New_Exp));
end if;
then
Call_Name := New_Copy (Name (N));
else
- Call_Name := New_Reference_To (Old_S, Loc);
+ Call_Name := New_Occurrence_Of (Old_S, Loc);
end if;
else
if Present (Formal) then
while Present (Formal) loop
- Append (New_Reference_To (Formal, Loc), Actuals);
+ Append (New_Occurrence_Of (Formal, Loc), Actuals);
Next_Formal (Formal);
end loop;
end if;
Error_Msg_SC -- CODEFIX
("|extra ""("" ignored");
+ -- Note: the following error used to be labeled as a non-serious
+ -- error like the other similar messages here (with a | at the start
+ -- of the message). But this caused some annoying cascaded errors
+ -- that were confusing, as shown by this example:
+
+ -- A : array (1 .. 9) of Integer :=
+ -- ((1 .. 2) => 0,
+ -- 1 2 3
+ -- >>> positional aggregate cannot have one component
+ -- >>> named association cannot follow positional association
+ -- >>> extra ")" ignored
+
+ -- So we decided to label it as serious after all
+
elsif T = Tok_Right_Paren then
Error_Msg_SC -- CODEFIX
- ("|extra "")"" ignored");
+ ("extra "")"" ignored");
elsif T = Tok_Semicolon then
Error_Msg_SC -- CODEFIX
Scop : Entity_Id;
begin
- Nam := New_Reference_To (U.Entity, Standard_Location);
+ Nam := New_Occurrence_Of (U.Entity, Standard_Location);
Scop := Scope (U.Entity);
if Nkind (N) = N_Defining_Program_Unit_Name then
Nam :=
Make_Expanded_Name (Standard_Location,
Chars => Chars (U.Entity),
- Prefix => New_Reference_To (Scop, Standard_Location),
+ Prefix => New_Occurrence_Of (Scop, Standard_Location),
Selector_Name => Nam);
Set_Entity (Nam, U.Entity);
Expr :=
Make_Attribute_Reference
(Loc,
- Prefix => New_Reference_To (Index_Typ, Loc),
+ Prefix => New_Occurrence_Of (Index_Typ, Loc),
Attribute_Name => Name_Val,
Expressions => New_List (Expr_Pos));
end if;
To_Pos :=
Make_Attribute_Reference
(Loc,
- Prefix => New_Reference_To (Index_Typ, Loc),
+ Prefix => New_Occurrence_Of (Index_Typ, Loc),
Attribute_Name => Name_Pos,
Expressions => New_List (Duplicate_Subexpr (To)));
Expr :=
Make_Attribute_Reference
(Loc,
- Prefix => New_Reference_To (Index_Typ, Loc),
+ Prefix => New_Occurrence_Of (Index_Typ, Loc),
Attribute_Name => Name_Val,
Expressions => New_List (Expr_Pos));
Insert_Action (N,
Make_Object_Declaration (Loc,
Defining_Identifier => Def_Id,
- Object_Definition => New_Reference_To (Index_Typ, Loc),
+ Object_Definition =>
+ New_Occurrence_Of (Index_Typ, Loc),
Constant_Present => True,
Expression => Relocate_Node (Expr)));
- Expr := New_Reference_To (Def_Id, Loc);
+ Expr := New_Occurrence_Of (Def_Id, Loc);
end;
end if;
end if;
when Attribute_Abort_Signal =>
Check_Standard_Prefix;
- Rewrite (N, New_Reference_To (Stand.Abort_Signal, Loc));
+ Rewrite (N, New_Occurrence_Of (Stand.Abort_Signal, Loc));
Analyze (N);
------------
Set_Etype (N, Base_Type (Entity (P)));
Set_Entity (N, Base_Type (Entity (P)));
- Rewrite (N, New_Reference_To (Entity (N), Loc));
+ Rewrite (N, New_Occurrence_Of (Entity (N), Loc));
Analyze (N);
end Base;
elsif Is_VAX_Float (P_Type)
and then Nkind (Lo_Bound) = N_Identifier
then
- Rewrite (N, New_Reference_To (Entity (Lo_Bound), Sloc (N)));
+ Rewrite (N, New_Occurrence_Of (Entity (Lo_Bound), Sloc (N)));
Analyze (N);
else
elsif Is_VAX_Float (P_Type)
and then Nkind (Hi_Bound) = N_Identifier
then
- Rewrite (N, New_Reference_To (Entity (Hi_Bound), Sloc (N)));
+ Rewrite (N, New_Occurrence_Of (Entity (Hi_Bound), Sloc (N)));
Analyze (N);
else
Name =>
Make_Identifier (Loc,
Chars => New_External_Name (Chars (Etype (Nam)), 'E')),
- Expression => New_Reference_To (Standard_True, Loc)));
+ Expression => New_Occurrence_Of (Standard_True, Loc)));
end if;
end if;
end Analyze_Task_Body_Stub;
function Build_Ancestor_Name (P : Node_Id) return Node_Id is
P_Ref : constant Node_Id :=
- New_Reference_To (Defining_Entity (P), Loc);
+ New_Occurrence_Of (Defining_Entity (P), Loc);
P_Spec : Node_Id := P;
begin
begin
if No (Parent_Spec (P_Unit)) then
- return New_Reference_To (P_Name, Loc);
+ return New_Occurrence_Of (P_Name, Loc);
else
Result :=
Make_Expanded_Name (Loc,
Chars => Chars (P_Name),
Prefix => Build_Ancestor_Name (Unit (Parent_Spec (P_Unit))),
- Selector_Name => New_Reference_To (P_Name, Loc));
+ Selector_Name => New_Occurrence_Of (P_Name, Loc));
Set_Entity (Result, P_Name);
return Result;
end if;
-- a parent unit that has limited with-clauses.
Set_Subtype_Indication (Decl,
- New_Reference_To (Non_Lim_View, Sloc (Def_Id)));
+ New_Occurrence_Of (Non_Lim_View, Sloc (Def_Id)));
Set_Etype (Def_Id, Non_Lim_View);
Set_Ekind (Def_Id, Subtype_Kind (Ekind (Non_Lim_View)));
Set_Analyzed (Decl, False);
Lo :=
Make_Attribute_Reference (Loc,
Attribute_Name => Name_First,
- Prefix => New_Reference_To (T, Loc));
+ Prefix => New_Occurrence_Of (T, Loc));
Set_Etype (Lo, T);
Hi :=
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Last,
- Prefix => New_Reference_To (T, Loc));
+ Prefix => New_Occurrence_Of (T, Loc));
Set_Etype (Hi, T);
Set_Scalar_Range (T,
then
declare
Non_Freezing_Ref : constant Node_Id :=
- New_Reference_To (Id, Sloc (Id));
+ New_Occurrence_Of (Id, Sloc (Id));
Decl : Node_Id;
begin
Make_Package_Renaming_Declaration (Loc,
Defining_Unit_Name =>
Make_Defining_Identifier (Loc, Chars (Gen_Unit)),
- Name => New_Reference_To (Act_Decl_Id, Loc));
+ Name => New_Occurrence_Of (Act_Decl_Id, Loc));
Append (Unit_Renaming, Renaming_List);
Nod :=
Make_Package_Renaming_Declaration (Loc,
Defining_Unit_Name => New_Copy (Defining_Identifier (Formal)),
- Name => New_Reference_To (Actual_Pack, Loc));
+ Name => New_Occurrence_Of (Actual_Pack, Loc));
Set_Associated_Formal_Package (Defining_Unit_Name (Nod),
Defining_Identifier (Formal));
Decl_Node :=
Make_Subtype_Declaration (Loc,
Defining_Identifier => Subt,
- Subtype_Indication => New_Reference_To (Act_T, Loc));
+ Subtype_Indication => New_Occurrence_Of (Act_T, Loc));
if Is_Private_Type (Act_T) then
Set_Has_Private_View (Subtype_Indication (Decl_Node));
Make_Subtype_Declaration (Loc,
Defining_Identifier => New_Corr,
Subtype_Indication =>
- New_Reference_To (Corr_Rec, Loc));
+ New_Occurrence_Of (Corr_Rec, Loc));
Append_To (Decl_Nodes, Corr_Decl);
if Ekind (Act_T) = E_Task_Type then
if Operating_Mode = Check_Semantics and then ASIS_Mode then
AtM_Nod :=
Make_Attribute_Definition_Clause (Loc,
- Name => New_Reference_To (Base_Type (Rectype), Loc),
+ Name => New_Occurrence_Of (Base_Type (Rectype), Loc),
Chars => Name_Alignment,
Expression => Relocate_Node (Expression (M)));
Defining_Identifier => BTemp,
Constant_Present => True,
Object_Definition =>
- New_Reference_To (Standard_Boolean, Loc),
+ New_Occurrence_Of (Standard_Boolean, Loc),
Expression => Expr_M)),
Handled_Statement_Sequence =>
Make_Handled_Sequence_Of_Statements (Loc,
Statements => New_List (
Make_Simple_Return_Statement (Loc,
- Expression => New_Reference_To (BTemp, Loc)))));
+ Expression => New_Occurrence_Of (BTemp, Loc)))));
-- Insert declaration before freeze node and body after
Out_P : constant Boolean := (Nam = TSS_Stream_Read);
Formals : List_Id;
Spec : Node_Id;
- T_Ref : constant Node_Id := New_Reference_To (Etyp, Loc);
+ T_Ref : constant Node_Id := New_Occurrence_Of (Etyp, Loc);
begin
Subp_Id := Make_Defining_Identifier (Loc, Sname);
Parameter_Type =>
Make_Access_Definition (Loc,
Subtype_Mark =>
- New_Reference_To (
+ New_Occurrence_Of (
Designated_Type (Etype (F)), Loc))));
if Nam = TSS_Stream_Input then
Subp_Decl :=
Make_Subprogram_Renaming_Declaration (Loc,
Specification => Build_Spec,
- Name => New_Reference_To (Subp, Loc));
+ Name => New_Occurrence_Of (Subp, Loc));
if Defer_Declaration then
Set_TSS (Base_Type (Ent), Subp_Id);
Defining_Identifier => Derived_Type,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Implicit_Base, Loc),
+ Subtype_Mark => New_Occurrence_Of (Implicit_Base, Loc),
Constraint => Constraint (Indic)));
Rewrite (N, New_Indic);
Lo :=
Make_Attribute_Reference (Loc,
Attribute_Name => Name_First,
- Prefix => New_Reference_To (Derived_Type, Loc));
+ Prefix => New_Occurrence_Of (Derived_Type, Loc));
Set_Etype (Lo, Derived_Type);
Hi :=
Make_Attribute_Reference (Loc,
Attribute_Name => Name_Last,
- Prefix => New_Reference_To (Derived_Type, Loc));
+ Prefix => New_Occurrence_Of (Derived_Type, Loc));
Set_Etype (Hi, Derived_Type);
Set_Scalar_Range (Derived_Type,
Defining_Identifier => Subt,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Par, Loc),
+ Subtype_Mark => New_Occurrence_Of (Par, Loc),
Constraint => New_Copy_Tree (Constr)));
-- If this is a component subtype for an outer itype, it is not
Chars => Name_Implemented,
Pragma_Argument_Associations => New_List (
Make_Pragma_Argument_Association (Loc,
- Expression => New_Reference_To (Subp, Loc)),
+ Expression => New_Occurrence_Of (Subp, Loc)),
Make_Pragma_Argument_Association (Loc,
Expression => Make_Identifier (Loc, Iface_Kind))));
then
D := First_Discriminant (Derived_Base);
while Present (D) loop
- Append_Elmt (New_Reference_To (D, Loc), Discs);
+ Append_Elmt (New_Occurrence_Of (D, Loc), Discs);
Next_Discriminant (D);
end loop;
end if;
elsif Ekind (Priv_Dep) = E_Incomplete_Subtype then
Set_Subtype_Indication
- (Parent (Priv_Dep), New_Reference_To (Full_T, Sloc (Priv_Dep)));
+ (Parent (Priv_Dep), New_Occurrence_Of (Full_T, Sloc (Priv_Dep)));
Set_Etype (Priv_Dep, Full_T);
Set_Ekind (Priv_Dep, Subtype_Kind (Ekind (Full_T)));
Set_Analyzed (Parent (Priv_Dep), False);
Rewrite (Lo,
Make_Attribute_Reference (Sloc (Lo),
Attribute_Name => Name_First,
- Prefix => New_Reference_To (T, Sloc (Lo))));
+ Prefix => New_Occurrence_Of (T, Sloc (Lo))));
Analyze_And_Resolve (Lo);
end if;
Rewrite (Hi,
Make_Attribute_Reference (Sloc (Hi),
Attribute_Name => Name_First,
- Prefix => New_Reference_To (T, Sloc (Hi))));
+ Prefix => New_Occurrence_Of (T, Sloc (Hi))));
Analyze_And_Resolve (Hi);
end if;
-- can never assign to its prefix). The Comes_From_Source attribute
-- needs to be propagated for accurate warnings.
- Ref := New_Reference_To (E, Sloc (P));
+ Ref := New_Occurrence_Of (E, Sloc (P));
Set_Comes_From_Source (Ref, Comes_From_Source (P));
Generate_Reference (E, Ref);
end if;
Success := False;
if No (Matching_Op) then
- Hom_Ref := New_Reference_To (Hom, Sloc (Subprog));
+ Hom_Ref := New_Occurrence_Of (Hom, Sloc (Subprog));
Set_Etype (Call_Node, Any_Type);
Set_Parent (Call_Node, Parent (Node_To_Replace));
Set_Is_Overloaded (Call_Node, False);
if No (Matching_Op) then
- Prim_Op_Ref := New_Reference_To (Prim_Op, Sloc (Subprog));
+ Prim_Op_Ref := New_Occurrence_Of (Prim_Op, Sloc (Subprog));
Candidate := Prim_Op;
Set_Parent (Call_Node, Parent (Node_To_Replace));
Defining_Identifier => Subt,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Indx, Loc),
+ Subtype_Mark => New_Occurrence_Of (Indx, Loc),
Constraint =>
Make_Range_Constraint (Loc, Relocate_Node (DS))));
Insert_Before (Loop_Nod, Decl);
Rewrite (DS,
Make_Attribute_Reference (Loc,
- Prefix => New_Reference_To (Subt, Loc),
+ Prefix => New_Occurrence_Of (Subt, Loc),
Attribute_Name => Attribute_Name (DS)));
Analyze (DS);
Make_Defining_Identifier (Loc, Name_uMaster),
Constant_Present => True,
Object_Definition =>
- New_Reference_To (RTE (RE_Master_Id), Loc),
+ New_Occurrence_Of (RTE (RE_Master_Id), Loc),
Expression =>
Make_Explicit_Dereference (Loc,
- New_Reference_To (RTE (RE_Current_Master), Loc)));
+ New_Occurrence_Of (RTE (RE_Current_Master), Loc)));
if Present (Declarations (N)) then
Prepend (Decl, Declarations (N));
Null_Exclusion_Present =>
Null_Exclusion_Present (Parent (Formal)),
Parameter_Type =>
- New_Reference_To (Etype (Formal), Loc),
+ New_Occurrence_Of (Etype (Formal), Loc),
Expression =>
Copy_Separate_Tree (Expression (Parent (Formal)))));
begin
Append_To (Actual_List,
- New_Reference_To (Defining_Identifier (New_Obj), Loc));
+ New_Occurrence_Of (Defining_Identifier (New_Obj), Loc));
Formal := First_Formal (Spec_Id);
while Present (Formal) loop
- Append_To (Actual_List, New_Reference_To (Formal, Loc));
+ Append_To (Actual_List, New_Occurrence_Of (Formal, Loc));
-- Avoid spurious warning on unreferenced formals
Proc_Call :=
Make_Procedure_Call_Statement (Loc,
- Name => New_Reference_To (Proc_Id, Loc),
+ Name => New_Occurrence_Of (Proc_Id, Loc),
Parameter_Associations => Actual_List);
end;
Make_Simple_Return_Statement (Loc,
Expression =>
- New_Reference_To
+ New_Occurrence_Of
(Defining_Identifier (New_Obj), Loc)))));
Rewrite (Ret_Node, Blk_Stmt);
Make_Parameter_Specification (Loc,
Defining_Identifier => A,
Parameter_Type =>
- New_Reference_To (Etype (First_Formal (S)),
+ New_Occurrence_Of (Etype (First_Formal (S)),
Sloc (Etype (First_Formal (S))))),
Make_Parameter_Specification (Loc,
Defining_Identifier => B,
Parameter_Type =>
- New_Reference_To (Etype (Next_Formal (First_Formal (S))),
+ New_Occurrence_Of (Etype (Next_Formal (First_Formal (S))),
Sloc (Etype (Next_Formal (First_Formal (S)))))));
Decl :=
Defining_Unit_Name => Op_Name,
Parameter_Specifications => Formals,
Result_Definition =>
- New_Reference_To (Standard_Boolean, Loc)));
+ New_Occurrence_Of (Standard_Boolean, Loc)));
-- Insert inequality right after equality if it is explicit or after
-- the derived type when implicit. These entities are created only
-- there are no subtypes involved.
Rewrite (Parameter_Type (Param_Spec),
- New_Reference_To
+ New_Occurrence_Of
(Base_Type (Entity (Parameter_Type (Param_Spec))), Loc));
end if;
Find_Type (Result_Definition (Spec));
Rewrite (Result_Definition (Spec),
- New_Reference_To
+ New_Occurrence_Of
(Base_Type (Entity (Result_Definition (Spec))), Loc));
Body_Node :=
Make_Expanded_Name (Sloc (N),
Chars => Chars (T),
Prefix => New_Copy (Prefix (Prefix (N))),
- Selector_Name => New_Reference_To (T, Sloc (N))));
+ Selector_Name => New_Occurrence_Of (T, Sloc (N))));
else
- Rewrite (N, New_Reference_To (T, Sloc (N)));
+ Rewrite (N, New_Occurrence_Of (T, Sloc (N)));
end if;
Set_Entity (N, T);
Name =>
Make_Expanded_Name (Loc,
Chars => Chars (System_Aux_Id),
- Prefix => New_Reference_To (Scope (System_Aux_Id), Loc),
- Selector_Name => New_Reference_To (System_Aux_Id, Loc)));
+ Prefix => New_Occurrence_Of (Scope (System_Aux_Id), Loc),
+ Selector_Name => New_Occurrence_Of (System_Aux_Id, Loc)));
Set_Entity (Name (Withn), System_Aux_Id);
Actual_1 :=
Make_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (Standard_Long_Long_Float, Loc),
+ Subtype_Mark => New_Occurrence_Of (Standard_Long_Long_Float, Loc),
Expression => Relocate_Node (L));
Actual_2 :=
New_N :=
Make_Type_Conversion (Loc,
- Subtype_Mark => New_Reference_To (New_Id, Loc),
+ Subtype_Mark => New_Occurrence_Of (New_Id, Loc),
Expression =>
Make_Function_Call (Loc,
- Name => New_Reference_To (RTE (RE_Expon_LLF), Loc),
+ Name => New_Occurrence_Of (RTE (RE_Expon_LLF), Loc),
Parameter_Associations => New_List (
Actual_1, Actual_2)));
if Present (Renamed_Object (Entity (Item))) then
Rewrite (Item,
- New_Reference_To (Item_Id, Sloc (Item)));
+ New_Occurrence_Of (Item_Id, Sloc (Item)));
Analyze (Item);
end if;
-- with a reference to the object.
if Present (Renamed_Object (Entity (Item))) then
- Rewrite (Item, New_Reference_To (Item_Id, Sloc (Item)));
+ Rewrite (Item, New_Occurrence_Of (Item_Id, Sloc (Item)));
Analyze (Item);
end if;
Rewrite (N,
Make_Qualified_Expression (Loc,
- Subtype_Mark => New_Reference_To (Typ, Loc),
+ Subtype_Mark => New_Occurrence_Of (Typ, Loc),
Expression =>
Make_Aggregate (Loc, Expressions => Lits)));
Loc := Sloc (N);
if Nkind (N) = N_Defining_Identifier then
- Obj := New_Reference_To (N, Loc);
+ Obj := New_Occurrence_Of (N, Loc);
-- If this is a formal parameter of a subprogram declaration, and
-- we are compiling the body, we want the declaration for the
Defining_Identifier => Subt,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (T, Loc),
+ Subtype_Mark => New_Occurrence_Of (T, Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => Constraints)));
Defining_Identifier => Subt,
Subtype_Indication =>
Make_Subtype_Indication (Loc,
- Subtype_Mark => New_Reference_To (Base_Type (T), Loc),
+ Subtype_Mark => New_Occurrence_Of (Base_Type (T), Loc),
Constraint =>
Make_Index_Or_Discriminant_Constraint (Loc,
Constraints => C)));
In_Present => In_Present (Parent (Formal)),
Out_Present => Out_Present (Parent (Formal)),
Parameter_Type =>
- New_Reference_To (Etype (Formal), Loc),
+ New_Occurrence_Of (Etype (Formal), Loc),
Expression =>
New_Copy_Tree (Expression (Parent (Formal)))),
Plist);
Make_Selected_Component (Loc,
Prefix => New_Copy (Rec),
Selector_Name =>
- New_Reference_To (First_Tag_Component (Full_Type), Loc)));
+ New_Occurrence_Of (First_Tag_Component (Full_Type), Loc)));
end Make_DT_Access;
------------------------
return Nod;
end New_Op_Node;
- ----------------------
- -- New_Reference_To --
- ----------------------
-
- function New_Reference_To
- (Def_Id : Entity_Id;
- Loc : Source_Ptr) return Node_Id
- is
- pragma Assert (Present (Def_Id) and then Nkind (Def_Id) in N_Entity);
- Occurrence : Node_Id;
- begin
- Occurrence := New_Node (N_Identifier, Loc);
- Set_Chars (Occurrence, Chars (Def_Id));
- Set_Entity (Occurrence, Def_Id);
- return Occurrence;
- end New_Reference_To;
-
-----------------------
-- New_Suffixed_Name --
-----------------------
-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2012, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2013, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- follows: Entity is simply a copy of Def_Id. Etype is a copy of Def_Id
-- for types, and a copy of the Etype of Def_Id for other entities.
- function New_Reference_To
- (Def_Id : Entity_Id;
- Loc : Source_Ptr) return Node_Id;
- -- This is like New_Occurrence_Of, but it does not set the Etype field. It
- -- is used from the expander, where Etype fields are generally not set,
- -- since they are set when the expanded tree is reanalyzed.
-
function New_Suffixed_Name
(Related_Id : Name_Id;
Suffix : String) return Name_Id;
projects / platform / upstream / gcc.git / commitdiff