+2010-10-21 Robert Dewar <dewar@adacore.com>
+
+ * a-cgaaso.ads, a-tags.ads, exp_ch3.adb, exp_attr.adb, exp_ch4.adb,
+ exp_ch3.ads, exp_ch7.adb, exp_ch9.adb, exp_disp.adb, exp_disp.ads,
+ exp_dist.adb, exp_util.adb, layout.adb, lib-xref.adb, lib.ads,
+ prep.adb, prj-strt.adb, s-ststop.adb, s-taskin.ads, s-tataat.ads,
+ sem_aggr.adb, sem_attr.adb, sem_ch12.adb, sem_ch3.adb, sem_ch4.adb,
+ sem_ch4.ads, sem_ch5.adb, sem_res.adb, sem_util.adb, einfo.adb,
+ g-sothco.ads, make.adb: Minor reformatting
+
2010-10-21 Vincent Celier <celier@adacore.com>
* vms_data.ads: Add new qualifiers /SRC_INFO= and
-- --
-- S p e c --
-- --
--- Copyright (C) 2004-2009, Free Software Foundation, Inc. --
+-- Copyright (C) 2004-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- --
-- Allows an anonymous array (or array-like container) to be sorted. Generic
-- formal Less returns the result of comparing the elements designated by the
--- indices, and generic formal Swap exchanges the designated elements.
+-- indexes, and generic formal Swap exchanges the designated elements.
generic
type Index_Type is (<>);
-- +------------------+ +-------------------+ +------------+
-- |table of |
-- : entry :
- -- | indices |
+ -- | indexes |
-- +------------------+
-- Structure of the GNAT Secondary Dispatch Table
(" Component Type ", Component_Type (Id));
Write_Eol;
Write_Str (Prefix);
- Write_Str (" Indices ");
+ Write_Str (" Indexes ");
Index := First_Index (Id);
while Present (Index) loop
Check : Boolean);
-- The body for a stream subprogram may be generated outside of the scope
-- of the type. If the type is fully private, it may depend on the full
- -- view of other types (e.g. indices) that are currently private as well.
+ -- view of other types (e.g. indexes) that are currently private as well.
-- We install the declarations of the package in which the type is declared
-- before compiling the body in what is its proper environment. The Check
-- parameter indicates if checks are to be suppressed for the stream body.
function Init_Component return List_Id;
-- Create one statement to initialize one array component, designated
- -- by a full set of indices.
+ -- by a full set of indexes.
function Init_One_Dimension (N : Int) return List_Id;
-- Create loop to initialize one dimension of the array. The single
Stats : List_Id;
begin
- -- Build declarations for indices
+ -- Build declarations for indexes
Decls := New_List;
Right_Opnd => New_Occurrence_Of (Left_Lo, Loc)),
Then_Statements => New_List (Make_Simple_Return_Statement (Loc))));
- -- Build initializations for indices
+ -- Build initializations for indexes
declare
F_Init : constant List_Id := New_List;
-- --
-- S p e c --
-- --
--- 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- --
-- enable the use of discriminals. Enclos_Type is the enclosing type when
-- initializing a component in an outer init proc, and it is used for
-- various expansion cases including the case where Typ is a task type
- -- which is an array component, the indices of the enclosing type are
+ -- which is an array component, the indexes of the enclosing type are
-- used to build the string that identifies each task at runtime.
--
-- Discr_Map is used to replace discriminants by their discriminals in
function Component_Equality (Typ : Entity_Id) return Node_Id;
-- Create one statement to compare corresponding components, designated
- -- by a full set of indices.
+ -- by a full set of indexes.
function Get_Arg_Type (N : Node_Id) return Entity_Id;
-- Given one of the arguments, computes the appropriate type to be used
-- end loop;
-- end;
--
- -- If both indices are constrained and identical, the procedure
+ -- If both indexes are constrained and identical, the procedure
-- returns a simpler loop:
--
-- for An in A'Range (N) loop
if Need_Separate_Indexes then
- -- Generate guard for loop, followed by increments of indices
+ -- Generate guard for loop, followed by increments of indexes
Append_To (Stm_List,
Make_Exit_Statement (Loc,
function One_Component return List_Id;
-- Create one statement to initialize/adjust/finalize one array
- -- component, designated by a full set of indices.
+ -- component, designated by a full set of indexes.
function One_Dimension (N : Int) return List_Id;
-- Create loop to deal with one dimension of the array. The single
Lo : Node_Id;
Ttyp : Entity_Id;
Cap : Boolean) return Node_Id;
- -- Compute (Hi - Lo) for two entry family indices. Hi is the index in
+ -- Compute (Hi - Lo) for two entry family indexes. Hi is the index in
-- an accept statement, or the upper bound in the discrete subtype of
-- an entry declaration. Lo is the corresponding lower bound. Ttyp is
-- the concurrent type of the entry. If Cap is true, the result is
Left_Opnd => Make_Identifier (Loc, Name_uE),
Right_Opnd => Siz);
- -- Map entry queue indices in the range of the current family
+ -- Map entry queue indexes in the range of the current family
-- into the current index, that designates the entry body.
if No (If_St) then
and then Is_Class_Wide_Type (Formal_Typ)
then
-- No need to displace the pointer if the type of the actual
- -- coindices with the type of the formal.
+ -- coincides with the type of the formal.
if Actual_Typ = Formal_Typ then
null;
-- Ada 2005 (AI-345): Create and populate the auxiliary table in the TSD
-- of Typ used for dispatching in asynchronous, conditional and timed
-- selects. Generate code to set the primitive operation kinds and entry
- -- indices of primitive operations and primitive wrappers.
+ -- indexes of primitive operations and primitive wrappers.
function Make_Tags (Typ : Entity_Id) return List_Id;
-- Generate the entities associated with the primary and secondary tags of
Arry : Entity_Id;
-- For 'Range and Etype
- Indices : List_Id;
+ Indexes : List_Id;
-- For the construction of the innermost element expression
with procedure Add_Process_Element
Depth : Pos := 1);
-- Build nested loop statements that iterate over the elements of an
-- array Arry. The statement(s) built by Add_Process_Element are
- -- executed for each element; Indices is the list of indices to be
+ -- executed for each element; Indexes is the list of indexes to be
-- used in the construction of the indexed component that denotes the
-- current element. Subprogram is the entity for the subprogram for
-- which this iterator is generated. The generated statements are
new Append_Array_Traversal (
Subprogram => Fnam,
Arry => Res,
- Indices => New_List,
+ Indexes => New_List,
Add_Process_Element => FA_Ary_Add_Process_Element);
Res_Subtype_Indication : Node_Id :=
new Append_Array_Traversal (
Subprogram => Fnam,
Arry => Expr_Parameter,
- Indices => New_List,
+ Indexes => New_List,
Add_Process_Element => TA_Ary_Add_Process_Element);
Index : Node_Id;
Element_Expr : constant Node_Id :=
Make_Indexed_Component (Loc,
New_Occurrence_Of (Arry, Loc),
- Indices);
+ Indexes);
begin
Set_Etype (Element_Expr, Component_Type (Typ));
Add_Process_Element (Stmts,
return;
end if;
- Append_To (Indices,
+ Append_To (Indexes,
Make_Identifier (Loc, New_External_Name ('L', Depth)));
if not Constrained or else Depth > 1 then
-- local to the init proc for the array type, and is called for each one
-- of the components. The constructed image has the form of an indexed
-- component, whose prefix is the outer variable of the array type.
- -- The n-dimensional array type has known indices Index, Index2...
+ -- The n-dimensional array type has known indexes Index, Index2...
-- Id_Ref is an indexed component form created by the enclosing init proc.
- -- Its successive indices are Val1, Val2, ... which are the loop variables
+ -- Its successive indexes are Val1, Val2, ... which are the loop variables
-- in the loops that call the individual task init proc on each component.
-- The generated function has the following structure:
-- String to hold result
Val : Node_Id;
- -- Value of successive indices
+ -- Value of successive indexes
Sum : Node_Id;
-- Expression to compute total size of string
Read_End : constant := 0;
Write_End : constant := 1;
- -- Indices into an Fd_Pair value providing access to each of the connected
+ -- Indexes into an Fd_Pair value providing access to each of the connected
-- file descriptors.
function Inet_Pton
Size := (Dynamic, Expr_From_SO_Ref (Loc, Component_Size (E)));
end if;
- -- Loop through indices
+ -- Loop through indexes
Indx := First_Index (E);
while Present (Indx) loop
Size := (Dynamic, Expr_From_SO_Ref (Loc, Component_Size (E)));
end if;
- -- Loop to process array indices
+ -- Loop to process array indexes
Indx := First_Index (E);
while Present (Indx) loop
end loop;
end;
- -- For array types, list index types as well.
- -- (This is not C, indices have distinct types).
+ -- For array types, list index types as well. (This is
+ -- not C, indexes have distinct types).
elsif Is_Array_Type (XE.Ent) then
declare
With_Node : Node_Id;
end record;
- -- The Load_Stack table contains a list of unit numbers (indices into the
+ -- The Load_Stack table contains a list of unit numbers (indexes into the
-- unit table) of units being loaded on a single dependency chain, and a
-- flag to indicate whether this unit is loaded through a limited_with
-- clause. The First entry is the main unit. The second entry, if present
type Temp_Path_Names is array (Positive range <>) of Path_Name_Type;
type Temp_Path_Ptr is access Temp_Path_Names;
- type Free_File_Indices is array (Positive range <>) of Positive;
- type Free_Indices_Ptr is access Free_File_Indices;
+ type Free_File_Indexes is array (Positive range <>) of Positive;
+ type Free_Indexes_Ptr is access Free_File_Indexes;
type Project_Compilation_Data is record
Mapping_File_Names : Temp_Path_Ptr;
Last_Mapping_File_Names : Natural;
-- Index of the last mapping file created for this project
- Free_Mapping_File_Indices : Free_Indices_Ptr;
- -- Indices in Mapping_File_Names of the mapping file names that can be
+ Free_Mapping_File_Indexes : Free_Indexes_Ptr;
+ -- Indexes in Mapping_File_Names of the mapping file names that can be
-- reused for subsequent compilations.
- Last_Free_Indices : Natural;
+ Last_Free_Indexes : Natural;
-- Number of mapping files that can be reused
end record;
-- Information necessary when compiling a project
Comp_Data :=
Project_Compilation_Htable.Get
(Project_Compilation, Project);
- Comp_Data.Last_Free_Indices :=
- Comp_Data.Last_Free_Indices + 1;
- Comp_Data.Free_Mapping_File_Indices
- (Comp_Data.Last_Free_Indices) :=
+ Comp_Data.Last_Free_Indexes :=
+ Comp_Data.Last_Free_Indexes + 1;
+ Comp_Data.Free_Mapping_File_Indexes
+ (Comp_Data.Last_Free_Indexes) :=
Running_Compile (J).Mapping_File;
end if;
-- If there is a mapping file ready to be reused, reuse it
- if Data.Last_Free_Indices > 0 then
- Mfile := Data.Free_Mapping_File_Indices (Data.Last_Free_Indices);
- Data.Last_Free_Indices := Data.Last_Free_Indices - 1;
+ if Data.Last_Free_Indexes > 0 then
+ Mfile := Data.Free_Mapping_File_Indexes (Data.Last_Free_Indexes);
+ Data.Last_Free_Indexes := Data.Last_Free_Indexes - 1;
-- Otherwise, create and initialize a new one
(Mapping_File_Names => new Temp_Path_Names
(1 .. Saved_Maximum_Processes),
Last_Mapping_File_Names => 0,
- Free_Mapping_File_Indices => new Free_File_Indices
+ Free_Mapping_File_Indexes => new Free_File_Indexes
(1 .. Saved_Maximum_Processes),
- Last_Free_Indices => 0);
+ Last_Free_Indexes => 0);
Project_Compilation_Htable.Set
(Project_Compilation, Proj.Project, Data);
(Mapping_File_Names => new Temp_Path_Names
(1 .. Saved_Maximum_Processes),
Last_Mapping_File_Names => 0,
- Free_Mapping_File_Indices => new Free_File_Indices
+ Free_Mapping_File_Indexes => new Free_File_Indexes
(1 .. Saved_Maximum_Processes),
- Last_Free_Indices => 0);
+ Last_Free_Indexes => 0);
Project_Compilation_Htable.Set
(Project_Compilation, No_Project, Data);
procedure List_Symbols (Foreword : String) is
Order : array (0 .. Integer (Symbol_Table.Last (Mapping)))
of Symbol_Id;
- -- After alphabetical sorting, this array stores the indices of
- -- the symbols in the order they are displayed.
+ -- After alphabetical sorting, this array stores the indexes of the
+ -- symbols in the order they are displayed.
function Lt (Op1, Op2 : Natural) return Boolean;
-- Comparison routine for sort call
Modified : Boolean := False;
procedure Output (From, To : Source_Ptr);
- -- Output the characters with indices From .. To in the buffer
- -- to the output file.
+ -- Output the characters with indexes From .. To in the buffer to the
+ -- output file.
procedure Output_Line (From, To : Source_Ptr);
-- Output a line or the end of a line from the buffer to the output
Table_Initial => 10,
Table_Increment => 100,
Table_Name => "Prj.Strt.Choice_Lasts");
- -- Used to store the indices of the choices in table Choices,
- -- to distinguish nested case constructions.
+ -- Used to store the indexes of the choices in table Choices, to
+ -- distinguish nested case constructions.
Choice_First : Choice_Node_Id := 0;
-- Index in table Choices of the first case label of the current
-- --
-- B o d y --
-- --
--- Copyright (C) 2009, Free Software Foundation, Inc. --
+-- Copyright (C) 2008-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- --
Rem_Size : constant Natural :=
Block_Size mod Default_Block_Size;
- -- String indices
+ -- String indexes
Low : Positive := Item'First;
High : Positive := Low + C_In_Default_Block - 1;
Rem_Size : constant Natural :=
Block_Size mod Default_Block_Size;
- -- String indices
+ -- String indexes
Low : Positive := Item'First;
High : Positive := Low + C_In_Default_Block - 1;
type Direct_Index is range 0 .. Parameters.Default_Attribute_Count;
subtype Direct_Index_Range is Direct_Index range 1 .. Direct_Index'Last;
- -- Attributes with indices in this range are stored directly in the task
+ -- Attributes with indexes in this range are stored directly in the task
-- control block. Such attributes must be Address-sized. Other attributes
-- will be held in dynamically allocated records chained off of the task
-- control block.
-- S p e c --
-- --
-- Copyright (C) 1991-1994, Florida State University --
--- Copyright (C) 1995-2008, AdaCore --
+-- Copyright (C) 1995-2010, AdaCore --
-- --
-- GNARL 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- --
-- Ensure that the designated object is always strictly enough aligned.
In_Use : Direct_Index_Vector := 0;
- -- Set True for direct indices that are already used (True??? type???)
+ -- Set True for direct indexes that are already used (True??? type???)
All_Attributes : Access_Instance;
-- A linked list of all indirectly access attributes, which includes all
Set_Parent (Index_Constraints, N);
Collect_Aggr_Bounds (N, 1);
- -- Build the list of constrained indices of our aggregate itype
+ -- Build the list of constrained indexes of our aggregate itype
for J in 1 .. Aggr_Dimension loop
Create_Index : declare
Error_Msg_N ("\Constraint_Error will be raised at run time?", AH);
-- You need to set AH to BH or else in the case of enumerations
- -- indices we will not be able to resolve the aggregate bounds.
+ -- indexes we will not be able to resolve the aggregate bounds.
AH := Duplicate_Subexpr (BH);
end if;
-- Start of processing for Resolve_Attribute
begin
- -- If error during analysis, no point in continuing, except for
- -- array types, where we get better recovery by using unconstrained
- -- indices than nothing at all (see Check_Array_Type).
+ -- If error during analysis, no point in continuing, except for array
+ -- types, where we get better recovery by using unconstrained indexes
+ -- than nothing at all (see Check_Array_Type).
if Error_Posted (N)
and then Attr_Id /= Attribute_First
I2 := First_Index (Act_T);
for J in 1 .. Formal_Dimensions loop
- -- If the indices of the actual were given by a subtype_mark,
+ -- If the indexes of the actual were given by a subtype_mark,
-- the index was transformed into a range attribute. Retrieve
-- the original type mark for checking.
Error_Msg_N ("missing index definition in array type declaration", T);
declare
- Indices : constant List_Id :=
+ Indexes : constant List_Id :=
New_List (New_Occurrence_Of (Any_Id, Sloc (T)));
begin
- Set_Discrete_Subtype_Definitions (Def, Indices);
- Set_First_Index (T, First (Indices));
+ Set_Discrete_Subtype_Definitions (Def, Indexes);
+ Set_First_Index (T, First (Indexes));
return;
end;
end if;
end if;
-- In the case of an unconstrained array the parser has already verified
- -- that all the indices are unconstrained but we still need to make sure
+ -- that all the indexes are unconstrained but we still need to make sure
-- that the element type is constrained.
if Is_Indefinite_Subtype (Element_Type) then
function Build_Constrained_Array_Type
(Old_Type : Entity_Id) return Entity_Id;
- -- If Old_Type is an array type, one of whose indices is constrained
+ -- If Old_Type is an array type, one of whose indexes is constrained
-- by a discriminant, build an Itype whose constraint replaces the
-- discriminant with its value in the constraint.
if All_Errors_Mode then
Error_Msg_Sloc := Sloc (Nam);
+ if Etype (Formal) = Any_Type then
+ Error_Msg_N
+ ("there is no legal actual parameter", Actual);
+ end if;
+
if Is_Overloadable (Nam)
and then Present (Alias (Nam))
and then not Comes_From_Source (Nam)
if Present (Arr_Type) then
- -- Verify that the actuals (excluding the object)
- -- match the types of the indices.
+ -- Verify that the actuals (excluding the object) match the types
+ -- of the indexes.
declare
Actual : Node_Id;
-- c) A conversion
-- d) A slice
-- The resolution of the construct requires some semantic information
- -- on the prefix and the indices.
+ -- on the prefix and the indexes.
end Sem_Ch4;
or else Nkind (N) /= N_Block_Statement)
then
-- Assignment verifies that the length of the Lsh and Rhs are equal,
- -- but of course the indices do not have to match. If the right-hand
+ -- but of course the indexes do not have to match. If the right-hand
-- side is a type conversion to an unconstrained type, a length check
-- is performed on the expression itself during expansion. In rare
-- cases, the redundant length check is computed on an index type
-- An Ada 2005 prefixed call to a primitive operation
-- whose first parameter is the prefix. This prefix was
-- prepended to the parameter list, which is actually a
- -- list of indices. Remove the prefix in order to build
+ -- list of indexes. Remove the prefix in order to build
-- the proper indexed component.
Index_Node :=
and then Denotes_Same_Object (Hi1, Hi2);
end;
- -- Literals will appear as indices. Isn't this where we should check
+ -- Literals will appear as indexes. Isn't this where we should check
-- Known_At_Compile_Time at least if we are generating warnings ???
elsif Nkind (A1) = N_Integer_Literal then
OSDN Git Service
