OSDN Git Service

edbd4814a0f3831ad0958a65f7c037ade1c1f228
[pf3gnuchains/gcc-fork.git] / gcc / ada / sinfo.ads
1 ------------------------------------------------------------------------------
2 --                                                                          --
3 --                         GNAT COMPILER COMPONENTS                         --
4 --                                                                          --
5 --                                S I N F O                                 --
6 --                                                                          --
7 --                                 S p e c                                  --
8 --                                                                          --
9 --          Copyright (C) 1992-2008, 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 2,  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 COPYING.  If not, write --
19 -- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
20 -- Boston, MA 02110-1301, USA.                                              --
21 --                                                                          --
22 -- As a special exception,  if other files  instantiate  generics from this --
23 -- unit, or you link  this unit with other files  to produce an executable, --
24 -- this  unit  does not  by itself cause  the resulting  executable  to  be --
25 -- covered  by the  GNU  General  Public  License.  This exception does not --
26 -- however invalidate  any other reasons why  the executable file  might be --
27 -- covered by the  GNU Public License.                                      --
28 --                                                                          --
29 -- GNAT was originally developed  by the GNAT team at  New York University. --
30 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
31 --                                                                          --
32 ------------------------------------------------------------------------------
33
34 --  This package defines the structure of the abstract syntax tree. The Tree
35 --  package provides a basic tree structure. Sinfo describes how this structure
36 --  is used to represent the syntax of an Ada program.
37
38 --  The grammar in the RM is followed very closely in the tree
39 --  design, and is repeated as part of this source file.
40
41 --  The tree contains not only the full syntactic representation of the
42 --  program, but also the results of semantic analysis. In particular, the
43 --  nodes for defining identifiers, defining character literals and defining
44 --  operator symbols, collectively referred to as entities, represent what
45 --  would normally be regarded as the symbol table information. In addition a
46 --  number of the tree nodes contain semantic information.
47
48 --  WARNING: Several files are automatically generated from this package.
49 --  See below for details.
50
51 with Namet;  use Namet;
52 with Types;  use Types;
53 with Uintp;  use Uintp;
54 with Urealp; use Urealp;
55
56 package Sinfo is
57
58    ---------------------------------
59    -- Making Changes to This File --
60    ---------------------------------
61
62    --  If changes are made to this file, a number of related steps must be
63    --  carried out to ensure consistency. First, if a field access function is
64    --  added, it appears in seven places:
65
66    --    The documentation associated with the node
67    --    The spec of the access function in sinfo.ads
68    --    The body of the access function in sinfo.adb
69    --    The pragma Inline at the end of sinfo.ads for the access function
70    --    The spec of the set procedure in sinfo.ads
71    --    The body of the set procedure in sinfo.adb
72    --    The pragma Inline at the end of sinfo.ads for the set procedure
73
74    --  The field chosen must be consistent in all places, and, for a node that
75    --  is a subexpression, must not overlap any of the standard expression
76    --  fields.
77
78    --  In addition, if any of the standard expression fields is changed, then
79    --  the utility program which creates the Treeprs spec (in file treeprs.ads)
80    --  must be updated appropriately, since it special cases expression fields.
81
82    --  If a new tree node is added, then the following changes are made
83
84    --    Add it to the documentation in the appropriate place
85    --    Add its fields to this documentation section
86    --    Define it in the appropriate classification in Node_Kind
87    --    In the body (sinfo), add entries to the access functions for all
88    --     its fields (except standard expression fields) to include the new
89    --     node in the checks.
90    --    Add an appropriate section to the case statement in sprint.adb
91    --    Add an appropriate section to the case statement in sem.adb
92    --    Add an appropriate section to the case statement in exp_util.adb
93    --     (Insert_Actions procedure)
94    --    For a subexpression, add an appropriate section to the case
95    --     statement in sem_eval.adb
96    --    For a subexpression, add an appropriate section to the case
97    --     statement in sem_res.adb
98
99    --  Finally, four utility programs must be run:
100
101    --    Run CSinfo to check that you have made the changes consistently. It
102    --     checks most of the rules given above, with clear error messages. This
103    --     utility reads sinfo.ads and sinfo.adb and generates a report to
104    --     standard output.
105
106    --    Run XSinfo to create sinfo.h, the corresponding C header. This
107    --     utility reads sinfo.ads and generates sinfo.h. Note that it does
108    --     not need to read sinfo.adb, since the contents of the body are
109    --     algorithmically determinable from the spec.
110
111    --    Run XTreeprs to create treeprs.ads, an updated version of the module
112    --     that is used to drive the tree print routine. This utility reads (but
113    --     does not modify) treeprs.adt, the template that provides the basic
114    --     structure of the file, and then fills in the data from the comments
115    --     in sinfo.ads.
116
117    --    Run XNmake to create nmake.ads and nmake.adb, the package body and
118    --     spec of the Nmake package which contains functions for constructing
119    --     nodes.
120
121    --  All of the above steps except CSinfo are done automatically by the
122    --  build scripts when you do a full bootstrap.
123
124    --  Note: sometime we could write a utility that actually generated the body
125    --  of sinfo from the spec instead of simply checking it, since, as noted
126    --  above, the contents of the body can be determined from the spec.
127
128    --------------------------------
129    -- Implicit Nodes in the Tree --
130    --------------------------------
131
132    --  Generally the structure of the tree very closely follows the grammar as
133    --  defined in the RM. However, certain nodes are omitted to save space and
134    --  simplify semantic processing. Two general classes of such omitted nodes
135    --  are as follows:
136
137    --   If the only possibilities for a non-terminal are one or more other
138    --   non-terminals (i.e. the rule is a "skinny" rule), then usually the
139    --   corresponding node is omitted from the tree, and the target construct
140    --   appears directly. For example, a real type definition is either
141    --   floating point definition or a fixed point definition. No explicit node
142    --   appears for real type definition. Instead either the floating point
143    --   definition or fixed point definition appears directly.
144
145    --   If a non-terminal corresponds to a list of some other non-terminal
146    --   (possibly with separating punctuation), then usually it is omitted from
147    --   the tree, and a list of components appears instead. For example,
148    --   sequence of statements does not appear explicitly in the tree. Instead
149    --   a list of statements appears directly.
150
151    --  Some additional cases of omitted nodes occur and are documented
152    --  individually. In particular, many nodes are omitted in the tree
153    --  generated for an expression.
154
155    -------------------------------------------
156    -- Handling of Defining Identifier Lists --
157    -------------------------------------------
158
159    --  In several declarative forms in the syntax, lists of defining
160    --  identifiers appear (object declarations, component declarations, number
161    --  declarations etc.)
162
163    --  The semantics of such statements are equivalent to a series of identical
164    --  declarations of single defining identifiers (except that conformance
165    --  checks require the same grouping of identifiers in the parameter case).
166
167    --  To simplify semantic processing, the parser breaks down such multiple
168    --  declaration cases into sequences of single declarations, duplicating
169    --  type and initialization information as required. The flags More_Ids and
170    --  Prev_Ids are used to record the original form of the source in the case
171    --  where the original source used a list of names, More_Ids being set on
172    --  all but the last name and Prev_Ids being set on all but the first name.
173    --  These flags are used to reconstruct the original source (e.g. in the
174    --  Sprint package), and also are included in the conformance checks, but
175    --  otherwise have no semantic significance.
176
177    --  Note: the reason that we use More_Ids and Prev_Ids rather than
178    --  First_Name and Last_Name flags is so that the flags are off in the
179    --  normal one identifier case, which minimizes tree print output.
180
181    -----------------------
182    -- Use of Node Lists --
183    -----------------------
184
185    --  With a few exceptions, if a construction of the form {non-terminal}
186    --  appears in the tree, lists are used in the corresponding tree node (see
187    --  package Nlists for handling of node lists). In this case a field of the
188    --  parent node points to a list of nodes for the non-terminal. The field
189    --  name for such fields has a plural name which always ends in "s". For
190    --  example, a case statement has a field Alternatives pointing to list of
191    --  case statement alternative nodes.
192
193    --  Only fields pointing to lists have names ending in "s", so generally the
194    --  structure is strongly typed, fields not ending in s point to single
195    --  nodes, and fields ending in s point to lists.
196
197    --  The following example shows how a traversal of a list is written. We
198    --  suppose here that Stmt points to a N_Case_Statement node which has a
199    --  list field called Alternatives:
200
201    --   Alt := First (Alternatives (Stmt));
202    --   while Present (Alt) loop
203    --      ..
204    --      -- processing for case statement alternative Alt
205    --      ..
206    --      Alt := Next (Alt);
207    --   end loop;
208
209    --  The Present function tests for Empty, which in this case signals the end
210    --  of the list. First returns Empty immediately if the list is empty.
211    --  Present is defined in Atree, First and Next are defined in Nlists.
212
213    --  The exceptions to this rule occur with {DEFINING_IDENTIFIERS} in all
214    --  contexts, which is handled as described in the previous section, and
215    --  with {,library_unit_NAME} in the N_With_Clause mode, which is handled
216    --  using the First_Name and Last_Name flags, as further detailed in the
217    --  description of the N_With_Clause node.
218
219    -------------
220    -- Pragmas --
221    -------------
222
223    --  Pragmas can appear in many different context, but are not included in
224    --  the grammar. Still they must appear in the tree, so they can be properly
225    --  processed.
226
227    --  Two approaches are used. In some cases, an extra field is defined in an
228    --  appropriate node that contains a list of pragmas appearing in the
229    --  expected context. For example pragmas can appear before an
230    --  Accept_Alternative in a Selective_Accept_Statement, and these pragmas
231    --  appear in the Pragmas_Before field of the N_Accept_Alternative node.
232
233    --  The other approach is to simply allow pragmas to appear in syntactic
234    --  lists where the grammar (of course) does not include the possibility.
235    --  For example, the Variants field of an N_Variant_Part node points to a
236    --  list that can contain both N_Pragma and N_Variant nodes.
237
238    --  To make processing easier in the latter case, the Nlists package
239    --  provides a set of routines (First_Non_Pragma, Last_Non_Pragma,
240    --  Next_Non_Pragma, Prev_Non_Pragma) that allow such lists to be handled
241    --  ignoring all pragmas.
242
243    --  In the case of the variants list, we can either write:
244
245    --      Variant := First (Variants (N));
246    --      while Present (Variant) loop
247    --         ...
248    --         Variant := Next (Variant);
249    --      end loop;
250
251    --  or
252
253    --      Variant := First_Non_Pragma (Variants (N));
254    --      while Present (Variant) loop
255    --         ...
256    --         Variant := Next_Non_Pragma (Variant);
257    --      end loop;
258
259    --  In the first form of the loop, Variant can either be an N_Pragma or an
260    --  N_Variant node. In the second form, Variant can only be N_Variant since
261    --  all pragmas are skipped.
262
263    ---------------------
264    -- Optional Fields --
265    ---------------------
266
267    --  Fields which correspond to a section of the syntax enclosed in square
268    --  brackets are generally omitted (and the corresponding field set to Empty
269    --  for a node, or No_List for a list). The documentation of such fields
270    --  notes these cases. One exception to this rule occurs in the case of
271    --  possibly empty statement sequences (such as the sequence of statements
272    --  in an entry call alternative). Such cases appear in the syntax rules as
273    --  [SEQUENCE_OF_STATEMENTS] and the fields corresponding to such optional
274    --  statement sequences always contain an empty list (not No_List) if no
275    --  statements are present.
276
277    --  Note: the utility program that constructs the body and spec of the Nmake
278    --  package relies on the format of the comments to determine if a field
279    --  should have a default value in the corresponding make routine. The rule
280    --  is that if the first line of the description of the field contains the
281    --  string "(set to xxx if", then a default value of xxx is provided for
282    --  this field in the corresponding Make_yyy routine.
283
284    -----------------------------------
285    -- Note on Body/Spec Terminology --
286    -----------------------------------
287
288    --  In informal discussions about Ada, it is customary to refer to package
289    --  and subprogram specs and bodies. However, this is not technically
290    --  correct, what is normally referred to as a spec or specification is in
291    --  fact a package declaration or subprogram declaration. We are careful in
292    --  GNAT to use the correct terminology and in particular, the full word
293    --  specification is never used as an incorrect substitute for declaration.
294    --  The structure and terminology used in the tree also reflects the grammar
295    --  and thus uses declaration and specification in the technically correct
296    --  manner.
297
298    --  However, there are contexts in which the informal terminology is useful.
299    --  We have the word "body" to refer to the Interp_Etype declared by the
300    --  declaration of a unit body, and in some contexts we need similar term to
301    --  refer to the entity declared by the package or subprogram declaration,
302    --  and simply using declaration can be confusing since the body also has a
303    --  declaration.
304
305    --  An example of such a context is the link between the package body and
306    --  its declaration. With_Declaration is confusing, since the package body
307    --  itself is a declaration.
308
309    --  To deal with this problem, we reserve the informal term Spec, i.e. the
310    --  popular abbreviation used in this context, to refer to the entity
311    --  declared by the package or subprogram declaration. So in the above
312    --  example case, the field in the body is called With_Spec.
313
314    --  Another important context for the use of the word Spec is in error
315    --  messages, where a hyper-correct use of declaration would be confusing to
316    --  a typical Ada programmer, and even for an expert programmer can cause
317    --  confusion since the body has a declaration as well.
318
319    --  So, to summarize:
320
321    --     Declaration    always refers to the syntactic entity that is called
322    --                    a declaration. In particular, subprogram declaration
323    --                    and package declaration are used to describe the
324    --                    syntactic entity that includes the semicolon.
325
326    --     Specification  always refers to the syntactic entity that is called
327    --                    a specification. In particular, the terms procedure
328    --                    specification, function specification, package
329    --                    specification, subprogram specification always refer
330    --                    to the syntactic entity that has no semicolon.
331
332    --     Spec           is an informal term, used to refer to the entity
333    --                    that is declared by a task declaration, protected
334    --                    declaration, generic declaration, subprogram
335    --                    declaration or package declaration.
336
337    --  This convention is followed throughout the GNAT documentation
338    --  both internal and external, and in all error message text.
339
340    ------------------------
341    -- Internal Use Nodes --
342    ------------------------
343
344    --  These are Node_Kind settings used in the internal implementation which
345    --  are not logically part of the specification.
346
347    --  N_Unused_At_Start
348    --  Completely unused entry at the start of the enumeration type. This
349    --  is inserted so that no legitimate value is zero, which helps to get
350    --  better debugging behavior, since zero is a likely uninitialized value).
351
352    --  N_Unused_At_End
353    --  Completely unused entry at the end of the enumeration type. This is
354    --  handy so that arrays with Node_Kind as the index type have an extra
355    --  entry at the end (see for example the use of the Pchar_Pos_Array in
356    --  Treepr, where the extra entry provides the limit value when dealing with
357    --  the last used entry in the array).
358
359    -----------------------------------------
360    -- Note on the settings of Sloc fields --
361    -----------------------------------------
362
363    --  The Sloc field of nodes that come from the source is set by the parser.
364    --  For internal nodes, and nodes generated during expansion the Sloc is
365    --  usually set in the call to the constructor for the node. In general the
366    --  Sloc value chosen for an internal node is the Sloc of the source node
367    --  whose processing is responsible for the expansion. For example, the Sloc
368    --  of an inherited primitive operation is the Sloc of the corresponding
369    --  derived type declaration.
370
371    --  For the nodes of a generic instantiation, the Sloc value is encoded to
372    --  represent both the original Sloc in the generic unit, and the Sloc of
373    --  the instantiation itself. See Sinput.ads for details.
374
375    --  Subprogram instances create two callable entities: one is the visible
376    --  subprogram instance, and the other is an anonymous subprogram nested
377    --  within a wrapper package that contains the renamings for the actuals.
378    --  Both of these entities have the Sloc of the defining entity in the
379    --  instantiation node. This simplifies some ASIS queries.
380
381    -----------------------
382    -- Field Definitions --
383    -----------------------
384
385    --  In the following node definitions, all fields, both syntactic and
386    --  semantic, are documented. The one exception is in the case of entities
387    --  (defining indentifiers, character literals and operator symbols), where
388    --  the usage of the fields depends on the entity kind. Entity fields are
389    --  fully documented in the separate package Einfo.
390
391    --  In the node definitions, three common sets of fields are abbreviated to
392    --  save both space in the documentation, and also space in the string
393    --  (defined in Tree_Print_Strings) used to print trees. The following
394    --  abbreviations are used:
395
396    --  Note: the utility program that creates the Treeprs spec (in the file
397    --  xtreeprs.adb) knows about the special fields here, so it must be
398    --  modified if any change is made to these fields.
399
400    --    "plus fields for binary operator"
401    --       Chars                    (Name1)      Name_Id for the operator
402    --       Left_Opnd                (Node2)      left operand expression
403    --       Right_Opnd               (Node3)      right operand expression
404    --       Entity                   (Node4-Sem)  defining entity for operator
405    --       Associated_Node          (Node4-Sem)  for generic processing
406    --       Do_Overflow_Check        (Flag17-Sem) set if overflow check needed
407    --       Has_Private_View         (Flag11-Sem) set in generic units.
408
409    --    "plus fields for unary operator"
410    --       Chars                    (Name1)      Name_Id for the operator
411    --       Right_Opnd               (Node3)      right operand expression
412    --       Entity                   (Node4-Sem)  defining entity for operator
413    --       Associated_Node          (Node4-Sem)  for generic processing
414    --       Do_Overflow_Check        (Flag17-Sem) set if overflow check needed
415    --       Has_Private_View         (Flag11-Sem) set in generic units.
416
417    --    "plus fields for expression"
418    --       Paren_Count                           number of parentheses levels
419    --       Etype                    (Node5-Sem)  type of the expression
420    --       Is_Overloaded            (Flag5-Sem)  >1 type interpretation exists
421    --       Is_Static_Expression     (Flag6-Sem)  set for static expression
422    --       Raises_Constraint_Error  (Flag7-Sem)  evaluation raises CE
423    --       Must_Not_Freeze          (Flag8-Sem)  set if must not freeze
424    --       Do_Range_Check           (Flag9-Sem)  set if a range check needed
425    --       Assignment_OK            (Flag15-Sem) set if modification is OK
426    --       Is_Controlling_Actual    (Flag16-Sem) set for controlling argument
427
428    --  Note: see under (EXPRESSION) for further details on the use of
429    --  the Paren_Count field to record the number of parentheses levels.
430
431    --  Node_Kind is the type used in the Nkind field to indicate the node kind.
432    --  The actual definition of this type is given later (the reason for this
433    --  is that we want the descriptions ordered by logical chapter in the RM,
434    --  but the type definition is reordered to facilitate the definition of
435    --  some subtype ranges. The individual descriptions of the nodes show how
436    --  the various fields are used in each node kind, as well as providing
437    --  logical names for the fields. Functions and procedures are provided for
438    --  accessing and setting these fields using these logical names.
439
440    -----------------------
441    -- Gigi Restrictions --
442    -----------------------
443
444    --  The tree passed to Gigi is more restricted than the general tree form.
445    --  For example, as a result of expansion, most of the tasking nodes can
446    --  never appear. For each node to which either a complete or partial
447    --  restriction applies, a note entitled "Gigi restriction" appears which
448    --  documents the restriction.
449
450    --  Note that most of these restrictions apply only to trees generated when
451    --  code is being generated, since they involved expander actions that
452    --  destroy the tree.
453
454    ------------------------
455    -- Common Flag Fields --
456    ------------------------
457
458    --  The following flag fields appear in all nodes
459
460    --  Analyzed (Flag1)
461    --    This flag is used to indicate that a node (and all its children have
462    --    been analyzed. It is used to avoid reanalysis of a node that has
463    --    already been analyzed, both for efficiency and functional correctness
464    --    reasons.
465
466    --  Comes_From_Source (Flag2)
467    --    This flag is on for any nodes built by the scanner or parser from the
468    --    source program, and off for any nodes built by the analyzer or
469    --    expander. It indicates that a node comes from the original source.
470    --    This flag is defined in Atree.
471
472    --  Error_Posted (Flag3)
473    --    This flag is used to avoid multiple error messages being posted on or
474    --    referring to the same node. This flag is set if an error message
475    --    refers to a node or is posted on its source location, and has the
476    --    effect of inhibiting further messages involving this same node.
477
478    --  Has_Dynamic_Length_Check (Flag10-Sem)
479    --    This flag is present on all nodes. It is set to indicate that one of
480    --    the routines in unit Checks has generated a length check action which
481    --    has been inserted at the flagged node. This is used to avoid the
482    --    generation of duplicate checks.
483
484    --  Has_Dynamic_Range_Check (Flag12-Sem)
485    --    This flag is present on all nodes. It is set to indicate that one of
486    --    the routines in unit Checks has generated a range check action which
487    --    has been inserted at the flagged node. This is used to avoid the
488    --    generation of duplicate checks.
489
490    --  Has_Local_Raise (Flag8-Sem)
491    --    Present in exception handler nodes. Set if the handler can be entered
492    --    via a local raise that gets transformed to a goto statement. This will
493    --    always be set if Local_Raise_Statements is non-empty, but can also be
494    --    set as a result of generation of N_Raise_xxx nodes, or flags set in
495    --    nodes requiring generation of back end checks.
496
497    ------------------------------------
498    -- Description of Semantic Fields --
499    ------------------------------------
500
501    --  The meaning of the syntactic fields is generally clear from their names
502    --  without any further description, since the names are chosen to
503    --  correspond very closely to the syntax in the reference manual. This
504    --  section describes the usage of the semantic fields, which are used to
505    --  contain additional information determined during semantic analysis.
506
507    --  ABE_Is_Certain (Flag18-Sem)
508    --    This flag is set in an instantiation node or a call node is determined
509    --    to be sure to raise an ABE. This is used to trigger special handling
510    --    of such cases, particularly in the instantiation case where we avoid
511    --    instantiating the body if this flag is set. This flag is also present
512    --    in an N_Formal_Package_Declaration_Node since formal package
513    --    declarations are treated like instantiations, but it is always set to
514    --    False in this context.
515
516    --  Accept_Handler_Records (List5-Sem)
517    --    This field is present only in an N_Accept_Alternative node. It is used
518    --    to temporarily hold the exception handler records from an accept
519    --    statement in a selective accept. These exception handlers will
520    --    eventually be placed in the Handler_Records list of the procedure
521    --    built for this accept (see Expand_N_Selective_Accept procedure in
522    --    Exp_Ch9 for further details).
523
524    --  Access_Types_To_Process (Elist2-Sem)
525    --    Present in N_Freeze_Entity nodes for Incomplete or private types.
526    --    Contains the list of access types which may require specific treatment
527    --    when the nature of the type completion is completely known. An example
528    --    of such treatement is the generation of the associated_final_chain.
529
530    --  Actions (List1-Sem)
531    --    This field contains a sequence of actions that are associated with the
532    --    node holding the field. See the individual node types for details of
533    --    how this field is used, as well as the description of the specific use
534    --    for a particular node type.
535
536    --  Activation_Chain_Entity (Node3-Sem)
537    --    This is used in tree nodes representing task activators (blocks,
538    --    subprogram bodies, package declarations, and task bodies). It is
539    --    initially Empty, and then gets set to point to the entity for the
540    --    declared Activation_Chain variable when the first task is declared.
541    --    When tasks are declared in the corresponding declarative region this
542    --    entity is located by name (its name is always _Chain) and the declared
543    --    tasks are added to the chain. Note that N_Extended_Return_Statement
544    --    does not have this attribute, although it does have an activation
545    --    chain. This chain is used to store the tasks temporarily, and is not
546    --    used for activating them. On successful completion of the return
547    --    statement, the tasks are moved to the caller's chain, and the caller
548    --    activates them.
549
550    --  Acts_As_Spec (Flag4-Sem)
551    --    A flag set in the N_Subprogram_Body node for a subprogram body which
552    --    is acting as its own spec, except in the case of a library level
553    --    subprogram, in which case the flag is set on the parent compilation
554    --    unit node instead (see further description in spec of Lib package).
555    --    ??? Above note about Lib is dubious since lib.ads does not mention
556    --    Acts_As_Spec at all.
557
558    --  Actual_Designated_Subtype (Node4-Sem)
559    --    Present in N_Free_Statement and N_Explicit_Dereference nodes. If gigi
560    --    needs to known the dynamic constrained subtype of the designated
561    --    object, this attribute is set to that type. This is done for
562    --    N_Free_Statements for access-to-classwide types and access to
563    --    unconstrained packed array types, and for N_Explicit_Dereference when
564    --    the designated type is an unconstrained packed array and the
565    --    dereference is the prefix of a 'Size attribute reference.
566
567    --  Address_Warning_Posted (Flag18-Sem)
568    --    Present in N_Attribute_Definition nodes. Set to indicate that we have
569    --    posted a warning for the address clause regarding size or alignment
570    --    issues. Used to inhibit multiple redundant messages.
571
572    --  Aggregate_Bounds (Node3-Sem)
573    --    Present in array N_Aggregate nodes. If the aggregate contains
574    --    component associations this field points to an N_Range node whose
575    --    bounds give the lowest and highest discrete choice values. If the
576    --    named aggregate contains a dynamic or null choice this field is empty.
577    --    If the aggregate contains positional elements this field points to an
578    --    N_Integer_Literal node giving the number of positional elements. Note
579    --    that if the aggregate contains positional elements and an other choice
580    --    the N_Integer_Literal only accounts for the number of positional
581    --    elements.
582
583    --  All_Others (Flag11-Sem)
584    --    Present in an N_Others_Choice node. This flag is set for an others
585    --    exception where all exceptions are to be caught, even those that are
586    --    not normally handled (in particular the tasking abort signal). This
587    --    is used for translation of the at end handler into a normal exception
588    --    handler.
589
590    --  Assignment_OK (Flag15-Sem)
591    --    This flag is set in a subexpression node for an object, indicating
592    --    that the associated object can be modified, even if this would not
593    --    normally be permissible (either by direct assignment, or by being
594    --    passed as an out or in-out parameter). This is used by the expander
595    --    for a number of purposes, including initialzation of constants and
596    --    limited type objects (such as tasks), setting discriminant fields,
597    --    setting tag values, etc. N_Object_Declaration nodes also have this
598    --    flag defined. Here it is used to indicate that an initialization
599    --    expression is valid, even where it would normally not be allowed
600    --    (e.g. where the type involved is limited).
601
602    --  Associated_Node (Node4-Sem)
603    --    Present in nodes that can denote an entity: identifiers, character
604    --    literals, operator symbols, expanded names, operator nodes, and
605    --    attribute reference nodes (all these nodes have an Entity field).
606    --    This field is also present in N_Aggregate, N_Selected_Component, and
607    --    N_Extension_Aggregate nodes. This field is used in generic processing
608    --    to create links between the generic template and the generic copy.
609    --    See Sem_Ch12.Get_Associated_Node for full details. Note that this
610    --    field overlaps Entity, which is fine, since, as explained in Sem_Ch12,
611    --    the normal function of Entity is not required at the point where the
612    --    Associated_Node is set. Note also, that in generic templates, this
613    --    means that the Entity field does not necessarily point to an Entity.
614    --    Since the back end is expected to ignore generic templates, this is
615    --    harmless.
616
617    --  At_End_Proc (Node1)
618    --    This field is present in an N_Handled_Sequence_Of_Statements node.
619    --    It contains an identifier reference for the cleanup procedure to be
620    --    called. See description of this node for further details.
621
622    --  Backwards_OK (Flag6-Sem)
623    --    A flag present in the N_Assignment_Statement node. It is used only
624    --    if the type being assigned is an array type, and is set if analysis
625    --    determines that it is definitely safe to do the copy backwards, i.e.
626    --    starting at the highest addressed element. Note that if neither of the
627    --    flags Forwards_OK or Backwards_OK is set, it means that the front end
628    --    could not determine that either direction is definitely safe, and a
629    --    runtime check may be required if the backend cannot figure it out.
630
631    --  Body_To_Inline (Node3-Sem)
632    --    present in subprogram declarations. Denotes analyzed but unexpanded
633    --    body of subprogram, to be used when inlining calls. Present when the
634    --    subprogram has an Inline pragma and inlining is enabled. If the
635    --    declaration is completed by a renaming_as_body, and the renamed en-
636    --    tity is a subprogram, the Body_To_Inline is the name of that entity,
637    --    which is used directly in later calls to the original subprogram.
638
639    --  Body_Required (Flag13-Sem)
640    --    A flag that appears in the N_Compilation_Unit node indicating that
641    --    the corresponding unit requires a body. For the package case, this
642    --    indicates that a completion is required. In Ada 95, if the flag is not
643    --    set for the package case, then a body may not be present. In Ada 83,
644    --    if the flag is not set for the package case, then body is optional.
645    --    For a subprogram declaration, the flag is set except in the case where
646    --    a pragma Import or Interface applies, in which case no body is
647    --    permitted (in Ada 83 or Ada 95).
648
649    --  By_Ref (Flag5-Sem)
650    --    Present in N_Simple_Return_Statement and N_Extended_Return_Statement,
651    --    this flag is set when the returned expression is already allocated on
652    --    the secondary stack and thus the result is passed by reference rather
653    --    than copied another time.
654
655    --  Check_Address_Alignment (Flag11-Sem)
656    --    A flag present in N_Attribute_Definition clause for a 'Address
657    --    attribute definition. This flag is set if a dynamic check should be
658    --    generated at the freeze point for the entity to which this address
659    --    clause applies. The reason that we need this flag is that we want to
660    --    check for range checks being suppressed at the point where the
661    --    attribute definition clause is given, rather than testing this at the
662    --    freeze point.
663
664    --  Coextensions (Elist4-Sem)
665    --    Present in allocators nodes. Points to list of allocators for the
666    --    access discriminants of the allocated object.
667
668    --  Comes_From_Extended_Return_Statement (Flag18-Sem)
669    --    Present in N_Simple_Return_Statement nodes. True if this node was
670    --    constructed as part of the N_Extended_Return_Statement expansion.
671    --    .
672
673    --  Compile_Time_Known_Aggregate (Flag18-Sem)
674    --    Present in N_Aggregate nodes. Set for aggregates which can be fully
675    --    evaluated at compile time without raising constraint error. Such
676    --    aggregates can be passed as is to Gigi without any expansion. See
677    --    Sem_Aggr for the specific conditions under which an aggregate has this
678    --    flag set. See also the flag Static_Processing_OK.
679
680    --  Condition_Actions (List3-Sem)
681    --    This field appears in else-if nodes and in the iteration scheme node
682    --    for while loops. This field is only used during semantic processing to
683    --    temporarily hold actions inserted into the tree. In the tree passed
684    --    to gigi, the condition actions field is always set to No_List. For
685    --    details on how this field is used, see the routine Insert_Actions in
686    --    package Exp_Util, and also the expansion routines for the relevant
687    --    nodes.
688
689    --  Controlling_Argument (Node1-Sem)
690    --    This field is set in procedure and function call nodes if the call
691    --    is a dispatching call (it is Empty for a non-dispatching call). It
692    --    indicates the source of the call's controlling tag. For procedure
693    --    calls, the Controlling_Argument is one of the actuals. For function
694    --    that has a dispatching result, it is an entity in the context of the
695    --    call that can provide a tag, or else it is the tag of the root type
696    --    of the class. It can also specify a tag directly rather than being a
697    --    tagged object. The latter is needed by the implementations of AI-239
698    --    and AI-260.
699
700    --  Conversion_OK (Flag14-Sem)
701    --    A flag set on type conversion nodes to indicate that the conversion
702    --    is to be considered as being valid, even though it is the case that
703    --    the conversion is not valid Ada. This is used for attributes Enum_Rep,
704    --    Fixed_Value and Integer_Value, for internal conversions done for
705    --    fixed-point operations, and for certain conversions for calls to
706    --    initialization procedures. If Conversion_OK is set, then Etype must be
707    --    set (the analyzer assumes that Etype has been set). For the case of
708    --    fixed-point operands, it also indicates that the conversion is to be
709    --    direct conversion of the underlying integer result, with no regard to
710    --    the small operand.
711
712    --  Corresponding_Body (Node5-Sem)
713    --    This field is set in subprogram declarations, package declarations,
714    --    entry declarations of protected types, and in generic units. It
715    --    points to the defining entity for the corresponding body (NOT the
716    --    node for the body itself).
717
718    --  Corresponding_Formal_Spec (Node3-Sem)
719    --    This field is set in subprogram renaming declarations, where it points
720    --    to the defining entity for a formal subprogram in the case where the
721    --    renaming corresponds to a generic formal subprogram association in an
722    --    instantiation. The field is Empty if the renaming does not correspond
723    --    to such a formal association.
724
725    --  Corresponding_Generic_Association (Node5-Sem)
726    --    This field is defined for object declarations and object renaming
727    --    declarations. It is set for the declarations within an instance that
728    --    map generic formals to their actuals. If set, the field points to
729    --    a generic_association which is the original parent of the expression
730    --    or name appearing in the declaration. This simplifies ASIS queries.
731
732    --  Corresponding_Integer_Value (Uint4-Sem)
733    --    This field is set in real literals of fixed-point types (it is not
734    --    used for floating-point types). It contains the integer value used
735    --    to represent the fixed-point value. It is also set on the universal
736    --    real literals used to represent bounds of fixed-point base types
737    --    and their first named subtypes.
738
739    --  Corresponding_Spec (Node5-Sem)
740    --    This field is set in subprogram, package, task, and protected body
741    --    nodes, where it points to the defining entity in the corresponding
742    --    spec. The attribute is also set in N_With_Clause nodes where it points
743    --    to the defining entity for the with'ed spec, and in a subprogram
744    --    renaming declaration when it is a Renaming_As_Body. The field is Empty
745    --    if there is no corresponding spec, as in the case of a subprogram body
746    --    that serves as its own spec.
747
748    --  Corresponding_Stub (Node3-Sem)
749    --    This field is present in an N_Subunit node. It holds the node in
750    --    the parent unit that is the stub declaration for the subunit. it is
751    --    set when analysis of the stub forces loading of the proper body. If
752    --    expansion of the proper body creates new declarative nodes, they are
753    --    inserted at the point of the corresponding_stub.
754
755    --  Dcheck_Function (Node5-Sem)
756    --    This field is present in an N_Variant node, It references the entity
757    --    for the discriminant checking function for the variant.
758
759    --  Debug_Statement (Node3)
760    --    This field is present in an N_Pragma node. It is used only for a Debug
761    --    pragma. The parameter is of the form of an expression, as required by
762    --    the pragma syntax, but is actually a procedure call. To simplify
763    --    semantic processing, the parser creates a copy of the argument
764    --    rearranged into a procedure call statement and places it in the
765    --    Debug_Statement field. Note that this field is considered syntactic
766    --    field, since it is created by the parser.
767
768    --  Default_Expression (Node5-Sem)
769    --    This field is Empty if there is no default expression. If there is a
770    --    simple default expression (one with no side effects), then this field
771    --    simply contains a copy of the Expression field (both point to the tree
772    --    for the default expression). Default_Expression is used for
773    --    conformance checking.
774
775    --  Discr_Check_Funcs_Built (Flag11-Sem)
776    --    This flag is present in N_Full_Type_Declaration nodes. It is set when
777    --    discriminant checking functions are constructed. The purpose is to
778    --    avoid attempting to set these functions more than once.
779
780    --  Do_Accessibility_Check (Flag13-Sem)
781    --    This flag is set on N_Parameter_Specification nodes to indicate
782    --    that an accessibility check is required for the parameter. It is
783    --    not yet decided who takes care of this check (TBD ???).
784
785    --  Do_Discriminant_Check (Flag13-Sem)
786    --    This flag is set on N_Selected_Component nodes to indicate that a
787    --    discriminant check is required using the discriminant check routine
788    --    associated with the selector. The actual check is generated by the
789    --    expander when processing selected components.
790
791    --  Do_Division_Check (Flag13-Sem)
792    --    This flag is set on a division operator (/ mod rem) to indicate
793    --    that a zero divide check is required. The actual check is dealt
794    --    with by the backend (all the front end does is to set the flag).
795
796    --  Do_Length_Check (Flag4-Sem)
797    --    This flag is set in an N_Assignment_Statement, N_Op_And, N_Op_Or,
798    --    N_Op_Xor, or N_Type_Conversion node to indicate that a length check
799    --    is required. It is not determined who deals with this flag (???).
800
801    --  Do_Overflow_Check (Flag17-Sem)
802    --    This flag is set on an operator where an overflow check is required on
803    --    the operation. The actual check is dealt with by the backend (all the
804    --    front end does is to set the flag). The other cases where this flag is
805    --    used is on a Type_Conversion node and for attribute reference nodes.
806    --    For a type conversion, it means that the conversion is from one base
807    --    type to another, and the value may not fit in the target base type.
808    --    See also the description of Do_Range_Check for this case. The only
809    --    attribute references which use this flag are Pred and Succ, where it
810    --    means that the result should be checked for going outside the base
811    --    range.
812
813    --  Do_Range_Check (Flag9-Sem)
814    --    This flag is set on an expression which appears in a context where a
815    --    range check is required. The target type is clear from the context.
816    --    The contexts in which this flag can appear are the following:
817
818    --      Right side of an assignment. In this case the target type is
819    --      taken from the left side of the assignment, which is referenced
820    --      by the Name of the N_Assignment_Statement node.
821
822    --      Subscript expressions in an indexed component. In this case the
823    --      target type is determined from the type of the array, which is
824    --      referenced by the Prefix of the N_Indexed_Component node.
825
826    --      Argument expression for a parameter, appearing either directly in
827    --      the Parameter_Associations list of a call or as the Expression of an
828    --      N_Parameter_Association node that appears in this list. In either
829    --      case, the check is against the type of the formal. Note that the
830    --      flag is relevant only in IN and IN OUT parameters, and will be
831    --      ignored for OUT parameters, where no check is required in the call,
832    --      and if a check is required on the return, it is generated explicitly
833    --      with a type conversion.
834
835    --      Initialization expression for the initial value in an object
836    --      declaration. In this case the Do_Range_Check flag is set on
837    --      the initialization expression, and the check is against the
838    --      range of the type of the object being declared.
839
840    --      The expression of a type conversion. In this case the range check is
841    --      against the target type of the conversion. See also the use of
842    --      Do_Overflow_Check on a type conversion. The distinction is that the
843    --      overflow check protects against a value that is outside the range of
844    --      the target base type, whereas a range check checks that the
845    --      resulting value (which is a value of the base type of the target
846    --      type), satisfies the range constraint of the target type.
847
848    --    Note: when a range check is required in contexts other than those
849    --    listed above (e.g. in a return statement), an additional type
850    --    conversion node is introduced to represent the required check.
851
852    --  Do_Storage_Check (Flag17-Sem)
853    --    This flag is set in an N_Allocator node to indicate that a storage
854    --    check is required for the allocation, or in an N_Subprogram_Body node
855    --    to indicate that a stack check is required in the subprogram prolog.
856    --    The N_Allocator case is handled by the routine that expands the call
857    --    to the runtime routine. The N_Subprogram_Body case is handled by the
858    --    backend, and all the semantics does is set the flag.
859
860    --  Do_Tag_Check (Flag13-Sem)
861    --    This flag is set on an N_Assignment_Statement, N_Function_Call,
862    --    N_Procedure_Call_Statement, N_Type_Conversion,
863    --    N_Simple_Return_Statement, or N_Extended_Return_Statement
864    --    node to indicate that the tag check can be suppressed. It is not
865    --    yet decided how this flag is used (TBD ???).
866
867    --  Elaborate_Present (Flag4-Sem)
868    --    This flag is set in the N_With_Clause node to indicate that pragma
869    --    Elaborate pragma appears for the with'ed units.
870
871    --  Elaborate_All_Desirable (Flag9-Sem)
872    --    This flag is set in the N_With_Clause mode to indicate that the static
873    --    elaboration processing has determined that an Elaborate_All pragma is
874    --    desirable for correct elaboration for this unit.
875
876    --  Elaborate_All_Present (Flag14-Sem)
877    --    This flag is set in the N_With_Clause node to indicate that a
878    --    pragma Elaborate_All pragma appears for the with'ed units.
879
880    --  Elaborate_Desirable (Flag11-Sem)
881    --    This flag is set in the N_With_Clause mode to indicate that the static
882    --    elaboration processing has determined that an Elaborate pragma is
883    --    desirable for correct elaboration for this unit.
884
885    --  Elaboration_Boolean (Node2-Sem)
886    --    This field is present in function and procedure specification nodes.
887    --    If set, it points to the entity for a Boolean flag that must be tested
888    --    for certain calls to check for access before elaboration. See body of
889    --    Sem_Elab for further details. This field is Empty if no elaboration
890    --    boolean is required.
891
892    --  Else_Actions (List3-Sem)
893    --    This field is present in conditional expression nodes. During code
894    --    expansion we use the Insert_Actions procedure (in Exp_Util) to insert
895    --    actions at an appropriate place in the tree to get elaborated at the
896    --    right time. For conditional expressions, we have to be sure that the
897    --    actions for the Else branch are only elaborated if the condition is
898    --    False. The Else_Actions field is used as a temporary parking place for
899    --    these actions. The final tree is always rewritten to eliminate the
900    --    need for this field, so in the tree passed to Gigi, this field is
901    --    always set to No_List.
902
903    --  Enclosing_Variant (Node2-Sem)
904    --    This field is present in the N_Variant node and identifies the Node_Id
905    --    corresponding to the immediately enclosing variant when the variant is
906    --    nested, and N_Empty otherwise. Set during semantic processing of the
907    --    variant part of a record type.
908
909    --  Entity (Node4-Sem)
910    --    Appears in all direct names (identifiers, character literals, and
911    --    operator symbols), as well as expanded names, and attributes that
912    --    denote entities, such as 'Class. Points to entity for corresponding
913    --    defining occurrence. Set after name resolution. For identifiers in a
914    --    WITH list, the corresponding defining occurrence is in a separately
915    --    compiled file, and Entity must be set by the library Load procedure.
916    --
917    --    Note: During name resolution, the value in Entity may be temporarily
918    --    incorrect (e.g. during overload resolution, Entity is initially set to
919    --    the first possible correct interpretation, and then later modified if
920    --    necessary to contain the correct value after resolution).
921    --
922    --    Note: This field overlaps Associated_Node, which is used during
923    --    generic processing (see Sem_Ch12 for details). Note also that in
924    --    generic templates, this means that the Entity field does not always
925    --    point to an Entity. Since the back end is expected to ignore generic
926    --    templates, this is harmless.
927    --
928    --    Note: This field also appears in N_Attribute_Definition_Clause nodes.
929    --    It is used only for stream attributes definition clauses. In this
930    --    case, it denotes a (possibly dummy) subprogram entity that is declared
931    --    conceptually at the point of the clause. Thus the visibility of the
932    --    attribute definition clause (in the sense of 8.3(23) as amended by
933    --    AI-195) can be checked by testing the visibility of that subprogram.
934    --
935    --    Note: Normally the Entity field of an identifier points to the entity
936    --    for the corresponding defining identifier, and hence the Chars field
937    --    of an identifier will match the Chars field of the entity. However,
938    --    there is no requirement that these match, and there are obscure cases
939    --    of generated code where they do not match.
940
941    --  Entity_Or_Associated_Node (Node4-Sem)
942    --    A synonym for both Entity and Associated_Node. Used by convention in
943    --    the code when referencing this field in cases where it is not known
944    --    whether the field contains an Entity or an Associated_Node.
945
946    --  Etype (Node5-Sem)
947    --    Appears in all expression nodes, all direct names, and all entities.
948    --    Points to the entity for the related type. Set after type resolution.
949    --    Normally this is the actual subtype of the expression. However, in
950    --    certain contexts such as the right side of an assignment, subscripts,
951    --    arguments to calls, returned value in a function, initial value etc.
952    --    it is the desired target type. In the event that this is different
953    --    from the actual type, the Do_Range_Check flag will be set if a range
954    --    check is required. Note: if the Is_Overloaded flag is set, then Etype
955    --    points to an essentially arbitrary choice from the possible set of
956    --    types.
957
958    --  Exception_Junk (Flag8-Sem)
959    --    This flag is set in a various nodes appearing in a statement sequence
960    --    to indicate that the corresponding node is an artifact of the
961    --    generated code for exception handling, and should be ignored when
962    --    analyzing the control flow of the relevant sequence of statements
963    --    (e.g. to check that it does not end with a bad return statement).
964
965    --  Exception_Label (Node5-Sem)
966    --    Appears in N_Push_xxx_Label nodes. Points to the entity of the label
967    --    to be used for transforming the corresponding exception into a goto,
968    --    or contains Empty, if this exception is not to be transformed. Also
969    --    appears in N_Exception_Handler nodes, where, if set, it indicates
970    --    that there may be a local raise for the handler, so that expansion
971    --    to allow a goto is required (and this field contains the label for
972    --    this goto). See Exp_Ch11.Expand_Local_Exception_Handlers for details.
973
974    --  Expansion_Delayed (Flag11-Sem)
975    --    Set on aggregates and extension aggregates that need a top-down rather
976    --    than bottom up expansion. Typically aggregate expansion happens bottom
977    --    up. For nested aggregates the expansion is delayed until the enclosing
978    --    aggregate itself is expanded, e.g. in the context of a declaration. To
979    --    delay it we set this flag. This is done to avoid creating a temporary
980    --    for each level of a nested aggregates, and also to prevent the
981    --    premature generation of constraint checks. This is also a requirement
982    --    if we want to generate the proper attachment to the internal
983    --    finalization lists (for record with controlled components). Top down
984    --    expansion of aggregates is also used for in-place array aggregate
985    --    assignment or initialization. When the full context is known, the
986    --    target of the assignment or initialization is used to generate the
987    --    left-hand side of individual assignment to each sub-component.
988
989    --  First_Inlined_Subprogram (Node3-Sem)
990    --    Present in the N_Compilation_Unit node for the main program. Points
991    --    to a chain of entities for subprograms that are to be inlined. The
992    --    Next_Inlined_Subprogram field of these entities is used as a link
993    --    pointer with Empty marking the end of the list. This field is Empty
994    --    if there are no inlined subprograms or inlining is not active.
995
996    --  First_Named_Actual (Node4-Sem)
997    --    Present in procedure call statement and function call nodes, and also
998    --    in Intrinsic nodes. Set during semantic analysis to point to the first
999    --    named parameter where parameters are ordered by declaration order (as
1000    --    opposed to the actual order in the call which may be different due to
1001    --    named associations). Note: this field points to the explicit actual
1002    --    parameter itself, not the N_Parameter_Association node (its parent).
1003
1004    --  First_Real_Statement (Node2-Sem)
1005    --    Present in N_Handled_Sequence_Of_Statements node. Normally set to
1006    --    Empty. Used only when declarations are moved into the statement part
1007    --    of a construct as a result of wrapping an AT END handler that is
1008    --    required to cover the declarations. In this case, this field is used
1009    --    to remember the location in the statements list of the first real
1010    --    statement, i.e. the statement that used to be first in the statement
1011    --    list before the declarations were prepended.
1012
1013    --  First_Subtype_Link (Node5-Sem)
1014    --    Present in N_Freeze_Entity node for an anonymous base type that is
1015    --    implicitly created by the declaration of a first subtype. It points
1016    --    to the entity for the first subtype.
1017
1018    --  Float_Truncate (Flag11-Sem)
1019    --    A flag present in type conversion nodes. This is used for float to
1020    --    integer conversions where truncation is required rather than rounding.
1021    --    Note that Gigi does not handle type conversions from real to integer
1022    --    with rounding (see Expand_N_Type_Conversion).
1023
1024    --  Forwards_OK (Flag5-Sem)
1025    --    A flag present in the N_Assignment_Statement node. It is used only
1026    --    if the type being assigned is an array type, and is set if analysis
1027    --    determines that it is definitely safe to do the copy forwards, i.e.
1028    --    starting at the lowest addressed element. Note that if neither of the
1029    --    flags Forwards_OK or Backwards_OK is set, it means that the front end
1030    --    could not determine that either direction is definitely safe, and a
1031    --    runtime check is required.
1032
1033    --  From_At_End (Flag4-Sem)
1034    --    This flag is set on an N_Raise_Statement node if it corresponds to
1035    --    the reraise statement generated as the last statement of an AT END
1036    --    handler when SJLJ exception handling is active. It is used to stop
1037    --    a bogus violation of restriction (No_Exception_Propagation), bogus
1038    --    because if the restriction is set, the reraise is not generated.
1039
1040    --  From_At_Mod (Flag4-Sem)
1041    --    This flag is set on the attribute definition clause node that is
1042    --    generated by a transformation of an at mod phrase in a record
1043    --    representation clause. This is used to give slightly different (Ada 83
1044    --    compatible) semantics to such a clause, namely it is used to specify a
1045    --    minimum acceptable alignment for the base type and all subtypes. In
1046    --    Ada 95 terms, the actual alignment of the base type and all subtypes
1047    --    must be a multiple of the given value, and the representation clause
1048    --    is considered to be type specific instead of subtype specific.
1049
1050    --  From_Default (Flag6-Sem)
1051    --    This flag is set on the subprogram renaming declaration created in an
1052    --    instance for a formal subprogram, when the formal is declared with a
1053    --    box, and there is no explicit actual. If the flag is present, the
1054    --    declaration is treated as an implicit reference to the formal in the
1055    --    ali file.
1056
1057    --  Generic_Parent (Node5-Sem)
1058    --    Generic_Parent is defined on declaration nodes that are instances. The
1059    --    value of Generic_Parent is the generic entity from which the instance
1060    --    is obtained. Generic_Parent is also defined for the renaming
1061    --    declarations and object declarations created for the actuals in an
1062    --    instantiation. The generic parent of such a declaration is the
1063    --    corresponding generic association in the Instantiation node.
1064
1065    --  Generic_Parent_Type (Node4-Sem)
1066    --    Generic_Parent_Type is defined on Subtype_Declaration nodes for the
1067    --    actuals of formal private and derived types. Within the instance, the
1068    --    operations on the actual are those inherited from the parent. For a
1069    --    formal private type, the parent type is the generic type itself. The
1070    --    Generic_Parent_Type is also used in an instance to determine whether a
1071    --    private operation overrides an inherited one.
1072
1073    --  Handler_List_Entry (Node2-Sem)
1074    --    This field is present in N_Object_Declaration nodes. It is set only
1075    --    for the Handler_Record entry generated for an exception in zero cost
1076    --    exception handling mode. It references the corresponding item in the
1077    --    handler list, and is used to delete this entry if the corresponding
1078    --    handler is deleted during optimization. For further details on why
1079    --    this is required, see Exp_Ch11.Remove_Handler_Entries.
1080
1081    --  Has_No_Elaboration_Code (Flag17-Sem)
1082    --    A flag that appears in the N_Compilation_Unit node to indicate whether
1083    --    or not elaboration code is present for this unit. It is initially set
1084    --    true for subprogram specs and bodies and for all generic units and
1085    --    false for non-generic package specs and bodies. Gigi may set the flag
1086    --    in the non-generic package case if it determines that no elaboration
1087    --    code is generated. Note that this flag is not related to the
1088    --    Is_Preelaborated status, there can be preelaborated packages that
1089    --    generate elaboration code, and non-preelaborated packages which do
1090    --    not generate elaboration code.
1091
1092    --  Has_Priority_Pragma (Flag6-Sem)
1093    --    A flag present in N_Subprogram_Body, N_Task_Definition and
1094    --    N_Protected_Definition nodes to flag the presence of either a Priority
1095    --    or Interrupt_Priority pragma in the declaration sequence (public or
1096    --    private in the task and protected cases)
1097
1098    --  Has_Private_View (Flag11-Sem)
1099    --    A flag present in generic nodes that have an entity, to indicate that
1100    --    the node has a private type. Used to exchange private and full
1101    --    declarations if the visibility at instantiation is different from the
1102    --    visibility at generic definition.
1103
1104    --  Has_Relative_Deadline_Pragma (Flag9-Sem)
1105    --    A flag present in N_Subprogram_Body and N_Task_Definition nodes to
1106    --    flag the presence of a pragma Relative_Deadline.
1107
1108    --  Has_Self_Reference (Flag13-Sem)
1109    --    Present in N_Aggregate and N_Extension_Aggregate. Indicates that one
1110    --    of the expressions contains an access attribute reference to the
1111    --    enclosing type. Such a self-reference can only appear in default-
1112    --    initialized aggregate for a record type.
1113
1114    --  Has_Storage_Size_Pragma (Flag5-Sem)
1115    --    A flag present in an N_Task_Definition node to flag the presence of a
1116    --    Storage_Size pragma.
1117
1118    --  Has_Task_Info_Pragma (Flag7-Sem)
1119    --    A flag present in an N_Task_Definition node to flag the presence of a
1120    --    Task_Info pragma. Used to detect duplicate pragmas.
1121
1122    --  Has_Task_Name_Pragma (Flag8-Sem)
1123    --    A flag present in N_Task_Definition nodes to flag the presence of a
1124    --    Task_Name pragma in the declaration sequence for the task.
1125
1126    --  Has_Wide_Character (Flag11-Sem)
1127    --    Present in string literals, set if any wide character (i.e. character
1128    --    code outside the Character range) appears in the string.
1129
1130    --  Hidden_By_Use_Clause (Elist4-Sem)
1131    --     An entity list present in use clauses that appear within
1132    --     instantiations. For the resolution of local entities, entities
1133    --     introduced by these use clauses have priority over global ones, and
1134    --     outer entities must be explicitly hidden/restored on exit.
1135
1136    --  Implicit_With (Flag16-Sem)
1137    --    This flag is set in the N_With_Clause node that is implicitly
1138    --    generated for runtime units that are loaded by the expander, and also
1139    --    for package System, if it is loaded implicitly by a use of the
1140    --    'Address or 'Tag attribute.
1141
1142    --  Includes_Infinities (Flag11-Sem)
1143    --    This flag is present in N_Range nodes. It is set for the range of
1144    --    unconstrained float types defined in Standard, which include not only
1145    --    the given range of values, but also legtitimately can include infinite
1146    --    values. This flag is false for any float type for which an explicit
1147    --    range is given by the programmer, even if that range is identical to
1148    --    the range for Float.
1149
1150    --  Instance_Spec (Node5-Sem)
1151    --    This field is present in generic instantiation nodes, and also in
1152    --    formal package declaration nodes (formal package declarations are
1153    --    treated in a manner very similar to package instantiations). It points
1154    --    to the node for the spec of the instance, inserted as part of the
1155    --    semantic processing for instantiations in Sem_Ch12.
1156
1157    --  Is_Asynchronous_Call_Block (Flag7-Sem)
1158    --    A flag set in a Block_Statement node to indicate that it is the
1159    --    expansion of an asynchronous entry call. Such a block needs cleanup
1160    --    handler to assure that the call is cancelled.
1161
1162    --  Is_Component_Left_Opnd  (Flag13-Sem)
1163    --  Is_Component_Right_Opnd (Flag14-Sem)
1164    --    Present in concatenation nodes, to indicate that the corresponding
1165    --    operand is of the component type of the result. Used in resolving
1166    --    concatenation nodes in instances.
1167
1168    --  Is_Controlling_Actual (Flag16-Sem)
1169    --    This flag is set on in an expression that is a controlling argument in
1170    --    a dispatching call. It is off in all other cases. See Sem_Disp for
1171    --    details of its use.
1172
1173    --  Is_Dynamic_Coextension (Flag18-Sem)
1174    --    Present in allocator nodes, to indicate that this is an allocator
1175    --    for an access discriminant of a dynamically allocated object. The
1176    --    coextension must be deallocated and finalized at the same time as
1177    --    the enclosing object.
1178
1179    --  Is_Entry_Barrier_Function (Flag8-Sem)
1180    --    This flag is set in an N_Subprogram_Body node which is the expansion
1181    --    of an entry barrier from a protected entry body. It is used for the
1182    --    circuitry checking for incorrect use of Current_Task.
1183
1184    --  Is_Expanded_Build_In_Place_Call (Flag11-Sem)
1185    --    This flag is set in an N_Function_Call node to indicate that the extra
1186    --    actuals to support a build-in-place style of call have been added to
1187    --    the call.
1188
1189    --  Is_In_Discriminant_Check (Flag11-Sem)
1190    --    This flag is present in a selected component, and is used to indicate
1191    --    that the reference occurs within a discriminant check. The
1192    --    significance is that optimizations based on assuming that the
1193    --    discriminant check has a correct value cannot be performed in this
1194    --    case (or the disriminant check may be optimized away!)
1195
1196    --  Is_Machine_Number (Flag11-Sem)
1197    --    This flag is set in an N_Real_Literal node to indicate that the value
1198    --    is a machine number. This avoids some unnecessary cases of converting
1199    --    real literals to machine numbers.
1200
1201    --  Is_Null_Loop (Flag16-Sem)
1202    --    This flag is set in an N_Loop_Statement node if the corresponding loop
1203    --    can be determined to be null at compile time. This is used to suppress
1204    --    any warnings that would otherwise be issued inside the loop since they
1205    --    are probably not useful.
1206
1207    --  Is_Overloaded (Flag5-Sem)
1208    --    A flag present in all expression nodes. Used temporarily during
1209    --    overloading determination. The setting of this flag is not relevant
1210    --    once overloading analysis is complete.
1211
1212    --  Is_Power_Of_2_For_Shift (Flag13-Sem)
1213    --    A flag present only in N_Op_Expon nodes. It is set when the
1214    --    exponentiation is of the forma 2 ** N, where the type of N is an
1215    --    unsigned integral subtype whose size does not exceed the size of
1216    --    Standard_Integer (i.e. a type that can be safely converted to
1217    --    Natural), and the exponentiation appears as the right operand of an
1218    --    integer multiplication or an integer division where the dividend is
1219    --    unsigned. It is also required that overflow checking is off for both
1220    --    the exponentiation and the multiply/divide node. If this set of
1221    --    conditions holds, and the flag is set, then the division or
1222    --    multiplication can be (and is) converted to a shift.
1223
1224    --  Is_Protected_Subprogram_Body (Flag7-Sem)
1225    --    A flag set in a Subprogram_Body block to indicate that it is the
1226    --    implemenation of a protected subprogram. Such a body needs cleanup
1227    --    handler to make sure that the associated protected object is unlocked
1228    --    when the subprogram completes.
1229
1230    --  Is_Static_Coextension (Flag14-Sem)
1231    --    Present in N_Allocator nodes. Set if the allocator is a coextension
1232    --    of an object allocated on the stack rather than the heap.
1233
1234    --  Is_Static_Expression (Flag6-Sem)
1235    --    Indicates that an expression is a static expression (RM 4.9). See spec
1236    --    of package Sem_Eval for full details on the use of this flag.
1237
1238    --  Is_Subprogram_Descriptor (Flag16-Sem)
1239    --    Present in N_Object_Declaration, and set only for the object
1240    --    declaration generated for a subprogram descriptor in fast exception
1241    --    mode. See Exp_Ch11 for details of use.
1242
1243    --  Is_Task_Allocation_Block (Flag6-Sem)
1244    --    A flag set in a Block_Statement node to indicate that it is the
1245    --    expansion of a task allocator, or the allocator of an object
1246    --    containing tasks. Such a block requires a cleanup handler to call
1247    --    Expunge_Unactivted_Tasks to complete any tasks that have been
1248    --    allocated but not activated when the allocator completes abnormally.
1249
1250    --  Is_Task_Master (Flag5-Sem)
1251    --    A flag set in a Subprogram_Body, Block_Statement or Task_Body node to
1252    --    indicate that the construct is a task master (i.e. has declared tasks
1253    --    or declares an access to a task type).
1254
1255    --  Itype (Node1-Sem)
1256    --    Used in N_Itype_Reference node to reference an itype for which it is
1257    --    important to ensure that it is defined. See description of this node
1258    --    for further details.
1259
1260    --  Kill_Range_Check (Flag11-Sem)
1261    --    Used in an N_Unchecked_Type_Conversion node to indicate that the
1262    --    result should not be subjected to range checks. This is used for the
1263    --    implementation of Normalize_Scalars.
1264
1265    --  Label_Construct (Node2-Sem)
1266    --    Used in an N_Implicit_Label_Declaration node. Refers to an N_Label,
1267    --    N_Block_Statement or N_Loop_Statement node to which the label
1268    --    declaration applies. This is not currently used in the compiler
1269    --    itself, but it is useful in the implementation of ASIS queries.
1270    --    This field is left empty for the special labels generated as part
1271    --    of expanding raise statements with a local exception handler.
1272
1273    --  Library_Unit (Node4-Sem)
1274    --    In a stub node, Library_Unit points to the compilation unit node of
1275    --    the corresponding subunit.
1276    --
1277    --    In a with clause node, Library_Unit points to the spec of the with'ed
1278    --    unit.
1279    --
1280    --    In a compilation unit node, the usage depends on the unit type:
1281    --
1282    --     For a subprogram body, Library_Unit points to the compilation unit
1283    --     node of the corresponding spec, unless Acts_As_Spec is set, in which
1284    --     case it points to itself.
1285    --
1286    --     For a package body, Library_Unit points to the compilation unit of
1287    --     the corresponding package spec.
1288    --
1289    --     For a subprogram spec to which pragma Inline applies, Library_Unit
1290    --     points to the compilation unit node of the corresponding body, if
1291    --     inlining is active.
1292    --
1293    --     For a generic declaration, Library_Unit points to the compilation
1294    --     unit node of the corresponding generic body.
1295    --
1296    --     For a subunit, Library_Unit points to the compilation unit node of
1297    --     the parent body.
1298    --
1299    --    Note that this field is not used to hold the parent pointer for child
1300    --    unit (which might in any case need to use it for some other purpose as
1301    --    described above). Instead for a child unit, implicit with's are
1302    --    generated for all parents.
1303
1304    --  Local_Raise_Statements (Elist1)
1305    --    This field is present in exception handler nodes. It is set to
1306    --    No_Elist in the normal case. If there is at least one raise statement
1307    --    which can potentially be handled as a local raise, then this field
1308    --    points to a list of raise nodes, which are calls to a routine to raise
1309    --    an exception. These are raise nodes which can be optimized into gotos
1310    --    if the handler turns out to meet the conditions which permit this
1311    --    transformation. Note that this does NOT include instances of the
1312    --    N_Raise_xxx_Error nodes since the transformation of these nodes is
1313    --    handled by the back end (using the N_Push/N_Pop mechanism).
1314
1315    --  Loop_Actions (List2-Sem)
1316    --    A list present in Component_Association nodes in array aggregates.
1317    --    Used to collect actions that must be executed within the loop because
1318    --    they may need to be evaluated anew each time through.
1319
1320    --  Limited_View_Installed (Flag18-Sem)
1321    --    Present in With_Clauses and in package specifications. If set on
1322    --    with_clause, it indicates that this clause has created the current
1323    --    limited view of the designated package. On a package specification, it
1324    --    indicates that the limited view has already been created because the
1325    --    package is mentioned in a limited_with_clause in the closure of the
1326    --    unit being compiled.
1327
1328    --  Local_Raise_Not_OK (Flag7-Sem)
1329    --    Present in N_Exception_Handler nodes. Set if the handler contains
1330    --    a construct (reraise statement, or call to subprogram in package
1331    --    GNAT.Current_Exception) that makes the handler unsuitable as a target
1332    --    for a local raise (one that could otherwise be converted to a goto).
1333
1334    --  Must_Be_Byte_Aligned (Flag14-Sem)
1335    --    This flag is present in N_Attribute_Reference nodes. It can be set
1336    --    only for the Address and Unrestricted_Access attributes. If set it
1337    --    means that the object for which the address/access is given must be on
1338    --    a byte (more accurately a storage unit) boundary. If necessary, a copy
1339    --    of the object is to be made before taking the address (this copy is in
1340    --    the current scope on the stack frame). This is used for certain cases
1341    --    of code generated by the expander that passes parameters by address.
1342    --
1343    --    The reason the copy is not made by the front end is that the back end
1344    --    has more information about type layout and may be able to (but is not
1345    --    guaranteed to) prevent making unnecessary copies.
1346
1347    --  Must_Not_Freeze (Flag8-Sem)
1348    --    A flag present in all expression nodes. Normally expressions cause
1349    --    freezing as described in the RM. If this flag is set, then this is
1350    --    inhibited. This is used by the analyzer and expander to label nodes
1351    --    that are created by semantic analysis or expansion and which must not
1352    --    cause freezing even though they normally would. This flag is also
1353    --    present in an N_Subtype_Indication node, since we also use these in
1354    --    calls to Freeze_Expression.
1355
1356    --  Next_Entity (Node2-Sem)
1357    --    Present in defining identifiers, defining character literals and
1358    --    defining operator symbols (i.e. in all entities). The entities of a
1359    --    scope are chained, and this field is used as the forward pointer for
1360    --    this list. See Einfo for further details.
1361
1362    --  Next_Named_Actual (Node4-Sem)
1363    --    Present in parameter association node. Set during semantic analysis to
1364    --    point to the next named parameter, where parameters are ordered by
1365    --    declaration order (as opposed to the actual order in the call, which
1366    --    may be different due to named associations). Not that this field
1367    --    points to the explicit actual parameter itself, not to the
1368    --    N_Parameter_Association node (its parent).
1369
1370    --  Next_Pragma (Node1-Sem)
1371    --    Present in N_Pragma nodes. Used to create a linked list of pragma
1372    --    nodes. Curently used for two purposes:
1373    --
1374    --      Create a list of linked Check_Policy pragmas. The head of this list
1375    --      is stored in Opt.Check_Policy_List (which has further details).
1376    --
1377    --      Used by processing for Pre/Postcondition pragmas to store a list of
1378    --      pragmas associated with the spec of a subprogram (see Sem_Prag for
1379    --      details).
1380
1381    --  Next_Rep_Item (Node5-Sem)
1382    --    Present in pragma nodes and attribute definition nodes. Used to link
1383    --    representation items that apply to an entity. See description of
1384    --    First_Rep_Item field in Einfo for full details.
1385
1386    --  Next_Use_Clause (Node3-Sem)
1387    --    While use clauses are active during semantic processing, they are
1388    --    chained from the scope stack entry, using Next_Use_Clause as a link
1389    --    pointer, with Empty marking the end of the list. The head pointer is
1390    --    in the scope stack entry (First_Use_Clause). At the end of semantic
1391    --    processing (i.e. when Gigi sees the tree, the contents of this field
1392    --    is undefined and should not be read).
1393
1394    --  No_Ctrl_Actions (Flag7-Sem)
1395    --    Present in N_Assignment_Statement to indicate that no finalize nor nor
1396    --    adjust should take place on this assignment eventhough the rhs is
1397    --    controlled. This is used in init procs and aggregate expansions where
1398    --    the generated assignments are more initialisations than real
1399    --    assignments.
1400
1401    --  No_Elaboration_Check (Flag14-Sem)
1402    --    Present in N_Function_Call and N_Procedure_Call_Statement. Indicates
1403    --    that no elaboration check is needed on the call, because it appears in
1404    --    the context of a local Suppress pragma. This is used on calls within
1405    --    task bodies, where the actual elaboration checks are applied after
1406    --    analysis, when the local scope stack is not present.
1407
1408    --  No_Entities_Ref_In_Spec (Flag8-Sem)
1409    --    Present in N_With_Clause nodes. Set if the with clause is on the
1410    --    package or subprogram spec where the main unit is the corresponding
1411    --    body, and no entities of the with'ed unit are referenced by the spec
1412    --    (an entity may still be referenced in the body, so this flag is used
1413    --    to generate the proper message (see Sem_Util.Check_Unused_Withs for
1414    --    full details)
1415
1416    --  No_Initialization (Flag13-Sem)
1417    --    Present in N_Object_Declaration & N_Allocator to indicate that the
1418    --    object must not be initialized (by Initialize or call to an init
1419    --    proc). This is needed for controlled aggregates. When the Object
1420    --    declaration has an expression, this flag means that this expression
1421    --    should not be taken into account (needed for in place initialization
1422    --    with aggregates)
1423
1424    --  No_Truncation (Flag17-Sem)
1425    --    Present in N_Unchecked_Type_Conversion node. This flag has an effect
1426    --    only if the RM_Size of the source is greater than the RM_Size of the
1427    --    target for scalar operands. Normally in such a case we truncate some
1428    --    higher order bits of the source, and then sign/zero extend the result
1429    --    to form the output value. But if this flag is set, then we do not do
1430    --    any truncation, so for example, if an 8 bit input is converted to 5
1431    --    bit result which is in fact stored in 8 bits, then the high order
1432    --    three bits of the target result will be copied from the source. This
1433    --    is used for properly setting out of range values for use by pragmas
1434    --    Initialize_Scalars and Normalize_Scalars.
1435
1436    --  Original_Discriminant (Node2-Sem)
1437    --    Present in identifiers. Used in references to discriminants that
1438    --    appear in generic units. Because the names of the discriminants may be
1439    --    different in an instance, we use this field to recover the position of
1440    --    the discriminant in the original type, and replace it with the
1441    --    discriminant at the same position in the instantiated type.
1442
1443    --  Original_Entity (Node2-Sem)
1444    --    Present in numeric literals. Used to denote the named number that has
1445    --    been constant-folded into the given literal. If literal is from
1446    --    source, or the result of some other constant-folding operation, then
1447    --    Original_Entity is empty. This field is needed to handle properly
1448    --    named numbers in generic units, where the Associated_Node field
1449    --    interferes with the Entity field, making it impossible to preserve the
1450    --    original entity at the point of instantiation (ASIS problem).
1451
1452    --  Others_Discrete_Choices (List1-Sem)
1453    --    When a case statement or variant is analyzed, the semantic checks
1454    --    determine the actual list of choices that correspond to an others
1455    --    choice. This list is materialized for later use by the expander and
1456    --    the Others_Discrete_Choices field of an N_Others_Choice node points to
1457    --    this materialized list of choices, which is in standard format for a
1458    --    list of discrete choices, except that of course it cannot contain an
1459    --    N_Others_Choice entry.
1460
1461    --  Parameter_List_Truncated (Flag17-Sem)
1462    --    Present in N_Function_Call and N_Procedure_Call_Statement nodes. Set
1463    --    (for OpenVMS ports of GNAT only) if the parameter list is truncated as
1464    --    a result of a First_Optional_Parameter specification in an
1465    --    Import_Function, Import_Procedure, or Import_Valued_Procedure pragma.
1466    --    The truncation is done by the expander by removing trailing parameters
1467    --    from the argument list, in accordance with the set of rules allowing
1468    --    such parameter removal. In particular, parameters can be removed
1469    --    working from the end of the parameter list backwards up to and
1470    --    including the entry designated by First_Optional_Parameter in the
1471    --    Import pragma. Parameters can be removed if they are implicit and the
1472    --    default value is a known-at-compile-time value, including the use of
1473    --    the Null_Parameter attribute, or if explicit parameter values are
1474    --    present that match the corresponding defaults.
1475
1476    --  Parent_Spec (Node4-Sem)
1477    --    For a library unit that is a child unit spec (package or subprogram
1478    --    declaration, generic declaration or instantiation, or library level
1479    --    rename, this field points to the compilation unit node for the parent
1480    --    package specification. This field is Empty for library bodies (the
1481    --    parent spec in this case can be found from the corresponding spec).
1482
1483    --  PPC_Enabled (Flag5-Sem)
1484    --    Present in N_Pragma nodes. This flag is relevant only for precondition
1485    --    and postcondition nodes. It is true if the check corresponding to the
1486    --    pragma type is enabled at the point where the pragma appears.
1487
1488    --  Present_Expr (Uint3-Sem)
1489    --    Present in an N_Variant node. This has a meaningful value only after
1490    --    Gigi has back annotated the tree with representation information. At
1491    --    this point, it contains a reference to a gcc expression that depends
1492    --    on the values of one or more discriminants. Give a set of discriminant
1493    --    values, this expression evaluates to False (zero) if variant is not
1494    --    present, and True (non-zero) if it is present. See unit Repinfo for
1495    --    further details on gigi back annotation. This field is used during
1496    --    ASIS processing (data decomposition annex) to determine if a field is
1497    --    present or not.
1498
1499    --  Print_In_Hex (Flag13-Sem)
1500    --    Set on an N_Integer_Literal node to indicate that the value should be
1501    --    printed in hexadecimal in the sprint listing. Has no effect on
1502    --    legality or semantics of program, only on the displayed output. This
1503    --    is used to clarify output from the packed array cases.
1504
1505    --  Procedure_To_Call (Node2-Sem)
1506    --    Present in N_Allocator, N_Free_Statement, N_Simple_Return_Statement,
1507    --    and N_Extended_Return_Statement nodes. References the entity for the
1508    --    declaration of the procedure to be called to accomplish the required
1509    --    operation (i.e. for the Allocate procedure in the case of N_Allocator
1510    --    and N_Simple_Return_Statement and N_Extended_Return_Statement (for
1511    --    allocating the return value), and for the Deallocate procedure in the
1512    --    case of N_Free_Statement.
1513
1514    --  Raises_Constraint_Error (Flag7-Sem)
1515    --    Set on an expression whose evaluation will definitely fail constraint
1516    --    error check. In the case of static expressions, this flag must be set
1517    --    accurately (and if it is set, the expression is typically illegal
1518    --    unless it appears as a non-elaborated branch of a short-circuit form).
1519    --    For a non-static expression, this flag may be set whenever an
1520    --    expression (e.g. an aggregate) is known to raise constraint error. If
1521    --    set, the expression definitely will raise CE if elaborated at runtime.
1522    --    If not set, the expression may or may not raise CE. In other words, on
1523    --    static expressions, the flag is set accurately, on non-static
1524    --    expressions it is set conservatively.
1525
1526    --  Redundant_Use (Flag13-Sem)
1527    --    Present in nodes that can appear as an operand in a use clause or use
1528    --    type clause (identifiers, expanded names, attribute references). Set
1529    --    to indicate that a use is redundant (and therefore need not be undone
1530    --    on scope exit).
1531
1532    --  Renaming_Exception (Node2-Sem)
1533    --    Present in N_Exception_Declaration node. Used to point back to the
1534    --    exception renaming for an exception declared within a subprogram.
1535    --    What happens is that an exception declared in a subprogram is moved
1536    --    to the library level with a unique name, and the original exception
1537    --    becomes a renaming. This link from the library level exception to the
1538    --    renaming declaration allows registering of the proper exception name.
1539
1540    --  Return_Statement_Entity (Node5-Sem)
1541    --    Present in N_Simple_Return_Statement and N_Extended_Return_Statement.
1542    --    Points to an E_Return_Statement representing the return statement.
1543
1544    --  Return_Object_Declarations (List3)
1545    --    Present in N_Extended_Return_Statement.
1546    --    Points to a list initially containing a single
1547    --    N_Object_Declaration representing the return object.
1548    --    We use a list (instead of just a pointer to the object decl)
1549    --    because Analyze wants to insert extra actions on this list.
1550
1551    --  Rounded_Result (Flag18-Sem)
1552    --    Present in N_Type_Conversion, N_Op_Divide and N_Op_Multiply nodes.
1553    --    Used in the fixed-point cases to indicate that the result must be
1554    --    rounded as a result of the use of the 'Round attribute. Also used for
1555    --    integer N_Op_Divide nodes to indicate that the result should be
1556    --    rounded to the nearest integer (breaking ties away from zero), rather
1557    --    than truncated towards zero as usual. These rounded integer operations
1558    --    are the result of expansion of rounded fixed-point divide, conversion
1559    --    and multiplication operations.
1560
1561    --  Scope (Node3-Sem)
1562    --    Present in defining identifiers, defining character literals and
1563    --    defining operator symbols (i.e. in all entities). The entities of a
1564    --    scope all use this field to reference the corresponding scope entity.
1565    --    See Einfo for further details.
1566
1567    --  Shift_Count_OK (Flag4-Sem)
1568    --    A flag present in shift nodes to indicate that the shift count is
1569    --    known to be in range, i.e. is in the range from zero to word length
1570    --    minus one. If this flag is not set, then the shift count may be
1571    --    outside this range, i.e. larger than the word length, and the code
1572    --    must ensure that such shift counts give the appropriate result.
1573
1574    --  Source_Type (Node1-Sem)
1575    --    Used in an N_Validate_Unchecked_Conversion node to point to the
1576    --    source type entity for the unchecked conversion instantiation
1577    --    which gigi must do size validation for.
1578
1579    --  Static_Processing_OK (Flag4-Sem)
1580    --    Present in N_Aggregate nodes. When the Compile_Time_Known_Aggregate
1581    --    flag is set, the full value of the aggregate can be determined at
1582    --    compile time and the aggregate can be passed as is to the back-end.
1583    --    In this event it is irrelevant whether this flag is set or not.
1584    --    However, if the flag Compile_Time_Known_Aggregate is not set but
1585    --    Static_Processing_OK is set, the aggregate can (but need not) be
1586    --    converted into a compile time known aggregate by the expander. See
1587    --    Sem_Aggr for the specific conditions under which an aggregate has its
1588    --    Static_Processing_OK flag set.
1589
1590    --  Storage_Pool (Node1-Sem)
1591    --    Present in N_Allocator, N_Free_Statement, N_Simple_Return_Statement,
1592    --    and N_Extended_Return_Statement nodes. References the entity for the
1593    --    storage pool to be used for the allocate or free call or for the
1594    --    allocation of the returned value from function. Empty indicates that
1595    --    the global default default pool is to be used. Note that in the case
1596    --    of a return statement, this field is set only if the function returns
1597    --    value of a type whose size is not known at compile time on the
1598    --    secondary stack.
1599
1600    --  Target_Type (Node2-Sem)
1601    --    Used in an N_Validate_Unchecked_Conversion node to point to the target
1602    --    type entity for the unchecked conversion instantiation which gigi must
1603    --    do size validation for.
1604
1605    --  Then_Actions (List3-Sem)
1606    --    This field is present in conditional expression nodes. During code
1607    --    expansion we use the Insert_Actions procedure (in Exp_Util) to insert
1608    --    actions at an appropriate place in the tree to get elaborated at the
1609    --    right time. For conditional expressions, we have to be sure that the
1610    --    actions for the Then branch are only elaborated if the condition is
1611    --    True. The Then_Actions field is used as a temporary parking place for
1612    --    these actions. The final tree is always rewritten to eliminate the
1613    --    need for this field, so in the tree passed to Gigi, this field is
1614    --    always set to No_List.
1615
1616    --  Treat_Fixed_As_Integer (Flag14-Sem)
1617    --    This flag appears in operator nodes for divide, multiply, mod and rem
1618    --    on fixed-point operands. It indicates that the operands are to be
1619    --    treated as integer values, ignoring small values. This flag is only
1620    --    set as a result of expansion of fixed-point operations. Typically a
1621    --    fixed-point multplication in the source generates subsidiary
1622    --    multiplication and division operations that work with the underlying
1623    --    integer values and have this flag set. Note that this flag is not
1624    --    needed on other arithmetic operations (add, neg, subtract etc) since
1625    --    in these cases it is always the case that fixed is treated as integer.
1626    --    The Etype field MUST be set if this flag is set. The analyzer knows to
1627    --    leave such nodes alone, and whoever makes them must set the correct
1628    --    Etype value.
1629
1630    --  TSS_Elist (Elist3-Sem)
1631    --    Present in N_Freeze_Entity nodes. Holds an element list containing
1632    --    entries for each TSS (type support subprogram) associated with the
1633    --    frozen type. The elements of the list are the entities for the
1634    --    subprograms (see package Exp_TSS for further details). Set to No_Elist
1635    --    if there are no type support subprograms for the type or if the freeze
1636    --    node is not for a type.
1637
1638    --  Unreferenced_In_Spec (Flag7-Sem)
1639    --    Present in N_With_Clause nodes. Set if the with clause is on the
1640    --    package or subprogram spec where the main unit is the corresponding
1641    --    body, and is not referenced by the spec (it may still be referenced by
1642    --    the body, so this flag is used to generate the proper message (see
1643    --    Sem_Util.Check_Unused_Withs for details)
1644
1645    --  Was_Originally_Stub (Flag13-Sem)
1646    --    This flag is set in the node for a proper body that replaces stub.
1647    --    During the analysis procedure, stubs in some situations get rewritten
1648    --    by the corresponding bodies, and we set this flag to remember that
1649    --    this happened. Note that it is not good enough to rely on the use of
1650    --    Original_Node here because of the case of nested instantiations where
1651    --    the substituted node can be copied.
1652
1653    --  Zero_Cost_Handling (Flag5-Sem)
1654    --    This flag is set in all handled sequence of statement and exception
1655    --    handler nodes if eceptions are to be handled using the zero-cost
1656    --    mechanism (see Ada.Exceptions and System.Exceptions in files
1657    --    a-except.ads/adb and s-except.ads for full details). What gigi needs
1658    --    to do for such a handler is simply to put the code in the handler
1659    --    somewhere. The front end has generated all necessary labels.
1660
1661    --------------------------------------------------
1662    -- Note on Use of End_Label and End_Span Fields --
1663    --------------------------------------------------
1664
1665    --  Several constructs have end lines:
1666
1667    --    Loop Statement             end loop [loop_IDENTIFIER];
1668    --    Package Specification      end [[PARENT_UNIT_NAME .] IDENTIFIER]
1669    --    Task Definition            end [task_IDENTIFIER]
1670    --    Protected Definition       end [protected_IDENTIFIER]
1671    --    Protected Body             end [protected_IDENTIFIER]
1672
1673    --    Block Statement            end [block_IDENTIFIER];
1674    --    Subprogram Body            end [DESIGNATOR];
1675    --    Package Body               end [[PARENT_UNIT_NAME .] IDENTIFIER];
1676    --    Task Body                  end [task_IDENTIFIER];
1677    --    Accept Statement           end [entry_IDENTIFIER]];
1678    --    Entry Body                 end [entry_IDENTIFIER];
1679
1680    --    If Statement               end if;
1681    --    Case Statement             end case;
1682
1683    --    Record Definition          end record;
1684    --    Enumeration Definition     );
1685
1686    --  The End_Label and End_Span fields are used to mark the locations of
1687    --  these lines, and also keep track of the label in the case where a label
1688    --  is present.
1689
1690    --  For the first group above, the End_Label field of the corresponding node
1691    --  is used to point to the label identifier. In the case where there is no
1692    --  label in the source, the parser supplies a dummy identifier (with
1693    --  Comes_From_Source set to False), and the Sloc of this dummy identifier
1694    --  marks the location of the token following the END token.
1695
1696    --  For the second group, the use of End_Label is similar, but the End_Label
1697    --  is found in the N_Handled_Sequence_Of_Statements node. This is done
1698    --  simply because in some cases there is no room in the parent node.
1699
1700    --  For the third group, there is never any label, and instead of using
1701    --  End_Label, we use the End_Span field which gives the location of the
1702    --  token following END, relative to the starting Sloc of the construct,
1703    --  i.e. add Sloc (Node) + End_Span (Node) to get the Sloc of the IF or CASE
1704    --  following the End_Label.
1705
1706    --  The record definition case is handled specially, we treat it as though
1707    --  it required an optional label which is never present, and so the parser
1708    --  always builds a dummy identifier with Comes From Source set False. The
1709    --  reason we do this, rather than using End_Span in this case, is that we
1710    --  want to generate a cross-ref entry for the end of a record, since it
1711    --  represents a scope for name declaration purposes.
1712
1713    --  The enumeration definition case is handled in an exactly similar manner,
1714    --  building a dummy identifier to get a cross-reference.
1715
1716    --  Note: the reason we store the difference as a Uint, instead of storing
1717    --  the Source_Ptr value directly, is that Source_Ptr values cannot be
1718    --  distinguished from other types of values, and we count on all general
1719    --  use fields being self describing. To make things easier for clients,
1720    --  note that we provide function End_Location, and procedure
1721    --  Set_End_Location to allow access to the logical value (which is the
1722    --  Source_Ptr value for the end token).
1723
1724    ---------------------
1725    -- Syntactic Nodes --
1726    ---------------------
1727
1728       ---------------------
1729       -- 2.3  Identifier --
1730       ---------------------
1731
1732       --  IDENTIFIER ::= IDENTIFIER_LETTER {[UNDERLINE] LETTER_OR_DIGIT}
1733       --  LETTER_OR_DIGIT ::= IDENTIFIER_LETTER | DIGIT
1734
1735       --  An IDENTIFIER shall not be a reserved word
1736
1737       --  In the Ada grammar identifiers are the bottom level tokens which have
1738       --  very few semantics. Actual program identifiers are direct names. If
1739       --  we were being 100% honest with the grammar, then we would have a node
1740       --  called N_Direct_Name which would point to an identifier. However,
1741       --  that's too many extra nodes, so we just use the N_Identifier node
1742       --  directly as a direct name, and it contains the expression fields and
1743       --  Entity field that correspond to its use as a direct name. In those
1744       --  few cases where identifiers appear in contexts where they are not
1745       --  direct names (pragmas, pragma argument associations, attribute
1746       --  references and attribute definition clauses), the Chars field of the
1747       --  node contains the Name_Id for the identifier name.
1748
1749       --  Note: in GNAT, a reserved word can be treated as an identifier in two
1750       --  cases. First, an incorrect use of a reserved word as an identifier is
1751       --  diagnosed and then treated as a normal identifier. Second, an
1752       --  attribute designator of the form of a reserved word (access, delta,
1753       --  digits, range) is treated as an identifier.
1754
1755       --  Note: The set of letters that is permitted in an identifier depends
1756       --  on the character set in use. See package Csets for full details.
1757
1758       --  N_Identifier
1759       --  Sloc points to identifier
1760       --  Chars (Name1) contains the Name_Id for the identifier
1761       --  Entity (Node4-Sem)
1762       --  Associated_Node (Node4-Sem)
1763       --  Original_Discriminant (Node2-Sem)
1764       --  Redundant_Use (Flag13-Sem)
1765       --  Has_Private_View (Flag11-Sem) (set in generic units)
1766       --  plus fields for expression
1767
1768       --------------------------
1769       -- 2.4  Numeric Literal --
1770       --------------------------
1771
1772       --  NUMERIC_LITERAL ::= DECIMAL_LITERAL | BASED_LITERAL
1773
1774       ----------------------------
1775       -- 2.4.1  Decimal Literal --
1776       ----------------------------
1777
1778       --  DECIMAL_LITERAL ::= NUMERAL [.NUMERAL] [EXPONENT]
1779
1780       --  NUMERAL ::= DIGIT {[UNDERLINE] DIGIT}
1781
1782       --  EXPONENT ::= E [+] NUMERAL | E - NUMERAL
1783
1784       --  Decimal literals appear in the tree as either integer literal nodes
1785       --  or real literal nodes, depending on whether a period is present.
1786
1787       --  Note: literal nodes appear as a result of direct use of literals
1788       --  in the source program, and also as the result of evaluating
1789       --  expressions at compile time. In the latter case, it is possible
1790       --  to construct real literals that have no syntactic representation
1791       --  using the standard literal format. Such literals are listed by
1792       --  Sprint using the notation [numerator / denominator].
1793
1794       --  Note: the value of an integer literal node created by the front end
1795       --  is never outside the range of values of the base type. However, it
1796       --  can be the case that the value is outside the range of the
1797       --  particular subtype. This happens in the case of integer overflows
1798       --  with checks suppressed.
1799
1800       --  N_Integer_Literal
1801       --  Sloc points to literal
1802       --  Original_Entity (Node2-Sem) If not Empty, holds Named_Number that
1803       --  has been constant-folded into its literal value.
1804       --  Intval (Uint3) contains integer value of literal
1805       --  plus fields for expression
1806       --  Print_In_Hex (Flag13-Sem)
1807
1808       --  N_Real_Literal
1809       --  Sloc points to literal
1810       --  Original_Entity (Node2-Sem) If not Empty, holds Named_Number that
1811       --  has been constant-folded into its literal value.
1812       --  Realval (Ureal3) contains real value of literal
1813       --  Corresponding_Integer_Value (Uint4-Sem)
1814       --  Is_Machine_Number (Flag11-Sem)
1815       --  plus fields for expression
1816
1817       --------------------------
1818       -- 2.4.2  Based Literal --
1819       --------------------------
1820
1821       --  BASED_LITERAL ::=
1822       --   BASE # BASED_NUMERAL [.BASED_NUMERAL] # [EXPONENT]
1823
1824       --  BASE ::= NUMERAL
1825
1826       --  BASED_NUMERAL ::=
1827       --    EXTENDED_DIGIT {[UNDERLINE] EXTENDED_DIGIT}
1828
1829       --  EXTENDED_DIGIT ::= DIGIT | A | B | C | D | E | F
1830
1831       --  Based literals appear in the tree as either integer literal nodes
1832       --  or real literal nodes, depending on whether a period is present.
1833
1834       ----------------------------
1835       -- 2.5  Character Literal --
1836       ----------------------------
1837
1838       --  CHARACTER_LITERAL ::= ' GRAPHIC_CHARACTER '
1839
1840       --  N_Character_Literal
1841       --  Sloc points to literal
1842       --  Chars (Name1) contains the Name_Id for the identifier
1843       --  Char_Literal_Value (Uint2) contains the literal value
1844       --  Entity (Node4-Sem)
1845       --  Associated_Node (Node4-Sem)
1846       --  Has_Private_View (Flag11-Sem) set in generic units.
1847       --  plus fields for expression
1848
1849       --  Note: the Entity field will be missing (set to Empty) for character
1850       --  literals whose type is Standard.Wide_Character or Standard.Character
1851       --  or a type derived from one of these two. In this case the character
1852       --  literal stands for its own coding. The reason we take this irregular
1853       --  short cut is to avoid the need to build lots of junk defining
1854       --  character literal nodes.
1855
1856       -------------------------
1857       -- 2.6  String Literal --
1858       -------------------------
1859
1860       --  STRING LITERAL ::= "{STRING_ELEMENT}"
1861
1862       --  A STRING_ELEMENT is either a pair of quotation marks ("), or a
1863       --  single GRAPHIC_CHARACTER other than a quotation mark.
1864       --
1865       --  Is_Folded_In_Parser is True if the parser created this literal by
1866       --  folding a sequence of "&" operators. For example, if the source code
1867       --  says "aaa" & "bbb" & "ccc", and this produces "aaabbbccc", the flag
1868       --  is set. This flag is needed because the parser doesn't know about
1869       --  visibility, so the folded result might be wrong, and semantic
1870       --  analysis needs to check for that.
1871
1872       --  N_String_Literal
1873       --  Sloc points to literal
1874       --  Strval (Str3) contains Id of string value
1875       --  Has_Wide_Character (Flag11-Sem)
1876       --  Is_Folded_In_Parser (Flag4)
1877       --  plus fields for expression
1878
1879       ------------------
1880       -- 2.7  Comment --
1881       ------------------
1882
1883       --  A COMMENT starts with two adjacent hyphens and extends up to the
1884       --  end of the line. A COMMENT may appear on any line of a program.
1885
1886       --  Comments are skipped by the scanner and do not appear in the tree.
1887       --  It is possible to reconstruct the position of comments with respect
1888       --  to the elements of the tree by using the source position (Sloc)
1889       --  pointers that appear in every tree node.
1890
1891       -----------------
1892       -- 2.8  Pragma --
1893       -----------------
1894
1895       --  PRAGMA ::= pragma IDENTIFIER
1896       --    [(PRAGMA_ARGUMENT_ASSOCIATION {, PRAGMA_ARGUMENT_ASSOCIATION})];
1897
1898       --  Note that a pragma may appear in the tree anywhere a declaration
1899       --  or a statement may appear, as well as in some other situations
1900       --  which are explicitly documented.
1901
1902       --  N_Pragma
1903       --  Sloc points to pragma identifier
1904       --  Next_Pragma (Node1-Sem)
1905       --  Pragma_Argument_Associations (List2) (set to No_List if none)
1906       --  Debug_Statement (Node3) (set to Empty if not Debug, Assert)
1907       --  Pragma_Identifier (Node4)
1908       --  Next_Rep_Item (Node5-Sem)
1909       --  PPC_Enabled (Flag5-Sem)
1910
1911       --  Note: we should have a section on what pragmas are passed on to
1912       --  the back end to be processed. This section should note that pragma
1913       --  Psect_Object is always converted to Common_Object, but there are
1914       --  undoubtedly many other similar notes required ???
1915
1916       --  Note: a utility function Pragma_Name may be applied to pragma nodes
1917       --  to conveniently obtain the Chars field of the Pragma_Identifier.
1918
1919       --------------------------------------
1920       -- 2.8  Pragma Argument Association --
1921       --------------------------------------
1922
1923       --  PRAGMA_ARGUMENT_ASSOCIATION ::=
1924       --    [pragma_argument_IDENTIFIER =>] NAME
1925       --  | [pragma_argument_IDENTIFIER =>] EXPRESSION
1926
1927       --  N_Pragma_Argument_Association
1928       --  Sloc points to first token in association
1929       --  Chars (Name1) (set to No_Name if no pragma argument identifier)
1930       --  Expression (Node3)
1931
1932       ------------------------
1933       -- 2.9  Reserved Word --
1934       ------------------------
1935
1936       --  Reserved words are parsed by the scanner, and returned as the
1937       --  corresponding token types (e.g. PACKAGE is returned as Tok_Package)
1938
1939       ----------------------------
1940       -- 3.1  Basic Declaration --
1941       ----------------------------
1942
1943       --  BASIC_DECLARATION ::=
1944       --    TYPE_DECLARATION          | SUBTYPE_DECLARATION
1945       --  | OBJECT_DECLARATION        | NUMBER_DECLARATION
1946       --  | SUBPROGRAM_DECLARATION    | ABSTRACT_SUBPROGRAM_DECLARATION
1947       --  | PACKAGE_DECLARATION       | RENAMING_DECLARATION
1948       --  | EXCEPTION_DECLARATION     | GENERIC_DECLARATION
1949       --  | GENERIC_INSTANTIATION
1950
1951       --  Basic declaration also includes IMPLICIT_LABEL_DECLARATION
1952       --  see further description in section on semantic nodes.
1953
1954       --  Also, in the tree that is constructed, a pragma may appear
1955       --  anywhere that a declaration may appear.
1956
1957       ------------------------------
1958       -- 3.1  Defining Identifier --
1959       ------------------------------
1960
1961       --  DEFINING_IDENTIFIER ::= IDENTIFIER
1962
1963       --  A defining identifier is an entity, which has additional fields
1964       --  depending on the setting of the Ekind field. These additional
1965       --  fields are defined (and access subprograms declared) in package
1966       --  Einfo.
1967
1968       --  Note: N_Defining_Identifier is an extended node whose fields are
1969       --  deliberate layed out to match the layout of fields in an ordinary
1970       --  N_Identifier node allowing for easy alteration of an identifier
1971       --  node into a defining identifier node. For details, see procedure
1972       --  Sinfo.CN.Change_Identifier_To_Defining_Identifier.
1973
1974       --  N_Defining_Identifier
1975       --  Sloc points to identifier
1976       --  Chars (Name1) contains the Name_Id for the identifier
1977       --  Next_Entity (Node2-Sem)
1978       --  Scope (Node3-Sem)
1979       --  Etype (Node5-Sem)
1980
1981       -----------------------------
1982       -- 3.2.1  Type Declaration --
1983       -----------------------------
1984
1985       --  TYPE_DECLARATION ::=
1986       --    FULL_TYPE_DECLARATION
1987       --  | INCOMPLETE_TYPE_DECLARATION
1988       --  | PRIVATE_TYPE_DECLARATION
1989       --  | PRIVATE_EXTENSION_DECLARATION
1990
1991       ----------------------------------
1992       -- 3.2.1  Full Type Declaration --
1993       ----------------------------------
1994
1995       --  FULL_TYPE_DECLARATION ::=
1996       --    type DEFINING_IDENTIFIER [KNOWN_DISCRIMINANT_PART]
1997       --      is TYPE_DEFINITION;
1998       --  | TASK_TYPE_DECLARATION
1999       --  | PROTECTED_TYPE_DECLARATION
2000
2001       --  The full type declaration node is used only for the first case. The
2002       --  second case (concurrent type declaration), is represented directly
2003       --  by a task type declaration or a protected type declaration.
2004
2005       --  N_Full_Type_Declaration
2006       --  Sloc points to TYPE
2007       --  Defining_Identifier (Node1)
2008       --  Discriminant_Specifications (List4) (set to No_List if none)
2009       --  Type_Definition (Node3)
2010       --  Discr_Check_Funcs_Built (Flag11-Sem)
2011
2012       ----------------------------
2013       -- 3.2.1  Type Definition --
2014       ----------------------------
2015
2016       --  TYPE_DEFINITION ::=
2017       --    ENUMERATION_TYPE_DEFINITION  | INTEGER_TYPE_DEFINITION
2018       --  | REAL_TYPE_DEFINITION         | ARRAY_TYPE_DEFINITION
2019       --  | RECORD_TYPE_DEFINITION       | ACCESS_TYPE_DEFINITION
2020       --  | DERIVED_TYPE_DEFINITION      | INTERFACE_TYPE_DEFINITION
2021
2022       --------------------------------
2023       -- 3.2.2  Subtype Declaration --
2024       --------------------------------
2025
2026       --  SUBTYPE_DECLARATION ::=
2027       --    subtype DEFINING_IDENTIFIER is [NULL_EXCLUSION] SUBTYPE_INDICATION;
2028
2029       --  The subtype indication field is set to Empty for subtypes
2030       --  declared in package Standard (Positive, Natural).
2031
2032       --  N_Subtype_Declaration
2033       --  Sloc points to SUBTYPE
2034       --  Defining_Identifier (Node1)
2035       --  Null_Exclusion_Present (Flag11)
2036       --  Subtype_Indication (Node5)
2037       --  Generic_Parent_Type (Node4-Sem) (set for an actual derived type).
2038       --  Exception_Junk (Flag8-Sem)
2039
2040       -------------------------------
2041       -- 3.2.2  Subtype Indication --
2042       -------------------------------
2043
2044       --  SUBTYPE_INDICATION ::= SUBTYPE_MARK [CONSTRAINT]
2045
2046       --  Note: if no constraint is present, the subtype indication appears
2047       --  directly in the tree as a subtype mark. The N_Subtype_Indication
2048       --  node is used only if a constraint is present.
2049
2050       --  Note: [For Ada 2005 (AI-231)]: Because Ada 2005 extends this rule
2051       --  with the null-exclusion part (see AI-231), we had to introduce a new
2052       --  attribute in all the parents of subtype_indication nodes to indicate
2053       --  if the null-exclusion is present.
2054
2055       --  Note: the reason that this node has expression fields is that a
2056       --  subtype indication can appear as an operand of a membership test.
2057
2058       --  N_Subtype_Indication
2059       --  Sloc points to first token of subtype mark
2060       --  Subtype_Mark (Node4)
2061       --  Constraint (Node3)
2062       --  Etype (Node5-Sem)
2063       --  Must_Not_Freeze (Flag8-Sem)
2064
2065       --  Note: Etype is a copy of the Etype field of the Subtype_Mark. The
2066       --  reason for this redundancy is so that in a list of array index types,
2067       --  the Etype can be uniformly accessed to determine the subscript type.
2068       --  This means that no Itype is constructed for the actual subtype that
2069       --  is created by the subtype indication. If such an Itype is required,
2070       --  it is constructed in the context in which the indication appears.
2071
2072       -------------------------
2073       -- 3.2.2  Subtype Mark --
2074       -------------------------
2075
2076       --  SUBTYPE_MARK ::= subtype_NAME
2077
2078       -----------------------
2079       -- 3.2.2  Constraint --
2080       -----------------------
2081
2082       --  CONSTRAINT ::= SCALAR_CONSTRAINT | COMPOSITE_CONSTRAINT
2083
2084       ------------------------------
2085       -- 3.2.2  Scalar Constraint --
2086       ------------------------------
2087
2088       --  SCALAR_CONSTRAINT ::=
2089       --    RANGE_CONSTRAINT | DIGITS_CONSTRAINT | DELTA_CONSTRAINT
2090
2091       ---------------------------------
2092       -- 3.2.2  Composite Constraint --
2093       ---------------------------------
2094
2095       --  COMPOSITE_CONSTRAINT ::=
2096       --    INDEX_CONSTRAINT | DISCRIMINANT_CONSTRAINT
2097
2098       -------------------------------
2099       -- 3.3.1  Object Declaration --
2100       -------------------------------
2101
2102       --  OBJECT_DECLARATION ::=
2103       --    DEFINING_IDENTIFIER_LIST : [aliased] [constant]
2104       --      [NULL_EXCLUSION] SUBTYPE_INDICATION [:= EXPRESSION];
2105       --  | DEFINING_IDENTIFIER_LIST : [aliased] [constant]
2106       --      ACCESS_DEFINITION [:= EXPRESSION];
2107       --  | DEFINING_IDENTIFIER_LIST : [aliased] [constant]
2108       --      ARRAY_TYPE_DEFINITION [:= EXPRESSION];
2109       --  | SINGLE_TASK_DECLARATION
2110       --  | SINGLE_PROTECTED_DECLARATION
2111
2112       --  Note: aliased is not permitted in Ada 83 mode
2113
2114       --  The N_Object_Declaration node is only for the first two cases.
2115       --  Single task declaration is handled by P_Task (9.1)
2116       --  Single protected declaration is handled by P_protected (9.5)
2117
2118       --  Although the syntax allows multiple identifiers in the list, the
2119       --  semantics is as though successive declarations were given with
2120       --  identical type definition and expression components. To simplify
2121       --  semantic processing, the parser represents a multiple declaration
2122       --  case as a sequence of single declarations, using the More_Ids and
2123       --  Prev_Ids flags to preserve the original source form as described
2124       --  in the section on "Handling of Defining Identifier Lists".
2125
2126       --  The flag Has_Init_Expression is set if an initializing expression
2127       --  is present. Normally it is set if and only if Expression contains
2128       --  a non-empty value, but there is an exception to this. When the
2129       --  initializing expression is an aggregate which requires explicit
2130       --  assignments, the Expression field gets set to Empty, but this flag
2131       --  is still set, so we don't forget we had an initializing expression.
2132
2133       --  Note: if a range check is required for the initialization
2134       --  expression then the Do_Range_Check flag is set in the Expression,
2135       --  with the check being done against the type given by the object
2136       --  definition, which is also the Etype of the defining identifier.
2137
2138       --  Note: the contents of the Expression field must be ignored (i.e.
2139       --  treated as though it were Empty) if No_Initialization is set True.
2140
2141       --  Note: the back end places some restrictions on the form of the
2142       --  Expression field. If the object being declared is Atomic, then
2143       --  the Expression may not have the form of an aggregate (since this
2144       --  might cause the back end to generate separate assignments). It
2145       --  also cannot be a reference to an object marked as a true constant
2146       --  (Is_True_Constant flag set), where the object is itself initalized
2147       --  with an aggregate. If necessary the front end must generate an
2148       --  extra temporary (with Is_True_Constant set False), and initialize
2149       --  this temporary as required (the temporary itself is not atomic).
2150
2151       --  Note: there is not node kind for object definition. Instead, the
2152       --  corresponding field holds a subtype indication, an array type
2153       --  definition, or (Ada 2005, AI-406) an access definition.
2154
2155       --  N_Object_Declaration
2156       --  Sloc points to first identifier
2157       --  Defining_Identifier (Node1)
2158       --  Aliased_Present (Flag4) set if ALIASED appears
2159       --  Constant_Present (Flag17) set if CONSTANT appears
2160       --  Null_Exclusion_Present (Flag11)
2161       --  Object_Definition (Node4) subtype indic./array type def./ access def.
2162       --  Expression (Node3) (set to Empty if not present)
2163       --  Handler_List_Entry (Node2-Sem)
2164       --  Corresponding_Generic_Association (Node5-Sem)
2165       --  More_Ids (Flag5) (set to False if no more identifiers in list)
2166       --  Prev_Ids (Flag6) (set to False if no previous identifiers in list)
2167       --  No_Initialization (Flag13-Sem)
2168       --  Assignment_OK (Flag15-Sem)
2169       --  Exception_Junk (Flag8-Sem)
2170       --  Is_Subprogram_Descriptor (Flag16-Sem)
2171       --  Has_Init_Expression (Flag14)
2172
2173       -------------------------------------
2174       -- 3.3.1  Defining Identifier List --
2175       -------------------------------------
2176
2177       --  DEFINING_IDENTIFIER_LIST ::=
2178       --    DEFINING_IDENTIFIER {, DEFINING_IDENTIFIER}
2179
2180       -------------------------------
2181       -- 3.3.2  Number Declaration --
2182       -------------------------------
2183
2184       --  NUMBER_DECLARATION ::=
2185       --    DEFINING_IDENTIFIER_LIST : constant := static_EXPRESSION;
2186
2187       --  Although the syntax allows multiple identifiers in the list, the
2188       --  semantics is as though successive declarations were given with
2189       --  identical expressions. To simplify semantic processing, the parser
2190       --  represents a multiple declaration case as a sequence of single
2191       --  declarations, using the More_Ids and Prev_Ids flags to preserve
2192       --  the original source form as described in the section on "Handling
2193       --  of Defining Identifier Lists".
2194
2195       --  N_Number_Declaration
2196       --  Sloc points to first identifier
2197       --  Defining_Identifier (Node1)
2198       --  Expression (Node3)
2199       --  More_Ids (Flag5) (set to False if no more identifiers in list)
2200       --  Prev_Ids (Flag6) (set to False if no previous identifiers in list)
2201
2202       ----------------------------------
2203       -- 3.4  Derived Type Definition --
2204       ----------------------------------
2205
2206       --  DERIVED_TYPE_DEFINITION ::=
2207       --    [abstract] [limited] new [NULL_EXCLUSION] parent_SUBTYPE_INDICATION
2208       --    [[and INTERFACE_LIST] RECORD_EXTENSION_PART]
2209
2210       --  Note: ABSTRACT, LIMITED and record extension part are not permitted
2211       --  in Ada 83 mode
2212
2213       --  Note: a record extension part is required if ABSTRACT is present
2214
2215       --  N_Derived_Type_Definition
2216       --  Sloc points to NEW
2217       --  Abstract_Present (Flag4)
2218       --  Null_Exclusion_Present (Flag11) (set to False if not present)
2219       --  Subtype_Indication (Node5)
2220       --  Record_Extension_Part (Node3) (set to Empty if not present)
2221       --  Limited_Present (Flag17)
2222       --  Task_Present (Flag5) set in task interfaces
2223       --  Protected_Present (Flag6) set in protected interfaces
2224       --  Synchronized_Present (Flag7) set in interfaces
2225       --  Interface_List (List2) (set to No_List if none)
2226       --  Interface_Present (Flag16) set in abstract interfaces
2227
2228       --  Note: Task_Present, Protected_Present, Synchronized_Present,
2229       --        Interface_List, and Interface_Present are used for abstract
2230       --        interfaces (see comments for INTERFACE_TYPE_DEFINITION).
2231
2232       ---------------------------
2233       -- 3.5  Range Constraint --
2234       ---------------------------
2235
2236       --  RANGE_CONSTRAINT ::= range RANGE
2237
2238       --  N_Range_Constraint
2239       --  Sloc points to RANGE
2240       --  Range_Expression (Node4)
2241
2242       ----------------
2243       -- 3.5  Range --
2244       ----------------
2245
2246       --  RANGE ::=
2247       --    RANGE_ATTRIBUTE_REFERENCE
2248       --  | SIMPLE_EXPRESSION .. SIMPLE_EXPRESSION
2249
2250       --  Note: the case of a range given as a range attribute reference
2251       --  appears directly in the tree as an attribute reference.
2252
2253       --  Note: the field name for a reference to a range is Range_Expression
2254       --  rather than Range, because range is a reserved keyword in Ada!
2255
2256       --  Note: the reason that this node has expression fields is that a
2257       --  range can appear as an operand of a membership test. The Etype
2258       --  field is the type of the range (we do NOT construct an implicit
2259       --  subtype to represent the range exactly).
2260
2261       --  N_Range
2262       --  Sloc points to ..
2263       --  Low_Bound (Node1)
2264       --  High_Bound (Node2)
2265       --  Includes_Infinities (Flag11)
2266       --  plus fields for expression
2267
2268       --  Note: if the range appears in a context, such as a subtype
2269       --  declaration, where range checks are required on one or both of
2270       --  the expression fields, then type conversion nodes are inserted
2271       --  to represent the required checks.
2272
2273       ----------------------------------------
2274       -- 3.5.1  Enumeration Type Definition --
2275       ----------------------------------------
2276
2277       --  ENUMERATION_TYPE_DEFINITION ::=
2278       --    (ENUMERATION_LITERAL_SPECIFICATION
2279       --      {, ENUMERATION_LITERAL_SPECIFICATION})
2280
2281       --  Note: the Literals field in the node described below is null for
2282       --  the case of the standard types CHARACTER and WIDE_CHARACTER, for
2283       --  which special processing handles these types as special cases.
2284
2285       --  N_Enumeration_Type_Definition
2286       --  Sloc points to left parenthesis
2287       --  Literals (List1) (Empty for CHARACTER or WIDE_CHARACTER)
2288       --  End_Label (Node4) (set to Empty if internally generated record)
2289
2290       ----------------------------------------------
2291       -- 3.5.1  Enumeration Literal Specification --
2292       ----------------------------------------------
2293
2294       --  ENUMERATION_LITERAL_SPECIFICATION ::=
2295       --    DEFINING_IDENTIFIER | DEFINING_CHARACTER_LITERAL
2296
2297       ---------------------------------------
2298       -- 3.5.1  Defining Character Literal --
2299       ---------------------------------------
2300
2301       --  DEFINING_CHARACTER_LITERAL ::= CHARACTER_LITERAL
2302
2303       --  A defining character literal is an entity, which has additional
2304       --  fields depending on the setting of the Ekind field. These
2305       --  additional fields are defined (and access subprograms declared)
2306       --  in package Einfo.
2307
2308       --  Note: N_Defining_Character_Literal is an extended node whose fields
2309       --  are deliberate layed out to match the layout of fields in an ordinary
2310       --  N_Character_Literal node allowing for easy alteration of a character
2311       --  literal node into a defining character literal node. For details, see
2312       --  Sinfo.CN.Change_Character_Literal_To_Defining_Character_Literal.
2313
2314       --  N_Defining_Character_Literal
2315       --  Sloc points to literal
2316       --  Chars (Name1) contains the Name_Id for the identifier
2317       --  Next_Entity (Node2-Sem)
2318       --  Scope (Node3-Sem)
2319       --  Etype (Node5-Sem)
2320
2321       ------------------------------------
2322       -- 3.5.4  Integer Type Definition --
2323       ------------------------------------
2324
2325       --  Note: there is an error in this rule in the latest version of the
2326       --  grammar, so we have retained the old rule pending clarification.
2327
2328       --  INTEGER_TYPE_DEFINITION ::=
2329       --    SIGNED_INTEGER_TYPE_DEFINITION
2330       --  | MODULAR_TYPE_DEFINITION
2331
2332       -------------------------------------------
2333       -- 3.5.4  Signed Integer Type Definition --
2334       -------------------------------------------
2335
2336       --  SIGNED_INTEGER_TYPE_DEFINITION ::=
2337       --    range static_SIMPLE_EXPRESSION .. static_SIMPLE_EXPRESSION
2338
2339       --  Note: the Low_Bound and High_Bound fields are set to Empty
2340       --  for integer types defined in package Standard.
2341
2342       --  N_Signed_Integer_Type_Definition
2343       --  Sloc points to RANGE
2344       --  Low_Bound (Node1)
2345       --  High_Bound (Node2)
2346
2347       ------------------------------------
2348       -- 3.5.4  Modular Type Definition --
2349       ------------------------------------
2350
2351       --  MODULAR_TYPE_DEFINITION ::= mod static_EXPRESSION
2352
2353       --  N_Modular_Type_Definition
2354       --  Sloc points to MOD
2355       --  Expression (Node3)
2356
2357       ---------------------------------
2358       -- 3.5.6  Real Type Definition --
2359       ---------------------------------
2360
2361       --  REAL_TYPE_DEFINITION ::=
2362       --    FLOATING_POINT_DEFINITION | FIXED_POINT_DEFINITION
2363
2364       --------------------------------------
2365       -- 3.5.7  Floating Point Definition --
2366       --------------------------------------
2367
2368       --  FLOATING_POINT_DEFINITION ::=
2369       --    digits static_SIMPLE_EXPRESSION [REAL_RANGE_SPECIFICATION]
2370
2371       --  Note: The Digits_Expression and Real_Range_Specifications fields
2372       --  are set to Empty for floating-point types declared in Standard.
2373
2374       --  N_Floating_Point_Definition
2375       --  Sloc points to DIGITS
2376       --  Digits_Expression (Node2)
2377       --  Real_Range_Specification (Node4) (set to Empty if not present)
2378
2379       -------------------------------------
2380       -- 3.5.7  Real Range Specification --
2381       -------------------------------------
2382
2383       --  REAL_RANGE_SPECIFICATION ::=
2384       --    range static_SIMPLE_EXPRESSION .. static_SIMPLE_EXPRESSION
2385
2386       --  N_Real_Range_Specification
2387       --  Sloc points to RANGE
2388       --  Low_Bound (Node1)
2389       --  High_Bound (Node2)
2390
2391       -----------------------------------
2392       -- 3.5.9  Fixed Point Definition --
2393       -----------------------------------
2394
2395       --  FIXED_POINT_DEFINITION ::=
2396       --    ORDINARY_FIXED_POINT_DEFINITION | DECIMAL_FIXED_POINT_DEFINITION
2397
2398       --------------------------------------------
2399       -- 3.5.9  Ordinary Fixed Point Definition --
2400       --------------------------------------------
2401
2402       --  ORDINARY_FIXED_POINT_DEFINITION ::=
2403       --    delta static_EXPRESSION REAL_RANGE_SPECIFICATION
2404
2405       --  Note: In Ada 83, the EXPRESSION must be a SIMPLE_EXPRESSION
2406
2407       --  N_Ordinary_Fixed_Point_Definition
2408       --  Sloc points to DELTA
2409       --  Delta_Expression (Node3)
2410       --  Real_Range_Specification (Node4)
2411
2412       -------------------------------------------
2413       -- 3.5.9  Decimal Fixed Point Definition --
2414       -------------------------------------------
2415
2416       --  DECIMAL_FIXED_POINT_DEFINITION ::=
2417       --    delta static_EXPRESSION
2418       --      digits static_EXPRESSION [REAL_RANGE_SPECIFICATION]
2419
2420       --  Note: decimal types are not permitted in Ada 83 mode
2421
2422       --  N_Decimal_Fixed_Point_Definition
2423       --  Sloc points to DELTA
2424       --  Delta_Expression (Node3)
2425       --  Digits_Expression (Node2)
2426       --  Real_Range_Specification (Node4) (set to Empty if not present)
2427
2428       ------------------------------
2429       -- 3.5.9  Digits Constraint --
2430       ------------------------------
2431
2432       --  DIGITS_CONSTRAINT ::=
2433       --    digits static_EXPRESSION [RANGE_CONSTRAINT]
2434
2435       --  Note: in Ada 83, the EXPRESSION must be a SIMPLE_EXPRESSION
2436       --  Note: in Ada 95, reduced accuracy subtypes are obsolescent
2437
2438       --  N_Digits_Constraint
2439       --  Sloc points to DIGITS
2440       --  Digits_Expression (Node2)
2441       --  Range_Constraint (Node4) (set to Empty if not present)
2442
2443       --------------------------------
2444       -- 3.6  Array Type Definition --
2445       --------------------------------
2446
2447       --  ARRAY_TYPE_DEFINITION ::=
2448       --    UNCONSTRAINED_ARRAY_DEFINITION | CONSTRAINED_ARRAY_DEFINITION
2449
2450       -----------------------------------------
2451       -- 3.6  Unconstrained Array Definition --
2452       -----------------------------------------
2453
2454       --  UNCONSTRAINED_ARRAY_DEFINITION ::=
2455       --    array (INDEX_SUBTYPE_DEFINITION {, INDEX_SUBTYPE_DEFINITION}) of
2456       --      COMPONENT_DEFINITION
2457
2458       --  Note: dimensionality of array is indicated by number of entries in
2459       --  the Subtype_Marks list, which has one entry for each dimension.
2460
2461       --  N_Unconstrained_Array_Definition
2462       --  Sloc points to ARRAY
2463       --  Subtype_Marks (List2)
2464       --  Component_Definition (Node4)
2465
2466       -----------------------------------
2467       -- 3.6  Index Subtype Definition --
2468       -----------------------------------
2469
2470       --  INDEX_SUBTYPE_DEFINITION ::= SUBTYPE_MARK range <>
2471
2472       --  There is no explicit node in the tree for an index subtype
2473       --  definition since the N_Unconstrained_Array_Definition node
2474       --  incorporates the type marks which appear in this context.
2475
2476       ---------------------------------------
2477       -- 3.6  Constrained Array Definition --
2478       ---------------------------------------
2479
2480       --  CONSTRAINED_ARRAY_DEFINITION ::=
2481       --    array (DISCRETE_SUBTYPE_DEFINITION
2482       --      {, DISCRETE_SUBTYPE_DEFINITION})
2483       --        of COMPONENT_DEFINITION
2484
2485       --  Note: dimensionality of array is indicated by number of entries
2486       --  in the Discrete_Subtype_Definitions list, which has one entry
2487       --  for each dimension.
2488
2489       --  N_Constrained_Array_Definition
2490       --  Sloc points to ARRAY
2491       --  Discrete_Subtype_Definitions (List2)
2492       --  Component_Definition (Node4)
2493
2494       --------------------------------------
2495       -- 3.6  Discrete Subtype Definition --
2496       --------------------------------------
2497
2498       --  DISCRETE_SUBTYPE_DEFINITION ::=
2499       --    discrete_SUBTYPE_INDICATION | RANGE
2500
2501       -------------------------------
2502       -- 3.6  Component Definition --
2503       -------------------------------
2504
2505       --  COMPONENT_DEFINITION ::=
2506       --    [aliased] [NULL_EXCLUSION] SUBTYPE_INDICATION | ACCESS_DEFINITION
2507
2508       --  Note: although the syntax does not permit a component definition to
2509       --  be an anonymous array (and the parser will diagnose such an attempt
2510       --  with an appropriate message), it is possible for anonymous arrays
2511       --  to appear as component definitions. The semantics and back end handle
2512       --  this case properly, and the expander in fact generates such cases.
2513       --  Access_Definition is an optional field that gives support to
2514       --  Ada 2005 (AI-230). The parser generates nodes that have either the
2515       --  Subtype_Indication field or else the Access_Definition field.
2516
2517       --  N_Component_Definition
2518       --  Sloc points to ALIASED, ACCESS or to first token of subtype mark
2519       --  Aliased_Present (Flag4)
2520       --  Null_Exclusion_Present (Flag11)
2521       --  Subtype_Indication (Node5) (set to Empty if not present)
2522       --  Access_Definition (Node3) (set to Empty if not present)
2523
2524       -----------------------------
2525       -- 3.6.1  Index Constraint --
2526       -----------------------------
2527
2528       --  INDEX_CONSTRAINT ::= (DISCRETE_RANGE {, DISCRETE_RANGE})
2529
2530       --  It is not in general possible to distinguish between discriminant
2531       --  constraints and index constraints at parse time, since a simple
2532       --  name could be either the subtype mark of a discrete range, or an
2533       --  expression in a discriminant association with no name. Either
2534       --  entry appears simply as the name, and the semantic parse must
2535       --  distinguish between the two cases. Thus we use a common tree
2536       --  node format for both of these constraint types.
2537
2538       --  See Discriminant_Constraint for format of node
2539
2540       ---------------------------
2541       -- 3.6.1  Discrete Range --
2542       ---------------------------
2543
2544       --  DISCRETE_RANGE ::= discrete_SUBTYPE_INDICATION | RANGE
2545
2546       ----------------------------
2547       -- 3.7  Discriminant Part --
2548       ----------------------------
2549
2550       --  DISCRIMINANT_PART ::=
2551       --    UNKNOWN_DISCRIMINANT_PART | KNOWN_DISCRIMINANT_PART
2552
2553       ------------------------------------
2554       -- 3.7  Unknown Discriminant Part --
2555       ------------------------------------
2556
2557       --  UNKNOWN_DISCRIMINANT_PART ::= (<>)
2558
2559       --  Note: unknown discriminant parts are not permitted in Ada 83 mode
2560
2561       --  There is no explicit node in the tree for an unknown discriminant
2562       --  part. Instead the Unknown_Discriminants_Present flag is set in the
2563       --  parent node.
2564
2565       ----------------------------------
2566       -- 3.7  Known Discriminant Part --
2567       ----------------------------------
2568
2569       --  KNOWN_DISCRIMINANT_PART ::=
2570       --    (DISCRIMINANT_SPECIFICATION {; DISCRIMINANT_SPECIFICATION})
2571
2572       -------------------------------------
2573       -- 3.7  Discriminant Specification --
2574       -------------------------------------
2575
2576       --  DISCRIMINANT_SPECIFICATION ::=
2577       --    DEFINING_IDENTIFIER_LIST : [NULL_EXCLUSION] SUBTYPE_MARK
2578       --      [:= DEFAULT_EXPRESSION]
2579       --  | DEFINING_IDENTIFIER_LIST : ACCESS_DEFINITION
2580       --      [:= DEFAULT_EXPRESSION]
2581
2582       --  Although the syntax allows multiple identifiers in the list, the
2583       --  semantics is as though successive specifications were given with
2584       --  identical type definition and expression components. To simplify
2585       --  semantic processing, the parser represents a multiple declaration
2586       --  case as a sequence of single specifications, using the More_Ids and
2587       --  Prev_Ids flags to preserve the original source form as described
2588       --  in the section on "Handling of Defining Identifier Lists".
2589
2590       --  N_Discriminant_Specification
2591       --  Sloc points to first identifier
2592       --  Defining_Identifier (Node1)
2593       --  Null_Exclusion_Present (Flag11)
2594       --  Discriminant_Type (Node5) subtype mark or access parameter definition
2595       --  Expression (Node3) (set to Empty if no default expression)
2596       --  More_Ids (Flag5) (set to False if no more identifiers in list)
2597       --  Prev_Ids (Flag6) (set to False if no previous identifiers in list)
2598
2599       -----------------------------
2600       -- 3.7  Default Expression --
2601       -----------------------------
2602
2603       --  DEFAULT_EXPRESSION ::= EXPRESSION
2604
2605       ------------------------------------
2606       -- 3.7.1  Discriminant Constraint --
2607       ------------------------------------
2608
2609       --  DISCRIMINANT_CONSTRAINT ::=
2610       --    (DISCRIMINANT_ASSOCIATION {, DISCRIMINANT_ASSOCIATION})
2611
2612       --  It is not in general possible to distinguish between discriminant
2613       --  constraints and index constraints at parse time, since a simple
2614       --  name could be either the subtype mark of a discrete range, or an
2615       --  expression in a discriminant association with no name. Either
2616       --  entry appears simply as the name, and the semantic parse must
2617       --  distinguish between the two cases. Thus we use a common tree
2618       --  node format for both of these constraint types.
2619
2620       --  N_Index_Or_Discriminant_Constraint
2621       --  Sloc points to left paren
2622       --  Constraints (List1) points to list of discrete ranges or
2623       --    discriminant associations
2624
2625       -------------------------------------
2626       -- 3.7.1  Discriminant Association --
2627       -------------------------------------
2628
2629       --  DISCRIMINANT_ASSOCIATION ::=
2630       --    [discriminant_SELECTOR_NAME
2631       --      {| discriminant_SELECTOR_NAME} =>] EXPRESSION
2632
2633       --  Note: a discriminant association that has no selector name list
2634       --  appears directly as an expression in the tree.
2635
2636       --  N_Discriminant_Association
2637       --  Sloc points to first token of discriminant association
2638       --  Selector_Names (List1) (always non-empty, since if no selector
2639       --   names are present, this node is not used, see comment above)
2640       --  Expression (Node3)
2641
2642       ---------------------------------
2643       -- 3.8  Record Type Definition --
2644       ---------------------------------
2645
2646       --  RECORD_TYPE_DEFINITION ::=
2647       --    [[abstract] tagged] [limited] RECORD_DEFINITION
2648
2649       --  Note: ABSTRACT, TAGGED, LIMITED are not permitted in Ada 83 mode
2650
2651       --  There is no explicit node in the tree for a record type definition.
2652       --  Instead the flags for Tagged_Present and Limited_Present appear in
2653       --  the N_Record_Definition node for a record definition appearing in
2654       --  the context of a record type definition.
2655
2656       ----------------------------
2657       -- 3.8  Record Definition --
2658       ----------------------------
2659
2660       --  RECORD_DEFINITION ::=
2661       --    record
2662       --      COMPONENT_LIST
2663       --    end record
2664       --  | null record
2665
2666       --  Note: the Abstract_Present, Tagged_Present and Limited_Present
2667       --  flags appear only for a record definition appearing in a record
2668       --  type definition.
2669
2670       --  Note: the NULL RECORD case is not permitted in Ada 83
2671
2672       --  N_Record_Definition
2673       --  Sloc points to RECORD or NULL
2674       --  End_Label (Node4) (set to Empty if internally generated record)
2675       --  Abstract_Present (Flag4)
2676       --  Tagged_Present (Flag15)
2677       --  Limited_Present (Flag17)
2678       --  Component_List (Node1) empty in null record case
2679       --  Null_Present (Flag13) set in null record case
2680       --  Task_Present (Flag5) set in task interfaces
2681       --  Protected_Present (Flag6) set in protected interfaces
2682       --  Synchronized_Present (Flag7) set in interfaces
2683       --  Interface_Present (Flag16) set in abstract interfaces
2684       --  Interface_List (List2) (set to No_List if none)
2685
2686       --  Note: Task_Present, Protected_Present, Synchronized _Present,
2687       --        Interface_List and Interface_Present are used for abstract
2688       --        interfaces (see comments for INTERFACE_TYPE_DEFINITION).
2689
2690       -------------------------
2691       -- 3.8  Component List --
2692       -------------------------
2693
2694       --  COMPONENT_LIST ::=
2695       --    COMPONENT_ITEM {COMPONENT_ITEM}
2696       --  | {COMPONENT_ITEM} VARIANT_PART
2697       --  | null;
2698
2699       --  N_Component_List
2700       --  Sloc points to first token of component list
2701       --  Component_Items (List3)
2702       --  Variant_Part (Node4) (set to Empty if no variant part)
2703       --  Null_Present (Flag13)
2704
2705       -------------------------
2706       -- 3.8  Component Item --
2707       -------------------------
2708
2709       --  COMPONENT_ITEM ::= COMPONENT_DECLARATION | REPRESENTATION_CLAUSE
2710
2711       --  Note: A component item can also be a pragma, and in the tree
2712       --  that is obtained after semantic processing, a component item
2713       --  can be an N_Null node resulting from a non-recognized pragma.
2714
2715       --------------------------------
2716       -- 3.8  Component Declaration --
2717       --------------------------------
2718
2719       --  COMPONENT_DECLARATION ::=
2720       --    DEFINING_IDENTIFIER_LIST : COMPONENT_DEFINITION
2721       --      [:= DEFAULT_EXPRESSION]
2722
2723       --  Note: although the syntax does not permit a component definition to
2724       --  be an anonymous array (and the parser will diagnose such an attempt
2725       --  with an appropriate message), it is possible for anonymous arrays
2726       --  to appear as component definitions. The semantics and back end handle
2727       --  this case properly, and the expander in fact generates such cases.
2728
2729       --  Although the syntax allows multiple identifiers in the list, the
2730       --  semantics is as though successive declarations were given with the
2731       --  same component definition and expression components. To simplify
2732       --  semantic processing, the parser represents a multiple declaration
2733       --  case as a sequence of single declarations, using the More_Ids and
2734       --  Prev_Ids flags to preserve the original source form as described
2735       --  in the section on "Handling of Defining Identifier Lists".
2736
2737       --  N_Component_Declaration
2738       --  Sloc points to first identifier
2739       --  Defining_Identifier (Node1)
2740       --  Component_Definition (Node4)
2741       --  Expression (Node3) (set to Empty if no default expression)
2742       --  More_Ids (Flag5) (set to False if no more identifiers in list)
2743       --  Prev_Ids (Flag6) (set to False if no previous identifiers in list)
2744
2745       -------------------------
2746       -- 3.8.1  Variant Part --
2747       -------------------------
2748
2749       --  VARIANT_PART ::=
2750       --    case discriminant_DIRECT_NAME is
2751       --      VARIANT
2752       --      {VARIANT}
2753       --    end case;
2754
2755       --  Note: the variants list can contain pragmas as well as variants.
2756       --  In a properly formed program there is at least one variant.
2757
2758       --  N_Variant_Part
2759       --  Sloc points to CASE
2760       --  Name (Node2)
2761       --  Variants (List1)
2762
2763       --------------------
2764       -- 3.8.1  Variant --
2765       --------------------
2766
2767       --  VARIANT ::=
2768       --    when DISCRETE_CHOICE_LIST =>
2769       --      COMPONENT_LIST
2770
2771       --  N_Variant
2772       --  Sloc points to WHEN
2773       --  Discrete_Choices (List4)
2774       --  Component_List (Node1)
2775       --  Enclosing_Variant (Node2-Sem)
2776       --  Present_Expr (Uint3-Sem)
2777       --  Dcheck_Function (Node5-Sem)
2778
2779       ---------------------------------
2780       -- 3.8.1  Discrete Choice List --
2781       ---------------------------------
2782
2783       --  DISCRETE_CHOICE_LIST ::= DISCRETE_CHOICE {| DISCRETE_CHOICE}
2784
2785       ----------------------------
2786       -- 3.8.1  Discrete Choice --
2787       ----------------------------
2788
2789       --  DISCRETE_CHOICE ::= EXPRESSION | DISCRETE_RANGE | others
2790
2791       --  Note: in Ada 83 mode, the expression must be a simple expression
2792
2793       --  The only choice that appears explicitly is the OTHERS choice, as
2794       --  defined here. Other cases of discrete choice (expression and
2795       --  discrete range) appear directly. This production is also used
2796       --  for the OTHERS possibility of an exception choice.
2797
2798       --  Note: in accordance with the syntax, the parser does not check that
2799       --  OTHERS appears at the end on its own in a choice list context. This
2800       --  is a semantic check.
2801
2802       --  N_Others_Choice
2803       --  Sloc points to OTHERS
2804       --  Others_Discrete_Choices (List1-Sem)
2805       --  All_Others (Flag11-Sem)
2806
2807       ----------------------------------
2808       -- 3.9.1  Record Extension Part --
2809       ----------------------------------
2810
2811       --  RECORD_EXTENSION_PART ::= with RECORD_DEFINITION
2812
2813       --  Note: record extension parts are not permitted in Ada 83 mode
2814
2815       --------------------------------------
2816       -- 3.9.4  Interface Type Definition --
2817       --------------------------------------
2818
2819       --  INTERFACE_TYPE_DEFINITION ::=
2820       --    [limited | task | protected | synchronized]
2821       --    interface [interface_list]
2822
2823       --  Note: Interfaces are implemented with N_Record_Definition and
2824       --        N_Derived_Type_Definition nodes because most of the support
2825       --        for the analysis of abstract types has been reused to
2826       --        analyze abstract interfaces.
2827
2828       ----------------------------------
2829       -- 3.10  Access Type Definition --
2830       ----------------------------------
2831
2832       --  ACCESS_TYPE_DEFINITION ::=
2833       --    ACCESS_TO_OBJECT_DEFINITION
2834       --  | ACCESS_TO_SUBPROGRAM_DEFINITION
2835
2836       --------------------------
2837       -- 3.10  Null Exclusion --
2838       --------------------------
2839
2840       --  NULL_EXCLUSION ::= not null
2841
2842       ---------------------------------------
2843       -- 3.10  Access To Object Definition --
2844       ---------------------------------------
2845
2846       --  ACCESS_TO_OBJECT_DEFINITION ::=
2847       --    [NULL_EXCLUSION] access [GENERAL_ACCESS_MODIFIER]
2848       --    SUBTYPE_INDICATION
2849
2850       --  N_Access_To_Object_Definition
2851       --  Sloc points to ACCESS
2852       --  All_Present (Flag15)
2853       --  Null_Exclusion_Present (Flag11)
2854       --  Subtype_Indication (Node5)
2855       --  Constant_Present (Flag17)
2856
2857       -----------------------------------
2858       -- 3.10  General Access Modifier --
2859       -----------------------------------
2860
2861       --  GENERAL_ACCESS_MODIFIER ::= all | constant
2862
2863       --  Note: general access modifiers are not permitted in Ada 83 mode
2864
2865       --  There is no explicit node in the tree for general access modifier.
2866       --  Instead the All_Present or Constant_Present flags are set in the
2867       --  parent node.
2868
2869       -------------------------------------------
2870       -- 3.10  Access To Subprogram Definition --
2871       -------------------------------------------
2872
2873       --  ACCESS_TO_SUBPROGRAM_DEFINITION
2874       --    [NULL_EXCLUSION] access [protected] procedure PARAMETER_PROFILE
2875       --  | [NULL_EXCLUSION] access [protected] function
2876       --    PARAMETER_AND_RESULT_PROFILE
2877
2878       --  Note: access to subprograms are not permitted in Ada 83 mode
2879
2880       --  N_Access_Function_Definition
2881       --  Sloc points to ACCESS
2882       --  Null_Exclusion_Present (Flag11)
2883       --  Protected_Present (Flag6)
2884       --  Parameter_Specifications (List3) (set to No_List if no formal part)
2885       --  Result_Definition (Node4) result subtype (subtype mark or access def)
2886
2887       --  N_Access_Procedure_Definition
2888       --  Sloc points to ACCESS
2889       --  Null_Exclusion_Present (Flag11)
2890       --  Protected_Present (Flag6)
2891       --  Parameter_Specifications (List3) (set to No_List if no formal part)
2892
2893       -----------------------------
2894       -- 3.10  Access Definition --
2895       -----------------------------
2896
2897       --  ACCESS_DEFINITION ::=
2898       --    [NULL_EXCLUSION] access [GENERAL_ACCESS_MODIFIER] SUBTYPE_MARK
2899       --  | ACCESS_TO_SUBPROGRAM_DEFINITION
2900
2901       --  Note: access to subprograms are an Ada 2005 (AI-254) extension
2902
2903       --  N_Access_Definition
2904       --  Sloc points to ACCESS
2905       --  Null_Exclusion_Present (Flag11)
2906       --  All_Present (Flag15)
2907       --  Constant_Present (Flag17)
2908       --  Subtype_Mark (Node4)
2909       --  Access_To_Subprogram_Definition (Node3) (set to Empty if not present)
2910
2911       -----------------------------------------
2912       -- 3.10.1  Incomplete Type Declaration --
2913       -----------------------------------------
2914
2915       --  INCOMPLETE_TYPE_DECLARATION ::=
2916       --    type DEFINING_IDENTIFIER [DISCRIMINANT_PART] [IS TAGGED];
2917
2918       --  N_Incomplete_Type_Declaration
2919       --  Sloc points to TYPE
2920       --  Defining_Identifier (Node1)
2921       --  Discriminant_Specifications (List4) (set to No_List if no
2922       --   discriminant part, or if the discriminant part is an
2923       --   unknown discriminant part)
2924       --  Unknown_Discriminants_Present (Flag13) set if (<>) discriminant
2925       --  Tagged_Present (Flag15)
2926
2927       ----------------------------
2928       -- 3.11  Declarative Part --
2929       ----------------------------
2930
2931       --  DECLARATIVE_PART ::= {DECLARATIVE_ITEM}
2932
2933       --  Note: although the parser enforces the syntactic requirement that
2934       --  a declarative part can contain only declarations, the semantic
2935       --  processing may add statements to the list of actions in a
2936       --  declarative part, so the code generator should be prepared
2937       --  to accept a statement in this position.
2938
2939       ----------------------------
2940       -- 3.11  Declarative Item --
2941       ----------------------------
2942
2943       --  DECLARATIVE_ITEM ::= BASIC_DECLARATIVE_ITEM | BODY
2944
2945       ----------------------------------
2946       -- 3.11  Basic Declarative Item --
2947       ----------------------------------
2948
2949       --  BASIC_DECLARATIVE_ITEM ::=
2950       --    BASIC_DECLARATION | REPRESENTATION_CLAUSE | USE_CLAUSE
2951
2952       ----------------
2953       -- 3.11  Body --
2954       ----------------
2955
2956       --  BODY ::= PROPER_BODY | BODY_STUB
2957
2958       -----------------------
2959       -- 3.11  Proper Body --
2960       -----------------------
2961
2962       --  PROPER_BODY ::=
2963       --    SUBPROGRAM_BODY | PACKAGE_BODY | TASK_BODY | PROTECTED_BODY
2964
2965       ---------------
2966       -- 4.1  Name --
2967       ---------------
2968
2969       --  NAME ::=
2970       --    DIRECT_NAME        | EXPLICIT_DEREFERENCE
2971       --  | INDEXED_COMPONENT  | SLICE
2972       --  | SELECTED_COMPONENT | ATTRIBUTE_REFERENCE
2973       --  | TYPE_CONVERSION    | FUNCTION_CALL
2974       --  | CHARACTER_LITERAL
2975
2976       ----------------------
2977       -- 4.1  Direct Name --
2978       ----------------------
2979
2980       --  DIRECT_NAME ::= IDENTIFIER | OPERATOR_SYMBOL
2981
2982       -----------------
2983       -- 4.1  Prefix --
2984       -----------------
2985
2986       --  PREFIX ::= NAME | IMPLICIT_DEREFERENCE
2987
2988       -------------------------------
2989       -- 4.1  Explicit Dereference --
2990       -------------------------------
2991
2992       --  EXPLICIT_DEREFERENCE ::= NAME . all
2993
2994       --  N_Explicit_Dereference
2995       --  Sloc points to ALL
2996       --  Prefix (Node3)
2997       --  Actual_Designated_Subtype (Node4-Sem)
2998       --  plus fields for expression
2999
3000       -------------------------------
3001       -- 4.1  Implicit Dereference --
3002       -------------------------------
3003
3004       --  IMPLICIT_DEREFERENCE ::= NAME
3005
3006       ------------------------------
3007       -- 4.1.1  Indexed Component --
3008       ------------------------------
3009
3010       --  INDEXED_COMPONENT ::= PREFIX (EXPRESSION {, EXPRESSION})
3011
3012       --  Note: the parser may generate this node in some situations where it
3013       --  should be a function call. The semantic  pass must correct this
3014       --  misidentification (which is inevitable at the parser level).
3015
3016       --  N_Indexed_Component
3017       --  Sloc contains a copy of the Sloc value of the Prefix
3018       --  Prefix (Node3)
3019       --  Expressions (List1)
3020       --  plus fields for expression
3021
3022       --  Note: if any of the subscripts requires a range check, then the
3023       --  Do_Range_Check flag is set on the corresponding expression, with
3024       --  the index type being determined from the type of the Prefix, which
3025       --  references the array being indexed.
3026
3027       --  Note: in a fully analyzed and expanded indexed component node, and
3028       --  hence in any such node that gigi sees, if the prefix is an access
3029       --  type, then an explicit dereference operation has been inserted.
3030
3031       ------------------
3032       -- 4.1.2  Slice --
3033       ------------------
3034
3035       --  SLICE ::= PREFIX (DISCRETE_RANGE)
3036
3037       --  Note: an implicit subtype is created to describe the resulting
3038       --  type, so that the bounds of this type are the bounds of the slice.
3039
3040       --  N_Slice
3041       --  Sloc points to first token of prefix
3042       --  Prefix (Node3)
3043       --  Discrete_Range (Node4)
3044       --  plus fields for expression
3045
3046       -------------------------------
3047       -- 4.1.3  Selected Component --
3048       -------------------------------
3049
3050       --  SELECTED_COMPONENT ::= PREFIX . SELECTOR_NAME
3051
3052       --  Note: selected components that are semantically expanded names get
3053       --  changed during semantic processing into the separate N_Expanded_Name
3054       --  node. See description of this node in the section on semantic nodes.
3055
3056       --  N_Selected_Component
3057       --  Sloc points to period
3058       --  Prefix (Node3)
3059       --  Selector_Name (Node2)
3060       --  Associated_Node (Node4-Sem)
3061       --  Do_Discriminant_Check (Flag13-Sem)
3062       --  Is_In_Discriminant_Check (Flag11-Sem)
3063       --  plus fields for expression
3064
3065       --------------------------
3066       -- 4.1.3  Selector Name --
3067       --------------------------
3068
3069       --  SELECTOR_NAME ::= IDENTIFIER | CHARACTER_LITERAL | OPERATOR_SYMBOL
3070
3071       --------------------------------
3072       -- 4.1.4  Attribute Reference --
3073       --------------------------------
3074
3075       --  ATTRIBUTE_REFERENCE ::= PREFIX ' ATTRIBUTE_DESIGNATOR
3076
3077       --  Note: the syntax is quite ambiguous at this point. Consider:
3078
3079       --    A'Length (X)  X is part of the attribute designator
3080       --    A'Pos (X)     X is an explicit actual parameter of function A'Pos
3081       --    A'Class (X)   X is the expression of a type conversion
3082
3083       --  It would be possible for the parser to distinguish these cases
3084       --  by looking at the attribute identifier. However, that would mean
3085       --  more work in introducing new implementation defined attributes,
3086       --  and also it would mean that special processing for attributes
3087       --  would be scattered around, instead of being centralized in the
3088       --  semantic routine that handles an N_Attribute_Reference node.
3089       --  Consequently, the parser in all the above cases stores the
3090       --  expression (X in these examples) as a single element list in
3091       --  in the Expressions field of the N_Attribute_Reference node.
3092
3093       --  Similarly, for attributes like Max which take two arguments,
3094       --  we store the two arguments as a two element list in the
3095       --  Expressions field. Of course it is clear at parse time that
3096       --  this case is really a function call with an attribute as the
3097       --  prefix, but it turns out to be convenient to handle the two
3098       --  argument case in a similar manner to the one argument case,
3099       --  and indeed in general the parser will accept any number of
3100       --  expressions in this position and store them as a list in the
3101       --  attribute reference node. This allows for future addition of
3102       --  attributes that take more than two arguments.
3103
3104       --  Note: named associates are not permitted in function calls where
3105       --  the function is an attribute (see RM 6.4(3)) so it is legitimate
3106       --  to skip the normal subprogram argument processing.
3107
3108       --  Note: for the attributes whose designators are technically keywords,
3109       --  i.e. digits, access, delta, range, the Attribute_Name field contains
3110       --  the corresponding name, even though no identifier is involved.
3111
3112       --  Note: the generated code may contain stream attributes applied to
3113       --  limited types for which no stream routines exist officially. In such
3114       --  case, the result is to use the stream attribute for the underlying
3115       --  full type, or in the case of a protected type, the components
3116       --  (including any disriminants) are merely streamed in order.
3117
3118       --  See Exp_Attr for a complete description of which attributes are
3119       --  passed onto Gigi, and which are handled entirely by the front end.
3120
3121       --  Gigi restriction: For the Pos attribute, the prefix cannot be
3122       --  a non-standard enumeration type or a nonzero/zero semantics
3123       --  boolean type, so the value is simply the stored representation.
3124
3125       --  Gigi requirement: For the Mechanism_Code attribute, if the prefix
3126       --  references a subprogram that is a renaming, then the front end must
3127       --  rewrite the attribute to refer directly to the renamed entity.
3128
3129       --  Note: In generated code, the Address and Unrestricted_Access
3130       --  attributes can be applied to any expression, and the meaning is
3131       --  to create an object containing the value (the object is in the
3132       --  current stack frame), and pass the address of this value. If the
3133       --  Must_Be_Byte_Aligned flag is set, then the object whose address
3134       --  is taken must be on a byte (storage unit) boundary, and if it is
3135       --  not (or may not be), then the generated code must create a copy
3136       --  that is byte aligned, and pass the address of this copy.
3137
3138       --  N_Attribute_Reference
3139       --  Sloc points to apostrophe
3140       --  Prefix (Node3)
3141       --  Attribute_Name (Name2) identifier name from attribute designator
3142       --  Expressions (List1) (set to No_List if no associated expressions)
3143       --  Entity (Node4-Sem) used if the attribute yields a type
3144       --  Associated_Node (Node4-Sem)
3145       --  Do_Overflow_Check (Flag17-Sem)
3146       --  Redundant_Use (Flag13-Sem)
3147       --  Must_Be_Byte_Aligned (Flag14)
3148       --  plus fields for expression
3149
3150       ---------------------------------
3151       -- 4.1.4  Attribute Designator --
3152       ---------------------------------
3153
3154       --  ATTRIBUTE_DESIGNATOR ::=
3155       --    IDENTIFIER [(static_EXPRESSION)]
3156       --  | access | delta | digits
3157
3158       --  There is no explicit node in the tree for an attribute designator.
3159       --  Instead the Attribute_Name and Expressions fields of the parent
3160       --  node (N_Attribute_Reference node) hold the information.
3161
3162       --  Note: if ACCESS, DELTA or DIGITS appears in an attribute
3163       --  designator, then they are treated as identifiers internally
3164       --  rather than the keywords of the same name.
3165
3166       --------------------------------------
3167       -- 4.1.4  Range Attribute Reference --
3168       --------------------------------------
3169
3170       --  RANGE_ATTRIBUTE_REFERENCE ::= PREFIX ' RANGE_ATTRIBUTE_DESIGNATOR
3171
3172       --  A range attribute reference is represented in the tree using the
3173       --  normal N_Attribute_Reference node.
3174
3175       ---------------------------------------
3176       -- 4.1.4  Range Attribute Designator --
3177       ---------------------------------------
3178
3179       --  RANGE_ATTRIBUTE_DESIGNATOR ::= Range [(static_EXPRESSION)]
3180
3181       --  A range attribute designator is represented in the tree using the
3182       --  normal N_Attribute_Reference node.
3183
3184       --------------------
3185       -- 4.3  Aggregate --
3186       --------------------
3187
3188       --  AGGREGATE ::=
3189       --    RECORD_AGGREGATE | EXTENSION_AGGREGATE | ARRAY_AGGREGATE
3190
3191       -----------------------------
3192       -- 4.3.1  Record Aggregate --
3193       -----------------------------
3194
3195       --  RECORD_AGGREGATE ::= (RECORD_COMPONENT_ASSOCIATION_LIST)
3196
3197       --  N_Aggregate
3198       --  Sloc points to left parenthesis
3199       --  Expressions (List1) (set to No_List if none or null record case)
3200       --  Component_Associations (List2) (set to No_List if none)
3201       --  Null_Record_Present (Flag17)
3202       --  Aggregate_Bounds (Node3-Sem)
3203       --  Associated_Node (Node4-Sem)
3204       --  Static_Processing_OK (Flag4-Sem)
3205       --  Compile_Time_Known_Aggregate (Flag18-Sem)
3206       --  Expansion_Delayed (Flag11-Sem)
3207       --  Has_Self_Reference (Flag13-Sem)
3208       --  plus fields for expression
3209
3210       --  Note: this structure is used for both record and array aggregates
3211       --  since the two cases are not separable by the parser. The parser
3212       --  makes no attempt to enforce consistency here, so it is up to the
3213       --  semantic phase to make sure that the aggregate is consistent (i.e.
3214       --  that it is not a "half-and-half" case that mixes record and array
3215       --  syntax. In particular, for a record aggregate, the expressions
3216       --  field will be set if there are positional associations.
3217
3218       --  Note: N_Aggregate is not used for all aggregates; in particular,
3219       --  there is a separate node kind for extension aggregates.
3220
3221       --  Note: gigi/gcc can handle array aggregates correctly providing that
3222       --  they are entirely positional, and the array subtype involved has a
3223       --  known at compile time length and is not bit packed, or a convention
3224       --  Fortran array with more than one dimension. If these conditions
3225       --  are not met, then the front end must translate the aggregate into
3226       --  an appropriate set of assignments into a temporary.
3227
3228       --  Note: for the record aggregate case, gigi/gcc can handle all cases
3229       --  of record aggregates, including those for packed, and rep-claused
3230       --  records, and also variant records, providing that there are no
3231       --  variable length fields whose size is not known at runtime, and
3232       --  providing that the aggregate is presented in fully named form.
3233
3234       ----------------------------------------------
3235       -- 4.3.1  Record Component Association List --
3236       ----------------------------------------------
3237
3238       --  RECORD_COMPONENT_ASSOCIATION_LIST ::=
3239       --     RECORD_COMPONENT_ASSOCIATION {, RECORD_COMPONENT_ASSOCIATION}
3240       --   | null record
3241
3242       --  There is no explicit node in the tree for a record component
3243       --  association list. Instead the Null_Record_Present flag is set in
3244       --  the parent node for the NULL RECORD case.
3245
3246       ------------------------------------------------------
3247       -- 4.3.1  Record Component Association (also 4.3.3) --
3248       ------------------------------------------------------
3249
3250       --  RECORD_COMPONENT_ASSOCIATION ::=
3251       --    [COMPONENT_CHOICE_LIST =>] EXPRESSION
3252
3253       --  N_Component_Association
3254       --  Sloc points to first selector name
3255       --  Choices (List1)
3256       --  Loop_Actions (List2-Sem)
3257       --  Expression (Node3)
3258       --  Box_Present (Flag15)
3259
3260       --  Note: this structure is used for both record component associations
3261       --  and array component associations, since the two cases aren't always
3262       --  separable by the parser. The choices list may represent either a
3263       --  list of selector names in the record aggregate case, or a list of
3264       --  discrete choices in the array aggregate case or an N_Others_Choice
3265       --  node (which appears as a singleton list). Box_Present gives support
3266       --  to Ada 2005 (AI-287).
3267
3268       -----------------------------------
3269       -- 4.3.1  Commponent Choice List --
3270       -----------------------------------
3271
3272       --  COMPONENT_CHOICE_LIST ::=
3273       --    component_SELECTOR_NAME {| component_SELECTOR_NAME}
3274       --  | others
3275
3276       --  The entries of a component choice list appear in the Choices list of
3277       --  the associated N_Component_Association, as either selector names, or
3278       --  as an N_Others_Choice node.
3279
3280       --------------------------------
3281       -- 4.3.2  Extension Aggregate --
3282       --------------------------------
3283
3284       --  EXTENSION_AGGREGATE ::=
3285       --    (ANCESTOR_PART with RECORD_COMPONENT_ASSOCIATION_LIST)
3286
3287       --  Note: extension aggregates are not permitted in Ada 83 mode
3288
3289       --  N_Extension_Aggregate
3290       --  Sloc points to left parenthesis
3291       --  Ancestor_Part (Node3)
3292       --  Associated_Node (Node4-Sem)
3293       --  Expressions (List1) (set to No_List if none or null record case)
3294       --  Component_Associations (List2) (set to No_List if none)
3295       --  Null_Record_Present (Flag17)
3296       --  Expansion_Delayed (Flag11-Sem)
3297       --  Has_Self_Reference (Flag13-Sem)
3298       --  plus fields for expression
3299
3300       --------------------------
3301       -- 4.3.2  Ancestor Part --
3302       --------------------------
3303
3304       --  ANCESTOR_PART ::= EXPRESSION | SUBTYPE_MARK
3305
3306       ----------------------------
3307       -- 4.3.3  Array Aggregate --
3308       ----------------------------
3309
3310       --  ARRAY_AGGREGATE ::=
3311       --    POSITIONAL_ARRAY_AGGREGATE | NAMED_ARRAY_AGGREGATE
3312
3313       ---------------------------------------
3314       -- 4.3.3  Positional Array Aggregate --
3315       ---------------------------------------
3316
3317       --  POSITIONAL_ARRAY_AGGREGATE ::=
3318       --    (EXPRESSION, EXPRESSION {, EXPRESSION})
3319       --  | (EXPRESSION {, EXPRESSION}, others => EXPRESSION)
3320
3321       --  See Record_Aggregate (4.3.1) for node structure
3322
3323       ----------------------------------
3324       -- 4.3.3  Named Array Aggregate --
3325       ----------------------------------
3326
3327       --  NAMED_ARRAY_AGGREGATE ::=
3328       --  | (ARRAY_COMPONENT_ASSOCIATION {, ARRAY_COMPONENT_ASSOCIATION})
3329
3330       --  See Record_Aggregate (4.3.1) for node structure
3331
3332       ----------------------------------------
3333       -- 4.3.3  Array Component Association --
3334       ----------------------------------------
3335
3336       --  ARRAY_COMPONENT_ASSOCIATION ::=
3337       --    DISCRETE_CHOICE_LIST => EXPRESSION
3338
3339       --  See Record_Component_Association (4.3.1) for node structure
3340
3341       --------------------------------------------------
3342       -- 4.4  Expression/Relation/Term/Factor/Primary --
3343       --------------------------------------------------
3344
3345       --  EXPRESSION ::=
3346       --    RELATION {and RELATION} | RELATION {and then RELATION}
3347       --  | RELATION {or RELATION}  | RELATION {or else RELATION}
3348       --  | RELATION {xor RELATION}
3349
3350       --  RELATION ::=
3351       --    SIMPLE_EXPRESSION [RELATIONAL_OPERATOR SIMPLE_EXPRESSION]
3352       --  | SIMPLE_EXPRESSION [not] in RANGE
3353       --  | SIMPLE_EXPRESSION [not] in SUBTYPE_MARK
3354
3355       --  SIMPLE_EXPRESSION ::=
3356       --    [UNARY_ADDING_OPERATOR] TERM {BINARY_ADDING_OPERATOR TERM}
3357
3358       --  TERM ::= FACTOR {MULTIPLYING_OPERATOR FACTOR}
3359
3360       --  FACTOR ::= PRIMARY [** PRIMARY] | abs PRIMARY | not PRIMARY
3361
3362       --  No nodes are generated for any of these constructs. Instead, the
3363       --  node for the operator appears directly. When we refer to an
3364       --  expression in this description, we mean any of the possible
3365       --  consistuent components of an expression (e.g. identifier is
3366       --  an example of an expression).
3367
3368       ------------------
3369       -- 4.4  Primary --
3370       ------------------
3371
3372       --  PRIMARY ::=
3373       --    NUMERIC_LITERAL  | null
3374       --  | STRING_LITERAL   | AGGREGATE
3375       --  | NAME             | QUALIFIED_EXPRESSION
3376       --  | ALLOCATOR        | (EXPRESSION)
3377
3378       --  Usually there is no explicit node in the tree for primary. Instead
3379       --  the constituent (e.g. AGGREGATE) appears directly. There are two
3380       --  exceptions. First, there is an explicit node for a null primary.
3381
3382       --  N_Null
3383       --  Sloc points to NULL
3384       --  plus fields for expression
3385
3386       --  Second, the case of (EXPRESSION) is handled specially. Ada requires
3387       --  that the parser keep track of which subexpressions are enclosed
3388       --  in parentheses, and how many levels of parentheses are used. This
3389       --  information is required for optimization purposes, and also for
3390       --  some semantic checks (e.g. (((1))) in a procedure spec does not
3391       --  conform with ((((1)))) in the body).
3392
3393       --  The parentheses are recorded by keeping a Paren_Count field in every
3394       --  subexpression node (it is actually present in all nodes, but only
3395       --  used in subexpression nodes). This count records the number of
3396       --  levels of parentheses. If the number of levels in the source exceeds
3397       --  the maximum accomodated by this count, then the count is simply left
3398       --  at the maximum value. This means that there are some pathalogical
3399       --  cases of failure to detect conformance failures (e.g. an expression
3400       --  with 500 levels of parens will conform with one with 501 levels),
3401       --  but we do not need to lose sleep over this.
3402
3403       --  Historical note: in versions of GNAT prior to 1.75, there was a node
3404       --  type N_Parenthesized_Expression used to accurately record unlimited
3405       --  numbers of levels of parentheses. However, it turned out to be a
3406       --  real nuisance to have to take into account the possible presence of
3407       --  this node during semantic analysis, since basically parentheses have
3408       --  zero relevance to semantic analysis.
3409
3410       --  Note: the level of parentheses always present in things like
3411       --  aggregates does not count, only the parentheses in the primary
3412       --  (EXPRESSION) affect the setting of the Paren_Count field.
3413
3414       --  2nd Note: the contents of the Expression field must be ignored (i.e.
3415       --  treated as though it were Empty) if No_Initialization is set True.
3416
3417       --------------------------------------
3418       -- 4.5  Short Circuit Control Forms --
3419       --------------------------------------
3420
3421       --  EXPRESSION ::=
3422       --    RELATION {and then RELATION} | RELATION {or else RELATION}
3423
3424       --  Gigi restriction: For both these control forms, the operand and
3425       --  result types are always Standard.Boolean. The expander inserts the
3426       --  required conversion operations where needed to ensure this is the
3427       --  case.
3428
3429       --  N_And_Then
3430       --  Sloc points to AND of AND THEN
3431       --  Left_Opnd (Node2)
3432       --  Right_Opnd (Node3)
3433       --  Actions (List1-Sem)
3434       --  plus fields for expression
3435
3436       --  N_Or_Else
3437       --  Sloc points to OR of OR ELSE
3438       --  Left_Opnd (Node2)
3439       --  Right_Opnd (Node3)
3440       --  Actions (List1-Sem)
3441       --  plus fields for expression
3442
3443       --  Note: The Actions field is used to hold actions associated with
3444       --  the right hand operand. These have to be treated specially since
3445       --  they are not unconditionally executed. See Insert_Actions for a
3446       --  more detailed description of how these actions are handled.
3447
3448       ---------------------------
3449       -- 4.5  Membership Tests --
3450       ---------------------------
3451
3452       --  RELATION ::=
3453       --    SIMPLE_EXPRESSION [not] in RANGE
3454       --  | SIMPLE_EXPRESSION [not] in SUBTYPE_MARK
3455
3456       --  Note: although the grammar above allows only a range or a
3457       --  subtype mark, the parser in fact will accept any simple
3458       --  expression in place of a subtype mark. This means that the
3459       --  semantic analyzer must be prepared to deal with, and diagnose
3460       --  a simple expression other than a name for the right operand.
3461       --  This simplifies error recovery in the parser.
3462
3463       --  N_In
3464       --  Sloc points to IN
3465       --  Left_Opnd (Node2)
3466       --  Right_Opnd (Node3)
3467       --  plus fields for expression
3468
3469       --  N_Not_In
3470       --  Sloc points to NOT of NOT IN
3471       --  Left_Opnd (Node2)
3472       --  Right_Opnd (Node3)
3473       --  plus fields for expression
3474
3475       --------------------
3476       -- 4.5  Operators --
3477       --------------------
3478
3479       --  LOGICAL_OPERATOR             ::=  and | or  | xor
3480
3481       --  RELATIONAL_OPERATOR          ::=  =   | /=  | <   | <= | > | >=
3482
3483       --  BINARY_ADDING_OPERATOR       ::=  +   |  -  | &
3484
3485       --  UNARY_ADDING_OPERATOR        ::=  +   |  -
3486
3487       --  MULTIPLYING_OPERATOR         ::=  *   |  /  | mod | rem
3488
3489       --  HIGHEST_PRECEDENCE_OPERATOR  ::=  **  | abs | not
3490
3491       --  Sprint syntax if Treat_Fixed_As_Integer is set:
3492
3493       --     x #* y
3494       --     x #/ y
3495       --     x #mod y
3496       --     x #rem y
3497
3498       --  Gigi restriction: For * / mod rem with fixed-point operands, Gigi
3499       --  will only be given nodes with the Treat_Fixed_As_Integer flag set.
3500       --  All handling of smalls for multiplication and division is handled
3501       --  by the front end (mod and rem result only from expansion). Gigi
3502       --  thus never needs to worry about small values (for other operators
3503       --  operating on fixed-point, e.g. addition, the small value does not
3504       --  have any semantic effect anyway, these are always integer operations.
3505
3506       --  Gigi restriction: For all operators taking Boolean operands, the
3507       --  type is always Standard.Boolean. The expander inserts the required
3508       --  conversion operations where needed to ensure this is the case.
3509
3510       --  N_Op_And
3511       --  Sloc points to AND
3512       --  Do_Length_Check (Flag4-Sem)
3513       --  plus fields for binary operator
3514       --  plus fields for expression
3515
3516       --  N_Op_Or
3517       --  Sloc points to OR
3518       --  Do_Length_Check (Flag4-Sem)
3519       --  plus fields for binary operator
3520       --  plus fields for expression
3521
3522       --  N_Op_Xor
3523       --  Sloc points to XOR
3524       --  Do_Length_Check (Flag4-Sem)
3525       --  plus fields for binary operator
3526       --  plus fields for expression
3527
3528       --  N_Op_Eq
3529       --  Sloc points to =
3530       --  plus fields for binary operator
3531       --  plus fields for expression
3532
3533       --  N_Op_Ne
3534       --  Sloc points to /=
3535       --  plus fields for binary operator
3536       --  plus fields for expression
3537
3538       --  N_Op_Lt
3539       --  Sloc points to <
3540       --  plus fields for binary operator
3541       --  plus fields for expression
3542
3543       --  N_Op_Le
3544       --  Sloc points to <=
3545       --  plus fields for binary operator
3546       --  plus fields for expression
3547
3548       --  N_Op_Gt
3549       --  Sloc points to >
3550       --  plus fields for binary operator
3551       --  plus fields for expression
3552
3553       --  N_Op_Ge
3554       --  Sloc points to >=
3555       --  plus fields for binary operator
3556       --  plus fields for expression
3557
3558       --  N_Op_Add
3559       --  Sloc points to + (binary)
3560       --  plus fields for binary operator
3561       --  plus fields for expression
3562
3563       --  N_Op_Subtract
3564       --  Sloc points to - (binary)
3565       --  plus fields for binary operator
3566       --  plus fields for expression
3567
3568       --  N_Op_Concat
3569       --  Sloc points to &
3570       --  Is_Component_Left_Opnd (Flag13-Sem)
3571       --  Is_Component_Right_Opnd (Flag14-Sem)
3572       --  plus fields for binary operator
3573       --  plus fields for expression
3574
3575       --  N_Op_Multiply
3576       --  Sloc points to *
3577       --  Treat_Fixed_As_Integer (Flag14-Sem)
3578       --  Rounded_Result (Flag18-Sem)
3579       --  plus fields for binary operator
3580       --  plus fields for expression
3581
3582       --  N_Op_Divide
3583       --  Sloc points to /
3584       --  Treat_Fixed_As_Integer (Flag14-Sem)
3585       --  Do_Division_Check (Flag13-Sem)
3586       --  Rounded_Result (Flag18-Sem)
3587       --  plus fields for binary operator
3588       --  plus fields for expression
3589
3590       --  N_Op_Mod
3591       --  Sloc points to MOD
3592       --  Treat_Fixed_As_Integer (Flag14-Sem)
3593       --  Do_Division_Check (Flag13-Sem)
3594       --  plus fields for binary operator
3595       --  plus fields for expression
3596
3597       --  N_Op_Rem
3598       --  Sloc points to REM
3599       --  Treat_Fixed_As_Integer (Flag14-Sem)
3600       --  Do_Division_Check (Flag13-Sem)
3601       --  plus fields for binary operator
3602       --  plus fields for expression
3603
3604       --  N_Op_Expon
3605       --  Is_Power_Of_2_For_Shift (Flag13-Sem)
3606       --  Sloc points to **
3607       --  plus fields for binary operator
3608       --  plus fields for expression
3609
3610       --  N_Op_Plus
3611       --  Sloc points to + (unary)
3612       --  plus fields for unary operator
3613       --  plus fields for expression
3614
3615       --  N_Op_Minus
3616       --  Sloc points to - (unary)
3617       --  plus fields for unary operator
3618       --  plus fields for expression
3619
3620       --  N_Op_Abs
3621       --  Sloc points to ABS
3622       --  plus fields for unary operator
3623       --  plus fields for expression
3624
3625       --  N_Op_Not
3626       --  Sloc points to NOT
3627       --  plus fields for unary operator
3628       --  plus fields for expression
3629
3630       --  See also shift operators in section B.2
3631
3632       --  Note on fixed-point operations passed to Gigi: For adding operators,
3633       --  the semantics is to treat these simply as integer operations, with
3634       --  the small values being ignored (the bounds are already stored in
3635       --  units of small, so that constraint checking works as usual). For the
3636       --  case of multiply/divide/rem/mod operations, Gigi will only see fixed
3637       --  point operands if the Treat_Fixed_As_Integer flag is set and will
3638       --  thus treat these nodes in identical manner, ignoring small values.
3639
3640       --------------------------
3641       -- 4.6  Type Conversion --
3642       --------------------------
3643
3644       --  TYPE_CONVERSION ::=
3645       --    SUBTYPE_MARK (EXPRESSION) | SUBTYPE_MARK (NAME)
3646
3647       --  In the (NAME) case, the name is stored as the expression
3648
3649       --  Note: the parser never generates a type conversion node, since it
3650       --  looks like an indexed component which is generated by preference.
3651       --  The semantic pass must correct this misidentification.
3652
3653       --  Gigi handles conversions that involve no change in the root type,
3654       --  and also all conversions from integer to floating-point types.
3655       --  Conversions from floating-point to integer are only handled in
3656       --  the case where Float_Truncate flag set. Other conversions from
3657       --  floating-point to integer (involving rounding) and all conversions
3658       --  involving fixed-point types are handled by the expander.
3659
3660       --  Sprint syntax if Float_Truncate set: X^(Y)
3661       --  Sprint syntax if Conversion_OK set X?(Y)
3662       --  Sprint syntax if both flags set X?^(Y)
3663
3664       --  Note: If either the operand or result type is fixed-point, Gigi will
3665       --  only see a type conversion node with Conversion_OK set. The front end
3666       --  takes care of all handling of small's for fixed-point conversions.
3667
3668       --  N_Type_Conversion
3669       --  Sloc points to first token of subtype mark
3670       --  Subtype_Mark (Node4)
3671       --  Expression (Node3)
3672       --  Do_Tag_Check (Flag13-Sem)
3673       --  Do_Length_Check (Flag4-Sem)
3674       --  Do_Overflow_Check (Flag17-Sem)
3675       --  Float_Truncate (Flag11-Sem)
3676       --  Rounded_Result (Flag18-Sem)
3677       --  Conversion_OK (Flag14-Sem)
3678       --  plus fields for expression
3679
3680       --  Note: if a range check is required, then the Do_Range_Check flag
3681       --  is set in the Expression with the check being done against the
3682       --  target type range (after the base type conversion, if any).
3683
3684       -------------------------------
3685       -- 4.7  Qualified Expression --
3686       -------------------------------
3687
3688       --  QUALIFIED_EXPRESSION ::=
3689       --    SUBTYPE_MARK ' (EXPRESSION) | SUBTYPE_MARK ' AGGREGATE
3690
3691       --  Note: the parentheses in the (EXPRESSION) case are deemed to enclose
3692       --  the expression, so the Expression field of this node always points
3693       --  to a parenthesized expression in this case (i.e. Paren_Count will
3694       --  always be non-zero for the referenced expression if it is not an
3695       --  aggregate).
3696
3697       --  N_Qualified_Expression
3698       --  Sloc points to apostrophe
3699       --  Subtype_Mark (Node4)
3700       --  Expression (Node3) expression or aggregate
3701       --  plus fields for expression
3702
3703       --------------------
3704       -- 4.8  Allocator --
3705       --------------------
3706
3707       --  ALLOCATOR ::=
3708       --    new [NULL_EXCLUSION] SUBTYPE_INDICATION | new QUALIFIED_EXPRESSION
3709
3710       --  Sprint syntax (when storage pool present)
3711       --    new xxx (storage_pool = pool)
3712
3713       --  N_Allocator
3714       --  Sloc points to NEW
3715       --  Expression (Node3) subtype indication or qualified expression
3716       --  Storage_Pool (Node1-Sem)
3717       --  Procedure_To_Call (Node2-Sem)
3718       --  Coextensions (Elist4-Sem)
3719       --  Null_Exclusion_Present (Flag11)
3720       --  No_Initialization (Flag13-Sem)
3721       --  Is_Static_Coextension (Flag14-Sem)
3722       --  Do_Storage_Check (Flag17-Sem)
3723       --  Is_Dynamic_Coextension (Flag18-Sem)
3724       --  plus fields for expression
3725
3726       ---------------------------------
3727       -- 5.1  Sequence Of Statements --
3728       ---------------------------------
3729
3730       --  SEQUENCE_OF_STATEMENTS ::= STATEMENT {STATEMENT}
3731
3732       --  Note: Although the parser will not accept a declaration as a
3733       --  statement, the semantic analyzer may insert declarations (e.g.
3734       --  declarations of implicit types needed for execution of other
3735       --  statements) into a sequence of statements, so the code genmerator
3736       --  should be prepared to accept a declaration where a statement is
3737       --  expected. Note also that pragmas can appear as statements.
3738
3739       --------------------
3740       -- 5.1  Statement --
3741       --------------------
3742
3743       -- &nb