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