1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2001, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 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, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
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. --
29 -- GNAT was originally developed by the GNAT team at New York University. --
30 -- Extensive contributions were provided by Ada Core Technologies Inc. --
32 ------------------------------------------------------------------------------
35 with Sinfo
; use Sinfo
;
36 with Einfo
; use Einfo
;
37 with Types
; use Types
;
38 with Snames
; use Snames
;
39 with System
; use System
;
41 with Uintp
; use Uintp
;
42 with Urealp
; use Urealp
;
43 with Unchecked_Conversion
;
47 -- This package defines the format of the tree used to represent the Ada
48 -- program internally. Syntactic and semantic information is combined in
49 -- this tree. There is no separate symbol table structure.
51 -- WARNING: There is a C version of this package. Any changes to this
52 -- source file must be properly reflected in the C header file tree.h
54 -- Package Atree defines the basic structure of the tree and its nodes and
55 -- provides the basic abstract interface for manipulating the tree. Two
56 -- other packages use this interface to define the representation of Ada
57 -- programs using this tree format. The package Sinfo defines the basic
58 -- representation of the syntactic structure of the program, as output
59 -- by the parser. The package Entity_Info defines the semantic information
60 -- which is added to the tree nodes that represent declared entities (i.e.
61 -- the information which might typically be described in a separate symbol
64 -- The front end of the compiler first parses the program and generates a
65 -- tree that is simply a syntactic representation of the program in abstract
66 -- syntax tree format. Subsequent processing in the front end traverses the
67 -- tree, transforming it in various ways and adding semantic information.
69 ----------------------------------------
70 -- Definitions of Fields in Tree Node --
71 ----------------------------------------
73 -- The representation of the tree is completely hidden, using a functional
74 -- interface for accessing and modifying the contents of nodes. Logically
75 -- a node contains a number of fields, much as though the nodes were
76 -- defined as a record type. The fields in a node are as follows:
78 -- Nkind Indicates the kind of the node. This field is present
79 -- in all nodes. The type is Node_Kind, which is declared
80 -- in the package Sinfo.
82 -- Sloc Location (Source_Ptr) of the corresponding token
83 -- in the Source buffer. The individual node definitions
84 -- show which token is referenced by this pointer.
86 -- In_List A flag used to indicate if the node is a member
89 -- Rewrite_Sub A flag set if the node has been rewritten using
90 -- the Rewrite procedure. The original value of the
91 -- node is retrievable with Original_Node.
93 -- Rewrite_Ins A flag set if a node is marked as a rewrite inserted
94 -- node as a result of a call to Mark_Rewrite_Insertion.
96 -- Paren_Count A 2-bit count used on expression nodes to indicate
97 -- the level of parentheses. Up to 3 levels can be
98 -- accomodated. Anything more than 3 levels is treated
99 -- as 3 levels (conformance tests that complain about
100 -- this are hereby deemed pathological!) Set to zero
101 -- for non-subexpression nodes.
104 -- This flag is present in all nodes. It is set if the
105 -- node is built by the scanner or parser, and clear if
106 -- the node is built by the analyzer or expander. It
107 -- indicates that the node corresponds to a construct
108 -- that appears in the original source program.
110 -- Analyzed This flag is present in all nodes. It is set when
111 -- a node is analyzed, and is used to avoid analyzing
112 -- the same node twice. Analysis includes expansion if
113 -- expansion is active, so in this case if the flag is
114 -- set it means the node has been analyzed and expanded.
116 -- Error_Posted This flag is present in all nodes. It is set when
117 -- an error message is posted which is associated with
118 -- the flagged node. This is used to avoid posting more
119 -- than one message on the same node.
125 -- Field5 Five fields holding Union_Id values
127 -- Char_CodeN Synonym for FieldN typed as Char_Code
128 -- ElistN Synonym for FieldN typed as Elist_Id
129 -- ListN Synonym for FieldN typed as List_Id
130 -- NameN Synonym for FieldN typed as Name_Id
131 -- NodeN Synonym for FieldN typed as Node_Id
132 -- StrN Synonym for FieldN typed as String_Id
133 -- UintN Synonym for FieldN typed as Uint (Empty = Uint_0)
134 -- UrealN Synonym for FieldN typed as Ureal
136 -- Note: the actual usage of FieldN (i.e. whether it contains a Char_Code,
137 -- Elist_Id, List_Id, Name_Id, Node_Id, String_Id, Uint or Ureal), depends
138 -- on the value in Nkind. Generally the access to this field is always via
139 -- the functional interface, so the field names Char_CodeN, ElistN, ListN,
140 -- NameN, NodeN, StrN, UintN and UrealN are used only in the bodies of the
141 -- access functions (i.e. in the bodies of Sinfo and Einfo). These access
142 -- functions contain debugging code that checks that the use is consistent
143 -- with Nkind and Ekind values.
145 -- However, in specialized circumstances (examples are the circuit in
146 -- generic instantiation to copy trees, and in the tree dump routine),
147 -- it is useful to be able to do untyped traversals, and an internal
148 -- package in Atree allows for direct untyped accesses in such cases.
150 -- Flag4 Fifteen Boolean flags (use depends on Nkind and
151 -- Flag5 Ekind, as described for Fieldn). Again the access
152 -- Flag6 is usually via subprograms in Sinfo and Einfo which
153 -- Flag7 provide high-level synonyms for these flags, and
154 -- Flag8 contain debugging code that checks that the values
155 -- Flag9 in Nkind and Ekind are appropriate for the access.
157 -- Flag11 Note that Flag1-3 are missing from this list. The
158 -- Flag12 first three flag positions are reserved for the
159 -- Flag13 standard flags (Comes_From_Source, Error_Posted,
160 -- Flag14 and Analyzed)
166 -- Link For a node, points to the Parent. For a list, points
167 -- to the list header. Note that in the latter case, a
168 -- client cannot modify the link field. This field is
169 -- private to the Atree package (but is also modified
170 -- by the Nlists package).
172 -- The following additional fields are present in extended nodes used
173 -- for entities (Nkind in N_Entity).
175 -- Ekind Entity type. This field indicates the type of the
176 -- entity, it is of type Entity_Kind which is defined
179 -- Flag19 133 additional flags
183 -- Convention Entity convention (Convention_Id value)
185 -- Field6 Additional Union_Id value stored in tree
187 -- Node6 Synonym for Field6 typed as Node_Id
188 -- Elist6 Synonym for Field6 typed as Elist_Id
189 -- Uint6 Synonym for Field6 typed as Uint (Empty = Uint_0)
191 -- Similar definitions for Field7 to Field23 (and Node7-Node23,
192 -- Elist7-Elist23, Uint7-Uint23, Ureal7-Ureal23). Note that not all
193 -- these functions are defined, only the ones that are actually used.
195 type Paren_Count_Type
is mod 4;
196 for Paren_Count_Type
'Size use 2;
197 -- Type used for Paren_Count field
199 function Last_Node_Id
return Node_Id
;
200 pragma Inline
(Last_Node_Id
);
201 -- Returns Id of last allocated node Id
203 function Nodes_Address
return System
.Address
;
204 -- Return address of Nodes table (used in Back_End for Gigi call)
206 function Num_Nodes
return Nat
;
207 -- Total number of nodes allocated, where an entity counts as a single
208 -- node. This count is incremented every time a node or entity is
209 -- allocated, and decremented every time a node or entity is deleted.
210 -- This value is used by Xref and by Treepr to allocate hash tables of
211 -- suitable size for hashing Node_Id values.
213 -----------------------
214 -- Use of Empty Node --
215 -----------------------
217 -- The special Node_Id Empty is used to mark missing fields. Whenever the
218 -- syntax has an optional component, then the corresponding field will be
219 -- set to Empty if the component is missing.
221 -- Note: Empty is not used to describe an empty list. Instead in this
222 -- case the node field contains a list which is empty, and these cases
223 -- should be distinguished (essentially from a type point of view, Empty
224 -- is a Node, and is thus not a list).
226 -- Note: Empty does in fact correspond to an allocated node. Only the
227 -- Nkind field of this node may be referenced. It contains N_Empty, which
228 -- uniquely identifies the empty case. This allows the Nkind field to be
229 -- dereferenced before the check for Empty which is sometimes useful.
231 -----------------------
232 -- Use of Error Node --
233 -----------------------
235 -- The Error node is used during syntactic and semantic analysis to
236 -- indicate that the corresponding piece of syntactic structure or
237 -- semantic meaning cannot properly be represented in the tree because
238 -- of an illegality in the program.
240 -- If an Error node is encountered, then you know that a previous
241 -- illegality has been detected. The proper reaction should be to
242 -- avoid posting related cascaded error messages, and to propagate
243 -- the error node if necessary.
245 -----------------------
246 -- Current_Error_Node --
247 -----------------------
249 -- The current error node is a global location indicating the current
250 -- node that is being processed for the purposes of placing a compiler
251 -- abort message. This is not necessarily perfectly accurate, it is
252 -- just a reasonably accurate best guess. It is used to output the
253 -- source location in the abort message by Comperr, and also to
254 -- implement the d3 debugging flag. This is also used by Rtsfind
255 -- to generate error messages for No_Run_Time mode.
257 Current_Error_Node
: Node_Id
;
258 -- Node to place error messages
260 -------------------------------
261 -- Default Setting of Fields --
262 -------------------------------
264 -- Nkind is set to N_Unused_At_Start
266 -- Ekind is set to E_Void
268 -- Sloc is always set, there is no default value
270 -- Field1-5 fields are set to Empty
272 -- Field6-22 fields in extended nodes are set to Empty
274 -- Parent is set to Empty
276 -- All Boolean flag fields are set to False
278 -- Note: the value Empty is used in Field1-Field17 to indicate a null node.
279 -- The usage varies. The common uses are to indicate absence of an
280 -- optional clause or a completely unused Field1-17 field.
282 -------------------------------------
283 -- Use of Synonyms for Node Fields --
284 -------------------------------------
286 -- A subpackage Atree.Unchecked_Access provides routines for reading and
287 -- writing the fields defined above (Field1-17, Node1-17, Flag1-88 etc).
288 -- These unchecked access routines can be used for untyped traversals. In
289 -- In addition they are used in the implementations of the Sinfo and
290 -- Einfo packages. These packages both provide logical synonyms for
291 -- the generic fields, together with an appropriate set of access routines.
292 -- Normally access to information within tree nodes uses these synonyms,
293 -- providing a high level typed interface to the tree information.
295 --------------------------------------------------
296 -- Node Allocation and Modification Subprograms --
297 --------------------------------------------------
299 -- Generally the parser builds the tree and then it is further decorated
300 -- (e.g. by setting the entity fields), but not fundamentally modified.
301 -- However, there are cases in which the tree must be restructured by
302 -- adding and rearranging nodes, as a result of disambiguating cases
303 -- which the parser could not parse correctly, and adding additional
304 -- semantic information (e.g. making constraint checks explicit). The
305 -- following subprograms are used for constructing the tree in the first
306 -- place, and then for subsequent modifications as required
308 procedure Initialize
;
309 -- Called at the start of compilation to initialize the allocation of
310 -- the node and list tables and make the standard entries for Empty,
311 -- Error and Error_List. Note that Initialize must not be called if
312 -- Tree_Read is used.
315 -- Called before the backend is invoked to lock the nodes table
318 -- Initializes internal tables from current tree file using Tree_Read.
319 -- Note that Initialize should not be called if Tree_Read is used.
320 -- Tree_Read includes all necessary initialization.
322 procedure Tree_Write
;
323 -- Writes out internal tables to current tree file using Tree_Write
326 (New_Node_Kind
: Node_Kind
;
327 New_Sloc
: Source_Ptr
)
329 -- Allocates a completely new node with the given node type and source
330 -- location values. All other fields are set to their standard defaults:
332 -- Empty for all Fieldn fields
333 -- False for all Flagn fields
335 -- The usual approach is to build a new node using this function and
336 -- then, using the value returned, use the Set_xxx functions to set
337 -- fields of the node as required. New_Node can only be used for
338 -- non-entity nodes, i.e. it never generates an extended node.
341 (New_Node_Kind
: Node_Kind
;
342 New_Sloc
: Source_Ptr
)
344 -- Similar to New_Node, except that it is used only for entity nodes
345 -- and returns an extended node.
347 procedure Set_Comes_From_Source_Default
(Default
: Boolean);
348 -- Sets value of Comes_From_Source flag to be used in all subsequent
349 -- New_Node and New_Entity calls until another call to this procedure
350 -- changes the default.
352 function Get_Comes_From_Source_Default
return Boolean;
353 pragma Inline
(Get_Comes_From_Source_Default
);
354 -- Gets the current value of the Comes_From_Source flag
356 procedure Preserve_Comes_From_Source
(NewN
, OldN
: Node_Id
);
357 pragma Inline
(Preserve_Comes_From_Source
);
358 -- When a node is rewritten, it is sometimes appropriate to preserve the
359 -- original comes from source indication. This is true when the rewrite
360 -- essentially corresponds to a transformation corresponding exactly to
361 -- semantics in the reference manual. This procedure copies the setting
362 -- of Comes_From_Source from OldN to NewN.
364 function Has_Extension
(N
: Node_Id
) return Boolean;
365 pragma Inline
(Has_Extension
);
366 -- Returns True if the given node has an extension (i.e. was created by
367 -- a call to New_Entity rather than New_Node, and Nkind is in N_Entity)
369 procedure Change_Node
(N
: Node_Id
; New_Node_Kind
: Node_Kind
);
370 -- This procedure replaces the given node by setting its Nkind field to
371 -- the indicated value and resetting all other fields to their default
372 -- values except for Sloc, which is unchanged, and the Parent pointer
373 -- and list links, which are also unchanged. All other information in
374 -- the original node is lost. The new node has an extension if the
375 -- original node had an extension.
377 procedure Copy_Node
(Source
: Node_Id
; Destination
: Node_Id
);
378 -- Copy the entire contents of the source node to the destination node.
379 -- The contents of the source node is not affected. If the source node
380 -- has an extension, then the destination must have an extension also.
381 -- The parent pointer of the destination and its list link, if any, are
382 -- not affected by the copy. Note that parent pointers of descendents
383 -- are not adjusted, so the descendents of the destination node after
384 -- the Copy_Node is completed have dubious parent pointers.
386 function New_Copy
(Source
: Node_Id
) return Node_Id
;
387 -- This function allocates a completely new node, and then initializes
388 -- it by copying the contents of the source node into it. The contents
389 -- of the source node is not affected. The target node is always marked
390 -- as not being in a list (even if the source is a list member). The
391 -- new node will have an extension if the source has an extension.
392 -- New_Copy (Empty) returns Empty and New_Copy (Error) returns Error.
393 -- Note that, unlike New_Copy_Tree, New_Copy does not recursively copy any
394 -- descendents, so in general parent pointers are not set correctly for
395 -- the descendents of the copied node. Both normal and extended nodes
396 -- (entities) may be copied using New_Copy.
398 function Relocate_Node
(Source
: Node_Id
) return Node_Id
;
399 -- Source is a non-entity node that is to be relocated. A new node is
400 -- allocated and the contents of Source are copied to this node using
401 -- Copy_Node. The parent pointers of descendents of the node are then
402 -- adjusted to point to the relocated copy. The original node is not
403 -- modified, but the parent pointers of its descendents are no longer
404 -- valid. This routine is used in conjunction with the tree rewrite
405 -- routines (see descriptions of Replace/Rewrite).
407 -- Note that the resulting node has the same parent as the source
408 -- node, and is thus still attached to the tree. It is valid for
409 -- Source to be Empty, in which case Relocate_Node simply returns
410 -- Empty as the result.
412 function New_Copy_Tree
414 Map
: Elist_Id
:= No_Elist
;
415 New_Sloc
: Source_Ptr
:= No_Location
;
416 New_Scope
: Entity_Id
:= Empty
)
418 -- Given a node that is the root of a subtree, Copy_Tree copies the entire
419 -- syntactic subtree, including recursively any descendents whose parent
420 -- field references a copied node (descendents not linked to a copied node
421 -- by the parent field are not copied, instead the copied tree references
422 -- the same descendent as the original in this case, which is appropriate
423 -- for non-syntactic fields such as Etype). The parent pointers in the
424 -- copy are properly set. Copy_Tree (Empty/Error) returns Empty/Error.
425 -- The one exception to the rule of not copying semantic fields is that
426 -- any implicit types attached to the subtree are duplicated, so that
427 -- the copy contains a distinct set of implicit type entities. The Map
428 -- argument, if set to a non-empty Elist, specifies a set of mappings
429 -- to be applied to entities in the tree. The map has the form:
432 -- new entity to replace references to entity 1
434 -- new entity to replace references to entity 2
437 -- The call destroys the contents of Map in this case
439 -- The parameter New_Sloc, if set to a value other than No_Location, is
440 -- used as the Sloc value for all nodes in the new copy. If New_Sloc is
441 -- set to its default value No_Location, then the Sloc values of the
442 -- nodes in the copy are simply copied from the corresponding original.
444 -- The Comes_From_Source indication is unchanged if New_Sloc is set to
445 -- the default No_Location value, but is reset if New_Sloc is given, since
446 -- in this case the result clearly is neither a source node or an exact
447 -- copy of a source node.
449 -- The parameter New_Scope, if set to a value other than Empty, is the
450 -- value to use as the Scope for any Itypes that are copied. The most
451 -- typical value for this parameter, if given, is Current_Scope.
453 function Copy_Separate_Tree
(Source
: Node_Id
) return Node_Id
;
454 -- Given a node that is the root of a subtree, Copy_Separate_Tree copies
455 -- the entire syntactic subtree, including recursively any descendants
456 -- whose parent field references a copied node (descendants not linked to
457 -- a copied node by the parent field are also copied.) The parent pointers
458 -- in the copy are properly set. Copy_Separate_Tree (Empty/Error) returns
459 -- Empty/Error. The semantic fields are not copied and the new subtree
460 -- does not share any entity with source subtree.
461 -- But the code *does* copy semantic fields, and the description above
462 -- is in any case unclear on this point ??? (RBKD)
464 procedure Exchange_Entities
(E1
: Entity_Id
; E2
: Entity_Id
);
465 -- Exchange the contents of two entities. The parent pointers are switched
466 -- as well as the Defining_Identifier fields in the parents, so that the
467 -- entities point correctly to their original parents. The effect is thus
468 -- to leave the tree completely unchanged in structure, except that the
469 -- entity ID values of the two entities are interchanged. Neither of the
470 -- two entities may be list members.
472 procedure Delete_Node
(Node
: Node_Id
);
473 -- The node, which must not be a list member, is deleted from the tree and
474 -- its type is set to N_Unused_At_End. It is an error (not necessarily
475 -- detected) to reference this node after it has been deleted. The
476 -- implementation of the body of Atree is free to reuse the node to
477 -- satisfy future node allocation requests, but is not required to do so.
479 procedure Delete_Tree
(Node
: Node_Id
);
480 -- The entire syntactic subtree referenced by Node (i.e. the given node
481 -- and all its syntactic descendents) are deleted as described above for
484 function Extend_Node
(Node
: Node_Id
) return Entity_Id
;
485 -- This function returns a copy of its input node with an extension
486 -- added. The fields of the extension are set to Empty. Due to the way
487 -- extensions are handled (as two consecutive array elements), it may
488 -- be necessary to reallocate the node, so that the returned value is
489 -- not the same as the input value, but where possible the returned
490 -- value will be the same as the input value (i.e. the extension will
491 -- occur in place). It is the caller's responsibility to ensure that
492 -- any pointers to the original node are appropriately updated. This
493 -- function is used only by Sinfo.CN to change nodes into their
494 -- corresponding entities.
496 type Traverse_Result
is (OK
, OK_Orig
, Skip
, Abandon
);
497 -- This is the type of the result returned by the Process function passed
498 -- to Traverse_Func and Traverse_Proc and also the type of the result of
499 -- Traverse_Func itself. See descriptions below for details.
502 with function Process
(N
: Node_Id
) return Traverse_Result
is <>;
503 function Traverse_Func
(Node
: Node_Id
) return Traverse_Result
;
504 -- This is a generic function that, given the parent node for a subtree,
505 -- traverses all syntactic nodes of this tree, calling the given function
506 -- Process on each one. The traversal is controlled as follows by the
507 -- result returned by Process:
509 -- OK The traversal continues normally with the syntactic
510 -- children of the node just processed.
512 -- OK_Orig The traversal continues normally with the syntactic
513 -- children of the original node of the node just processed.
515 -- Skip The children of the node just processed are skipped and
516 -- excluded from the traversal, but otherwise processing
517 -- continues elsewhere in the tree.
519 -- Abandon The entire traversal is immediately abandoned, and the
520 -- original call to Traverse returns Abandon.
522 -- The result returned by Traverse is Abandon if processing was terminated
523 -- by a call to Process returning Abandon, otherwise it is OK (meaning that
524 -- all calls to process returned either OK or Skip).
527 with function Process
(N
: Node_Id
) return Traverse_Result
is <>;
528 procedure Traverse_Proc
(Node
: Node_Id
);
529 pragma Inline
(Traverse_Proc
);
530 -- This is similar to Traverse_Func except that no result is returned,
531 -- i.e. Traverse_Func is called and the result is simply discarded.
533 ---------------------------
534 -- Node Access Functions --
535 ---------------------------
537 -- The following functions return the contents of the indicated field of
538 -- the node referenced by the argument, which is a Node_Id.
540 function Nkind
(N
: Node_Id
) return Node_Kind
;
541 pragma Inline
(Nkind
);
543 function Analyzed
(N
: Node_Id
) return Boolean;
544 pragma Inline
(Analyzed
);
546 function Comes_From_Source
(N
: Node_Id
) return Boolean;
547 pragma Inline
(Comes_From_Source
);
549 function Error_Posted
(N
: Node_Id
) return Boolean;
550 pragma Inline
(Error_Posted
);
552 function Sloc
(N
: Node_Id
) return Source_Ptr
;
553 pragma Inline
(Sloc
);
555 function Paren_Count
(N
: Node_Id
) return Paren_Count_Type
;
556 pragma Inline
(Paren_Count
);
558 function Parent
(N
: Node_Id
) return Node_Id
;
559 pragma Inline
(Parent
);
560 -- Returns the parent of a node if the node is not a list member, or
561 -- else the parent of the list containing the node if the node is a
564 function No
(N
: Node_Id
) return Boolean;
566 -- Tests given Id for equality with the Empty node. This allows notations
567 -- like "if No (Variant_Part)" as opposed to "if Variant_Part = Empty".
569 function Present
(N
: Node_Id
) return Boolean;
570 pragma Inline
(Present
);
571 -- Tests given Id for inequality with the Empty node. This allows notations
572 -- like "if Present (Statement)" as opposed to "if Statement /= Empty".
574 -----------------------------
575 -- Entity Access Functions --
576 -----------------------------
578 -- The following functions apply only to Entity_Id values, i.e.
579 -- to extended nodes.
581 function Ekind
(E
: Entity_Id
) return Entity_Kind
;
582 pragma Inline
(Ekind
);
584 function Convention
(E
: Entity_Id
) return Convention_Id
;
585 pragma Inline
(Convention
);
587 ----------------------------
588 -- Node Update Procedures --
589 ----------------------------
591 -- The following functions set a specified field in the node whose Id is
592 -- passed as the first argument. The second parameter is the new value
593 -- to be set in the specified field. Note that Set_Nkind is in the next
594 -- section, since its use is restricted.
596 procedure Set_Sloc
(N
: Node_Id
; Val
: Source_Ptr
);
597 pragma Inline
(Set_Sloc
);
599 procedure Set_Paren_Count
(N
: Node_Id
; Val
: Paren_Count_Type
);
600 pragma Inline
(Set_Paren_Count
);
602 procedure Set_Parent
(N
: Node_Id
; Val
: Node_Id
);
603 pragma Inline
(Set_Parent
);
605 procedure Set_Analyzed
(N
: Node_Id
; Val
: Boolean := True);
606 pragma Inline
(Set_Analyzed
);
608 procedure Set_Error_Posted
(N
: Node_Id
; Val
: Boolean := True);
609 pragma Inline
(Set_Error_Posted
);
611 procedure Set_Comes_From_Source
(N
: Node_Id
; Val
: Boolean);
612 pragma Inline
(Set_Comes_From_Source
);
613 -- Note that this routine is very rarely used, since usually the
614 -- default mechanism provided sets the right value, but in some
615 -- unusual cases, the value needs to be reset (e.g. when a source
616 -- node is copied, and the copy must not have Comes_From_Source set.
618 ------------------------------
619 -- Entity Update Procedures --
620 ------------------------------
622 -- The following procedures apply only to Entity_Id values, i.e.
623 -- to extended nodes.
625 procedure Set_Ekind
(E
: Entity_Id
; Val
: Entity_Kind
);
626 pragma Inline
(Set_Ekind
);
628 procedure Set_Convention
(E
: Entity_Id
; Val
: Convention_Id
);
629 pragma Inline
(Set_Convention
);
631 ---------------------------
632 -- Tree Rewrite Routines --
633 ---------------------------
635 -- During the compilation process it is necessary in a number of situations
636 -- to rewrite the tree. In some cases, such rewrites do not affect the
637 -- structure of the tree, for example, when an indexed component node is
638 -- replaced by the corresponding call node (the parser cannot distinguish
639 -- between these two cases).
641 -- In other situations, the rewrite does affect the structure of the
642 -- tree. Examples are the replacement of a generic instantiation by the
643 -- instantiated spec and body, and the static evaluation of expressions.
645 -- If such structural modifications are done by the expander, there are
646 -- no difficulties, since the form of the tree after the expander has no
647 -- special significance, except as input to the backend of the compiler.
648 -- However, if these modifications are done by the semantic phase, then
649 -- it is important that they be done in a manner which allows the original
650 -- tree to be preserved. This is because tools like pretty printers need
651 -- to have this original tree structure available.
653 -- The subprograms in this section allow rewriting of the tree by either
654 -- insertion of new nodes in an existing list, or complete replacement of
655 -- a subtree. The resulting tree for most purposes looks as though it has
656 -- been really changed, and there is no trace of the original. However,
657 -- special subprograms, also defined in this section, allow the original
658 -- tree to be reconstructed if necessary.
660 -- For tree modifications done in the expander, it is permissible to
661 -- destroy the original tree, although it is also allowable to use the
662 -- tree rewrite routines where it is convenient to do so.
664 procedure Mark_Rewrite_Insertion
(New_Node
: Node_Id
);
665 pragma Inline
(Mark_Rewrite_Insertion
);
666 -- This procedure marks the given node as an insertion made during a tree
667 -- rewriting operation. Only the root needs to be marked. The call does
668 -- not do the actual insertion, which must be done using one of the normal
669 -- list insertion routines. The node is treated normally in all respects
670 -- except for its response to Is_Rewrite_Insertion. The function of these
671 -- calls is to be able to get an accurate original tree. This helps the
672 -- accuracy of Sprint.Sprint_Node, and in particular, when stubs are being
673 -- generated, it is essential that the original tree be accurate.
675 function Is_Rewrite_Insertion
(Node
: Node_Id
) return Boolean;
676 pragma Inline
(Is_Rewrite_Insertion
);
677 -- Tests whether the given node was marked using Set_Rewrite_Insert. This
678 -- is used in reconstructing the original tree (where such nodes are to
679 -- be eliminated from the reconstructed tree).
681 procedure Rewrite
(Old_Node
, New_Node
: Node_Id
);
682 -- This is used when a complete subtree is to be replaced. Old_Node is the
683 -- root of the old subtree to be replaced, and New_Node is the root of the
684 -- newly constructed replacement subtree. The actual mechanism is to swap
685 -- the contents of these two nodes fixing up the parent pointers of the
686 -- replaced node (we do not attempt to preserve parent pointers for the
687 -- original node). Neither Old_Node nor New_Node can be extended nodes.
689 -- Note: New_Node may not contain references to Old_Node, for example as
690 -- descendents, since the rewrite would make such references invalid. If
691 -- New_Node does need to reference Old_Node, then these references should
692 -- be to a relocated copy of Old_Node (see Relocate_Node procedure).
694 -- Note: The Original_Node function applied to Old_Node (which has now
695 -- been replaced by the contents of New_Node), can be used to obtain the
696 -- original node, i.e. the old contents of Old_Node.
698 procedure Replace
(Old_Node
, New_Node
: Node_Id
);
699 -- This is similar to Rewrite, except that the old value of Old_Node is
700 -- not saved, and the New_Node is deleted after the replace, since it
701 -- is assumed that it can no longer be legitimately needed. The flag
702 -- Is_Rewrite_Susbtitute will be False for the resulting node, unless
703 -- it was already true on entry, and Original_Node will not return the
704 -- original contents of the Old_Node, but rather the New_Node value (unless
705 -- Old_Node had already been rewritten using Rewrite). Replace also
706 -- preserves the setting of Comes_From_Source.
708 -- Note, New_Node may not contain references to Old_Node, for example as
709 -- descendents, since the rewrite would make such references invalid. If
710 -- New_Node does need to reference Old_Node, then these references should
711 -- be to a relocated copy of Old_Node (see Relocate_Node procedure).
713 -- Replace is used in certain circumstances where it is desirable to
714 -- suppress any history of the rewriting operation. Notably, it is used
715 -- when the parser has mis-classified a node (e.g. a task entry call
716 -- that the parser has parsed as a procedure call).
718 function Is_Rewrite_Substitution
(Node
: Node_Id
) return Boolean;
719 pragma Inline
(Is_Rewrite_Substitution
);
720 -- Return True iff Node has been rewritten (i.e. if Node is the root
721 -- of a subtree which was installed using Rewrite).
723 function Original_Node
(Node
: Node_Id
) return Node_Id
;
724 pragma Inline
(Original_Node
);
725 -- If Node has not been rewritten, then returns its input argument
726 -- unchanged, else returns the Node for the original subtree.
728 -- Note: Parents are not preserved in original tree nodes that are
729 -- retrieved in this way (i.e. their children may have children whose
730 -- pointers which reference some other node).
732 -- Note: there is no direct mechanism for deleting an original node (in
733 -- a manner that can be reversed later). One possible approach is to use
734 -- Rewrite to substitute a null statement for the node to be deleted.
736 -----------------------------------
737 -- Generic Field Access Routines --
738 -----------------------------------
740 -- This subpackage provides the functions for accessing and procedures
741 -- for setting fields that are normally referenced by their logical
742 -- synonyms defined in packages Sinfo and Einfo. As previously
743 -- described the implementations of these packages use the package
744 -- Atree.Unchecked_Access.
746 package Unchecked_Access
is
748 -- Functions to allow interpretation of Union_Id values as Uint
751 function To_Union
is new Unchecked_Conversion
(Uint
, Union_Id
);
752 function To_Union
is new Unchecked_Conversion
(Ureal
, Union_Id
);
754 function From_Union
is new Unchecked_Conversion
(Union_Id
, Uint
);
755 function From_Union
is new Unchecked_Conversion
(Union_Id
, Ureal
);
757 -- Functions to fetch contents of indicated field. It is an error
758 -- to attempt to read the value of a field which is not present.
760 function Field1
(N
: Node_Id
) return Union_Id
;
761 pragma Inline
(Field1
);
763 function Field2
(N
: Node_Id
) return Union_Id
;
764 pragma Inline
(Field2
);
766 function Field3
(N
: Node_Id
) return Union_Id
;
767 pragma Inline
(Field3
);
769 function Field4
(N
: Node_Id
) return Union_Id
;
770 pragma Inline
(Field4
);
772 function Field5
(N
: Node_Id
) return Union_Id
;
773 pragma Inline
(Field5
);
775 function Field6
(N
: Node_Id
) return Union_Id
;
776 pragma Inline
(Field6
);
778 function Field7
(N
: Node_Id
) return Union_Id
;
779 pragma Inline
(Field7
);
781 function Field8
(N
: Node_Id
) return Union_Id
;
782 pragma Inline
(Field8
);
784 function Field9
(N
: Node_Id
) return Union_Id
;
785 pragma Inline
(Field9
);
787 function Field10
(N
: Node_Id
) return Union_Id
;
788 pragma Inline
(Field10
);
790 function Field11
(N
: Node_Id
) return Union_Id
;
791 pragma Inline
(Field11
);
793 function Field12
(N
: Node_Id
) return Union_Id
;
794 pragma Inline
(Field12
);
796 function Field13
(N
: Node_Id
) return Union_Id
;
797 pragma Inline
(Field13
);
799 function Field14
(N
: Node_Id
) return Union_Id
;
800 pragma Inline
(Field14
);
802 function Field15
(N
: Node_Id
) return Union_Id
;
803 pragma Inline
(Field15
);
805 function Field16
(N
: Node_Id
) return Union_Id
;
806 pragma Inline
(Field16
);
808 function Field17
(N
: Node_Id
) return Union_Id
;
809 pragma Inline
(Field17
);
811 function Field18
(N
: Node_Id
) return Union_Id
;
812 pragma Inline
(Field18
);
814 function Field19
(N
: Node_Id
) return Union_Id
;
815 pragma Inline
(Field19
);
817 function Field20
(N
: Node_Id
) return Union_Id
;
818 pragma Inline
(Field20
);
820 function Field21
(N
: Node_Id
) return Union_Id
;
821 pragma Inline
(Field21
);
823 function Field22
(N
: Node_Id
) return Union_Id
;
824 pragma Inline
(Field22
);
826 function Field23
(N
: Node_Id
) return Union_Id
;
827 pragma Inline
(Field23
);
829 function Node1
(N
: Node_Id
) return Node_Id
;
830 pragma Inline
(Node1
);
832 function Node2
(N
: Node_Id
) return Node_Id
;
833 pragma Inline
(Node2
);
835 function Node3
(N
: Node_Id
) return Node_Id
;
836 pragma Inline
(Node3
);
838 function Node4
(N
: Node_Id
) return Node_Id
;
839 pragma Inline
(Node4
);
841 function Node5
(N
: Node_Id
) return Node_Id
;
842 pragma Inline
(Node5
);
844 function Node6
(N
: Node_Id
) return Node_Id
;
845 pragma Inline
(Node6
);
847 function Node7
(N
: Node_Id
) return Node_Id
;
848 pragma Inline
(Node7
);
850 function Node8
(N
: Node_Id
) return Node_Id
;
851 pragma Inline
(Node8
);
853 function Node9
(N
: Node_Id
) return Node_Id
;
854 pragma Inline
(Node9
);
856 function Node10
(N
: Node_Id
) return Node_Id
;
857 pragma Inline
(Node10
);
859 function Node11
(N
: Node_Id
) return Node_Id
;
860 pragma Inline
(Node11
);
862 function Node12
(N
: Node_Id
) return Node_Id
;
863 pragma Inline
(Node12
);
865 function Node13
(N
: Node_Id
) return Node_Id
;
866 pragma Inline
(Node13
);
868 function Node14
(N
: Node_Id
) return Node_Id
;
869 pragma Inline
(Node14
);
871 function Node15
(N
: Node_Id
) return Node_Id
;
872 pragma Inline
(Node15
);
874 function Node16
(N
: Node_Id
) return Node_Id
;
875 pragma Inline
(Node16
);
877 function Node17
(N
: Node_Id
) return Node_Id
;
878 pragma Inline
(Node17
);
880 function Node18
(N
: Node_Id
) return Node_Id
;
881 pragma Inline
(Node18
);
883 function Node19
(N
: Node_Id
) return Node_Id
;
884 pragma Inline
(Node19
);
886 function Node20
(N
: Node_Id
) return Node_Id
;
887 pragma Inline
(Node20
);
889 function Node21
(N
: Node_Id
) return Node_Id
;
890 pragma Inline
(Node21
);
892 function Node22
(N
: Node_Id
) return Node_Id
;
893 pragma Inline
(Node22
);
895 function Node23
(N
: Node_Id
) return Node_Id
;
896 pragma Inline
(Node23
);
898 function List1
(N
: Node_Id
) return List_Id
;
899 pragma Inline
(List1
);
901 function List2
(N
: Node_Id
) return List_Id
;
902 pragma Inline
(List2
);
904 function List3
(N
: Node_Id
) return List_Id
;
905 pragma Inline
(List3
);
907 function List4
(N
: Node_Id
) return List_Id
;
908 pragma Inline
(List4
);
910 function List5
(N
: Node_Id
) return List_Id
;
911 pragma Inline
(List5
);
913 function List10
(N
: Node_Id
) return List_Id
;
914 pragma Inline
(List10
);
916 function List14
(N
: Node_Id
) return List_Id
;
917 pragma Inline
(List14
);
919 function Elist2
(N
: Node_Id
) return Elist_Id
;
920 pragma Inline
(Elist2
);
922 function Elist3
(N
: Node_Id
) return Elist_Id
;
923 pragma Inline
(Elist3
);
925 function Elist4
(N
: Node_Id
) return Elist_Id
;
926 pragma Inline
(Elist4
);
928 function Elist8
(N
: Node_Id
) return Elist_Id
;
929 pragma Inline
(Elist8
);
931 function Elist13
(N
: Node_Id
) return Elist_Id
;
932 pragma Inline
(Elist13
);
934 function Elist15
(N
: Node_Id
) return Elist_Id
;
935 pragma Inline
(Elist15
);
937 function Elist16
(N
: Node_Id
) return Elist_Id
;
938 pragma Inline
(Elist16
);
940 function Elist18
(N
: Node_Id
) return Elist_Id
;
941 pragma Inline
(Elist18
);
943 function Elist21
(N
: Node_Id
) return Elist_Id
;
944 pragma Inline
(Elist21
);
946 function Elist23
(N
: Node_Id
) return Elist_Id
;
947 pragma Inline
(Elist23
);
949 function Name1
(N
: Node_Id
) return Name_Id
;
950 pragma Inline
(Name1
);
952 function Name2
(N
: Node_Id
) return Name_Id
;
953 pragma Inline
(Name2
);
955 function Char_Code2
(N
: Node_Id
) return Char_Code
;
956 pragma Inline
(Char_Code2
);
958 function Str3
(N
: Node_Id
) return String_Id
;
959 pragma Inline
(Str3
);
961 -- Note: the following Uintnn functions have a special test for
962 -- the Field value being Empty. If an Empty value is found then
963 -- Uint_0 is returned. This avoids the rather tricky requirement
964 -- of initializing all Uint fields in nodes and entities.
966 function Uint3
(N
: Node_Id
) return Uint
;
967 pragma Inline
(Uint3
);
969 function Uint4
(N
: Node_Id
) return Uint
;
970 pragma Inline
(Uint4
);
972 function Uint5
(N
: Node_Id
) return Uint
;
973 pragma Inline
(Uint5
);
975 function Uint8
(N
: Node_Id
) return Uint
;
976 pragma Inline
(Uint8
);
978 function Uint9
(N
: Node_Id
) return Uint
;
979 pragma Inline
(Uint9
);
981 function Uint10
(N
: Node_Id
) return Uint
;
982 pragma Inline
(Uint10
);
984 function Uint11
(N
: Node_Id
) return Uint
;
985 pragma Inline
(Uint11
);
987 function Uint12
(N
: Node_Id
) return Uint
;
988 pragma Inline
(Uint12
);
990 function Uint13
(N
: Node_Id
) return Uint
;
991 pragma Inline
(Uint13
);
993 function Uint14
(N
: Node_Id
) return Uint
;
994 pragma Inline
(Uint14
);
996 function Uint15
(N
: Node_Id
) return Uint
;
997 pragma Inline
(Uint15
);
999 function Uint16
(N
: Node_Id
) return Uint
;
1000 pragma Inline
(Uint16
);
1002 function Uint17
(N
: Node_Id
) return Uint
;
1003 pragma Inline
(Uint17
);
1005 function Uint22
(N
: Node_Id
) return Uint
;
1006 pragma Inline
(Uint22
);
1008 function Ureal3
(N
: Node_Id
) return Ureal
;
1009 pragma Inline
(Ureal3
);
1011 function Ureal18
(N
: Node_Id
) return Ureal
;
1012 pragma Inline
(Ureal18
);
1014 function Ureal21
(N
: Node_Id
) return Ureal
;
1015 pragma Inline
(Ureal21
);
1017 function Flag4
(N
: Node_Id
) return Boolean;
1018 pragma Inline
(Flag4
);
1020 function Flag5
(N
: Node_Id
) return Boolean;
1021 pragma Inline
(Flag5
);
1023 function Flag6
(N
: Node_Id
) return Boolean;
1024 pragma Inline
(Flag6
);
1026 function Flag7
(N
: Node_Id
) return Boolean;
1027 pragma Inline
(Flag7
);
1029 function Flag8
(N
: Node_Id
) return Boolean;
1030 pragma Inline
(Flag8
);
1032 function Flag9
(N
: Node_Id
) return Boolean;
1033 pragma Inline
(Flag9
);
1035 function Flag10
(N
: Node_Id
) return Boolean;
1036 pragma Inline
(Flag10
);
1038 function Flag11
(N
: Node_Id
) return Boolean;
1039 pragma Inline
(Flag11
);
1041 function Flag12
(N
: Node_Id
) return Boolean;
1042 pragma Inline
(Flag12
);
1044 function Flag13
(N
: Node_Id
) return Boolean;
1045 pragma Inline
(Flag13
);
1047 function Flag14
(N
: Node_Id
) return Boolean;
1048 pragma Inline
(Flag14
);
1050 function Flag15
(N
: Node_Id
) return Boolean;
1051 pragma Inline
(Flag15
);
1053 function Flag16
(N
: Node_Id
) return Boolean;
1054 pragma Inline
(Flag16
);
1056 function Flag17
(N
: Node_Id
) return Boolean;
1057 pragma Inline
(Flag17
);
1059 function Flag18
(N
: Node_Id
) return Boolean;
1060 pragma Inline
(Flag18
);
1062 function Flag19
(N
: Node_Id
) return Boolean;
1063 pragma Inline
(Flag19
);
1065 function Flag20
(N
: Node_Id
) return Boolean;
1066 pragma Inline
(Flag20
);
1068 function Flag21
(N
: Node_Id
) return Boolean;
1069 pragma Inline
(Flag21
);
1071 function Flag22
(N
: Node_Id
) return Boolean;
1072 pragma Inline
(Flag22
);
1074 function Flag23
(N
: Node_Id
) return Boolean;
1075 pragma Inline
(Flag23
);
1077 function Flag24
(N
: Node_Id
) return Boolean;
1078 pragma Inline
(Flag24
);
1080 function Flag25
(N
: Node_Id
) return Boolean;
1081 pragma Inline
(Flag25
);
1083 function Flag26
(N
: Node_Id
) return Boolean;
1084 pragma Inline
(Flag26
);
1086 function Flag27
(N
: Node_Id
) return Boolean;
1087 pragma Inline
(Flag27
);
1089 function Flag28
(N
: Node_Id
) return Boolean;
1090 pragma Inline
(Flag28
);
1092 function Flag29
(N
: Node_Id
) return Boolean;
1093 pragma Inline
(Flag29
);
1095 function Flag30
(N
: Node_Id
) return Boolean;
1096 pragma Inline
(Flag30
);
1098 function Flag31
(N
: Node_Id
) return Boolean;
1099 pragma Inline
(Flag31
);
1101 function Flag32
(N
: Node_Id
) return Boolean;
1102 pragma Inline
(Flag32
);
1104 function Flag33
(N
: Node_Id
) return Boolean;
1105 pragma Inline
(Flag33
);
1107 function Flag34
(N
: Node_Id
) return Boolean;
1108 pragma Inline
(Flag34
);
1110 function Flag35
(N
: Node_Id
) return Boolean;
1111 pragma Inline
(Flag35
);
1113 function Flag36
(N
: Node_Id
) return Boolean;
1114 pragma Inline
(Flag36
);
1116 function Flag37
(N
: Node_Id
) return Boolean;
1117 pragma Inline
(Flag37
);
1119 function Flag38
(N
: Node_Id
) return Boolean;
1120 pragma Inline
(Flag38
);
1122 function Flag39
(N
: Node_Id
) return Boolean;
1123 pragma Inline
(Flag39
);
1125 function Flag40
(N
: Node_Id
) return Boolean;
1126 pragma Inline
(Flag40
);
1128 function Flag41
(N
: Node_Id
) return Boolean;
1129 pragma Inline
(Flag41
);
1131 function Flag42
(N
: Node_Id
) return Boolean;
1132 pragma Inline
(Flag42
);
1134 function Flag43
(N
: Node_Id
) return Boolean;
1135 pragma Inline
(Flag43
);
1137 function Flag44
(N
: Node_Id
) return Boolean;
1138 pragma Inline
(Flag44
);
1140 function Flag45
(N
: Node_Id
) return Boolean;
1141 pragma Inline
(Flag45
);
1143 function Flag46
(N
: Node_Id
) return Boolean;
1144 pragma Inline
(Flag46
);
1146 function Flag47
(N
: Node_Id
) return Boolean;
1147 pragma Inline
(Flag47
);
1149 function Flag48
(N
: Node_Id
) return Boolean;
1150 pragma Inline
(Flag48
);
1152 function Flag49
(N
: Node_Id
) return Boolean;
1153 pragma Inline
(Flag49
);
1155 function Flag50
(N
: Node_Id
) return Boolean;
1156 pragma Inline
(Flag50
);
1158 function Flag51
(N
: Node_Id
) return Boolean;
1159 pragma Inline
(Flag51
);
1161 function Flag52
(N
: Node_Id
) return Boolean;
1162 pragma Inline
(Flag52
);
1164 function Flag53
(N
: Node_Id
) return Boolean;
1165 pragma Inline
(Flag53
);
1167 function Flag54
(N
: Node_Id
) return Boolean;
1168 pragma Inline
(Flag54
);
1170 function Flag55
(N
: Node_Id
) return Boolean;
1171 pragma Inline
(Flag55
);
1173 function Flag56
(N
: Node_Id
) return Boolean;
1174 pragma Inline
(Flag56
);
1176 function Flag57
(N
: Node_Id
) return Boolean;
1177 pragma Inline
(Flag57
);
1179 function Flag58
(N
: Node_Id
) return Boolean;
1180 pragma Inline
(Flag58
);
1182 function Flag59
(N
: Node_Id
) return Boolean;
1183 pragma Inline
(Flag59
);
1185 function Flag60
(N
: Node_Id
) return Boolean;
1186 pragma Inline
(Flag60
);
1188 function Flag61
(N
: Node_Id
) return Boolean;
1189 pragma Inline
(Flag61
);
1191 function Flag62
(N
: Node_Id
) return Boolean;
1192 pragma Inline
(Flag62
);
1194 function Flag63
(N
: Node_Id
) return Boolean;
1195 pragma Inline
(Flag63
);
1197 function Flag64
(N
: Node_Id
) return Boolean;
1198 pragma Inline
(Flag64
);
1200 function Flag65
(N
: Node_Id
) return Boolean;
1201 pragma Inline
(Flag65
);
1203 function Flag66
(N
: Node_Id
) return Boolean;
1204 pragma Inline
(Flag66
);
1206 function Flag67
(N
: Node_Id
) return Boolean;
1207 pragma Inline
(Flag67
);
1209 function Flag68
(N
: Node_Id
) return Boolean;
1210 pragma Inline
(Flag68
);
1212 function Flag69
(N
: Node_Id
) return Boolean;
1213 pragma Inline
(Flag69
);
1215 function Flag70
(N
: Node_Id
) return Boolean;
1216 pragma Inline
(Flag70
);
1218 function Flag71
(N
: Node_Id
) return Boolean;
1219 pragma Inline
(Flag71
);
1221 function Flag72
(N
: Node_Id
) return Boolean;
1222 pragma Inline
(Flag72
);
1224 function Flag73
(N
: Node_Id
) return Boolean;
1225 pragma Inline
(Flag73
);
1227 function Flag74
(N
: Node_Id
) return Boolean;
1228 pragma Inline
(Flag74
);
1230 function Flag75
(N
: Node_Id
) return Boolean;
1231 pragma Inline
(Flag75
);
1233 function Flag76
(N
: Node_Id
) return Boolean;
1234 pragma Inline
(Flag76
);
1236 function Flag77
(N
: Node_Id
) return Boolean;
1237 pragma Inline
(Flag77
);
1239 function Flag78
(N
: Node_Id
) return Boolean;
1240 pragma Inline
(Flag78
);
1242 function Flag79
(N
: Node_Id
) return Boolean;
1243 pragma Inline
(Flag79
);
1245 function Flag80
(N
: Node_Id
) return Boolean;
1246 pragma Inline
(Flag80
);
1248 function Flag81
(N
: Node_Id
) return Boolean;
1249 pragma Inline
(Flag81
);
1251 function Flag82
(N
: Node_Id
) return Boolean;
1252 pragma Inline
(Flag82
);
1254 function Flag83
(N
: Node_Id
) return Boolean;
1255 pragma Inline
(Flag83
);
1257 function Flag84
(N
: Node_Id
) return Boolean;
1258 pragma Inline
(Flag84
);
1260 function Flag85
(N
: Node_Id
) return Boolean;
1261 pragma Inline
(Flag85
);
1263 function Flag86
(N
: Node_Id
) return Boolean;
1264 pragma Inline
(Flag86
);
1266 function Flag87
(N
: Node_Id
) return Boolean;
1267 pragma Inline
(Flag87
);
1269 function Flag88
(N
: Node_Id
) return Boolean;
1270 pragma Inline
(Flag88
);
1272 function Flag89
(N
: Node_Id
) return Boolean;
1273 pragma Inline
(Flag89
);
1275 function Flag90
(N
: Node_Id
) return Boolean;
1276 pragma Inline
(Flag90
);
1278 function Flag91
(N
: Node_Id
) return Boolean;
1279 pragma Inline
(Flag91
);
1281 function Flag92
(N
: Node_Id
) return Boolean;
1282 pragma Inline
(Flag92
);
1284 function Flag93
(N
: Node_Id
) return Boolean;
1285 pragma Inline
(Flag93
);
1287 function Flag94
(N
: Node_Id
) return Boolean;
1288 pragma Inline
(Flag94
);
1290 function Flag95
(N
: Node_Id
) return Boolean;
1291 pragma Inline
(Flag95
);
1293 function Flag96
(N
: Node_Id
) return Boolean;
1294 pragma Inline
(Flag96
);
1296 function Flag97
(N
: Node_Id
) return Boolean;
1297 pragma Inline
(Flag97
);
1299 function Flag98
(N
: Node_Id
) return Boolean;
1300 pragma Inline
(Flag98
);
1302 function Flag99
(N
: Node_Id
) return Boolean;
1303 pragma Inline
(Flag99
);
1305 function Flag100
(N
: Node_Id
) return Boolean;
1306 pragma Inline
(Flag100
);
1308 function Flag101
(N
: Node_Id
) return Boolean;
1309 pragma Inline
(Flag101
);
1311 function Flag102
(N
: Node_Id
) return Boolean;
1312 pragma Inline
(Flag102
);
1314 function Flag103
(N
: Node_Id
) return Boolean;
1315 pragma Inline
(Flag103
);
1317 function Flag104
(N
: Node_Id
) return Boolean;
1318 pragma Inline
(Flag104
);
1320 function Flag105
(N
: Node_Id
) return Boolean;
1321 pragma Inline
(Flag105
);
1323 function Flag106
(N
: Node_Id
) return Boolean;
1324 pragma Inline
(Flag106
);
1326 function Flag107
(N
: Node_Id
) return Boolean;
1327 pragma Inline
(Flag107
);
1329 function Flag108
(N
: Node_Id
) return Boolean;
1330 pragma Inline
(Flag108
);
1332 function Flag109
(N
: Node_Id
) return Boolean;
1333 pragma Inline
(Flag109
);
1335 function Flag110
(N
: Node_Id
) return Boolean;
1336 pragma Inline
(Flag110
);
1338 function Flag111
(N
: Node_Id
) return Boolean;
1339 pragma Inline
(Flag111
);
1341 function Flag112
(N
: Node_Id
) return Boolean;
1342 pragma Inline
(Flag112
);
1344 function Flag113
(N
: Node_Id
) return Boolean;
1345 pragma Inline
(Flag113
);
1347 function Flag114
(N
: Node_Id
) return Boolean;
1348 pragma Inline
(Flag114
);
1350 function Flag115
(N
: Node_Id
) return Boolean;
1351 pragma Inline
(Flag115
);
1353 function Flag116
(N
: Node_Id
) return Boolean;
1354 pragma Inline
(Flag116
);
1356 function Flag117
(N
: Node_Id
) return Boolean;
1357 pragma Inline
(Flag117
);
1359 function Flag118
(N
: Node_Id
) return Boolean;
1360 pragma Inline
(Flag118
);
1362 function Flag119
(N
: Node_Id
) return Boolean;
1363 pragma Inline
(Flag119
);
1365 function Flag120
(N
: Node_Id
) return Boolean;
1366 pragma Inline
(Flag120
);
1368 function Flag121
(N
: Node_Id
) return Boolean;
1369 pragma Inline
(Flag121
);
1371 function Flag122
(N
: Node_Id
) return Boolean;
1372 pragma Inline
(Flag122
);
1374 function Flag123
(N
: Node_Id
) return Boolean;
1375 pragma Inline
(Flag123
);
1377 function Flag124
(N
: Node_Id
) return Boolean;
1378 pragma Inline
(Flag124
);
1380 function Flag125
(N
: Node_Id
) return Boolean;
1381 pragma Inline
(Flag125
);
1383 function Flag126
(N
: Node_Id
) return Boolean;
1384 pragma Inline
(Flag126
);
1386 function Flag127
(N
: Node_Id
) return Boolean;
1387 pragma Inline
(Flag127
);
1389 function Flag128
(N
: Node_Id
) return Boolean;
1390 pragma Inline
(Flag128
);
1392 function Flag129
(N
: Node_Id
) return Boolean;
1393 pragma Inline
(Flag129
);
1395 function Flag130
(N
: Node_Id
) return Boolean;
1396 pragma Inline
(Flag130
);
1398 function Flag131
(N
: Node_Id
) return Boolean;
1399 pragma Inline
(Flag131
);
1401 function Flag132
(N
: Node_Id
) return Boolean;
1402 pragma Inline
(Flag132
);
1404 function Flag133
(N
: Node_Id
) return Boolean;
1405 pragma Inline
(Flag133
);
1407 function Flag134
(N
: Node_Id
) return Boolean;
1408 pragma Inline
(Flag134
);
1410 function Flag135
(N
: Node_Id
) return Boolean;
1411 pragma Inline
(Flag135
);
1413 function Flag136
(N
: Node_Id
) return Boolean;
1414 pragma Inline
(Flag136
);
1416 function Flag137
(N
: Node_Id
) return Boolean;
1417 pragma Inline
(Flag137
);
1419 function Flag138
(N
: Node_Id
) return Boolean;
1420 pragma Inline
(Flag138
);
1422 function Flag139
(N
: Node_Id
) return Boolean;
1423 pragma Inline
(Flag139
);
1425 function Flag140
(N
: Node_Id
) return Boolean;
1426 pragma Inline
(Flag140
);
1428 function Flag141
(N
: Node_Id
) return Boolean;
1429 pragma Inline
(Flag141
);
1431 function Flag142
(N
: Node_Id
) return Boolean;
1432 pragma Inline
(Flag142
);
1434 function Flag143
(N
: Node_Id
) return Boolean;
1435 pragma Inline
(Flag143
);
1437 function Flag144
(N
: Node_Id
) return Boolean;
1438 pragma Inline
(Flag144
);
1440 function Flag145
(N
: Node_Id
) return Boolean;
1441 pragma Inline
(Flag145
);
1443 function Flag146
(N
: Node_Id
) return Boolean;
1444 pragma Inline
(Flag146
);
1446 function Flag147
(N
: Node_Id
) return Boolean;
1447 pragma Inline
(Flag147
);
1449 function Flag148
(N
: Node_Id
) return Boolean;
1450 pragma Inline
(Flag148
);
1452 function Flag149
(N
: Node_Id
) return Boolean;
1453 pragma Inline
(Flag149
);
1455 function Flag150
(N
: Node_Id
) return Boolean;
1456 pragma Inline
(Flag150
);
1458 function Flag151
(N
: Node_Id
) return Boolean;
1459 pragma Inline
(Flag151
);
1461 function Flag152
(N
: Node_Id
) return Boolean;
1462 pragma Inline
(Flag151
);
1464 function Flag153
(N
: Node_Id
) return Boolean;
1465 pragma Inline
(Flag151
);
1467 function Flag154
(N
: Node_Id
) return Boolean;
1468 pragma Inline
(Flag151
);
1470 function Flag155
(N
: Node_Id
) return Boolean;
1471 pragma Inline
(Flag151
);
1473 function Flag156
(N
: Node_Id
) return Boolean;
1474 pragma Inline
(Flag151
);
1476 function Flag157
(N
: Node_Id
) return Boolean;
1477 pragma Inline
(Flag151
);
1479 function Flag158
(N
: Node_Id
) return Boolean;
1480 pragma Inline
(Flag151
);
1482 function Flag159
(N
: Node_Id
) return Boolean;
1483 pragma Inline
(Flag159
);
1485 function Flag160
(N
: Node_Id
) return Boolean;
1486 pragma Inline
(Flag160
);
1488 function Flag161
(N
: Node_Id
) return Boolean;
1489 pragma Inline
(Flag161
);
1491 function Flag162
(N
: Node_Id
) return Boolean;
1492 pragma Inline
(Flag162
);
1494 function Flag163
(N
: Node_Id
) return Boolean;
1495 pragma Inline
(Flag163
);
1497 function Flag164
(N
: Node_Id
) return Boolean;
1498 pragma Inline
(Flag164
);
1500 function Flag165
(N
: Node_Id
) return Boolean;
1501 pragma Inline
(Flag165
);
1503 function Flag166
(N
: Node_Id
) return Boolean;
1504 pragma Inline
(Flag166
);
1506 function Flag167
(N
: Node_Id
) return Boolean;
1507 pragma Inline
(Flag167
);
1509 function Flag168
(N
: Node_Id
) return Boolean;
1510 pragma Inline
(Flag168
);
1512 function Flag169
(N
: Node_Id
) return Boolean;
1513 pragma Inline
(Flag169
);
1515 function Flag170
(N
: Node_Id
) return Boolean;
1516 pragma Inline
(Flag170
);
1518 function Flag171
(N
: Node_Id
) return Boolean;
1519 pragma Inline
(Flag171
);
1521 function Flag172
(N
: Node_Id
) return Boolean;
1522 pragma Inline
(Flag172
);
1524 function Flag173
(N
: Node_Id
) return Boolean;
1525 pragma Inline
(Flag173
);
1527 function Flag174
(N
: Node_Id
) return Boolean;
1528 pragma Inline
(Flag174
);
1530 function Flag175
(N
: Node_Id
) return Boolean;
1531 pragma Inline
(Flag175
);
1533 function Flag176
(N
: Node_Id
) return Boolean;
1534 pragma Inline
(Flag176
);
1536 function Flag177
(N
: Node_Id
) return Boolean;
1537 pragma Inline
(Flag177
);
1539 function Flag178
(N
: Node_Id
) return Boolean;
1540 pragma Inline
(Flag178
);
1542 function Flag179
(N
: Node_Id
) return Boolean;
1543 pragma Inline
(Flag179
);
1545 function Flag180
(N
: Node_Id
) return Boolean;
1546 pragma Inline
(Flag180
);
1548 function Flag181
(N
: Node_Id
) return Boolean;
1549 pragma Inline
(Flag181
);
1551 function Flag182
(N
: Node_Id
) return Boolean;
1552 pragma Inline
(Flag182
);
1554 function Flag183
(N
: Node_Id
) return Boolean;
1555 pragma Inline
(Flag183
);
1557 -- Procedures to set value of indicated field
1559 procedure Set_Nkind
(N
: Node_Id
; Val
: Node_Kind
);
1560 pragma Inline
(Set_Nkind
);
1562 procedure Set_Field1
(N
: Node_Id
; Val
: Union_Id
);
1563 pragma Inline
(Set_Field1
);
1565 procedure Set_Field2
(N
: Node_Id
; Val
: Union_Id
);
1566 pragma Inline
(Set_Field2
);
1568 procedure Set_Field3
(N
: Node_Id
; Val
: Union_Id
);
1569 pragma Inline
(Set_Field3
);
1571 procedure Set_Field4
(N
: Node_Id
; Val
: Union_Id
);
1572 pragma Inline
(Set_Field4
);
1574 procedure Set_Field5
(N
: Node_Id
; Val
: Union_Id
);
1575 pragma Inline
(Set_Field5
);
1577 procedure Set_Field6
(N
: Node_Id
; Val
: Union_Id
);
1578 pragma Inline
(Set_Field6
);
1580 procedure Set_Field7
(N
: Node_Id
; Val
: Union_Id
);
1581 pragma Inline
(Set_Field7
);
1583 procedure Set_Field8
(N
: Node_Id
; Val
: Union_Id
);
1584 pragma Inline
(Set_Field8
);
1586 procedure Set_Field9
(N
: Node_Id
; Val
: Union_Id
);
1587 pragma Inline
(Set_Field9
);
1589 procedure Set_Field10
(N
: Node_Id
; Val
: Union_Id
);
1590 pragma Inline
(Set_Field10
);
1592 procedure Set_Field11
(N
: Node_Id
; Val
: Union_Id
);
1593 pragma Inline
(Set_Field11
);
1595 procedure Set_Field12
(N
: Node_Id
; Val
: Union_Id
);
1596 pragma Inline
(Set_Field12
);
1598 procedure Set_Field13
(N
: Node_Id
; Val
: Union_Id
);
1599 pragma Inline
(Set_Field13
);
1601 procedure Set_Field14
(N
: Node_Id
; Val
: Union_Id
);
1602 pragma Inline
(Set_Field14
);
1604 procedure Set_Field15
(N
: Node_Id
; Val
: Union_Id
);
1605 pragma Inline
(Set_Field15
);
1607 procedure Set_Field16
(N
: Node_Id
; Val
: Union_Id
);
1608 pragma Inline
(Set_Field16
);
1610 procedure Set_Field17
(N
: Node_Id
; Val
: Union_Id
);
1611 pragma Inline
(Set_Field17
);
1613 procedure Set_Field18
(N
: Node_Id
; Val
: Union_Id
);
1614 pragma Inline
(Set_Field18
);
1616 procedure Set_Field19
(N
: Node_Id
; Val
: Union_Id
);
1617 pragma Inline
(Set_Field19
);
1619 procedure Set_Field20
(N
: Node_Id
; Val
: Union_Id
);
1620 pragma Inline
(Set_Field20
);
1622 procedure Set_Field21
(N
: Node_Id
; Val
: Union_Id
);
1623 pragma Inline
(Set_Field21
);
1625 procedure Set_Field22
(N
: Node_Id
; Val
: Union_Id
);
1626 pragma Inline
(Set_Field22
);
1628 procedure Set_Field23
(N
: Node_Id
; Val
: Union_Id
);
1629 pragma Inline
(Set_Field23
);
1631 procedure Set_Node1
(N
: Node_Id
; Val
: Node_Id
);
1632 pragma Inline
(Set_Node1
);
1634 procedure Set_Node2
(N
: Node_Id
; Val
: Node_Id
);
1635 pragma Inline
(Set_Node2
);
1637 procedure Set_Node3
(N
: Node_Id
; Val
: Node_Id
);
1638 pragma Inline
(Set_Node3
);
1640 procedure Set_Node4
(N
: Node_Id
; Val
: Node_Id
);
1641 pragma Inline
(Set_Node4
);
1643 procedure Set_Node5
(N
: Node_Id
; Val
: Node_Id
);
1644 pragma Inline
(Set_Node5
);
1646 procedure Set_Node6
(N
: Node_Id
; Val
: Node_Id
);
1647 pragma Inline
(Set_Node6
);
1649 procedure Set_Node7
(N
: Node_Id
; Val
: Node_Id
);
1650 pragma Inline
(Set_Node7
);
1652 procedure Set_Node8
(N
: Node_Id
; Val
: Node_Id
);
1653 pragma Inline
(Set_Node8
);
1655 procedure Set_Node9
(N
: Node_Id
; Val
: Node_Id
);
1656 pragma Inline
(Set_Node9
);
1658 procedure Set_Node10
(N
: Node_Id
; Val
: Node_Id
);
1659 pragma Inline
(Set_Node10
);
1661 procedure Set_Node11
(N
: Node_Id
; Val
: Node_Id
);
1662 pragma Inline
(Set_Node11
);
1664 procedure Set_Node12
(N
: Node_Id
; Val
: Node_Id
);
1665 pragma Inline
(Set_Node12
);
1667 procedure Set_Node13
(N
: Node_Id
; Val
: Node_Id
);
1668 pragma Inline
(Set_Node13
);
1670 procedure Set_Node14
(N
: Node_Id
; Val
: Node_Id
);
1671 pragma Inline
(Set_Node14
);
1673 procedure Set_Node15
(N
: Node_Id
; Val
: Node_Id
);
1674 pragma Inline
(Set_Node15
);
1676 procedure Set_Node16
(N
: Node_Id
; Val
: Node_Id
);
1677 pragma Inline
(Set_Node16
);
1679 procedure Set_Node17
(N
: Node_Id
; Val
: Node_Id
);
1680 pragma Inline
(Set_Node17
);
1682 procedure Set_Node18
(N
: Node_Id
; Val
: Node_Id
);
1683 pragma Inline
(Set_Node18
);
1685 procedure Set_Node19
(N
: Node_Id
; Val
: Node_Id
);
1686 pragma Inline
(Set_Node19
);
1688 procedure Set_Node20
(N
: Node_Id
; Val
: Node_Id
);
1689 pragma Inline
(Set_Node20
);
1691 procedure Set_Node21
(N
: Node_Id
; Val
: Node_Id
);
1692 pragma Inline
(Set_Node21
);
1694 procedure Set_Node22
(N
: Node_Id
; Val
: Node_Id
);
1695 pragma Inline
(Set_Node22
);
1697 procedure Set_Node23
(N
: Node_Id
; Val
: Node_Id
);
1698 pragma Inline
(Set_Node23
);
1700 procedure Set_List1
(N
: Node_Id
; Val
: List_Id
);
1701 pragma Inline
(Set_List1
);
1703 procedure Set_List2
(N
: Node_Id
; Val
: List_Id
);
1704 pragma Inline
(Set_List2
);
1706 procedure Set_List3
(N
: Node_Id
; Val
: List_Id
);
1707 pragma Inline
(Set_List3
);
1709 procedure Set_List4
(N
: Node_Id
; Val
: List_Id
);
1710 pragma Inline
(Set_List4
);
1712 procedure Set_List5
(N
: Node_Id
; Val
: List_Id
);
1713 pragma Inline
(Set_List5
);
1715 procedure Set_List10
(N
: Node_Id
; Val
: List_Id
);
1716 pragma Inline
(Set_List10
);
1718 procedure Set_List14
(N
: Node_Id
; Val
: List_Id
);
1719 pragma Inline
(Set_List14
);
1721 procedure Set_Elist2
(N
: Node_Id
; Val
: Elist_Id
);
1722 pragma Inline
(Set_Elist2
);
1724 procedure Set_Elist3
(N
: Node_Id
; Val
: Elist_Id
);
1725 pragma Inline
(Set_Elist3
);
1727 procedure Set_Elist4
(N
: Node_Id
; Val
: Elist_Id
);
1728 pragma Inline
(Set_Elist4
);
1730 procedure Set_Elist8
(N
: Node_Id
; Val
: Elist_Id
);
1731 pragma Inline
(Set_Elist8
);
1733 procedure Set_Elist13
(N
: Node_Id
; Val
: Elist_Id
);
1734 pragma Inline
(Set_Elist13
);
1736 procedure Set_Elist15
(N
: Node_Id
; Val
: Elist_Id
);
1737 pragma Inline
(Set_Elist15
);
1739 procedure Set_Elist16
(N
: Node_Id
; Val
: Elist_Id
);
1740 pragma Inline
(Set_Elist16
);
1742 procedure Set_Elist18
(N
: Node_Id
; Val
: Elist_Id
);
1743 pragma Inline
(Set_Elist18
);
1745 procedure Set_Elist21
(N
: Node_Id
; Val
: Elist_Id
);
1746 pragma Inline
(Set_Elist21
);
1748 procedure Set_Elist23
(N
: Node_Id
; Val
: Elist_Id
);
1749 pragma Inline
(Set_Elist23
);
1751 procedure Set_Name1
(N
: Node_Id
; Val
: Name_Id
);
1752 pragma Inline
(Set_Name1
);
1754 procedure Set_Name2
(N
: Node_Id
; Val
: Name_Id
);
1755 pragma Inline
(Set_Name2
);
1757 procedure Set_Char_Code2
(N
: Node_Id
; Val
: Char_Code
);
1758 pragma Inline
(Set_Char_Code2
);
1760 procedure Set_Str3
(N
: Node_Id
; Val
: String_Id
);
1761 pragma Inline
(Set_Str3
);
1763 procedure Set_Uint3
(N
: Node_Id
; Val
: Uint
);
1764 pragma Inline
(Set_Uint3
);
1766 procedure Set_Uint4
(N
: Node_Id
; Val
: Uint
);
1767 pragma Inline
(Set_Uint4
);
1769 procedure Set_Uint5
(N
: Node_Id
; Val
: Uint
);
1770 pragma Inline
(Set_Uint5
);
1772 procedure Set_Uint8
(N
: Node_Id
; Val
: Uint
);
1773 pragma Inline
(Set_Uint8
);
1775 procedure Set_Uint9
(N
: Node_Id
; Val
: Uint
);
1776 pragma Inline
(Set_Uint9
);
1778 procedure Set_Uint10
(N
: Node_Id
; Val
: Uint
);
1779 pragma Inline
(Set_Uint10
);
1781 procedure Set_Uint11
(N
: Node_Id
; Val
: Uint
);
1782 pragma Inline
(Set_Uint11
);
1784 procedure Set_Uint12
(N
: Node_Id
; Val
: Uint
);
1785 pragma Inline
(Set_Uint12
);
1787 procedure Set_Uint13
(N
: Node_Id
; Val
: Uint
);
1788 pragma Inline
(Set_Uint13
);
1790 procedure Set_Uint14
(N
: Node_Id
; Val
: Uint
);
1791 pragma Inline
(Set_Uint14
);
1793 procedure Set_Uint15
(N
: Node_Id
; Val
: Uint
);
1794 pragma Inline
(Set_Uint15
);
1796 procedure Set_Uint16
(N
: Node_Id
; Val
: Uint
);
1797 pragma Inline
(Set_Uint16
);
1799 procedure Set_Uint17
(N
: Node_Id
; Val
: Uint
);
1800 pragma Inline
(Set_Uint17
);
1802 procedure Set_Uint22
(N
: Node_Id
; Val
: Uint
);
1803 pragma Inline
(Set_Uint22
);
1805 procedure Set_Ureal3
(N
: Node_Id
; Val
: Ureal
);
1806 pragma Inline
(Set_Ureal3
);
1808 procedure Set_Ureal18
(N
: Node_Id
; Val
: Ureal
);
1809 pragma Inline
(Set_Ureal18
);
1811 procedure Set_Ureal21
(N
: Node_Id
; Val
: Ureal
);
1812 pragma Inline
(Set_Ureal21
);
1814 procedure Set_Flag4
(N
: Node_Id
; Val
: Boolean);
1815 pragma Inline
(Set_Flag4
);
1817 procedure Set_Flag5
(N
: Node_Id
; Val
: Boolean);
1818 pragma Inline
(Set_Flag5
);
1820 procedure Set_Flag6
(N
: Node_Id
; Val
: Boolean);
1821 pragma Inline
(Set_Flag6
);
1823 procedure Set_Flag7
(N
: Node_Id
; Val
: Boolean);
1824 pragma Inline
(Set_Flag7
);
1826 procedure Set_Flag8
(N
: Node_Id
; Val
: Boolean);
1827 pragma Inline
(Set_Flag8
);
1829 procedure Set_Flag9
(N
: Node_Id
; Val
: Boolean);
1830 pragma Inline
(Set_Flag9
);
1832 procedure Set_Flag10
(N
: Node_Id
; Val
: Boolean);
1833 pragma Inline
(Set_Flag10
);
1835 procedure Set_Flag11
(N
: Node_Id
; Val
: Boolean);
1836 pragma Inline
(Set_Flag11
);
1838 procedure Set_Flag12
(N
: Node_Id
; Val
: Boolean);
1839 pragma Inline
(Set_Flag12
);
1841 procedure Set_Flag13
(N
: Node_Id
; Val
: Boolean);
1842 pragma Inline
(Set_Flag13
);
1844 procedure Set_Flag14
(N
: Node_Id
; Val
: Boolean);
1845 pragma Inline
(Set_Flag14
);
1847 procedure Set_Flag15
(N
: Node_Id
; Val
: Boolean);
1848 pragma Inline
(Set_Flag15
);
1850 procedure Set_Flag16
(N
: Node_Id
; Val
: Boolean);
1851 pragma Inline
(Set_Flag16
);
1853 procedure Set_Flag17
(N
: Node_Id
; Val
: Boolean);
1854 pragma Inline
(Set_Flag17
);
1856 procedure Set_Flag18
(N
: Node_Id
; Val
: Boolean);
1857 pragma Inline
(Set_Flag18
);
1859 procedure Set_Flag19
(N
: Node_Id
; Val
: Boolean);
1860 pragma Inline
(Set_Flag19
);
1862 procedure Set_Flag20
(N
: Node_Id
; Val
: Boolean);
1863 pragma Inline
(Set_Flag20
);
1865 procedure Set_Flag21
(N
: Node_Id
; Val
: Boolean);
1866 pragma Inline
(Set_Flag21
);
1868 procedure Set_Flag22
(N
: Node_Id
; Val
: Boolean);
1869 pragma Inline
(Set_Flag22
);
1871 procedure Set_Flag23
(N
: Node_Id
; Val
: Boolean);
1872 pragma Inline
(Set_Flag23
);
1874 procedure Set_Flag24
(N
: Node_Id
; Val
: Boolean);
1875 pragma Inline
(Set_Flag24
);
1877 procedure Set_Flag25
(N
: Node_Id
; Val
: Boolean);
1878 pragma Inline
(Set_Flag25
);
1880 procedure Set_Flag26
(N
: Node_Id
; Val
: Boolean);
1881 pragma Inline
(Set_Flag26
);
1883 procedure Set_Flag27
(N
: Node_Id
; Val
: Boolean);
1884 pragma Inline
(Set_Flag27
);
1886 procedure Set_Flag28
(N
: Node_Id
; Val
: Boolean);
1887 pragma Inline
(Set_Flag28
);
1889 procedure Set_Flag29
(N
: Node_Id
; Val
: Boolean);
1890 pragma Inline
(Set_Flag29
);
1892 procedure Set_Flag30
(N
: Node_Id
; Val
: Boolean);
1893 pragma Inline
(Set_Flag30
);
1895 procedure Set_Flag31
(N
: Node_Id
; Val
: Boolean);
1896 pragma Inline
(Set_Flag31
);
1898 procedure Set_Flag32
(N
: Node_Id
; Val
: Boolean);
1899 pragma Inline
(Set_Flag32
);
1901 procedure Set_Flag33
(N
: Node_Id
; Val
: Boolean);
1902 pragma Inline
(Set_Flag33
);
1904 procedure Set_Flag34
(N
: Node_Id
; Val
: Boolean);
1905 pragma Inline
(Set_Flag34
);
1907 procedure Set_Flag35
(N
: Node_Id
; Val
: Boolean);
1908 pragma Inline
(Set_Flag35
);
1910 procedure Set_Flag36
(N
: Node_Id
; Val
: Boolean);
1911 pragma Inline
(Set_Flag36
);
1913 procedure Set_Flag37
(N
: Node_Id
; Val
: Boolean);
1914 pragma Inline
(Set_Flag37
);
1916 procedure Set_Flag38
(N
: Node_Id
; Val
: Boolean);
1917 pragma Inline
(Set_Flag38
);
1919 procedure Set_Flag39
(N
: Node_Id
; Val
: Boolean);
1920 pragma Inline
(Set_Flag39
);
1922 procedure Set_Flag40
(N
: Node_Id
; Val
: Boolean);
1923 pragma Inline
(Set_Flag40
);
1925 procedure Set_Flag41
(N
: Node_Id
; Val
: Boolean);
1926 pragma Inline
(Set_Flag41
);
1928 procedure Set_Flag42
(N
: Node_Id
; Val
: Boolean);
1929 pragma Inline
(Set_Flag42
);
1931 procedure Set_Flag43
(N
: Node_Id
; Val
: Boolean);
1932 pragma Inline
(Set_Flag43
);
1934 procedure Set_Flag44
(N
: Node_Id
; Val
: Boolean);
1935 pragma Inline
(Set_Flag44
);
1937 procedure Set_Flag45
(N
: Node_Id
; Val
: Boolean);
1938 pragma Inline
(Set_Flag45
);
1940 procedure Set_Flag46
(N
: Node_Id
; Val
: Boolean);
1941 pragma Inline
(Set_Flag46
);
1943 procedure Set_Flag47
(N
: Node_Id
; Val
: Boolean);
1944 pragma Inline
(Set_Flag47
);
1946 procedure Set_Flag48
(N
: Node_Id
; Val
: Boolean);
1947 pragma Inline
(Set_Flag48
);
1949 procedure Set_Flag49
(N
: Node_Id
; Val
: Boolean);
1950 pragma Inline
(Set_Flag49
);
1952 procedure Set_Flag50
(N
: Node_Id
; Val
: Boolean);
1953 pragma Inline
(Set_Flag50
);
1955 procedure Set_Flag51
(N
: Node_Id
; Val
: Boolean);
1956 pragma Inline
(Set_Flag51
);
1958 procedure Set_Flag52
(N
: Node_Id
; Val
: Boolean);
1959 pragma Inline
(Set_Flag52
);
1961 procedure Set_Flag53
(N
: Node_Id
; Val
: Boolean);
1962 pragma Inline
(Set_Flag53
);
1964 procedure Set_Flag54
(N
: Node_Id
; Val
: Boolean);
1965 pragma Inline
(Set_Flag54
);
1967 procedure Set_Flag55
(N
: Node_Id
; Val
: Boolean);
1968 pragma Inline
(Set_Flag55
);
1970 procedure Set_Flag56
(N
: Node_Id
; Val
: Boolean);
1971 pragma Inline
(Set_Flag56
);
1973 procedure Set_Flag57
(N
: Node_Id
; Val
: Boolean);
1974 pragma Inline
(Set_Flag57
);
1976 procedure Set_Flag58
(N
: Node_Id
; Val
: Boolean);
1977 pragma Inline
(Set_Flag58
);
1979 procedure Set_Flag59
(N
: Node_Id
; Val
: Boolean);
1980 pragma Inline
(Set_Flag59
);
1982 procedure Set_Flag60
(N
: Node_Id
; Val
: Boolean);
1983 pragma Inline
(Set_Flag60
);
1985 procedure Set_Flag61
(N
: Node_Id
; Val
: Boolean);
1986 pragma Inline
(Set_Flag61
);
1988 procedure Set_Flag62
(N
: Node_Id
; Val
: Boolean);
1989 pragma Inline
(Set_Flag62
);
1991 procedure Set_Flag63
(N
: Node_Id
; Val
: Boolean);
1992 pragma Inline
(Set_Flag63
);
1994 procedure Set_Flag64
(N
: Node_Id
; Val
: Boolean);
1995 pragma Inline
(Set_Flag64
);
1997 procedure Set_Flag65
(N
: Node_Id
; Val
: Boolean);
1998 pragma Inline
(Set_Flag65
);
2000 procedure Set_Flag66
(N
: Node_Id
; Val
: Boolean);
2001 pragma Inline
(Set_Flag66
);
2003 procedure Set_Flag67
(N
: Node_Id
; Val
: Boolean);
2004 pragma Inline
(Set_Flag67
);
2006 procedure Set_Flag68
(N
: Node_Id
; Val
: Boolean);
2007 pragma Inline
(Set_Flag68
);
2009 procedure Set_Flag69
(N
: Node_Id
; Val
: Boolean);
2010 pragma Inline
(Set_Flag69
);
2012 procedure Set_Flag70
(N
: Node_Id
; Val
: Boolean);
2013 pragma Inline
(Set_Flag70
);
2015 procedure Set_Flag71
(N
: Node_Id
; Val
: Boolean);
2016 pragma Inline
(Set_Flag71
);
2018 procedure Set_Flag72
(N
: Node_Id
; Val
: Boolean);
2019 pragma Inline
(Set_Flag72
);
2021 procedure Set_Flag73
(N
: Node_Id
; Val
: Boolean);
2022 pragma Inline
(Set_Flag73
);
2024 procedure Set_Flag74
(N
: Node_Id
; Val
: Boolean);
2025 pragma Inline
(Set_Flag74
);
2027 procedure Set_Flag75
(N
: Node_Id
; Val
: Boolean);
2028 pragma Inline
(Set_Flag75
);
2030 procedure Set_Flag76
(N
: Node_Id
; Val
: Boolean);
2031 pragma Inline
(Set_Flag76
);
2033 procedure Set_Flag77
(N
: Node_Id
; Val
: Boolean);
2034 pragma Inline
(Set_Flag77
);
2036 procedure Set_Flag78
(N
: Node_Id
; Val
: Boolean);
2037 pragma Inline
(Set_Flag78
);
2039 procedure Set_Flag79
(N
: Node_Id
; Val
: Boolean);
2040 pragma Inline
(Set_Flag79
);
2042 procedure Set_Flag80
(N
: Node_Id
; Val
: Boolean);
2043 pragma Inline
(Set_Flag80
);
2045 procedure Set_Flag81
(N
: Node_Id
; Val
: Boolean);
2046 pragma Inline
(Set_Flag81
);
2048 procedure Set_Flag82
(N
: Node_Id
; Val
: Boolean);
2049 pragma Inline
(Set_Flag82
);
2051 procedure Set_Flag83
(N
: Node_Id
; Val
: Boolean);
2052 pragma Inline
(Set_Flag83
);
2054 procedure Set_Flag84
(N
: Node_Id
; Val
: Boolean);
2055 pragma Inline
(Set_Flag84
);
2057 procedure Set_Flag85
(N
: Node_Id
; Val
: Boolean);
2058 pragma Inline
(Set_Flag85
);
2060 procedure Set_Flag86
(N
: Node_Id
; Val
: Boolean);
2061 pragma Inline
(Set_Flag86
);
2063 procedure Set_Flag87
(N
: Node_Id
; Val
: Boolean);
2064 pragma Inline
(Set_Flag87
);
2066 procedure Set_Flag88
(N
: Node_Id
; Val
: Boolean);
2067 pragma Inline
(Set_Flag88
);
2069 procedure Set_Flag89
(N
: Node_Id
; Val
: Boolean);
2070 pragma Inline
(Set_Flag89
);
2072 procedure Set_Flag90
(N
: Node_Id
; Val
: Boolean);
2073 pragma Inline
(Set_Flag90
);
2075 procedure Set_Flag91
(N
: Node_Id
; Val
: Boolean);
2076 pragma Inline
(Set_Flag91
);
2078 procedure Set_Flag92
(N
: Node_Id
; Val
: Boolean);
2079 pragma Inline
(Set_Flag92
);
2081 procedure Set_Flag93
(N
: Node_Id
; Val
: Boolean);
2082 pragma Inline
(Set_Flag93
);
2084 procedure Set_Flag94
(N
: Node_Id
; Val
: Boolean);
2085 pragma Inline
(Set_Flag94
);
2087 procedure Set_Flag95
(N
: Node_Id
; Val
: Boolean);
2088 pragma Inline
(Set_Flag95
);
2090 procedure Set_Flag96
(N
: Node_Id
; Val
: Boolean);
2091 pragma Inline
(Set_Flag96
);
2093 procedure Set_Flag97
(N
: Node_Id
; Val
: Boolean);
2094 pragma Inline
(Set_Flag97
);
2096 procedure Set_Flag98
(N
: Node_Id
; Val
: Boolean);
2097 pragma Inline
(Set_Flag98
);
2099 procedure Set_Flag99
(N
: Node_Id
; Val
: Boolean);
2100 pragma Inline
(Set_Flag99
);
2102 procedure Set_Flag100
(N
: Node_Id
; Val
: Boolean);
2103 pragma Inline
(Set_Flag100
);
2105 procedure Set_Flag101
(N
: Node_Id
; Val
: Boolean);
2106 pragma Inline
(Set_Flag101
);
2108 procedure Set_Flag102
(N
: Node_Id
; Val
: Boolean);
2109 pragma Inline
(Set_Flag102
);
2111 procedure Set_Flag103
(N
: Node_Id
; Val
: Boolean);
2112 pragma Inline
(Set_Flag103
);
2114 procedure Set_Flag104
(N
: Node_Id
; Val
: Boolean);
2115 pragma Inline
(Set_Flag104
);
2117 procedure Set_Flag105
(N
: Node_Id
; Val
: Boolean);
2118 pragma Inline
(Set_Flag105
);
2120 procedure Set_Flag106
(N
: Node_Id
; Val
: Boolean);
2121 pragma Inline
(Set_Flag106
);
2123 procedure Set_Flag107
(N
: Node_Id
; Val
: Boolean);
2124 pragma Inline
(Set_Flag107
);
2126 procedure Set_Flag108
(N
: Node_Id
; Val
: Boolean);
2127 pragma Inline
(Set_Flag108
);
2129 procedure Set_Flag109
(N
: Node_Id
; Val
: Boolean);
2130 pragma Inline
(Set_Flag109
);
2132 procedure Set_Flag110
(N
: Node_Id
; Val
: Boolean);
2133 pragma Inline
(Set_Flag110
);
2135 procedure Set_Flag111
(N
: Node_Id
; Val
: Boolean);
2136 pragma Inline
(Set_Flag111
);
2138 procedure Set_Flag112
(N
: Node_Id
; Val
: Boolean);
2139 pragma Inline
(Set_Flag112
);
2141 procedure Set_Flag113
(N
: Node_Id
; Val
: Boolean);
2142 pragma Inline
(Set_Flag113
);
2144 procedure Set_Flag114
(N
: Node_Id
; Val
: Boolean);
2145 pragma Inline
(Set_Flag114
);
2147 procedure Set_Flag115
(N
: Node_Id
; Val
: Boolean);
2148 pragma Inline
(Set_Flag115
);
2150 procedure Set_Flag116
(N
: Node_Id
; Val
: Boolean);
2151 pragma Inline
(Set_Flag116
);
2153 procedure Set_Flag117
(N
: Node_Id
; Val
: Boolean);
2154 pragma Inline
(Set_Flag117
);
2156 procedure Set_Flag118
(N
: Node_Id
; Val
: Boolean);
2157 pragma Inline
(Set_Flag118
);
2159 procedure Set_Flag119
(N
: Node_Id
; Val
: Boolean);
2160 pragma Inline
(Set_Flag119
);
2162 procedure Set_Flag120
(N
: Node_Id
; Val
: Boolean);
2163 pragma Inline
(Set_Flag120
);
2165 procedure Set_Flag121
(N
: Node_Id
; Val
: Boolean);
2166 pragma Inline
(Set_Flag121
);
2168 procedure Set_Flag122
(N
: Node_Id
; Val
: Boolean);
2169 pragma Inline
(Set_Flag122
);
2171 procedure Set_Flag123
(N
: Node_Id
; Val
: Boolean);
2172 pragma Inline
(Set_Flag123
);
2174 procedure Set_Flag124
(N
: Node_Id
; Val
: Boolean);
2175 pragma Inline
(Set_Flag124
);
2177 procedure Set_Flag125
(N
: Node_Id
; Val
: Boolean);
2178 pragma Inline
(Set_Flag125
);
2180 procedure Set_Flag126
(N
: Node_Id
; Val
: Boolean);
2181 pragma Inline
(Set_Flag126
);
2183 procedure Set_Flag127
(N
: Node_Id
; Val
: Boolean);
2184 pragma Inline
(Set_Flag127
);
2186 procedure Set_Flag128
(N
: Node_Id
; Val
: Boolean);
2187 pragma Inline
(Set_Flag128
);
2189 procedure Set_Flag129
(N
: Node_Id
; Val
: Boolean);
2190 pragma Inline
(Set_Flag129
);
2192 procedure Set_Flag130
(N
: Node_Id
; Val
: Boolean);
2193 pragma Inline
(Set_Flag130
);
2195 procedure Set_Flag131
(N
: Node_Id
; Val
: Boolean);
2196 pragma Inline
(Set_Flag131
);
2198 procedure Set_Flag132
(N
: Node_Id
; Val
: Boolean);
2199 pragma Inline
(Set_Flag132
);
2201 procedure Set_Flag133
(N
: Node_Id
; Val
: Boolean);
2202 pragma Inline
(Set_Flag133
);
2204 procedure Set_Flag134
(N
: Node_Id
; Val
: Boolean);
2205 pragma Inline
(Set_Flag134
);
2207 procedure Set_Flag135
(N
: Node_Id
; Val
: Boolean);
2208 pragma Inline
(Set_Flag135
);
2210 procedure Set_Flag136
(N
: Node_Id
; Val
: Boolean);
2211 pragma Inline
(Set_Flag136
);
2213 procedure Set_Flag137
(N
: Node_Id
; Val
: Boolean);
2214 pragma Inline
(Set_Flag137
);
2216 procedure Set_Flag138
(N
: Node_Id
; Val
: Boolean);
2217 pragma Inline
(Set_Flag138
);
2219 procedure Set_Flag139
(N
: Node_Id
; Val
: Boolean);
2220 pragma Inline
(Set_Flag139
);
2222 procedure Set_Flag140
(N
: Node_Id
; Val
: Boolean);
2223 pragma Inline
(Set_Flag140
);
2225 procedure Set_Flag141
(N
: Node_Id
; Val
: Boolean);
2226 pragma Inline
(Set_Flag141
);
2228 procedure Set_Flag142
(N
: Node_Id
; Val
: Boolean);
2229 pragma Inline
(Set_Flag142
);
2231 procedure Set_Flag143
(N
: Node_Id
; Val
: Boolean);
2232 pragma Inline
(Set_Flag143
);
2234 procedure Set_Flag144
(N
: Node_Id
; Val
: Boolean);
2235 pragma Inline
(Set_Flag144
);
2237 procedure Set_Flag145
(N
: Node_Id
; Val
: Boolean);
2238 pragma Inline
(Set_Flag145
);
2240 procedure Set_Flag146
(N
: Node_Id
; Val
: Boolean);
2241 pragma Inline
(Set_Flag146
);
2243 procedure Set_Flag147
(N
: Node_Id
; Val
: Boolean);
2244 pragma Inline
(Set_Flag147
);
2246 procedure Set_Flag148
(N
: Node_Id
; Val
: Boolean);
2247 pragma Inline
(Set_Flag148
);
2249 procedure Set_Flag149
(N
: Node_Id
; Val
: Boolean);
2250 pragma Inline
(Set_Flag149
);
2252 procedure Set_Flag150
(N
: Node_Id
; Val
: Boolean);
2253 pragma Inline
(Set_Flag150
);
2255 procedure Set_Flag151
(N
: Node_Id
; Val
: Boolean);
2256 pragma Inline
(Set_Flag151
);
2258 procedure Set_Flag152
(N
: Node_Id
; Val
: Boolean);
2259 pragma Inline
(Set_Flag152
);
2261 procedure Set_Flag153
(N
: Node_Id
; Val
: Boolean);
2262 pragma Inline
(Set_Flag153
);
2264 procedure Set_Flag154
(N
: Node_Id
; Val
: Boolean);
2265 pragma Inline
(Set_Flag154
);
2267 procedure Set_Flag155
(N
: Node_Id
; Val
: Boolean);
2268 pragma Inline
(Set_Flag155
);
2270 procedure Set_Flag156
(N
: Node_Id
; Val
: Boolean);
2271 pragma Inline
(Set_Flag156
);
2273 procedure Set_Flag157
(N
: Node_Id
; Val
: Boolean);
2274 pragma Inline
(Set_Flag157
);
2276 procedure Set_Flag158
(N
: Node_Id
; Val
: Boolean);
2277 pragma Inline
(Set_Flag158
);
2279 procedure Set_Flag159
(N
: Node_Id
; Val
: Boolean);
2280 pragma Inline
(Set_Flag159
);
2282 procedure Set_Flag160
(N
: Node_Id
; Val
: Boolean);
2283 pragma Inline
(Set_Flag160
);
2285 procedure Set_Flag161
(N
: Node_Id
; Val
: Boolean);
2286 pragma Inline
(Set_Flag161
);
2288 procedure Set_Flag162
(N
: Node_Id
; Val
: Boolean);
2289 pragma Inline
(Set_Flag162
);
2291 procedure Set_Flag163
(N
: Node_Id
; Val
: Boolean);
2292 pragma Inline
(Set_Flag163
);
2294 procedure Set_Flag164
(N
: Node_Id
; Val
: Boolean);
2295 pragma Inline
(Set_Flag164
);
2297 procedure Set_Flag165
(N
: Node_Id
; Val
: Boolean);
2298 pragma Inline
(Set_Flag165
);
2300 procedure Set_Flag166
(N
: Node_Id
; Val
: Boolean);
2301 pragma Inline
(Set_Flag166
);
2303 procedure Set_Flag167
(N
: Node_Id
; Val
: Boolean);
2304 pragma Inline
(Set_Flag167
);
2306 procedure Set_Flag168
(N
: Node_Id
; Val
: Boolean);
2307 pragma Inline
(Set_Flag168
);
2309 procedure Set_Flag169
(N
: Node_Id
; Val
: Boolean);
2310 pragma Inline
(Set_Flag169
);
2312 procedure Set_Flag170
(N
: Node_Id
; Val
: Boolean);
2313 pragma Inline
(Set_Flag170
);
2315 procedure Set_Flag171
(N
: Node_Id
; Val
: Boolean);
2316 pragma Inline
(Set_Flag171
);
2318 procedure Set_Flag172
(N
: Node_Id
; Val
: Boolean);
2319 pragma Inline
(Set_Flag172
);
2321 procedure Set_Flag173
(N
: Node_Id
; Val
: Boolean);
2322 pragma Inline
(Set_Flag173
);
2324 procedure Set_Flag174
(N
: Node_Id
; Val
: Boolean);
2325 pragma Inline
(Set_Flag174
);
2327 procedure Set_Flag175
(N
: Node_Id
; Val
: Boolean);
2328 pragma Inline
(Set_Flag175
);
2330 procedure Set_Flag176
(N
: Node_Id
; Val
: Boolean);
2331 pragma Inline
(Set_Flag176
);
2333 procedure Set_Flag177
(N
: Node_Id
; Val
: Boolean);
2334 pragma Inline
(Set_Flag177
);
2336 procedure Set_Flag178
(N
: Node_Id
; Val
: Boolean);
2337 pragma Inline
(Set_Flag178
);
2339 procedure Set_Flag179
(N
: Node_Id
; Val
: Boolean);
2340 pragma Inline
(Set_Flag179
);
2342 procedure Set_Flag180
(N
: Node_Id
; Val
: Boolean);
2343 pragma Inline
(Set_Flag180
);
2345 procedure Set_Flag181
(N
: Node_Id
; Val
: Boolean);
2346 pragma Inline
(Set_Flag181
);
2348 procedure Set_Flag182
(N
: Node_Id
; Val
: Boolean);
2349 pragma Inline
(Set_Flag182
);
2351 procedure Set_Flag183
(N
: Node_Id
; Val
: Boolean);
2352 pragma Inline
(Set_Flag183
);
2354 -- The following versions of Set_Noden also set the parent
2355 -- pointer of the referenced node if it is non_Empty
2357 procedure Set_Node1_With_Parent
(N
: Node_Id
; Val
: Node_Id
);
2358 pragma Inline
(Set_Node1_With_Parent
);
2360 procedure Set_Node2_With_Parent
(N
: Node_Id
; Val
: Node_Id
);
2361 pragma Inline
(Set_Node2_With_Parent
);
2363 procedure Set_Node3_With_Parent
(N
: Node_Id
; Val
: Node_Id
);
2364 pragma Inline
(Set_Node3_With_Parent
);
2366 procedure Set_Node4_With_Parent
(N
: Node_Id
; Val
: Node_Id
);
2367 pragma Inline
(Set_Node4_With_Parent
);
2369 procedure Set_Node5_With_Parent
(N
: Node_Id
; Val
: Node_Id
);
2370 pragma Inline
(Set_Node5_With_Parent
);
2372 -- The following versions of Set_Listn also set the parent pointer of
2373 -- the referenced node if it is non_Empty. The procedures for List6
2374 -- to List12 can only be applied to nodes which have an extension.
2376 procedure Set_List1_With_Parent
(N
: Node_Id
; Val
: List_Id
);
2377 pragma Inline
(Set_List1_With_Parent
);
2379 procedure Set_List2_With_Parent
(N
: Node_Id
; Val
: List_Id
);
2380 pragma Inline
(Set_List2_With_Parent
);
2382 procedure Set_List3_With_Parent
(N
: Node_Id
; Val
: List_Id
);
2383 pragma Inline
(Set_List3_With_Parent
);
2385 procedure Set_List4_With_Parent
(N
: Node_Id
; Val
: List_Id
);
2386 pragma Inline
(Set_List4_With_Parent
);
2388 procedure Set_List5_With_Parent
(N
: Node_Id
; Val
: List_Id
);
2389 pragma Inline
(Set_List5_With_Parent
);
2391 end Unchecked_Access
;
2393 -----------------------------
2394 -- Private Part Subpackage --
2395 -----------------------------
2397 -- The following package contains the definition of the data structure
2398 -- used by the implementation of the Atree package. Logically it really
2399 -- corresponds to the private part, hence the name. The reason that it
2400 -- is defined as a sub-package is to allow special access from clients
2401 -- that need to see the internals of the data structures.
2403 package Atree_Private_Part
is
2405 -------------------------
2406 -- Tree Representation --
2407 -------------------------
2409 -- The nodes of the tree are stored in a table (i.e. an array). In the
2410 -- case of extended nodes four consecutive components in the array are
2411 -- used. There are thus two formats for array components. One is used
2412 -- for non-extended nodes, and for the first component of extended
2413 -- nodes. The other is used for the extension parts (second, third and
2414 -- fourth components) of an extended node. A variant record structure
2415 -- is used to distinguish the two formats.
2417 type Node_Record
(Is_Extension
: Boolean := False) is record
2419 -- Logically, the only field in the common part is the above
2420 -- Is_Extension discriminant (a single bit). However, Gigi cannot
2421 -- yet handle such a structure, so we fill out the common part of
2422 -- the record with fields that are used in different ways for
2423 -- normal nodes and node extensions.
2425 Pflag1
, Pflag2
: Boolean;
2426 -- The Paren_Count field is represented using two boolean flags,
2427 -- where Pflag1 is worth 1, and Pflag2 is worth 2. This is done
2428 -- because we need to be easily able to reuse this field for
2429 -- extra flags in the extended node case.
2432 -- Flag used to indicate if node is a member of a list.
2433 -- This field is considered private to the Atree package.
2436 -- Currently unused flag
2438 Rewrite_Ins
: Boolean;
2439 -- Flag set by Mark_Rewrite_Insertion procedure.
2440 -- This field is considered private to the Atree package.
2443 -- Flag to indicate the node has been analyzed (and expanded)
2445 Comes_From_Source
: Boolean;
2446 -- Flag to indicate that node comes from the source program (i.e.
2447 -- was built by the parser or scanner, not the analyzer or expander).
2449 Error_Posted
: Boolean;
2450 -- Flag to indicate that an error message has been posted on the
2451 -- node (to avoid duplicate flags on the same node)
2468 -- The eighteen flags for a normal node
2470 -- The above fields are used as follows in components 2-4 of
2471 -- an extended node entry.
2473 -- In_List used as Flag19, Flag40, Flag129
2474 -- Unused_1 used as Flag20, Flag41, Flag130
2475 -- Rewrite_Ins used as Flag21, Flag42, Flag131
2476 -- Analyzed used as Flag22, Flag43, Flag132
2477 -- Comes_From_Source used as Flag23, Flag44, Flag133
2478 -- Error_Posted used as Flag24, Flag45, Flag134
2479 -- Flag4 used as Flag25, Flag46, Flag135
2480 -- Flag5 used as Flag26, Flag47, Flag136
2481 -- Flag6 used as Flag27, Flag48, Flag137
2482 -- Flag7 used as Flag28, Flag49, Flag138
2483 -- Flag8 used as Flag29, Flag50, Flag139
2484 -- Flag9 used as Flag30, Flag51, Flag140
2485 -- Flag10 used as Flag31, Flag52, Flag141
2486 -- Flag11 used as Flag32, Flag53, Flag142
2487 -- Flag12 used as Flag33, Flag54, Flag143
2488 -- Flag13 used as Flag34, Flag55, Flag144
2489 -- Flag14 used as Flag35, Flag56, Flag145
2490 -- Flag15 used as Flag36, Flag57, Flag146
2491 -- Flag16 used as Flag37, Flag58, Flag147
2492 -- Flag17 used as Flag38, Flag59, Flag148
2493 -- Flag18 used as Flag39, Flag60, Flag149
2494 -- Pflag1 used as Flag61, Flag62, Flag150
2495 -- Pflag2 used as Flag63, Flag64, Flag151
2498 -- For a non-extended node, or the initial section of an extended
2499 -- node, this field holds the Node_Kind value. For an extended node,
2500 -- The Nkind field is used as follows:
2502 -- Second entry: holds the Ekind field of the entity
2503 -- Third entry: holds 8 additional flags (Flag65-Flag72)
2504 -- Fourth entry: not currently used
2506 -- Now finally (on an 32-bit boundary!) comes the variant part
2508 case Is_Extension
is
2510 -- Non-extended node, or first component of extended node
2515 -- Source location for this node
2518 -- This field is used either as the Parent pointer (if In_List
2519 -- is False), or to point to the list header (if In_List is
2520 -- True). This field is considered private and can be modified
2521 -- only by Atree or by Nlists.
2528 -- Five general use fields, which can contain Node_Id, List_Id,
2529 -- Elist_Id, String_Id, Name_Id, or Char_Code values depending
2530 -- on the values in Nkind and (for extended nodes), in Ekind.
2531 -- See packages Sinfo and Einfo for details of their use.
2533 -- Extension (second component) of extended node
2543 -- Seven additional general fields available only for entities
2544 -- See package Einfo for details of their use (which depends
2545 -- on the value in the Ekind field).
2547 -- In the third component, the extension format as described
2548 -- above is used to hold additional general fields and flags
2551 -- Field6-11 Holds Field13-Field18
2552 -- Field12 Holds Flag73-Flag96 and Convention
2554 -- In the fourth component, the extension format as described
2555 -- above is used to hold additional general fields and flags
2558 -- Field6-10 Holds Field19-Field23
2559 -- Field11 Holds Flag152-Flag167 (16 bits unused)
2560 -- Field12 Holds Flag97-Flag128
2565 pragma Pack
(Node_Record
);
2566 for Node_Record
'Size use 8*32;
2567 for Node_Record
'Alignment use 4;
2569 -- The following defines the extendible array used for the nodes table
2570 -- Nodes with extensions use two consecutive entries in the array
2572 package Nodes
is new Table
.Table
(
2573 Table_Component_Type
=> Node_Record
,
2574 Table_Index_Type
=> Node_Id
,
2575 Table_Low_Bound
=> First_Node_Id
,
2576 Table_Initial
=> Alloc
.Nodes_Initial
,
2577 Table_Increment
=> Alloc
.Nodes_Increment
,
2578 Table_Name
=> "Nodes");
2580 end Atree_Private_Part
;