X-Git-Url: https://oss.titaniummirror.com/gitweb/?a=blobdiff_plain;f=gcc%2Fada%2Fsem_util.adb;fp=gcc%2Fada%2Fsem_util.adb;h=0000000000000000000000000000000000000000;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=44f58239adfc0ecf755c420b6e186053ef73a8d5;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb deleted file mode 100644 index 44f58239..00000000 --- a/gcc/ada/sem_util.adb +++ /dev/null @@ -1,5241 +0,0 @@ ------------------------------------------------------------------------------ --- -- --- GNAT COMPILER COMPONENTS -- --- -- --- S E M _ U T I L -- --- -- --- B o d y -- --- -- --- $Revision: 1.7.10.1 $ --- -- --- Copyright (C) 1992-2001, 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- -- --- ware Foundation; either version 2, or (at your option) any later ver- -- --- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- --- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- --- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- --- for more details. You should have received a copy of the GNU General -- --- Public License distributed with GNAT; see file COPYING. If not, write -- --- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, -- --- MA 02111-1307, USA. -- --- -- --- GNAT was originally developed by the GNAT team at New York University. -- --- Extensive contributions were provided by Ada Core Technologies Inc. -- --- -- ------------------------------------------------------------------------------- - -with Atree; use Atree; -with Casing; use Casing; -with Debug; use Debug; -with Errout; use Errout; -with Elists; use Elists; -with Exp_Util; use Exp_Util; -with Freeze; use Freeze; -with Lib; use Lib; -with Lib.Xref; use Lib.Xref; -with Namet; use Namet; -with Nlists; use Nlists; -with Nmake; use Nmake; -with Output; use Output; -with Opt; use Opt; -with Restrict; use Restrict; -with Scans; use Scans; -with Scn; use Scn; -with Sem; use Sem; -with Sem_Ch8; use Sem_Ch8; -with Sem_Eval; use Sem_Eval; -with Sem_Res; use Sem_Res; -with Sem_Type; use Sem_Type; -with Sinfo; use Sinfo; -with Sinput; use Sinput; -with Snames; use Snames; -with Stand; use Stand; -with Style; -with Stringt; use Stringt; -with Targparm; use Targparm; -with Tbuild; use Tbuild; -with Ttypes; use Ttypes; - -package body Sem_Util is - - ----------------------- - -- Local Subprograms -- - ----------------------- - - function Build_Component_Subtype - (C : List_Id; - Loc : Source_Ptr; - T : Entity_Id) - return Node_Id; - -- This function builds the subtype for Build_Actual_Subtype_Of_Component - -- and Build_Discriminal_Subtype_Of_Component. C is a list of constraints, - -- Loc is the source location, T is the original subtype. - - -------------------------------- - -- Add_Access_Type_To_Process -- - -------------------------------- - - procedure Add_Access_Type_To_Process (E : Entity_Id; A : Entity_Id) - is - L : Elist_Id; - begin - Ensure_Freeze_Node (E); - L := Access_Types_To_Process (Freeze_Node (E)); - - if No (L) then - L := New_Elmt_List; - Set_Access_Types_To_Process (Freeze_Node (E), L); - end if; - - Append_Elmt (A, L); - end Add_Access_Type_To_Process; - - ----------------------- - -- Alignment_In_Bits -- - ----------------------- - - function Alignment_In_Bits (E : Entity_Id) return Uint is - begin - return Alignment (E) * System_Storage_Unit; - end Alignment_In_Bits; - - ----------------------------------------- - -- Apply_Compile_Time_Constraint_Error -- - ----------------------------------------- - - procedure Apply_Compile_Time_Constraint_Error - (N : Node_Id; - Msg : String; - Ent : Entity_Id := Empty; - Typ : Entity_Id := Empty; - Loc : Source_Ptr := No_Location; - Rep : Boolean := True) - is - Stat : constant Boolean := Is_Static_Expression (N); - Rtyp : Entity_Id; - - begin - if No (Typ) then - Rtyp := Etype (N); - else - Rtyp := Typ; - end if; - - if No (Compile_Time_Constraint_Error (N, Msg, Ent, Loc)) - or else not Rep - then - return; - end if; - - -- Now we replace the node by an N_Raise_Constraint_Error node - -- This does not need reanalyzing, so set it as analyzed now. - - Rewrite (N, Make_Raise_Constraint_Error (Sloc (N))); - Set_Analyzed (N, True); - Set_Etype (N, Rtyp); - Set_Raises_Constraint_Error (N); - - -- If the original expression was marked as static, the result is - -- still marked as static, but the Raises_Constraint_Error flag is - -- always set so that further static evaluation is not attempted. - - if Stat then - Set_Is_Static_Expression (N); - end if; - end Apply_Compile_Time_Constraint_Error; - - -------------------------- - -- Build_Actual_Subtype -- - -------------------------- - - function Build_Actual_Subtype - (T : Entity_Id; - N : Node_Or_Entity_Id) - return Node_Id - is - Obj : Node_Id; - - Loc : constant Source_Ptr := Sloc (N); - Constraints : List_Id; - Decl : Node_Id; - Discr : Entity_Id; - Hi : Node_Id; - Lo : Node_Id; - Subt : Entity_Id; - Disc_Type : Entity_Id; - - begin - if Nkind (N) = N_Defining_Identifier then - Obj := New_Reference_To (N, Loc); - else - Obj := N; - end if; - - if Is_Array_Type (T) then - Constraints := New_List; - - for J in 1 .. Number_Dimensions (T) loop - - -- Build an array subtype declaration with the nominal - -- subtype and the bounds of the actual. Add the declaration - -- in front of the local declarations for the subprogram,for - -- analysis before any reference to the formal in the body. - - Lo := - Make_Attribute_Reference (Loc, - Prefix => Duplicate_Subexpr (Obj, Name_Req => True), - Attribute_Name => Name_First, - Expressions => New_List ( - Make_Integer_Literal (Loc, J))); - - Hi := - Make_Attribute_Reference (Loc, - Prefix => Duplicate_Subexpr (Obj, Name_Req => True), - Attribute_Name => Name_Last, - Expressions => New_List ( - Make_Integer_Literal (Loc, J))); - - Append (Make_Range (Loc, Lo, Hi), Constraints); - end loop; - - -- If the type has unknown discriminants there is no constrained - -- subtype to build. - - elsif Has_Unknown_Discriminants (T) then - return T; - - else - Constraints := New_List; - - if Is_Private_Type (T) and then No (Full_View (T)) then - - -- Type is a generic derived type. Inherit discriminants from - -- Parent type. - - Disc_Type := Etype (Base_Type (T)); - else - Disc_Type := T; - end if; - - Discr := First_Discriminant (Disc_Type); - - while Present (Discr) loop - Append_To (Constraints, - Make_Selected_Component (Loc, - Prefix => Duplicate_Subexpr (Obj), - Selector_Name => New_Occurrence_Of (Discr, Loc))); - Next_Discriminant (Discr); - end loop; - end if; - - Subt := - Make_Defining_Identifier (Loc, - Chars => New_Internal_Name ('S')); - Set_Is_Internal (Subt); - - Decl := - Make_Subtype_Declaration (Loc, - Defining_Identifier => Subt, - Subtype_Indication => - Make_Subtype_Indication (Loc, - Subtype_Mark => New_Reference_To (T, Loc), - Constraint => - Make_Index_Or_Discriminant_Constraint (Loc, - Constraints => Constraints))); - - Mark_Rewrite_Insertion (Decl); - return Decl; - end Build_Actual_Subtype; - - --------------------------------------- - -- Build_Actual_Subtype_Of_Component -- - --------------------------------------- - - function Build_Actual_Subtype_Of_Component - (T : Entity_Id; - N : Node_Id) - return Node_Id - is - Loc : constant Source_Ptr := Sloc (N); - P : constant Node_Id := Prefix (N); - D : Elmt_Id; - Id : Node_Id; - Indx_Type : Entity_Id; - - Deaccessed_T : Entity_Id; - -- This is either a copy of T, or if T is an access type, then it is - -- the directly designated type of this access type. - - function Build_Actual_Array_Constraint return List_Id; - -- If one or more of the bounds of the component depends on - -- discriminants, build actual constraint using the discriminants - -- of the prefix. - - function Build_Actual_Record_Constraint return List_Id; - -- Similar to previous one, for discriminated components constrained - -- by the discriminant of the enclosing object. - - ----------------------------------- - -- Build_Actual_Array_Constraint -- - ----------------------------------- - - function Build_Actual_Array_Constraint return List_Id is - Constraints : List_Id := New_List; - Indx : Node_Id; - Hi : Node_Id; - Lo : Node_Id; - Old_Hi : Node_Id; - Old_Lo : Node_Id; - - begin - Indx := First_Index (Deaccessed_T); - while Present (Indx) loop - Old_Lo := Type_Low_Bound (Etype (Indx)); - Old_Hi := Type_High_Bound (Etype (Indx)); - - if Denotes_Discriminant (Old_Lo) then - Lo := - Make_Selected_Component (Loc, - Prefix => New_Copy_Tree (P), - Selector_Name => New_Occurrence_Of (Entity (Old_Lo), Loc)); - - else - Lo := New_Copy_Tree (Old_Lo); - - -- The new bound will be reanalyzed in the enclosing - -- declaration. For literal bounds that come from a type - -- declaration, the type of the context must be imposed, so - -- insure that analysis will take place. For non-universal - -- types this is not strictly necessary. - - Set_Analyzed (Lo, False); - end if; - - if Denotes_Discriminant (Old_Hi) then - Hi := - Make_Selected_Component (Loc, - Prefix => New_Copy_Tree (P), - Selector_Name => New_Occurrence_Of (Entity (Old_Hi), Loc)); - - else - Hi := New_Copy_Tree (Old_Hi); - Set_Analyzed (Hi, False); - end if; - - Append (Make_Range (Loc, Lo, Hi), Constraints); - Next_Index (Indx); - end loop; - - return Constraints; - end Build_Actual_Array_Constraint; - - ------------------------------------ - -- Build_Actual_Record_Constraint -- - ------------------------------------ - - function Build_Actual_Record_Constraint return List_Id is - Constraints : List_Id := New_List; - D : Elmt_Id; - D_Val : Node_Id; - - begin - D := First_Elmt (Discriminant_Constraint (Deaccessed_T)); - while Present (D) loop - - if Denotes_Discriminant (Node (D)) then - D_Val := Make_Selected_Component (Loc, - Prefix => New_Copy_Tree (P), - Selector_Name => New_Occurrence_Of (Entity (Node (D)), Loc)); - - else - D_Val := New_Copy_Tree (Node (D)); - end if; - - Append (D_Val, Constraints); - Next_Elmt (D); - end loop; - - return Constraints; - end Build_Actual_Record_Constraint; - - -- Start of processing for Build_Actual_Subtype_Of_Component - - begin - if Nkind (N) = N_Explicit_Dereference then - if Is_Composite_Type (T) - and then not Is_Constrained (T) - and then not (Is_Class_Wide_Type (T) - and then Is_Constrained (Root_Type (T))) - and then not Has_Unknown_Discriminants (T) - then - -- If the type of the dereference is already constrained, it - -- is an actual subtype. - - if Is_Array_Type (Etype (N)) - and then Is_Constrained (Etype (N)) - then - return Empty; - else - Remove_Side_Effects (P); - return Build_Actual_Subtype (T, N); - end if; - else - return Empty; - end if; - end if; - - if Ekind (T) = E_Access_Subtype then - Deaccessed_T := Designated_Type (T); - else - Deaccessed_T := T; - end if; - - if Ekind (Deaccessed_T) = E_Array_Subtype then - - Id := First_Index (Deaccessed_T); - Indx_Type := Underlying_Type (Etype (Id)); - - while Present (Id) loop - - if Denotes_Discriminant (Type_Low_Bound (Indx_Type)) or else - Denotes_Discriminant (Type_High_Bound (Indx_Type)) - then - Remove_Side_Effects (P); - return - Build_Component_Subtype ( - Build_Actual_Array_Constraint, Loc, Base_Type (T)); - end if; - - Next_Index (Id); - end loop; - - elsif Is_Composite_Type (Deaccessed_T) - and then Has_Discriminants (Deaccessed_T) - and then not Has_Unknown_Discriminants (Deaccessed_T) - then - D := First_Elmt (Discriminant_Constraint (Deaccessed_T)); - while Present (D) loop - - if Denotes_Discriminant (Node (D)) then - Remove_Side_Effects (P); - return - Build_Component_Subtype ( - Build_Actual_Record_Constraint, Loc, Base_Type (T)); - end if; - - Next_Elmt (D); - end loop; - end if; - - -- If none of the above, the actual and nominal subtypes are the same. - - return Empty; - - end Build_Actual_Subtype_Of_Component; - - ----------------------------- - -- Build_Component_Subtype -- - ----------------------------- - - function Build_Component_Subtype - (C : List_Id; - Loc : Source_Ptr; - T : Entity_Id) - return Node_Id - is - Subt : Entity_Id; - Decl : Node_Id; - - begin - Subt := - Make_Defining_Identifier (Loc, - Chars => New_Internal_Name ('S')); - Set_Is_Internal (Subt); - - Decl := - Make_Subtype_Declaration (Loc, - Defining_Identifier => Subt, - Subtype_Indication => - Make_Subtype_Indication (Loc, - Subtype_Mark => New_Reference_To (Base_Type (T), Loc), - Constraint => - Make_Index_Or_Discriminant_Constraint (Loc, - Constraints => C))); - - Mark_Rewrite_Insertion (Decl); - return Decl; - end Build_Component_Subtype; - - -------------------------------------------- - -- Build_Discriminal_Subtype_Of_Component -- - -------------------------------------------- - - function Build_Discriminal_Subtype_Of_Component - (T : Entity_Id) - return Node_Id - is - Loc : constant Source_Ptr := Sloc (T); - D : Elmt_Id; - Id : Node_Id; - - function Build_Discriminal_Array_Constraint return List_Id; - -- If one or more of the bounds of the component depends on - -- discriminants, build actual constraint using the discriminants - -- of the prefix. - - function Build_Discriminal_Record_Constraint return List_Id; - -- Similar to previous one, for discriminated components constrained - -- by the discriminant of the enclosing object. - - ---------------------------------------- - -- Build_Discriminal_Array_Constraint -- - ---------------------------------------- - - function Build_Discriminal_Array_Constraint return List_Id is - Constraints : List_Id := New_List; - Indx : Node_Id; - Hi : Node_Id; - Lo : Node_Id; - Old_Hi : Node_Id; - Old_Lo : Node_Id; - - begin - Indx := First_Index (T); - while Present (Indx) loop - Old_Lo := Type_Low_Bound (Etype (Indx)); - Old_Hi := Type_High_Bound (Etype (Indx)); - - if Denotes_Discriminant (Old_Lo) then - Lo := New_Occurrence_Of (Discriminal (Entity (Old_Lo)), Loc); - - else - Lo := New_Copy_Tree (Old_Lo); - end if; - - if Denotes_Discriminant (Old_Hi) then - Hi := New_Occurrence_Of (Discriminal (Entity (Old_Hi)), Loc); - - else - Hi := New_Copy_Tree (Old_Hi); - end if; - - Append (Make_Range (Loc, Lo, Hi), Constraints); - Next_Index (Indx); - end loop; - - return Constraints; - end Build_Discriminal_Array_Constraint; - - ----------------------------------------- - -- Build_Discriminal_Record_Constraint -- - ----------------------------------------- - - function Build_Discriminal_Record_Constraint return List_Id is - Constraints : List_Id := New_List; - D : Elmt_Id; - D_Val : Node_Id; - - begin - D := First_Elmt (Discriminant_Constraint (T)); - while Present (D) loop - - if Denotes_Discriminant (Node (D)) then - D_Val := - New_Occurrence_Of (Discriminal (Entity (Node (D))), Loc); - - else - D_Val := New_Copy_Tree (Node (D)); - end if; - - Append (D_Val, Constraints); - Next_Elmt (D); - end loop; - - return Constraints; - end Build_Discriminal_Record_Constraint; - - -- Start of processing for Build_Discriminal_Subtype_Of_Component - - begin - if Ekind (T) = E_Array_Subtype then - - Id := First_Index (T); - - while Present (Id) loop - - if Denotes_Discriminant (Type_Low_Bound (Etype (Id))) or else - Denotes_Discriminant (Type_High_Bound (Etype (Id))) - then - return Build_Component_Subtype - (Build_Discriminal_Array_Constraint, Loc, T); - end if; - - Next_Index (Id); - end loop; - - elsif Ekind (T) = E_Record_Subtype - and then Has_Discriminants (T) - and then not Has_Unknown_Discriminants (T) - then - D := First_Elmt (Discriminant_Constraint (T)); - while Present (D) loop - - if Denotes_Discriminant (Node (D)) then - return Build_Component_Subtype - (Build_Discriminal_Record_Constraint, Loc, T); - end if; - - Next_Elmt (D); - end loop; - end if; - - -- If none of the above, the actual and nominal subtypes are the same. - - return Empty; - - end Build_Discriminal_Subtype_Of_Component; - - ------------------------------ - -- Build_Elaboration_Entity -- - ------------------------------ - - procedure Build_Elaboration_Entity (N : Node_Id; Spec_Id : Entity_Id) is - Loc : constant Source_Ptr := Sloc (N); - Unum : constant Unit_Number_Type := Get_Source_Unit (Loc); - Decl : Node_Id; - P : Natural; - Elab_Ent : Entity_Id; - - begin - -- Ignore if already constructed - - if Present (Elaboration_Entity (Spec_Id)) then - return; - end if; - - -- Construct name of elaboration entity as xxx_E, where xxx - -- is the unit name with dots replaced by double underscore. - -- We have to manually construct this name, since it will - -- be elaborated in the outer scope, and thus will not have - -- the unit name automatically prepended. - - Get_Name_String (Unit_Name (Unum)); - - -- Replace the %s by _E - - Name_Buffer (Name_Len - 1 .. Name_Len) := "_E"; - - -- Replace dots by double underscore - - P := 2; - while P < Name_Len - 2 loop - if Name_Buffer (P) = '.' then - Name_Buffer (P + 2 .. Name_Len + 1) := - Name_Buffer (P + 1 .. Name_Len); - Name_Len := Name_Len + 1; - Name_Buffer (P) := '_'; - Name_Buffer (P + 1) := '_'; - P := P + 3; - else - P := P + 1; - end if; - end loop; - - -- Create elaboration flag - - Elab_Ent := - Make_Defining_Identifier (Loc, Chars => Name_Find); - Set_Elaboration_Entity (Spec_Id, Elab_Ent); - - if No (Declarations (Aux_Decls_Node (N))) then - Set_Declarations (Aux_Decls_Node (N), New_List); - end if; - - Decl := - Make_Object_Declaration (Loc, - Defining_Identifier => Elab_Ent, - Object_Definition => - New_Occurrence_Of (Standard_Boolean, Loc), - Expression => - New_Occurrence_Of (Standard_False, Loc)); - - Append_To (Declarations (Aux_Decls_Node (N)), Decl); - Analyze (Decl); - - -- Reset True_Constant indication, since we will indeed - -- assign a value to the variable in the binder main. - - Set_Is_True_Constant (Elab_Ent, False); - - -- We do not want any further qualification of the name (if we did - -- not do this, we would pick up the name of the generic package - -- in the case of a library level generic instantiation). - - Set_Has_Qualified_Name (Elab_Ent); - Set_Has_Fully_Qualified_Name (Elab_Ent); - end Build_Elaboration_Entity; - - -------------------------- - -- Check_Fully_Declared -- - -------------------------- - - procedure Check_Fully_Declared (T : Entity_Id; N : Node_Id) is - begin - if Ekind (T) = E_Incomplete_Type then - Error_Msg_NE - ("premature usage of incomplete}", N, First_Subtype (T)); - - elsif Has_Private_Component (T) - and then not Is_Generic_Type (Root_Type (T)) - and then not In_Default_Expression - then - Error_Msg_NE - ("premature usage of incomplete}", N, First_Subtype (T)); - end if; - end Check_Fully_Declared; - - ------------------------------------------ - -- Check_Potentially_Blocking_Operation -- - ------------------------------------------ - - procedure Check_Potentially_Blocking_Operation (N : Node_Id) is - S : Entity_Id; - Loc : constant Source_Ptr := Sloc (N); - - begin - -- N is one of the potentially blocking operations listed in - -- 9.5.1 (8). When using the Ravenscar profile, raise Program_Error - -- before N if the context is a protected action. Otherwise, only issue - -- a warning, since some users are relying on blocking operations - -- inside protected objects. - -- Indirect blocking through a subprogram call - -- cannot be diagnosed statically without interprocedural analysis, - -- so we do not attempt to do it here. - - S := Scope (Current_Scope); - - while Present (S) and then S /= Standard_Standard loop - if Is_Protected_Type (S) then - if Restricted_Profile then - Insert_Before (N, - Make_Raise_Program_Error (Loc)); - Error_Msg_N ("potentially blocking operation, " & - " Program Error will be raised at run time?", N); - - else - Error_Msg_N - ("potentially blocking operation in protected operation?", N); - end if; - - return; - end if; - - S := Scope (S); - end loop; - end Check_Potentially_Blocking_Operation; - - --------------- - -- Check_VMS -- - --------------- - - procedure Check_VMS (Construct : Node_Id) is - begin - if not OpenVMS_On_Target then - Error_Msg_N - ("this construct is allowed only in Open'V'M'S", Construct); - end if; - end Check_VMS; - - ---------------------------------- - -- Collect_Primitive_Operations -- - ---------------------------------- - - function Collect_Primitive_Operations (T : Entity_Id) return Elist_Id is - B_Type : constant Entity_Id := Base_Type (T); - B_Decl : constant Node_Id := Original_Node (Parent (B_Type)); - B_Scope : Entity_Id := Scope (B_Type); - Op_List : Elist_Id; - Formal : Entity_Id; - Is_Prim : Boolean; - Formal_Derived : Boolean := False; - Id : Entity_Id; - - begin - -- For tagged types, the primitive operations are collected as they - -- are declared, and held in an explicit list which is simply returned. - - if Is_Tagged_Type (B_Type) then - return Primitive_Operations (B_Type); - - -- An untagged generic type that is a derived type inherits the - -- primitive operations of its parent type. Other formal types only - -- have predefined operators, which are not explicitly represented. - - elsif Is_Generic_Type (B_Type) then - if Nkind (B_Decl) = N_Formal_Type_Declaration - and then Nkind (Formal_Type_Definition (B_Decl)) - = N_Formal_Derived_Type_Definition - then - Formal_Derived := True; - else - return New_Elmt_List; - end if; - end if; - - Op_List := New_Elmt_List; - - if B_Scope = Standard_Standard then - if B_Type = Standard_String then - Append_Elmt (Standard_Op_Concat, Op_List); - - elsif B_Type = Standard_Wide_String then - Append_Elmt (Standard_Op_Concatw, Op_List); - - else - null; - end if; - - elsif (Is_Package (B_Scope) - and then Nkind ( - Parent (Declaration_Node (First_Subtype (T)))) - /= N_Package_Body) - - or else Is_Derived_Type (B_Type) - then - -- The primitive operations appear after the base type, except - -- if the derivation happens within the private part of B_Scope - -- and the type is a private type, in which case both the type - -- and some primitive operations may appear before the base - -- type, and the list of candidates starts after the type. - - if In_Open_Scopes (B_Scope) - and then Scope (T) = B_Scope - and then In_Private_Part (B_Scope) - then - Id := Next_Entity (T); - else - Id := Next_Entity (B_Type); - end if; - - while Present (Id) loop - - -- Note that generic formal subprograms are not - -- considered to be primitive operations and thus - -- are never inherited. - - if Is_Overloadable (Id) - and then Nkind (Parent (Parent (Id))) - /= N_Formal_Subprogram_Declaration - then - Is_Prim := False; - - if Base_Type (Etype (Id)) = B_Type then - Is_Prim := True; - else - Formal := First_Formal (Id); - while Present (Formal) loop - if Base_Type (Etype (Formal)) = B_Type then - Is_Prim := True; - exit; - - elsif Ekind (Etype (Formal)) = E_Anonymous_Access_Type - and then Base_Type - (Designated_Type (Etype (Formal))) = B_Type - then - Is_Prim := True; - exit; - end if; - - Next_Formal (Formal); - end loop; - end if; - - -- For a formal derived type, the only primitives are the - -- ones inherited from the parent type. Operations appearing - -- in the package declaration are not primitive for it. - - if Is_Prim - and then (not Formal_Derived - or else Present (Alias (Id))) - then - Append_Elmt (Id, Op_List); - end if; - end if; - - Next_Entity (Id); - - -- For a type declared in System, some of its operations - -- may appear in the target-specific extension to System. - - if No (Id) - and then Chars (B_Scope) = Name_System - and then Scope (B_Scope) = Standard_Standard - and then Present_System_Aux - then - B_Scope := System_Aux_Id; - Id := First_Entity (System_Aux_Id); - end if; - - end loop; - - end if; - - return Op_List; - end Collect_Primitive_Operations; - - ----------------------------------- - -- Compile_Time_Constraint_Error -- - ----------------------------------- - - function Compile_Time_Constraint_Error - (N : Node_Id; - Msg : String; - Ent : Entity_Id := Empty; - Loc : Source_Ptr := No_Location) - return Node_Id - is - Msgc : String (1 .. Msg'Length + 2); - Msgl : Natural; - Warn : Boolean; - P : Node_Id; - Msgs : Boolean; - - begin - -- A static constraint error in an instance body is not a fatal error. - -- we choose to inhibit the message altogether, because there is no - -- obvious node (for now) on which to post it. On the other hand the - -- offending node must be replaced with a constraint_error in any case. - - -- No messages are generated if we already posted an error on this node - - if not Error_Posted (N) then - - -- Make all such messages unconditional - - Msgc (1 .. Msg'Length) := Msg; - Msgc (Msg'Length + 1) := '!'; - Msgl := Msg'Length + 1; - - -- Message is a warning, even in Ada 95 case - - if Msg (Msg'Length) = '?' then - Warn := True; - - -- In Ada 83, all messages are warnings. In the private part and - -- the body of an instance, constraint_checks are only warnings. - - elsif Ada_83 and then Comes_From_Source (N) then - - Msgl := Msgl + 1; - Msgc (Msgl) := '?'; - Warn := True; - - elsif In_Instance_Not_Visible then - - Msgl := Msgl + 1; - Msgc (Msgl) := '?'; - Warn := True; - Warn_On_Instance := True; - - -- Otherwise we have a real error message (Ada 95 static case) - - else - Warn := False; - end if; - - -- Should we generate a warning? The answer is not quite yes. The - -- very annoying exception occurs in the case of a short circuit - -- operator where the left operand is static and decisive. Climb - -- parents to see if that is the case we have here. - - Msgs := True; - P := N; - - loop - P := Parent (P); - - if (Nkind (P) = N_And_Then - and then Compile_Time_Known_Value (Left_Opnd (P)) - and then Is_False (Expr_Value (Left_Opnd (P)))) - or else (Nkind (P) = N_Or_Else - and then Compile_Time_Known_Value (Left_Opnd (P)) - and then Is_True (Expr_Value (Left_Opnd (P)))) - then - Msgs := False; - exit; - - elsif Nkind (P) = N_Component_Association - and then Nkind (Parent (P)) = N_Aggregate - then - null; -- Keep going. - - else - exit when Nkind (P) not in N_Subexpr; - end if; - end loop; - - if Msgs then - if Present (Ent) then - Error_Msg_NE (Msgc (1 .. Msgl), N, Ent); - else - Error_Msg_NE (Msgc (1 .. Msgl), N, Etype (N)); - end if; - - if Warn then - if Inside_Init_Proc then - Error_Msg_NE - ("\& will be raised for objects of this type!?", - N, Standard_Constraint_Error); - else - Error_Msg_NE - ("\& will be raised at run time!?", - N, Standard_Constraint_Error); - end if; - else - Error_Msg_NE - ("\static expression raises&!", - N, Standard_Constraint_Error); - end if; - end if; - end if; - - return N; - end Compile_Time_Constraint_Error; - - ----------------------- - -- Conditional_Delay -- - ----------------------- - - procedure Conditional_Delay (New_Ent, Old_Ent : Entity_Id) is - begin - if Has_Delayed_Freeze (Old_Ent) and then not Is_Frozen (Old_Ent) then - Set_Has_Delayed_Freeze (New_Ent); - end if; - end Conditional_Delay; - - -------------------- - -- Current_Entity -- - -------------------- - - -- The currently visible definition for a given identifier is the - -- one most chained at the start of the visibility chain, i.e. the - -- one that is referenced by the Node_Id value of the name of the - -- given identifier. - - function Current_Entity (N : Node_Id) return Entity_Id is - begin - return Get_Name_Entity_Id (Chars (N)); - end Current_Entity; - - ----------------------------- - -- Current_Entity_In_Scope -- - ----------------------------- - - function Current_Entity_In_Scope (N : Node_Id) return Entity_Id is - E : Entity_Id; - CS : constant Entity_Id := Current_Scope; - - Transient_Case : constant Boolean := Scope_Is_Transient; - - begin - E := Get_Name_Entity_Id (Chars (N)); - - while Present (E) - and then Scope (E) /= CS - and then (not Transient_Case or else Scope (E) /= Scope (CS)) - loop - E := Homonym (E); - end loop; - - return E; - end Current_Entity_In_Scope; - - ------------------- - -- Current_Scope -- - ------------------- - - function Current_Scope return Entity_Id is - begin - if Scope_Stack.Last = -1 then - return Standard_Standard; - else - declare - C : constant Entity_Id := - Scope_Stack.Table (Scope_Stack.Last).Entity; - begin - if Present (C) then - return C; - else - return Standard_Standard; - end if; - end; - end if; - end Current_Scope; - - ------------------------ - -- Current_Subprogram -- - ------------------------ - - function Current_Subprogram return Entity_Id is - Scop : constant Entity_Id := Current_Scope; - - begin - if Ekind (Scop) = E_Function - or else - Ekind (Scop) = E_Procedure - or else - Ekind (Scop) = E_Generic_Function - or else - Ekind (Scop) = E_Generic_Procedure - then - return Scop; - - else - return Enclosing_Subprogram (Scop); - end if; - end Current_Subprogram; - - --------------------- - -- Defining_Entity -- - --------------------- - - function Defining_Entity (N : Node_Id) return Entity_Id is - K : constant Node_Kind := Nkind (N); - Err : Entity_Id := Empty; - - begin - case K is - when - N_Subprogram_Declaration | - N_Abstract_Subprogram_Declaration | - N_Subprogram_Body | - N_Package_Declaration | - N_Subprogram_Renaming_Declaration | - N_Subprogram_Body_Stub | - N_Generic_Subprogram_Declaration | - N_Generic_Package_Declaration | - N_Formal_Subprogram_Declaration - => - return Defining_Entity (Specification (N)); - - when - N_Component_Declaration | - N_Defining_Program_Unit_Name | - N_Discriminant_Specification | - N_Entry_Body | - N_Entry_Declaration | - N_Entry_Index_Specification | - N_Exception_Declaration | - N_Exception_Renaming_Declaration | - N_Formal_Object_Declaration | - N_Formal_Package_Declaration | - N_Formal_Type_Declaration | - N_Full_Type_Declaration | - N_Implicit_Label_Declaration | - N_Incomplete_Type_Declaration | - N_Loop_Parameter_Specification | - N_Number_Declaration | - N_Object_Declaration | - N_Object_Renaming_Declaration | - N_Package_Body_Stub | - N_Parameter_Specification | - N_Private_Extension_Declaration | - N_Private_Type_Declaration | - N_Protected_Body | - N_Protected_Body_Stub | - N_Protected_Type_Declaration | - N_Single_Protected_Declaration | - N_Single_Task_Declaration | - N_Subtype_Declaration | - N_Task_Body | - N_Task_Body_Stub | - N_Task_Type_Declaration - => - return Defining_Identifier (N); - - when N_Subunit => - return Defining_Entity (Proper_Body (N)); - - when - N_Function_Instantiation | - N_Function_Specification | - N_Generic_Function_Renaming_Declaration | - N_Generic_Package_Renaming_Declaration | - N_Generic_Procedure_Renaming_Declaration | - N_Package_Body | - N_Package_Instantiation | - N_Package_Renaming_Declaration | - N_Package_Specification | - N_Procedure_Instantiation | - N_Procedure_Specification - => - declare - Nam : constant Node_Id := Defining_Unit_Name (N); - - begin - if Nkind (Nam) in N_Entity then - return Nam; - - -- For Error, make up a name and attach to declaration - -- so we can continue semantic analysis - - elsif Nam = Error then - Err := - Make_Defining_Identifier (Sloc (N), - Chars => New_Internal_Name ('T')); - Set_Defining_Unit_Name (N, Err); - - return Err; - -- If not an entity, get defining identifier - - else - return Defining_Identifier (Nam); - end if; - end; - - when N_Block_Statement => - return Entity (Identifier (N)); - - when others => - raise Program_Error; - - end case; - end Defining_Entity; - - -------------------------- - -- Denotes_Discriminant -- - -------------------------- - - function Denotes_Discriminant (N : Node_Id) return Boolean is - begin - return Is_Entity_Name (N) - and then Present (Entity (N)) - and then Ekind (Entity (N)) = E_Discriminant; - end Denotes_Discriminant; - - ----------------------------- - -- Depends_On_Discriminant -- - ----------------------------- - - function Depends_On_Discriminant (N : Node_Id) return Boolean is - L : Node_Id; - H : Node_Id; - - begin - Get_Index_Bounds (N, L, H); - return Denotes_Discriminant (L) or else Denotes_Discriminant (H); - end Depends_On_Discriminant; - - ------------------------- - -- Designate_Same_Unit -- - ------------------------- - - function Designate_Same_Unit - (Name1 : Node_Id; - Name2 : Node_Id) - return Boolean - is - K1 : Node_Kind := Nkind (Name1); - K2 : Node_Kind := Nkind (Name2); - - function Prefix_Node (N : Node_Id) return Node_Id; - -- Returns the parent unit name node of a defining program unit name - -- or the prefix if N is a selected component or an expanded name. - - function Select_Node (N : Node_Id) return Node_Id; - -- Returns the defining identifier node of a defining program unit - -- name or the selector node if N is a selected component or an - -- expanded name. - - function Prefix_Node (N : Node_Id) return Node_Id is - begin - if Nkind (N) = N_Defining_Program_Unit_Name then - return Name (N); - - else - return Prefix (N); - end if; - end Prefix_Node; - - function Select_Node (N : Node_Id) return Node_Id is - begin - if Nkind (N) = N_Defining_Program_Unit_Name then - return Defining_Identifier (N); - - else - return Selector_Name (N); - end if; - end Select_Node; - - -- Start of processing for Designate_Next_Unit - - begin - if (K1 = N_Identifier or else - K1 = N_Defining_Identifier) - and then - (K2 = N_Identifier or else - K2 = N_Defining_Identifier) - then - return Chars (Name1) = Chars (Name2); - - elsif - (K1 = N_Expanded_Name or else - K1 = N_Selected_Component or else - K1 = N_Defining_Program_Unit_Name) - and then - (K2 = N_Expanded_Name or else - K2 = N_Selected_Component or else - K2 = N_Defining_Program_Unit_Name) - then - return - (Chars (Select_Node (Name1)) = Chars (Select_Node (Name2))) - and then - Designate_Same_Unit (Prefix_Node (Name1), Prefix_Node (Name2)); - - else - return False; - end if; - end Designate_Same_Unit; - - ---------------------------- - -- Enclosing_Generic_Body -- - ---------------------------- - - function Enclosing_Generic_Body - (E : Entity_Id) - return Node_Id - is - P : Node_Id; - Decl : Node_Id; - Spec : Node_Id; - - begin - P := Parent (E); - - while Present (P) loop - if Nkind (P) = N_Package_Body - or else Nkind (P) = N_Subprogram_Body - then - Spec := Corresponding_Spec (P); - - if Present (Spec) then - Decl := Unit_Declaration_Node (Spec); - - if Nkind (Decl) = N_Generic_Package_Declaration - or else Nkind (Decl) = N_Generic_Subprogram_Declaration - then - return P; - end if; - end if; - end if; - - P := Parent (P); - end loop; - - return Empty; - end Enclosing_Generic_Body; - - ------------------------------- - -- Enclosing_Lib_Unit_Entity -- - ------------------------------- - - function Enclosing_Lib_Unit_Entity return Entity_Id is - Unit_Entity : Entity_Id := Current_Scope; - - begin - -- Look for enclosing library unit entity by following scope links. - -- Equivalent to, but faster than indexing through the scope stack. - - while (Present (Scope (Unit_Entity)) - and then Scope (Unit_Entity) /= Standard_Standard) - and not Is_Child_Unit (Unit_Entity) - loop - Unit_Entity := Scope (Unit_Entity); - end loop; - - return Unit_Entity; - end Enclosing_Lib_Unit_Entity; - - ----------------------------- - -- Enclosing_Lib_Unit_Node -- - ----------------------------- - - function Enclosing_Lib_Unit_Node (N : Node_Id) return Node_Id is - Current_Node : Node_Id := N; - - begin - while Present (Current_Node) - and then Nkind (Current_Node) /= N_Compilation_Unit - loop - Current_Node := Parent (Current_Node); - end loop; - - if Nkind (Current_Node) /= N_Compilation_Unit then - return Empty; - end if; - - return Current_Node; - end Enclosing_Lib_Unit_Node; - - -------------------------- - -- Enclosing_Subprogram -- - -------------------------- - - function Enclosing_Subprogram (E : Entity_Id) return Entity_Id is - Dynamic_Scope : constant Entity_Id := Enclosing_Dynamic_Scope (E); - - begin - if Dynamic_Scope = Standard_Standard then - return Empty; - - elsif Ekind (Dynamic_Scope) = E_Subprogram_Body then - return Corresponding_Spec (Parent (Parent (Dynamic_Scope))); - - elsif Ekind (Dynamic_Scope) = E_Block then - return Enclosing_Subprogram (Dynamic_Scope); - - elsif Ekind (Dynamic_Scope) = E_Task_Type then - return Get_Task_Body_Procedure (Dynamic_Scope); - - elsif Convention (Dynamic_Scope) = Convention_Protected then - return Protected_Body_Subprogram (Dynamic_Scope); - - else - return Dynamic_Scope; - end if; - end Enclosing_Subprogram; - - ------------------------ - -- Ensure_Freeze_Node -- - ------------------------ - - procedure Ensure_Freeze_Node (E : Entity_Id) is - FN : Node_Id; - - begin - if No (Freeze_Node (E)) then - FN := Make_Freeze_Entity (Sloc (E)); - Set_Has_Delayed_Freeze (E); - Set_Freeze_Node (E, FN); - Set_Access_Types_To_Process (FN, No_Elist); - Set_TSS_Elist (FN, No_Elist); - Set_Entity (FN, E); - end if; - end Ensure_Freeze_Node; - - ---------------- - -- Enter_Name -- - ---------------- - - procedure Enter_Name (Def_Id : Node_Id) is - C : constant Entity_Id := Current_Entity (Def_Id); - E : constant Entity_Id := Current_Entity_In_Scope (Def_Id); - S : constant Entity_Id := Current_Scope; - - begin - Generate_Definition (Def_Id); - - -- Add new name to current scope declarations. Check for duplicate - -- declaration, which may or may not be a genuine error. - - if Present (E) then - - -- Case of previous entity entered because of a missing declaration - -- or else a bad subtype indication. Best is to use the new entity, - -- and make the previous one invisible. - - if Etype (E) = Any_Type then - Set_Is_Immediately_Visible (E, False); - - -- Case of renaming declaration constructed for package instances. - -- if there is an explicit declaration with the same identifier, - -- the renaming is not immediately visible any longer, but remains - -- visible through selected component notation. - - elsif Nkind (Parent (E)) = N_Package_Renaming_Declaration - and then not Comes_From_Source (E) - then - Set_Is_Immediately_Visible (E, False); - - -- The new entity may be the package renaming, which has the same - -- same name as a generic formal which has been seen already. - - elsif Nkind (Parent (Def_Id)) = N_Package_Renaming_Declaration - and then not Comes_From_Source (Def_Id) - then - Set_Is_Immediately_Visible (E, False); - - -- For a fat pointer corresponding to a remote access to subprogram, - -- we use the same identifier as the RAS type, so that the proper - -- name appears in the stub. This type is only retrieved through - -- the RAS type and never by visibility, and is not added to the - -- visibility list (see below). - - elsif Nkind (Parent (Def_Id)) = N_Full_Type_Declaration - and then Present (Corresponding_Remote_Type (Def_Id)) - then - null; - - -- A controller component for a type extension overrides the - -- inherited component. - - elsif Chars (E) = Name_uController then - null; - - -- Case of an implicit operation or derived literal. The new entity - -- hides the implicit one, which is removed from all visibility, - -- i.e. the entity list of its scope, and homonym chain of its name. - - elsif (Is_Overloadable (E) and then Present (Alias (E))) - or else Is_Internal (E) - or else (Ekind (E) = E_Enumeration_Literal - and then Is_Derived_Type (Etype (E))) - then - declare - Prev : Entity_Id; - Prev_Vis : Entity_Id; - - begin - -- If E is an implicit declaration, it cannot be the first - -- entity in the scope. - - Prev := First_Entity (Current_Scope); - - while Next_Entity (Prev) /= E loop - Next_Entity (Prev); - end loop; - - Set_Next_Entity (Prev, Next_Entity (E)); - - if No (Next_Entity (Prev)) then - Set_Last_Entity (Current_Scope, Prev); - end if; - - if E = Current_Entity (E) then - Prev_Vis := Empty; - else - Prev_Vis := Current_Entity (E); - while Homonym (Prev_Vis) /= E loop - Prev_Vis := Homonym (Prev_Vis); - end loop; - end if; - - if Present (Prev_Vis) then - - -- Skip E in the visibility chain - - Set_Homonym (Prev_Vis, Homonym (E)); - - else - Set_Name_Entity_Id (Chars (E), Homonym (E)); - end if; - end; - - -- This section of code could use a comment ??? - - elsif Present (Etype (E)) - and then Is_Concurrent_Type (Etype (E)) - and then E = Def_Id - then - return; - - -- In the body or private part of an instance, a type extension - -- may introduce a component with the same name as that of an - -- actual. The legality rule is not enforced, but the semantics - -- of the full type with two components of the same name are not - -- clear at this point ??? - - elsif In_Instance_Not_Visible then - null; - - -- When compiling a package body, some child units may have become - -- visible. They cannot conflict with local entities that hide them. - - elsif Is_Child_Unit (E) - and then In_Open_Scopes (Scope (E)) - and then not Is_Immediately_Visible (E) - then - null; - - -- Conversely, with front-end inlining we may compile the parent - -- body first, and a child unit subsequently. The context is now - -- the parent spec, and body entities are not visible. - - elsif Is_Child_Unit (Def_Id) - and then Is_Package_Body_Entity (E) - and then not In_Package_Body (Current_Scope) - then - null; - - -- Case of genuine duplicate declaration - - else - Error_Msg_Sloc := Sloc (E); - - -- If the previous declaration is an incomplete type declaration - -- this may be an attempt to complete it with a private type. - -- The following avoids confusing cascaded errors. - - if Nkind (Parent (E)) = N_Incomplete_Type_Declaration - and then Nkind (Parent (Def_Id)) = N_Private_Type_Declaration - then - Error_Msg_N - ("incomplete type cannot be completed" & - " with a private declaration", - Parent (Def_Id)); - Set_Is_Immediately_Visible (E, False); - Set_Full_View (E, Def_Id); - - elsif Ekind (E) = E_Discriminant - and then Present (Scope (Def_Id)) - and then Scope (Def_Id) /= Current_Scope - then - -- An inherited component of a record conflicts with - -- a new discriminant. The discriminant is inserted first - -- in the scope, but the error should be posted on it, not - -- on the component. - - Error_Msg_Sloc := Sloc (Def_Id); - Error_Msg_N ("& conflicts with declaration#", E); - return; - - -- If the name of the unit appears in its own context clause, - -- a dummy package with the name has already been created, and - -- the error emitted. Try to continue quietly. - - elsif Error_Posted (E) - and then Sloc (E) = No_Location - and then Nkind (Parent (E)) = N_Package_Specification - and then Current_Scope = Standard_Standard - then - Set_Scope (Def_Id, Current_Scope); - return; - - else - Error_Msg_N ("& conflicts with declaration#", Def_Id); - - -- Avoid cascaded messages with duplicate components in - -- derived types. - - if Ekind (E) = E_Component - or else Ekind (E) = E_Discriminant - then - return; - end if; - end if; - - if Nkind (Parent (Parent (Def_Id))) - = N_Generic_Subprogram_Declaration - and then Def_Id = - Defining_Entity (Specification (Parent (Parent (Def_Id)))) - then - Error_Msg_N ("\generic units cannot be overloaded", Def_Id); - end if; - - -- If entity is in standard, then we are in trouble, because - -- it means that we have a library package with a duplicated - -- name. That's hard to recover from, so abort! - - if S = Standard_Standard then - raise Unrecoverable_Error; - - -- Otherwise we continue with the declaration. Having two - -- identical declarations should not cause us too much trouble! - - else - null; - end if; - end if; - end if; - - -- If we fall through, declaration is OK , or OK enough to continue - - -- If Def_Id is a discriminant or a record component we are in the - -- midst of inheriting components in a derived record definition. - -- Preserve their Ekind and Etype. - - if Ekind (Def_Id) = E_Discriminant - or else Ekind (Def_Id) = E_Component - then - null; - - -- If a type is already set, leave it alone (happens whey a type - -- declaration is reanalyzed following a call to the optimizer) - - elsif Present (Etype (Def_Id)) then - null; - - -- Otherwise, the kind E_Void insures that premature uses of the entity - -- will be detected. Any_Type insures that no cascaded errors will occur - - else - Set_Ekind (Def_Id, E_Void); - Set_Etype (Def_Id, Any_Type); - end if; - - -- Inherited discriminants and components in derived record types are - -- immediately visible. Itypes are not. - - if Ekind (Def_Id) = E_Discriminant - or else Ekind (Def_Id) = E_Component - or else (No (Corresponding_Remote_Type (Def_Id)) - and then not Is_Itype (Def_Id)) - then - Set_Is_Immediately_Visible (Def_Id); - Set_Current_Entity (Def_Id); - end if; - - Set_Homonym (Def_Id, C); - Append_Entity (Def_Id, S); - Set_Public_Status (Def_Id); - - -- Warn if new entity hides an old one - - if Warn_On_Hiding - and then Length_Of_Name (Chars (C)) /= 1 - and then Present (C) - and then Comes_From_Source (C) - and then Comes_From_Source (Def_Id) - and then In_Extended_Main_Source_Unit (Def_Id) - then - Error_Msg_Sloc := Sloc (C); - Error_Msg_N ("declaration hides &#?", Def_Id); - end if; - - end Enter_Name; - - ------------------------------------- - -- Find_Corresponding_Discriminant -- - ------------------------------------- - - function Find_Corresponding_Discriminant - (Id : Node_Id; - Typ : Entity_Id) - return Entity_Id - is - Par_Disc : Entity_Id; - Old_Disc : Entity_Id; - New_Disc : Entity_Id; - - begin - Par_Disc := Original_Record_Component (Original_Discriminant (Id)); - Old_Disc := First_Discriminant (Scope (Par_Disc)); - - if Is_Class_Wide_Type (Typ) then - New_Disc := First_Discriminant (Root_Type (Typ)); - else - New_Disc := First_Discriminant (Typ); - end if; - - while Present (Old_Disc) and then Present (New_Disc) loop - if Old_Disc = Par_Disc then - return New_Disc; - else - Next_Discriminant (Old_Disc); - Next_Discriminant (New_Disc); - end if; - end loop; - - -- Should always find it - - raise Program_Error; - end Find_Corresponding_Discriminant; - - ------------------ - -- First_Actual -- - ------------------ - - function First_Actual (Node : Node_Id) return Node_Id is - N : Node_Id; - - begin - if No (Parameter_Associations (Node)) then - return Empty; - end if; - - N := First (Parameter_Associations (Node)); - - if Nkind (N) = N_Parameter_Association then - return First_Named_Actual (Node); - else - return N; - end if; - end First_Actual; - - ------------------------- - -- Full_Qualified_Name -- - ------------------------- - - function Full_Qualified_Name (E : Entity_Id) return String_Id is - - Res : String_Id; - - function Internal_Full_Qualified_Name (E : Entity_Id) return String_Id; - -- Compute recursively the qualified name without NUL at the end. - - function Internal_Full_Qualified_Name (E : Entity_Id) return String_Id is - Ent : Entity_Id := E; - Parent_Name : String_Id := No_String; - - begin - -- Deals properly with child units - - if Nkind (Ent) = N_Defining_Program_Unit_Name then - Ent := Defining_Identifier (Ent); - end if; - - -- Compute recursively the qualification. Only "Standard" has no - -- scope. - - if Present (Scope (Scope (Ent))) then - Parent_Name := Internal_Full_Qualified_Name (Scope (Ent)); - end if; - - -- Every entity should have a name except some expanded blocks - -- don't bother about those. - - if Chars (Ent) = No_Name then - return Parent_Name; - end if; - - -- Add a period between Name and qualification - - if Parent_Name /= No_String then - Start_String (Parent_Name); - Store_String_Char (Get_Char_Code ('.')); - - else - Start_String; - end if; - - -- Generates the entity name in upper case - - Get_Name_String (Chars (Ent)); - Set_All_Upper_Case; - Store_String_Chars (Name_Buffer (1 .. Name_Len)); - return End_String; - end Internal_Full_Qualified_Name; - - begin - Res := Internal_Full_Qualified_Name (E); - Store_String_Char (Get_Char_Code (ASCII.nul)); - return End_String; - end Full_Qualified_Name; - - ----------------------- - -- Gather_Components -- - ----------------------- - - procedure Gather_Components - (Typ : Entity_Id; - Comp_List : Node_Id; - Governed_By : List_Id; - Into : Elist_Id; - Report_Errors : out Boolean) - is - Assoc : Node_Id; - Variant : Node_Id; - Discrete_Choice : Node_Id; - Comp_Item : Node_Id; - - Discrim : Entity_Id; - Discrim_Name : Node_Id; - Discrim_Value : Node_Id; - - begin - Report_Errors := False; - - if No (Comp_List) or else Null_Present (Comp_List) then - return; - - elsif Present (Component_Items (Comp_List)) then - Comp_Item := First (Component_Items (Comp_List)); - - else - Comp_Item := Empty; - end if; - - while Present (Comp_Item) loop - - -- Skip the tag of a tagged record, as well as all items - -- that are not user components (anonymous types, rep clauses, - -- Parent field, controller field). - - if Nkind (Comp_Item) = N_Component_Declaration - and then Chars (Defining_Identifier (Comp_Item)) /= Name_uTag - and then Chars (Defining_Identifier (Comp_Item)) /= Name_uParent - and then Chars (Defining_Identifier (Comp_Item)) /= Name_uController - then - Append_Elmt (Defining_Identifier (Comp_Item), Into); - end if; - - Next (Comp_Item); - end loop; - - if No (Variant_Part (Comp_List)) then - return; - else - Discrim_Name := Name (Variant_Part (Comp_List)); - Variant := First_Non_Pragma (Variants (Variant_Part (Comp_List))); - end if; - - -- Look for the discriminant that governs this variant part. - -- The discriminant *must* be in the Governed_By List - - Assoc := First (Governed_By); - Find_Constraint : loop - Discrim := First (Choices (Assoc)); - exit Find_Constraint when Chars (Discrim_Name) = Chars (Discrim) - or else (Present (Corresponding_Discriminant (Entity (Discrim))) - and then - Chars (Corresponding_Discriminant (Entity (Discrim))) - = Chars (Discrim_Name)) - or else Chars (Original_Record_Component (Entity (Discrim))) - = Chars (Discrim_Name); - - if No (Next (Assoc)) then - if not Is_Constrained (Typ) - and then Is_Derived_Type (Typ) - and then Present (Girder_Constraint (Typ)) - then - - -- If the type is a tagged type with inherited discriminants, - -- use the girder constraint on the parent in order to find - -- the values of discriminants that are otherwise hidden by an - -- explicit constraint. Renamed discriminants are handled in - -- the code above. - - declare - D : Entity_Id; - C : Elmt_Id; - - begin - D := First_Discriminant (Etype (Typ)); - C := First_Elmt (Girder_Constraint (Typ)); - - while Present (D) - and then Present (C) - loop - if Chars (Discrim_Name) = Chars (D) then - Assoc := - Make_Component_Association (Sloc (Typ), - New_List - (New_Occurrence_Of (D, Sloc (Typ))), - Duplicate_Subexpr (Node (C))); - exit Find_Constraint; - end if; - - D := Next_Discriminant (D); - Next_Elmt (C); - end loop; - end; - end if; - end if; - - if No (Next (Assoc)) then - Error_Msg_NE (" missing value for discriminant&", - First (Governed_By), Discrim_Name); - Report_Errors := True; - return; - end if; - - Next (Assoc); - end loop Find_Constraint; - - Discrim_Value := Expression (Assoc); - - if not Is_OK_Static_Expression (Discrim_Value) then - Error_Msg_NE - ("value for discriminant & must be static", Discrim_Value, Discrim); - Report_Errors := True; - return; - end if; - - Search_For_Discriminant_Value : declare - Low : Node_Id; - High : Node_Id; - - UI_High : Uint; - UI_Low : Uint; - UI_Discrim_Value : constant Uint := Expr_Value (Discrim_Value); - - begin - Find_Discrete_Value : while Present (Variant) loop - Discrete_Choice := First (Discrete_Choices (Variant)); - while Present (Discrete_Choice) loop - - exit Find_Discrete_Value when - Nkind (Discrete_Choice) = N_Others_Choice; - - Get_Index_Bounds (Discrete_Choice, Low, High); - - UI_Low := Expr_Value (Low); - UI_High := Expr_Value (High); - - exit Find_Discrete_Value when - UI_Low <= UI_Discrim_Value - and then - UI_High >= UI_Discrim_Value; - - Next (Discrete_Choice); - end loop; - - Next_Non_Pragma (Variant); - end loop Find_Discrete_Value; - end Search_For_Discriminant_Value; - - if No (Variant) then - Error_Msg_NE - ("value of discriminant & is out of range", Discrim_Value, Discrim); - Report_Errors := True; - return; - end if; - - -- If we have found the corresponding choice, recursively add its - -- components to the Into list. - - Gather_Components (Empty, - Component_List (Variant), Governed_By, Into, Report_Errors); - end Gather_Components; - - ------------------------ - -- Get_Actual_Subtype -- - ------------------------ - - function Get_Actual_Subtype (N : Node_Id) return Entity_Id is - Typ : constant Entity_Id := Etype (N); - Utyp : Entity_Id := Underlying_Type (Typ); - Decl : Node_Id; - Atyp : Entity_Id; - - begin - if not Present (Utyp) then - Utyp := Typ; - end if; - - -- If what we have is an identifier that references a subprogram - -- formal, or a variable or constant object, then we get the actual - -- subtype from the referenced entity if one has been built. - - if Nkind (N) = N_Identifier - and then - (Is_Formal (Entity (N)) - or else Ekind (Entity (N)) = E_Constant - or else Ekind (Entity (N)) = E_Variable) - and then Present (Actual_Subtype (Entity (N))) - then - return Actual_Subtype (Entity (N)); - - -- Actual subtype of unchecked union is always itself. We never need - -- the "real" actual subtype. If we did, we couldn't get it anyway - -- because the discriminant is not available. The restrictions on - -- Unchecked_Union are designed to make sure that this is OK. - - elsif Is_Unchecked_Union (Utyp) then - return Typ; - - -- Here for the unconstrained case, we must find actual subtype - -- No actual subtype is available, so we must build it on the fly. - - -- Checking the type, not the underlying type, for constrainedness - -- seems to be necessary. Maybe all the tests should be on the type??? - - elsif (not Is_Constrained (Typ)) - and then (Is_Array_Type (Utyp) - or else (Is_Record_Type (Utyp) - and then Has_Discriminants (Utyp))) - and then not Has_Unknown_Discriminants (Utyp) - and then not (Ekind (Utyp) = E_String_Literal_Subtype) - then - -- Nothing to do if in default expression - - if In_Default_Expression then - return Typ; - - -- Else build the actual subtype - - else - Decl := Build_Actual_Subtype (Typ, N); - Atyp := Defining_Identifier (Decl); - - -- If Build_Actual_Subtype generated a new declaration then use it - - if Atyp /= Typ then - - -- The actual subtype is an Itype, so analyze the declaration, - -- but do not attach it to the tree, to get the type defined. - - Set_Parent (Decl, N); - Set_Is_Itype (Atyp); - Analyze (Decl, Suppress => All_Checks); - Set_Associated_Node_For_Itype (Atyp, N); - Set_Has_Delayed_Freeze (Atyp, False); - - -- We need to freeze the actual subtype immediately. This is - -- needed, because otherwise this Itype will not get frozen - -- at all, and it is always safe to freeze on creation because - -- any associated types must be frozen at this point. - - Freeze_Itype (Atyp, N); - return Atyp; - - -- Otherwise we did not build a declaration, so return original - - else - return Typ; - end if; - end if; - - -- For all remaining cases, the actual subtype is the same as - -- the nominal type. - - else - return Typ; - end if; - end Get_Actual_Subtype; - - ------------------------------------- - -- Get_Actual_Subtype_If_Available -- - ------------------------------------- - - function Get_Actual_Subtype_If_Available (N : Node_Id) return Entity_Id is - Typ : constant Entity_Id := Etype (N); - - begin - -- If what we have is an identifier that references a subprogram - -- formal, or a variable or constant object, then we get the actual - -- subtype from the referenced entity if one has been built. - - if Nkind (N) = N_Identifier - and then - (Is_Formal (Entity (N)) - or else Ekind (Entity (N)) = E_Constant - or else Ekind (Entity (N)) = E_Variable) - and then Present (Actual_Subtype (Entity (N))) - then - return Actual_Subtype (Entity (N)); - - -- Otherwise the Etype of N is returned unchanged - - else - return Typ; - end if; - end Get_Actual_Subtype_If_Available; - - ------------------------------- - -- Get_Default_External_Name -- - ------------------------------- - - function Get_Default_External_Name (E : Node_Or_Entity_Id) return Node_Id is - begin - Get_Decoded_Name_String (Chars (E)); - - if Opt.External_Name_Imp_Casing = Uppercase then - Set_Casing (All_Upper_Case); - else - Set_Casing (All_Lower_Case); - end if; - - return - Make_String_Literal (Sloc (E), - Strval => String_From_Name_Buffer); - - end Get_Default_External_Name; - - --------------------------- - -- Get_Enum_Lit_From_Pos -- - --------------------------- - - function Get_Enum_Lit_From_Pos - (T : Entity_Id; - Pos : Uint; - Loc : Source_Ptr) - return Node_Id - is - Lit : Node_Id; - P : constant Nat := UI_To_Int (Pos); - - begin - -- In the case where the literal is either of type Wide_Character - -- or Character or of a type derived from them, there needs to be - -- some special handling since there is no explicit chain of - -- literals to search. Instead, an N_Character_Literal node is - -- created with the appropriate Char_Code and Chars fields. - - if Root_Type (T) = Standard_Character - or else Root_Type (T) = Standard_Wide_Character - then - Set_Character_Literal_Name (Char_Code (P)); - return - Make_Character_Literal (Loc, - Chars => Name_Find, - Char_Literal_Value => Char_Code (P)); - - -- For all other cases, we have a complete table of literals, and - -- we simply iterate through the chain of literal until the one - -- with the desired position value is found. - -- - - else - Lit := First_Literal (Base_Type (T)); - for J in 1 .. P loop - Next_Literal (Lit); - end loop; - - return New_Occurrence_Of (Lit, Loc); - end if; - end Get_Enum_Lit_From_Pos; - - ---------------------- - -- Get_Index_Bounds -- - ---------------------- - - procedure Get_Index_Bounds (N : Node_Id; L, H : out Node_Id) is - Kind : constant Node_Kind := Nkind (N); - R : Node_Id; - - begin - if Kind = N_Range then - L := Low_Bound (N); - H := High_Bound (N); - - elsif Kind = N_Subtype_Indication then - R := Range_Expression (Constraint (N)); - - if R = Error then - L := Error; - H := Error; - return; - - else - L := Low_Bound (Range_Expression (Constraint (N))); - H := High_Bound (Range_Expression (Constraint (N))); - end if; - - elsif Is_Entity_Name (N) and then Is_Type (Entity (N)) then - if Error_Posted (Scalar_Range (Entity (N))) then - L := Error; - H := Error; - - elsif Nkind (Scalar_Range (Entity (N))) = N_Subtype_Indication then - Get_Index_Bounds (Scalar_Range (Entity (N)), L, H); - - else - L := Low_Bound (Scalar_Range (Entity (N))); - H := High_Bound (Scalar_Range (Entity (N))); - end if; - - else - -- N is an expression, indicating a range with one value. - - L := N; - H := N; - end if; - end Get_Index_Bounds; - - ------------------------ - -- Get_Name_Entity_Id -- - ------------------------ - - function Get_Name_Entity_Id (Id : Name_Id) return Entity_Id is - begin - return Entity_Id (Get_Name_Table_Info (Id)); - end Get_Name_Entity_Id; - - --------------------------- - -- Get_Referenced_Object -- - --------------------------- - - function Get_Referenced_Object (N : Node_Id) return Node_Id is - R : Node_Id := N; - - begin - while Is_Entity_Name (R) - and then Present (Renamed_Object (Entity (R))) - loop - R := Renamed_Object (Entity (R)); - end loop; - - return R; - end Get_Referenced_Object; - - ------------------------- - -- Get_Subprogram_Body -- - ------------------------- - - function Get_Subprogram_Body (E : Entity_Id) return Node_Id is - Decl : Node_Id; - - begin - Decl := Unit_Declaration_Node (E); - - if Nkind (Decl) = N_Subprogram_Body then - return Decl; - - else -- Nkind (Decl) = N_Subprogram_Declaration - - if Present (Corresponding_Body (Decl)) then - return Unit_Declaration_Node (Corresponding_Body (Decl)); - - else -- imported subprogram. - return Empty; - end if; - end if; - end Get_Subprogram_Body; - - ----------------------------- - -- Get_Task_Body_Procedure -- - ----------------------------- - - function Get_Task_Body_Procedure (E : Entity_Id) return Node_Id is - begin - return Task_Body_Procedure (Declaration_Node (Root_Type (E))); - end Get_Task_Body_Procedure; - - -------------------- - -- Has_Infinities -- - -------------------- - - function Has_Infinities (E : Entity_Id) return Boolean is - begin - return - Is_Floating_Point_Type (E) - and then Nkind (Scalar_Range (E)) = N_Range - and then Includes_Infinities (Scalar_Range (E)); - end Has_Infinities; - - --------------------------- - -- Has_Private_Component -- - --------------------------- - - function Has_Private_Component (Type_Id : Entity_Id) return Boolean is - Btype : Entity_Id := Base_Type (Type_Id); - Component : Entity_Id; - - begin - if Error_Posted (Type_Id) - or else Error_Posted (Btype) - then - return False; - end if; - - if Is_Class_Wide_Type (Btype) then - Btype := Root_Type (Btype); - end if; - - if Is_Private_Type (Btype) then - declare - UT : constant Entity_Id := Underlying_Type (Btype); - begin - if No (UT) then - - if No (Full_View (Btype)) then - return not Is_Generic_Type (Btype) - and then not Is_Generic_Type (Root_Type (Btype)); - - else - return not Is_Generic_Type (Root_Type (Full_View (Btype))); - end if; - - else - return not Is_Frozen (UT) and then Has_Private_Component (UT); - end if; - end; - elsif Is_Array_Type (Btype) then - return Has_Private_Component (Component_Type (Btype)); - - elsif Is_Record_Type (Btype) then - - Component := First_Component (Btype); - while Present (Component) loop - - if Has_Private_Component (Etype (Component)) then - return True; - end if; - - Next_Component (Component); - end loop; - - return False; - - elsif Is_Protected_Type (Btype) - and then Present (Corresponding_Record_Type (Btype)) - then - return Has_Private_Component (Corresponding_Record_Type (Btype)); - - else - return False; - end if; - end Has_Private_Component; - - -------------------------- - -- Has_Tagged_Component -- - -------------------------- - - function Has_Tagged_Component (Typ : Entity_Id) return Boolean is - Comp : Entity_Id; - - begin - if Is_Private_Type (Typ) - and then Present (Underlying_Type (Typ)) - then - return Has_Tagged_Component (Underlying_Type (Typ)); - - elsif Is_Array_Type (Typ) then - return Has_Tagged_Component (Component_Type (Typ)); - - elsif Is_Tagged_Type (Typ) then - return True; - - elsif Is_Record_Type (Typ) then - Comp := First_Component (Typ); - - while Present (Comp) loop - if Has_Tagged_Component (Etype (Comp)) then - return True; - end if; - - Comp := Next_Component (Typ); - end loop; - - return False; - - else - return False; - end if; - end Has_Tagged_Component; - - ----------------- - -- In_Instance -- - ----------------- - - function In_Instance return Boolean is - S : Entity_Id := Current_Scope; - - begin - while Present (S) - and then S /= Standard_Standard - loop - if (Ekind (S) = E_Function - or else Ekind (S) = E_Package - or else Ekind (S) = E_Procedure) - and then Is_Generic_Instance (S) - then - return True; - end if; - - S := Scope (S); - end loop; - - return False; - end In_Instance; - - ---------------------- - -- In_Instance_Body -- - ---------------------- - - function In_Instance_Body return Boolean is - S : Entity_Id := Current_Scope; - - begin - while Present (S) - and then S /= Standard_Standard - loop - if (Ekind (S) = E_Function - or else Ekind (S) = E_Procedure) - and then Is_Generic_Instance (S) - then - return True; - - elsif Ekind (S) = E_Package - and then In_Package_Body (S) - and then Is_Generic_Instance (S) - then - return True; - end if; - - S := Scope (S); - end loop; - - return False; - end In_Instance_Body; - - ----------------------------- - -- In_Instance_Not_Visible -- - ----------------------------- - - function In_Instance_Not_Visible return Boolean is - S : Entity_Id := Current_Scope; - - begin - while Present (S) - and then S /= Standard_Standard - loop - if (Ekind (S) = E_Function - or else Ekind (S) = E_Procedure) - and then Is_Generic_Instance (S) - then - return True; - - elsif Ekind (S) = E_Package - and then (In_Package_Body (S) or else In_Private_Part (S)) - and then Is_Generic_Instance (S) - then - return True; - end if; - - S := Scope (S); - end loop; - - return False; - end In_Instance_Not_Visible; - - ------------------------------ - -- In_Instance_Visible_Part -- - ------------------------------ - - function In_Instance_Visible_Part return Boolean is - S : Entity_Id := Current_Scope; - - begin - while Present (S) - and then S /= Standard_Standard - loop - if Ekind (S) = E_Package - and then Is_Generic_Instance (S) - and then not In_Package_Body (S) - and then not In_Private_Part (S) - then - return True; - end if; - - S := Scope (S); - end loop; - - return False; - end In_Instance_Visible_Part; - - -------------------------------------- - -- In_Subprogram_Or_Concurrent_Unit -- - -------------------------------------- - - function In_Subprogram_Or_Concurrent_Unit return Boolean is - E : Entity_Id; - K : Entity_Kind; - - begin - -- Use scope chain to check successively outer scopes - - E := Current_Scope; - loop - K := Ekind (E); - - if K in Subprogram_Kind - or else K in Concurrent_Kind - or else K = E_Generic_Procedure - or else K = E_Generic_Function - then - return True; - - elsif E = Standard_Standard then - return False; - end if; - - E := Scope (E); - end loop; - - end In_Subprogram_Or_Concurrent_Unit; - - --------------------- - -- In_Visible_Part -- - --------------------- - - function In_Visible_Part (Scope_Id : Entity_Id) return Boolean is - begin - return - Is_Package (Scope_Id) - and then In_Open_Scopes (Scope_Id) - and then not In_Package_Body (Scope_Id) - and then not In_Private_Part (Scope_Id); - end In_Visible_Part; - - ------------------- - -- Is_AAMP_Float -- - ------------------- - - function Is_AAMP_Float (E : Entity_Id) return Boolean is - begin - pragma Assert (Is_Type (E)); - - return AAMP_On_Target - and then Is_Floating_Point_Type (E) - and then E = Base_Type (E); - end Is_AAMP_Float; - - ------------------------- - -- Is_Actual_Parameter -- - ------------------------- - - function Is_Actual_Parameter (N : Node_Id) return Boolean is - PK : constant Node_Kind := Nkind (Parent (N)); - - begin - case PK is - when N_Parameter_Association => - return N = Explicit_Actual_Parameter (Parent (N)); - - when N_Function_Call | N_Procedure_Call_Statement => - return Is_List_Member (N) - and then - List_Containing (N) = Parameter_Associations (Parent (N)); - - when others => - return False; - end case; - end Is_Actual_Parameter; - - --------------------- - -- Is_Aliased_View -- - --------------------- - - function Is_Aliased_View (Obj : Node_Id) return Boolean is - E : Entity_Id; - - begin - if Is_Entity_Name (Obj) then - - -- Shouldn't we check that we really have an object here? - -- If we do, then a-caldel.adb blows up mysteriously ??? - - E := Entity (Obj); - - return Is_Aliased (E) - or else (Present (Renamed_Object (E)) - and then Is_Aliased_View (Renamed_Object (E))) - - or else ((Is_Formal (E) - or else Ekind (E) = E_Generic_In_Out_Parameter - or else Ekind (E) = E_Generic_In_Parameter) - and then Is_Tagged_Type (Etype (E))) - - or else ((Ekind (E) = E_Task_Type or else - Ekind (E) = E_Protected_Type) - and then In_Open_Scopes (E)) - - -- Current instance of type - - or else (Is_Type (E) and then E = Current_Scope) - or else (Is_Incomplete_Or_Private_Type (E) - and then Full_View (E) = Current_Scope); - - elsif Nkind (Obj) = N_Selected_Component then - return Is_Aliased (Entity (Selector_Name (Obj))); - - elsif Nkind (Obj) = N_Indexed_Component then - return Has_Aliased_Components (Etype (Prefix (Obj))) - or else - (Is_Access_Type (Etype (Prefix (Obj))) - and then - Has_Aliased_Components - (Designated_Type (Etype (Prefix (Obj))))); - - elsif Nkind (Obj) = N_Unchecked_Type_Conversion - or else Nkind (Obj) = N_Type_Conversion - then - return Is_Tagged_Type (Etype (Obj)) - or else Is_Aliased_View (Expression (Obj)); - - elsif Nkind (Obj) = N_Explicit_Dereference then - return Nkind (Original_Node (Obj)) /= N_Function_Call; - - else - return False; - end if; - end Is_Aliased_View; - - ---------------------- - -- Is_Atomic_Object -- - ---------------------- - - function Is_Atomic_Object (N : Node_Id) return Boolean is - - function Object_Has_Atomic_Components (N : Node_Id) return Boolean; - -- Determines if given object has atomic components - - function Is_Atomic_Prefix (N : Node_Id) return Boolean; - -- If prefix is an implicit dereference, examine designated type. - - function Is_Atomic_Prefix (N : Node_Id) return Boolean is - begin - if Is_Access_Type (Etype (N)) then - return - Has_Atomic_Components (Designated_Type (Etype (N))); - else - return Object_Has_Atomic_Components (N); - end if; - end Is_Atomic_Prefix; - - function Object_Has_Atomic_Components (N : Node_Id) return Boolean is - begin - if Has_Atomic_Components (Etype (N)) - or else Is_Atomic (Etype (N)) - then - return True; - - elsif Is_Entity_Name (N) - and then (Has_Atomic_Components (Entity (N)) - or else Is_Atomic (Entity (N))) - then - return True; - - elsif Nkind (N) = N_Indexed_Component - or else Nkind (N) = N_Selected_Component - then - return Is_Atomic_Prefix (Prefix (N)); - - else - return False; - end if; - end Object_Has_Atomic_Components; - - -- Start of processing for Is_Atomic_Object - - begin - if Is_Atomic (Etype (N)) - or else (Is_Entity_Name (N) and then Is_Atomic (Entity (N))) - then - return True; - - elsif Nkind (N) = N_Indexed_Component - or else Nkind (N) = N_Selected_Component - then - return Is_Atomic_Prefix (Prefix (N)); - - else - return False; - end if; - end Is_Atomic_Object; - - ---------------------------------------------- - -- Is_Dependent_Component_Of_Mutable_Object -- - ---------------------------------------------- - - function Is_Dependent_Component_Of_Mutable_Object - (Object : Node_Id) - return Boolean - is - P : Node_Id; - Prefix_Type : Entity_Id; - P_Aliased : Boolean := False; - Comp : Entity_Id; - - function Has_Dependent_Constraint (Comp : Entity_Id) return Boolean; - -- Returns True if and only if Comp has a constrained subtype - -- that depends on a discriminant. - - function Is_Declared_Within_Variant (Comp : Entity_Id) return Boolean; - -- Returns True if and only if Comp is declared within a variant part. - - ------------------------------ - -- Has_Dependent_Constraint -- - ------------------------------ - - function Has_Dependent_Constraint (Comp : Entity_Id) return Boolean is - Comp_Decl : constant Node_Id := Parent (Comp); - Subt_Indic : constant Node_Id := Subtype_Indication (Comp_Decl); - Constr : Node_Id; - Assn : Node_Id; - - begin - if Nkind (Subt_Indic) = N_Subtype_Indication then - Constr := Constraint (Subt_Indic); - - if Nkind (Constr) = N_Index_Or_Discriminant_Constraint then - Assn := First (Constraints (Constr)); - while Present (Assn) loop - case Nkind (Assn) is - when N_Subtype_Indication | - N_Range | - N_Identifier - => - if Depends_On_Discriminant (Assn) then - return True; - end if; - - when N_Discriminant_Association => - if Depends_On_Discriminant (Expression (Assn)) then - return True; - end if; - - when others => - null; - - end case; - - Next (Assn); - end loop; - end if; - end if; - - return False; - end Has_Dependent_Constraint; - - -------------------------------- - -- Is_Declared_Within_Variant -- - -------------------------------- - - function Is_Declared_Within_Variant (Comp : Entity_Id) return Boolean is - Comp_Decl : constant Node_Id := Parent (Comp); - Comp_List : constant Node_Id := Parent (Comp_Decl); - - begin - return Nkind (Parent (Comp_List)) = N_Variant; - end Is_Declared_Within_Variant; - - -- Start of processing for Is_Dependent_Component_Of_Mutable_Object - - begin - if Is_Variable (Object) then - - if Nkind (Object) = N_Selected_Component then - P := Prefix (Object); - Prefix_Type := Etype (P); - - if Is_Entity_Name (P) then - - if Ekind (Entity (P)) = E_Generic_In_Out_Parameter then - Prefix_Type := Base_Type (Prefix_Type); - end if; - - if Is_Aliased (Entity (P)) then - P_Aliased := True; - end if; - - else - -- Check for prefix being an aliased component ??? - null; - end if; - - if Is_Access_Type (Prefix_Type) - or else Nkind (P) = N_Explicit_Dereference - then - return False; - end if; - - Comp := - Original_Record_Component (Entity (Selector_Name (Object))); - - if not Is_Constrained (Prefix_Type) - and then not Is_Indefinite_Subtype (Prefix_Type) - and then (Is_Declared_Within_Variant (Comp) - or else Has_Dependent_Constraint (Comp)) - and then not P_Aliased - then - return True; - - else - return - Is_Dependent_Component_Of_Mutable_Object (Prefix (Object)); - - end if; - - elsif Nkind (Object) = N_Indexed_Component - or else Nkind (Object) = N_Slice - then - return Is_Dependent_Component_Of_Mutable_Object (Prefix (Object)); - end if; - end if; - - return False; - end Is_Dependent_Component_Of_Mutable_Object; - - -------------- - -- Is_False -- - -------------- - - function Is_False (U : Uint) return Boolean is - begin - return (U = 0); - end Is_False; - - --------------------------- - -- Is_Fixed_Model_Number -- - --------------------------- - - function Is_Fixed_Model_Number (U : Ureal; T : Entity_Id) return Boolean is - S : constant Ureal := Small_Value (T); - M : Urealp.Save_Mark; - R : Boolean; - - begin - M := Urealp.Mark; - R := (U = UR_Trunc (U / S) * S); - Urealp.Release (M); - return R; - end Is_Fixed_Model_Number; - - ------------------------------- - -- Is_Fully_Initialized_Type -- - ------------------------------- - - function Is_Fully_Initialized_Type (Typ : Entity_Id) return Boolean is - begin - if Is_Scalar_Type (Typ) then - return False; - - elsif Is_Access_Type (Typ) then - return True; - - elsif Is_Array_Type (Typ) then - if Is_Fully_Initialized_Type (Component_Type (Typ)) then - return True; - end if; - - -- An interesting case, if we have a constrained type one of whose - -- bounds is known to be null, then there are no elements to be - -- initialized, so all the elements are initialized! - - if Is_Constrained (Typ) then - declare - Indx : Node_Id; - Indx_Typ : Entity_Id; - Lbd, Hbd : Node_Id; - - begin - Indx := First_Index (Typ); - while Present (Indx) loop - - if Etype (Indx) = Any_Type then - return False; - - -- If index is a range, use directly. - - elsif Nkind (Indx) = N_Range then - Lbd := Low_Bound (Indx); - Hbd := High_Bound (Indx); - - else - Indx_Typ := Etype (Indx); - - if Is_Private_Type (Indx_Typ) then - Indx_Typ := Full_View (Indx_Typ); - end if; - - if No (Indx_Typ) then - return False; - else - Lbd := Type_Low_Bound (Indx_Typ); - Hbd := Type_High_Bound (Indx_Typ); - end if; - end if; - - if Compile_Time_Known_Value (Lbd) - and then Compile_Time_Known_Value (Hbd) - then - if Expr_Value (Hbd) < Expr_Value (Lbd) then - return True; - end if; - end if; - - Next_Index (Indx); - end loop; - end; - end if; - - return False; - - elsif Is_Record_Type (Typ) then - declare - Ent : Entity_Id; - - begin - Ent := First_Entity (Typ); - - while Present (Ent) loop - if Ekind (Ent) = E_Component - and then (No (Parent (Ent)) - or else No (Expression (Parent (Ent)))) - and then not Is_Fully_Initialized_Type (Etype (Ent)) - then - return False; - end if; - - Next_Entity (Ent); - end loop; - end; - - return True; - - elsif Is_Concurrent_Type (Typ) then - return True; - - elsif Is_Private_Type (Typ) then - declare - U : constant Entity_Id := Underlying_Type (Typ); - - begin - if No (U) then - return False; - else - return Is_Fully_Initialized_Type (U); - end if; - end; - - else - return False; - end if; - end Is_Fully_Initialized_Type; - - ---------------------------- - -- Is_Inherited_Operation -- - ---------------------------- - - function Is_Inherited_Operation (E : Entity_Id) return Boolean is - Kind : constant Node_Kind := Nkind (Parent (E)); - - begin - pragma Assert (Is_Overloadable (E)); - return Kind = N_Full_Type_Declaration - or else Kind = N_Private_Extension_Declaration - or else Kind = N_Subtype_Declaration - or else (Ekind (E) = E_Enumeration_Literal - and then Is_Derived_Type (Etype (E))); - end Is_Inherited_Operation; - - ----------------------------- - -- Is_Library_Level_Entity -- - ----------------------------- - - function Is_Library_Level_Entity (E : Entity_Id) return Boolean is - begin - return Enclosing_Dynamic_Scope (E) = Standard_Standard; - end Is_Library_Level_Entity; - - --------------------------------- - -- Is_Local_Variable_Reference -- - --------------------------------- - - function Is_Local_Variable_Reference (Expr : Node_Id) return Boolean is - begin - if not Is_Entity_Name (Expr) then - return False; - - else - declare - Ent : constant Entity_Id := Entity (Expr); - Sub : constant Entity_Id := Enclosing_Subprogram (Ent); - - begin - if Ekind (Ent) /= E_Variable - and then - Ekind (Ent) /= E_In_Out_Parameter - then - return False; - - else - return Present (Sub) and then Sub = Current_Subprogram; - end if; - end; - end if; - end Is_Local_Variable_Reference; - - ------------------------- - -- Is_Object_Reference -- - ------------------------- - - function Is_Object_Reference (N : Node_Id) return Boolean is - begin - if Is_Entity_Name (N) then - return Is_Object (Entity (N)); - - else - case Nkind (N) is - when N_Indexed_Component | N_Slice => - return Is_Object_Reference (Prefix (N)); - - -- In Ada95, a function call is a constant object. - - when N_Function_Call => - return True; - - when N_Selected_Component => - return Is_Object_Reference (Selector_Name (N)); - - when N_Explicit_Dereference => - return True; - - -- An unchecked type conversion is considered to be an object if - -- the operand is an object (this construction arises only as a - -- result of expansion activities). - - when N_Unchecked_Type_Conversion => - return True; - - when others => - return False; - end case; - end if; - end Is_Object_Reference; - - ----------------------------------- - -- Is_OK_Variable_For_Out_Formal -- - ----------------------------------- - - function Is_OK_Variable_For_Out_Formal (AV : Node_Id) return Boolean is - begin - Note_Possible_Modification (AV); - - -- We must reject parenthesized variable names. The check for - -- Comes_From_Source is present because there are currently - -- cases where the compiler violates this rule (e.g. passing - -- a task object to its controlled Initialize routine). - - if Paren_Count (AV) > 0 and then Comes_From_Source (AV) then - return False; - - -- A variable is always allowed - - elsif Is_Variable (AV) then - return True; - - -- Unchecked conversions are allowed only if they come from the - -- generated code, which sometimes uses unchecked conversions for - -- out parameters in cases where code generation is unaffected. - -- We tell source unchecked conversions by seeing if they are - -- rewrites of an original UC function call, or of an explicit - -- conversion of a function call. - - elsif Nkind (AV) = N_Unchecked_Type_Conversion then - if Nkind (Original_Node (AV)) = N_Function_Call then - return False; - - elsif Comes_From_Source (AV) - and then Nkind (Original_Node (Expression (AV))) = N_Function_Call - then - return False; - - else - return True; - end if; - - -- Normal type conversions are allowed if argument is a variable - - elsif Nkind (AV) = N_Type_Conversion then - if Is_Variable (Expression (AV)) - and then Paren_Count (Expression (AV)) = 0 - then - Note_Possible_Modification (Expression (AV)); - return True; - - -- We also allow a non-parenthesized expression that raises - -- constraint error if it rewrites what used to be a variable - - elsif Raises_Constraint_Error (Expression (AV)) - and then Paren_Count (Expression (AV)) = 0 - and then Is_Variable (Original_Node (Expression (AV))) - then - return True; - - -- Type conversion of something other than a variable - - else - return False; - end if; - - -- If this node is rewritten, then test the original form, if that is - -- OK, then we consider the rewritten node OK (for example, if the - -- original node is a conversion, then Is_Variable will not be true - -- but we still want to allow the conversion if it converts a variable. - - elsif Original_Node (AV) /= AV then - return Is_OK_Variable_For_Out_Formal (Original_Node (AV)); - - -- All other non-variables are rejected - - else - return False; - end if; - end Is_OK_Variable_For_Out_Formal; - - ----------------------------- - -- Is_RCI_Pkg_Spec_Or_Body -- - ----------------------------- - - function Is_RCI_Pkg_Spec_Or_Body (Cunit : Node_Id) return Boolean is - - function Is_RCI_Pkg_Decl_Cunit (Cunit : Node_Id) return Boolean; - -- Return True if the unit of Cunit is an RCI package declaration - - --------------------------- - -- Is_RCI_Pkg_Decl_Cunit -- - --------------------------- - - function Is_RCI_Pkg_Decl_Cunit (Cunit : Node_Id) return Boolean is - The_Unit : constant Node_Id := Unit (Cunit); - - begin - if Nkind (The_Unit) /= N_Package_Declaration then - return False; - end if; - return Is_Remote_Call_Interface (Defining_Entity (The_Unit)); - end Is_RCI_Pkg_Decl_Cunit; - - -- Start of processing for Is_RCI_Pkg_Spec_Or_Body - - begin - return Is_RCI_Pkg_Decl_Cunit (Cunit) - or else - (Nkind (Unit (Cunit)) = N_Package_Body - and then Is_RCI_Pkg_Decl_Cunit (Library_Unit (Cunit))); - end Is_RCI_Pkg_Spec_Or_Body; - - ----------------------------------------- - -- Is_Remote_Access_To_Class_Wide_Type -- - ----------------------------------------- - - function Is_Remote_Access_To_Class_Wide_Type - (E : Entity_Id) - return Boolean - is - D : Entity_Id; - - function Comes_From_Limited_Private_Type_Declaration - (E : Entity_Id) - return Boolean; - -- Check if the original declaration is a limited private one and - -- if all the derivations have been using private extensions. - - ------------------------------------------------- - -- Comes_From_Limited_Private_Type_Declaration -- - ------------------------------------------------- - - function Comes_From_Limited_Private_Type_Declaration (E : in Entity_Id) - return Boolean - is - N : constant Node_Id := Declaration_Node (E); - begin - if Nkind (N) = N_Private_Type_Declaration - and then Limited_Present (N) - then - return True; - end if; - - if Nkind (N) = N_Private_Extension_Declaration then - return Comes_From_Limited_Private_Type_Declaration (Etype (E)); - end if; - - return False; - end Comes_From_Limited_Private_Type_Declaration; - - -- Start of processing for Is_Remote_Access_To_Class_Wide_Type - - begin - if not (Is_Remote_Call_Interface (E) - or else Is_Remote_Types (E)) - or else Ekind (E) /= E_General_Access_Type - then - return False; - end if; - - D := Designated_Type (E); - - if Ekind (D) /= E_Class_Wide_Type then - return False; - end if; - - return Comes_From_Limited_Private_Type_Declaration - (Defining_Identifier (Parent (D))); - end Is_Remote_Access_To_Class_Wide_Type; - - ----------------------------------------- - -- Is_Remote_Access_To_Subprogram_Type -- - ----------------------------------------- - - function Is_Remote_Access_To_Subprogram_Type - (E : Entity_Id) - return Boolean - is - begin - return (Ekind (E) = E_Access_Subprogram_Type - or else (Ekind (E) = E_Record_Type - and then Present (Corresponding_Remote_Type (E)))) - and then (Is_Remote_Call_Interface (E) - or else Is_Remote_Types (E)); - end Is_Remote_Access_To_Subprogram_Type; - - -------------------- - -- Is_Remote_Call -- - -------------------- - - function Is_Remote_Call (N : Node_Id) return Boolean is - begin - if Nkind (N) /= N_Procedure_Call_Statement - and then Nkind (N) /= N_Function_Call - then - -- An entry call cannot be remote - - return False; - - elsif Nkind (Name (N)) in N_Has_Entity - and then Is_Remote_Call_Interface (Entity (Name (N))) - then - -- A subprogram declared in the spec of a RCI package is remote - - return True; - - elsif Nkind (Name (N)) = N_Explicit_Dereference - and then Is_Remote_Access_To_Subprogram_Type - (Etype (Prefix (Name (N)))) - then - -- The dereference of a RAS is a remote call - - return True; - - elsif Present (Controlling_Argument (N)) - and then Is_Remote_Access_To_Class_Wide_Type - (Etype (Controlling_Argument (N))) - then - -- Any primitive operation call with a controlling argument of - -- a RACW type is a remote call. - - return True; - end if; - - -- All other calls are local calls - - return False; - end Is_Remote_Call; - - ---------------------- - -- Is_Selector_Name -- - ---------------------- - - function Is_Selector_Name (N : Node_Id) return Boolean is - - begin - if not Is_List_Member (N) then - declare - P : constant Node_Id := Parent (N); - K : constant Node_Kind := Nkind (P); - - begin - return - (K = N_Expanded_Name or else - K = N_Generic_Association or else - K = N_Parameter_Association or else - K = N_Selected_Component) - and then Selector_Name (P) = N; - end; - - else - declare - L : constant List_Id := List_Containing (N); - P : constant Node_Id := Parent (L); - - begin - return (Nkind (P) = N_Discriminant_Association - and then Selector_Names (P) = L) - or else - (Nkind (P) = N_Component_Association - and then Choices (P) = L); - end; - end if; - end Is_Selector_Name; - - ------------------ - -- Is_Statement -- - ------------------ - - function Is_Statement (N : Node_Id) return Boolean is - begin - return - Nkind (N) in N_Statement_Other_Than_Procedure_Call - or else Nkind (N) = N_Procedure_Call_Statement; - end Is_Statement; - - ----------------- - -- Is_Transfer -- - ----------------- - - function Is_Transfer (N : Node_Id) return Boolean is - Kind : constant Node_Kind := Nkind (N); - - begin - if Kind = N_Return_Statement - or else - Kind = N_Goto_Statement - or else - Kind = N_Raise_Statement - or else - Kind = N_Requeue_Statement - then - return True; - - elsif (Kind = N_Exit_Statement or else Kind in N_Raise_xxx_Error) - and then No (Condition (N)) - then - return True; - - elsif Kind = N_Procedure_Call_Statement - and then Is_Entity_Name (Name (N)) - and then Present (Entity (Name (N))) - and then No_Return (Entity (Name (N))) - then - return True; - - elsif Nkind (Original_Node (N)) = N_Raise_Statement then - return True; - - else - return False; - end if; - end Is_Transfer; - - ------------- - -- Is_True -- - ------------- - - function Is_True (U : Uint) return Boolean is - begin - return (U /= 0); - end Is_True; - - ----------------- - -- Is_Variable -- - ----------------- - - function Is_Variable (N : Node_Id) return Boolean is - - Orig_Node : constant Node_Id := Original_Node (N); - -- We do the test on the original node, since this is basically a - -- test of syntactic categories, so it must not be disturbed by - -- whatever rewriting might have occurred. For example, an aggregate, - -- which is certainly NOT a variable, could be turned into a variable - -- by expansion. - - function In_Protected_Function (E : Entity_Id) return Boolean; - -- Within a protected function, the private components of the - -- enclosing protected type are constants. A function nested within - -- a (protected) procedure is not itself protected. - - function Is_Variable_Prefix (P : Node_Id) return Boolean; - -- Prefixes can involve implicit dereferences, in which case we - -- must test for the case of a reference of a constant access - -- type, which can never be a variable. - - function In_Protected_Function (E : Entity_Id) return Boolean is - Prot : constant Entity_Id := Scope (E); - S : Entity_Id; - - begin - if not Is_Protected_Type (Prot) then - return False; - else - S := Current_Scope; - - while Present (S) and then S /= Prot loop - - if Ekind (S) = E_Function - and then Scope (S) = Prot - then - return True; - end if; - - S := Scope (S); - end loop; - - return False; - end if; - end In_Protected_Function; - - function Is_Variable_Prefix (P : Node_Id) return Boolean is - begin - if Is_Access_Type (Etype (P)) then - return not Is_Access_Constant (Root_Type (Etype (P))); - else - return Is_Variable (P); - end if; - end Is_Variable_Prefix; - - -- Start of processing for Is_Variable - - begin - -- Definitely OK if Assignment_OK is set. Since this is something that - -- only gets set for expanded nodes, the test is on N, not Orig_Node. - - if Nkind (N) in N_Subexpr and then Assignment_OK (N) then - return True; - - -- Normally we go to the original node, but there is one exception - -- where we use the rewritten node, namely when it is an explicit - -- dereference. The generated code may rewrite a prefix which is an - -- access type with an explicit dereference. The dereference is a - -- variable, even though the original node may not be (since it could - -- be a constant of the access type). - - elsif Nkind (N) = N_Explicit_Dereference - and then Nkind (Orig_Node) /= N_Explicit_Dereference - and then Is_Access_Type (Etype (Orig_Node)) - then - return Is_Variable_Prefix (Original_Node (Prefix (N))); - - -- All remaining checks use the original node - - elsif Is_Entity_Name (Orig_Node) then - declare - E : constant Entity_Id := Entity (Orig_Node); - K : constant Entity_Kind := Ekind (E); - - begin - return (K = E_Variable - and then Nkind (Parent (E)) /= N_Exception_Handler) - or else (K = E_Component - and then not In_Protected_Function (E)) - or else K = E_Out_Parameter - or else K = E_In_Out_Parameter - or else K = E_Generic_In_Out_Parameter - - -- Current instance of type: - - or else (Is_Type (E) and then In_Open_Scopes (E)) - or else (Is_Incomplete_Or_Private_Type (E) - and then In_Open_Scopes (Full_View (E))); - end; - - else - case Nkind (Orig_Node) is - when N_Indexed_Component | N_Slice => - return Is_Variable_Prefix (Prefix (Orig_Node)); - - when N_Selected_Component => - return Is_Variable_Prefix (Prefix (Orig_Node)) - and then Is_Variable (Selector_Name (Orig_Node)); - - -- For an explicit dereference, we must check whether the type - -- is ACCESS CONSTANT, since if it is, then it is not a variable. - - when N_Explicit_Dereference => - return Is_Access_Type (Etype (Prefix (Orig_Node))) - and then not - Is_Access_Constant (Root_Type (Etype (Prefix (Orig_Node)))); - - -- The type conversion is the case where we do not deal with the - -- context dependent special case of an actual parameter. Thus - -- the type conversion is only considered a variable for the - -- purposes of this routine if the target type is tagged. However, - -- a type conversion is considered to be a variable if it does not - -- come from source (this deals for example with the conversions - -- of expressions to their actual subtypes). - - when N_Type_Conversion => - return Is_Variable (Expression (Orig_Node)) - and then - (not Comes_From_Source (Orig_Node) - or else - (Is_Tagged_Type (Etype (Subtype_Mark (Orig_Node))) - and then - Is_Tagged_Type (Etype (Expression (Orig_Node))))); - - -- GNAT allows an unchecked type conversion as a variable. This - -- only affects the generation of internal expanded code, since - -- calls to instantiations of Unchecked_Conversion are never - -- considered variables (since they are function calls). - -- This is also true for expression actions. - - when N_Unchecked_Type_Conversion => - return Is_Variable (Expression (Orig_Node)); - - when others => - return False; - end case; - end if; - end Is_Variable; - - ------------------------ - -- Is_Volatile_Object -- - ------------------------ - - function Is_Volatile_Object (N : Node_Id) return Boolean is - - function Object_Has_Volatile_Components (N : Node_Id) return Boolean; - -- Determines if given object has volatile components - - function Is_Volatile_Prefix (N : Node_Id) return Boolean; - -- If prefix is an implicit dereference, examine designated type. - - function Is_Volatile_Prefix (N : Node_Id) return Boolean is - begin - if Is_Access_Type (Etype (N)) then - return Has_Volatile_Components (Designated_Type (Etype (N))); - else - return Object_Has_Volatile_Components (N); - end if; - end Is_Volatile_Prefix; - - function Object_Has_Volatile_Components (N : Node_Id) return Boolean is - begin - if Is_Volatile (Etype (N)) - or else Has_Volatile_Components (Etype (N)) - then - return True; - - elsif Is_Entity_Name (N) - and then (Has_Volatile_Components (Entity (N)) - or else Is_Volatile (Entity (N))) - then - return True; - - elsif Nkind (N) = N_Indexed_Component - or else Nkind (N) = N_Selected_Component - then - return Is_Volatile_Prefix (Prefix (N)); - - else - return False; - end if; - end Object_Has_Volatile_Components; - - -- Start of processing for Is_Volatile_Object - - begin - if Is_Volatile (Etype (N)) - or else (Is_Entity_Name (N) and then Is_Volatile (Entity (N))) - then - return True; - - elsif Nkind (N) = N_Indexed_Component - or else Nkind (N) = N_Selected_Component - then - return Is_Volatile_Prefix (Prefix (N)); - - else - return False; - end if; - end Is_Volatile_Object; - - -------------------------- - -- Kill_Size_Check_Code -- - -------------------------- - - procedure Kill_Size_Check_Code (E : Entity_Id) is - begin - if (Ekind (E) = E_Constant or else Ekind (E) = E_Variable) - and then Present (Size_Check_Code (E)) - then - Remove (Size_Check_Code (E)); - Set_Size_Check_Code (E, Empty); - end if; - end Kill_Size_Check_Code; - - ------------------------- - -- New_External_Entity -- - ------------------------- - - function New_External_Entity - (Kind : Entity_Kind; - Scope_Id : Entity_Id; - Sloc_Value : Source_Ptr; - Related_Id : Entity_Id; - Suffix : Character; - Suffix_Index : Nat := 0; - Prefix : Character := ' ') - return Entity_Id - is - N : constant Entity_Id := - Make_Defining_Identifier (Sloc_Value, - New_External_Name - (Chars (Related_Id), Suffix, Suffix_Index, Prefix)); - - begin - Set_Ekind (N, Kind); - Set_Is_Internal (N, True); - Append_Entity (N, Scope_Id); - Set_Public_Status (N); - - if Kind in Type_Kind then - Init_Size_Align (N); - end if; - - return N; - end New_External_Entity; - - ------------------------- - -- New_Internal_Entity -- - ------------------------- - - function New_Internal_Entity - (Kind : Entity_Kind; - Scope_Id : Entity_Id; - Sloc_Value : Source_Ptr; - Id_Char : Character) - return Entity_Id - is - N : constant Entity_Id := - Make_Defining_Identifier (Sloc_Value, New_Internal_Name (Id_Char)); - - begin - Set_Ekind (N, Kind); - Set_Is_Internal (N, True); - Append_Entity (N, Scope_Id); - - if Kind in Type_Kind then - Init_Size_Align (N); - end if; - - return N; - end New_Internal_Entity; - - ----------------- - -- Next_Actual -- - ----------------- - - function Next_Actual (Actual_Id : Node_Id) return Node_Id is - N : Node_Id; - - begin - -- If we are pointing at a positional parameter, it is a member of - -- a node list (the list of parameters), and the next parameter - -- is the next node on the list, unless we hit a parameter - -- association, in which case we shift to using the chain whose - -- head is the First_Named_Actual in the parent, and then is - -- threaded using the Next_Named_Actual of the Parameter_Association. - -- All this fiddling is because the original node list is in the - -- textual call order, and what we need is the declaration order. - - if Is_List_Member (Actual_Id) then - N := Next (Actual_Id); - - if Nkind (N) = N_Parameter_Association then - return First_Named_Actual (Parent (Actual_Id)); - else - return N; - end if; - - else - return Next_Named_Actual (Parent (Actual_Id)); - end if; - end Next_Actual; - - procedure Next_Actual (Actual_Id : in out Node_Id) is - begin - Actual_Id := Next_Actual (Actual_Id); - end Next_Actual; - - ----------------------- - -- Normalize_Actuals -- - ----------------------- - - -- Chain actuals according to formals of subprogram. If there are - -- no named associations, the chain is simply the list of Parameter - -- Associations, since the order is the same as the declaration order. - -- If there are named associations, then the First_Named_Actual field - -- in the N_Procedure_Call_Statement node or N_Function_Call node - -- points to the Parameter_Association node for the parameter that - -- comes first in declaration order. The remaining named parameters - -- are then chained in declaration order using Next_Named_Actual. - - -- This routine also verifies that the number of actuals is compatible - -- with the number and default values of formals, but performs no type - -- checking (type checking is done by the caller). - - -- If the matching succeeds, Success is set to True, and the caller - -- proceeds with type-checking. If the match is unsuccessful, then - -- Success is set to False, and the caller attempts a different - -- interpretation, if there is one. - - -- If the flag Report is on, the call is not overloaded, and a failure - -- to match can be reported here, rather than in the caller. - - procedure Normalize_Actuals - (N : Node_Id; - S : Entity_Id; - Report : Boolean; - Success : out Boolean) - is - Actuals : constant List_Id := Parameter_Associations (N); - Actual : Node_Id := Empty; - Formal : Entity_Id; - Last : Node_Id := Empty; - First_Named : Node_Id := Empty; - Found : Boolean; - - Formals_To_Match : Integer := 0; - Actuals_To_Match : Integer := 0; - - procedure Chain (A : Node_Id); - -- Add named actual at the proper place in the list, using the - -- Next_Named_Actual link. - - function Reporting return Boolean; - -- Determines if an error is to be reported. To report an error, we - -- need Report to be True, and also we do not report errors caused - -- by calls to Init_Proc's that occur within other Init_Proc's. Such - -- errors must always be cascaded errors, since if all the types are - -- declared correctly, the compiler will certainly build decent calls! - - procedure Chain (A : Node_Id) is - begin - if No (Last) then - - -- Call node points to first actual in list. - - Set_First_Named_Actual (N, Explicit_Actual_Parameter (A)); - - else - Set_Next_Named_Actual (Last, Explicit_Actual_Parameter (A)); - end if; - - Last := A; - Set_Next_Named_Actual (Last, Empty); - end Chain; - - function Reporting return Boolean is - begin - if not Report then - return False; - - elsif not Within_Init_Proc then - return True; - - elsif Chars (Entity (Name (N))) = Name_uInit_Proc then - return False; - - else - return True; - end if; - end Reporting; - - -- Start of processing for Normalize_Actuals - - begin - if Is_Access_Type (S) then - - -- The name in the call is a function call that returns an access - -- to subprogram. The designated type has the list of formals. - - Formal := First_Formal (Designated_Type (S)); - else - Formal := First_Formal (S); - end if; - - while Present (Formal) loop - Formals_To_Match := Formals_To_Match + 1; - Next_Formal (Formal); - end loop; - - -- Find if there is a named association, and verify that no positional - -- associations appear after named ones. - - if Present (Actuals) then - Actual := First (Actuals); - end if; - - while Present (Actual) - and then Nkind (Actual) /= N_Parameter_Association - loop - Actuals_To_Match := Actuals_To_Match + 1; - Next (Actual); - end loop; - - if No (Actual) and Actuals_To_Match = Formals_To_Match then - - -- Most common case: positional notation, no defaults - - Success := True; - return; - - elsif Actuals_To_Match > Formals_To_Match then - - -- Too many actuals: will not work. - - if Reporting then - Error_Msg_N ("too many arguments in call", N); - end if; - - Success := False; - return; - end if; - - First_Named := Actual; - - while Present (Actual) loop - if Nkind (Actual) /= N_Parameter_Association then - Error_Msg_N - ("positional parameters not allowed after named ones", Actual); - Success := False; - return; - - else - Actuals_To_Match := Actuals_To_Match + 1; - end if; - - Next (Actual); - end loop; - - if Present (Actuals) then - Actual := First (Actuals); - end if; - - Formal := First_Formal (S); - - while Present (Formal) loop - - -- Match the formals in order. If the corresponding actual - -- is positional, nothing to do. Else scan the list of named - -- actuals to find the one with the right name. - - if Present (Actual) - and then Nkind (Actual) /= N_Parameter_Association - then - Next (Actual); - Actuals_To_Match := Actuals_To_Match - 1; - Formals_To_Match := Formals_To_Match - 1; - - else - -- For named parameters, search the list of actuals to find - -- one that matches the next formal name. - - Actual := First_Named; - Found := False; - - while Present (Actual) loop - if Chars (Selector_Name (Actual)) = Chars (Formal) then - Found := True; - Chain (Actual); - Actuals_To_Match := Actuals_To_Match - 1; - Formals_To_Match := Formals_To_Match - 1; - exit; - end if; - - Next (Actual); - end loop; - - if not Found then - if Ekind (Formal) /= E_In_Parameter - or else No (Default_Value (Formal)) - then - if Reporting then - if Comes_From_Source (S) - and then Is_Overloadable (S) - then - Error_Msg_Name_1 := Chars (S); - Error_Msg_Sloc := Sloc (S); - Error_Msg_NE - ("missing argument for parameter & " & - "in call to % declared #", N, Formal); - else - Error_Msg_NE - ("missing argument for parameter &", N, Formal); - end if; - end if; - - Success := False; - return; - - else - Formals_To_Match := Formals_To_Match - 1; - end if; - end if; - end if; - - Next_Formal (Formal); - end loop; - - if Formals_To_Match = 0 and then Actuals_To_Match = 0 then - Success := True; - return; - - else - if Reporting then - - -- Find some superfluous named actual that did not get - -- attached to the list of associations. - - Actual := First (Actuals); - - while Present (Actual) loop - - if Nkind (Actual) = N_Parameter_Association - and then Actual /= Last - and then No (Next_Named_Actual (Actual)) - then - Error_Msg_N ("Unmatched actual in call", Actual); - exit; - end if; - - Next (Actual); - end loop; - end if; - - Success := False; - return; - end if; - end Normalize_Actuals; - - -------------------------------- - -- Note_Possible_Modification -- - -------------------------------- - - procedure Note_Possible_Modification (N : Node_Id) is - Ent : Entity_Id; - Exp : Node_Id; - - procedure Set_Ref (E : Entity_Id; N : Node_Id); - -- Internal routine to note modification on entity E by node N - - procedure Set_Ref (E : Entity_Id; N : Node_Id) is - begin - Set_Not_Source_Assigned (E, False); - Set_Is_True_Constant (E, False); - Generate_Reference (E, N, 'm'); - end Set_Ref; - - -- Start of processing for Note_Possible_Modification - - begin - -- Loop to find referenced entity, if there is one - - Exp := N; - loop - -- Test for node rewritten as dereference (e.g. accept parameter) - - if Nkind (Exp) = N_Explicit_Dereference - and then Is_Entity_Name (Original_Node (Exp)) - then - Set_Ref (Entity (Original_Node (Exp)), Original_Node (Exp)); - return; - - elsif Is_Entity_Name (Exp) then - Ent := Entity (Exp); - - if (Ekind (Ent) = E_Variable or else Ekind (Ent) = E_Constant) - and then Present (Renamed_Object (Ent)) - then - Exp := Renamed_Object (Ent); - - else - Set_Ref (Ent, Exp); - return; - end if; - - elsif Nkind (Exp) = N_Type_Conversion - or else Nkind (Exp) = N_Unchecked_Type_Conversion - then - Exp := Expression (Exp); - - elsif Nkind (Exp) = N_Slice - or else Nkind (Exp) = N_Indexed_Component - or else Nkind (Exp) = N_Selected_Component - then - Exp := Prefix (Exp); - - else - return; - end if; - end loop; - end Note_Possible_Modification; - - ------------------------- - -- Object_Access_Level -- - ------------------------- - - function Object_Access_Level (Obj : Node_Id) return Uint is - E : Entity_Id; - - -- Returns the static accessibility level of the view denoted - -- by Obj. Note that the value returned is the result of a - -- call to Scope_Depth. Only scope depths associated with - -- dynamic scopes can actually be returned. Since only - -- relative levels matter for accessibility checking, the fact - -- that the distance between successive levels of accessibility - -- is not always one is immaterial (invariant: if level(E2) is - -- deeper than level(E1), then Scope_Depth(E1) < Scope_Depth(E2)). - - begin - if Is_Entity_Name (Obj) then - E := Entity (Obj); - - -- If E is a type then it denotes a current instance. - -- For this case we add one to the normal accessibility - -- level of the type to ensure that current instances - -- are treated as always being deeper than than the level - -- of any visible named access type (see 3.10.2(21)). - - if Is_Type (E) then - return Type_Access_Level (E) + 1; - - elsif Present (Renamed_Object (E)) then - return Object_Access_Level (Renamed_Object (E)); - - -- Similarly, if E is a component of the current instance of a - -- protected type, any instance of it is assumed to be at a deeper - -- level than the type. For a protected object (whose type is an - -- anonymous protected type) its components are at the same level - -- as the type itself. - - elsif not Is_Overloadable (E) - and then Ekind (Scope (E)) = E_Protected_Type - and then Comes_From_Source (Scope (E)) - then - return Type_Access_Level (Scope (E)) + 1; - - else - return Scope_Depth (Enclosing_Dynamic_Scope (E)); - end if; - - elsif Nkind (Obj) = N_Selected_Component then - if Is_Access_Type (Etype (Prefix (Obj))) then - return Type_Access_Level (Etype (Prefix (Obj))); - else - return Object_Access_Level (Prefix (Obj)); - end if; - - elsif Nkind (Obj) = N_Indexed_Component then - if Is_Access_Type (Etype (Prefix (Obj))) then - return Type_Access_Level (Etype (Prefix (Obj))); - else - return Object_Access_Level (Prefix (Obj)); - end if; - - elsif Nkind (Obj) = N_Explicit_Dereference then - - -- If the prefix is a selected access discriminant then - -- we make a recursive call on the prefix, which will - -- in turn check the level of the prefix object of - -- the selected discriminant. - - if Nkind (Prefix (Obj)) = N_Selected_Component - and then Ekind (Etype (Prefix (Obj))) = E_Anonymous_Access_Type - and then - Ekind (Entity (Selector_Name (Prefix (Obj)))) = E_Discriminant - then - return Object_Access_Level (Prefix (Obj)); - else - return Type_Access_Level (Etype (Prefix (Obj))); - end if; - - elsif Nkind (Obj) = N_Type_Conversion then - return Object_Access_Level (Expression (Obj)); - - -- Function results are objects, so we get either the access level - -- of the function or, in the case of an indirect call, the level of - -- of the access-to-subprogram type. - - elsif Nkind (Obj) = N_Function_Call then - if Is_Entity_Name (Name (Obj)) then - return Subprogram_Access_Level (Entity (Name (Obj))); - else - return Type_Access_Level (Etype (Prefix (Name (Obj)))); - end if; - - -- For convenience we handle qualified expressions, even though - -- they aren't technically object names. - - elsif Nkind (Obj) = N_Qualified_Expression then - return Object_Access_Level (Expression (Obj)); - - -- Otherwise return the scope level of Standard. - -- (If there are cases that fall through - -- to this point they will be treated as - -- having global accessibility for now. ???) - - else - return Scope_Depth (Standard_Standard); - end if; - end Object_Access_Level; - - ----------------------- - -- Private_Component -- - ----------------------- - - function Private_Component (Type_Id : Entity_Id) return Entity_Id is - Ancestor : constant Entity_Id := Base_Type (Type_Id); - - function Trace_Components - (T : Entity_Id; - Check : Boolean) - return Entity_Id; - -- Recursive function that does the work, and checks against circular - -- definition for each subcomponent type. - - ---------------------- - -- Trace_Components -- - ---------------------- - - function Trace_Components - (T : Entity_Id; - Check : Boolean) return Entity_Id - is - Btype : constant Entity_Id := Base_Type (T); - Component : Entity_Id; - P : Entity_Id; - Candidate : Entity_Id := Empty; - - begin - if Check and then Btype = Ancestor then - Error_Msg_N ("circular type definition", Type_Id); - return Any_Type; - end if; - - if Is_Private_Type (Btype) - and then not Is_Generic_Type (Btype) - then - return Btype; - - elsif Is_Array_Type (Btype) then - return Trace_Components (Component_Type (Btype), True); - - elsif Is_Record_Type (Btype) then - Component := First_Entity (Btype); - while Present (Component) loop - - -- skip anonymous types generated by constrained components. - - if not Is_Type (Component) then - P := Trace_Components (Etype (Component), True); - - if Present (P) then - if P = Any_Type then - return P; - else - Candidate := P; - end if; - end if; - end if; - - Next_Entity (Component); - end loop; - - return Candidate; - - else - return Empty; - end if; - end Trace_Components; - - -- Start of processing for Private_Component - - begin - return Trace_Components (Type_Id, False); - end Private_Component; - - ----------------------- - -- Process_End_Label -- - ----------------------- - - procedure Process_End_Label (N : Node_Id; Typ : Character) is - Loc : Source_Ptr; - Nam : Node_Id; - Ctyp : Entity_Id; - - Label_Ref : Boolean; - -- Set True if reference to end label itself is required - - Endl : Node_Id; - -- Gets set to the operator symbol or identifier that references - -- the entity Ent. For the child unit case, this is the identifier - -- from the designator. For other cases, this is simply Endl. - - Ent : Entity_Id; - -- This is the entity for the construct to which the End_Label applies - - procedure Generate_Parent_Ref (N : Node_Id); - -- N is an identifier node that appears as a parent unit reference - -- in the case where Ent is a child unit. This procedure generates - -- an appropriate cross-reference entry. - - procedure Generate_Parent_Ref (N : Node_Id) is - Parent_Ent : Entity_Id; - - begin - -- Search up scope stack. The reason we do this is that normal - -- visibility analysis would not work for two reasons. First in - -- some subunit cases, the entry for the parent unit may not be - -- visible, and in any case there can be a local entity that - -- hides the scope entity. - - Parent_Ent := Current_Scope; - while Present (Parent_Ent) loop - if Chars (Parent_Ent) = Chars (N) then - - -- Generate the reference. We do NOT consider this as a - -- reference for unreferenced symbol purposes, but we do - -- force a cross-reference even if the end line does not - -- come from source (the caller already generated the - -- appropriate Typ for this situation). - - Generate_Reference - (Parent_Ent, N, 'r', Set_Ref => False, Force => True); - Style.Check_Identifier (N, Parent_Ent); - return; - end if; - - Parent_Ent := Scope (Parent_Ent); - end loop; - - -- Fall through means entity was not found -- that's odd, but - -- the appropriate thing is simply to ignore and not generate - -- any cross-reference for this entry. - - return; - end Generate_Parent_Ref; - - -- Start of processing for Process_End_Label - - begin - -- If no node, ignore. This happens in some error situations, - -- and also for some internally generated structures where no - -- end label references are required in any case. - - if No (N) then - return; - end if; - - -- Nothing to do if no End_Label, happens for internally generated - -- constructs where we don't want an end label reference anyway. - -- Also nothing to do if Endl is a string literal, which means - -- there was some prior error (bad operator symbol) - - Endl := End_Label (N); - - if No (Endl) or else Nkind (Endl) = N_String_Literal then - return; - end if; - - -- Reference node is not in extended main source unit - - if not In_Extended_Main_Source_Unit (N) then - - -- Generally we do not collect references except for the - -- extended main source unit. The one exception is the 'e' - -- entry for a package spec, where it is useful for a client - -- to have the ending information to define scopes. - - if Typ /= 'e' then - return; - - else - Label_Ref := False; - - -- For this case, we can ignore any parent references, - -- but we need the package name itself for the 'e' entry. - - if Nkind (Endl) = N_Designator then - Endl := Identifier (Endl); - end if; - end if; - - -- Reference is in extended main source unit - - else - Label_Ref := True; - - -- For designator, generate references for the parent entries - - if Nkind (Endl) = N_Designator then - - -- Generate references for the prefix if the END line comes - -- from source (otherwise we do not need these references) - - if Comes_From_Source (Endl) then - Nam := Name (Endl); - while Nkind (Nam) = N_Selected_Component loop - Generate_Parent_Ref (Selector_Name (Nam)); - Nam := Prefix (Nam); - end loop; - - Generate_Parent_Ref (Nam); - end if; - - Endl := Identifier (Endl); - end if; - end if; - - -- Locate the entity to which the end label applies. Most of the - -- time this is simply the current scope containing the construct. - - Ent := Current_Scope; - - if Chars (Ent) = Chars (Endl) then - null; - - -- But in the case of single tasks and single protected objects, - -- the current scope is the anonymous task or protected type and - -- what we want is the object. There is no direct link so what we - -- do is search ahead in the entity chain for the object with the - -- matching type and name. In practice it is almost certain to be - -- the very next entity on the chain, so this is not inefficient. - - else - Ctyp := Etype (Ent); - loop - Next_Entity (Ent); - - -- If we don't find the entry we are looking for, that's - -- odd, perhaps results from some error condition? Anyway - -- the appropriate thing is just to abandon the attempt. - - if No (Ent) then - return; - - -- Exit if we find the entity we are looking for - - elsif Etype (Ent) = Ctyp - and then Chars (Ent) = Chars (Endl) - then - exit; - end if; - end loop; - end if; - - -- If label was really there, then generate a normal reference - -- and then adjust the location in the end label to point past - -- the name (which should almost always be the semicolon). - - Loc := Sloc (Endl); - - if Comes_From_Source (Endl) then - - -- If a label reference is required, then do the style check - -- and generate a normal cross-reference entry for the label - - if Label_Ref then - Style.Check_Identifier (Endl, Ent); - Generate_Reference (Ent, Endl, 'r', Set_Ref => False); - end if; - - -- Set the location to point past the label (normally this will - -- mean the semicolon immediately following the label). This is - -- done for the sake of the 'e' or 't' entry generated below. - - Get_Decoded_Name_String (Chars (Endl)); - Set_Sloc (Endl, Sloc (Endl) + Source_Ptr (Name_Len)); - end if; - - -- Now generate the e/t reference - - Generate_Reference (Ent, Endl, Typ, Set_Ref => False, Force => True); - - -- Restore Sloc, in case modified above, since we have an identifier - -- and the normal Sloc should be left set in the tree. - - Set_Sloc (Endl, Loc); - end Process_End_Label; - - ------------------ - -- Real_Convert -- - ------------------ - - -- We do the conversion to get the value of the real string by using - -- the scanner, see Sinput for details on use of the internal source - -- buffer for scanning internal strings. - - function Real_Convert (S : String) return Node_Id is - Save_Src : constant Source_Buffer_Ptr := Source; - Negative : Boolean; - - begin - Source := Internal_Source_Ptr; - Scan_Ptr := 1; - - for J in S'Range loop - Source (Source_Ptr (J)) := S (J); - end loop; - - Source (S'Length + 1) := EOF; - - if Source (Scan_Ptr) = '-' then - Negative := True; - Scan_Ptr := Scan_Ptr + 1; - else - Negative := False; - end if; - - Scan; - - if Negative then - Set_Realval (Token_Node, UR_Negate (Realval (Token_Node))); - end if; - - Source := Save_Src; - return Token_Node; - end Real_Convert; - - ------------------------------ - -- Requires_Transient_Scope -- - ------------------------------ - - -- A transient scope is required when variable-sized temporaries are - -- allocated in the primary or secondary stack, or when finalization - -- actions must be generated before the next instruction - - function Requires_Transient_Scope (Id : Entity_Id) return Boolean is - Typ : constant Entity_Id := Underlying_Type (Id); - - begin - -- This is a private type which is not completed yet. This can only - -- happen in a default expression (of a formal parameter or of a - -- record component). Do not expand transient scope in this case - - if No (Typ) then - return False; - - elsif Typ = Standard_Void_Type then - return False; - - -- The back-end has trouble allocating variable-size temporaries so - -- we generate them in the front-end and need a transient scope to - -- reclaim them properly - - elsif not Size_Known_At_Compile_Time (Typ) then - return True; - - -- Unconstrained discriminated records always require a variable - -- length temporary, since the length may depend on the variant. - - elsif Is_Record_Type (Typ) - and then Has_Discriminants (Typ) - and then not Is_Constrained (Typ) - then - return True; - - -- Functions returning tagged types may dispatch on result so their - -- returned value is allocated on the secondary stack. Controlled - -- type temporaries need finalization. - - elsif Is_Tagged_Type (Typ) - or else Has_Controlled_Component (Typ) - then - return True; - - -- Unconstrained array types are returned on the secondary stack - - elsif Is_Array_Type (Typ) then - return not Is_Constrained (Typ); - end if; - - return False; - end Requires_Transient_Scope; - - -------------------------- - -- Reset_Analyzed_Flags -- - -------------------------- - - procedure Reset_Analyzed_Flags (N : Node_Id) is - - function Clear_Analyzed - (N : Node_Id) - return Traverse_Result; - -- Function used to reset Analyzed flags in tree. Note that we do - -- not reset Analyzed flags in entities, since there is no need to - -- renalalyze entities, and indeed, it is wrong to do so, since it - -- can result in generating auxiliary stuff more than once. - - function Clear_Analyzed - (N : Node_Id) - return Traverse_Result - is - begin - if not Has_Extension (N) then - Set_Analyzed (N, False); - end if; - - return OK; - end Clear_Analyzed; - - function Reset_Analyzed is - new Traverse_Func (Clear_Analyzed); - - Discard : Traverse_Result; - - -- Start of processing for Reset_Analyzed_Flags - - begin - Discard := Reset_Analyzed (N); - end Reset_Analyzed_Flags; - - --------------- - -- Same_Name -- - --------------- - - function Same_Name (N1, N2 : Node_Id) return Boolean is - K1 : constant Node_Kind := Nkind (N1); - K2 : constant Node_Kind := Nkind (N2); - - begin - if (K1 = N_Identifier or else K1 = N_Defining_Identifier) - and then (K2 = N_Identifier or else K2 = N_Defining_Identifier) - then - return Chars (N1) = Chars (N2); - - elsif (K1 = N_Selected_Component or else K1 = N_Expanded_Name) - and then (K2 = N_Selected_Component or else K2 = N_Expanded_Name) - then - return Same_Name (Selector_Name (N1), Selector_Name (N2)) - and then Same_Name (Prefix (N1), Prefix (N2)); - - else - return False; - end if; - end Same_Name; - - --------------- - -- Same_Type -- - --------------- - - function Same_Type (T1, T2 : Entity_Id) return Boolean is - begin - if T1 = T2 then - return True; - - elsif not Is_Constrained (T1) - and then not Is_Constrained (T2) - and then Base_Type (T1) = Base_Type (T2) - then - return True; - - -- For now don't bother with case of identical constraints, to be - -- fiddled with later on perhaps (this is only used for optimization - -- purposes, so it is not critical to do a best possible job) - - else - return False; - end if; - end Same_Type; - - ------------------------ - -- Scope_Is_Transient -- - ------------------------ - - function Scope_Is_Transient return Boolean is - begin - return Scope_Stack.Table (Scope_Stack.Last).Is_Transient; - end Scope_Is_Transient; - - ------------------ - -- Scope_Within -- - ------------------ - - function Scope_Within (Scope1, Scope2 : Entity_Id) return Boolean is - Scop : Entity_Id; - - begin - Scop := Scope1; - while Scop /= Standard_Standard loop - Scop := Scope (Scop); - - if Scop = Scope2 then - return True; - end if; - end loop; - - return False; - end Scope_Within; - - -------------------------- - -- Scope_Within_Or_Same -- - -------------------------- - - function Scope_Within_Or_Same (Scope1, Scope2 : Entity_Id) return Boolean is - Scop : Entity_Id; - - begin - Scop := Scope1; - while Scop /= Standard_Standard loop - if Scop = Scope2 then - return True; - else - Scop := Scope (Scop); - end if; - end loop; - - return False; - end Scope_Within_Or_Same; - - ------------------------ - -- Set_Current_Entity -- - ------------------------ - - -- The given entity is to be set as the currently visible definition - -- of its associated name (i.e. the Node_Id associated with its name). - -- All we have to do is to get the name from the identifier, and - -- then set the associated Node_Id to point to the given entity. - - procedure Set_Current_Entity (E : Entity_Id) is - begin - Set_Name_Entity_Id (Chars (E), E); - end Set_Current_Entity; - - --------------------------------- - -- Set_Entity_With_Style_Check -- - --------------------------------- - - procedure Set_Entity_With_Style_Check (N : Node_Id; Val : Entity_Id) is - Val_Actual : Entity_Id; - Nod : Node_Id; - - begin - Set_Entity (N, Val); - - if Style_Check - and then not Suppress_Style_Checks (Val) - and then not In_Instance - then - if Nkind (N) = N_Identifier then - Nod := N; - - elsif Nkind (N) = N_Expanded_Name then - Nod := Selector_Name (N); - - else - return; - end if; - - Val_Actual := Val; - - -- A special situation arises for derived operations, where we want - -- to do the check against the parent (since the Sloc of the derived - -- operation points to the derived type declaration itself). - - while not Comes_From_Source (Val_Actual) - and then Nkind (Val_Actual) in N_Entity - and then (Ekind (Val_Actual) = E_Enumeration_Literal - or else Ekind (Val_Actual) = E_Function - or else Ekind (Val_Actual) = E_Generic_Function - or else Ekind (Val_Actual) = E_Procedure - or else Ekind (Val_Actual) = E_Generic_Procedure) - and then Present (Alias (Val_Actual)) - loop - Val_Actual := Alias (Val_Actual); - end loop; - - -- Renaming declarations for generic actuals do not come from source, - -- and have a different name from that of the entity they rename, so - -- there is no style check to perform here. - - if Chars (Nod) = Chars (Val_Actual) then - Style.Check_Identifier (Nod, Val_Actual); - end if; - - end if; - - Set_Entity (N, Val); - end Set_Entity_With_Style_Check; - - ------------------------ - -- Set_Name_Entity_Id -- - ------------------------ - - procedure Set_Name_Entity_Id (Id : Name_Id; Val : Entity_Id) is - begin - Set_Name_Table_Info (Id, Int (Val)); - end Set_Name_Entity_Id; - - --------------------- - -- Set_Next_Actual -- - --------------------- - - procedure Set_Next_Actual (Ass1_Id : Node_Id; Ass2_Id : Node_Id) is - begin - if Nkind (Parent (Ass1_Id)) = N_Parameter_Association then - Set_First_Named_Actual (Parent (Ass1_Id), Ass2_Id); - end if; - end Set_Next_Actual; - - ----------------------- - -- Set_Public_Status -- - ----------------------- - - procedure Set_Public_Status (Id : Entity_Id) is - S : constant Entity_Id := Current_Scope; - - begin - if S = Standard_Standard - or else (Is_Public (S) - and then (Ekind (S) = E_Package - or else Is_Record_Type (S) - or else Ekind (S) = E_Void)) - then - Set_Is_Public (Id); - - -- The bounds of an entry family declaration can generate object - -- declarations that are visible to the back-end, e.g. in the - -- the declaration of a composite type that contains tasks. - - elsif Is_Public (S) - and then Is_Concurrent_Type (S) - and then not Has_Completion (S) - and then Nkind (Parent (Id)) = N_Object_Declaration - then - Set_Is_Public (Id); - end if; - end Set_Public_Status; - - ---------------------------- - -- Set_Scope_Is_Transient -- - ---------------------------- - - procedure Set_Scope_Is_Transient (V : Boolean := True) is - begin - Scope_Stack.Table (Scope_Stack.Last).Is_Transient := V; - end Set_Scope_Is_Transient; - - ------------------- - -- Set_Size_Info -- - ------------------- - - procedure Set_Size_Info (T1, T2 : Entity_Id) is - begin - -- We copy Esize, but not RM_Size, since in general RM_Size is - -- subtype specific and does not get inherited by all subtypes. - - Set_Esize (T1, Esize (T2)); - Set_Has_Biased_Representation (T1, Has_Biased_Representation (T2)); - - if Is_Discrete_Or_Fixed_Point_Type (T1) - and then - Is_Discrete_Or_Fixed_Point_Type (T2) - then - Set_Is_Unsigned_Type (T1, Is_Unsigned_Type (T2)); - end if; - - Set_Alignment (T1, Alignment (T2)); - end Set_Size_Info; - - -------------------- - -- Static_Integer -- - -------------------- - - function Static_Integer (N : Node_Id) return Uint is - begin - Analyze_And_Resolve (N, Any_Integer); - - if N = Error - or else Error_Posted (N) - or else Etype (N) = Any_Type - then - return No_Uint; - end if; - - if Is_Static_Expression (N) then - if not Raises_Constraint_Error (N) then - return Expr_Value (N); - else - return No_Uint; - end if; - - elsif Etype (N) = Any_Type then - return No_Uint; - - else - Error_Msg_N ("static integer expression required here", N); - return No_Uint; - end if; - end Static_Integer; - - -------------------------- - -- Statically_Different -- - -------------------------- - - function Statically_Different (E1, E2 : Node_Id) return Boolean is - R1 : constant Node_Id := Get_Referenced_Object (E1); - R2 : constant Node_Id := Get_Referenced_Object (E2); - - begin - return Is_Entity_Name (R1) - and then Is_Entity_Name (R2) - and then Entity (R1) /= Entity (R2) - and then not Is_Formal (Entity (R1)) - and then not Is_Formal (Entity (R2)); - end Statically_Different; - - ----------------------------- - -- Subprogram_Access_Level -- - ----------------------------- - - function Subprogram_Access_Level (Subp : Entity_Id) return Uint is - begin - if Present (Alias (Subp)) then - return Subprogram_Access_Level (Alias (Subp)); - else - return Scope_Depth (Enclosing_Dynamic_Scope (Subp)); - end if; - end Subprogram_Access_Level; - - ----------------- - -- Trace_Scope -- - ----------------- - - procedure Trace_Scope (N : Node_Id; E : Entity_Id; Msg : String) is - begin - if Debug_Flag_W then - for J in 0 .. Scope_Stack.Last loop - Write_Str (" "); - end loop; - - Write_Str (Msg); - Write_Name (Chars (E)); - Write_Str (" line "); - Write_Int (Int (Get_Logical_Line_Number (Sloc (N)))); - Write_Eol; - end if; - end Trace_Scope; - - ----------------------- - -- Transfer_Entities -- - ----------------------- - - procedure Transfer_Entities (From : Entity_Id; To : Entity_Id) is - Ent : Entity_Id := First_Entity (From); - - begin - if No (Ent) then - return; - end if; - - if (Last_Entity (To)) = Empty then - Set_First_Entity (To, Ent); - else - Set_Next_Entity (Last_Entity (To), Ent); - end if; - - Set_Last_Entity (To, Last_Entity (From)); - - while Present (Ent) loop - Set_Scope (Ent, To); - - if not Is_Public (Ent) then - Set_Public_Status (Ent); - - if Is_Public (Ent) - and then Ekind (Ent) = E_Record_Subtype - - then - -- The components of the propagated Itype must be public - -- as well. - - declare - Comp : Entity_Id; - - begin - Comp := First_Entity (Ent); - - while Present (Comp) loop - Set_Is_Public (Comp); - Next_Entity (Comp); - end loop; - end; - end if; - end if; - - Next_Entity (Ent); - end loop; - - Set_First_Entity (From, Empty); - Set_Last_Entity (From, Empty); - end Transfer_Entities; - - ----------------------- - -- Type_Access_Level -- - ----------------------- - - function Type_Access_Level (Typ : Entity_Id) return Uint is - Btyp : Entity_Id := Base_Type (Typ); - - begin - -- If the type is an anonymous access type we treat it as being - -- declared at the library level to ensure that names such as - -- X.all'access don't fail static accessibility checks. - - if Ekind (Btyp) in Access_Kind then - if Ekind (Btyp) = E_Anonymous_Access_Type then - return Scope_Depth (Standard_Standard); - end if; - - Btyp := Root_Type (Btyp); - end if; - - return Scope_Depth (Enclosing_Dynamic_Scope (Btyp)); - end Type_Access_Level; - - -------------------------- - -- Unit_Declaration_Node -- - -------------------------- - - function Unit_Declaration_Node (Unit_Id : Entity_Id) return Node_Id is - N : Node_Id := Parent (Unit_Id); - - begin - -- Predefined operators do not have a full function declaration. - - if Ekind (Unit_Id) = E_Operator then - return N; - end if; - - while Nkind (N) /= N_Abstract_Subprogram_Declaration - and then Nkind (N) /= N_Formal_Package_Declaration - and then Nkind (N) /= N_Formal_Subprogram_Declaration - and then Nkind (N) /= N_Function_Instantiation - and then Nkind (N) /= N_Generic_Package_Declaration - and then Nkind (N) /= N_Generic_Subprogram_Declaration - and then Nkind (N) /= N_Package_Declaration - and then Nkind (N) /= N_Package_Body - and then Nkind (N) /= N_Package_Instantiation - and then Nkind (N) /= N_Package_Renaming_Declaration - and then Nkind (N) /= N_Procedure_Instantiation - and then Nkind (N) /= N_Subprogram_Declaration - and then Nkind (N) /= N_Subprogram_Body - and then Nkind (N) /= N_Subprogram_Body_Stub - and then Nkind (N) /= N_Subprogram_Renaming_Declaration - and then Nkind (N) /= N_Task_Body - and then Nkind (N) /= N_Task_Type_Declaration - and then Nkind (N) not in N_Generic_Renaming_Declaration - loop - N := Parent (N); - pragma Assert (Present (N)); - end loop; - - return N; - end Unit_Declaration_Node; - - ---------------------- - -- Within_Init_Proc -- - ---------------------- - - function Within_Init_Proc return Boolean is - S : Entity_Id; - - begin - S := Current_Scope; - while not Is_Overloadable (S) loop - if S = Standard_Standard then - return False; - else - S := Scope (S); - end if; - end loop; - - return Chars (S) = Name_uInit_Proc; - end Within_Init_Proc; - - ---------------- - -- Wrong_Type -- - ---------------- - - procedure Wrong_Type (Expr : Node_Id; Expected_Type : Entity_Id) is - Found_Type : constant Entity_Id := First_Subtype (Etype (Expr)); - Expec_Type : constant Entity_Id := First_Subtype (Expected_Type); - - function Has_One_Matching_Field return Boolean; - -- Determines whether Expec_Type is a record type with a single - -- component or discriminant whose type matches the found type or - -- is a one dimensional array whose component type matches the - -- found type. - - function Has_One_Matching_Field return Boolean is - E : Entity_Id; - - begin - if Is_Array_Type (Expec_Type) - and then Number_Dimensions (Expec_Type) = 1 - and then - Covers (Etype (Component_Type (Expec_Type)), Found_Type) - then - return True; - - elsif not Is_Record_Type (Expec_Type) then - return False; - - else - E := First_Entity (Expec_Type); - - loop - if No (E) then - return False; - - elsif (Ekind (E) /= E_Discriminant - and then Ekind (E) /= E_Component) - or else (Chars (E) = Name_uTag - or else Chars (E) = Name_uParent) - then - Next_Entity (E); - - else - exit; - end if; - end loop; - - if not Covers (Etype (E), Found_Type) then - return False; - - elsif Present (Next_Entity (E)) then - return False; - - else - return True; - end if; - end if; - end Has_One_Matching_Field; - - -- Start of processing for Wrong_Type - - begin - -- Don't output message if either type is Any_Type, or if a message - -- has already been posted for this node. We need to do the latter - -- check explicitly (it is ordinarily done in Errout), because we - -- are using ! to force the output of the error messages. - - if Expec_Type = Any_Type - or else Found_Type = Any_Type - or else Error_Posted (Expr) - then - return; - - -- In an instance, there is an ongoing problem with completion of - -- type derived from private types. Their structure is what Gigi - -- expects, but the Etype is the parent type rather than the - -- derived private type itself. Do not flag error in this case. The - -- private completion is an entity without a parent, like an Itype. - -- Similarly, full and partial views may be incorrect in the instance. - -- There is no simple way to insure that it is consistent ??? - - elsif In_Instance then - - if Etype (Etype (Expr)) = Etype (Expected_Type) - and then No (Parent (Expected_Type)) - then - return; - end if; - end if; - - -- An interesting special check. If the expression is parenthesized - -- and its type corresponds to the type of the sole component of the - -- expected record type, or to the component type of the expected one - -- dimensional array type, then assume we have a bad aggregate attempt. - - if Nkind (Expr) in N_Subexpr - and then Paren_Count (Expr) /= 0 - and then Has_One_Matching_Field - then - Error_Msg_N ("positional aggregate cannot have one component", Expr); - - -- Another special check, if we are looking for a pool-specific access - -- type and we found an E_Access_Attribute_Type, then we have the case - -- of an Access attribute being used in a context which needs a pool- - -- specific type, which is never allowed. The one extra check we make - -- is that the expected designated type covers the Found_Type. - - elsif Is_Access_Type (Expec_Type) - and then Ekind (Found_Type) = E_Access_Attribute_Type - and then Ekind (Base_Type (Expec_Type)) /= E_General_Access_Type - and then Ekind (Base_Type (Expec_Type)) /= E_Anonymous_Access_Type - and then Covers - (Designated_Type (Expec_Type), Designated_Type (Found_Type)) - then - Error_Msg_N ("result must be general access type!", Expr); - Error_Msg_NE ("add ALL to }!", Expr, Expec_Type); - - -- If the expected type is an anonymous access type, as for access - -- parameters and discriminants, the error is on the designated types. - - elsif Ekind (Expec_Type) = E_Anonymous_Access_Type then - if Comes_From_Source (Expec_Type) then - Error_Msg_NE ("expected}!", Expr, Expec_Type); - else - Error_Msg_NE - ("expected an access type with designated}", - Expr, Designated_Type (Expec_Type)); - end if; - - if Is_Access_Type (Found_Type) - and then not Comes_From_Source (Found_Type) - then - Error_Msg_NE - ("found an access type with designated}!", - Expr, Designated_Type (Found_Type)); - else - if From_With_Type (Found_Type) then - Error_Msg_NE ("found incomplete}!", Expr, Found_Type); - Error_Msg_NE - ("\possibly missing with_clause on&", Expr, - Scope (Found_Type)); - else - Error_Msg_NE ("found}!", Expr, Found_Type); - end if; - end if; - - -- Normal case of one type found, some other type expected - - else - -- If the names of the two types are the same, see if some - -- number of levels of qualification will help. Don't try - -- more than three levels, and if we get to standard, it's - -- no use (and probably represents an error in the compiler) - -- Also do not bother with internal scope names. - - declare - Expec_Scope : Entity_Id; - Found_Scope : Entity_Id; - - begin - Expec_Scope := Expec_Type; - Found_Scope := Found_Type; - - for Levels in Int range 0 .. 3 loop - if Chars (Expec_Scope) /= Chars (Found_Scope) then - Error_Msg_Qual_Level := Levels; - exit; - end if; - - Expec_Scope := Scope (Expec_Scope); - Found_Scope := Scope (Found_Scope); - - exit when Expec_Scope = Standard_Standard - or else - Found_Scope = Standard_Standard - or else - not Comes_From_Source (Expec_Scope) - or else - not Comes_From_Source (Found_Scope); - end loop; - end; - - Error_Msg_NE ("expected}!", Expr, Expec_Type); - - if Is_Entity_Name (Expr) - and then Is_Package (Entity (Expr)) - then - Error_Msg_N ("found package name!", Expr); - - elsif Is_Entity_Name (Expr) - and then - (Ekind (Entity (Expr)) = E_Procedure - or else - Ekind (Entity (Expr)) = E_Generic_Procedure) - then - Error_Msg_N ("found procedure name instead of function!", Expr); - - -- catch common error: a prefix or infix operator which is not - -- directly visible because the type isn't. - - elsif Nkind (Expr) in N_Op - and then Is_Overloaded (Expr) - and then not Is_Immediately_Visible (Expec_Type) - and then not Is_Potentially_Use_Visible (Expec_Type) - and then not In_Use (Expec_Type) - and then Has_Compatible_Type (Right_Opnd (Expr), Expec_Type) - then - Error_Msg_N ( - "operator of the type is not directly visible!", Expr); - - else - Error_Msg_NE ("found}!", Expr, Found_Type); - end if; - - Error_Msg_Qual_Level := 0; - end if; - end Wrong_Type; - -end Sem_Util;