OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [ada/] [atree.ads] - Blame information for rev 729

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 706 jeremybenn
------------------------------------------------------------------------------
2
--                                                                          --
3
--                         GNAT COMPILER COMPONENTS                         --
4
--                                                                          --
5
--                                A T R E E                                 --
6
--                                                                          --
7
--                                 S p e c                                  --
8
--                                                                          --
9
--          Copyright (C) 1992-2011, Free Software Foundation, Inc.         --
10
--                                                                          --
11
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
12
-- terms of the  GNU General Public License as published  by the Free Soft- --
13
-- ware  Foundation;  either version 3,  or (at your option) any later ver- --
14
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
15
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
16
-- or FITNESS FOR A PARTICULAR PURPOSE.                                     --
17
--                                                                          --
18
-- As a special exception under Section 7 of GPL version 3, you are granted --
19
-- additional permissions described in the GCC Runtime Library Exception,   --
20
-- version 3.1, as published by the Free Software Foundation.               --
21
--                                                                          --
22
-- You should have received a copy of the GNU General Public License and    --
23
-- a copy of the GCC Runtime Library Exception along with this program;     --
24
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
25
-- <http://www.gnu.org/licenses/>.                                          --
26
--                                                                          --
27
-- GNAT was originally developed  by the GNAT team at  New York University. --
28
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
29
--                                                                          --
30
------------------------------------------------------------------------------
31
 
32
with Alloc;
33
with Sinfo;  use Sinfo;
34
with Einfo;  use Einfo;
35
with Namet;  use Namet;
36
with Types;  use Types;
37
with Snames; use Snames;
38
with System; use System;
39
with Table;
40
with Uintp;  use Uintp;
41
with Urealp; use Urealp;
42
with Unchecked_Conversion;
43
 
44
package Atree is
45
 
46
--  This package defines the format of the tree used to represent the Ada
47
--  program internally. Syntactic and semantic information is combined in
48
--  this tree. There is no separate symbol table structure.
49
 
50
--  WARNING: There is a C version of this package. Any changes to this
51
--  source file must be properly reflected in the C header file atree.h
52
 
53
--  Package Atree defines the basic structure of the tree and its nodes and
54
--  provides the basic abstract interface for manipulating the tree. Two
55
--  other packages use this interface to define the representation of Ada
56
--  programs using this tree format. The package Sinfo defines the basic
57
--  representation of the syntactic structure of the program, as output
58
--  by the parser. The package Entity_Info defines the semantic information
59
--  which is added to the tree nodes that represent declared entities (i.e.
60
--  the information which might typically be described in a separate symbol
61
--  table structure).
62
 
63
--  The front end of the compiler first parses the program and generates a
64
--  tree that is simply a syntactic representation of the program in abstract
65
--  syntax tree format. Subsequent processing in the front end traverses the
66
--  tree, transforming it in various ways and adding semantic information.
67
 
68
   ----------------------------------------
69
   -- Definitions of Fields in Tree Node --
70
   ----------------------------------------
71
 
72
   --  The representation of the tree is completely hidden, using a functional
73
   --  interface for accessing and modifying the contents of nodes. Logically
74
   --  a node contains a number of fields, much as though the nodes were
75
   --  defined as a record type. The fields in a node are as follows:
76
 
77
   --   Nkind         Indicates the kind of the node. This field is present
78
   --                 in all nodes. The type is Node_Kind, which is declared
79
   --                 in the package Sinfo.
80
 
81
   --   Sloc          Location (Source_Ptr) of the corresponding token
82
   --                 in the Source buffer. The individual node definitions
83
   --                 show which token is referenced by this pointer.
84
 
85
   --   In_List       A flag used to indicate if the node is a member
86
   --                 of a node list.
87
 
88
   --   Rewrite_Ins   A flag set if a node is marked as a rewrite inserted
89
   --                 node as a result of a call to Mark_Rewrite_Insertion.
90
 
91
   --   Paren_Count   A 2-bit count used in sub-expression nodes to indicate
92
   --                 the level of parentheses. The settings are 0,1,2 and
93
   --                 3 for many. If the value is 3, then an auxiliary table
94
   --                 is used to indicate the real value. Set to zero for
95
   --                 non-subexpression nodes.
96
 
97
   --   Comes_From_Source
98
   --                 This flag is present in all nodes. It is set if the
99
   --                 node is built by the scanner or parser, and clear if
100
   --                 the node is built by the analyzer or expander. It
101
   --                 indicates that the node corresponds to a construct
102
   --                 that appears in the original source program.
103
 
104
   --   Analyzed      This flag is present in all nodes. It is set when
105
   --                 a node is analyzed, and is used to avoid analyzing
106
   --                 the same node twice. Analysis includes expansion if
107
   --                 expansion is active, so in this case if the flag is
108
   --                 set it means the node has been analyzed and expanded.
109
 
110
   --   Error_Posted  This flag is present in all nodes. It is set when
111
   --                 an error message is posted which is associated with
112
   --                 the flagged node. This is used to avoid posting more
113
   --                 than one message on the same node.
114
 
115
   --   Field1
116
   --   Field2
117
   --   Field3
118
   --   Field4
119
   --   Field5        Five fields holding Union_Id values
120
 
121
   --   ElistN        Synonym for FieldN typed as Elist_Id (Empty = No_Elist)
122
   --   ListN         Synonym for FieldN typed as List_Id
123
   --   NameN         Synonym for FieldN typed as Name_Id
124
   --   NodeN         Synonym for FieldN typed as Node_Id
125
   --   StrN          Synonym for FieldN typed as String_Id
126
   --   UintN         Synonym for FieldN typed as Uint (Empty = Uint_0)
127
   --   UrealN        Synonym for FieldN typed as Ureal
128
 
129
   --   Note: in the case of ElistN and UintN fields, it is common that we
130
   --   end up with a value of Union_Id'(0) as the default value. This value
131
   --   is meaningless as a Uint or Elist_Id value. We have two choices here.
132
   --   We could require that all Uint and Elist fields be initialized to an
133
   --   appropriate value, but that's error prone, since it would be easy to
134
   --   miss an initialization. So instead we have the retrieval functions
135
   --   generate an appropriate default value (Uint_0 or No_Elist). Probably
136
   --   it would be cleaner to generate No_Uint in the Uint case but we got
137
   --   stuck with representing an "unset" size value as zero early on, and
138
   --   it will take a bit of fiddling to change that ???
139
 
140
   --   Note: the actual usage of FieldN (i.e. whether it contains a Elist_Id,
141
   --   List_Id, Name_Id, Node_Id, String_Id, Uint or Ureal) depends on the
142
   --   value in Nkind. Generally the access to this field is always via the
143
   --   functional interface, so the field names ElistN, ListN, NameN, NodeN,
144
   --   StrN, UintN and UrealN are used only in the bodies of the access
145
   --   functions (i.e. in the bodies of Sinfo and Einfo). These access
146
   --   functions contain debugging code that checks that the use is
147
   --   consistent with Nkind and Ekind values.
148
 
149
   --   However, in specialized circumstances (examples are the circuit in
150
   --   generic instantiation to copy trees, and in the tree dump routine),
151
   --   it is useful to be able to do untyped traversals, and an internal
152
   --   package in Atree allows for direct untyped accesses in such cases.
153
 
154
   --   Flag4         Fifteen Boolean flags (use depends on Nkind and
155
   --   Flag5         Ekind, as described for FieldN). Again the access
156
   --   Flag6         is usually via subprograms in Sinfo and Einfo which
157
   --   Flag7         provide high-level synonyms for these flags, and
158
   --   Flag8         contain debugging code that checks that the values
159
   --   Flag9         in Nkind and Ekind are appropriate for the access.
160
   --   Flag10
161
   --   Flag11        Note that Flag1-3 are missing from this list. For
162
   --   Flag12        historical reasons, these flag names are unused.
163
   --   Flag13
164
   --   Flag14
165
   --   Flag15
166
   --   Flag16
167
   --   Flag17
168
   --   Flag18
169
 
170
   --   Link          For a node, points to the Parent. For a list, points
171
   --                 to the list header. Note that in the latter case, a
172
   --                 client cannot modify the link field. This field is
173
   --                 private to the Atree package (but is also modified
174
   --                 by the Nlists package).
175
 
176
   --  The following additional fields are present in extended nodes used
177
   --  for entities (Nkind in N_Entity).
178
 
179
   --   Ekind         Entity type. This field indicates the type of the
180
   --                 entity, it is of type Entity_Kind which is defined
181
   --                 in package Einfo.
182
 
183
   --   Flag19        235 additional flags
184
   --   ...
185
   --   Flag254
186
 
187
   --   Convention    Entity convention (Convention_Id value)
188
 
189
   --   Field6        Additional Union_Id value stored in tree
190
 
191
   --   Node6         Synonym for Field6 typed as Node_Id
192
   --   Elist6        Synonym for Field6 typed as Elist_Id (Empty = No_Elist)
193
   --   Uint6         Synonym for Field6 typed as Uint (Empty = Uint_0)
194
 
195
   --   Similar definitions for Field7 to Field28 (and Node7-Node28,
196
   --   Elist7-Elist28, Uint7-Uint28, Ureal7-Ureal28). Note that not all these
197
   --   functions are defined, only the ones that are actually used.
198
 
199
   function Last_Node_Id return Node_Id;
200
   pragma Inline (Last_Node_Id);
201
   --  Returns Id of last allocated node Id
202
 
203
   function Nodes_Address return System.Address;
204
   --  Return address of Nodes table (used in Back_End for Gigi call)
205
 
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.
212
 
213
   -----------------------
214
   -- Use of Empty Node --
215
   -----------------------
216
 
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.
220
 
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).
225
 
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.
230
 
231
   -----------------------
232
   -- Use of Error Node --
233
   -----------------------
234
 
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.
239
 
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.
244
 
245
   ------------------------
246
   -- Current_Error_Node --
247
   ------------------------
248
 
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 high integrity mode.
256
 
257
   --  There are two ways this gets set. During parsing, when new source
258
   --  nodes are being constructed by calls to New_Node and New_Entity,
259
   --  either one of these calls sets Current_Error_Node to the newly
260
   --  created node. During semantic analysis, this mechanism is not
261
   --  used, and instead Current_Error_Node is set by the subprograms in
262
   --  Debug_A that mark the start and end of analysis/expansion of a
263
   --  node in the tree.
264
 
265
   Current_Error_Node : Node_Id;
266
   --  Node to place error messages
267
 
268
   -------------------------------
269
   -- Default Setting of Fields --
270
   -------------------------------
271
 
272
   --  Nkind is set to N_Unused_At_Start
273
 
274
   --  Ekind is set to E_Void
275
 
276
   --  Sloc is always set, there is no default value
277
 
278
   --  Field1-5 fields are set to Empty
279
 
280
   --  Field6-29 fields in extended nodes are set to Empty
281
 
282
   --  Parent is set to Empty
283
 
284
   --  All Boolean flag fields are set to False
285
 
286
   --  Note: the value Empty is used in Field1-Field17 to indicate a null node.
287
   --  The usage varies. The common uses are to indicate absence of an
288
   --  optional clause or a completely unused Field1-17 field.
289
 
290
   -------------------------------------
291
   -- Use of Synonyms for Node Fields --
292
   -------------------------------------
293
 
294
   --  A subpackage Atree.Unchecked_Access provides routines for reading and
295
   --  writing the fields defined above (Field1-27, Node1-27, Flag4-254 etc).
296
   --  These unchecked access routines can be used for untyped traversals.
297
   --  In addition they are used in the implementations of the Sinfo and
298
   --  Einfo packages. These packages both provide logical synonyms for
299
   --  the generic fields, together with an appropriate set of access routines.
300
   --  Normally access to information within tree nodes uses these synonyms,
301
   --  providing a high level typed interface to the tree information.
302
 
303
   --------------------------------------------------
304
   -- Node Allocation and Modification Subprograms --
305
   --------------------------------------------------
306
 
307
   --  Generally the parser builds the tree and then it is further decorated
308
   --  (e.g. by setting the entity fields), but not fundamentally modified.
309
   --  However, there are cases in which the tree must be restructured by
310
   --  adding and rearranging nodes, as a result of disambiguating cases
311
   --  which the parser could not parse correctly, and adding additional
312
   --  semantic information (e.g. making constraint checks explicit). The
313
   --  following subprograms are used for constructing the tree in the first
314
   --  place, and then for subsequent modifications as required.
315
 
316
   procedure Initialize;
317
   --  Called at the start of compilation to initialize the allocation of
318
   --  the node and list tables and make the standard entries for Empty,
319
   --  Error and Error_List. Note that Initialize must not be called if
320
   --  Tree_Read is used.
321
 
322
   procedure Lock;
323
   --  Called before the back end is invoked to lock the nodes table
324
   --  Also called after Unlock to relock???
325
 
326
   procedure Unlock;
327
   --  Unlocks nodes table, in cases where the back end needs to modify it
328
 
329
   procedure Tree_Read;
330
   --  Initializes internal tables from current tree file using the relevant
331
   --  Table.Tree_Read routines. Note that Initialize should not be called if
332
   --  Tree_Read is used. Tree_Read includes all necessary initialization.
333
 
334
   procedure Tree_Write;
335
   --  Writes out internal tables to current tree file using the relevant
336
   --  Table.Tree_Write routines.
337
 
338
   function New_Node
339
     (New_Node_Kind : Node_Kind;
340
      New_Sloc      : Source_Ptr) return Node_Id;
341
   --  Allocates a completely new node with the given node type and source
342
   --  location values. All other fields are set to their standard defaults:
343
   --
344
   --    Empty for all FieldN fields
345
   --    False for all FlagN fields
346
   --
347
   --  The usual approach is to build a new node using this function and
348
   --  then, using the value returned, use the Set_xxx functions to set
349
   --  fields of the node as required. New_Node can only be used for
350
   --  non-entity nodes, i.e. it never generates an extended node.
351
   --
352
   --  If we are currently parsing, as indicated by a previous call to
353
   --  Set_Comes_From_Source_Default (True), then this call also resets
354
   --  the value of Current_Error_Node.
355
 
356
   function New_Entity
357
     (New_Node_Kind : Node_Kind;
358
      New_Sloc      : Source_Ptr) return Entity_Id;
359
   --  Similar to New_Node, except that it is used only for entity nodes
360
   --  and returns an extended node.
361
 
362
   procedure Set_Comes_From_Source_Default (Default : Boolean);
363
   --  Sets value of Comes_From_Source flag to be used in all subsequent
364
   --  New_Node and New_Entity calls until another call to this procedure
365
   --  changes the default. This value is set True during parsing and
366
   --  False during semantic analysis. This is also used to determine
367
   --  if New_Node and New_Entity should set Current_Error_Node.
368
 
369
   function Get_Comes_From_Source_Default return Boolean;
370
   pragma Inline (Get_Comes_From_Source_Default);
371
   --  Gets the current value of the Comes_From_Source flag
372
 
373
   procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id);
374
   pragma Inline (Preserve_Comes_From_Source);
375
   --  When a node is rewritten, it is sometimes appropriate to preserve the
376
   --  original comes from source indication. This is true when the rewrite
377
   --  essentially corresponds to a transformation corresponding exactly to
378
   --  semantics in the reference manual. This procedure copies the setting
379
   --  of Comes_From_Source from OldN to NewN.
380
 
381
   function Has_Extension (N : Node_Id) return Boolean;
382
   pragma Inline (Has_Extension);
383
   --  Returns True if the given node has an extension (i.e. was created by
384
   --  a call to New_Entity rather than New_Node, and Nkind is in N_Entity)
385
 
386
   procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind);
387
   --  This procedure replaces the given node by setting its Nkind field to
388
   --  the indicated value and resetting all other fields to their default
389
   --  values except for Sloc, which is unchanged, and the Parent pointer
390
   --  and list links, which are also unchanged. All other information in
391
   --  the original node is lost. The new node has an extension if the
392
   --  original node had an extension.
393
 
394
   procedure Copy_Node (Source : Node_Id; Destination : Node_Id);
395
   --  Copy the entire contents of the source node to the destination node.
396
   --  The contents of the source node is not affected. If the source node
397
   --  has an extension, then the destination must have an extension also.
398
   --  The parent pointer of the destination and its list link, if any, are
399
   --  not affected by the copy. Note that parent pointers of descendents
400
   --  are not adjusted, so the descendents of the destination node after
401
   --  the Copy_Node is completed have dubious parent pointers. Note that
402
   --  this routine does NOT copy aspect specifications, the Has_Aspects
403
   --  flag in the returned node will always be False. The caller must deal
404
   --  with copying aspect specifications where this is required.
405
 
406
   function New_Copy (Source : Node_Id) return Node_Id;
407
   --  This function allocates a completely new node, and then initializes it
408
   --  by copying the contents of the source node into it. The contents of the
409
   --  source node is not affected. The target node is always marked as not
410
   --  being in a list (even if the source is a list member). The new node will
411
   --  have an extension if the source has an extension. New_Copy (Empty)
412
   --  returns Empty and New_Copy (Error) returns Error. Note that, unlike
413
   --  Copy_Separate_Tree, New_Copy does not recursively copy any descendents,
414
   --  so in general parent pointers are not set correctly for the descendents
415
   --  of the copied node. Both normal and extended nodes (entities) may be
416
   --  copied using New_Copy.
417
 
418
   function Relocate_Node (Source : Node_Id) return Node_Id;
419
   --  Source is a non-entity node that is to be relocated. A new node is
420
   --  allocated and the contents of Source are copied to this node using
421
   --  Copy_Node. The parent pointers of descendents of the node are then
422
   --  adjusted to point to the relocated copy. The original node is not
423
   --  modified, but the parent pointers of its descendents are no longer
424
   --  valid. This routine is used in conjunction with the tree rewrite
425
   --  routines (see descriptions of Replace/Rewrite).
426
   --
427
   --  Note that the resulting node has the same parent as the source
428
   --  node, and is thus still attached to the tree. It is valid for
429
   --  Source to be Empty, in which case Relocate_Node simply returns
430
   --  Empty as the result.
431
 
432
   function Copy_Separate_Tree (Source : Node_Id) return Node_Id;
433
   --  Given a node that is the root of a subtree, Copy_Separate_Tree copies
434
   --  the entire syntactic subtree, including recursively any descendants
435
   --  whose parent field references a copied node (descendants not linked to
436
   --  a copied node by the parent field are also copied.) The parent pointers
437
   --  in the copy are properly set. Copy_Separate_Tree (Empty/Error) returns
438
   --  Empty/Error. The new subtree does not share entities with the source,
439
   --  but has new entities with the same name. Most of the time this routine
440
   --  is called on an unanalyzed tree, and no semantic information is copied.
441
   --  However, to ensure that no entities are shared between the two when the
442
   --  source is already analyzed, entity fields in the copy are zeroed out.
443
 
444
   function Copy_Separate_List (Source : List_Id) return List_Id;
445
   --  Applies Copy_Separate_Tree to each element of the Source list, returning
446
   --  a new list of the results of these copy operations.
447
 
448
   procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id);
449
   --  Exchange the contents of two entities. The parent pointers are switched
450
   --  as well as the Defining_Identifier fields in the parents, so that the
451
   --  entities point correctly to their original parents. The effect is thus
452
   --  to leave the tree completely unchanged in structure, except that the
453
   --  entity ID values of the two entities are interchanged. Neither of the
454
   --  two entities may be list members.
455
 
456
   function Extend_Node (Node : Node_Id) return Entity_Id;
457
   --  This function returns a copy of its input node with an extension added.
458
   --  The fields of the extension are set to Empty. Due to the way extensions
459
   --  are handled (as four consecutive array elements), it may be necessary
460
   --  to reallocate the node, so that the returned value is not the same as
461
   --  the input value, but where possible the returned value will be the same
462
   --  as the input value (i.e. the extension will occur in place). It is the
463
   --  caller's responsibility to ensure that any pointers to the original node
464
   --  are appropriately updated. This function is used only by Sinfo.CN to
465
   --  change nodes into their corresponding entities.
466
 
467
   type Report_Proc is access procedure (Target : Node_Id; Source : Node_Id);
468
 
469
   procedure Set_Reporting_Proc (P : Report_Proc);
470
   --  Register a procedure that is invoked when a node is allocated, replaced
471
   --  or rewritten.
472
 
473
   type Traverse_Result is (Abandon, OK, OK_Orig, Skip);
474
   --  This is the type of the result returned by the Process function passed
475
   --  to Traverse_Func and Traverse_Proc. See below for details.
476
 
477
   subtype Traverse_Final_Result is Traverse_Result range Abandon .. OK;
478
   --  This is the type of the final result returned Traverse_Func, based on
479
   --  the results of Process calls. See below for details.
480
 
481
   generic
482
      with function Process (N : Node_Id) return Traverse_Result is <>;
483
   function Traverse_Func (Node : Node_Id) return Traverse_Final_Result;
484
   --  This is a generic function that, given the parent node for a subtree,
485
   --  traverses all syntactic nodes of this tree, calling the given function
486
   --  Process on each one, in pre order (i.e. top-down). The order of
487
   --  traversing subtrees is arbitrary. The traversal is controlled as follows
488
   --  by the result returned by Process:
489
 
490
   --    OK       The traversal continues normally with the syntactic
491
   --             children of the node just processed.
492
 
493
   --    OK_Orig  The traversal continues normally with the syntactic
494
   --             children of the original node of the node just processed.
495
 
496
   --    Skip     The children of the node just processed are skipped and
497
   --             excluded from the traversal, but otherwise processing
498
   --             continues elsewhere in the tree.
499
 
500
   --    Abandon  The entire traversal is immediately abandoned, and the
501
   --             original call to Traverse returns Abandon.
502
 
503
   --  The result returned by Traverse is Abandon if processing was terminated
504
   --  by a call to Process returning Abandon, otherwise it is OK (meaning that
505
   --  all calls to process returned either OK, OK_Orig, or Skip).
506
 
507
   generic
508
      with function Process (N : Node_Id) return Traverse_Result is <>;
509
   procedure Traverse_Proc (Node : Node_Id);
510
   pragma Inline (Traverse_Proc);
511
   --  This is the same as Traverse_Func except that no result is returned,
512
   --  i.e. Traverse_Func is called and the result is simply discarded.
513
 
514
   ---------------------------
515
   -- Node Access Functions --
516
   ---------------------------
517
 
518
   --  The following functions return the contents of the indicated field of
519
   --  the node referenced by the argument, which is a Node_Id.
520
 
521
   function Nkind             (N : Node_Id) return Node_Kind;
522
   pragma Inline (Nkind);
523
 
524
   function Analyzed          (N : Node_Id) return Boolean;
525
   pragma Inline (Analyzed);
526
 
527
   function Has_Aspects       (N : Node_Id) return Boolean;
528
   pragma Inline (Has_Aspects);
529
 
530
   function Comes_From_Source (N : Node_Id) return Boolean;
531
   pragma Inline (Comes_From_Source);
532
 
533
   function Error_Posted      (N : Node_Id) return Boolean;
534
   pragma Inline (Error_Posted);
535
 
536
   function Sloc              (N : Node_Id) return Source_Ptr;
537
   pragma Inline (Sloc);
538
 
539
   function Paren_Count       (N : Node_Id) return Nat;
540
   pragma Inline (Paren_Count);
541
 
542
   function Parent            (N : Node_Id) return Node_Id;
543
   pragma Inline (Parent);
544
   --  Returns the parent of a node if the node is not a list member, or else
545
   --  the parent of the list containing the node if the node is a list member.
546
 
547
   function No                (N : Node_Id) return Boolean;
548
   pragma Inline (No);
549
   --  Tests given Id for equality with the Empty node. This allows notations
550
   --  like "if No (Variant_Part)" as opposed to "if Variant_Part = Empty".
551
 
552
   function Present           (N : Node_Id) return Boolean;
553
   pragma Inline (Present);
554
   --  Tests given Id for inequality with the Empty node. This allows notations
555
   --  like "if Present (Statement)" as opposed to "if Statement /= Empty".
556
 
557
   ---------------------
558
   -- Node_Kind Tests --
559
   ---------------------
560
 
561
   --  These are like the functions in Sinfo, but the first argument is a
562
   --  Node_Id, and the tested field is Nkind (N).
563
 
564
   function Nkind_In
565
     (N  : Node_Id;
566
      V1 : Node_Kind;
567
      V2 : Node_Kind) return Boolean;
568
 
569
   function Nkind_In
570
     (N  : Node_Id;
571
      V1 : Node_Kind;
572
      V2 : Node_Kind;
573
      V3 : Node_Kind) return Boolean;
574
 
575
   function Nkind_In
576
     (N  : Node_Id;
577
      V1 : Node_Kind;
578
      V2 : Node_Kind;
579
      V3 : Node_Kind;
580
      V4 : Node_Kind) return Boolean;
581
 
582
   function Nkind_In
583
     (N  : Node_Id;
584
      V1 : Node_Kind;
585
      V2 : Node_Kind;
586
      V3 : Node_Kind;
587
      V4 : Node_Kind;
588
      V5 : Node_Kind) return Boolean;
589
 
590
   function Nkind_In
591
     (N  : Node_Id;
592
      V1 : Node_Kind;
593
      V2 : Node_Kind;
594
      V3 : Node_Kind;
595
      V4 : Node_Kind;
596
      V5 : Node_Kind;
597
      V6 : Node_Kind) return Boolean;
598
 
599
   function Nkind_In
600
     (N  : Node_Id;
601
      V1 : Node_Kind;
602
      V2 : Node_Kind;
603
      V3 : Node_Kind;
604
      V4 : Node_Kind;
605
      V5 : Node_Kind;
606
      V6 : Node_Kind;
607
      V7 : Node_Kind) return Boolean;
608
 
609
   function Nkind_In
610
     (N  : Node_Id;
611
      V1 : Node_Kind;
612
      V2 : Node_Kind;
613
      V3 : Node_Kind;
614
      V4 : Node_Kind;
615
      V5 : Node_Kind;
616
      V6 : Node_Kind;
617
      V7 : Node_Kind;
618
      V8 : Node_Kind) return Boolean;
619
 
620
   function Nkind_In
621
     (N  : Node_Id;
622
      V1 : Node_Kind;
623
      V2 : Node_Kind;
624
      V3 : Node_Kind;
625
      V4 : Node_Kind;
626
      V5 : Node_Kind;
627
      V6 : Node_Kind;
628
      V7 : Node_Kind;
629
      V8 : Node_Kind;
630
      V9 : Node_Kind) return Boolean;
631
 
632
   pragma Inline (Nkind_In);
633
   --  Inline all above functions
634
 
635
   -----------------------
636
   -- Entity_Kind_Tests --
637
   -----------------------
638
 
639
   --  Utility functions to test whether an Entity_Kind value, either given
640
   --  directly as the first argument, or the Ekind field of an Entity give
641
   --  as the first argument, matches any of the given list of Entity_Kind
642
   --  values. Return True if any match, False if no match.
643
 
644
   function Ekind_In
645
     (E  : Entity_Id;
646
      V1 : Entity_Kind;
647
      V2 : Entity_Kind) return Boolean;
648
 
649
   function Ekind_In
650
     (E  : Entity_Id;
651
      V1 : Entity_Kind;
652
      V2 : Entity_Kind;
653
      V3 : Entity_Kind) return Boolean;
654
 
655
   function Ekind_In
656
     (E  : Entity_Id;
657
      V1 : Entity_Kind;
658
      V2 : Entity_Kind;
659
      V3 : Entity_Kind;
660
      V4 : Entity_Kind) return Boolean;
661
 
662
   function Ekind_In
663
     (E  : Entity_Id;
664
      V1 : Entity_Kind;
665
      V2 : Entity_Kind;
666
      V3 : Entity_Kind;
667
      V4 : Entity_Kind;
668
      V5 : Entity_Kind) return Boolean;
669
 
670
   function Ekind_In
671
     (E  : Entity_Id;
672
      V1 : Entity_Kind;
673
      V2 : Entity_Kind;
674
      V3 : Entity_Kind;
675
      V4 : Entity_Kind;
676
      V5 : Entity_Kind;
677
      V6 : Entity_Kind) return Boolean;
678
 
679
   function Ekind_In
680
     (T  : Entity_Kind;
681
      V1 : Entity_Kind;
682
      V2 : Entity_Kind) return Boolean;
683
 
684
   function Ekind_In
685
     (T  : Entity_Kind;
686
      V1 : Entity_Kind;
687
      V2 : Entity_Kind;
688
      V3 : Entity_Kind) return Boolean;
689
 
690
   function Ekind_In
691
     (T  : Entity_Kind;
692
      V1 : Entity_Kind;
693
      V2 : Entity_Kind;
694
      V3 : Entity_Kind;
695
      V4 : Entity_Kind) return Boolean;
696
 
697
   function Ekind_In
698
     (T  : Entity_Kind;
699
      V1 : Entity_Kind;
700
      V2 : Entity_Kind;
701
      V3 : Entity_Kind;
702
      V4 : Entity_Kind;
703
      V5 : Entity_Kind) return Boolean;
704
 
705
   function Ekind_In
706
     (T  : Entity_Kind;
707
      V1 : Entity_Kind;
708
      V2 : Entity_Kind;
709
      V3 : Entity_Kind;
710
      V4 : Entity_Kind;
711
      V5 : Entity_Kind;
712
      V6 : Entity_Kind) return Boolean;
713
 
714
   pragma Inline (Ekind_In);
715
   --  Inline all above functions
716
 
717
   -----------------------------
718
   -- Entity Access Functions --
719
   -----------------------------
720
 
721
   --  The following functions apply only to Entity_Id values, i.e.
722
   --  to extended nodes.
723
 
724
   function Ekind (E : Entity_Id) return Entity_Kind;
725
   pragma Inline (Ekind);
726
 
727
   function Convention (E : Entity_Id) return Convention_Id;
728
   pragma Inline (Convention);
729
 
730
   ----------------------------
731
   -- Node Update Procedures --
732
   ----------------------------
733
 
734
   --  The following functions set a specified field in the node whose Id is
735
   --  passed as the first argument. The second parameter is the new value
736
   --  to be set in the specified field. Note that Set_Nkind is in the next
737
   --  section, since its use is restricted.
738
 
739
   procedure Set_Sloc         (N : Node_Id; Val : Source_Ptr);
740
   pragma Inline (Set_Sloc);
741
 
742
   procedure Set_Paren_Count  (N : Node_Id; Val : Nat);
743
   pragma Inline (Set_Paren_Count);
744
 
745
   procedure Set_Parent       (N : Node_Id; Val : Node_Id);
746
   pragma Inline (Set_Parent);
747
 
748
   procedure Set_Analyzed     (N : Node_Id; Val : Boolean := True);
749
   pragma Inline (Set_Analyzed);
750
 
751
   procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True);
752
   pragma Inline (Set_Error_Posted);
753
 
754
   procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean);
755
   pragma Inline (Set_Comes_From_Source);
756
   --  Note that this routine is very rarely used, since usually the
757
   --  default mechanism provided sets the right value, but in some
758
   --  unusual cases, the value needs to be reset (e.g. when a source
759
   --  node is copied, and the copy must not have Comes_From_Source set.
760
 
761
   procedure Set_Has_Aspects (N : Node_Id; Val : Boolean := True);
762
   pragma Inline (Set_Has_Aspects);
763
 
764
   procedure Set_Original_Node (N : Node_Id; Val : Node_Id);
765
   pragma Inline (Set_Original_Node);
766
   --  Note that this routine is used only in very peculiar cases. In normal
767
   --  cases, the Original_Node link is set by calls to Rewrite. We currently
768
   --  use it in ASIS mode to manually set the link from pragma expressions
769
   --  to their aspect original source expressions, so that the original source
770
   --  expressions accessed by ASIS are also semantically analyzed.
771
 
772
   ------------------------------
773
   -- Entity Update Procedures --
774
   ------------------------------
775
 
776
   --  The following procedures apply only to Entity_Id values, i.e.
777
   --  to extended nodes.
778
 
779
   procedure Basic_Set_Convention (E : Entity_Id; Val : Convention_Id);
780
   pragma Inline (Basic_Set_Convention);
781
   --  Clients should use Sem_Util.Set_Convention rather than calling this
782
   --  routine directly, as Set_Convention also deals with the special
783
   --  processing required for access types.
784
 
785
   procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind);
786
   pragma Inline (Set_Ekind);
787
 
788
   ---------------------------
789
   -- Tree Rewrite Routines --
790
   ---------------------------
791
 
792
   --  During the compilation process it is necessary in a number of situations
793
   --  to rewrite the tree. In some cases, such rewrites do not affect the
794
   --  structure of the tree, for example, when an indexed component node is
795
   --  replaced by the corresponding call node (the parser cannot distinguish
796
   --  between these two cases).
797
 
798
   --  In other situations, the rewrite does affect the structure of the
799
   --  tree. Examples are the replacement of a generic instantiation by the
800
   --  instantiated spec and body, and the static evaluation of expressions.
801
 
802
   --  If such structural modifications are done by the expander, there are
803
   --  no difficulties, since the form of the tree after the expander has no
804
   --  special significance, except as input to the backend of the compiler.
805
   --  However, if these modifications are done by the semantic phase, then
806
   --  it is important that they be done in a manner which allows the original
807
   --  tree to be preserved. This is because tools like pretty printers need
808
   --  to have this original tree structure available.
809
 
810
   --  The subprograms in this section allow rewriting of the tree by either
811
   --  insertion of new nodes in an existing list, or complete replacement of
812
   --  a subtree. The resulting tree for most purposes looks as though it has
813
   --  been really changed, and there is no trace of the original. However,
814
   --  special subprograms, also defined in this section, allow the original
815
   --  tree to be reconstructed if necessary.
816
 
817
   --  For tree modifications done in the expander, it is permissible to
818
   --  destroy the original tree, although it is also allowable to use the
819
   --  tree rewrite routines where it is convenient to do so.
820
 
821
   procedure Mark_Rewrite_Insertion (New_Node : Node_Id);
822
   pragma Inline (Mark_Rewrite_Insertion);
823
   --  This procedure marks the given node as an insertion made during a tree
824
   --  rewriting operation. Only the root needs to be marked. The call does
825
   --  not do the actual insertion, which must be done using one of the normal
826
   --  list insertion routines. The node is treated normally in all respects
827
   --  except for its response to Is_Rewrite_Insertion. The function of these
828
   --  calls is to be able to get an accurate original tree. This helps the
829
   --  accuracy of Sprint.Sprint_Node, and in particular, when stubs are being
830
   --  generated, it is essential that the original tree be accurate.
831
 
832
   function Is_Rewrite_Insertion (Node : Node_Id) return Boolean;
833
   pragma Inline (Is_Rewrite_Insertion);
834
   --  Tests whether the given node was marked using Mark_Rewrite_Insertion.
835
   --  This is used in reconstructing the original tree (where such nodes are
836
   --  to be eliminated).
837
 
838
   procedure Rewrite (Old_Node, New_Node : Node_Id);
839
   --  This is used when a complete subtree is to be replaced. Old_Node is the
840
   --  root of the old subtree to be replaced, and New_Node is the root of the
841
   --  newly constructed replacement subtree. The actual mechanism is to swap
842
   --  the contents of these two nodes fixing up the parent pointers of the
843
   --  replaced node (we do not attempt to preserve parent pointers for the
844
   --  original node). Neither Old_Node nor New_Node can be extended nodes.
845
   --
846
   --  Note: New_Node may not contain references to Old_Node, for example as
847
   --  descendents, since the rewrite would make such references invalid. If
848
   --  New_Node does need to reference Old_Node, then these references should
849
   --  be to a relocated copy of Old_Node (see Relocate_Node procedure).
850
   --
851
   --  Note: The Original_Node function applied to Old_Node (which has now
852
   --  been replaced by the contents of New_Node), can be used to obtain the
853
   --  original node, i.e. the old contents of Old_Node.
854
 
855
   procedure Replace (Old_Node, New_Node : Node_Id);
856
   --  This is similar to Rewrite, except that the old value of Old_Node is
857
   --  not saved, and the New_Node is deleted after the replace, since it
858
   --  is assumed that it can no longer be legitimately needed. The flag
859
   --  Is_Rewrite_Substitution will be False for the resulting node, unless
860
   --  it was already true on entry, and Original_Node will not return the
861
   --  original contents of the Old_Node, but rather the New_Node value (unless
862
   --  Old_Node had already been rewritten using Rewrite). Replace also
863
   --  preserves the setting of Comes_From_Source.
864
   --
865
   --  Note, New_Node may not contain references to Old_Node, for example as
866
   --  descendents, since the rewrite would make such references invalid. If
867
   --  New_Node does need to reference Old_Node, then these references should
868
   --  be to a relocated copy of Old_Node (see Relocate_Node procedure).
869
   --
870
   --  Replace is used in certain circumstances where it is desirable to
871
   --  suppress any history of the rewriting operation. Notably, it is used
872
   --  when the parser has mis-classified a node (e.g. a task entry call
873
   --  that the parser has parsed as a procedure call).
874
 
875
   function Is_Rewrite_Substitution (Node : Node_Id) return Boolean;
876
   pragma Inline (Is_Rewrite_Substitution);
877
   --  Return True iff Node has been rewritten (i.e. if Node is the root
878
   --  of a subtree which was installed using Rewrite).
879
 
880
   function Original_Node (Node : Node_Id) return Node_Id;
881
   pragma Inline (Original_Node);
882
   --  If Node has not been rewritten, then returns its input argument
883
   --  unchanged, else returns the Node for the original subtree.
884
   --
885
   --  Note: Parents are not preserved in original tree nodes that are
886
   --  retrieved in this way (i.e. their children may have children whose
887
   --  pointers which reference some other node).
888
 
889
   --  Note: there is no direct mechanism for deleting an original node (in
890
   --  a manner that can be reversed later). One possible approach is to use
891
   --  Rewrite to substitute a null statement for the node to be deleted.
892
 
893
   -----------------------------------
894
   -- Generic Field Access Routines --
895
   -----------------------------------
896
 
897
   --  This subpackage provides the functions for accessing and procedures for
898
   --  setting fields that are normally referenced by wrapper subprograms (e.g.
899
   --  logical synonyms defined in packages Sinfo and Einfo, or specialized
900
   --  routines such as Rewrite (for Original_Node), or the node creation
901
   --  routines (for Set_Nkind). The implementations of these wrapper
902
   --  subprograms use the package Atree.Unchecked_Access as do various
903
   --  special case accesses where no wrapper applies. Documentation is always
904
   --  required for such a special case access explaining why it is needed.
905
 
906
   package Unchecked_Access is
907
 
908
      --  Functions to allow interpretation of Union_Id values as Uint and
909
      --  Ureal values.
910
 
911
      function To_Union is new Unchecked_Conversion (Uint,  Union_Id);
912
      function To_Union is new Unchecked_Conversion (Ureal, Union_Id);
913
 
914
      function From_Union is new Unchecked_Conversion (Union_Id, Uint);
915
      function From_Union is new Unchecked_Conversion (Union_Id, Ureal);
916
 
917
      --  Functions to fetch contents of indicated field. It is an error to
918
      --  attempt to read the value of a field which is not present.
919
 
920
      function Field1 (N : Node_Id) return Union_Id;
921
      pragma Inline (Field1);
922
 
923
      function Field2 (N : Node_Id) return Union_Id;
924
      pragma Inline (Field2);
925
 
926
      function Field3 (N : Node_Id) return Union_Id;
927
      pragma Inline (Field3);
928
 
929
      function Field4 (N : Node_Id) return Union_Id;
930
      pragma Inline (Field4);
931
 
932
      function Field5 (N : Node_Id) return Union_Id;
933
      pragma Inline (Field5);
934
 
935
      function Field6 (N : Node_Id) return Union_Id;
936
      pragma Inline (Field6);
937
 
938
      function Field7 (N : Node_Id) return Union_Id;
939
      pragma Inline (Field7);
940
 
941
      function Field8 (N : Node_Id) return Union_Id;
942
      pragma Inline (Field8);
943
 
944
      function Field9 (N : Node_Id) return Union_Id;
945
      pragma Inline (Field9);
946
 
947
      function Field10 (N : Node_Id) return Union_Id;
948
      pragma Inline (Field10);
949
 
950
      function Field11 (N : Node_Id) return Union_Id;
951
      pragma Inline (Field11);
952
 
953
      function Field12 (N : Node_Id) return Union_Id;
954
      pragma Inline (Field12);
955
 
956
      function Field13 (N : Node_Id) return Union_Id;
957
      pragma Inline (Field13);
958
 
959
      function Field14 (N : Node_Id) return Union_Id;
960
      pragma Inline (Field14);
961
 
962
      function Field15 (N : Node_Id) return Union_Id;
963
      pragma Inline (Field15);
964
 
965
      function Field16 (N : Node_Id) return Union_Id;
966
      pragma Inline (Field16);
967
 
968
      function Field17 (N : Node_Id) return Union_Id;
969
      pragma Inline (Field17);
970
 
971
      function Field18 (N : Node_Id) return Union_Id;
972
      pragma Inline (Field18);
973
 
974
      function Field19 (N : Node_Id) return Union_Id;
975
      pragma Inline (Field19);
976
 
977
      function Field20 (N : Node_Id) return Union_Id;
978
      pragma Inline (Field20);
979
 
980
      function Field21 (N : Node_Id) return Union_Id;
981
      pragma Inline (Field21);
982
 
983
      function Field22 (N : Node_Id) return Union_Id;
984
      pragma Inline (Field22);
985
 
986
      function Field23 (N : Node_Id) return Union_Id;
987
      pragma Inline (Field23);
988
 
989
      function Field24 (N : Node_Id) return Union_Id;
990
      pragma Inline (Field24);
991
 
992
      function Field25 (N : Node_Id) return Union_Id;
993
      pragma Inline (Field25);
994
 
995
      function Field26 (N : Node_Id) return Union_Id;
996
      pragma Inline (Field26);
997
 
998
      function Field27 (N : Node_Id) return Union_Id;
999
      pragma Inline (Field27);
1000
 
1001
      function Field28 (N : Node_Id) return Union_Id;
1002
      pragma Inline (Field28);
1003
 
1004
      function Field29 (N : Node_Id) return Union_Id;
1005
      pragma Inline (Field29);
1006
 
1007
      function Node1 (N : Node_Id) return Node_Id;
1008
      pragma Inline (Node1);
1009
 
1010
      function Node2 (N : Node_Id) return Node_Id;
1011
      pragma Inline (Node2);
1012
 
1013
      function Node3 (N : Node_Id) return Node_Id;
1014
      pragma Inline (Node3);
1015
 
1016
      function Node4 (N : Node_Id) return Node_Id;
1017
      pragma Inline (Node4);
1018
 
1019
      function Node5 (N : Node_Id) return Node_Id;
1020
      pragma Inline (Node5);
1021
 
1022
      function Node6 (N : Node_Id) return Node_Id;
1023
      pragma Inline (Node6);
1024
 
1025
      function Node7 (N : Node_Id) return Node_Id;
1026
      pragma Inline (Node7);
1027
 
1028
      function Node8 (N : Node_Id) return Node_Id;
1029
      pragma Inline (Node8);
1030
 
1031
      function Node9 (N : Node_Id) return Node_Id;
1032
      pragma Inline (Node9);
1033
 
1034
      function Node10 (N : Node_Id) return Node_Id;
1035
      pragma Inline (Node10);
1036
 
1037
      function Node11 (N : Node_Id) return Node_Id;
1038
      pragma Inline (Node11);
1039
 
1040
      function Node12 (N : Node_Id) return Node_Id;
1041
      pragma Inline (Node12);
1042
 
1043
      function Node13 (N : Node_Id) return Node_Id;
1044
      pragma Inline (Node13);
1045
 
1046
      function Node14 (N : Node_Id) return Node_Id;
1047
      pragma Inline (Node14);
1048
 
1049
      function Node15 (N : Node_Id) return Node_Id;
1050
      pragma Inline (Node15);
1051
 
1052
      function Node16 (N : Node_Id) return Node_Id;
1053
      pragma Inline (Node16);
1054
 
1055
      function Node17 (N : Node_Id) return Node_Id;
1056
      pragma Inline (Node17);
1057
 
1058
      function Node18 (N : Node_Id) return Node_Id;
1059
      pragma Inline (Node18);
1060
 
1061
      function Node19 (N : Node_Id) return Node_Id;
1062
      pragma Inline (Node19);
1063
 
1064
      function Node20 (N : Node_Id) return Node_Id;
1065
      pragma Inline (Node20);
1066
 
1067
      function Node21 (N : Node_Id) return Node_Id;
1068
      pragma Inline (Node21);
1069
 
1070
      function Node22 (N : Node_Id) return Node_Id;
1071
      pragma Inline (Node22);
1072
 
1073
      function Node23 (N : Node_Id) return Node_Id;
1074
      pragma Inline (Node23);
1075
 
1076
      function Node24 (N : Node_Id) return Node_Id;
1077
      pragma Inline (Node24);
1078
 
1079
      function Node25 (N : Node_Id) return Node_Id;
1080
      pragma Inline (Node25);
1081
 
1082
      function Node26 (N : Node_Id) return Node_Id;
1083
      pragma Inline (Node26);
1084
 
1085
      function Node27 (N : Node_Id) return Node_Id;
1086
      pragma Inline (Node27);
1087
 
1088
      function Node28 (N : Node_Id) return Node_Id;
1089
      pragma Inline (Node28);
1090
 
1091
      function Node29 (N : Node_Id) return Node_Id;
1092
      pragma Inline (Node29);
1093
 
1094
      function List1 (N : Node_Id) return List_Id;
1095
      pragma Inline (List1);
1096
 
1097
      function List2 (N : Node_Id) return List_Id;
1098
      pragma Inline (List2);
1099
 
1100
      function List3 (N : Node_Id) return List_Id;
1101
      pragma Inline (List3);
1102
 
1103
      function List4 (N : Node_Id) return List_Id;
1104
      pragma Inline (List4);
1105
 
1106
      function List5 (N : Node_Id) return List_Id;
1107
      pragma Inline (List5);
1108
 
1109
      function List10 (N : Node_Id) return List_Id;
1110
      pragma Inline (List10);
1111
 
1112
      function List14 (N : Node_Id) return List_Id;
1113
      pragma Inline (List14);
1114
 
1115
      function List25 (N : Node_Id) return List_Id;
1116
      pragma Inline (List25);
1117
 
1118
      function Elist1 (N : Node_Id) return Elist_Id;
1119
      pragma Inline (Elist1);
1120
 
1121
      function Elist2 (N : Node_Id) return Elist_Id;
1122
      pragma Inline (Elist2);
1123
 
1124
      function Elist3 (N : Node_Id) return Elist_Id;
1125
      pragma Inline (Elist3);
1126
 
1127
      function Elist4 (N : Node_Id) return Elist_Id;
1128
      pragma Inline (Elist4);
1129
 
1130
      function Elist5 (N : Node_Id) return Elist_Id;
1131
      pragma Inline (Elist5);
1132
 
1133
      function Elist8 (N : Node_Id) return Elist_Id;
1134
      pragma Inline (Elist8);
1135
 
1136
      function Elist10 (N : Node_Id) return Elist_Id;
1137
      pragma Inline (Elist10);
1138
 
1139
      function Elist13 (N : Node_Id) return Elist_Id;
1140
      pragma Inline (Elist13);
1141
 
1142
      function Elist15 (N : Node_Id) return Elist_Id;
1143
      pragma Inline (Elist15);
1144
 
1145
      function Elist16 (N : Node_Id) return Elist_Id;
1146
      pragma Inline (Elist16);
1147
 
1148
      function Elist18 (N : Node_Id) return Elist_Id;
1149
      pragma Inline (Elist18);
1150
 
1151
      function Elist21 (N : Node_Id) return Elist_Id;
1152
      pragma Inline (Elist21);
1153
 
1154
      function Elist23 (N : Node_Id) return Elist_Id;
1155
      pragma Inline (Elist23);
1156
 
1157
      function Elist24 (N : Node_Id) return Elist_Id;
1158
      pragma Inline (Elist24);
1159
 
1160
      function Elist25 (N : Node_Id) return Elist_Id;
1161
      pragma Inline (Elist25);
1162
 
1163
      function Elist26 (N : Node_Id) return Elist_Id;
1164
      pragma Inline (Elist26);
1165
 
1166
      function Name1 (N : Node_Id) return Name_Id;
1167
      pragma Inline (Name1);
1168
 
1169
      function Name2 (N : Node_Id) return Name_Id;
1170
      pragma Inline (Name2);
1171
 
1172
      function Str3 (N : Node_Id) return String_Id;
1173
      pragma Inline (Str3);
1174
 
1175
      --  Note: the following Uintnn functions have a special test for the
1176
      --  Field value being Empty. If an Empty value is found then Uint_0 is
1177
      --  returned. This avoids the rather tricky requirement of initializing
1178
      --  all Uint fields in nodes and entities.
1179
 
1180
      function Uint2 (N : Node_Id) return Uint;
1181
      pragma Inline (Uint2);
1182
 
1183
      function Uint3 (N : Node_Id) return Uint;
1184
      pragma Inline (Uint3);
1185
 
1186
      function Uint4 (N : Node_Id) return Uint;
1187
      pragma Inline (Uint4);
1188
 
1189
      function Uint5 (N : Node_Id) return Uint;
1190
      pragma Inline (Uint5);
1191
 
1192
      function Uint8 (N : Node_Id) return Uint;
1193
      pragma Inline (Uint8);
1194
 
1195
      function Uint9 (N : Node_Id) return Uint;
1196
      pragma Inline (Uint9);
1197
 
1198
      function Uint10 (N : Node_Id) return Uint;
1199
      pragma Inline (Uint10);
1200
 
1201
      function Uint11 (N : Node_Id) return Uint;
1202
      pragma Inline (Uint11);
1203
 
1204
      function Uint12 (N : Node_Id) return Uint;
1205
      pragma Inline (Uint12);
1206
 
1207
      function Uint13 (N : Node_Id) return Uint;
1208
      pragma Inline (Uint13);
1209
 
1210
      function Uint14 (N : Node_Id) return Uint;
1211
      pragma Inline (Uint14);
1212
 
1213
      function Uint15 (N : Node_Id) return Uint;
1214
      pragma Inline (Uint15);
1215
 
1216
      function Uint16 (N : Node_Id) return Uint;
1217
      pragma Inline (Uint16);
1218
 
1219
      function Uint17 (N : Node_Id) return Uint;
1220
      pragma Inline (Uint17);
1221
 
1222
      function Uint22 (N : Node_Id) return Uint;
1223
      pragma Inline (Uint22);
1224
 
1225
      function Ureal3 (N : Node_Id) return Ureal;
1226
      pragma Inline (Ureal3);
1227
 
1228
      function Ureal18 (N : Node_Id) return Ureal;
1229
      pragma Inline (Ureal18);
1230
 
1231
      function Ureal21 (N : Node_Id) return Ureal;
1232
      pragma Inline (Ureal21);
1233
 
1234
      function Flag4 (N : Node_Id) return Boolean;
1235
      pragma Inline (Flag4);
1236
 
1237
      function Flag5 (N : Node_Id) return Boolean;
1238
      pragma Inline (Flag5);
1239
 
1240
      function Flag6 (N : Node_Id) return Boolean;
1241
      pragma Inline (Flag6);
1242
 
1243
      function Flag7 (N : Node_Id) return Boolean;
1244
      pragma Inline (Flag7);
1245
 
1246
      function Flag8 (N : Node_Id) return Boolean;
1247
      pragma Inline (Flag8);
1248
 
1249
      function Flag9 (N : Node_Id) return Boolean;
1250
      pragma Inline (Flag9);
1251
 
1252
      function Flag10 (N : Node_Id) return Boolean;
1253
      pragma Inline (Flag10);
1254
 
1255
      function Flag11 (N : Node_Id) return Boolean;
1256
      pragma Inline (Flag11);
1257
 
1258
      function Flag12 (N : Node_Id) return Boolean;
1259
      pragma Inline (Flag12);
1260
 
1261
      function Flag13 (N : Node_Id) return Boolean;
1262
      pragma Inline (Flag13);
1263
 
1264
      function Flag14 (N : Node_Id) return Boolean;
1265
      pragma Inline (Flag14);
1266
 
1267
      function Flag15 (N : Node_Id) return Boolean;
1268
      pragma Inline (Flag15);
1269
 
1270
      function Flag16 (N : Node_Id) return Boolean;
1271
      pragma Inline (Flag16);
1272
 
1273
      function Flag17 (N : Node_Id) return Boolean;
1274
      pragma Inline (Flag17);
1275
 
1276
      function Flag18 (N : Node_Id) return Boolean;
1277
      pragma Inline (Flag18);
1278
 
1279
      function Flag19 (N : Node_Id) return Boolean;
1280
      pragma Inline (Flag19);
1281
 
1282
      function Flag20 (N : Node_Id) return Boolean;
1283
      pragma Inline (Flag20);
1284
 
1285
      function Flag21 (N : Node_Id) return Boolean;
1286
      pragma Inline (Flag21);
1287
 
1288
      function Flag22 (N : Node_Id) return Boolean;
1289
      pragma Inline (Flag22);
1290
 
1291
      function Flag23 (N : Node_Id) return Boolean;
1292
      pragma Inline (Flag23);
1293
 
1294
      function Flag24 (N : Node_Id) return Boolean;
1295
      pragma Inline (Flag24);
1296
 
1297
      function Flag25 (N : Node_Id) return Boolean;
1298
      pragma Inline (Flag25);
1299
 
1300
      function Flag26 (N : Node_Id) return Boolean;
1301
      pragma Inline (Flag26);
1302
 
1303
      function Flag27 (N : Node_Id) return Boolean;
1304
      pragma Inline (Flag27);
1305
 
1306
      function Flag28 (N : Node_Id) return Boolean;
1307
      pragma Inline (Flag28);
1308
 
1309
      function Flag29 (N : Node_Id) return Boolean;
1310
      pragma Inline (Flag29);
1311
 
1312
      function Flag30 (N : Node_Id) return Boolean;
1313
      pragma Inline (Flag30);
1314
 
1315
      function Flag31 (N : Node_Id) return Boolean;
1316
      pragma Inline (Flag31);
1317
 
1318
      function Flag32 (N : Node_Id) return Boolean;
1319
      pragma Inline (Flag32);
1320
 
1321
      function Flag33 (N : Node_Id) return Boolean;
1322
      pragma Inline (Flag33);
1323
 
1324
      function Flag34 (N : Node_Id) return Boolean;
1325
      pragma Inline (Flag34);
1326
 
1327
      function Flag35 (N : Node_Id) return Boolean;
1328
      pragma Inline (Flag35);
1329
 
1330
      function Flag36 (N : Node_Id) return Boolean;
1331
      pragma Inline (Flag36);
1332
 
1333
      function Flag37 (N : Node_Id) return Boolean;
1334
      pragma Inline (Flag37);
1335
 
1336
      function Flag38 (N : Node_Id) return Boolean;
1337
      pragma Inline (Flag38);
1338
 
1339
      function Flag39 (N : Node_Id) return Boolean;
1340
      pragma Inline (Flag39);
1341
 
1342
      function Flag40 (N : Node_Id) return Boolean;
1343
      pragma Inline (Flag40);
1344
 
1345
      function Flag41 (N : Node_Id) return Boolean;
1346
      pragma Inline (Flag41);
1347
 
1348
      function Flag42 (N : Node_Id) return Boolean;
1349
      pragma Inline (Flag42);
1350
 
1351
      function Flag43 (N : Node_Id) return Boolean;
1352
      pragma Inline (Flag43);
1353
 
1354
      function Flag44 (N : Node_Id) return Boolean;
1355
      pragma Inline (Flag44);
1356
 
1357
      function Flag45 (N : Node_Id) return Boolean;
1358
      pragma Inline (Flag45);
1359
 
1360
      function Flag46 (N : Node_Id) return Boolean;
1361
      pragma Inline (Flag46);
1362
 
1363
      function Flag47 (N : Node_Id) return Boolean;
1364
      pragma Inline (Flag47);
1365
 
1366
      function Flag48 (N : Node_Id) return Boolean;
1367
      pragma Inline (Flag48);
1368
 
1369
      function Flag49 (N : Node_Id) return Boolean;
1370
      pragma Inline (Flag49);
1371
 
1372
      function Flag50 (N : Node_Id) return Boolean;
1373
      pragma Inline (Flag50);
1374
 
1375
      function Flag51 (N : Node_Id) return Boolean;
1376
      pragma Inline (Flag51);
1377
 
1378
      function Flag52 (N : Node_Id) return Boolean;
1379
      pragma Inline (Flag52);
1380
 
1381
      function Flag53 (N : Node_Id) return Boolean;
1382
      pragma Inline (Flag53);
1383
 
1384
      function Flag54 (N : Node_Id) return Boolean;
1385
      pragma Inline (Flag54);
1386
 
1387
      function Flag55 (N : Node_Id) return Boolean;
1388
      pragma Inline (Flag55);
1389
 
1390
      function Flag56 (N : Node_Id) return Boolean;
1391
      pragma Inline (Flag56);
1392
 
1393
      function Flag57 (N : Node_Id) return Boolean;
1394
      pragma Inline (Flag57);
1395
 
1396
      function Flag58 (N : Node_Id) return Boolean;
1397
      pragma Inline (Flag58);
1398
 
1399
      function Flag59 (N : Node_Id) return Boolean;
1400
      pragma Inline (Flag59);
1401
 
1402
      function Flag60 (N : Node_Id) return Boolean;
1403
      pragma Inline (Flag60);
1404
 
1405
      function Flag61 (N : Node_Id) return Boolean;
1406
      pragma Inline (Flag61);
1407
 
1408
      function Flag62 (N : Node_Id) return Boolean;
1409
      pragma Inline (Flag62);
1410
 
1411
      function Flag63 (N : Node_Id) return Boolean;
1412
      pragma Inline (Flag63);
1413
 
1414
      function Flag64 (N : Node_Id) return Boolean;
1415
      pragma Inline (Flag64);
1416
 
1417
      function Flag65 (N : Node_Id) return Boolean;
1418
      pragma Inline (Flag65);
1419
 
1420
      function Flag66 (N : Node_Id) return Boolean;
1421
      pragma Inline (Flag66);
1422
 
1423
      function Flag67 (N : Node_Id) return Boolean;
1424
      pragma Inline (Flag67);
1425
 
1426
      function Flag68 (N : Node_Id) return Boolean;
1427
      pragma Inline (Flag68);
1428
 
1429
      function Flag69 (N : Node_Id) return Boolean;
1430
      pragma Inline (Flag69);
1431
 
1432
      function Flag70 (N : Node_Id) return Boolean;
1433
      pragma Inline (Flag70);
1434
 
1435
      function Flag71 (N : Node_Id) return Boolean;
1436
      pragma Inline (Flag71);
1437
 
1438
      function Flag72 (N : Node_Id) return Boolean;
1439
      pragma Inline (Flag72);
1440
 
1441
      function Flag73 (N : Node_Id) return Boolean;
1442
      pragma Inline (Flag73);
1443
 
1444
      function Flag74 (N : Node_Id) return Boolean;
1445
      pragma Inline (Flag74);
1446
 
1447
      function Flag75 (N : Node_Id) return Boolean;
1448
      pragma Inline (Flag75);
1449
 
1450
      function Flag76 (N : Node_Id) return Boolean;
1451
      pragma Inline (Flag76);
1452
 
1453
      function Flag77 (N : Node_Id) return Boolean;
1454
      pragma Inline (Flag77);
1455
 
1456
      function Flag78 (N : Node_Id) return Boolean;
1457
      pragma Inline (Flag78);
1458
 
1459
      function Flag79 (N : Node_Id) return Boolean;
1460
      pragma Inline (Flag79);
1461
 
1462
      function Flag80 (N : Node_Id) return Boolean;
1463
      pragma Inline (Flag80);
1464
 
1465
      function Flag81 (N : Node_Id) return Boolean;
1466
      pragma Inline (Flag81);
1467
 
1468
      function Flag82 (N : Node_Id) return Boolean;
1469
      pragma Inline (Flag82);
1470
 
1471
      function Flag83 (N : Node_Id) return Boolean;
1472
      pragma Inline (Flag83);
1473
 
1474
      function Flag84 (N : Node_Id) return Boolean;
1475
      pragma Inline (Flag84);
1476
 
1477
      function Flag85 (N : Node_Id) return Boolean;
1478
      pragma Inline (Flag85);
1479
 
1480
      function Flag86 (N : Node_Id) return Boolean;
1481
      pragma Inline (Flag86);
1482
 
1483
      function Flag87 (N : Node_Id) return Boolean;
1484
      pragma Inline (Flag87);
1485
 
1486
      function Flag88 (N : Node_Id) return Boolean;
1487
      pragma Inline (Flag88);
1488
 
1489
      function Flag89 (N : Node_Id) return Boolean;
1490
      pragma Inline (Flag89);
1491
 
1492
      function Flag90 (N : Node_Id) return Boolean;
1493
      pragma Inline (Flag90);
1494
 
1495
      function Flag91 (N : Node_Id) return Boolean;
1496
      pragma Inline (Flag91);
1497
 
1498
      function Flag92 (N : Node_Id) return Boolean;
1499
      pragma Inline (Flag92);
1500
 
1501
      function Flag93 (N : Node_Id) return Boolean;
1502
      pragma Inline (Flag93);
1503
 
1504
      function Flag94 (N : Node_Id) return Boolean;
1505
      pragma Inline (Flag94);
1506
 
1507
      function Flag95 (N : Node_Id) return Boolean;
1508
      pragma Inline (Flag95);
1509
 
1510
      function Flag96 (N : Node_Id) return Boolean;
1511
      pragma Inline (Flag96);
1512
 
1513
      function Flag97 (N : Node_Id) return Boolean;
1514
      pragma Inline (Flag97);
1515
 
1516
      function Flag98 (N : Node_Id) return Boolean;
1517
      pragma Inline (Flag98);
1518
 
1519
      function Flag99 (N : Node_Id) return Boolean;
1520
      pragma Inline (Flag99);
1521
 
1522
      function Flag100 (N : Node_Id) return Boolean;
1523
      pragma Inline (Flag100);
1524
 
1525
      function Flag101 (N : Node_Id) return Boolean;
1526
      pragma Inline (Flag101);
1527
 
1528
      function Flag102 (N : Node_Id) return Boolean;
1529
      pragma Inline (Flag102);
1530
 
1531
      function Flag103 (N : Node_Id) return Boolean;
1532
      pragma Inline (Flag103);
1533
 
1534
      function Flag104 (N : Node_Id) return Boolean;
1535
      pragma Inline (Flag104);
1536
 
1537
      function Flag105 (N : Node_Id) return Boolean;
1538
      pragma Inline (Flag105);
1539
 
1540
      function Flag106 (N : Node_Id) return Boolean;
1541
      pragma Inline (Flag106);
1542
 
1543
      function Flag107 (N : Node_Id) return Boolean;
1544
      pragma Inline (Flag107);
1545
 
1546
      function Flag108 (N : Node_Id) return Boolean;
1547
      pragma Inline (Flag108);
1548
 
1549
      function Flag109 (N : Node_Id) return Boolean;
1550
      pragma Inline (Flag109);
1551
 
1552
      function Flag110 (N : Node_Id) return Boolean;
1553
      pragma Inline (Flag110);
1554
 
1555
      function Flag111 (N : Node_Id) return Boolean;
1556
      pragma Inline (Flag111);
1557
 
1558
      function Flag112 (N : Node_Id) return Boolean;
1559
      pragma Inline (Flag112);
1560
 
1561
      function Flag113 (N : Node_Id) return Boolean;
1562
      pragma Inline (Flag113);
1563
 
1564
      function Flag114 (N : Node_Id) return Boolean;
1565
      pragma Inline (Flag114);
1566
 
1567
      function Flag115 (N : Node_Id) return Boolean;
1568
      pragma Inline (Flag115);
1569
 
1570
      function Flag116 (N : Node_Id) return Boolean;
1571
      pragma Inline (Flag116);
1572
 
1573
      function Flag117 (N : Node_Id) return Boolean;
1574
      pragma Inline (Flag117);
1575
 
1576
      function Flag118 (N : Node_Id) return Boolean;
1577
      pragma Inline (Flag118);
1578
 
1579
      function Flag119 (N : Node_Id) return Boolean;
1580
      pragma Inline (Flag119);
1581
 
1582
      function Flag120 (N : Node_Id) return Boolean;
1583
      pragma Inline (Flag120);
1584
 
1585
      function Flag121 (N : Node_Id) return Boolean;
1586
      pragma Inline (Flag121);
1587
 
1588
      function Flag122 (N : Node_Id) return Boolean;
1589
      pragma Inline (Flag122);
1590
 
1591
      function Flag123 (N : Node_Id) return Boolean;
1592
      pragma Inline (Flag123);
1593
 
1594
      function Flag124 (N : Node_Id) return Boolean;
1595
      pragma Inline (Flag124);
1596
 
1597
      function Flag125 (N : Node_Id) return Boolean;
1598
      pragma Inline (Flag125);
1599
 
1600
      function Flag126 (N : Node_Id) return Boolean;
1601
      pragma Inline (Flag126);
1602
 
1603
      function Flag127 (N : Node_Id) return Boolean;
1604
      pragma Inline (Flag127);
1605
 
1606
      function Flag128 (N : Node_Id) return Boolean;
1607
      pragma Inline (Flag128);
1608
 
1609
      function Flag129 (N : Node_Id) return Boolean;
1610
      pragma Inline (Flag129);
1611
 
1612
      function Flag130 (N : Node_Id) return Boolean;
1613
      pragma Inline (Flag130);
1614
 
1615
      function Flag131 (N : Node_Id) return Boolean;
1616
      pragma Inline (Flag131);
1617
 
1618
      function Flag132 (N : Node_Id) return Boolean;
1619
      pragma Inline (Flag132);
1620
 
1621
      function Flag133 (N : Node_Id) return Boolean;
1622
      pragma Inline (Flag133);
1623
 
1624
      function Flag134 (N : Node_Id) return Boolean;
1625
      pragma Inline (Flag134);
1626
 
1627
      function Flag135 (N : Node_Id) return Boolean;
1628
      pragma Inline (Flag135);
1629
 
1630
      function Flag136 (N : Node_Id) return Boolean;
1631
      pragma Inline (Flag136);
1632
 
1633
      function Flag137 (N : Node_Id) return Boolean;
1634
      pragma Inline (Flag137);
1635
 
1636
      function Flag138 (N : Node_Id) return Boolean;
1637
      pragma Inline (Flag138);
1638
 
1639
      function Flag139 (N : Node_Id) return Boolean;
1640
      pragma Inline (Flag139);
1641
 
1642
      function Flag140 (N : Node_Id) return Boolean;
1643
      pragma Inline (Flag140);
1644
 
1645
      function Flag141 (N : Node_Id) return Boolean;
1646
      pragma Inline (Flag141);
1647
 
1648
      function Flag142 (N : Node_Id) return Boolean;
1649
      pragma Inline (Flag142);
1650
 
1651
      function Flag143 (N : Node_Id) return Boolean;
1652
      pragma Inline (Flag143);
1653
 
1654
      function Flag144 (N : Node_Id) return Boolean;
1655
      pragma Inline (Flag144);
1656
 
1657
      function Flag145 (N : Node_Id) return Boolean;
1658
      pragma Inline (Flag145);
1659
 
1660
      function Flag146 (N : Node_Id) return Boolean;
1661
      pragma Inline (Flag146);
1662
 
1663
      function Flag147 (N : Node_Id) return Boolean;
1664
      pragma Inline (Flag147);
1665
 
1666
      function Flag148 (N : Node_Id) return Boolean;
1667
      pragma Inline (Flag148);
1668
 
1669
      function Flag149 (N : Node_Id) return Boolean;
1670
      pragma Inline (Flag149);
1671
 
1672
      function Flag150 (N : Node_Id) return Boolean;
1673
      pragma Inline (Flag150);
1674
 
1675
      function Flag151 (N : Node_Id) return Boolean;
1676
      pragma Inline (Flag151);
1677
 
1678
      function Flag152 (N : Node_Id) return Boolean;
1679
      pragma Inline (Flag152);
1680
 
1681
      function Flag153 (N : Node_Id) return Boolean;
1682
      pragma Inline (Flag153);
1683
 
1684
      function Flag154 (N : Node_Id) return Boolean;
1685
      pragma Inline (Flag154);
1686
 
1687
      function Flag155 (N : Node_Id) return Boolean;
1688
      pragma Inline (Flag155);
1689
 
1690
      function Flag156 (N : Node_Id) return Boolean;
1691
      pragma Inline (Flag156);
1692
 
1693
      function Flag157 (N : Node_Id) return Boolean;
1694
      pragma Inline (Flag157);
1695
 
1696
      function Flag158 (N : Node_Id) return Boolean;
1697
      pragma Inline (Flag158);
1698
 
1699
      function Flag159 (N : Node_Id) return Boolean;
1700
      pragma Inline (Flag159);
1701
 
1702
      function Flag160 (N : Node_Id) return Boolean;
1703
      pragma Inline (Flag160);
1704
 
1705
      function Flag161 (N : Node_Id) return Boolean;
1706
      pragma Inline (Flag161);
1707
 
1708
      function Flag162 (N : Node_Id) return Boolean;
1709
      pragma Inline (Flag162);
1710
 
1711
      function Flag163 (N : Node_Id) return Boolean;
1712
      pragma Inline (Flag163);
1713
 
1714
      function Flag164 (N : Node_Id) return Boolean;
1715
      pragma Inline (Flag164);
1716
 
1717
      function Flag165 (N : Node_Id) return Boolean;
1718
      pragma Inline (Flag165);
1719
 
1720
      function Flag166 (N : Node_Id) return Boolean;
1721
      pragma Inline (Flag166);
1722
 
1723
      function Flag167 (N : Node_Id) return Boolean;
1724
      pragma Inline (Flag167);
1725
 
1726
      function Flag168 (N : Node_Id) return Boolean;
1727
      pragma Inline (Flag168);
1728
 
1729
      function Flag169 (N : Node_Id) return Boolean;
1730
      pragma Inline (Flag169);
1731
 
1732
      function Flag170 (N : Node_Id) return Boolean;
1733
      pragma Inline (Flag170);
1734
 
1735
      function Flag171 (N : Node_Id) return Boolean;
1736
      pragma Inline (Flag171);
1737
 
1738
      function Flag172 (N : Node_Id) return Boolean;
1739
      pragma Inline (Flag172);
1740
 
1741
      function Flag173 (N : Node_Id) return Boolean;
1742
      pragma Inline (Flag173);
1743
 
1744
      function Flag174 (N : Node_Id) return Boolean;
1745
      pragma Inline (Flag174);
1746
 
1747
      function Flag175 (N : Node_Id) return Boolean;
1748
      pragma Inline (Flag175);
1749
 
1750
      function Flag176 (N : Node_Id) return Boolean;
1751
      pragma Inline (Flag176);
1752
 
1753
      function Flag177 (N : Node_Id) return Boolean;
1754
      pragma Inline (Flag177);
1755
 
1756
      function Flag178 (N : Node_Id) return Boolean;
1757
      pragma Inline (Flag178);
1758
 
1759
      function Flag179 (N : Node_Id) return Boolean;
1760
      pragma Inline (Flag179);
1761
 
1762
      function Flag180 (N : Node_Id) return Boolean;
1763
      pragma Inline (Flag180);
1764
 
1765
      function Flag181 (N : Node_Id) return Boolean;
1766
      pragma Inline (Flag181);
1767
 
1768
      function Flag182 (N : Node_Id) return Boolean;
1769
      pragma Inline (Flag182);
1770
 
1771
      function Flag183 (N : Node_Id) return Boolean;
1772
      pragma Inline (Flag183);
1773
 
1774
      function Flag184 (N : Node_Id) return Boolean;
1775
      pragma Inline (Flag184);
1776
 
1777
      function Flag185 (N : Node_Id) return Boolean;
1778
      pragma Inline (Flag185);
1779
 
1780
      function Flag186 (N : Node_Id) return Boolean;
1781
      pragma Inline (Flag186);
1782
 
1783
      function Flag187 (N : Node_Id) return Boolean;
1784
      pragma Inline (Flag187);
1785
 
1786
      function Flag188 (N : Node_Id) return Boolean;
1787
      pragma Inline (Flag188);
1788
 
1789
      function Flag189 (N : Node_Id) return Boolean;
1790
      pragma Inline (Flag189);
1791
 
1792
      function Flag190 (N : Node_Id) return Boolean;
1793
      pragma Inline (Flag190);
1794
 
1795
      function Flag191 (N : Node_Id) return Boolean;
1796
      pragma Inline (Flag191);
1797
 
1798
      function Flag192 (N : Node_Id) return Boolean;
1799
      pragma Inline (Flag192);
1800
 
1801
      function Flag193 (N : Node_Id) return Boolean;
1802
      pragma Inline (Flag193);
1803
 
1804
      function Flag194 (N : Node_Id) return Boolean;
1805
      pragma Inline (Flag194);
1806
 
1807
      function Flag195 (N : Node_Id) return Boolean;
1808
      pragma Inline (Flag195);
1809
 
1810
      function Flag196 (N : Node_Id) return Boolean;
1811
      pragma Inline (Flag196);
1812
 
1813
      function Flag197 (N : Node_Id) return Boolean;
1814
      pragma Inline (Flag197);
1815
 
1816
      function Flag198 (N : Node_Id) return Boolean;
1817
      pragma Inline (Flag198);
1818
 
1819
      function Flag199 (N : Node_Id) return Boolean;
1820
      pragma Inline (Flag199);
1821
 
1822
      function Flag200 (N : Node_Id) return Boolean;
1823
      pragma Inline (Flag200);
1824
 
1825
      function Flag201 (N : Node_Id) return Boolean;
1826
      pragma Inline (Flag201);
1827
 
1828
      function Flag202 (N : Node_Id) return Boolean;
1829
      pragma Inline (Flag202);
1830
 
1831
      function Flag203 (N : Node_Id) return Boolean;
1832
      pragma Inline (Flag203);
1833
 
1834
      function Flag204 (N : Node_Id) return Boolean;
1835
      pragma Inline (Flag204);
1836
 
1837
      function Flag205 (N : Node_Id) return Boolean;
1838
      pragma Inline (Flag205);
1839
 
1840
      function Flag206 (N : Node_Id) return Boolean;
1841
      pragma Inline (Flag206);
1842
 
1843
      function Flag207 (N : Node_Id) return Boolean;
1844
      pragma Inline (Flag207);
1845
 
1846
      function Flag208 (N : Node_Id) return Boolean;
1847
      pragma Inline (Flag208);
1848
 
1849
      function Flag209 (N : Node_Id) return Boolean;
1850
      pragma Inline (Flag209);
1851
 
1852
      function Flag210 (N : Node_Id) return Boolean;
1853
      pragma Inline (Flag210);
1854
 
1855
      function Flag211 (N : Node_Id) return Boolean;
1856
      pragma Inline (Flag211);
1857
 
1858
      function Flag212 (N : Node_Id) return Boolean;
1859
      pragma Inline (Flag212);
1860
 
1861
      function Flag213 (N : Node_Id) return Boolean;
1862
      pragma Inline (Flag213);
1863
 
1864
      function Flag214 (N : Node_Id) return Boolean;
1865
      pragma Inline (Flag214);
1866
 
1867
      function Flag215 (N : Node_Id) return Boolean;
1868
      pragma Inline (Flag215);
1869
 
1870
      function Flag216 (N : Node_Id) return Boolean;
1871
      pragma Inline (Flag216);
1872
 
1873
      function Flag217 (N : Node_Id) return Boolean;
1874
      pragma Inline (Flag217);
1875
 
1876
      function Flag218 (N : Node_Id) return Boolean;
1877
      pragma Inline (Flag218);
1878
 
1879
      function Flag219 (N : Node_Id) return Boolean;
1880
      pragma Inline (Flag219);
1881
 
1882
      function Flag220 (N : Node_Id) return Boolean;
1883
      pragma Inline (Flag220);
1884
 
1885
      function Flag221 (N : Node_Id) return Boolean;
1886
      pragma Inline (Flag221);
1887
 
1888
      function Flag222 (N : Node_Id) return Boolean;
1889
      pragma Inline (Flag222);
1890
 
1891
      function Flag223 (N : Node_Id) return Boolean;
1892
      pragma Inline (Flag223);
1893
 
1894
      function Flag224 (N : Node_Id) return Boolean;
1895
      pragma Inline (Flag224);
1896
 
1897
      function Flag225 (N : Node_Id) return Boolean;
1898
      pragma Inline (Flag225);
1899
 
1900
      function Flag226 (N : Node_Id) return Boolean;
1901
      pragma Inline (Flag226);
1902
 
1903
      function Flag227 (N : Node_Id) return Boolean;
1904
      pragma Inline (Flag227);
1905
 
1906
      function Flag228 (N : Node_Id) return Boolean;
1907
      pragma Inline (Flag228);
1908
 
1909
      function Flag229 (N : Node_Id) return Boolean;
1910
      pragma Inline (Flag229);
1911
 
1912
      function Flag230 (N : Node_Id) return Boolean;
1913
      pragma Inline (Flag230);
1914
 
1915
      function Flag231 (N : Node_Id) return Boolean;
1916
      pragma Inline (Flag231);
1917
 
1918
      function Flag232 (N : Node_Id) return Boolean;
1919
      pragma Inline (Flag232);
1920
 
1921
      function Flag233 (N : Node_Id) return Boolean;
1922
      pragma Inline (Flag233);
1923
 
1924
      function Flag234 (N : Node_Id) return Boolean;
1925
      pragma Inline (Flag234);
1926
 
1927
      function Flag235 (N : Node_Id) return Boolean;
1928
      pragma Inline (Flag235);
1929
 
1930
      function Flag236 (N : Node_Id) return Boolean;
1931
      pragma Inline (Flag236);
1932
 
1933
      function Flag237 (N : Node_Id) return Boolean;
1934
      pragma Inline (Flag237);
1935
 
1936
      function Flag238 (N : Node_Id) return Boolean;
1937
      pragma Inline (Flag238);
1938
 
1939
      function Flag239 (N : Node_Id) return Boolean;
1940
      pragma Inline (Flag239);
1941
 
1942
      function Flag240 (N : Node_Id) return Boolean;
1943
      pragma Inline (Flag240);
1944
 
1945
      function Flag241 (N : Node_Id) return Boolean;
1946
      pragma Inline (Flag241);
1947
 
1948
      function Flag242 (N : Node_Id) return Boolean;
1949
      pragma Inline (Flag242);
1950
 
1951
      function Flag243 (N : Node_Id) return Boolean;
1952
      pragma Inline (Flag243);
1953
 
1954
      function Flag244 (N : Node_Id) return Boolean;
1955
      pragma Inline (Flag244);
1956
 
1957
      function Flag245 (N : Node_Id) return Boolean;
1958
      pragma Inline (Flag245);
1959
 
1960
      function Flag246 (N : Node_Id) return Boolean;
1961
      pragma Inline (Flag246);
1962
 
1963
      function Flag247 (N : Node_Id) return Boolean;
1964
      pragma Inline (Flag247);
1965
 
1966
      function Flag248 (N : Node_Id) return Boolean;
1967
      pragma Inline (Flag248);
1968
 
1969
      function Flag249 (N : Node_Id) return Boolean;
1970
      pragma Inline (Flag249);
1971
 
1972
      function Flag250 (N : Node_Id) return Boolean;
1973
      pragma Inline (Flag250);
1974
 
1975
      function Flag251 (N : Node_Id) return Boolean;
1976
      pragma Inline (Flag251);
1977
 
1978
      function Flag252 (N : Node_Id) return Boolean;
1979
      pragma Inline (Flag252);
1980
 
1981
      function Flag253 (N : Node_Id) return Boolean;
1982
      pragma Inline (Flag253);
1983
 
1984
      function Flag254 (N : Node_Id) return Boolean;
1985
      pragma Inline (Flag254);
1986
 
1987
      --  Procedures to set value of indicated field
1988
 
1989
      procedure Set_Nkind (N : Node_Id; Val : Node_Kind);
1990
      pragma Inline (Set_Nkind);
1991
 
1992
      procedure Set_Field1 (N : Node_Id; Val : Union_Id);
1993
      pragma Inline (Set_Field1);
1994
 
1995
      procedure Set_Field2 (N : Node_Id; Val : Union_Id);
1996
      pragma Inline (Set_Field2);
1997
 
1998
      procedure Set_Field3 (N : Node_Id; Val : Union_Id);
1999
      pragma Inline (Set_Field3);
2000
 
2001
      procedure Set_Field4 (N : Node_Id; Val : Union_Id);
2002
      pragma Inline (Set_Field4);
2003
 
2004
      procedure Set_Field5 (N : Node_Id; Val : Union_Id);
2005
      pragma Inline (Set_Field5);
2006
 
2007
      procedure Set_Field6 (N : Node_Id; Val : Union_Id);
2008
      pragma Inline (Set_Field6);
2009
 
2010
      procedure Set_Field7 (N : Node_Id; Val : Union_Id);
2011
      pragma Inline (Set_Field7);
2012
 
2013
      procedure Set_Field8 (N : Node_Id; Val : Union_Id);
2014
      pragma Inline (Set_Field8);
2015
 
2016
      procedure Set_Field9 (N : Node_Id; Val : Union_Id);
2017
      pragma Inline (Set_Field9);
2018
 
2019
      procedure Set_Field10 (N : Node_Id; Val : Union_Id);
2020
      pragma Inline (Set_Field10);
2021
 
2022
      procedure Set_Field11 (N : Node_Id; Val : Union_Id);
2023
      pragma Inline (Set_Field11);
2024
 
2025
      procedure Set_Field12 (N : Node_Id; Val : Union_Id);
2026
      pragma Inline (Set_Field12);
2027
 
2028
      procedure Set_Field13 (N : Node_Id; Val : Union_Id);
2029
      pragma Inline (Set_Field13);
2030
 
2031
      procedure Set_Field14 (N : Node_Id; Val : Union_Id);
2032
      pragma Inline (Set_Field14);
2033
 
2034
      procedure Set_Field15 (N : Node_Id; Val : Union_Id);
2035
      pragma Inline (Set_Field15);
2036
 
2037
      procedure Set_Field16 (N : Node_Id; Val : Union_Id);
2038
      pragma Inline (Set_Field16);
2039
 
2040
      procedure Set_Field17 (N : Node_Id; Val : Union_Id);
2041
      pragma Inline (Set_Field17);
2042
 
2043
      procedure Set_Field18 (N : Node_Id; Val : Union_Id);
2044
      pragma Inline (Set_Field18);
2045
 
2046
      procedure Set_Field19 (N : Node_Id; Val : Union_Id);
2047
      pragma Inline (Set_Field19);
2048
 
2049
      procedure Set_Field20 (N : Node_Id; Val : Union_Id);
2050
      pragma Inline (Set_Field20);
2051
 
2052
      procedure Set_Field21 (N : Node_Id; Val : Union_Id);
2053
      pragma Inline (Set_Field21);
2054
 
2055
      procedure Set_Field22 (N : Node_Id; Val : Union_Id);
2056
      pragma Inline (Set_Field22);
2057
 
2058
      procedure Set_Field23 (N : Node_Id; Val : Union_Id);
2059
      pragma Inline (Set_Field23);
2060
 
2061
      procedure Set_Field24 (N : Node_Id; Val : Union_Id);
2062
      pragma Inline (Set_Field24);
2063
 
2064
      procedure Set_Field25 (N : Node_Id; Val : Union_Id);
2065
      pragma Inline (Set_Field25);
2066
 
2067
      procedure Set_Field26 (N : Node_Id; Val : Union_Id);
2068
      pragma Inline (Set_Field26);
2069
 
2070
      procedure Set_Field27 (N : Node_Id; Val : Union_Id);
2071
      pragma Inline (Set_Field27);
2072
 
2073
      procedure Set_Field28 (N : Node_Id; Val : Union_Id);
2074
      pragma Inline (Set_Field28);
2075
 
2076
      procedure Set_Field29 (N : Node_Id; Val : Union_Id);
2077
      pragma Inline (Set_Field29);
2078
 
2079
      procedure Set_Node1 (N : Node_Id; Val : Node_Id);
2080
      pragma Inline (Set_Node1);
2081
 
2082
      procedure Set_Node2 (N : Node_Id; Val : Node_Id);
2083
      pragma Inline (Set_Node2);
2084
 
2085
      procedure Set_Node3 (N : Node_Id; Val : Node_Id);
2086
      pragma Inline (Set_Node3);
2087
 
2088
      procedure Set_Node4 (N : Node_Id; Val : Node_Id);
2089
      pragma Inline (Set_Node4);
2090
 
2091
      procedure Set_Node5 (N : Node_Id; Val : Node_Id);
2092
      pragma Inline (Set_Node5);
2093
 
2094
      procedure Set_Node6 (N : Node_Id; Val : Node_Id);
2095
      pragma Inline (Set_Node6);
2096
 
2097
      procedure Set_Node7 (N : Node_Id; Val : Node_Id);
2098
      pragma Inline (Set_Node7);
2099
 
2100
      procedure Set_Node8 (N : Node_Id; Val : Node_Id);
2101
      pragma Inline (Set_Node8);
2102
 
2103
      procedure Set_Node9 (N : Node_Id; Val : Node_Id);
2104
      pragma Inline (Set_Node9);
2105
 
2106
      procedure Set_Node10 (N : Node_Id; Val : Node_Id);
2107
      pragma Inline (Set_Node10);
2108
 
2109
      procedure Set_Node11 (N : Node_Id; Val : Node_Id);
2110
      pragma Inline (Set_Node11);
2111
 
2112
      procedure Set_Node12 (N : Node_Id; Val : Node_Id);
2113
      pragma Inline (Set_Node12);
2114
 
2115
      procedure Set_Node13 (N : Node_Id; Val : Node_Id);
2116
      pragma Inline (Set_Node13);
2117
 
2118
      procedure Set_Node14 (N : Node_Id; Val : Node_Id);
2119
      pragma Inline (Set_Node14);
2120
 
2121
      procedure Set_Node15 (N : Node_Id; Val : Node_Id);
2122
      pragma Inline (Set_Node15);
2123
 
2124
      procedure Set_Node16 (N : Node_Id; Val : Node_Id);
2125
      pragma Inline (Set_Node16);
2126
 
2127
      procedure Set_Node17 (N : Node_Id; Val : Node_Id);
2128
      pragma Inline (Set_Node17);
2129
 
2130
      procedure Set_Node18 (N : Node_Id; Val : Node_Id);
2131
      pragma Inline (Set_Node18);
2132
 
2133
      procedure Set_Node19 (N : Node_Id; Val : Node_Id);
2134
      pragma Inline (Set_Node19);
2135
 
2136
      procedure Set_Node20 (N : Node_Id; Val : Node_Id);
2137
      pragma Inline (Set_Node20);
2138
 
2139
      procedure Set_Node21 (N : Node_Id; Val : Node_Id);
2140
      pragma Inline (Set_Node21);
2141
 
2142
      procedure Set_Node22 (N : Node_Id; Val : Node_Id);
2143
      pragma Inline (Set_Node22);
2144
 
2145
      procedure Set_Node23 (N : Node_Id; Val : Node_Id);
2146
      pragma Inline (Set_Node23);
2147
 
2148
      procedure Set_Node24 (N : Node_Id; Val : Node_Id);
2149
      pragma Inline (Set_Node24);
2150
 
2151
      procedure Set_Node25 (N : Node_Id; Val : Node_Id);
2152
      pragma Inline (Set_Node25);
2153
 
2154
      procedure Set_Node26 (N : Node_Id; Val : Node_Id);
2155
      pragma Inline (Set_Node26);
2156
 
2157
      procedure Set_Node27 (N : Node_Id; Val : Node_Id);
2158
      pragma Inline (Set_Node27);
2159
 
2160
      procedure Set_Node28 (N : Node_Id; Val : Node_Id);
2161
      pragma Inline (Set_Node28);
2162
 
2163
      procedure Set_Node29 (N : Node_Id; Val : Node_Id);
2164
      pragma Inline (Set_Node29);
2165
 
2166
      procedure Set_List1 (N : Node_Id; Val : List_Id);
2167
      pragma Inline (Set_List1);
2168
 
2169
      procedure Set_List2 (N : Node_Id; Val : List_Id);
2170
      pragma Inline (Set_List2);
2171
 
2172
      procedure Set_List3 (N : Node_Id; Val : List_Id);
2173
      pragma Inline (Set_List3);
2174
 
2175
      procedure Set_List4 (N : Node_Id; Val : List_Id);
2176
      pragma Inline (Set_List4);
2177
 
2178
      procedure Set_List5 (N : Node_Id; Val : List_Id);
2179
      pragma Inline (Set_List5);
2180
 
2181
      procedure Set_List10 (N : Node_Id; Val : List_Id);
2182
      pragma Inline (Set_List10);
2183
 
2184
      procedure Set_List14 (N : Node_Id; Val : List_Id);
2185
      pragma Inline (Set_List14);
2186
 
2187
      procedure Set_List25 (N : Node_Id; Val : List_Id);
2188
      pragma Inline (Set_List25);
2189
 
2190
      procedure Set_Elist1 (N : Node_Id; Val : Elist_Id);
2191
      pragma Inline (Set_Elist1);
2192
 
2193
      procedure Set_Elist2 (N : Node_Id; Val : Elist_Id);
2194
      pragma Inline (Set_Elist2);
2195
 
2196
      procedure Set_Elist3 (N : Node_Id; Val : Elist_Id);
2197
      pragma Inline (Set_Elist3);
2198
 
2199
      procedure Set_Elist4 (N : Node_Id; Val : Elist_Id);
2200
      pragma Inline (Set_Elist4);
2201
 
2202
      procedure Set_Elist5 (N : Node_Id; Val : Elist_Id);
2203
      pragma Inline (Set_Elist5);
2204
 
2205
      procedure Set_Elist8 (N : Node_Id; Val : Elist_Id);
2206
      pragma Inline (Set_Elist8);
2207
 
2208
      procedure Set_Elist10 (N : Node_Id; Val : Elist_Id);
2209
      pragma Inline (Set_Elist10);
2210
 
2211
      procedure Set_Elist13 (N : Node_Id; Val : Elist_Id);
2212
      pragma Inline (Set_Elist13);
2213
 
2214
      procedure Set_Elist15 (N : Node_Id; Val : Elist_Id);
2215
      pragma Inline (Set_Elist15);
2216
 
2217
      procedure Set_Elist16 (N : Node_Id; Val : Elist_Id);
2218
      pragma Inline (Set_Elist16);
2219
 
2220
      procedure Set_Elist18 (N : Node_Id; Val : Elist_Id);
2221
      pragma Inline (Set_Elist18);
2222
 
2223
      procedure Set_Elist21 (N : Node_Id; Val : Elist_Id);
2224
      pragma Inline (Set_Elist21);
2225
 
2226
      procedure Set_Elist23 (N : Node_Id; Val : Elist_Id);
2227
      pragma Inline (Set_Elist23);
2228
 
2229
      procedure Set_Elist24 (N : Node_Id; Val : Elist_Id);
2230
      pragma Inline (Set_Elist24);
2231
 
2232
      procedure Set_Elist25 (N : Node_Id; Val : Elist_Id);
2233
      pragma Inline (Set_Elist25);
2234
 
2235
      procedure Set_Elist26 (N : Node_Id; Val : Elist_Id);
2236
      pragma Inline (Set_Elist26);
2237
 
2238
      procedure Set_Name1 (N : Node_Id; Val : Name_Id);
2239
      pragma Inline (Set_Name1);
2240
 
2241
      procedure Set_Name2 (N : Node_Id; Val : Name_Id);
2242
      pragma Inline (Set_Name2);
2243
 
2244
      procedure Set_Str3 (N : Node_Id; Val : String_Id);
2245
      pragma Inline (Set_Str3);
2246
 
2247
      procedure Set_Uint2 (N : Node_Id; Val : Uint);
2248
      pragma Inline (Set_Uint2);
2249
 
2250
      procedure Set_Uint3 (N : Node_Id; Val : Uint);
2251
      pragma Inline (Set_Uint3);
2252
 
2253
      procedure Set_Uint4 (N : Node_Id; Val : Uint);
2254
      pragma Inline (Set_Uint4);
2255
 
2256
      procedure Set_Uint5 (N : Node_Id; Val : Uint);
2257
      pragma Inline (Set_Uint5);
2258
 
2259
      procedure Set_Uint8 (N : Node_Id; Val : Uint);
2260
      pragma Inline (Set_Uint8);
2261
 
2262
      procedure Set_Uint9 (N : Node_Id; Val : Uint);
2263
      pragma Inline (Set_Uint9);
2264
 
2265
      procedure Set_Uint10 (N : Node_Id; Val : Uint);
2266
      pragma Inline (Set_Uint10);
2267
 
2268
      procedure Set_Uint11 (N : Node_Id; Val : Uint);
2269
      pragma Inline (Set_Uint11);
2270
 
2271
      procedure Set_Uint12 (N : Node_Id; Val : Uint);
2272
      pragma Inline (Set_Uint12);
2273
 
2274
      procedure Set_Uint13 (N : Node_Id; Val : Uint);
2275
      pragma Inline (Set_Uint13);
2276
 
2277
      procedure Set_Uint14 (N : Node_Id; Val : Uint);
2278
      pragma Inline (Set_Uint14);
2279
 
2280
      procedure Set_Uint15 (N : Node_Id; Val : Uint);
2281
      pragma Inline (Set_Uint15);
2282
 
2283
      procedure Set_Uint16 (N : Node_Id; Val : Uint);
2284
      pragma Inline (Set_Uint16);
2285
 
2286
      procedure Set_Uint17 (N : Node_Id; Val : Uint);
2287
      pragma Inline (Set_Uint17);
2288
 
2289
      procedure Set_Uint22 (N : Node_Id; Val : Uint);
2290
      pragma Inline (Set_Uint22);
2291
 
2292
      procedure Set_Ureal3 (N : Node_Id; Val : Ureal);
2293
      pragma Inline (Set_Ureal3);
2294
 
2295
      procedure Set_Ureal18 (N : Node_Id; Val : Ureal);
2296
      pragma Inline (Set_Ureal18);
2297
 
2298
      procedure Set_Ureal21 (N : Node_Id; Val : Ureal);
2299
      pragma Inline (Set_Ureal21);
2300
 
2301
      procedure Set_Flag4 (N : Node_Id; Val : Boolean);
2302
      pragma Inline (Set_Flag4);
2303
 
2304
      procedure Set_Flag5 (N : Node_Id; Val : Boolean);
2305
      pragma Inline (Set_Flag5);
2306
 
2307
      procedure Set_Flag6 (N : Node_Id; Val : Boolean);
2308
      pragma Inline (Set_Flag6);
2309
 
2310
      procedure Set_Flag7 (N : Node_Id; Val : Boolean);
2311
      pragma Inline (Set_Flag7);
2312
 
2313
      procedure Set_Flag8 (N : Node_Id; Val : Boolean);
2314
      pragma Inline (Set_Flag8);
2315
 
2316
      procedure Set_Flag9 (N : Node_Id; Val : Boolean);
2317
      pragma Inline (Set_Flag9);
2318
 
2319
      procedure Set_Flag10 (N : Node_Id; Val : Boolean);
2320
      pragma Inline (Set_Flag10);
2321
 
2322
      procedure Set_Flag11 (N : Node_Id; Val : Boolean);
2323
      pragma Inline (Set_Flag11);
2324
 
2325
      procedure Set_Flag12 (N : Node_Id; Val : Boolean);
2326
      pragma Inline (Set_Flag12);
2327
 
2328
      procedure Set_Flag13 (N : Node_Id; Val : Boolean);
2329
      pragma Inline (Set_Flag13);
2330
 
2331
      procedure Set_Flag14 (N : Node_Id; Val : Boolean);
2332
      pragma Inline (Set_Flag14);
2333
 
2334
      procedure Set_Flag15 (N : Node_Id; Val : Boolean);
2335
      pragma Inline (Set_Flag15);
2336
 
2337
      procedure Set_Flag16 (N : Node_Id; Val : Boolean);
2338
      pragma Inline (Set_Flag16);
2339
 
2340
      procedure Set_Flag17 (N : Node_Id; Val : Boolean);
2341
      pragma Inline (Set_Flag17);
2342
 
2343
      procedure Set_Flag18 (N : Node_Id; Val : Boolean);
2344
      pragma Inline (Set_Flag18);
2345
 
2346
      procedure Set_Flag19 (N : Node_Id; Val : Boolean);
2347
      pragma Inline (Set_Flag19);
2348
 
2349
      procedure Set_Flag20 (N : Node_Id; Val : Boolean);
2350
      pragma Inline (Set_Flag20);
2351
 
2352
      procedure Set_Flag21 (N : Node_Id; Val : Boolean);
2353
      pragma Inline (Set_Flag21);
2354
 
2355
      procedure Set_Flag22 (N : Node_Id; Val : Boolean);
2356
      pragma Inline (Set_Flag22);
2357
 
2358
      procedure Set_Flag23 (N : Node_Id; Val : Boolean);
2359
      pragma Inline (Set_Flag23);
2360
 
2361
      procedure Set_Flag24 (N : Node_Id; Val : Boolean);
2362
      pragma Inline (Set_Flag24);
2363
 
2364
      procedure Set_Flag25 (N : Node_Id; Val : Boolean);
2365
      pragma Inline (Set_Flag25);
2366
 
2367
      procedure Set_Flag26 (N : Node_Id; Val : Boolean);
2368
      pragma Inline (Set_Flag26);
2369
 
2370
      procedure Set_Flag27 (N : Node_Id; Val : Boolean);
2371
      pragma Inline (Set_Flag27);
2372
 
2373
      procedure Set_Flag28 (N : Node_Id; Val : Boolean);
2374
      pragma Inline (Set_Flag28);
2375
 
2376
      procedure Set_Flag29 (N : Node_Id; Val : Boolean);
2377
      pragma Inline (Set_Flag29);
2378
 
2379
      procedure Set_Flag30 (N : Node_Id; Val : Boolean);
2380
      pragma Inline (Set_Flag30);
2381
 
2382
      procedure Set_Flag31 (N : Node_Id; Val : Boolean);
2383
      pragma Inline (Set_Flag31);
2384
 
2385
      procedure Set_Flag32 (N : Node_Id; Val : Boolean);
2386
      pragma Inline (Set_Flag32);
2387
 
2388
      procedure Set_Flag33 (N : Node_Id; Val : Boolean);
2389
      pragma Inline (Set_Flag33);
2390
 
2391
      procedure Set_Flag34 (N : Node_Id; Val : Boolean);
2392
      pragma Inline (Set_Flag34);
2393
 
2394
      procedure Set_Flag35 (N : Node_Id; Val : Boolean);
2395
      pragma Inline (Set_Flag35);
2396
 
2397
      procedure Set_Flag36 (N : Node_Id; Val : Boolean);
2398
      pragma Inline (Set_Flag36);
2399
 
2400
      procedure Set_Flag37 (N : Node_Id; Val : Boolean);
2401
      pragma Inline (Set_Flag37);
2402
 
2403
      procedure Set_Flag38 (N : Node_Id; Val : Boolean);
2404
      pragma Inline (Set_Flag38);
2405
 
2406
      procedure Set_Flag39 (N : Node_Id; Val : Boolean);
2407
      pragma Inline (Set_Flag39);
2408
 
2409
      procedure Set_Flag40 (N : Node_Id; Val : Boolean);
2410
      pragma Inline (Set_Flag40);
2411
 
2412
      procedure Set_Flag41 (N : Node_Id; Val : Boolean);
2413
      pragma Inline (Set_Flag41);
2414
 
2415
      procedure Set_Flag42 (N : Node_Id; Val : Boolean);
2416
      pragma Inline (Set_Flag42);
2417
 
2418
      procedure Set_Flag43 (N : Node_Id; Val : Boolean);
2419
      pragma Inline (Set_Flag43);
2420
 
2421
      procedure Set_Flag44 (N : Node_Id; Val : Boolean);
2422
      pragma Inline (Set_Flag44);
2423
 
2424
      procedure Set_Flag45 (N : Node_Id; Val : Boolean);
2425
      pragma Inline (Set_Flag45);
2426
 
2427
      procedure Set_Flag46 (N : Node_Id; Val : Boolean);
2428
      pragma Inline (Set_Flag46);
2429
 
2430
      procedure Set_Flag47 (N : Node_Id; Val : Boolean);
2431
      pragma Inline (Set_Flag47);
2432
 
2433
      procedure Set_Flag48 (N : Node_Id; Val : Boolean);
2434
      pragma Inline (Set_Flag48);
2435
 
2436
      procedure Set_Flag49 (N : Node_Id; Val : Boolean);
2437
      pragma Inline (Set_Flag49);
2438
 
2439
      procedure Set_Flag50 (N : Node_Id; Val : Boolean);
2440
      pragma Inline (Set_Flag50);
2441
 
2442
      procedure Set_Flag51 (N : Node_Id; Val : Boolean);
2443
      pragma Inline (Set_Flag51);
2444
 
2445
      procedure Set_Flag52 (N : Node_Id; Val : Boolean);
2446
      pragma Inline (Set_Flag52);
2447
 
2448
      procedure Set_Flag53 (N : Node_Id; Val : Boolean);
2449
      pragma Inline (Set_Flag53);
2450
 
2451
      procedure Set_Flag54 (N : Node_Id; Val : Boolean);
2452
      pragma Inline (Set_Flag54);
2453
 
2454
      procedure Set_Flag55 (N : Node_Id; Val : Boolean);
2455
      pragma Inline (Set_Flag55);
2456
 
2457
      procedure Set_Flag56 (N : Node_Id; Val : Boolean);
2458
      pragma Inline (Set_Flag56);
2459
 
2460
      procedure Set_Flag57 (N : Node_Id; Val : Boolean);
2461
      pragma Inline (Set_Flag57);
2462
 
2463
      procedure Set_Flag58 (N : Node_Id; Val : Boolean);
2464
      pragma Inline (Set_Flag58);
2465
 
2466
      procedure Set_Flag59 (N : Node_Id; Val : Boolean);
2467
      pragma Inline (Set_Flag59);
2468
 
2469
      procedure Set_Flag60 (N : Node_Id; Val : Boolean);
2470
      pragma Inline (Set_Flag60);
2471
 
2472
      procedure Set_Flag61 (N : Node_Id; Val : Boolean);
2473
      pragma Inline (Set_Flag61);
2474
 
2475
      procedure Set_Flag62 (N : Node_Id; Val : Boolean);
2476
      pragma Inline (Set_Flag62);
2477
 
2478
      procedure Set_Flag63 (N : Node_Id; Val : Boolean);
2479
      pragma Inline (Set_Flag63);
2480
 
2481
      procedure Set_Flag64 (N : Node_Id; Val : Boolean);
2482
      pragma Inline (Set_Flag64);
2483
 
2484
      procedure Set_Flag65 (N : Node_Id; Val : Boolean);
2485
      pragma Inline (Set_Flag65);
2486
 
2487
      procedure Set_Flag66 (N : Node_Id; Val : Boolean);
2488
      pragma Inline (Set_Flag66);
2489
 
2490
      procedure Set_Flag67 (N : Node_Id; Val : Boolean);
2491
      pragma Inline (Set_Flag67);
2492
 
2493
      procedure Set_Flag68 (N : Node_Id; Val : Boolean);
2494
      pragma Inline (Set_Flag68);
2495
 
2496
      procedure Set_Flag69 (N : Node_Id; Val : Boolean);
2497
      pragma Inline (Set_Flag69);
2498
 
2499
      procedure Set_Flag70 (N : Node_Id; Val : Boolean);
2500
      pragma Inline (Set_Flag70);
2501
 
2502
      procedure Set_Flag71 (N : Node_Id; Val : Boolean);
2503
      pragma Inline (Set_Flag71);
2504
 
2505
      procedure Set_Flag72 (N : Node_Id; Val : Boolean);
2506
      pragma Inline (Set_Flag72);
2507
 
2508
      procedure Set_Flag73 (N : Node_Id; Val : Boolean);
2509
      pragma Inline (Set_Flag73);
2510
 
2511
      procedure Set_Flag74 (N : Node_Id; Val : Boolean);
2512
      pragma Inline (Set_Flag74);
2513
 
2514
      procedure Set_Flag75 (N : Node_Id; Val : Boolean);
2515
      pragma Inline (Set_Flag75);
2516
 
2517
      procedure Set_Flag76 (N : Node_Id; Val : Boolean);
2518
      pragma Inline (Set_Flag76);
2519
 
2520
      procedure Set_Flag77 (N : Node_Id; Val : Boolean);
2521
      pragma Inline (Set_Flag77);
2522
 
2523
      procedure Set_Flag78 (N : Node_Id; Val : Boolean);
2524
      pragma Inline (Set_Flag78);
2525
 
2526
      procedure Set_Flag79 (N : Node_Id; Val : Boolean);
2527
      pragma Inline (Set_Flag79);
2528
 
2529
      procedure Set_Flag80 (N : Node_Id; Val : Boolean);
2530
      pragma Inline (Set_Flag80);
2531
 
2532
      procedure Set_Flag81 (N : Node_Id; Val : Boolean);
2533
      pragma Inline (Set_Flag81);
2534
 
2535
      procedure Set_Flag82 (N : Node_Id; Val : Boolean);
2536
      pragma Inline (Set_Flag82);
2537
 
2538
      procedure Set_Flag83 (N : Node_Id; Val : Boolean);
2539
      pragma Inline (Set_Flag83);
2540
 
2541
      procedure Set_Flag84 (N : Node_Id; Val : Boolean);
2542
      pragma Inline (Set_Flag84);
2543
 
2544
      procedure Set_Flag85 (N : Node_Id; Val : Boolean);
2545
      pragma Inline (Set_Flag85);
2546
 
2547
      procedure Set_Flag86 (N : Node_Id; Val : Boolean);
2548
      pragma Inline (Set_Flag86);
2549
 
2550
      procedure Set_Flag87 (N : Node_Id; Val : Boolean);
2551
      pragma Inline (Set_Flag87);
2552
 
2553
      procedure Set_Flag88 (N : Node_Id; Val : Boolean);
2554
      pragma Inline (Set_Flag88);
2555
 
2556
      procedure Set_Flag89 (N : Node_Id; Val : Boolean);
2557
      pragma Inline (Set_Flag89);
2558
 
2559
      procedure Set_Flag90 (N : Node_Id; Val : Boolean);
2560
      pragma Inline (Set_Flag90);
2561
 
2562
      procedure Set_Flag91 (N : Node_Id; Val : Boolean);
2563
      pragma Inline (Set_Flag91);
2564
 
2565
      procedure Set_Flag92 (N : Node_Id; Val : Boolean);
2566
      pragma Inline (Set_Flag92);
2567
 
2568
      procedure Set_Flag93 (N : Node_Id; Val : Boolean);
2569
      pragma Inline (Set_Flag93);
2570
 
2571
      procedure Set_Flag94 (N : Node_Id; Val : Boolean);
2572
      pragma Inline (Set_Flag94);
2573
 
2574
      procedure Set_Flag95 (N : Node_Id; Val : Boolean);
2575
      pragma Inline (Set_Flag95);
2576
 
2577
      procedure Set_Flag96 (N : Node_Id; Val : Boolean);
2578
      pragma Inline (Set_Flag96);
2579
 
2580
      procedure Set_Flag97 (N : Node_Id; Val : Boolean);
2581
      pragma Inline (Set_Flag97);
2582
 
2583
      procedure Set_Flag98 (N : Node_Id; Val : Boolean);
2584
      pragma Inline (Set_Flag98);
2585
 
2586
      procedure Set_Flag99 (N : Node_Id; Val : Boolean);
2587
      pragma Inline (Set_Flag99);
2588
 
2589
      procedure Set_Flag100 (N : Node_Id; Val : Boolean);
2590
      pragma Inline (Set_Flag100);
2591
 
2592
      procedure Set_Flag101 (N : Node_Id; Val : Boolean);
2593
      pragma Inline (Set_Flag101);
2594
 
2595
      procedure Set_Flag102 (N : Node_Id; Val : Boolean);
2596
      pragma Inline (Set_Flag102);
2597
 
2598
      procedure Set_Flag103 (N : Node_Id; Val : Boolean);
2599
      pragma Inline (Set_Flag103);
2600
 
2601
      procedure Set_Flag104 (N : Node_Id; Val : Boolean);
2602
      pragma Inline (Set_Flag104);
2603
 
2604
      procedure Set_Flag105 (N : Node_Id; Val : Boolean);
2605
      pragma Inline (Set_Flag105);
2606
 
2607
      procedure Set_Flag106 (N : Node_Id; Val : Boolean);
2608
      pragma Inline (Set_Flag106);
2609
 
2610
      procedure Set_Flag107 (N : Node_Id; Val : Boolean);
2611
      pragma Inline (Set_Flag107);
2612
 
2613
      procedure Set_Flag108 (N : Node_Id; Val : Boolean);
2614
      pragma Inline (Set_Flag108);
2615
 
2616
      procedure Set_Flag109 (N : Node_Id; Val : Boolean);
2617
      pragma Inline (Set_Flag109);
2618
 
2619
      procedure Set_Flag110 (N : Node_Id; Val : Boolean);
2620
      pragma Inline (Set_Flag110);
2621
 
2622
      procedure Set_Flag111 (N : Node_Id; Val : Boolean);
2623
      pragma Inline (Set_Flag111);
2624
 
2625
      procedure Set_Flag112 (N : Node_Id; Val : Boolean);
2626
      pragma Inline (Set_Flag112);
2627
 
2628
      procedure Set_Flag113 (N : Node_Id; Val : Boolean);
2629
      pragma Inline (Set_Flag113);
2630
 
2631
      procedure Set_Flag114 (N : Node_Id; Val : Boolean);
2632
      pragma Inline (Set_Flag114);
2633
 
2634
      procedure Set_Flag115 (N : Node_Id; Val : Boolean);
2635
      pragma Inline (Set_Flag115);
2636
 
2637
      procedure Set_Flag116 (N : Node_Id; Val : Boolean);
2638
      pragma Inline (Set_Flag116);
2639
 
2640
      procedure Set_Flag117 (N : Node_Id; Val : Boolean);
2641
      pragma Inline (Set_Flag117);
2642
 
2643
      procedure Set_Flag118 (N : Node_Id; Val : Boolean);
2644
      pragma Inline (Set_Flag118);
2645
 
2646
      procedure Set_Flag119 (N : Node_Id; Val : Boolean);
2647
      pragma Inline (Set_Flag119);
2648
 
2649
      procedure Set_Flag120 (N : Node_Id; Val : Boolean);
2650
      pragma Inline (Set_Flag120);
2651
 
2652
      procedure Set_Flag121 (N : Node_Id; Val : Boolean);
2653
      pragma Inline (Set_Flag121);
2654
 
2655
      procedure Set_Flag122 (N : Node_Id; Val : Boolean);
2656
      pragma Inline (Set_Flag122);
2657
 
2658
      procedure Set_Flag123 (N : Node_Id; Val : Boolean);
2659
      pragma Inline (Set_Flag123);
2660
 
2661
      procedure Set_Flag124 (N : Node_Id; Val : Boolean);
2662
      pragma Inline (Set_Flag124);
2663
 
2664
      procedure Set_Flag125 (N : Node_Id; Val : Boolean);
2665
      pragma Inline (Set_Flag125);
2666
 
2667
      procedure Set_Flag126 (N : Node_Id; Val : Boolean);
2668
      pragma Inline (Set_Flag126);
2669
 
2670
      procedure Set_Flag127 (N : Node_Id; Val : Boolean);
2671
      pragma Inline (Set_Flag127);
2672
 
2673
      procedure Set_Flag128 (N : Node_Id; Val : Boolean);
2674
      pragma Inline (Set_Flag128);
2675
 
2676
      procedure Set_Flag129 (N : Node_Id; Val : Boolean);
2677
      pragma Inline (Set_Flag129);
2678
 
2679
      procedure Set_Flag130 (N : Node_Id; Val : Boolean);
2680
      pragma Inline (Set_Flag130);
2681
 
2682
      procedure Set_Flag131 (N : Node_Id; Val : Boolean);
2683
      pragma Inline (Set_Flag131);
2684
 
2685
      procedure Set_Flag132 (N : Node_Id; Val : Boolean);
2686
      pragma Inline (Set_Flag132);
2687
 
2688
      procedure Set_Flag133 (N : Node_Id; Val : Boolean);
2689
      pragma Inline (Set_Flag133);
2690
 
2691
      procedure Set_Flag134 (N : Node_Id; Val : Boolean);
2692
      pragma Inline (Set_Flag134);
2693
 
2694
      procedure Set_Flag135 (N : Node_Id; Val : Boolean);
2695
      pragma Inline (Set_Flag135);
2696
 
2697
      procedure Set_Flag136 (N : Node_Id; Val : Boolean);
2698
      pragma Inline (Set_Flag136);
2699
 
2700
      procedure Set_Flag137 (N : Node_Id; Val : Boolean);
2701
      pragma Inline (Set_Flag137);
2702
 
2703
      procedure Set_Flag138 (N : Node_Id; Val : Boolean);
2704
      pragma Inline (Set_Flag138);
2705
 
2706
      procedure Set_Flag139 (N : Node_Id; Val : Boolean);
2707
      pragma Inline (Set_Flag139);
2708
 
2709
      procedure Set_Flag140 (N : Node_Id; Val : Boolean);
2710
      pragma Inline (Set_Flag140);
2711
 
2712
      procedure Set_Flag141 (N : Node_Id; Val : Boolean);
2713
      pragma Inline (Set_Flag141);
2714
 
2715
      procedure Set_Flag142 (N : Node_Id; Val : Boolean);
2716
      pragma Inline (Set_Flag142);
2717
 
2718
      procedure Set_Flag143 (N : Node_Id; Val : Boolean);
2719
      pragma Inline (Set_Flag143);
2720
 
2721
      procedure Set_Flag144 (N : Node_Id; Val : Boolean);
2722
      pragma Inline (Set_Flag144);
2723
 
2724
      procedure Set_Flag145 (N : Node_Id; Val : Boolean);
2725
      pragma Inline (Set_Flag145);
2726
 
2727
      procedure Set_Flag146 (N : Node_Id; Val : Boolean);
2728
      pragma Inline (Set_Flag146);
2729
 
2730
      procedure Set_Flag147 (N : Node_Id; Val : Boolean);
2731
      pragma Inline (Set_Flag147);
2732
 
2733
      procedure Set_Flag148 (N : Node_Id; Val : Boolean);
2734
      pragma Inline (Set_Flag148);
2735
 
2736
      procedure Set_Flag149 (N : Node_Id; Val : Boolean);
2737
      pragma Inline (Set_Flag149);
2738
 
2739
      procedure Set_Flag150 (N : Node_Id; Val : Boolean);
2740
      pragma Inline (Set_Flag150);
2741
 
2742
      procedure Set_Flag151 (N : Node_Id; Val : Boolean);
2743
      pragma Inline (Set_Flag151);
2744
 
2745
      procedure Set_Flag152 (N : Node_Id; Val : Boolean);
2746
      pragma Inline (Set_Flag152);
2747
 
2748
      procedure Set_Flag153 (N : Node_Id; Val : Boolean);
2749
      pragma Inline (Set_Flag153);
2750
 
2751
      procedure Set_Flag154 (N : Node_Id; Val : Boolean);
2752
      pragma Inline (Set_Flag154);
2753
 
2754
      procedure Set_Flag155 (N : Node_Id; Val : Boolean);
2755
      pragma Inline (Set_Flag155);
2756
 
2757
      procedure Set_Flag156 (N : Node_Id; Val : Boolean);
2758
      pragma Inline (Set_Flag156);
2759
 
2760
      procedure Set_Flag157 (N : Node_Id; Val : Boolean);
2761
      pragma Inline (Set_Flag157);
2762
 
2763
      procedure Set_Flag158 (N : Node_Id; Val : Boolean);
2764
      pragma Inline (Set_Flag158);
2765
 
2766
      procedure Set_Flag159 (N : Node_Id; Val : Boolean);
2767
      pragma Inline (Set_Flag159);
2768
 
2769
      procedure Set_Flag160 (N : Node_Id; Val : Boolean);
2770
      pragma Inline (Set_Flag160);
2771
 
2772
      procedure Set_Flag161 (N : Node_Id; Val : Boolean);
2773
      pragma Inline (Set_Flag161);
2774
 
2775
      procedure Set_Flag162 (N : Node_Id; Val : Boolean);
2776
      pragma Inline (Set_Flag162);
2777
 
2778
      procedure Set_Flag163 (N : Node_Id; Val : Boolean);
2779
      pragma Inline (Set_Flag163);
2780
 
2781
      procedure Set_Flag164 (N : Node_Id; Val : Boolean);
2782
      pragma Inline (Set_Flag164);
2783
 
2784
      procedure Set_Flag165 (N : Node_Id; Val : Boolean);
2785
      pragma Inline (Set_Flag165);
2786
 
2787
      procedure Set_Flag166 (N : Node_Id; Val : Boolean);
2788
      pragma Inline (Set_Flag166);
2789
 
2790
      procedure Set_Flag167 (N : Node_Id; Val : Boolean);
2791
      pragma Inline (Set_Flag167);
2792
 
2793
      procedure Set_Flag168 (N : Node_Id; Val : Boolean);
2794
      pragma Inline (Set_Flag168);
2795
 
2796
      procedure Set_Flag169 (N : Node_Id; Val : Boolean);
2797
      pragma Inline (Set_Flag169);
2798
 
2799
      procedure Set_Flag170 (N : Node_Id; Val : Boolean);
2800
      pragma Inline (Set_Flag170);
2801
 
2802
      procedure Set_Flag171 (N : Node_Id; Val : Boolean);
2803
      pragma Inline (Set_Flag171);
2804
 
2805
      procedure Set_Flag172 (N : Node_Id; Val : Boolean);
2806
      pragma Inline (Set_Flag172);
2807
 
2808
      procedure Set_Flag173 (N : Node_Id; Val : Boolean);
2809
      pragma Inline (Set_Flag173);
2810
 
2811
      procedure Set_Flag174 (N : Node_Id; Val : Boolean);
2812
      pragma Inline (Set_Flag174);
2813
 
2814
      procedure Set_Flag175 (N : Node_Id; Val : Boolean);
2815
      pragma Inline (Set_Flag175);
2816
 
2817
      procedure Set_Flag176 (N : Node_Id; Val : Boolean);
2818
      pragma Inline (Set_Flag176);
2819
 
2820
      procedure Set_Flag177 (N : Node_Id; Val : Boolean);
2821
      pragma Inline (Set_Flag177);
2822
 
2823
      procedure Set_Flag178 (N : Node_Id; Val : Boolean);
2824
      pragma Inline (Set_Flag178);
2825
 
2826
      procedure Set_Flag179 (N : Node_Id; Val : Boolean);
2827
      pragma Inline (Set_Flag179);
2828
 
2829
      procedure Set_Flag180 (N : Node_Id; Val : Boolean);
2830
      pragma Inline (Set_Flag180);
2831
 
2832
      procedure Set_Flag181 (N : Node_Id; Val : Boolean);
2833
      pragma Inline (Set_Flag181);
2834
 
2835
      procedure Set_Flag182 (N : Node_Id; Val : Boolean);
2836
      pragma Inline (Set_Flag182);
2837
 
2838
      procedure Set_Flag183 (N : Node_Id; Val : Boolean);
2839
      pragma Inline (Set_Flag183);
2840
 
2841
      procedure Set_Flag184 (N : Node_Id; Val : Boolean);
2842
      pragma Inline (Set_Flag184);
2843
 
2844
      procedure Set_Flag185 (N : Node_Id; Val : Boolean);
2845
      pragma Inline (Set_Flag185);
2846
 
2847
      procedure Set_Flag186 (N : Node_Id; Val : Boolean);
2848
      pragma Inline (Set_Flag186);
2849
 
2850
      procedure Set_Flag187 (N : Node_Id; Val : Boolean);
2851
      pragma Inline (Set_Flag187);
2852
 
2853
      procedure Set_Flag188 (N : Node_Id; Val : Boolean);
2854
      pragma Inline (Set_Flag188);
2855
 
2856
      procedure Set_Flag189 (N : Node_Id; Val : Boolean);
2857
      pragma Inline (Set_Flag189);
2858
 
2859
      procedure Set_Flag190 (N : Node_Id; Val : Boolean);
2860
      pragma Inline (Set_Flag190);
2861
 
2862
      procedure Set_Flag191 (N : Node_Id; Val : Boolean);
2863
      pragma Inline (Set_Flag191);
2864
 
2865
      procedure Set_Flag192 (N : Node_Id; Val : Boolean);
2866
      pragma Inline (Set_Flag192);
2867
 
2868
      procedure Set_Flag193 (N : Node_Id; Val : Boolean);
2869
      pragma Inline (Set_Flag193);
2870
 
2871
      procedure Set_Flag194 (N : Node_Id; Val : Boolean);
2872
      pragma Inline (Set_Flag194);
2873
 
2874
      procedure Set_Flag195 (N : Node_Id; Val : Boolean);
2875
      pragma Inline (Set_Flag195);
2876
 
2877
      procedure Set_Flag196 (N : Node_Id; Val : Boolean);
2878
      pragma Inline (Set_Flag196);
2879
 
2880
      procedure Set_Flag197 (N : Node_Id; Val : Boolean);
2881
      pragma Inline (Set_Flag197);
2882
 
2883
      procedure Set_Flag198 (N : Node_Id; Val : Boolean);
2884
      pragma Inline (Set_Flag198);
2885
 
2886
      procedure Set_Flag199 (N : Node_Id; Val : Boolean);
2887
      pragma Inline (Set_Flag199);
2888
 
2889
      procedure Set_Flag200 (N : Node_Id; Val : Boolean);
2890
      pragma Inline (Set_Flag200);
2891
 
2892
      procedure Set_Flag201 (N : Node_Id; Val : Boolean);
2893
      pragma Inline (Set_Flag201);
2894
 
2895
      procedure Set_Flag202 (N : Node_Id; Val : Boolean);
2896
      pragma Inline (Set_Flag202);
2897
 
2898
      procedure Set_Flag203 (N : Node_Id; Val : Boolean);
2899
      pragma Inline (Set_Flag203);
2900
 
2901
      procedure Set_Flag204 (N : Node_Id; Val : Boolean);
2902
      pragma Inline (Set_Flag204);
2903
 
2904
      procedure Set_Flag205 (N : Node_Id; Val : Boolean);
2905
      pragma Inline (Set_Flag205);
2906
 
2907
      procedure Set_Flag206 (N : Node_Id; Val : Boolean);
2908
      pragma Inline (Set_Flag206);
2909
 
2910
      procedure Set_Flag207 (N : Node_Id; Val : Boolean);
2911
      pragma Inline (Set_Flag207);
2912
 
2913
      procedure Set_Flag208 (N : Node_Id; Val : Boolean);
2914
      pragma Inline (Set_Flag208);
2915
 
2916
      procedure Set_Flag209 (N : Node_Id; Val : Boolean);
2917
      pragma Inline (Set_Flag209);
2918
 
2919
      procedure Set_Flag210 (N : Node_Id; Val : Boolean);
2920
      pragma Inline (Set_Flag210);
2921
 
2922
      procedure Set_Flag211 (N : Node_Id; Val : Boolean);
2923
      pragma Inline (Set_Flag211);
2924
 
2925
      procedure Set_Flag212 (N : Node_Id; Val : Boolean);
2926
      pragma Inline (Set_Flag212);
2927
 
2928
      procedure Set_Flag213 (N : Node_Id; Val : Boolean);
2929
      pragma Inline (Set_Flag213);
2930
 
2931
      procedure Set_Flag214 (N : Node_Id; Val : Boolean);
2932
      pragma Inline (Set_Flag214);
2933
 
2934
      procedure Set_Flag215 (N : Node_Id; Val : Boolean);
2935
      pragma Inline (Set_Flag215);
2936
 
2937
      procedure Set_Flag216 (N : Node_Id; Val : Boolean);
2938
      pragma Inline (Set_Flag216);
2939
 
2940
      procedure Set_Flag217 (N : Node_Id; Val : Boolean);
2941
      pragma Inline (Set_Flag217);
2942
 
2943
      procedure Set_Flag218 (N : Node_Id; Val : Boolean);
2944
      pragma Inline (Set_Flag218);
2945
 
2946
      procedure Set_Flag219 (N : Node_Id; Val : Boolean);
2947
      pragma Inline (Set_Flag219);
2948
 
2949
      procedure Set_Flag220 (N : Node_Id; Val : Boolean);
2950
      pragma Inline (Set_Flag220);
2951
 
2952
      procedure Set_Flag221 (N : Node_Id; Val : Boolean);
2953
      pragma Inline (Set_Flag221);
2954
 
2955
      procedure Set_Flag222 (N : Node_Id; Val : Boolean);
2956
      pragma Inline (Set_Flag222);
2957
 
2958
      procedure Set_Flag223 (N : Node_Id; Val : Boolean);
2959
      pragma Inline (Set_Flag223);
2960
 
2961
      procedure Set_Flag224 (N : Node_Id; Val : Boolean);
2962
      pragma Inline (Set_Flag224);
2963
 
2964
      procedure Set_Flag225 (N : Node_Id; Val : Boolean);
2965
      pragma Inline (Set_Flag225);
2966
 
2967
      procedure Set_Flag226 (N : Node_Id; Val : Boolean);
2968
      pragma Inline (Set_Flag226);
2969
 
2970
      procedure Set_Flag227 (N : Node_Id; Val : Boolean);
2971
      pragma Inline (Set_Flag227);
2972
 
2973
      procedure Set_Flag228 (N : Node_Id; Val : Boolean);
2974
      pragma Inline (Set_Flag228);
2975
 
2976
      procedure Set_Flag229 (N : Node_Id; Val : Boolean);
2977
      pragma Inline (Set_Flag229);
2978
 
2979
      procedure Set_Flag230 (N : Node_Id; Val : Boolean);
2980
      pragma Inline (Set_Flag230);
2981
 
2982
      procedure Set_Flag231 (N : Node_Id; Val : Boolean);
2983
      pragma Inline (Set_Flag231);
2984
 
2985
      procedure Set_Flag232 (N : Node_Id; Val : Boolean);
2986
      pragma Inline (Set_Flag232);
2987
 
2988
      procedure Set_Flag233 (N : Node_Id; Val : Boolean);
2989
      pragma Inline (Set_Flag233);
2990
 
2991
      procedure Set_Flag234 (N : Node_Id; Val : Boolean);
2992
      pragma Inline (Set_Flag234);
2993
 
2994
      procedure Set_Flag235 (N : Node_Id; Val : Boolean);
2995
      pragma Inline (Set_Flag235);
2996
 
2997
      procedure Set_Flag236 (N : Node_Id; Val : Boolean);
2998
      pragma Inline (Set_Flag236);
2999
 
3000
      procedure Set_Flag237 (N : Node_Id; Val : Boolean);
3001
      pragma Inline (Set_Flag237);
3002
 
3003
      procedure Set_Flag238 (N : Node_Id; Val : Boolean);
3004
      pragma Inline (Set_Flag238);
3005
 
3006
      procedure Set_Flag239 (N : Node_Id; Val : Boolean);
3007
      pragma Inline (Set_Flag239);
3008
 
3009
      procedure Set_Flag240 (N : Node_Id; Val : Boolean);
3010
      pragma Inline (Set_Flag240);
3011
 
3012
      procedure Set_Flag241 (N : Node_Id; Val : Boolean);
3013
      pragma Inline (Set_Flag241);
3014
 
3015
      procedure Set_Flag242 (N : Node_Id; Val : Boolean);
3016
      pragma Inline (Set_Flag242);
3017
 
3018
      procedure Set_Flag243 (N : Node_Id; Val : Boolean);
3019
      pragma Inline (Set_Flag243);
3020
 
3021
      procedure Set_Flag244 (N : Node_Id; Val : Boolean);
3022
      pragma Inline (Set_Flag244);
3023
 
3024
      procedure Set_Flag245 (N : Node_Id; Val : Boolean);
3025
      pragma Inline (Set_Flag245);
3026
 
3027
      procedure Set_Flag246 (N : Node_Id; Val : Boolean);
3028
      pragma Inline (Set_Flag246);
3029
 
3030
      procedure Set_Flag247 (N : Node_Id; Val : Boolean);
3031
      pragma Inline (Set_Flag247);
3032
 
3033
      procedure Set_Flag248 (N : Node_Id; Val : Boolean);
3034
      pragma Inline (Set_Flag248);
3035
 
3036
      procedure Set_Flag249 (N : Node_Id; Val : Boolean);
3037
      pragma Inline (Set_Flag249);
3038
 
3039
      procedure Set_Flag250 (N : Node_Id; Val : Boolean);
3040
      pragma Inline (Set_Flag250);
3041
 
3042
      procedure Set_Flag251 (N : Node_Id; Val : Boolean);
3043
      pragma Inline (Set_Flag251);
3044
 
3045
      procedure Set_Flag252 (N : Node_Id; Val : Boolean);
3046
      pragma Inline (Set_Flag252);
3047
 
3048
      procedure Set_Flag253 (N : Node_Id; Val : Boolean);
3049
      pragma Inline (Set_Flag253);
3050
 
3051
      procedure Set_Flag254 (N : Node_Id; Val : Boolean);
3052
      pragma Inline (Set_Flag254);
3053
 
3054
      --  The following versions of Set_Noden also set the parent pointer of
3055
      --  the referenced node if it is not Empty.
3056
 
3057
      procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id);
3058
      pragma Inline (Set_Node1_With_Parent);
3059
 
3060
      procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id);
3061
      pragma Inline (Set_Node2_With_Parent);
3062
 
3063
      procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id);
3064
      pragma Inline (Set_Node3_With_Parent);
3065
 
3066
      procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id);
3067
      pragma Inline (Set_Node4_With_Parent);
3068
 
3069
      procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id);
3070
      pragma Inline (Set_Node5_With_Parent);
3071
 
3072
      --  The following versions of Set_Listn also set the parent pointer of
3073
      --  the referenced node if it is not Empty.
3074
 
3075
      procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id);
3076
      pragma Inline (Set_List1_With_Parent);
3077
 
3078
      procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id);
3079
      pragma Inline (Set_List2_With_Parent);
3080
 
3081
      procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id);
3082
      pragma Inline (Set_List3_With_Parent);
3083
 
3084
      procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id);
3085
      pragma Inline (Set_List4_With_Parent);
3086
 
3087
      procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id);
3088
      pragma Inline (Set_List5_With_Parent);
3089
 
3090
   end Unchecked_Access;
3091
 
3092
   -----------------------------
3093
   -- Private Part Subpackage --
3094
   -----------------------------
3095
 
3096
   --  The following package contains the definition of the data structure
3097
   --  used by the implementation of the Atree package. Logically it really
3098
   --  corresponds to the private part, hence the name. The reason that it
3099
   --  is defined as a sub-package is to allow special access from clients
3100
   --  that need to see the internals of the data structures.
3101
 
3102
   package Atree_Private_Part is
3103
 
3104
      -------------------------
3105
      -- Tree Representation --
3106
      -------------------------
3107
 
3108
      --  The nodes of the tree are stored in a table (i.e. an array). In the
3109
      --  case of extended nodes five consecutive components in the array are
3110
      --  used. There are thus two formats for array components. One is used
3111
      --  for non-extended nodes, and for the first component of extended
3112
      --  nodes. The other is used for the extension parts (second, third,
3113
      --  fourth and fifth components) of an extended node. A variant record
3114
      --  structure is used to distinguish the two formats.
3115
 
3116
      type Node_Record (Is_Extension : Boolean := False) is record
3117
 
3118
         --  Logically, the only field in the common part is the above
3119
         --  Is_Extension discriminant (a single bit). However, Gigi cannot
3120
         --  yet handle such a structure, so we fill out the common part of
3121
         --  the record with fields that are used in different ways for
3122
         --  normal nodes and node extensions.
3123
 
3124
         Pflag1, Pflag2 : Boolean;
3125
         --  The Paren_Count field is represented using two boolean flags,
3126
         --  where Pflag1 is worth 1, and Pflag2 is worth 2. This is done
3127
         --  because we need to be easily able to reuse this field for
3128
         --  extra flags in the extended node case.
3129
 
3130
         In_List : Boolean;
3131
         --  Flag used to indicate if node is a member of a list.
3132
         --  This field is considered private to the Atree package.
3133
 
3134
         Has_Aspects : Boolean;
3135
         --  Flag used to indicate that a node has aspect specifications that
3136
         --  are associated with the node. See Aspects package for details.
3137
 
3138
         Rewrite_Ins : Boolean;
3139
         --  Flag set by Mark_Rewrite_Insertion procedure.
3140
         --  This field is considered private to the Atree package.
3141
 
3142
         Analyzed : Boolean;
3143
         --  Flag to indicate the node has been analyzed (and expanded)
3144
 
3145
         Comes_From_Source : Boolean;
3146
         --  Flag to indicate that node comes from the source program (i.e.
3147
         --  was built by the parser or scanner, not the analyzer or expander).
3148
 
3149
         Error_Posted : Boolean;
3150
         --  Flag to indicate that an error message has been posted on the
3151
         --  node (to avoid duplicate flags on the same node)
3152
 
3153
         Flag4  : Boolean;
3154
         Flag5  : Boolean;
3155
         Flag6  : Boolean;
3156
         Flag7  : Boolean;
3157
         Flag8  : Boolean;
3158
         Flag9  : Boolean;
3159
         Flag10 : Boolean;
3160
         Flag11 : Boolean;
3161
         Flag12 : Boolean;
3162
         Flag13 : Boolean;
3163
         Flag14 : Boolean;
3164
         Flag15 : Boolean;
3165
         Flag16 : Boolean;
3166
         Flag17 : Boolean;
3167
         Flag18 : Boolean;
3168
         --  The eighteen flags for a normal node
3169
 
3170
         --  The above fields are used as follows in components 2-5 of
3171
         --  an extended node entry.
3172
 
3173
         --    In_List              used as  Flag19, Flag40, Flag129, Flag216
3174
         --    Has_Aspects          used as  Flag20, Flag41, Flag130, Flag217
3175
         --    Rewrite_Ins          used as  Flag21, Flag42, Flag131, Flag218
3176
         --    Analyzed             used as  Flag22, Flag43, Flag132, Flag219
3177
         --    Comes_From_Source    used as  Flag23, Flag44, Flag133, Flag220
3178
         --    Error_Posted         used as  Flag24, Flag45, Flag134, Flag221
3179
         --    Flag4                used as  Flag25, Flag46, Flag135, Flag222
3180
         --    Flag5                used as  Flag26, Flag47, Flag136, Flag223
3181
         --    Flag6                used as  Flag27, Flag48, Flag137, Flag224
3182
         --    Flag7                used as  Flag28, Flag49, Flag138, Flag225
3183
         --    Flag8                used as  Flag29, Flag50, Flag139, Flag226
3184
         --    Flag9                used as  Flag30, Flag51, Flag140, Flag227
3185
         --    Flag10               used as  Flag31, Flag52, Flag141, Flag228
3186
         --    Flag11               used as  Flag32, Flag53, Flag142, Flag229
3187
         --    Flag12               used as  Flag33, Flag54, Flag143, Flag230
3188
         --    Flag13               used as  Flag34, Flag55, Flag144, Flag231
3189
         --    Flag14               used as  Flag35, Flag56, Flag145, Flag232
3190
         --    Flag15               used as  Flag36, Flag57, Flag146, Flag233
3191
         --    Flag16               used as  Flag37, Flag58, Flag147, Flag234
3192
         --    Flag17               used as  Flag38, Flag59, Flag148, Flag235
3193
         --    Flag18               used as  Flag39, Flag60, Flag149, Flag236
3194
         --    Pflag1               used as  Flag61, Flag62, Flag150, Flag237
3195
         --    Pflag2               used as  Flag63, Flag64, Flag151, Flag238
3196
 
3197
         Nkind : Node_Kind;
3198
         --  For a non-extended node, or the initial section of an extended
3199
         --  node, this field holds the Node_Kind value. For an extended node,
3200
         --  The Nkind field is used as follows:
3201
         --
3202
         --     Second entry: holds the Ekind field of the entity
3203
         --     Third entry:  holds 8 additional flags (Flag65-Flag72)
3204
         --     Fourth entry: holds 8 additional flags (Flag239-246)
3205
         --     Fifth entry:  holds 8 additional flags (Flag247-254)
3206
 
3207
         --  Now finally (on an 32-bit boundary!) comes the variant part
3208
 
3209
         case Is_Extension is
3210
 
3211
            --  Non-extended node, or first component of extended node
3212
 
3213
            when False =>
3214
 
3215
               Sloc : Source_Ptr;
3216
               --  Source location for this node
3217
 
3218
               Link : Union_Id;
3219
               --  This field is used either as the Parent pointer (if In_List
3220
               --  is False), or to point to the list header (if In_List is
3221
               --  True). This field is considered private and can be modified
3222
               --  only by Atree or by Nlists.
3223
 
3224
               Field1 : Union_Id;
3225
               Field2 : Union_Id;
3226
               Field3 : Union_Id;
3227
               Field4 : Union_Id;
3228
               Field5 : Union_Id;
3229
               --  Five general use fields, which can contain Node_Id, List_Id,
3230
               --  Elist_Id, String_Id, or Name_Id values depending on the
3231
               --  values in Nkind and (for extended nodes), in Ekind. See
3232
               --  packages Sinfo and Einfo for details of their use.
3233
 
3234
            --  Extension (second component) of extended node
3235
 
3236
            when True =>
3237
 
3238
               Field6  : Union_Id;
3239
               Field7  : Union_Id;
3240
               Field8  : Union_Id;
3241
               Field9  : Union_Id;
3242
               Field10 : Union_Id;
3243
               Field11 : Union_Id;
3244
               Field12 : Union_Id;
3245
               --  Seven additional general fields available only for entities
3246
               --  See package Einfo for details of their use (which depends
3247
               --  on the value in the Ekind field).
3248
 
3249
            --  In the third component, the extension format as described
3250
            --  above is used to hold additional general fields and flags
3251
            --  as follows:
3252
 
3253
            --    Field6-11      Holds Field13-Field18
3254
            --    Field12        Holds Flag73-Flag96 and Convention
3255
 
3256
            --  In the fourth component, the extension format as described
3257
            --  above is used to hold additional general fields and flags
3258
            --  as follows:
3259
 
3260
            --    Field6-10      Holds Field19-Field23
3261
            --    Field11        Holds Flag152-Flag183
3262
            --    Field12        Holds Flag97-Flag128
3263
 
3264
            --  In the fifth component, the extension format as described
3265
            --  above is used to hold additional general fields and flags
3266
            --  as follows:
3267
 
3268
            --    Field6-11      Holds Field24-Field29
3269
            --    Field12        Holds Flag184-Flag215
3270
 
3271
         end case;
3272
      end record;
3273
 
3274
      pragma Pack (Node_Record);
3275
      for Node_Record'Size use 8*32;
3276
      for Node_Record'Alignment use 4;
3277
 
3278
      function E_To_N is new Unchecked_Conversion (Entity_Kind, Node_Kind);
3279
      function N_To_E is new Unchecked_Conversion (Node_Kind, Entity_Kind);
3280
 
3281
      --  Default value used to initialize default nodes. Note that some of the
3282
      --  fields get overwritten, and in particular, Nkind always gets reset.
3283
 
3284
      Default_Node : Node_Record := (
3285
         Is_Extension      => False,
3286
         Pflag1            => False,
3287
         Pflag2            => False,
3288
         In_List           => False,
3289
         Has_Aspects       => False,
3290
         Rewrite_Ins       => False,
3291
         Analyzed          => False,
3292
         Comes_From_Source => False,
3293
         --  modified by Set_Comes_From_Source_Default
3294
         Error_Posted      => False,
3295
         Flag4             => False,
3296
 
3297
         Flag5             => False,
3298
         Flag6             => False,
3299
         Flag7             => False,
3300
         Flag8             => False,
3301
         Flag9             => False,
3302
         Flag10            => False,
3303
         Flag11            => False,
3304
         Flag12            => False,
3305
 
3306
         Flag13            => False,
3307
         Flag14            => False,
3308
         Flag15            => False,
3309
         Flag16            => False,
3310
         Flag17            => False,
3311
         Flag18            => False,
3312
 
3313
         Nkind             => N_Unused_At_Start,
3314
 
3315
         Sloc              => No_Location,
3316
         Link              => Empty_List_Or_Node,
3317
         Field1            => Empty_List_Or_Node,
3318
         Field2            => Empty_List_Or_Node,
3319
         Field3            => Empty_List_Or_Node,
3320
         Field4            => Empty_List_Or_Node,
3321
         Field5            => Empty_List_Or_Node);
3322
 
3323
      --  Default value used to initialize node extensions (i.e. the second
3324
      --  and third and fourth components of an extended node). Note we are
3325
      --  cheating a bit here when it comes to Node12, which really holds
3326
      --  flags an (for the third component), the convention. But it works
3327
      --  because Empty, False, Convention_Ada, all happen to be all zero bits.
3328
 
3329
      Default_Node_Extension : constant Node_Record := (
3330
         Is_Extension      => True,
3331
         Pflag1            => False,
3332
         Pflag2            => False,
3333
         In_List           => False,
3334
         Has_Aspects       => False,
3335
         Rewrite_Ins       => False,
3336
         Analyzed          => False,
3337
         Comes_From_Source => False,
3338
         Error_Posted      => False,
3339
         Flag4             => False,
3340
 
3341
         Flag5             => False,
3342
         Flag6             => False,
3343
         Flag7             => False,
3344
         Flag8             => False,
3345
         Flag9             => False,
3346
         Flag10            => False,
3347
         Flag11            => False,
3348
         Flag12            => False,
3349
 
3350
         Flag13            => False,
3351
         Flag14            => False,
3352
         Flag15            => False,
3353
         Flag16            => False,
3354
         Flag17            => False,
3355
         Flag18            => False,
3356
 
3357
         Nkind             => E_To_N (E_Void),
3358
 
3359
         Field6            => Empty_List_Or_Node,
3360
         Field7            => Empty_List_Or_Node,
3361
         Field8            => Empty_List_Or_Node,
3362
         Field9            => Empty_List_Or_Node,
3363
         Field10           => Empty_List_Or_Node,
3364
         Field11           => Empty_List_Or_Node,
3365
         Field12           => Empty_List_Or_Node);
3366
 
3367
      --  The following defines the extendable array used for the nodes table
3368
      --  Nodes with extensions use five consecutive entries in the array
3369
 
3370
      package Nodes is new Table.Table (
3371
        Table_Component_Type => Node_Record,
3372
        Table_Index_Type     => Node_Id'Base,
3373
        Table_Low_Bound      => First_Node_Id,
3374
        Table_Initial        => Alloc.Nodes_Initial,
3375
        Table_Increment      => Alloc.Nodes_Increment,
3376
        Table_Name           => "Nodes");
3377
 
3378
   end Atree_Private_Part;
3379
 
3380
end Atree;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.