+2010-10-26 Robert Dewar <dewar@adacore.com>
+
+ * exp_ch5.adb, exp_prag.adb, sem_ch3.adb, exp_atag.adb, layout.adb,
+ sem_dist.adb, exp_ch7.adb, exp_util.adb, exp_attr.adb, exp_ch9.adb,
+ sem_ch10.adb, checks.adb, sem_prag.adb, par-endh.adb, sem_ch12.adb,
+ exp_smem.adb, sem_attr.adb, exp_ch4.adb, exp_ch6.adb, exp_ch8.adb,
+ sem_ch6.adb, exp_disp.adb, exp_aggr.adb, exp_dist.adb, sem_ch13.adb,
+ par-ch3.adb, par-ch5.adb, exp_strm.adb, exp_ch3.adb: Minor reformatting
+ * opt.ads: Minor comment fix.
+
+2010-10-26 Vincent Celier <celier@adacore.com>
+
+ * gnat_ugn.texi: Document option -s for gnatlink.
+
2010-10-26 Robert Dewar <dewar@adacore.com>
* opt.ads: Move documentation on checksum stuff here from prj-nmsc
-- one of the stored discriminants, this will provide the
-- required consistency check.
- Append_Elmt (
- Make_Selected_Component (Loc,
- Prefix =>
+ Append_Elmt
+ (Make_Selected_Component (Loc,
+ Prefix =>
Duplicate_Subexpr_No_Checks
(Expr, Name_Req => True),
Selector_Name =>
Make_Identifier (Loc, Chars (Discr))),
- New_Constraints);
+ New_Constraints);
else
-- Discriminant of more remote ancestor ???
Prefix =>
New_Reference_To (
Associated_Final_Chain (Etype (Alloc)), Loc),
- Selector_Name =>
- Make_Identifier (Loc, Name_F));
+ Selector_Name => Make_Identifier (Loc, Name_F));
elsif Present (Flist) then
External_Final_List := New_Copy_Tree (Flist);
Make_Identifier (Loc, Name_uController));
F :=
Make_Selected_Component (Loc,
- Prefix => F,
+ Prefix => F,
Selector_Name => Make_Identifier (Loc, Name_F));
Attach := Make_Integer_Literal (Loc, 1);
if Needs_Finalization (Comp_Type) then
Internal_Final_List :=
Make_Selected_Component (Loc,
- Prefix => Convert_To (
- Scope (Original_Record_Component (Selector)),
- New_Copy_Tree (Target)),
- Selector_Name =>
- Make_Identifier (Loc, Name_uController));
+ Prefix => Convert_To
+ (Scope (Original_Record_Component (Selector)),
+ New_Copy_Tree (Target)),
+ Selector_Name => Make_Identifier (Loc, Name_uController));
Internal_Final_List :=
Make_Selected_Component (Loc,
- Prefix => Internal_Final_List,
+ Prefix => Internal_Final_List,
Selector_Name => Make_Identifier (Loc, Name_F));
-- The internal final list can be part of a constant object
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name =>
- Make_Identifier (Loc, Name_uC),
+ Name => Make_Identifier (Loc, Name_uC),
Expression =>
Make_Function_Call (Loc,
Name => New_Occurrence_Of (RTE (RE_Get_Prim_Op_Kind), Loc),
Make_Or_Else (Loc,
Left_Opnd =>
Make_Op_Eq (Loc,
- Left_Opnd =>
- Make_Identifier (Loc, Name_uC),
+ Left_Opnd => Make_Identifier (Loc, Name_uC),
Right_Opnd =>
New_Reference_To (RTE (RE_POK_Procedure), Loc)),
Right_Opnd =>
Make_Or_Else (Loc,
Left_Opnd =>
Make_Op_Eq (Loc,
- Left_Opnd =>
- Make_Identifier (Loc, Name_uC),
+ Left_Opnd => Make_Identifier (Loc, Name_uC),
Right_Opnd =>
- New_Reference_To (RTE (
- RE_POK_Protected_Procedure), Loc)),
+ New_Reference_To
+ (RTE (RE_POK_Protected_Procedure), Loc)),
Right_Opnd =>
Make_Op_Eq (Loc,
- Left_Opnd =>
- Make_Identifier (Loc, Name_uC),
+ Left_Opnd => Make_Identifier (Loc, Name_uC),
Right_Opnd =>
- New_Reference_To (RTE (
- RE_POK_Task_Procedure), Loc)))),
+ New_Reference_To
+ (RTE (RE_POK_Task_Procedure), Loc)))),
Then_Statements =>
New_List (
New_Reference_To
(RTU_Entity (System_Storage_Elements), Loc),
Selector_Name =>
- Make_Identifier (Loc,
- Chars => Name_Op_Subtract)),
+ Make_Identifier (Loc, Name_Op_Subtract)),
Parameter_Associations => New_List (
Ctrl_Tag,
- New_Reference_To (RTE (RE_DT_Predef_Prims_Offset),
- Loc)))))),
+ New_Reference_To
+ (RTE (RE_DT_Predef_Prims_Offset), Loc)))))),
Expressions =>
New_List (Make_Integer_Literal (Loc, Position)));
end Build_Get_Predefined_Prim_Op_Address;
Make_Function_Call (Loc,
Name =>
Make_Expanded_Name (Loc,
- Chars => Name_Op_Subtract,
- Prefix => New_Reference_To
- (RTU_Entity (System_Storage_Elements), Loc),
- Selector_Name => Make_Identifier (Loc,
- Chars => Name_Op_Subtract)),
+ Chars => Name_Op_Subtract,
+ Prefix =>
+ New_Reference_To
+ (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 (RTE (RE_DT_Offset_To_Top_Offset),
- Loc)))));
+ New_Reference_To
+ (RTE (RE_DT_Offset_To_Top_Offset), Loc)))));
end Build_Offset_To_Top;
------------------------------------------
Make_Function_Call (Loc,
Name =>
Make_Expanded_Name (Loc,
- Chars => Name_Op_Subtract,
- Prefix => New_Reference_To
- (RTU_Entity (System_Storage_Elements), Loc),
- Selector_Name => Make_Identifier (Loc,
- Chars => Name_Op_Subtract)),
+ Chars => Name_Op_Subtract,
+ Prefix =>
+ New_Reference_To
+ (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 (RTE (RE_DT_Offset_To_Top_Offset),
- Loc))))),
+ New_Reference_To
+ (RTE (RE_DT_Offset_To_Top_Offset), Loc))))),
Offset_Value);
end Build_Set_Static_Offset_To_Top;
Prefix =>
New_Reference_To
(RTU_Entity (System_Storage_Elements), Loc),
- Selector_Name =>
- Make_Identifier (Loc,
- Chars => Name_Op_Subtract)),
+ Selector_Name => Make_Identifier (Loc, Name_Op_Subtract)),
Parameter_Associations => New_List (
Tag_Node_Addr,
Make_Pragma (Loc,
Chars => Name_Import,
Pragma_Argument_Associations => New_List (
- Make_Pragma_Argument_Association (Loc,
- Expression => Lang),
+ Make_Pragma_Argument_Association (Loc, Expression => Lang),
Make_Pragma_Argument_Association (Loc,
- Expression =>
- Make_Identifier (Loc, Chars (Ent))),
+ Expression => Make_Identifier (Loc, Chars (Ent))),
Make_Pragma_Argument_Association (Loc,
- Expression =>
- Make_String_Literal (Loc, Str))))));
+ Expression => Make_String_Literal (Loc, Str))))));
Set_Entity (N, Ent);
Rewrite (N, New_Occurrence_Of (Ent, Loc));
Object_Parm :=
Make_Attribute_Reference (Loc,
- Prefix =>
- Make_Selected_Component (Loc,
- Prefix =>
- Unchecked_Convert_To (New_Itype,
- New_Reference_To
- (First_Entity
- (Protected_Body_Subprogram (Subprg)),
- Loc)),
- Selector_Name =>
- Make_Identifier (Loc, Name_uObject)),
+ Prefix =>
+ Make_Selected_Component (Loc,
+ Prefix =>
+ Unchecked_Convert_To (New_Itype,
+ New_Reference_To
+ (First_Entity
+ (Protected_Body_Subprogram (Subprg)),
+ Loc)),
+ Selector_Name =>
+ Make_Identifier (Loc, Name_uObject)),
Attribute_Name => Name_Unchecked_Access);
end;
(First_Entity
(Protected_Body_Subprogram (Subprg)),
Loc),
- Selector_Name =>
- Make_Identifier (Loc, Name_uObject)),
+ Selector_Name => Make_Identifier (Loc, Name_uObject)),
Attribute_Name => Name_Unchecked_Access);
end if;
begin
Comp :=
Make_Indexed_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Expressions => Index_List);
if Needs_Simple_Initialization (Comp_Type) then
Make_Attribute_Reference (Loc,
Prefix => Make_Identifier (Loc, Name_uInit),
Attribute_Name => Name_Range,
- Expressions => New_List (
+ Expressions => New_List (
Make_Integer_Literal (Loc, N))))),
Statements => Init_One_Dimension (N + 1)));
end if;
Decl :=
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => M_Id,
- Subtype_Mark => New_Reference_To (Standard_Integer, Loc),
- Name => Make_Identifier (Loc, Name_uMaster));
+ Subtype_Mark => New_Reference_To (Standard_Integer, Loc),
+ Name => Make_Identifier (Loc, Name_uMaster));
Insert_Before (P, Decl);
Analyze (Decl);
-- Replace the discriminant which controls the variant, with the name
-- of the formal of the checking function.
- Set_Expression (Case_Node,
- Make_Identifier (Loc, Chars (Case_Id)));
+ Set_Expression (Case_Node, Make_Identifier (Loc, Chars (Case_Id)));
Choice := First (Discrete_Choices (Variant));
Decl :=
Make_Object_Renaming_Declaration (Loc,
Defining_Identifier => M_Id,
- Subtype_Mark => New_Reference_To (RTE (RE_Master_Id), Loc),
- Name => Make_Identifier (Loc, Name_uMaster));
+ Subtype_Mark => New_Reference_To (RTE (RE_Master_Id), Loc),
+ Name => Make_Identifier (Loc, Name_uMaster));
Insert_Before (N, Decl);
Analyze (Decl);
return M_Id;
Loc := Sloc (N);
Lhs :=
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name => New_Occurrence_Of (Id, Loc));
Set_Assignment_OK (Lhs);
Make_Simple_Return_Statement (Loc,
Expression =>
Make_Attribute_Reference (Loc,
- Prefix =>
+ Prefix =>
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uO),
- Selector_Name => New_Reference_To
- (Iface_Comp, Loc)),
+ Prefix => Make_Identifier (Loc, Name_uO),
+ Selector_Name =>
+ New_Reference_To (Iface_Comp, Loc)),
Attribute_Name => Name_Position)))));
Set_Ekind (Func_Id, E_Function);
Make_Assignment_Statement (Loc,
Name =>
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name =>
New_Reference_To
(First_Tag_Component (Rec_Type), Loc)),
Make_Assignment_Statement (Loc,
Name =>
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name =>
New_Reference_To
(First_Tag_Component (Rec_Type), Loc)),
Append_To (Statement_List,
Make_Assignment_Statement (Loc,
Name => Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name => Make_Identifier (Loc, Name_uTask_Id)),
Expression => Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
- Selector_Name =>
- Make_Identifier (Loc, Name_uATCB)),
+ Prefix => Make_Identifier (Loc, Name_uInit),
+ Selector_Name => Make_Identifier (Loc, Name_uATCB)),
Attribute_Name => Name_Unchecked_Access)));
end if;
RTE (RE_Bind_Interrupt_To_Entry), Loc),
Parameter_Associations => New_List (
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
Make_Identifier (Loc, Name_uInit),
Selector_Name =>
Make_Identifier (Loc, Name_uTask_Id)),
- Entry_Index_Expression (
- Loc, Ent, Empty, Task_Type),
+ Entry_Index_Expression
+ (Loc, Ent, Empty, Task_Type),
Expression (Vis_Decl))));
end if;
end if;
Pos_Expr :=
Convert_To (Standard_Integer,
Make_Op_Subtract (Loc,
- Left_Opnd =>
- Unchecked_Convert_To (Ityp,
- Make_Identifier (Loc, Name_uA)),
- Right_Opnd =>
- Make_Integer_Literal (Loc,
- Intval =>
- Enumeration_Rep (First_Literal (Typ)))));
+ Left_Opnd =>
+ Unchecked_Convert_To
+ (Ityp, Make_Identifier (Loc, Name_uA)),
+ Right_Opnd =>
+ Make_Integer_Literal (Loc,
+ Intval => Enumeration_Rep (First_Literal (Typ)))));
end if;
Append_To (Lst,
Statements => New_List (
Make_Case_Statement (Loc,
Expression =>
- Unchecked_Convert_To (Ityp,
- Make_Identifier (Loc, Name_uA)),
+ Unchecked_Convert_To
+ (Ityp, Make_Identifier (Loc, Name_uA)),
Alternatives => Lst))));
Set_TSS (Typ, Fent);
Make_Case_Statement (Loc,
Expression =>
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_X),
+ Prefix => Make_Identifier (Loc, Name_X),
Selector_Name => New_Copy (Name (Variant_Part (CL)))),
Alternatives => Alt_List));
end if;
Left_Opnd =>
Make_Selected_Component (Loc,
Prefix => Make_Identifier (Loc, Name_X),
- Selector_Name =>
- Make_Identifier (Loc, Field_Name)),
+ Selector_Name => Make_Identifier (Loc, Field_Name)),
Right_Opnd =>
Make_Selected_Component (Loc,
Prefix => Make_Identifier (Loc, Name_Y),
- Selector_Name =>
- Make_Identifier (Loc, Field_Name))));
+ Selector_Name => Make_Identifier (Loc, Field_Name))));
end if;
Next_Non_Pragma (C);
Make_Simple_Return_Statement (Loc,
Expression =>
Make_Attribute_Reference (Loc,
- Prefix => Make_Identifier (Loc, Name_X),
+ Prefix => Make_Identifier (Loc, Name_X),
Attribute_Name => Name_Alignment)))));
Append_To (Res, Decl);
Make_Simple_Return_Statement (Loc,
Expression =>
Make_Attribute_Reference (Loc,
- Prefix => Make_Identifier (Loc, Name_X),
+ Prefix => Make_Identifier (Loc, Name_X),
Attribute_Name => Name_Size)))));
Append_To (Res, Decl);
L :=
Make_Indexed_Component (Loc,
- Prefix => Make_Identifier (Loc, Chars (A)),
+ Prefix => Make_Identifier (Loc, Chars (A)),
Expressions => Index_List1);
R :=
Make_Indexed_Component (Loc,
- Prefix => Make_Identifier (Loc, Chars (B)),
+ Prefix => Make_Identifier (Loc, Chars (B)),
Expressions => Index_List2);
Test := Expand_Composite_Equality
Flist :=
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
New_Reference_To (Associated_Final_Chain (PtrT), Loc),
- Selector_Name =>
- Make_Identifier (Loc, Name_F));
+ Selector_Name => Make_Identifier (Loc, Name_F));
Coext_Elmt := First_Elmt (Coextensions (N));
while Present (Coext_Elmt) loop
then
-- Enclosing record is an Unchecked_Union, use formal A
- if Is_Unchecked_Union (Scope
- (Entity (Selector_Name (Lhs))))
+ if Is_Unchecked_Union
+ (Scope (Entity (Selector_Name (Lhs))))
then
- Lhs_Discr_Val :=
- Make_Identifier (Loc,
- Chars => Name_A);
+ Lhs_Discr_Val := Make_Identifier (Loc, Name_A);
-- Enclosing record is of a non-Unchecked_Union type, it is
-- possible to reference the discriminant.
if Is_Unchecked_Union
(Scope (Entity (Selector_Name (Rhs))))
then
- Rhs_Discr_Val :=
- Make_Identifier (Loc,
- Chars => Name_B);
+ Rhs_Discr_Val := Make_Identifier (Loc, Name_B);
else
Rhs_Discr_Val :=
while Present (Disc) loop
Append_To (Cons,
Make_Selected_Component (Loc,
- Prefix => Duplicate_Subexpr_Move_Checks (Operand),
+ Prefix =>
+ Duplicate_Subexpr_Move_Checks (Operand),
Selector_Name =>
Make_Identifier (Loc, Chars (Disc))));
Next_Discriminant (Disc);
else
Expr :=
Make_Selected_Component (Loc,
- Prefix => Duplicate_Subexpr (Rhs),
+ Prefix => Duplicate_Subexpr (Rhs),
Selector_Name =>
Make_Identifier (Loc, Chars (Name (VP))));
end if;
Make_Selected_Component (Loc,
Prefix => Duplicate_Subexpr (Lhs),
Selector_Name =>
- Make_Identifier (Loc,
- Chars => Name_uTag)),
+ Make_Identifier (Loc, Name_uTag)),
Right_Opnd =>
Make_Selected_Component (Loc,
Prefix => Duplicate_Subexpr (Rhs),
Selector_Name =>
- Make_Identifier (Loc,
- Chars => Name_uTag))),
+ Make_Identifier (Loc, Name_uTag))),
Reason => CE_Tag_Check_Failed));
end if;
Right_Opnd => Make_Selected_Component (Loc,
Prefix => New_Occurrence_Of (Pack, Loc),
Selector_Name =>
- Make_Identifier (Loc, Chars => Name_No_Element)));
+ Make_Identifier (Loc, Name_No_Element)));
if Of_Present (I_Spec) then
if Has_Controlled_Component (T) then
Prev_Ref :=
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
Make_Selected_Component (Loc,
Prefix => Duplicate_Subexpr_No_Checks (L),
Selector_Name =>
Make_Assignment_Statement (Loc,
Name =>
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
Unchecked_Convert_To (RTE (RE_Finalizable),
New_Copy_Tree (Ctrl_Ref)),
Selector_Name => Make_Identifier (Loc, Name_Prev)),
Make_Assignment_Statement (Loc,
Name =>
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
Unchecked_Convert_To (RTE (RE_Finalizable),
New_Copy_Tree (Ctrl_Ref)),
Selector_Name => Make_Identifier (Loc, Name_Next)),
Proc : Entity_Id;
begin
- Rec :=
- Make_Identifier (Loc,
- Chars => Name_uObject);
+ Rec := Make_Identifier (Loc, Name_uObject);
Set_Etype (Rec, Corresponding_Record_Type (Scop));
-- Find enclosing protected operation, and retrieve its first parameter,
Make_Op_Ne (Loc,
Left_Opnd =>
Make_Selected_Component (Loc,
- Prefix => Duplicate_Subexpr (Exp),
- Selector_Name =>
- Make_Identifier (Loc, Chars => Name_uTag)),
+ Prefix => Duplicate_Subexpr (Exp),
+ Selector_Name => Make_Identifier (Loc, Name_uTag)),
Right_Opnd =>
Make_Attribute_Reference (Loc,
Prefix => New_Occurrence_Of (Base_Type (Utyp), Loc),
Left_Opnd =>
Make_Selected_Component (Loc,
Prefix => Duplicate_Subexpr (Exp),
- Selector_Name =>
- Make_Identifier (Loc, Chars => Name_uTag)),
+ Selector_Name => Make_Identifier (Loc, Name_uTag)),
Right_Opnd =>
Make_Attribute_Reference (Loc,
Prefix =>
return
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
Make_Selected_Component (Loc,
Prefix => R,
Selector_Name => Make_Identifier (Loc, Name_uController)),
Name => Name,
Parameter_Associations => New_List (
Make_Attribute_Reference (Loc,
- Prefix =>
+ Prefix =>
Make_Selected_Component (Loc,
- Prefix => New_Reference_To (
- Defining_Identifier (Param), Loc),
+ Prefix =>
+ New_Reference_To (Defining_Identifier (Param), Loc),
Selector_Name =>
Make_Identifier (Loc, Name_uObject)),
Attribute_Name => Name_Unchecked_Access))));
Defining_Identifier => Index,
Discrete_Subtype_Definition =>
Make_Attribute_Reference (Loc,
- Prefix => Make_Identifier (Loc, Name_V),
+ Prefix => Make_Identifier (Loc, Name_V),
Attribute_Name => Name_Range,
- Expressions => New_List (
+ Expressions => New_List (
Make_Integer_Literal (Loc, N))),
Reverse_Present => Prim = Finalize_Case)),
Statements => One_Dimension (N + 1)));
Parameter_Associations =>
New_List (New_Copy_Tree (Obj_Ref))));
- Append_To (Res, Make_Attach_Call (
- Obj_Ref => New_Copy_Tree (Obj_Ref),
- Flist_Ref => Make_Identifier (Loc, Name_L),
- With_Attach => Make_Identifier (Loc, Name_B)));
+ Append_To (Res,
+ Make_Attach_Call
+ (Obj_Ref => New_Copy_Tree (Obj_Ref),
+ Flist_Ref => Make_Identifier (Loc, Name_L),
+ With_Attach => Make_Identifier (Loc, Name_B)));
end if;
when Adjust_Case =>
Append_List_To (Res,
- Make_Adjust_Call (Controller_Ref, Controller_Typ,
- Make_Identifier (Loc, Name_L),
- Make_Identifier (Loc, Name_B)));
+ Make_Adjust_Call
+ (Controller_Ref, Controller_Typ,
+ Make_Identifier (Loc, Name_L),
+ Make_Identifier (Loc, Name_B)));
-- When the type is also a controlled type by itself,
-- adjust it and attach it to the finalization chain.
Parameter_Associations =>
New_List (New_Copy_Tree (Obj_Ref))));
- Append_To (Res, Make_Attach_Call (
- Obj_Ref => New_Copy_Tree (Obj_Ref),
- Flist_Ref => Make_Identifier (Loc, Name_L),
- With_Attach => Make_Identifier (Loc, Name_B)));
+ Append_To (Res,
+ Make_Attach_Call
+ (Obj_Ref => New_Copy_Tree (Obj_Ref),
+ Flist_Ref => Make_Identifier (Loc, Name_L),
+ With_Attach => Make_Identifier (Loc, Name_B)));
end if;
when Finalize_Case =>
if Is_Controlled (Typ) then
Append_To (Res,
Make_Implicit_If_Statement (Obj_Ref,
- Condition => Make_Identifier (Loc, Name_B),
+ Condition => Make_Identifier (Loc, Name_B),
Then_Statements => New_List (
Make_Procedure_Call_Statement (Loc,
Name => New_Reference_To (RTE (RE_Finalize_One), Loc),
end if;
Append_List_To (Res,
- Make_Final_Call (Controller_Ref, Controller_Typ,
- Make_Identifier (Loc, Name_B)));
+ Make_Final_Call
+ (Controller_Ref, Controller_Typ,
+ Make_Identifier (Loc, Name_B)));
end case;
+
return Res;
end Make_Deep_Record_Body;
Statements => New_List (
Make_Simple_Return_Statement (Loc,
Expression =>
- Expand_Record_Equality (
- Id,
+ Expand_Record_Equality
+ (Id,
Typ => Typ,
Lhs =>
- Make_Identifier (Loc,
- Chars (First_Formal (Id))),
+ Make_Identifier (Loc, Chars (First_Formal (Id))),
Rhs =>
- Make_Identifier (Loc,
- Chars (Next_Formal (First_Formal (Id)))),
+ Make_Identifier
+ (Loc, Chars (Next_Formal (First_Formal (Id)))),
Bodies => Declarations (Decl))))));
Append (Decl, List_Containing (N));
Name =>
Make_Explicit_Dereference (Loc,
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
Unchecked_Convert_To (Entry_Parameters_Type (Ent),
Make_Identifier (Loc, Chars (Ptr))),
- Selector_Name =>
- New_Reference_To (Comp, Loc))));
+ Selector_Name => New_Reference_To (Comp, Loc))));
Append (Decl, Decls);
Set_Renamed_Object (Formal, New_F);
Object_Definition =>
New_Reference_To (Obj_Ptr, Loc),
Expression =>
- Unchecked_Convert_To (Obj_Ptr,
- Make_Identifier (Loc, Name_uO)));
+ Unchecked_Convert_To (Obj_Ptr, Make_Identifier (Loc, Name_uO)));
Set_Debug_Info_Needed (Defining_Identifier (Decl));
Prepend_To (Decls, Decl);
Actuals := New_List;
while Present (Formal) loop
Append_To (Actuals,
- Make_Identifier (Loc, Chars =>
- Chars (Defining_Identifier (Formal))));
-
+ Make_Identifier (Loc,
+ Chars => Chars (Defining_Identifier (Formal))));
Next (Formal);
end loop;
end if;
else
Prepend_To (Actuals,
- Make_Identifier (Loc, Chars =>
- Chars (Defining_Identifier (First_Form))));
+ Make_Identifier (Loc,
+ Chars => Chars (Defining_Identifier (First_Form))));
end if;
Nam := New_Reference_To (Subp_Id, Loc);
Cond :=
Make_Op_Le (Loc,
- Left_Opnd => Make_Identifier (Loc, Name_uE),
+ Left_Opnd => Make_Identifier (Loc, Name_uE),
Right_Opnd => Siz);
-- Map entry queue indexes in the range of the current family
Make_Attribute_Reference (End_Loc,
Prefix =>
Make_Selected_Component (End_Loc,
- Prefix =>
- Make_Identifier (End_Loc, Name_uObject),
- Selector_Name =>
- Make_Identifier (End_Loc, Name_uObject)),
+ Prefix => Make_Identifier (End_Loc, Name_uObject),
+ Selector_Name => Make_Identifier (End_Loc, Name_uObject)),
Attribute_Name => Name_Unchecked_Access))));
-- When exceptions can not be propagated, we never need to call
Make_Attribute_Reference (Han_Loc,
Prefix =>
Make_Selected_Component (Han_Loc,
- Prefix =>
+ Prefix =>
Make_Identifier (Han_Loc, Name_uObject),
Selector_Name =>
Make_Identifier (Han_Loc, Name_uObject)),
Uactuals := New_List;
Pformal := First (Parameter_Specifications (P_Op_Spec));
while Present (Pformal) loop
- Append (
- Make_Identifier (Loc, Chars (Defining_Identifier (Pformal))),
- Uactuals);
+ Append_To (Uactuals,
+ Make_Identifier (Loc, Chars (Defining_Identifier (Pformal))));
Next (Pformal);
end loop;
Expression =>
Make_Function_Call (Loc,
Name => Make_Identifier (Loc,
- Chars (Defining_Unit_Name (N_Op_Spec))),
+ Chars => Chars (Defining_Unit_Name (N_Op_Spec))),
Parameter_Associations => Uactuals));
Return_Stmt :=
Expression => Make_Function_Call (Loc,
Name =>
Make_Identifier (Loc,
- Chars (Defining_Unit_Name (N_Op_Spec))),
+ Chars => Chars (Defining_Unit_Name (N_Op_Spec))),
Parameter_Associations => Uactuals));
end if;
Unprot_Call :=
Make_Procedure_Call_Statement (Loc,
Name =>
- Make_Identifier (Loc,
- Chars (Defining_Unit_Name (N_Op_Spec))),
+ Make_Identifier (Loc, Chars (Defining_Unit_Name (N_Op_Spec))),
Parameter_Associations => Uactuals);
end if;
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix =>
- Make_Identifier (Loc, Name_uObject),
- Selector_Name =>
- Make_Identifier (Loc, Name_uObject)),
+ Prefix => Make_Identifier (Loc, Name_uObject),
+ Selector_Name => Make_Identifier (Loc, Name_uObject)),
Attribute_Name => Name_Unchecked_Access);
Lock_Stmt := Make_Procedure_Call_Statement (Loc,
return
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
Unchecked_Convert_To (Corresponding_Record_Type (Ntyp),
New_Copy_Tree (N)),
Selector_Name => Make_Identifier (Loc, Sel));
New_Reference_To (RTE (RO_ST_Task_Id), Loc),
Expression =>
Make_Selected_Component (Loc,
- Prefix =>
- New_Copy_Tree (Tasknm),
+ Prefix => New_Copy_Tree (Tasknm),
Selector_Name =>
Make_Identifier (Loc, Name_uDisp_Get_Task_Id)))));
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
New_Reference_To (RTE (RE_Communication_Block), Loc),
- Expression =>
- Make_Identifier (Loc, Name_uD))));
+ Expression => Make_Identifier (Loc, Name_uD))));
-- Generate:
-- _Disp_Asynchronous_Select (<object>, S, P'Address, D, B);
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
New_Reference_To (RTE (RE_Communication_Block), Loc),
- Expression =>
- Make_Identifier (Loc, Name_uD))));
+ Expression => Make_Identifier (Loc, Name_uD))));
-- Generate:
-- _Disp_Asynchronous_Select (<object>, S, P'Address, D, B);
Make_Procedure_Call_Statement (Loc,
Name =>
Make_Selected_Component (Loc,
- Prefix =>
- Make_Identifier (Loc, Chars (Obj)),
- Selector_Name =>
- Make_Identifier (Loc, Chars (Call_Ent))),
+ Prefix => Make_Identifier (Loc, Chars (Obj)),
+ Selector_Name => Make_Identifier (Loc, Chars (Call_Ent))),
Parameter_Associations => Actuals);
end Build_Dispatching_Call_Equivalent;
return
Make_Procedure_Call_Statement (Loc,
- Name =>
- Make_Identifier (Loc, Name_uDisp_Requeue),
+ Name => Make_Identifier (Loc, Name_uDisp_Requeue),
Parameter_Associations => Params);
end Build_Dispatching_Requeue;
Cond := Make_Op_Ne (Loc,
Left_Opnd =>
Make_Selected_Component (Loc,
- Prefix => Make_Indexed_Component (Loc,
- Prefix => New_Reference_To (Qnam, Loc),
- Expressions => New_List (New_Reference_To (J, Loc))),
- Selector_Name => Make_Identifier (Loc, Name_S)),
+ Prefix =>
+ Make_Indexed_Component (Loc,
+ Prefix => New_Reference_To (Qnam, Loc),
+ Expressions => New_List (New_Reference_To (J, Loc))),
+ Selector_Name => Make_Identifier (Loc, Name_S)),
Right_Opnd =>
New_Reference_To (RTE (RE_Null_Task_Entry), Loc));
New_Reference_To (RTE (Prot_Typ), Loc),
Name =>
Make_Selected_Component (Loc,
- Prefix =>
- New_Reference_To (Obj_Ent, Loc),
- Selector_Name =>
- Make_Identifier (Loc, Name_uObject)));
+ Prefix => New_Reference_To (Obj_Ent, Loc),
+ Selector_Name => Make_Identifier (Loc, Name_uObject)));
Add (Decl);
end;
end if;
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name => Make_Identifier (Loc, Name_uObject)),
Attribute_Name => Name_Unchecked_Access));
then
Append_To (Args,
Make_Attribute_Reference (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Attribute_Name => Name_Address));
end if;
Make_Attribute_Reference (Loc,
Prefix =>
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name => Make_Identifier (Loc, Name_uObject)),
Attribute_Name => Name_Unchecked_Access));
if Present (Tdef) and then Has_Pragma_Priority (Tdef) then
Append_To (Args,
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name => Make_Identifier (Loc, Name_uPriority)));
else
Append_To (Args,
if Preallocated_Stacks_On_Target then
Append_To (Args,
Make_Attribute_Reference (Loc,
- Prefix => Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
- Selector_Name =>
- Make_Identifier (Loc, Name_uStack)),
+ Prefix =>
+ Make_Selected_Component (Loc,
+ Prefix => Make_Identifier (Loc, Name_uInit),
+ Selector_Name => Make_Identifier (Loc, Name_uStack)),
Attribute_Name => Name_Address));
else
then
Append_To (Args,
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name => Make_Identifier (Loc, Name_uSize)));
else
then
Append_To (Args,
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name => Make_Identifier (Loc, Name_uTask_Info)));
else
Append_To (Args,
Convert_To (Standard_Integer,
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name => Make_Identifier (Loc, Name_uCPU))));
else
if Present (Tdef) and then Has_Relative_Deadline_Pragma (Tdef) then
Append_To (Args,
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix =>
+ Make_Identifier (Loc, Name_uInit),
Selector_Name =>
Make_Identifier (Loc, Name_uRelative_Deadline)));
Append_To (Args,
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix => Make_Identifier (Loc, Name_uInit),
Selector_Name => Make_Identifier (Loc, Name_uTask_Id)));
-- Build_Entry_Names generation flag. When set to true, the runtime
Expression =>
Make_Explicit_Dereference (Loc,
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
New_Reference_To (P, Loc),
Selector_Name =>
Make_Identifier (Loc, Chars (Formal)))));
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
New_Reference_To
- (RTE (RE_Protected_Entry_Index), Loc),
+ (RTE (RE_Protected_Entry_Index), Loc),
Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uP), -- parameter block
- New_Reference_To ( -- Asynchronous_Call
- RTE (RE_Asynchronous_Call), Loc),
+ New_Reference_To -- Asynchronous_Call
+ (RTE (RE_Asynchronous_Call), Loc),
New_Reference_To (Com_Block, Loc)))); -- comm block
Obj_Ref,
Make_Attribute_Reference (Loc,
- Prefix => Make_Identifier (Loc, Name_uP),
+ Prefix => Make_Identifier (Loc, Name_uP),
Attribute_Name => Name_Address),
New_Reference_To
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name =>
- Make_Identifier (Loc, Name_uB),
+ Name => Make_Identifier (Loc, Name_uB),
Expression =>
Make_Unchecked_Type_Conversion (Loc,
Subtype_Mark =>
Parameter_Associations =>
New_List (
Make_Selected_Component (Loc, -- T._task_id
- Prefix =>
- Make_Identifier (Loc, Name_uT),
- Selector_Name =>
- Make_Identifier (Loc, Name_uTask_Id)),
+ Prefix => Make_Identifier (Loc, Name_uT),
+ Selector_Name => Make_Identifier (Loc, Name_uTask_Id)),
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
- Expression =>
- Make_Identifier (Loc, Name_uI)),
+ Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uP), -- parameter block
- New_Reference_To ( -- Asynchronous_Call
- RTE (RE_Asynchronous_Call), Loc),
+ New_Reference_To -- 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_uI),
+ Name => Make_Identifier (Loc, Name_uI),
Expression =>
Make_Function_Call (Loc,
Name =>
Obj_Ref,
Make_Attribute_Reference (Loc,
- Prefix => Make_Identifier (Loc, Name_uP),
+ Prefix => Make_Identifier (Loc, Name_uP),
Attribute_Name => Name_Address),
New_Reference_To
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name =>
- Make_Identifier (Loc, Name_uF),
+ Name => Make_Identifier (Loc, Name_uF),
Expression =>
Make_Op_Not (Loc,
Right_Opnd =>
New_List (
Make_Selected_Component (Loc, -- T._task_id
- Prefix =>
- Make_Identifier (Loc, Name_uT),
- Selector_Name =>
- Make_Identifier (Loc, Name_uTask_Id)),
+ Prefix => Make_Identifier (Loc, Name_uT),
+ Selector_Name => Make_Identifier (Loc, Name_uTask_Id)),
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
- Expression =>
- Make_Identifier (Loc, Name_uI)),
+ 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 -- Conditional_Call
+ (RTE (RE_Conditional_Call), Loc),
Make_Identifier (Loc, Name_uF)))); -- status flag
end if;
New_Reference_To (RTE (RE_Address), Loc),
Expression =>
Make_Selected_Component (Loc,
- Prefix =>
- Make_Identifier (Loc, Name_uT),
- Selector_Name =>
- Make_Identifier (Loc, Name_uTask_Id))));
+ Prefix => Make_Identifier (Loc, Name_uT),
+ Selector_Name => Make_Identifier (Loc, Name_uTask_Id))));
-- A null body is constructed for non-task types
else
Append_To (Stmts,
Make_If_Statement (Loc,
- Condition =>
- Make_Identifier (Loc, Name_uF),
+ Condition => Make_Identifier (Loc, Name_uF),
Then_Statements =>
New_List (
Name_Unchecked_Access,
Prefix =>
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
Make_Identifier (Loc, Name_uO),
Selector_Name =>
Make_Identifier (Loc, Name_uObject))),
Subtype_Mark =>
New_Reference_To (
RTE (RE_Protected_Entry_Index), Loc),
- Expression =>
- Make_Identifier (Loc, Name_uI)),
+ Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uA)))), -- abort status
Append_To (Stmts,
Make_If_Statement (Loc,
- Condition =>
- Make_Identifier (Loc, Name_uF),
+ Condition => Make_Identifier (Loc, Name_uF),
- Then_Statements =>
- New_List (
+ Then_Statements => New_List (
- -- Call to Requeue_Protected_To_Task_Entry
+ -- Call to Requeue_Protected_To_Task_Entry
- Make_Procedure_Call_Statement (Loc,
- Name =>
- New_Reference_To (
- RTE (RE_Requeue_Protected_To_Task_Entry), Loc),
+ Make_Procedure_Call_Statement (Loc,
+ Name =>
+ New_Reference_To
+ (RTE (RE_Requeue_Protected_To_Task_Entry), Loc),
- Parameter_Associations =>
- New_List (
+ Parameter_Associations => New_List (
- Make_Unchecked_Type_Conversion (Loc, -- PEA (P)
- Subtype_Mark =>
- New_Reference_To (
- RTE (RE_Protection_Entries_Access), Loc),
- Expression =>
- Make_Identifier (Loc, Name_uP)),
+ Make_Unchecked_Type_Conversion (Loc, -- PEA (P)
+ Subtype_Mark =>
+ New_Reference_To
+ (RTE (RE_Protection_Entries_Access), Loc),
+ Expression => Make_Identifier (Loc, Name_uP)),
- Make_Selected_Component (Loc, -- O._task_id
- Prefix =>
- Make_Identifier (Loc, Name_uO),
- Selector_Name =>
- Make_Identifier (Loc, Name_uTask_Id)),
+ Make_Selected_Component (Loc, -- O._task_id
+ Prefix => Make_Identifier (Loc, Name_uO),
+ Selector_Name => Make_Identifier (Loc, Name_uTask_Id)),
- Make_Unchecked_Type_Conversion (Loc, -- entry index
- Subtype_Mark =>
- New_Reference_To (
- RTE (RE_Task_Entry_Index), Loc),
- Expression =>
- Make_Identifier (Loc, Name_uI)),
+ Make_Unchecked_Type_Conversion (Loc, -- entry index
+ Subtype_Mark =>
+ New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
+ Expression => Make_Identifier (Loc, Name_uI)),
- Make_Identifier (Loc, Name_uA)))), -- abort status
+ Make_Identifier (Loc, Name_uA)))), -- abort status
- Else_Statements =>
- New_List (
+ Else_Statements => New_List (
- -- Call to Requeue_Task_Entry
+ -- Call to Requeue_Task_Entry
- Make_Procedure_Call_Statement (Loc,
- Name =>
- New_Reference_To (RTE (RE_Requeue_Task_Entry), Loc),
+ Make_Procedure_Call_Statement (Loc,
+ Name => New_Reference_To (RTE (RE_Requeue_Task_Entry), Loc),
- Parameter_Associations =>
- New_List (
+ Parameter_Associations => New_List (
- Make_Selected_Component (Loc, -- O._task_id
- Prefix =>
- Make_Identifier (Loc, Name_uO),
- Selector_Name =>
- Make_Identifier (Loc, Name_uTask_Id)),
+ Make_Selected_Component (Loc, -- O._task_id
+ Prefix => Make_Identifier (Loc, Name_uO),
+ Selector_Name => Make_Identifier (Loc, Name_uTask_Id)),
- Make_Unchecked_Type_Conversion (Loc, -- entry index
- Subtype_Mark =>
- New_Reference_To (
- RTE (RE_Task_Entry_Index), Loc),
- Expression =>
- Make_Identifier (Loc, Name_uI)),
+ Make_Unchecked_Type_Conversion (Loc, -- entry index
+ Subtype_Mark =>
+ New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
+ Expression => Make_Identifier (Loc, Name_uI)),
- Make_Identifier (Loc, Name_uA)))))); -- abort status
+ Make_Identifier (Loc, Name_uA)))))); -- abort status
end if;
-- Even though no declarations are needed in both cases, we allocate
Append_To (Stmts,
Make_Assignment_Statement (Loc,
- Name =>
- Make_Identifier (Loc, Name_uI),
+ Name => Make_Identifier (Loc, Name_uI),
Expression =>
Make_Function_Call (Loc,
Name =>
New_List (
Make_Selected_Component (Loc, -- T._task_id
- Prefix =>
- Make_Identifier (Loc, Name_uT),
- Selector_Name =>
- Make_Identifier (Loc, Name_uTask_Id)),
+ Prefix => Make_Identifier (Loc, Name_uT),
+ Selector_Name => Make_Identifier (Loc, Name_uTask_Id)),
Make_Unchecked_Type_Conversion (Loc, -- entry index
Subtype_Mark =>
New_Reference_To (RTE (RE_Task_Entry_Index), Loc),
- Expression =>
- Make_Identifier (Loc, Name_uI)),
+ Expression => Make_Identifier (Loc, Name_uI)),
Make_Identifier (Loc, Name_uP), -- parameter block
Make_Identifier (Loc, Name_uD), -- delay
New_Reference_To (Node (Tag_Elmt), Loc),
Expression =>
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_uInit),
+ Prefix =>
+ Make_Identifier (Loc, Name_uInit),
Selector_Name =>
New_Reference_To (Tag_Comp, Loc))));
Prefix => Request_Parameter,
Selector_Name => Name_Params))))),
- Selector_Name =>
- Make_Identifier (Loc, Name_Subp_Id))))));
+ Selector_Name => Make_Identifier (Loc, Name_Subp_Id))))));
-- Build a subprogram for RAS information lookups
Make_Aggregate (Loc,
Component_Associations => New_List (
Make_Component_Association (Loc,
- Choices => New_List (
- Make_Identifier (Loc, Name_Ras)),
+ Choices => New_List (Make_Identifier (Loc, Name_Ras)),
Expression =>
PolyORB_Support.Helpers.Build_From_Any_Call (
Underlying_RACW_Type (RAS_Type),
else
Target_Info.Object :=
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Chars (RCI_Locator)),
+ Prefix =>
+ Make_Identifier (Loc, Chars (RCI_Locator)),
Selector_Name =>
Make_Identifier (Loc, Name_Get_RCI_Package_Ref));
end if;
New_Occurrence_Of (RTE (RE_Get_Local_Address), Loc),
Parameter_Associations => New_List (
Make_Selected_Component (Loc,
- Prefix =>
+ Prefix =>
New_Occurrence_Of (
Request_Parameter, Loc),
Selector_Name =>
Left_Opnd =>
Make_Op_Add (Loc,
Left_Opnd =>
- OK_Convert_To (
- Standard_Long_Integer,
- Make_Identifier (Loc, Lnam)),
+ OK_Convert_To
+ (Standard_Long_Integer,
+ Make_Identifier (Loc, Lnam)),
Right_Opnd =>
- OK_Convert_To (
- Standard_Long_Integer,
- Make_Function_Call (Loc,
- Name =>
- New_Occurrence_Of (RTE (
- RE_Get_Nested_Sequence_Length
- ), Loc),
- Parameter_Associations =>
- New_List (
- New_Occurrence_Of (
- Any_Parameter, Loc),
- Make_Integer_Literal (Loc,
- Intval => J))))),
+ OK_Convert_To
+ (Standard_Long_Integer,
+ Make_Function_Call (Loc,
+ Name =>
+ New_Occurrence_Of (RTE (
+ RE_Get_Nested_Sequence_Length
+ ), Loc),
+ Parameter_Associations =>
+ New_List (
+ New_Occurrence_Of (
+ Any_Parameter, Loc),
+ Make_Integer_Literal (Loc,
+ Intval => J))))),
Right_Opnd =>
Make_Integer_Literal (Loc, 1))))));
(Loc,
Name_Export,
New_List
- (Make_Pragma_Argument_Association
- (Sloc => Loc,
- Expression => Make_Identifier (Loc, Name_C)),
+ (Make_Pragma_Argument_Association (Loc,
+ Expression => Make_Identifier (Loc, Name_C)),
- Make_Pragma_Argument_Association
- (Sloc => Loc,
- Expression =>
- New_Reference_To (Excep_Internal, Loc)),
+ Make_Pragma_Argument_Association (Loc,
+ Expression =>
+ New_Reference_To (Excep_Internal, Loc)),
- Make_Pragma_Argument_Association
- (Sloc => Loc,
- Expression =>
- Make_String_Literal
- (Sloc => Loc,
- Strval => Excep_Image)),
+ Make_Pragma_Argument_Association (Loc,
+ Expression =>
+ Make_String_Literal (Loc, Excep_Image)),
- Make_Pragma_Argument_Association
- (Sloc => Loc,
+ Make_Pragma_Argument_Association (Loc,
Expression =>
- Make_String_Literal
- (Sloc => Loc,
- Strval => Excep_Image))));
+ Make_String_Literal (Loc, Excep_Image))));
Insert_Action (N, Export_Pragma);
Analyze (Export_Pragma);
Name => Make_Selected_Component (Loc,
Prefix =>
New_Occurrence_Of (Shared_Var_Procs_Instance (E), Loc),
- Selector_Name => Make_Identifier (Loc, Chars => N)));
+ Selector_Name => Make_Identifier (Loc, N)));
end Build_Shared_Var_Proc_Call;
---------------------
Object_Definition => New_Occurrence_Of (Etype (Indx), Loc),
Expression =>
Make_Attribute_Reference (Loc,
- Prefix =>
+ Prefix =>
New_Occurrence_Of (Stream_Base_Type (Etype (Indx)), Loc),
Attribute_Name => Name_Input,
- Expressions => New_List (Make_Identifier (Loc, Name_S)))));
+ Expressions => New_List (Make_Identifier (Loc, Name_S)))));
Append_To (Decls,
Make_Object_Declaration (Loc,
New_Occurrence_Of (Stream_Base_Type (Etype (Indx)), Loc),
Expression =>
Make_Attribute_Reference (Loc,
- Prefix =>
+ Prefix =>
New_Occurrence_Of (Stream_Base_Type (Etype (Indx)), Loc),
Attribute_Name => Name_Input,
- Expressions => New_List (Make_Identifier (Loc, Name_S)))));
+ Expressions => New_List (Make_Identifier (Loc, Name_S)))));
Append_To (Ranges,
Make_Range (Loc,
Expressions => New_List (
Make_Identifier (Loc, Name_S),
Make_Attribute_Reference (Loc,
- Prefix => Make_Identifier (Loc, Name_V),
+ Prefix => Make_Identifier (Loc, Name_V),
Attribute_Name => Name_First,
- Expressions => New_List (
+ Expressions => New_List (
Make_Integer_Literal (Loc, J))))));
Append_To (Stms,
Expressions => New_List (
Make_Identifier (Loc, Name_S),
Make_Attribute_Reference (Loc,
- Prefix => Make_Identifier (Loc, Name_V),
+ Prefix => Make_Identifier (Loc, Name_V),
Attribute_Name => Name_Last,
- Expressions => New_List (
+ Expressions => New_List (
Make_Integer_Literal (Loc, J))))));
Next_Index (Indx);
Expressions => New_List (
Make_Identifier (Loc, Name_S),
Make_Indexed_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_V),
+ Prefix => Make_Identifier (Loc, Name_V),
Expressions => Exl)));
-- The corresponding stream attribute for the component type of the
Discrete_Subtype_Definition =>
Make_Attribute_Reference (Loc,
- Prefix => Make_Identifier (Loc, Name_V),
+ Prefix => Make_Identifier (Loc, Name_V),
Attribute_Name => Name_Range,
Expressions => New_List (
Out_Formal :=
Make_Selected_Component (Loc,
- Prefix => New_Occurrence_Of (Pnam, Loc),
+ Prefix => New_Occurrence_Of (Pnam, Loc),
Selector_Name => Make_Identifier (Loc, Name_V));
-- Generate Reads for the discriminants of the type. The discriminants
Append_To (Constrained_Stms,
Make_Assignment_Statement (Loc,
- Name => Out_Formal,
+ Name => Out_Formal,
Expression => Make_Identifier (Loc, Name_V)));
if Is_Unchecked_Union (Typ) then
else
D_Ref :=
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_V),
+ Prefix => Make_Identifier (Loc, Name_V),
Selector_Name => New_Occurrence_Of (Disc, Loc));
end if;
Make_Attribute_Reference (Loc,
Prefix => New_Occurrence_Of (Etype (Disc), Loc),
Attribute_Name => Name_Write,
- Expressions => New_List (
+ Expressions => New_List (
Make_Identifier (Loc, Name_S),
D_Ref)));
else
Disc_Ref :=
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_V),
+ Prefix => Make_Identifier (Loc, Name_V),
Selector_Name => New_Occurrence_Of (Disc, Loc));
end if;
else
D_Ref :=
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_V),
+ Prefix => Make_Identifier (Loc, Name_V),
Selector_Name =>
New_Occurrence_Of (Entity (Name (VP)), Loc));
end if;
Expressions => New_List (
Make_Identifier (Loc, Name_S),
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Name_V),
+ Prefix => Make_Identifier (Loc, Name_V),
Selector_Name => New_Occurrence_Of (C, Loc))));
end Make_Field_Attribute;
begin
return
Make_Pragma (Loc,
- Pragma_Identifier =>
- Make_Identifier (Loc,
- Name_Check),
+ Pragma_Identifier => Make_Identifier (Loc, Name_Check),
Pragma_Argument_Associations => New_List (
Make_Pragma_Argument_Association (Loc,
- Expression =>
- Make_Identifier (Loc,
- Chars => Name_Predicate)),
+ Expression => Make_Identifier (Loc, Name_Predicate)),
Make_Pragma_Argument_Association (Loc,
Expression => Make_Predicate_Call (Typ, Expr))));
end Make_Predicate_Check;
declare
CS : constant Boolean := Comes_From_Source (N);
begin
- Rewrite (N, Make_Identifier (Sloc (N), Chars => Chars (E)));
+ Rewrite (N, Make_Identifier (Sloc (N), Chars (E)));
Set_Entity (N, E);
Set_Comes_From_Source (N, CS);
Set_Analyzed (N, True);
switches.
The default linker called by gnatlink is @command{gcc} which in
turn calls the appropriate system linker.
+
+One useful option for the linker is @option{-s}: it reduces the size of the
+executable by removing all symbol table and relocation information from the
+executable.
+
Standard options for the linker such as @option{-lmy_lib} or
@option{-Ldir} can be added as is.
For options that are not recognized by
@command{gcc} as linker options, use the @command{gcc} switches
@option{-Xlinker} or @option{-Wl,}.
+
Refer to the GCC documentation for
-details. Here is an example showing how to generate a linker map:
+details.
+
+Here is an example showing how to generate a linker map:
@smallexample
$ ^gnatlink my_prog -Wl,-Map,MAPFILE^GNAT LINK my_prog.ali /MAP^
Name => New_Occurrence_Of (Ent, Loc),
Parameter_Associations => New_List (
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Chars => Vname),
+ Prefix => Make_Identifier (Loc, Vname),
Selector_Name => New_Occurrence_Of (Comp, Loc))));
else
Make_Function_Call (Loc,
Name => New_Occurrence_Of (Ent, Loc),
Parameter_Associations => New_List (
- Make_Identifier (Loc, Chars => Vname)));
+ Make_Identifier (Loc, Vname)));
end if;
else
N :=
Make_Selected_Component (Loc,
- Prefix => Make_Identifier (Loc, Chars => Vname),
+ Prefix => Make_Identifier (Loc, Vname),
Selector_Name => New_Occurrence_Of (Entity (N), Loc));
-- Set the Etype attributes of the selected name and its prefix.
Make_Function_Call (Loc,
Name => New_Occurrence_Of (RMS_Ent, Loc),
Parameter_Associations => New_List (
- Make_Identifier (Loc, Chars => Vname)));
+ Make_Identifier (Loc, Vname)));
-- If the size is represented by a constant, then the
-- expression we want is a reference to this constant
Discrim :=
Make_Selected_Component (Loc,
Prefix =>
- Make_Identifier (Loc, Chars => Vname),
+ Make_Identifier (Loc, Vname),
Selector_Name =>
New_Occurrence_Of
(Entity (Name (Vpart)), Loc));
Append (
Make_Selected_Component (Loc,
Prefix =>
- Make_Identifier (Loc, Chars => Vname),
+ Make_Identifier (Loc, Vname),
Selector_Name =>
- New_Occurrence_Of
- (D_Entity, Loc)),
+ New_Occurrence_Of (D_Entity, Loc)),
D_List);
D_Entity := Next_Discriminant (D_Entity);
Checksum_Accumulate_Token_Checksum : Boolean := True;
-- GPRBUILD
- -- Set to False by gprbuild when the version of GNAT is 5.02 or before.
+ -- Set to False by gprbuild when the version of GNAT is 5.02 or before. If
+ -- this switch is False, then we do not call Accumulate_Token_Checksum, so
+ -- the setting of the following two flags is irrelevant.
Checksum_GNAT_6_3 : Boolean := False;
-- GPRBUILD
-- and we need to fix it.
if Nkind (Ident_Node) = N_Defining_Identifier then
- Ident_Node :=
- Make_Identifier (Sloc (Ident_Node),
- Chars => Chars (Ident_Node));
+ Ident_Node := Make_Identifier (Sloc (Ident_Node), Chars (Ident_Node));
end if;
-- Change identifier to defining identifier if not in error
when Tok_Left_Paren =>
Typedef_Node := P_Enumeration_Type_Definition;
- End_Labl :=
- Make_Identifier (Token_Ptr,
- Chars => Chars (Ident_Node));
+ End_Labl := Make_Identifier (Token_Ptr, Chars (Ident_Node));
Set_Comes_From_Source (End_Labl, False);
Set_End_Label (Typedef_Node, End_Labl);
if Nkind (Typedef_Node) = N_Derived_Type_Definition
and then Present (Record_Extension_Part (Typedef_Node))
then
- End_Labl :=
- Make_Identifier (Token_Ptr,
- Chars => Chars (Ident_Node));
+ End_Labl := Make_Identifier (Token_Ptr, Chars (Ident_Node));
Set_Comes_From_Source (End_Labl, False);
Set_End_Label
when Tok_Record =>
Typedef_Node := P_Record_Definition;
- End_Labl :=
- Make_Identifier (Token_Ptr,
- Chars => Chars (Ident_Node));
+ End_Labl := Make_Identifier (Token_Ptr, Chars (Ident_Node));
Set_Comes_From_Source (End_Labl, False);
Set_End_Label (Typedef_Node, End_Labl);
Set_Limited_Present (Typedef_Node, True);
End_Labl :=
- Make_Identifier (Token_Ptr,
- Chars => Chars (Ident_Node));
+ Make_Identifier (Token_Ptr, Chars (Ident_Node));
Set_Comes_From_Source (End_Labl, False);
Set_End_Label (Typedef_Node, End_Labl);
Set_Tagged_Present (Typedef_Node, True);
End_Labl :=
- Make_Identifier (Token_Ptr,
- Chars => Chars (Ident_Node));
+ Make_Identifier (Token_Ptr, Chars (Ident_Node));
Set_Comes_From_Source (End_Labl, False);
Set_End_Label (Typedef_Node, End_Labl);
and then Present (Record_Extension_Part (Typedef_Node))
then
End_Labl :=
- Make_Identifier (Token_Ptr,
- Chars => Chars (Ident_Node));
+ Make_Identifier (Token_Ptr, Chars (Ident_Node));
Set_Comes_From_Source (End_Labl, False);
Set_End_Label
if No (Loop_Name) then
Created_Name :=
- Make_Identifier (Sloc (Loop_Node),
- Chars => Set_Loop_Block_Name ('L'));
+ Make_Identifier (Sloc (Loop_Node), Set_Loop_Block_Name ('L'));
Set_Comes_From_Source (Created_Name, False);
Set_Has_Created_Identifier (Loop_Node, True);
Set_Identifier (Loop_Node, Created_Name);
if No (Loop_Name) then
Created_Name :=
- Make_Identifier (Sloc (Loop_Node),
- Chars => Set_Loop_Block_Name ('L'));
+ Make_Identifier (Sloc (Loop_Node), Set_Loop_Block_Name ('L'));
Set_Comes_From_Source (Created_Name, False);
Set_Has_Created_Identifier (Loop_Node, True);
Set_Identifier (Loop_Node, Created_Name);
if No (Loop_Name) then
Created_Name :=
- Make_Identifier (Sloc (Loop_Node),
- Chars => Set_Loop_Block_Name ('L'));
+ Make_Identifier (Sloc (Loop_Node), Set_Loop_Block_Name ('L'));
Set_Comes_From_Source (Created_Name, False);
Set_Has_Created_Identifier (Loop_Node, True);
Set_Identifier (Loop_Node, Created_Name);
if No (Block_Name) then
Created_Name :=
- Make_Identifier (Sloc (Block_Node),
- Chars => Set_Loop_Block_Name ('B'));
+ Make_Identifier (Sloc (Block_Node), Set_Loop_Block_Name ('B'));
Set_Comes_From_Source (Created_Name, False);
Set_Has_Created_Identifier (Block_Node, True);
Set_Identifier (Block_Node, Created_Name);
if No (Block_Name) then
Created_Name :=
- Make_Identifier (Sloc (Block_Node),
- Chars => Set_Loop_Block_Name ('B'));
+ Make_Identifier (Sloc (Block_Node), Set_Loop_Block_Name ('B'));
Set_Comes_From_Source (Created_Name, False);
Set_Has_Created_Identifier (Block_Node, True);
Set_Identifier (Block_Node, Created_Name);
Copy_Name (Selector_Name (N)));
else
- R :=
- Make_Identifier (Token_Ptr,
- Chars => Chars (N));
+ R := Make_Identifier (Token_Ptr, Chars (N));
Set_Comes_From_Source (N, False);
return R;
end if;
elsif Nkind (End_Labl) = N_Defining_Identifier
or else Nkind (End_Labl) = N_Identifier
then
- End_Labl :=
- Make_Identifier (Token_Ptr,
- Chars => Chars (End_Labl));
+ End_Labl := Make_Identifier (Token_Ptr, Chars (End_Labl));
elsif Nkind (End_Labl) = N_Defining_Operator_Symbol
or else Nkind (End_Labl) = N_Operator_Symbol
Error_Attr;
end if;
- Rewrite (N,
- Make_Identifier (Sloc (N),
- Chars => Name_uResult));
+ Rewrite (N, Make_Identifier (Sloc (N), Name_uResult));
Analyze_And_Resolve (N, Etype (PS));
else
Make_Assignment_Statement (Loc,
Name =>
Make_Identifier (Loc,
- New_External_Name (Chars (Etype (Nam)), 'E')),
+ Chars => New_External_Name (Chars (Etype (Nam)), 'E')),
Expression => New_Reference_To (Standard_True, Loc)));
end if;
end if;
-- defining identifier for it.
Decl := New_Copy_Tree (F);
- Id := Make_Defining_Identifier (Sloc (F_Id), Chars => Chars (F_Id));
+ Id := Make_Defining_Identifier (Sloc (F_Id), Chars (F_Id));
if Nkind (F) in N_Formal_Subprogram_Declaration then
Set_Defining_Unit_Name (Specification (Decl), Id);
Aitem :=
Make_Pragma (Loc,
Pragma_Identifier =>
- Make_Identifier (Sloc (Id),
- Chars => Pname),
+ Make_Identifier (Sloc (Id), Pname),
Class_Present => Class_Present (Aspect),
Split_PPC => Split_PPC (Aspect),
Pragma_Argument_Associations => New_List (
Make_Type_Conversion (Loc,
Subtype_Mark =>
Make_Attribute_Reference (Loc,
- Prefix =>
- New_Occurrence_Of (T, Loc),
+ Prefix => New_Occurrence_Of (T, Loc),
Attribute_Name => Name_Class),
- Expression =>
- Make_Identifier (Loc,
- Chars => Object_Name)));
+ Expression => Make_Identifier (Loc, Object_Name)));
Set_Entity (Expression (N), Object_Entity);
Set_Etype (Expression (N), Typ);
-- Invariant, replace with obj
else
- Rewrite (N, Make_Identifier (Loc, Chars => Object_Name));
+ Rewrite (N, Make_Identifier (Loc, Object_Name));
Set_Entity (N, Object_Entity);
Set_Etype (N, Typ);
end if;
Assoc := New_List (
Make_Pragma_Argument_Association (Loc,
- Expression =>
- Make_Identifier (Loc, Chars => Name_Invariant)),
- Make_Pragma_Argument_Association (Loc,
- Expression => Exp));
+ Expression => Make_Identifier (Loc, Name_Invariant)),
+ Make_Pragma_Argument_Association (Loc, Expression => Exp));
-- Add message if present in Invariant pragma
Append_To (Stmts,
Make_Pragma (Loc,
Pragma_Identifier =>
- Make_Identifier (Loc, Chars => Name_Check),
+ Make_Identifier (Loc, Name_Check),
Pragma_Argument_Associations => Assoc));
-- If Inherited case and option enabled, output info msg. Note
Parameter_Specifications => New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier =>
- Make_Defining_Identifier (Loc,
- Chars => Object_Name),
- Parameter_Type =>
- New_Occurrence_Of (Typ, Loc))));
+ Make_Defining_Identifier (Loc, Object_Name),
+ Parameter_Type => New_Occurrence_Of (Typ, Loc))));
PBody :=
Make_Subprogram_Body (Loc,
Exp :=
Make_Predicate_Call
- (T,
- Convert_To (T,
- Make_Identifier (Loc, Chars => Object_Name)));
+ (T, Convert_To (T, Make_Identifier (Loc, Object_Name)));
-- Add call to evolving expression, using AND THEN if needed
procedure Replace_Type_Reference (N : Node_Id) is
begin
- Rewrite (N, Make_Identifier (Loc, Chars => Object_Name));
+ Rewrite (N, Make_Identifier (Loc, Object_Name));
end Replace_Type_Reference;
-- Start of processing for Add_Predicates
Parameter_Specifications => New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier =>
- Make_Defining_Identifier (Loc, Chars => Object_Name),
+ Make_Defining_Identifier (Loc, Object_Name),
Parameter_Type => New_Occurrence_Of (Typ, Loc))),
Result_Definition =>
New_Occurrence_Of (Standard_Boolean, Loc));
Parameter_Specifications => New_List (
Make_Parameter_Specification (Loc,
Defining_Identifier =>
- Make_Defining_Identifier (Loc, Chars => Object_Name),
+ Make_Defining_Identifier (Loc, Object_Name),
Parameter_Type =>
New_Occurrence_Of (Typ, Loc))),
Result_Definition =>
if Is_Enumeration_Type (Typ) then
Result := Get_Enum_Lit_From_Pos (Typ, V, Loc);
else
- Result := Make_Integer_Literal (Loc, Intval => V);
+ Result := Make_Integer_Literal (Loc, V);
end if;
Set_Etype (Result, Btyp);
Set_Component_Clause (Fent,
Make_Component_Clause (Loc,
- Component_Name =>
- Make_Identifier (Loc,
- Chars => Name_uTag),
-
- Position =>
- Make_Integer_Literal (Loc,
- Intval => Uint_0),
-
- First_Bit =>
- Make_Integer_Literal (Loc,
- Intval => Uint_0),
+ Component_Name => Make_Identifier (Loc, Name_uTag),
+ Position => Make_Integer_Literal (Loc, Uint_0),
+ First_Bit => Make_Integer_Literal (Loc, Uint_0),
Last_Bit =>
Make_Integer_Literal (Loc,
UI_From_Int (System_Address_Size))));
else
Subp_Id :=
- Make_Defining_Identifier (Loc,
- Chars => New_External_Name (Sname, 'V'));
+ Make_Defining_Identifier (Loc, New_External_Name (Sname, 'V'));
Subp_Decl :=
Make_Object_Declaration (Loc,
Defining_Identifier => Subp_Id,
Loc : constant Source_Ptr := Sloc (N);
Anon : constant Entity_Id :=
Make_Defining_Identifier (Loc,
- New_External_Name (Chars (Derived_Type), 'T'));
+ Chars => New_External_Name (Chars (Derived_Type), 'T'));
Decl : Node_Id;
begin
Implicit_Base :=
Make_Defining_Identifier (Sloc (Derived_Type),
- New_External_Name (Chars (Derived_Type), 'B'));
+ Chars => New_External_Name (Chars (Derived_Type), 'B'));
-- Indicate the proper nature of the derived type. This must be done
-- before analysis of the literals, to recognize cases when a literal
if not Is_Private_Type (Full_View (Parent_Type))
and then (In_Open_Scopes (Scope (Parent_Type)))
then
- Full_Der := Make_Defining_Identifier (Sloc (Derived_Type),
- Chars (Derived_Type));
+ Full_Der :=
+ Make_Defining_Identifier
+ (Sloc (Derived_Type), Chars (Derived_Type));
Set_Is_Itype (Full_Der);
Set_Has_Private_Declaration (Full_Der);
Set_Has_Private_Declaration (Derived_Type);
and then not Is_Completion
then
Full_Der :=
- Make_Defining_Identifier (Sloc (Derived_Type),
- Chars => Chars (Derived_Type));
+ Make_Defining_Identifier
+ (Sloc (Derived_Type), Chars (Derived_Type));
Set_Is_Itype (Full_Der);
Set_Has_Private_Declaration (Full_Der);
Set_Has_Private_Declaration (Derived_Type);
-- will be installed when the enclosing child body is compiled.
Full_Der :=
- Make_Defining_Identifier (Sloc (Derived_Type),
- Chars => Chars (Derived_Type));
+ Make_Defining_Identifier
+ (Sloc (Derived_Type), Chars (Derived_Type));
Set_Is_Itype (Full_Der);
Build_Itype_Reference (Full_Der, N);
begin
-- A discriminal has the same name as the discriminant
- D_Minal :=
- Make_Defining_Identifier (Sloc (Discrim),
- Chars => Chars (Discrim));
+ D_Minal := Make_Defining_Identifier (Sloc (Discrim), Chars (Discrim));
Set_Ekind (D_Minal, E_In_Parameter);
Set_Mechanism (D_Minal, Default_Mechanism);
New_Reference_To (Subp, Loc)),
Make_Pragma_Argument_Association (Loc,
- Expression =>
- Make_Identifier (Loc, Iface_Kind))));
+ Expression => Make_Identifier (Loc, Iface_Kind))));
-- The pragma doesn't need to be analyzed because it is internaly
-- build. It is safe to directly register it as a rep item since we
New_Copy (Subtype_Indication
(Parent (Partial_View))));
- New_Iface := Make_Identifier (Sloc (N),
- Chars (Parent_Type));
+ New_Iface :=
+ Make_Identifier (Sloc (N), Chars (Parent_Type));
Append (New_Iface, Interface_List (Def));
-- Analyze the transformed code
Set_Scalar_Range (T,
Make_Range (Sloc (Mod_Expr),
- Low_Bound =>
- Make_Integer_Literal (Sloc (Mod_Expr), 0),
- High_Bound =>
- Make_Integer_Literal (Sloc (Mod_Expr), M_Val - 1)));
+ Low_Bound => Make_Integer_Literal (Sloc (Mod_Expr), 0),
+ High_Bound => Make_Integer_Literal (Sloc (Mod_Expr), M_Val - 1)));
-- Properly analyze the literals for the range. We do this manually
-- because we can't go calling Resolve, since we are resolving these
Prepend_To (Pragma_Argument_Associations (CP),
Make_Pragma_Argument_Association (Sloc (Prag),
- Expression =>
- Make_Identifier (Loc,
- Chars => Nam)));
- Set_Pragma_Identifier (CP,
- Make_Identifier (Sloc (Prag),
- Chars => Name_Check));
+ Expression => Make_Identifier (Loc, Nam)));
+ Set_Pragma_Identifier (CP, Make_Identifier (Sloc (Prag), Name_Check));
-- If this is inherited case and the current message starts with
-- "failed p", we change it to "failed inherited p...".
-- --
-- B o d y --
-- --
--- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2010, 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_Aggregate (Loc,
Component_Associations => New_List (
Make_Component_Association (Loc,
- Choices => New_List (Make_Identifier (Loc, Name_Ras)),
+ Choices => New_List (Make_Identifier (Loc, Name_Ras)),
Expression => Make_Null (Loc)))));
Analyze_And_Resolve (N, Target_Type);
return True;
Expr := Get_Pragma_Arg (Arg1);
Newa := New_List (
Make_Pragma_Argument_Association (Loc,
- Expression =>
- Make_Identifier (Loc,
- Chars => Name_Assertion)),
+ Expression => Make_Identifier (Loc, Name_Assertion)),
Make_Pragma_Argument_Association (Sloc (Expr),
Expression => Expr));
Pragma_Argument_Associations => New_List (
Make_Pragma_Argument_Association (Loc,
- Expression =>
- Make_Identifier (Loc,
- Chars => Name_Assertion)),
+ Expression => Make_Identifier (Loc, Name_Assertion)),
Make_Pragma_Argument_Association (Loc,
Expression =>
- Make_Identifier (Sloc (Policy),
- Chars => Chars (Policy))))));
+ Make_Identifier (Sloc (Policy), Chars (Policy))))));
Set_Analyzed (N);
Set_Next_Pragma (N, Opt.Check_Policy_List);
Chars => Name_Check,
Pragma_Argument_Associations => New_List (
Make_Pragma_Argument_Association (Loc,
- Expression =>
- Make_Identifier (Loc,
- Chars => Name_Precondition)),
+ Expression => Make_Identifier (Loc, Name_Precondition)),
Make_Pragma_Argument_Association (Sloc (Arg1),
Expression => Relocate_Node (Get_Pragma_Arg (Arg1))))));
Chars => Name_Suppress,
Pragma_Argument_Associations => New_List (
Make_Pragma_Argument_Association (Sloc (N),
- Expression =>
- Make_Identifier (Sloc (N),
- Chars => Name_All_Checks)))));
+ Expression => Make_Identifier (Sloc (N), Name_All_Checks)))));
end if;
-- Nothing else to do at the current time!
projects / gcc.git / commitdiff