File : sem.ads
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- S E M --
6 -- --
7 -- S p e c --
8 -- --
9 -- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
10 -- --
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. --
20 -- --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
23 -- --
24 ------------------------------------------------------------------------------
25
26 --------------------------------------
27 -- Semantic Analysis: General Model --
28 --------------------------------------
29
30 -- Semantic processing involves 3 phases which are highly intertwined
31 -- (i.e. mutually recursive):
32
33 -- Analysis implements the bulk of semantic analysis such as
34 -- name analysis and type resolution for declarations,
35 -- instructions and expressions. The main routine
36 -- driving this process is procedure Analyze given below.
37 -- This analysis phase is really a bottom up pass that is
38 -- achieved during the recursive traversal performed by the
39 -- Analyze_... procedures implemented in the sem_* packages.
40 -- For expressions this phase determines unambiguous types
41 -- and collects sets of possible types where the
42 -- interpretation is potentially ambiguous.
43
44 -- Resolution is carried out only for expressions to finish type
45 -- resolution that was initiated but not necessarily
46 -- completed during analysis (because of overloading
47 -- ambiguities). Specifically, after completing the bottom
48 -- up pass carried out during analysis for expressions, the
49 -- Resolve routine (see the spec of sem_res for more info)
50 -- is called to perform a top down resolution with
51 -- recursive calls to itself to resolve operands.
52
53 -- Expansion if we are not generating code this phase is a no-op.
54 -- otherwise this phase expands, i.e. transforms, original
55 -- declaration, expressions or instructions into simpler
56 -- structures that can be handled by the back-end. This
57 -- phase is also in charge of generating code which is
58 -- implicit in the original source (for instance for
59 -- default initializations, controlled types, etc.)
60 -- There are two separate instances where expansion is
61 -- invoked. For declarations and instructions, expansion is
62 -- invoked just after analysis since no resolution needs
63 -- to be performed. For expressions, expansion is done just
64 -- after resolution. In both cases expansion is done from the
65 -- bottom up just before the end of Analyze for instructions
66 -- and declarations or the call to Resolve for expressions.
67 -- The main routine driving expansion is Expand.
68 -- See the spec of Expander for more details.
69
70 -- To summarize, in normal code generation mode we recursively traverse the
71 -- abstract syntax tree top-down performing semantic analysis bottom
72 -- up. For instructions and declarations, before the call to the Analyze
73 -- routine completes we perform expansion since at that point we have all
74 -- semantic information needed. For expression nodes, after the call to
75 -- Analysis terminates we invoke the Resolve routine to transmit top-down
76 -- the type that was gathered by Analyze which will resolve possible
77 -- ambiguities in the expression. Just before the call to Resolve
78 -- terminates, the expression can be expanded since all the semantic
79 -- information is available at that point.
80
81 -- If we are not generating code then the expansion phase is a no-op
82
83 -- When generating code there are a number of exceptions to the basic
84 -- Analysis-Resolution-Expansion model for expressions. The most prominent
85 -- examples are the handling of default expressions and aggregates.
86
87 -----------------------------------------------------------------------
88 -- Handling of Default and Per-Object Expressions (Spec-Expressions) --
89 -----------------------------------------------------------------------
90
91 -- The default expressions in component declarations and in procedure
92 -- specifications (but not the ones in object declarations) are quite tricky
93 -- to handle. The problem is that some processing is required at the point
94 -- where the expression appears:
95
96 -- visibility analysis (including user defined operators)
97 -- freezing of static expressions
98
99 -- but other processing must be deferred until the enclosing entity (record or
100 -- procedure specification) is frozen:
101
102 -- freezing of any other types in the expression expansion
103 -- generation of code
104
105 -- A similar situation occurs with the argument of priority and interrupt
106 -- priority pragmas that appear in task and protected definition specs and
107 -- other cases of per-object expressions (see RM 3.8(18)).
108
109 -- Another similar case is the conditions in precondition and postcondition
110 -- pragmas that appear with subprogram specifications rather than in the body.
111
112 -- Collectively we call these Spec_Expressions. The routine that performs the
113 -- special analysis is called Analyze_Spec_Expression.
114
115 -- Expansion has to be deferred since you can't generate code for expressions
116 -- that reference types that have not been frozen yet. As an example, consider
117 -- the following:
118
119 -- type x is delta 0.5 range -10.0 .. +10.0;
120 -- ...
121 -- type q is record
122 -- xx : x := y * z;
123 -- end record;
124
125 -- for x'small use 0.25;
126
127 -- The expander is in charge of dealing with fixed-point, and of course the
128 -- small declaration, which is not too late, since the declaration of type q
129 -- does *not* freeze type x, definitely affects the expanded code.
130
131 -- Another reason that we cannot expand early is that expansion can generate
132 -- range checks. These range checks need to be inserted not at the point of
133 -- definition but at the point of use. The whole point here is that the value
134 -- of the expression cannot be obtained at the point of declaration, only at
135 -- the point of use.
136
137 -- Generally our model is to combine analysis resolution and expansion, but
138 -- this is the one case where this model falls down. Here is how we patch
139 -- it up without causing too much distortion to our basic model.
140
141 -- A switch (In_Spec_Expression) is set to show that we are in the initial
142 -- occurrence of a default expression. The analyzer is then called on this
143 -- expression with the switch set true. Analysis and resolution proceed almost
144 -- as usual, except that Freeze_Expression will not freeze non-static
145 -- expressions if this switch is set, and the call to Expand at the end of
146 -- resolution is skipped. This also skips the code that normally sets the
147 -- Analyzed flag to True. The result is that when we are done the tree is
148 -- still marked as unanalyzed, but all types for static expressions are frozen
149 -- as required, and all entities of variables have been recorded. We then turn
150 -- off the switch, and later on reanalyze the expression with the switch off.
151 -- The effect is that this second analysis freezes the rest of the types as
152 -- required, and generates code but visibility analysis is not repeated since
153 -- all the entities are marked.
154
155 -- The second analysis (the one that generates code) is in the context
156 -- where the code is required. For a record field default, this is in the
157 -- initialization procedure for the record and for a subprogram default
158 -- parameter, it is at the point the subprogram is frozen. For a priority or
159 -- storage size pragma it is in the context of the Init_Proc for the task or
160 -- protected object. For a pre/postcondition pragma it is in the body when
161 -- code for the pragma is generated.
162
163 ------------------
164 -- Pre-Analysis --
165 ------------------
166
167 -- For certain kind of expressions, such as aggregates, we need to defer
168 -- expansion of the aggregate and its inner expressions after the whole
169 -- set of expressions appearing inside the aggregate have been analyzed.
170 -- Consider, for instance the following example:
171 --
172 -- (1 .. 100 => new Thing (Function_Call))
173 --
174 -- The normal Analysis-Resolution-Expansion mechanism where expansion of the
175 -- children is performed before expansion of the parent does not work if the
176 -- code generated for the children by the expander needs to be evaluated
177 -- repeatedly (for instance in the above aggregate "new Thing (Function_Call)"
178 -- needs to be called 100 times.)
179
180 -- The reason why this mechanism does not work is that the expanded code for
181 -- the children is typically inserted above the parent and thus when the
182 -- father gets expanded no re-evaluation takes place. For instance in the case
183 -- of aggregates if "new Thing (Function_Call)" is expanded before of the
184 -- aggregate the expanded code will be placed outside of the aggregate and
185 -- when expanding the aggregate the loop from 1 to 100 will not surround the
186 -- expanded code for "new Thing (Function_Call)".
187
188 -- To remedy this situation we introduce a new flag which signals whether we
189 -- want a full analysis (i.e. expansion is enabled) or a pre-analysis which
190 -- performs Analysis and Resolution but no expansion.
191
192 -- After the complete pre-analysis of an expression has been carried out we
193 -- can transform the expression and then carry out the full three stage
194 -- (Analyze-Resolve-Expand) cycle on the transformed expression top-down so
195 -- that the expansion of inner expressions happens inside the newly generated
196 -- node for the parent expression.
197
198 -- Note that the difference between processing of default expressions and
199 -- pre-analysis of other expressions is that we do carry out freezing in
200 -- the latter but not in the former (except for static scalar expressions).
201 -- The routine that performs preanalysis and corresponding resolution is
202 -- called Preanalyze_And_Resolve and is in Sem_Res.
203
204 with Alloc;
205 with Einfo; use Einfo;
206 with Opt; use Opt;
207 with Table;
208 with Types; use Types;
209
210 package Sem is
211
212 -----------------------------
213 -- Semantic Analysis Flags --
214 -----------------------------
215
216 Full_Analysis : Boolean := True;
217 -- Switch to indicate if we are doing a full analysis or a pre-analysis.
218 -- In normal analysis mode (Analysis-Expansion for instructions or
219 -- declarations) or (Analysis-Resolution-Expansion for expressions) this
220 -- flag is set. Note that if we are not generating code the expansion phase
221 -- merely sets the Analyzed flag to True in this case. If we are in
222 -- Pre-Analysis mode (see above) this flag is set to False then the
223 -- expansion phase is skipped.
224 --
225 -- When this flag is False the flag Expander_Active is also False (the
226 -- Expander_Active flag defined in the spec of package Expander tells you
227 -- whether expansion is currently enabled). You should really regard this
228 -- as a read only flag.
229
230 In_Spec_Expression : Boolean := False;
231 -- Switch to indicate that we are in a spec-expression, as described
232 -- above. Note that this must be recursively saved on a Semantics call
233 -- since it is possible for the analysis of an expression to result in a
234 -- recursive call (e.g. to get the entity for System.Address as part of the
235 -- processing of an Address attribute reference). When this switch is True
236 -- then Full_Analysis above must be False. You should really regard this as
237 -- a read only flag.
238
239 In_Deleted_Code : Boolean := False;
240 -- If the condition in an if-statement is statically known, the branch
241 -- that is not taken is analyzed with expansion disabled, and the tree
242 -- is deleted after analysis. Itypes generated in deleted code must be
243 -- frozen from start, because the tree on which they depend will not
244 -- be available at the freeze point.
245
246 In_Assertion_Expr : Nat := 0;
247 -- This is set non-zero if we are within the expression of an assertion
248 -- pragma or aspect. It is a counter which is incremented at the start of
249 -- expanding such an expression, and decremented on completion of expanding
250 -- that expression. Probably a boolean would be good enough, since we think
251 -- that such expressions cannot nest, but that might not be true in the
252 -- future (e.g. if let expressions are added to Ada) so we prepare for that
253 -- future possibility by making it a counter. As with In_Spec_Expression,
254 -- it must be recursively saved and restored for a Semantics call.
255
256 In_Default_Expr : Boolean := False;
257 -- Switch to indicate that we are analyzing a default component expression.
258 -- As with In_Spec_Expression, it must be recursively saved and restored
259 -- for a Semantics call.
260
261 In_Inlined_Body : Boolean := False;
262 -- Switch to indicate that we are analyzing and resolving an inlined body.
263 -- Type checking is disabled in this context, because types are known to be
264 -- compatible. This avoids problems with private types whose full view is
265 -- derived from private types.
266
267 Inside_A_Generic : Boolean := False;
268 -- This flag is set if we are processing a generic specification, generic
269 -- definition, or generic body. When this flag is True the Expander_Active
270 -- flag is False to disable any code expansion (see package Expander). Only
271 -- the generic processing can modify the status of this flag, any other
272 -- client should regard it as read-only.
273 -- Probably should be called Inside_A_Generic_Template ???
274
275 Inside_Freezing_Actions : Nat := 0;
276 -- Flag indicating whether we are within a call to Expand_N_Freeze_Actions.
277 -- Non-zero means we are inside (it is actually a level counter to deal
278 -- with nested calls). Used to avoid traversing the tree each time a
279 -- subprogram call is processed to know if we must not clear all constant
280 -- indications from entities in the current scope. Only the expansion of
281 -- freezing nodes can modify the status of this flag, any other client
282 -- should regard it as read-only.
283
284 Unloaded_Subunits : Boolean := False;
285 -- This flag is set True if we have subunits that are not loaded. This
286 -- occurs when the main unit is a subunit, and contains lower level
287 -- subunits that are not loaded. We use this flag to suppress warnings
288 -- about unused variables, since these warnings are unreliable in this
289 -- case. We could perhaps do a more accurate job and retain some of the
290 -- warnings, but it is quite a tricky job.
291
292 -----------------------------------
293 -- Handling of Check Suppression --
294 -----------------------------------
295
296 -- There are two kinds of suppress checks: scope based suppress checks,
297 -- and entity based suppress checks.
298
299 -- Scope based suppress checks for the predefined checks (from initial
300 -- command line arguments, or from Suppress pragmas not including an entity
301 -- name) are recorded in the Sem.Scope_Suppress variable, and all that
302 -- is necessary is to save the state of this variable on scope entry, and
303 -- restore it on scope exit. This mechanism allows for fast checking of the
304 -- scope suppress state without needing complex data structures.
305
306 -- Entity based checks, from Suppress/Unsuppress pragmas giving an
307 -- Entity_Id and scope based checks for non-predefined checks (introduced
308 -- using pragma Check_Name), are handled as follows. If a suppress or
309 -- unsuppress pragma is encountered for a given entity, then the flag
310 -- Checks_May_Be_Suppressed is set in the entity and an entry is made in
311 -- either the Local_Entity_Suppress stack (case of pragma that appears in
312 -- other than a package spec), or in the Global_Entity_Suppress stack (case
313 -- of pragma that appears in a package spec, which is by the rule of RM
314 -- 11.5(7) applicable throughout the life of the entity). Similarly, a
315 -- Suppress/Unsuppress pragma for a non-predefined check which does not
316 -- specify an entity is also stored in one of these stacks.
317
318 -- If the Checks_May_Be_Suppressed flag is set in an entity then the
319 -- procedure is to search first the local and then the global suppress
320 -- stacks (we search these in reverse order, top element first). The only
321 -- other point is that we have to make sure that we have proper nested
322 -- interaction between such specific pragmas and locally applied general
323 -- pragmas applying to all entities. This is achieved by including in the
324 -- Local_Entity_Suppress table dummy entries with an empty Entity field
325 -- that are applicable to all entities. A similar search is needed for any
326 -- non-predefined check even if no specific entity is involved.
327
328 Scope_Suppress : Suppress_Record;
329 -- This variable contains the current scope based settings of the suppress
330 -- switches. It is initialized from Suppress_Options in Gnat1drv, and then
331 -- modified by pragma Suppress. On entry to each scope, the current setting
332 -- is saved on the scope stack, and then restored on exit from the scope.
333 -- This record may be rapidly checked to determine the current status of
334 -- a check if no specific entity is involved or if the specific entity
335 -- involved is one for which no specific Suppress/Unsuppress pragma has
336 -- been set (as indicated by the Checks_May_Be_Suppressed flag being set).
337
338 -- This scheme is a little complex, but serves the purpose of enabling
339 -- a very rapid check in the common case where no entity specific pragma
340 -- applies, and gives the right result when such pragmas are used even
341 -- in complex cases of nested Suppress and Unsuppress pragmas.
342
343 -- The Local_Entity_Suppress and Global_Entity_Suppress stacks are handled
344 -- using dynamic allocation and linked lists. We do not often use this
345 -- approach in the compiler (preferring to use extensible tables instead).
346 -- The reason we do it here is that scope stack entries save a pointer to
347 -- the current local stack top, which is also saved and restored on scope
348 -- exit. Furthermore for processing of generics we save pointers to the
349 -- top of the stack, so that the local stack is actually a tree of stacks
350 -- rather than a single stack, a structure that is easy to represent using
351 -- linked lists, but impossible to represent using a single table. Note
352 -- that because of the generic issue, we never release entries in these
353 -- stacks, but that's no big deal, since we are unlikely to have a huge
354 -- number of Suppress/Unsuppress entries in a single compilation.
355
356 type Suppress_Stack_Entry;
357 type Suppress_Stack_Entry_Ptr is access all Suppress_Stack_Entry;
358
359 type Suppress_Stack_Entry is record
360 Entity : Entity_Id;
361 -- Entity to which the check applies, or Empty for a check that has
362 -- no entity name (and thus applies to all entities).
363
364 Check : Check_Id;
365 -- Check which is set (can be All_Checks for the All_Checks case)
366
367 Suppress : Boolean;
368 -- Set True for Suppress, and False for Unsuppress
369
370 Prev : Suppress_Stack_Entry_Ptr;
371 -- Pointer to previous entry on stack
372
373 Next : Suppress_Stack_Entry_Ptr;
374 -- All allocated Suppress_Stack_Entry records are chained together in
375 -- a linked list whose head is Suppress_Stack_Entries, and the Next
376 -- field is used as a forward pointer (null ends the list). This is
377 -- used to free all entries in Sem.Init (which will be important if
378 -- we ever setup the compiler to be reused).
379 end record;
380
381 Suppress_Stack_Entries : Suppress_Stack_Entry_Ptr := null;
382 -- Pointer to linked list of records (see comments for Next above)
383
384 Local_Suppress_Stack_Top : Suppress_Stack_Entry_Ptr;
385 -- Pointer to top element of local suppress stack. This is the entry that
386 -- is saved and restored in the scope stack, and also saved for generic
387 -- body expansion.
388
389 Global_Suppress_Stack_Top : Suppress_Stack_Entry_Ptr;
390 -- Pointer to top element of global suppress stack
391
392 procedure Push_Local_Suppress_Stack_Entry
393 (Entity : Entity_Id;
394 Check : Check_Id;
395 Suppress : Boolean);
396 -- Push a new entry on to the top of the local suppress stack, updating
397 -- the value in Local_Suppress_Stack_Top;
398
399 procedure Push_Global_Suppress_Stack_Entry
400 (Entity : Entity_Id;
401 Check : Check_Id;
402 Suppress : Boolean);
403 -- Push a new entry on to the top of the global suppress stack, updating
404 -- the value in Global_Suppress_Stack_Top;
405
406 -----------------
407 -- Scope Stack --
408 -----------------
409
410 -- The scope stack indicates the declarative regions that are currently
411 -- being processed (analyzed and/or expanded). The scope stack is one of
412 -- the basic visibility structures in the compiler: entities that are
413 -- declared in a scope that is currently on the scope stack are immediately
414 -- visible (leaving aside issues of hiding and overloading).
415
416 -- Initially, the scope stack only contains an entry for package Standard.
417 -- When a compilation unit, subprogram unit, block or declarative region
418 -- is being processed, the corresponding entity is pushed on the scope
419 -- stack. It is removed after the processing step is completed. A given
420 -- entity can be placed several times on the scope stack, for example
421 -- when processing derived type declarations, freeze nodes, etc. The top
422 -- of the scope stack is the innermost scope currently being processed.
423 -- It is obtained through function Current_Scope. After a compilation unit
424 -- has been processed, the scope stack must contain only Standard.
425 -- The predicate In_Open_Scopes specifies whether a scope is currently
426 -- on the scope stack.
427
428 -- This model is complicated by the need to compile units on the fly, in
429 -- the middle of the compilation of other units. This arises when compiling
430 -- instantiations, and when compiling run-time packages obtained through
431 -- rtsfind. Given that the scope stack is a single static and global
432 -- structure (not originally designed for the recursive processing required
433 -- by rtsfind for example) additional machinery is needed to indicate what
434 -- is currently being compiled. As a result, the scope stack holds several
435 -- contiguous sections that correspond to the compilation of a given
436 -- compilation unit. These sections are separated by distinct occurrences
437 -- of package Standard. The currently active section of the scope stack
438 -- goes from the current scope to the first (innermost) occurrence of
439 -- Standard, which is additionally marked with flag Is_Active_Stack_Base.
440 -- The basic visibility routine (Find_Direct_Name, in Sem_Ch8) uses this
441 -- contiguous section of the scope stack to determine whether a given
442 -- entity is or is not visible at a point. In_Open_Scopes only examines
443 -- the currently active section of the scope stack.
444
445 -- Similar complications arise when processing child instances. These
446 -- must be compiled in the context of parent instances, and therefore the
447 -- parents must be pushed on the stack before compiling the child, and
448 -- removed afterwards. Routines Save_Scope_Stack and Restore_Scope_Stack
449 -- are used to set/reset the visibility of entities declared in scopes
450 -- that are currently on the scope stack, and are used when compiling
451 -- instance bodies on the fly.
452
453 -- It is clear in retrospect that all semantic processing and visibility
454 -- structures should have been fully recursive. The rtsfind mechanism,
455 -- and the complexities brought about by subunits and by generic child
456 -- units and their instantiations, have led to a hybrid model that carries
457 -- more state than one would wish.
458
459 type Scope_Action_Kind is (Before, After, Cleanup);
460 type Scope_Actions is array (Scope_Action_Kind) of List_Id;
461 -- Transient blocks have three associated actions list, to be inserted
462 -- before and after the block's statements, and as cleanup actions.
463
464 Configuration_Component_Alignment : Component_Alignment_Kind :=
465 Calign_Default;
466 -- Used for handling the pragma Component_Alignment in the context of a
467 -- configuration file.
468
469 type Scope_Stack_Entry is record
470 Entity : Entity_Id;
471 -- Entity representing the scope
472
473 Last_Subprogram_Name : String_Ptr;
474 -- Pointer to name of last subprogram body in this scope. Used for
475 -- testing proper alpha ordering of subprogram bodies in scope.
476
477 Save_Scope_Suppress : Suppress_Record;
478 -- Save contents of Scope_Suppress on entry
479
480 Save_Local_Suppress_Stack_Top : Suppress_Stack_Entry_Ptr;
481 -- Save contents of Local_Suppress_Stack on entry to restore on exit
482
483 Save_Check_Policy_List : Node_Id;
484 -- Save contents of Check_Policy_List on entry to restore on exit. The
485 -- Check_Policy pragmas are chained with Check_Policy_List pointing to
486 -- the most recent entry. This list is searched starting here, so that
487 -- the search finds the most recent appicable entry. When we restore
488 -- Check_Policy_List on exit from the scope, the effect is to remove
489 -- all entries set in the scope being exited.
490
491 Save_Default_Storage_Pool : Node_Id;
492 -- Save contents of Default_Storage_Pool on entry to restore on exit
493
494 Save_SPARK_Mode : SPARK_Mode_Type;
495 -- Setting of SPARK_Mode on entry to restore on exit
496
497 Save_SPARK_Mode_Pragma : Node_Id;
498 -- Setting of SPARK_Mode_Pragma on entry to restore on exit
499
500 Save_No_Tagged_Streams : Node_Id;
501 -- Setting of No_Tagged_Streams to restore on exit
502
503 Save_Default_SSO : Character;
504 -- Setting of Default_SSO on entry to restore on exit
505
506 Save_Uneval_Old : Character;
507 -- Setting of Uneval_Old on entry to restore on exit
508
509 Is_Transient : Boolean;
510 -- Marks transient scopes (see Exp_Ch7 body for details)
511
512 Previous_Visibility : Boolean;
513 -- Used when installing the parent(s) of the current compilation unit.
514 -- The parent may already be visible because of an ongoing compilation,
515 -- and the proper visibility must be restored on exit. The flag is
516 -- typically needed when the context of a child unit requires
517 -- compilation of a sibling. In other cases the flag is set to False.
518 -- See Sem_Ch10 (Install_Parents, Remove_Parents).
519
520 Node_To_Be_Wrapped : Node_Id;
521 -- Only used in transient scopes. Records the node which will
522 -- be wrapped by the transient block.
523
524 Actions_To_Be_Wrapped : Scope_Actions;
525 -- Actions that have to be inserted at the start, at the end, or as
526 -- cleanup actions of a transient block. Used to temporarily hold these
527 -- actions until the block is created, at which time the actions are
528 -- moved to the block.
529
530 Pending_Freeze_Actions : List_Id;
531 -- Used to collect freeze entity nodes and associated actions that are
532 -- generated in an inner context but need to be analyzed outside, such
533 -- as records and initialization procedures. On exit from the scope,
534 -- this list of actions is inserted before the scope construct and
535 -- analyzed to generate the corresponding freeze processing and
536 -- elaboration of other associated actions.
537
538 First_Use_Clause : Node_Id;
539 -- Head of list of Use_Clauses in current scope. The list is built when
540 -- the declarations in the scope are processed. The list is traversed
541 -- on scope exit to undo the effect of the use clauses.
542
543 Component_Alignment_Default : Component_Alignment_Kind;
544 -- Component alignment to be applied to any record or array types that
545 -- are declared for which a specific component alignment pragma does not
546 -- set the alignment.
547
548 Is_Active_Stack_Base : Boolean;
549 -- Set to true only when entering the scope for Standard_Standard from
550 -- from within procedure Semantics. Indicates the base of the current
551 -- active set of scopes. Needed by In_Open_Scopes to handle cases where
552 -- Standard_Standard can be pushed anew on the scope stack to start a
553 -- new active section (see comment above).
554
555 Locked_Shared_Objects : Elist_Id;
556 -- List of shared passive protected objects that have been locked in
557 -- this transient scope (always No_Elist for non-transient scopes).
558 end record;
559
560 package Scope_Stack is new Table.Table (
561 Table_Component_Type => Scope_Stack_Entry,
562 Table_Index_Type => Int,
563 Table_Low_Bound => 0,
564 Table_Initial => Alloc.Scope_Stack_Initial,
565 Table_Increment => Alloc.Scope_Stack_Increment,
566 Table_Name => "Sem.Scope_Stack");
567
568 -----------------
569 -- Subprograms --
570 -----------------
571
572 procedure Initialize;
573 -- Initialize internal tables
574
575 procedure Lock;
576 -- Lock internal tables before calling back end
577
578 procedure Semantics (Comp_Unit : Node_Id);
579 -- This procedure is called to perform semantic analysis on the specified
580 -- node which is the N_Compilation_Unit node for the unit.
581
582 procedure Analyze (N : Node_Id);
583 procedure Analyze (N : Node_Id; Suppress : Check_Id);
584 -- This is the recursive procedure that is applied to individual nodes of
585 -- the tree, starting at the top level node (compilation unit node) and
586 -- then moving down the tree in a top down traversal. It calls individual
587 -- routines with names Analyze_xxx to analyze node xxx. Each of these
588 -- routines is responsible for calling Analyze on the components of the
589 -- subtree.
590 --
591 -- Note: In the case of expression components (nodes whose Nkind is in
592 -- N_Subexpr), the call to Analyze does not complete the semantic analysis
593 -- of the node, since the type resolution cannot be completed until the
594 -- complete context is analyzed. The completion of the type analysis occurs
595 -- in the corresponding Resolve routine (see Sem_Res).
596 --
597 -- Note: for integer and real literals, the analyzer sets the flag to
598 -- indicate that the result is a static expression. If the expander
599 -- generates a literal that does NOT correspond to a static expression,
600 -- e.g. by folding an expression whose value is known at compile time,
601 -- but is not technically static, then the caller should reset the
602 -- Is_Static_Expression flag after analyzing but before resolving.
603 --
604 -- If the Suppress argument is present, then the analysis is done
605 -- with the specified check suppressed (can be All_Checks to suppress
606 -- all checks).
607
608 procedure Analyze_List (L : List_Id);
609 procedure Analyze_List (L : List_Id; Suppress : Check_Id);
610 -- Analyzes each element of a list. If the Suppress argument is present,
611 -- then the analysis is done with the specified check suppressed (can
612 -- be All_Checks to suppress all checks).
613
614 procedure Copy_Suppress_Status
615 (C : Check_Id;
616 From : Entity_Id;
617 To : Entity_Id);
618 -- If From is an entity for which check C is explicitly suppressed
619 -- then also explicitly suppress the corresponding check in To.
620
621 procedure Insert_List_After_And_Analyze
622 (N : Node_Id; L : List_Id);
623 procedure Insert_List_After_And_Analyze
624 (N : Node_Id; L : List_Id; Suppress : Check_Id);
625 -- Inserts list L after node N using Nlists.Insert_List_After, and then,
626 -- after this insertion is complete, analyzes all the nodes in the list,
627 -- including any additional nodes generated by this analysis. If the list
628 -- is empty or No_List, the call has no effect. If the Suppress argument is
629 -- present, then the analysis is done with the specified check suppressed
630 -- (can be All_Checks to suppress all checks).
631
632 procedure Insert_List_Before_And_Analyze
633 (N : Node_Id; L : List_Id);
634 procedure Insert_List_Before_And_Analyze
635 (N : Node_Id; L : List_Id; Suppress : Check_Id);
636 -- Inserts list L before node N using Nlists.Insert_List_Before, and then,
637 -- after this insertion is complete, analyzes all the nodes in the list,
638 -- including any additional nodes generated by this analysis. If the list
639 -- is empty or No_List, the call has no effect. If the Suppress argument is
640 -- present, then the analysis is done with the specified check suppressed
641 -- (can be All_Checks to suppress all checks).
642
643 procedure Insert_After_And_Analyze
644 (N : Node_Id; M : Node_Id);
645 procedure Insert_After_And_Analyze
646 (N : Node_Id; M : Node_Id; Suppress : Check_Id);
647 -- Inserts node M after node N and then after the insertion is complete,
648 -- analyzes the inserted node and all nodes that are generated by
649 -- this analysis. If the node is empty, the call has no effect. If the
650 -- Suppress argument is present, then the analysis is done with the
651 -- specified check suppressed (can be All_Checks to suppress all checks).
652
653 procedure Insert_Before_And_Analyze
654 (N : Node_Id; M : Node_Id);
655 procedure Insert_Before_And_Analyze
656 (N : Node_Id; M : Node_Id; Suppress : Check_Id);
657 -- Inserts node M before node N and then after the insertion is complete,
658 -- analyzes the inserted node and all nodes that could be generated by
659 -- this analysis. If the node is empty, the call has no effect. If the
660 -- Suppress argument is present, then the analysis is done with the
661 -- specified check suppressed (can be All_Checks to suppress all checks).
662
663 function External_Ref_In_Generic (E : Entity_Id) return Boolean;
664 -- Return True if we are in the context of a generic and E is
665 -- external (more global) to it.
666
667 procedure Enter_Generic_Scope (S : Entity_Id);
668 -- Called each time a Generic subprogram or package scope is entered. S is
669 -- the entity of the scope.
670 --
671 -- ??? At the moment, only called for package specs because this mechanism
672 -- is only used for avoiding freezing of external references in generics
673 -- and this can only be an issue if the outer generic scope is a package
674 -- spec (otherwise all external entities are already frozen)
675
676 procedure Exit_Generic_Scope (S : Entity_Id);
677 -- Called each time a Generic subprogram or package scope is exited. S is
678 -- the entity of the scope.
679 --
680 -- ??? At the moment, only called for package specs exit.
681
682 function Explicit_Suppress (E : Entity_Id; C : Check_Id) return Boolean;
683 -- This function returns True if an explicit pragma Suppress for check C
684 -- is present in the package defining E.
685
686 procedure Preanalyze (N : Node_Id);
687 -- Performs a pre-analysis of node N. During pre-analysis no expansion is
688 -- carried out for N or its children. For more info on pre-analysis read
689 -- the spec of Sem.
690
691 generic
692 with procedure Action (Item : Node_Id);
693 procedure Walk_Library_Items;
694 -- Primarily for use by CodePeer and GNATprove. Must be called after
695 -- semantic analysis (and expansion in the case of CodePeer) are complete.
696 -- Walks each relevant library item, calling Action for each, in an order
697 -- such that one will not run across forward references. Each Item passed
698 -- to Action is the declaration or body of a library unit, including
699 -- generics and renamings. The first item is the N_Package_Declaration node
700 -- for package Standard. Bodies are not included, except for the main unit
701 -- itself, which always comes last.
702 --
703 -- Item is never a subunit
704 --
705 -- Item is never an instantiation. Instead, the instance declaration is
706 -- passed, and (if the instantiation is the main unit), the instance body.
707
708 ------------------------
709 -- Debugging Routines --
710 ------------------------
711
712 function ss (Index : Int) return Scope_Stack_Entry;
713 pragma Export (Ada, ss);
714 -- "ss" = "scope stack"; returns the Index'th entry in the Scope_Stack
715
716 function sst return Scope_Stack_Entry;
717 pragma Export (Ada, sst);
718 -- "sst" = "scope stack top"; same as ss(Scope_Stack.Last)
719
720 end Sem;