1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 with Types; use Types;
29 -----------------------------------
30 -- Handling extensions of System --
31 -----------------------------------
33 -- For targets that define a much larger System package than given in
34 -- the RM, we use a child package containing additional declarations,
35 -- which is loaded when needed, and whose entities are conceptually
36 -- within System itself. The presence of this auxiliary package is
37 -- controlled with the pragma Extend_System. The following variable
38 -- holds the entity of the auxiliary package, to simplify the special
39 -- visibility rules that apply to it.
41 System_Aux_Id : Entity_Id := Empty;
47 procedure Analyze_Exception_Renaming (N : Node_Id);
48 procedure Analyze_Expanded_Name (N : Node_Id);
49 procedure Analyze_Generic_Function_Renaming (N : Node_Id);
50 procedure Analyze_Generic_Package_Renaming (N : Node_Id);
51 procedure Analyze_Generic_Procedure_Renaming (N : Node_Id);
52 procedure Analyze_Object_Renaming (N : Node_Id);
53 procedure Analyze_Package_Renaming (N : Node_Id);
54 procedure Analyze_Subprogram_Renaming (N : Node_Id);
55 procedure Analyze_Use_Package (N : Node_Id);
56 procedure Analyze_Use_Type (N : Node_Id);
59 -- Called at end of scope. On exit from blocks and bodies (subprogram,
60 -- package, task, and protected bodies), the name of the current scope
61 -- must be removed from the scope stack, and the local entities must be
62 -- removed from their homonym chains. On exit from record declarations,
63 -- from package specifications, and from tasks and protected type
64 -- specifications, more specialized procedures are invoked.
66 procedure End_Use_Clauses (Clause : Node_Id);
67 -- Invoked on scope exit, to undo the effect of local use clauses. Clause
68 -- is the first use-clause of a scope being exited. This can be the current
69 -- scope, or some enclosing scopes when building a clean environment to
70 -- compile an instance body for inlining.
72 procedure End_Use_Package (N : Node_Id);
73 procedure End_Use_Type (N : Node_Id);
74 -- Subsidiaries of End_Use_Clauses. Also called directly for use clauses
75 -- appearing in context clauses.
77 procedure Find_Direct_Name (N : Node_Id);
78 -- Given a direct name (Identifier or Operator_Symbol), this routine scans
79 -- the homonym chain for the name searching for corresponding visible
80 -- entities to find the referenced entity (or in the case of overloading,
81 -- entities). On return, the Entity and Etype fields are set. In the
82 -- non-overloaded case, these are the correct final entries. In the
83 -- overloaded case, Is_Overloaded is set, Etype and Entity refer to an
84 -- arbitrary element of the overloads set, and an appropriate list of
85 -- entries has been made in the overload interpretation table (to be
86 -- disambiguated in the resolve phase).
88 procedure Find_Selected_Component (N : Node_Id);
89 -- Resolve various cases of selected components, recognize expanded names
91 procedure Find_Type (N : Node_Id);
92 -- Perform name resolution, and verify that the name found is that of a
93 -- type. On return the Entity and Etype fields of the node N are set
94 -- appropriately. If it is an incomplete type whose full declaration has
95 -- been seen, they are set to the entity in the full declaration. If it
96 -- is an incomplete type associated with an interface visible through a
97 -- limited-with clause, whose full declaration has been seen, they are
98 -- set to the entity in the full declaration. Similarly, if the type is
99 -- private, it has received a full declaration, and we are in the private
100 -- part or body of the package, then the two fields are set to the entity
101 -- of the full declaration as well. This procedure also has special
102 -- processing for 'Class attribute references.
104 function Has_Loop_In_Inner_Open_Scopes (S : Entity_Id) return Boolean;
105 -- S is the entity of an open scope. This function determines if there is
106 -- an inner scope of S which is a loop (i.e. it appears somewhere in the
107 -- scope stack after S).
109 function In_Open_Scopes (S : Entity_Id) return Boolean;
110 -- S is the entity of a scope. This function determines if this scope is
111 -- currently open (i.e. it appears somewhere in the scope stack).
113 procedure Initialize;
114 -- Initializes data structures used for visibility analysis. Must be
115 -- called before analyzing each new main source program.
117 procedure Install_Use_Clauses
119 Force_Installation : Boolean := False);
120 -- Applies the use clauses appearing in a given declarative part,
121 -- when the corresponding scope has been placed back on the scope
122 -- stack after unstacking to compile a different context (subunit or
123 -- parent of generic body). Force_Installation is used when called from
124 -- Analyze_Subunit.Re_Install_Use_Clauses to insure that, after the
125 -- analysis of the subunit, the parent's environment is again identical.
127 procedure Push_Scope (S : Entity_Id);
128 -- Make new scope stack entry, pushing S, the entity for a scope onto the
129 -- top of the scope table. The current setting of the scope suppress flags
130 -- is saved for restoration on exit.
133 -- Remove top entry from scope stack, restoring the saved setting of the
134 -- scope suppress flags.
136 function Present_System_Aux (N : Node_Id := Empty) return Boolean;
137 -- Return True if the auxiliary system file has been successfully loaded.
138 -- Otherwise attempt to load it, using the name supplied by a previous
139 -- Extend_System pragma, and report on the success of the load. If N is
140 -- present, it is a selected component whose prefix is System, or else a
141 -- with-clause on system. N is absent when the function is called to find
142 -- the visibility of implicit operators.
144 procedure Restore_Scope_Stack (Handle_Use : Boolean := True);
145 procedure Save_Scope_Stack (Handle_Use : Boolean := True);
146 -- These two procedures are called from Semantics, when a unit U1 is to
147 -- be compiled in the course of the compilation of another unit U2. This
148 -- happens whenever Rtsfind is called. U1, the unit retrieved by Rtsfind,
149 -- must be compiled in its own context, and the current scope stack
150 -- containing U2 and local scopes must be made unreachable. On return, the
151 -- contents of the scope stack must be made accessible again. The flag
152 -- Handle_Use indicates whether local use clauses must be removed or
153 -- installed. In the case of inlining of instance bodies, the visibility
154 -- handling is done fully in Inline_Instance_Body, and use clauses are
157 procedure Set_Use (L : List_Id);
158 -- Find use clauses that are declarative items in a package declaration
159 -- and set the potentially use-visible flags of imported entities before
160 -- analyzing the corresponding package body.
163 -- Debugging routine for use in gdb: dump all entities on scope stack