-----------------------
function Get_Component_Val (N : Node_Id) return Uint is
- Val : Uint;
+ Val : Uint;
begin
-- We have to analyze the expression here before doing any further
--------------
when Attribute_From_Any => From_Any : declare
- Decls : constant List_Id := New_List;
+ Decls : constant List_Id := New_List;
begin
Rewrite (N,
Set_Static_Initialization (Proc_Id, Agg);
declare
- Comp : Node_Id;
+ Comp : Node_Id;
begin
Comp := First (Component_Associations (Agg));
while Present (Comp) loop
(N : Node_Id;
Ref : Node_Id) return Node_Id
is
- Loc : constant Source_Ptr := Sloc (N);
+ Loc : constant Source_Ptr := Sloc (N);
begin
-- For restricted run-time libraries (Ravenscar), tasks are
---------------------------------
procedure Expand_Calling_Stubs_Bodies (Unit_Node : Node_Id) is
- Spec : constant Node_Id := Specification (Unit_Node);
+ Spec : constant Node_Id := Specification (Unit_Node);
begin
Add_Calling_Stubs_To_Declarations (Spec);
end Expand_Calling_Stubs_Bodies;
----------------------------------
function Is_Possibly_Unaligned_Object (N : Node_Id) return Boolean is
- T : constant Entity_Id := Etype (N);
+ T : constant Entity_Id := Etype (N);
begin
-- If renamed object, apply test to underlying object
----------------------------
procedure Check_Strict_Alignment (E : Entity_Id) is
- Comp : Entity_Id;
+ Comp : Entity_Id;
begin
-- Bit-packed array types do not require strict alignment, even if they
-- Initialize_Scalars, but others should be checked: as well???
declare
- Item : Node_Id;
+ Item : Node_Id;
begin
Item := First (Context_Items (Cunit (Main_Unit)));
------------------------
function Copy_Return_Object (Obj_Decl : Node_Id) return Node_Id is
- Obj_Id : constant Entity_Id := Defining_Entity (Obj_Decl);
+ Obj_Id : constant Entity_Id := Defining_Entity (Obj_Decl);
begin
-- The use of New_Copy_Tree ensures that global references are
------------------
function Process_Loop (N : Node_Id) return Traverse_Result is
- Id : Entity_Id;
+ Id : Entity_Id;
begin
if Nkind (N) = N_Loop_Statement
----------------------------
procedure Rewrite_Procedure_Call (N : Node_Id; Blk : Node_Id) is
- HSS : constant Node_Id := Handled_Statement_Sequence (Blk);
+ HSS : constant Node_Id := Handled_Statement_Sequence (Blk);
begin
Make_Loop_Labels_Unique (HSS);
Related_Nod : Node_Id;
Scope_Id : Entity_Id := Current_Scope) return Entity_Id
is
- I_Typ : Entity_Id;
+ I_Typ : Entity_Id;
begin
pragma Assert (Is_Access_Type (T));
-- code will have to be generated for it.
procedure Make_Instance_Unit (N : Node_Id; In_Main : Boolean) is
- Sind : constant Source_File_Index := Source_Index (Main_Unit);
+ Sind : constant Source_File_Index := Source_Index (Main_Unit);
begin
Units.Increment_Last;
-- declared in the main unit.
Handle_Prim_Ops : declare
- Ent : Entity_Id;
+ Ent : Entity_Id;
begin
for J in 1 .. Xrefs.Last loop
(Vet (Container, Position), "bad cursor in function Key");
declare
- N : Node_Type renames Container.Content.Nodes (Position.Node);
+ N : Node_Type renames Container.Content.Nodes (Position.Node);
begin
return Key (N.Element);
end;
------------------
procedure Delete_First (Container : in out Set) is
- X : constant Count_Type := Container.Content.First;
+ X : constant Count_Type := Container.Content.First;
begin
if X /= 0 then
Tree_Operations.Delete_Node_Sans_Free (Container.Content, X);
-----------------
procedure Delete_Last (Container : in out Set) is
- X : constant Count_Type := Container.Content.Last;
+ X : constant Count_Type := Container.Content.Last;
begin
if X /= 0 then
Tree_Operations.Delete_Node_Sans_Free (Container.Content, X);
--------------
function New_Node return Count_Type is
- N : Node_Type renames NN (Node);
+ N : Node_Type renames NN (Node);
begin
N.Element := Item;
N.Color := Red;
(Stream : not null access Root_Stream_Type'Class;
HT : out Hash_Table_Type'Class)
is
- N : Count_Type'Base;
+ N : Count_Type'Base;
begin
Clear (HT);
pragma Assert (Vet (Position), "bad cursor in Update_Element");
declare
- N : Node_Type renames Container.Nodes (Position.Node);
+ N : Node_Type renames Container.Nodes (Position.Node);
begin
Process (N.Element);
else
declare
- New_Msg : constant String := Prefix & Exception_Name (X);
+ New_Msg : constant String := Prefix & Exception_Name (X);
begin
-- No message present, just provide our own
Before : Positive;
New_Item : String) return String
is
- Front : constant Integer := Before - Source'First;
+ Front : constant Integer := Before - Source'First;
begin
if Before - 1 not in Source'First - 1 .. Source'Last then
-----------------
function End_Of_Page (File : File_Type) return Boolean is
- ch : int;
+ ch : int;
begin
FIO.Check_Read_Status (AP (File));
(File : File_Type;
Item : out Character)
is
- ch : int;
+ ch : int;
begin
FIO.Check_Read_Status (AP (File));
Start : out Natural;
Stop : out Natural)
is
- C : Character;
+ C : Character;
-- Processing for Scan_Enum_Lit
Buf : out String;
Ptr : in out Natural)
is
- Loaded : Boolean;
+ Loaded : Boolean;
begin
-- Skip initial blanks, and load possible sign
-----------------
function End_Of_File (File : File_Type) return Boolean is
- ch : int;
+ ch : int;
begin
FIO.Check_Read_Status (AP (File));
-----------------
function End_Of_Page (File : File_Type) return Boolean is
- ch : int;
+ ch : int;
begin
FIO.Check_Read_Status (AP (File));
(File : File_Type;
Item : out Wide_Character)
is
- C : Character;
+ C : Character;
begin
FIO.Check_Read_Status (AP (File));
Start : out Natural;
Stop : out Natural)
is
- WC : Wide_Character;
+ WC : Wide_Character;
-- Processing for Scan_Enum_Lit
Buf : out String;
Ptr : in out Natural)
is
- Loaded : Boolean;
+ Loaded : Boolean;
begin
-- Skip initial blanks and load possible sign
Start : out Natural;
Stop : out Natural)
is
- WC : Wide_Wide_Character;
+ WC : Wide_Wide_Character;
-- Processing for Scan_Enum_Lit
-----------------
function End_Of_File (File : File_Type) return Boolean is
- ch : int;
+ ch : int;
begin
FIO.Check_Read_Status (AP (File));
-----------------
function End_Of_Page (File : File_Type) return Boolean is
- ch : int;
+ ch : int;
begin
FIO.Check_Read_Status (AP (File));
(File : File_Type;
Item : out Wide_Wide_Character)
is
- C : Character;
+ C : Character;
begin
FIO.Check_Read_Status (AP (File));
Buf : out String;
Ptr : in out Natural)
is
- Loaded : Boolean;
+ Loaded : Boolean;
begin
-- Skip initial blanks and load possible sign
if Do_Expansion then
declare
- Arg : constant String :=
- Argument (Parser, Parser.Current_Argument - 1);
+ Arg : constant String :=
+ Argument (Parser, Parser.Current_Argument - 1);
begin
for Index in Arg'Range loop
if Arg (Index) in '*' | '?' | '[' then
Expanded : String;
Section : String := "")
is
- Def : Alias_Definition;
+ Def : Alias_Definition;
begin
if Config = null then
function Is_Valid_Or_Handled
(Storage : System.Address;
Valid : Boolean) return Boolean is
- Int_Storage : constant Integer_Address := To_Integer (Storage);
+ Int_Storage : constant Integer_Address := To_Integer (Storage);
begin
-- The pool only returns addresses aligned on Storage_Alignment so
Str : String;
Filter_On : Filter_Type)
is
- Current_Filter : Filter_List;
+ Current_Filter : Filter_List;
begin
if Pid.Filters_Lock = 0 then
if File.Shared_Status = Yes then
declare
- P : AFCB_Ptr;
+ P : AFCB_Ptr;
begin
P := Open_Files;
Size : size_t)
return System.Address
is
- Result : System.Address;
+ Result : System.Address;
begin
if Size = size_t'Last then
raise Storage_Error with "object too large";
Length : File_Size := 0;
Mutable : Boolean := False) return Mapped_Region
is
- Region : Mapped_Region := Invalid_Mapped_Region;
+ Region : Mapped_Region := Invalid_Mapped_Region;
begin
Read (File, Region, Offset, Length, Mutable);
return Region;
(Obj : in out XCOFF32_Object_File;
Sym : Object_Symbol) return String_Ptr_Len
is
- Symbol : Symbol_Entry;
+ Symbol : Symbol_Entry;
begin
Seek (Obj.Symtab_Stream, Sym.Off);
(S : in out Mapped_Stream;
Off : Offset) return String
is
- Buf : Buffer;
+ Buf : Buffer;
begin
Seek (S, Off);
------------
procedure Insert (Value : String) is
- Len : constant Natural := Value'Length;
+ Len : constant Natural := Value'Length;
begin
if Verbose then
Operand : Pointer;
Greedy : Boolean := True)
is
- Old : Pointer;
+ Old : Pointer;
begin
Old := Insert_Operator_Before (Op, Operand, Greedy, Opsize => 7);
Emit_Natural (Old + Next_Pointer_Bytes, Min);
if Do_Print then
declare
- Point : constant String := Pointer'Image (Index);
+ Point : constant String := Pointer'Image (Index);
begin
Put ([1 .. 4 - Point'Length => ' ']
& Point & ":"
if SFE = null then
declare
- S : aliased constant String := Dir.all & Var;
+ S : aliased constant String := Dir.all & Var;
begin
SFE := new Shared_Var_File_Entry;
if SFE = null then
declare
- S : aliased constant String := Dir.all & Var;
+ S : aliased constant String := Dir.all & Var;
begin
SFE := new Shared_Var_File_Entry;
elsif S > 0 then
declare
- LS : Integer := S;
+ LS : Integer := S;
begin
Y := Safe_Expont (B, LS, 10 ** Integer'Max (0, Scale));
elsif ScaleB > 0 then
declare
- LS : Integer := ScaleB;
+ LS : Integer := ScaleB;
begin
Y := Safe_Expont (B, LS, Den);
-- Error_Recovery : Cannot raise Error_Resync
function P_Handled_Sequence_Of_Statements return Node_Id is
- Handled_Stmt_Seq_Node : Node_Id;
+ Handled_Stmt_Seq_Node : Node_Id;
begin
Handled_Stmt_Seq_Node :=
New_Node (N_Handled_Sequence_Of_Statements, Token_Ptr);
(Prefix_Node : Node_Id)
return Node_Id
is
- Attr_Node : Node_Id;
+ Attr_Node : Node_Id;
begin
Attr_Node := New_Node (N_Attribute_Reference, Token_Ptr);
--------------
function Real_Dot return Boolean is
- Scan_State : Saved_Scan_State;
+ Scan_State : Saved_Scan_State;
begin
if Token /= Tok_Dot then
-- Error recovery: cannot raise Error_Resync
function P_Task_Definition return Node_Id is
- Def_Node : Node_Id;
+ Def_Node : Node_Id;
begin
Def_Node := New_Node (N_Task_Definition, Token_Ptr);
---------------------
procedure Record_Instance (Id : Instance_Id; Inst_Sloc : Source_Ptr) is
- Inst_Src : constant Source_File_Index :=
- Get_Source_File_Index (Inst_Sloc);
+ Inst_Src : constant Source_File_Index :=
+ Get_Source_File_Index (Inst_Sloc);
begin
SCO_Instance_Table.Append
((Inst_Dep_Num => Dependency_Num (Unit (Inst_Src)),
----------------------
function Decode_Integer (Lo, Hi : Text_Ptr) return Uint is
- Len : constant Nat := Int (Hi) - Int (Lo) + 1;
+ Len : constant Nat := Int (Hi) - Int (Lo) + 1;
begin
-- Decode up to 9 characters manually, otherwise call into Uint
----------------------------
function In_Package_Declaration return Boolean is
- Unit_Kind : constant Node_Kind :=
- Nkind (Unit (Cunit (Current_Sem_Unit)));
+ Unit_Kind : constant Node_Kind :=
+ Nkind (Unit (Cunit (Current_Sem_Unit)));
begin
-- There are no restrictions on the body of an RCI or RT unit
----------------------------
procedure Re_Install_Use_Clauses is
- U : Node_Id;
+ U : Node_Id;
begin
for J in reverse 1 .. Num_Scopes loop
U := Use_Clauses (J);
T : Entity_Id;
Def : Node_Id)
is
- Loc : constant Source_Ptr := Sloc (Def);
+ Loc : constant Source_Ptr := Sloc (Def);
begin
-- Rewrite as a type declaration of a derived type. This ensures that
Formal_Ent : Entity_Id;
Actual_Ent : Entity_Id)
is
- Act_Pkg : Entity_Id;
+ Act_Pkg : Entity_Id;
begin
Set_Instance_Of (Formal_Ent, Actual_Ent);
Comp := First_Component_Or_Discriminant (R);
while Present (Comp) loop
declare
- CC : constant Node_Id := Component_Clause (Comp);
+ CC : constant Node_Id := Component_Clause (Comp);
begin
-- Collect only component clauses whose last bit is less than
and then Is_Entity_Name (Name (Parent (Par)))
then
declare
- Proc : Entity_Id;
+ Proc : Entity_Id;
begin
-- We should look for an interpretation with the proper
------------------
function Expr_Value_E (N : Node_Id) return Entity_Id is
- Ent : constant Entity_Id := Entity (N);
+ Ent : constant Entity_Id := Entity (N);
begin
if Ekind (Ent) = E_Enumeration_Literal then
return Ent;
--------------------------------------------
procedure Defer_Compile_Time_Warning_Error_To_BE (N : Node_Id) is
- Arg1 : constant Node_Id := First (Pragma_Argument_Associations (N));
+ Arg1 : constant Node_Id := First (Pragma_Argument_Associations (N));
begin
Compile_Time_Warnings_Errors.Append
(New_Val => CTWE_Entry'(Eloc => Sloc (Arg1),
----------------------------
procedure Resolve_Set_Membership is
- Alt : Node_Id;
+ Alt : Node_Id;
begin
-- If the left operand is overloaded, find type compatible with not
Typ : Entity_Id;
Suggest_Static : Boolean := False)
is
- Gen : Entity_Id;
+ Gen : Entity_Id;
begin
-- Avoid cascaded errors
-------------------------------------
function Get_Actual_Subtype_If_Available (N : Node_Id) return Entity_Id is
- Typ : constant Entity_Id := Etype (N);
+ Typ : constant Entity_Id := Etype (N);
begin
-- If what we have is an identifier that references a subprogram
------------------------------------
function Prefix_Has_Volatile_Components (P : Node_Id) return Boolean is
- Typ : constant Entity_Id := Etype (P);
+ Typ : constant Entity_Id := Etype (P);
begin
if Is_Access_Type (Typ) then
begin
for X in 1 .. Source_File.Last loop
declare
- S : Source_File_Record renames Source_File.Table (X);
+ S : Source_File_Record renames Source_File.Table (X);
begin
if S.Instance = No_Instance_Id then
Free_Source_Buffer (S.Source_Text);
else
declare
- OK : Boolean;
+ OK : Boolean;
begin
Set_Validity_Check_Options
Store_Switch := False;
declare
- OK : Boolean;
+ OK : Boolean;
begin
Set_Style_Check_Options
projects / platform / upstream / gcc.git / commitdiff