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

Subversion Repositories openrisc

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

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
--                                 B o d y                                  --
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
pragma Style_Checks (All_Checks);
33
--  Turn off subprogram ordering check for this package
34
 
35
--  WARNING: There is a C version of this package. Any changes to this source
36
--  file must be properly reflected in the file atree.h which is a C header
37
--  file containing equivalent definitions for use by gigi.
38
 
39
with Aspects; use Aspects;
40
with Debug;   use Debug;
41
with Nlists;  use Nlists;
42
with Output;  use Output;
43
with Sinput;  use Sinput;
44
with Tree_IO; use Tree_IO;
45
 
46
package body Atree is
47
 
48
   Reporting_Proc : Report_Proc := null;
49
   --  Record argument to last call to Set_Reporting_Proc
50
 
51
   ---------------
52
   -- Debugging --
53
   ---------------
54
 
55
   --  Suppose you find that node 12345 is messed up. You might want to find
56
   --  the code that created that node. There are two ways to do this:
57
 
58
   --  One way is to set a conditional breakpoint on New_Node_Debugging_Output
59
   --  (nickname "nnd"):
60
   --     break nnd if n = 12345
61
   --  and run gnat1 again from the beginning.
62
 
63
   --  The other way is to set a breakpoint near the beginning (e.g. on
64
   --  gnat1drv), and run. Then set Watch_Node (nickname "ww") to 12345 in gdb:
65
   --     ww := 12345
66
   --  and set a breakpoint on New_Node_Breakpoint (nickname "nn"). Continue.
67
 
68
   --  Either way, gnat1 will stop when node 12345 is created
69
 
70
   --  The second method is much faster
71
 
72
   --  Similarly, rr and rrd allow breaking on rewriting of a given node
73
 
74
   ww : Node_Id'Base := Node_Id'First - 1;
75
   pragma Export (Ada, ww); --  trick the optimizer
76
   Watch_Node : Node_Id'Base renames ww;
77
   --  Node to "watch"; that is, whenever a node is created, we check if it
78
   --  is equal to Watch_Node, and if so, call New_Node_Breakpoint. You have
79
   --  presumably set a breakpoint on New_Node_Breakpoint. Note that the
80
   --  initial value of Node_Id'First - 1 ensures that by default, no node
81
   --  will be equal to Watch_Node.
82
 
83
   procedure nn;
84
   pragma Export (Ada, nn);
85
   procedure New_Node_Breakpoint renames nn;
86
   --  This doesn't do anything interesting; it's just for setting breakpoint
87
   --  on as explained above.
88
 
89
   procedure nnd (N : Node_Id);
90
   pragma Export (Ada, nnd);
91
   procedure New_Node_Debugging_Output (N : Node_Id) renames nnd;
92
   --  For debugging. If debugging is turned on, New_Node and New_Entity call
93
   --  this. If debug flag N is turned on, this prints out the new node.
94
   --
95
   --  If Node = Watch_Node, this prints out the new node and calls
96
   --  New_Node_Breakpoint. Otherwise, does nothing.
97
 
98
   procedure rr;
99
   pragma Export (Ada, rr);
100
   procedure Rewrite_Breakpoint renames rr;
101
   --  This doesn't do anything interesting; it's just for setting breakpoint
102
   --  on as explained above.
103
 
104
   procedure rrd (Old_Node, New_Node : Node_Id);
105
   pragma Export (Ada, rrd);
106
   procedure Rewrite_Debugging_Output
107
     (Old_Node, New_Node : Node_Id) renames rrd;
108
   --  For debugging. If debugging is turned on, Rewrite calls this. If debug
109
   --  flag N is turned on, this prints out the new node.
110
   --
111
   --  If Old_Node = Watch_Node, this prints out the old and new nodes and
112
   --  calls Rewrite_Breakpoint. Otherwise, does nothing.
113
 
114
   procedure Node_Debug_Output (Op : String; N : Node_Id);
115
   --  Common code for nnd and rrd, writes Op followed by information about N
116
 
117
   -----------------------------
118
   -- Local Objects and Types --
119
   -----------------------------
120
 
121
   Node_Count : Nat;
122
   --  Count allocated nodes for Num_Nodes function
123
 
124
   use Unchecked_Access;
125
   --  We are allowed to see these from within our own body!
126
 
127
   use Atree_Private_Part;
128
   --  We are also allowed to see our private data structures!
129
 
130
   --  Functions used to store Entity_Kind value in Nkind field
131
 
132
   --  The following declarations are used to store flags 65-72 in the
133
   --  Nkind field of the third component of an extended (entity) node.
134
 
135
   type Flag_Byte is record
136
      Flag65 : Boolean;
137
      Flag66 : Boolean;
138
      Flag67 : Boolean;
139
      Flag68 : Boolean;
140
      Flag69 : Boolean;
141
      Flag70 : Boolean;
142
      Flag71 : Boolean;
143
      Flag72 : Boolean;
144
   end record;
145
 
146
   pragma Pack (Flag_Byte);
147
   for Flag_Byte'Size use 8;
148
 
149
   type Flag_Byte_Ptr is access all Flag_Byte;
150
   type Node_Kind_Ptr is access all Node_Kind;
151
 
152
   function To_Flag_Byte is new
153
     Unchecked_Conversion (Node_Kind, Flag_Byte);
154
 
155
   function To_Flag_Byte_Ptr is new
156
     Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);
157
 
158
   --  The following declarations are used to store flags 239-246 in the
159
   --  Nkind field of the fourth component of an extended (entity) node.
160
 
161
   type Flag_Byte2 is record
162
      Flag239 : Boolean;
163
      Flag240 : Boolean;
164
      Flag241 : Boolean;
165
      Flag242 : Boolean;
166
      Flag243 : Boolean;
167
      Flag244 : Boolean;
168
      Flag245 : Boolean;
169
      Flag246 : Boolean;
170
   end record;
171
 
172
   pragma Pack (Flag_Byte2);
173
   for Flag_Byte2'Size use 8;
174
 
175
   type Flag_Byte2_Ptr is access all Flag_Byte2;
176
 
177
   function To_Flag_Byte2 is new
178
     Unchecked_Conversion (Node_Kind, Flag_Byte2);
179
 
180
   function To_Flag_Byte2_Ptr is new
181
     Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte2_Ptr);
182
 
183
   --  The following declarations are used to store flags 247-254 in the
184
   --  Nkind field of the fifth component of an extended (entity) node.
185
 
186
   type Flag_Byte3 is record
187
      Flag247 : Boolean;
188
      Flag248 : Boolean;
189
      Flag249 : Boolean;
190
      Flag250 : Boolean;
191
      Flag251 : Boolean;
192
      Flag252 : Boolean;
193
      Flag253 : Boolean;
194
      Flag254 : Boolean;
195
   end record;
196
 
197
   pragma Pack (Flag_Byte3);
198
   for Flag_Byte3'Size use 8;
199
 
200
   type Flag_Byte3_Ptr is access all Flag_Byte3;
201
 
202
   function To_Flag_Byte3 is new
203
     Unchecked_Conversion (Node_Kind, Flag_Byte3);
204
 
205
   function To_Flag_Byte3_Ptr is new
206
     Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte3_Ptr);
207
 
208
   --  The following declarations are used to store flags 73-96 and the
209
   --  Convention field in the Field12 field of the third component of an
210
   --  extended (Entity) node.
211
 
212
   type Flag_Word is record
213
      Flag73 : Boolean;
214
      Flag74 : Boolean;
215
      Flag75 : Boolean;
216
      Flag76 : Boolean;
217
      Flag77 : Boolean;
218
      Flag78 : Boolean;
219
      Flag79 : Boolean;
220
      Flag80 : Boolean;
221
 
222
      Flag81 : Boolean;
223
      Flag82 : Boolean;
224
      Flag83 : Boolean;
225
      Flag84 : Boolean;
226
      Flag85 : Boolean;
227
      Flag86 : Boolean;
228
      Flag87 : Boolean;
229
      Flag88 : Boolean;
230
 
231
      Flag89 : Boolean;
232
      Flag90 : Boolean;
233
      Flag91 : Boolean;
234
      Flag92 : Boolean;
235
      Flag93 : Boolean;
236
      Flag94 : Boolean;
237
      Flag95 : Boolean;
238
      Flag96 : Boolean;
239
 
240
      Convention : Convention_Id;
241
   end record;
242
 
243
   pragma Pack (Flag_Word);
244
   for Flag_Word'Size use 32;
245
   for Flag_Word'Alignment use 4;
246
 
247
   type Flag_Word_Ptr is access all Flag_Word;
248
   type Union_Id_Ptr  is access all Union_Id;
249
 
250
   function To_Flag_Word is new
251
     Unchecked_Conversion (Union_Id, Flag_Word);
252
 
253
   function To_Flag_Word_Ptr is new
254
     Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr);
255
 
256
   --  The following declarations are used to store flags 97-128 in the
257
   --  Field12 field of the fourth component of an extended (entity) node.
258
 
259
   type Flag_Word2 is record
260
      Flag97  : Boolean;
261
      Flag98  : Boolean;
262
      Flag99  : Boolean;
263
      Flag100 : Boolean;
264
      Flag101 : Boolean;
265
      Flag102 : Boolean;
266
      Flag103 : Boolean;
267
      Flag104 : Boolean;
268
 
269
      Flag105 : Boolean;
270
      Flag106 : Boolean;
271
      Flag107 : Boolean;
272
      Flag108 : Boolean;
273
      Flag109 : Boolean;
274
      Flag110 : Boolean;
275
      Flag111 : Boolean;
276
      Flag112 : Boolean;
277
 
278
      Flag113 : Boolean;
279
      Flag114 : Boolean;
280
      Flag115 : Boolean;
281
      Flag116 : Boolean;
282
      Flag117 : Boolean;
283
      Flag118 : Boolean;
284
      Flag119 : Boolean;
285
      Flag120 : Boolean;
286
 
287
      Flag121 : Boolean;
288
      Flag122 : Boolean;
289
      Flag123 : Boolean;
290
      Flag124 : Boolean;
291
      Flag125 : Boolean;
292
      Flag126 : Boolean;
293
      Flag127 : Boolean;
294
      Flag128 : Boolean;
295
   end record;
296
 
297
   pragma Pack (Flag_Word2);
298
   for Flag_Word2'Size use 32;
299
   for Flag_Word2'Alignment use 4;
300
 
301
   type Flag_Word2_Ptr is access all Flag_Word2;
302
 
303
   function To_Flag_Word2 is new
304
     Unchecked_Conversion (Union_Id, Flag_Word2);
305
 
306
   function To_Flag_Word2_Ptr is new
307
     Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr);
308
 
309
   --  The following declarations are used to store flags 152-183 in the
310
   --  Field11 field of the fourth component of an extended (entity) node.
311
 
312
   type Flag_Word3 is record
313
      Flag152 : Boolean;
314
      Flag153 : Boolean;
315
      Flag154 : Boolean;
316
      Flag155 : Boolean;
317
      Flag156 : Boolean;
318
      Flag157 : Boolean;
319
      Flag158 : Boolean;
320
      Flag159 : Boolean;
321
 
322
      Flag160 : Boolean;
323
      Flag161 : Boolean;
324
      Flag162 : Boolean;
325
      Flag163 : Boolean;
326
      Flag164 : Boolean;
327
      Flag165 : Boolean;
328
      Flag166 : Boolean;
329
      Flag167 : Boolean;
330
 
331
      Flag168 : Boolean;
332
      Flag169 : Boolean;
333
      Flag170 : Boolean;
334
      Flag171 : Boolean;
335
      Flag172 : Boolean;
336
      Flag173 : Boolean;
337
      Flag174 : Boolean;
338
      Flag175 : Boolean;
339
 
340
      Flag176 : Boolean;
341
      Flag177 : Boolean;
342
      Flag178 : Boolean;
343
      Flag179 : Boolean;
344
      Flag180 : Boolean;
345
      Flag181 : Boolean;
346
      Flag182 : Boolean;
347
      Flag183 : Boolean;
348
   end record;
349
 
350
   pragma Pack (Flag_Word3);
351
   for Flag_Word3'Size use 32;
352
   for Flag_Word3'Alignment use 4;
353
 
354
   type Flag_Word3_Ptr is access all Flag_Word3;
355
 
356
   function To_Flag_Word3 is new
357
     Unchecked_Conversion (Union_Id, Flag_Word3);
358
 
359
   function To_Flag_Word3_Ptr is new
360
     Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr);
361
 
362
   --  The following declarations are used to store flags 184-215 in the
363
   --  Field12 field of the fifth component of an extended (entity) node.
364
 
365
   type Flag_Word4 is record
366
      Flag184 : Boolean;
367
      Flag185 : Boolean;
368
      Flag186 : Boolean;
369
      Flag187 : Boolean;
370
      Flag188 : Boolean;
371
      Flag189 : Boolean;
372
      Flag190 : Boolean;
373
      Flag191 : Boolean;
374
 
375
      Flag192 : Boolean;
376
      Flag193 : Boolean;
377
      Flag194 : Boolean;
378
      Flag195 : Boolean;
379
      Flag196 : Boolean;
380
      Flag197 : Boolean;
381
      Flag198 : Boolean;
382
      Flag199 : Boolean;
383
 
384
      Flag200 : Boolean;
385
      Flag201 : Boolean;
386
      Flag202 : Boolean;
387
      Flag203 : Boolean;
388
      Flag204 : Boolean;
389
      Flag205 : Boolean;
390
      Flag206 : Boolean;
391
      Flag207 : Boolean;
392
 
393
      Flag208 : Boolean;
394
      Flag209 : Boolean;
395
      Flag210 : Boolean;
396
      Flag211 : Boolean;
397
      Flag212 : Boolean;
398
      Flag213 : Boolean;
399
      Flag214 : Boolean;
400
      Flag215 : Boolean;
401
   end record;
402
 
403
   pragma Pack (Flag_Word4);
404
   for Flag_Word4'Size use 32;
405
   for Flag_Word4'Alignment use 4;
406
 
407
   type Flag_Word4_Ptr is access all Flag_Word4;
408
 
409
   function To_Flag_Word4 is new
410
     Unchecked_Conversion (Union_Id, Flag_Word4);
411
 
412
   function To_Flag_Word4_Ptr is new
413
     Unchecked_Conversion (Union_Id_Ptr, Flag_Word4_Ptr);
414
 
415
   --------------------------------------------------
416
   -- Implementation of Tree Substitution Routines --
417
   --------------------------------------------------
418
 
419
   --  A separate table keeps track of the mapping between rewritten nodes
420
   --  and their corresponding original tree nodes. Rewrite makes an entry
421
   --  in this table for use by Original_Node. By default, if no call is
422
   --  Rewrite, the entry in this table points to the original unwritten node.
423
 
424
   --  Note: eventually, this should be a field in the Node directly, but
425
   --  for now we do not want to disturb the efficiency of a power of 2
426
   --  for the node size
427
 
428
   package Orig_Nodes is new Table.Table (
429
      Table_Component_Type => Node_Id,
430
      Table_Index_Type     => Node_Id'Base,
431
      Table_Low_Bound      => First_Node_Id,
432
      Table_Initial        => Alloc.Orig_Nodes_Initial,
433
      Table_Increment      => Alloc.Orig_Nodes_Increment,
434
      Table_Name           => "Orig_Nodes");
435
 
436
   --------------------------
437
   -- Paren_Count Handling --
438
   --------------------------
439
 
440
   --  As noted in the spec, the paren count in a sub-expression node has
441
   --  four possible values 0,1,2, and 3. The value 3 really means 3 or more,
442
   --  and we use an auxiliary serially scanned table to record the actual
443
   --  count. A serial search is fine, only pathological programs will use
444
   --  entries in this table. Normal programs won't use it at all.
445
 
446
   type Paren_Count_Entry is record
447
      Nod   : Node_Id;
448
      --  The node to which this count applies
449
 
450
      Count : Nat range 3 .. Nat'Last;
451
      --  The count of parentheses, which will be in the indicated range
452
   end record;
453
 
454
   package Paren_Counts is new Table.Table (
455
     Table_Component_Type => Paren_Count_Entry,
456
     Table_Index_Type     => Int,
457
     Table_Low_Bound      => 0,
458
     Table_Initial        => 10,
459
     Table_Increment      => 200,
460
     Table_Name           => "Paren_Counts");
461
 
462
   -----------------------
463
   -- Local Subprograms --
464
   -----------------------
465
 
466
   procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id);
467
   --  Fixup parent pointers for the syntactic children of Fix_Node after
468
   --  a copy, setting them to Fix_Node when they pointed to Ref_Node.
469
 
470
   function Allocate_Initialize_Node
471
     (Src            : Node_Id;
472
      With_Extension : Boolean) return Node_Id;
473
   --  Allocate a new node or node extension. If Src is not empty,
474
   --  the information for the newly-allocated node is copied from it.
475
 
476
   ------------------------------
477
   -- Allocate_Initialize_Node --
478
   ------------------------------
479
 
480
   function Allocate_Initialize_Node
481
     (Src            : Node_Id;
482
      With_Extension : Boolean) return Node_Id
483
   is
484
      New_Id : Node_Id;
485
 
486
   begin
487
      if Present (Src)
488
        and then not Has_Extension (Src)
489
        and then With_Extension
490
        and then Src = Nodes.Last
491
      then
492
         New_Id := Src;
493
      else
494
         --  We are allocating a new node, or extending a node
495
         --  other than Nodes.Last.
496
 
497
         if Present (Src) then
498
            Nodes.Append (Nodes.Table (Src));
499
         else
500
            Nodes.Append (Default_Node);
501
         end if;
502
 
503
         New_Id := Nodes.Last;
504
         Orig_Nodes.Append (New_Id);
505
         Node_Count := Node_Count + 1;
506
      end if;
507
 
508
      --  Specifically copy Paren_Count to deal with creating new table entry
509
      --  if the parentheses count is at the maximum possible value already.
510
 
511
      if Present (Src) and then Nkind (Src) in N_Subexpr then
512
         Set_Paren_Count (New_Id, Paren_Count (Src));
513
      end if;
514
 
515
      --  Set extension nodes if required
516
 
517
      if With_Extension then
518
         if Present (Src) and then Has_Extension (Src) then
519
            for J in 1 .. 4 loop
520
               Nodes.Append (Nodes.Table (Src + Node_Id (J)));
521
            end loop;
522
         else
523
            for J in 1 .. 4 loop
524
               Nodes.Append (Default_Node_Extension);
525
            end loop;
526
         end if;
527
      end if;
528
 
529
      Orig_Nodes.Set_Last (Nodes.Last);
530
      Allocate_List_Tables (Nodes.Last);
531
 
532
      --  Invoke the reporting procedure (if available)
533
 
534
      if Reporting_Proc /= null then
535
         Reporting_Proc.all (Target => New_Id, Source => Src);
536
      end if;
537
 
538
      return New_Id;
539
   end Allocate_Initialize_Node;
540
 
541
   --------------
542
   -- Analyzed --
543
   --------------
544
 
545
   function Analyzed (N : Node_Id) return Boolean is
546
   begin
547
      pragma Assert (N <= Nodes.Last);
548
      return Nodes.Table (N).Analyzed;
549
   end Analyzed;
550
 
551
   --------------------------
552
   -- Basic_Set_Convention --
553
   --------------------------
554
 
555
   procedure Basic_Set_Convention  (E : Entity_Id; Val : Convention_Id) is
556
   begin
557
      pragma Assert (Nkind (E) in N_Entity);
558
      To_Flag_Word_Ptr
559
        (Union_Id_Ptr'
560
          (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention := Val;
561
   end Basic_Set_Convention;
562
 
563
   -----------------
564
   -- Change_Node --
565
   -----------------
566
 
567
   procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is
568
      Save_Sloc    : constant Source_Ptr := Sloc (N);
569
      Save_In_List : constant Boolean    := Nodes.Table (N).In_List;
570
      Save_Link    : constant Union_Id   := Nodes.Table (N).Link;
571
      Save_CFS     : constant Boolean    := Nodes.Table (N).Comes_From_Source;
572
      Save_Posted  : constant Boolean    := Nodes.Table (N).Error_Posted;
573
      Par_Count    : Nat                 := 0;
574
 
575
   begin
576
      if Nkind (N) in N_Subexpr then
577
         Par_Count := Paren_Count (N);
578
      end if;
579
 
580
      Nodes.Table (N)                   := Default_Node;
581
      Nodes.Table (N).Sloc              := Save_Sloc;
582
      Nodes.Table (N).In_List           := Save_In_List;
583
      Nodes.Table (N).Link              := Save_Link;
584
      Nodes.Table (N).Comes_From_Source := Save_CFS;
585
      Nodes.Table (N).Nkind             := New_Node_Kind;
586
      Nodes.Table (N).Error_Posted      := Save_Posted;
587
 
588
      if New_Node_Kind in N_Subexpr then
589
         Set_Paren_Count (N, Par_Count);
590
      end if;
591
   end Change_Node;
592
 
593
   -----------------------
594
   -- Comes_From_Source --
595
   -----------------------
596
 
597
   function Comes_From_Source (N : Node_Id) return Boolean is
598
   begin
599
      pragma Assert (N <= Nodes.Last);
600
      return Nodes.Table (N).Comes_From_Source;
601
   end Comes_From_Source;
602
 
603
   ----------------
604
   -- Convention --
605
   ----------------
606
 
607
   function Convention (E : Entity_Id) return Convention_Id is
608
   begin
609
      pragma Assert (Nkind (E) in N_Entity);
610
      return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention;
611
   end Convention;
612
 
613
   ---------------
614
   -- Copy_Node --
615
   ---------------
616
 
617
   procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is
618
      Save_In_List : constant Boolean  := Nodes.Table (Destination).In_List;
619
      Save_Link    : constant Union_Id := Nodes.Table (Destination).Link;
620
 
621
   begin
622
      Nodes.Table (Destination)         := Nodes.Table (Source);
623
      Nodes.Table (Destination).In_List := Save_In_List;
624
      Nodes.Table (Destination).Link    := Save_Link;
625
 
626
      --  Specifically set Paren_Count to make sure auxiliary table entry
627
      --  gets correctly made if the parentheses count is at the max value.
628
 
629
      if Nkind (Destination) in N_Subexpr then
630
         Set_Paren_Count (Destination, Paren_Count (Source));
631
      end if;
632
 
633
      --  Deal with copying extension nodes if present
634
 
635
      if Has_Extension (Source) then
636
         pragma Assert (Has_Extension (Destination));
637
         Nodes.Table (Destination + 1) := Nodes.Table (Source + 1);
638
         Nodes.Table (Destination + 2) := Nodes.Table (Source + 2);
639
         Nodes.Table (Destination + 3) := Nodes.Table (Source + 3);
640
         Nodes.Table (Destination + 4) := Nodes.Table (Source + 4);
641
 
642
      else
643
         pragma Assert (not Has_Extension (Source));
644
         null;
645
      end if;
646
   end Copy_Node;
647
 
648
   ------------------------
649
   -- Copy_Separate_List --
650
   ------------------------
651
 
652
   function Copy_Separate_List (Source : List_Id) return List_Id is
653
      Result : constant List_Id := New_List;
654
      Nod    : Node_Id;
655
 
656
   begin
657
      Nod := First (Source);
658
      while Present (Nod) loop
659
         Append (Copy_Separate_Tree (Nod), Result);
660
         Next (Nod);
661
      end loop;
662
 
663
      return Result;
664
   end Copy_Separate_List;
665
 
666
   ------------------------
667
   -- Copy_Separate_Tree --
668
   ------------------------
669
 
670
   function Copy_Separate_Tree (Source : Node_Id) return Node_Id is
671
      New_Id  : Node_Id;
672
 
673
      function Copy_Entity (E : Entity_Id) return Entity_Id;
674
      --  Copy Entity, copying only the Ekind and Chars fields
675
 
676
      function Copy_List (List : List_Id) return List_Id;
677
      --  Copy list
678
 
679
      function Possible_Copy (Field : Union_Id) return Union_Id;
680
      --  Given a field, returns a copy of the node or list if its parent
681
      --  is the current source node, and otherwise returns the input
682
 
683
      -----------------
684
      -- Copy_Entity --
685
      -----------------
686
 
687
      function Copy_Entity (E : Entity_Id) return Entity_Id is
688
         New_Ent : Entity_Id;
689
 
690
      begin
691
         case N_Entity (Nkind (E)) is
692
            when N_Defining_Identifier =>
693
               New_Ent := New_Entity (N_Defining_Identifier, Sloc (E));
694
 
695
            when N_Defining_Character_Literal =>
696
               New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E));
697
 
698
            when N_Defining_Operator_Symbol =>
699
               New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E));
700
         end case;
701
 
702
         Set_Chars (New_Ent, Chars (E));
703
         return New_Ent;
704
      end Copy_Entity;
705
 
706
      ---------------
707
      -- Copy_List --
708
      ---------------
709
 
710
      function Copy_List (List : List_Id) return List_Id is
711
         NL : List_Id;
712
         E  : Node_Id;
713
 
714
      begin
715
         if List = No_List then
716
            return No_List;
717
 
718
         else
719
            NL := New_List;
720
 
721
            E := First (List);
722
            while Present (E) loop
723
               if Has_Extension (E) then
724
                  Append (Copy_Entity (E), NL);
725
               else
726
                  Append (Copy_Separate_Tree (E), NL);
727
               end if;
728
 
729
               Next (E);
730
            end loop;
731
 
732
            return NL;
733
         end if;
734
      end Copy_List;
735
 
736
      -------------------
737
      -- Possible_Copy --
738
      -------------------
739
 
740
      function Possible_Copy (Field : Union_Id) return Union_Id is
741
         New_N : Union_Id;
742
 
743
      begin
744
         if Field in Node_Range then
745
            New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field)));
746
 
747
            if Parent (Node_Id (Field)) = Source then
748
               Set_Parent (Node_Id (New_N), New_Id);
749
            end if;
750
 
751
            return New_N;
752
 
753
         elsif Field in List_Range then
754
            New_N := Union_Id (Copy_List (List_Id (Field)));
755
 
756
            if Parent (List_Id (Field)) = Source then
757
               Set_Parent (List_Id (New_N), New_Id);
758
            end if;
759
 
760
            return New_N;
761
 
762
         else
763
            return Field;
764
         end if;
765
      end Possible_Copy;
766
 
767
   --  Start of processing for Copy_Separate_Tree
768
 
769
   begin
770
      if Source <= Empty_Or_Error then
771
         return Source;
772
 
773
      elsif Has_Extension (Source) then
774
         return Copy_Entity (Source);
775
 
776
      else
777
         New_Id := New_Copy (Source);
778
 
779
         --  Recursively copy descendents
780
 
781
         Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id)));
782
         Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id)));
783
         Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id)));
784
         Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id)));
785
         Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id)));
786
 
787
         --  Set Entity field to Empty to ensure that no entity references
788
         --  are shared between the two, if the source is already analyzed.
789
 
790
         if Nkind (New_Id) in N_Has_Entity
791
           or else Nkind (New_Id) = N_Freeze_Entity
792
         then
793
            Set_Entity (New_Id, Empty);
794
         end if;
795
 
796
         --  All done, return copied node
797
 
798
         return New_Id;
799
      end if;
800
   end Copy_Separate_Tree;
801
 
802
   -----------
803
   -- Ekind --
804
   -----------
805
 
806
   function Ekind (E : Entity_Id) return Entity_Kind is
807
   begin
808
      pragma Assert (Nkind (E) in N_Entity);
809
      return N_To_E (Nodes.Table (E + 1).Nkind);
810
   end Ekind;
811
 
812
   --------------
813
   -- Ekind_In --
814
   --------------
815
 
816
   function Ekind_In
817
     (T  : Entity_Kind;
818
      V1 : Entity_Kind;
819
      V2 : Entity_Kind) return Boolean
820
   is
821
   begin
822
      return T = V1 or else
823
             T = V2;
824
   end Ekind_In;
825
 
826
   function Ekind_In
827
     (T  : Entity_Kind;
828
      V1 : Entity_Kind;
829
      V2 : Entity_Kind;
830
      V3 : Entity_Kind) return Boolean
831
   is
832
   begin
833
      return T = V1 or else
834
             T = V2 or else
835
             T = V3;
836
   end Ekind_In;
837
 
838
   function Ekind_In
839
     (T  : Entity_Kind;
840
      V1 : Entity_Kind;
841
      V2 : Entity_Kind;
842
      V3 : Entity_Kind;
843
      V4 : Entity_Kind) return Boolean
844
   is
845
   begin
846
      return T = V1 or else
847
             T = V2 or else
848
             T = V3 or else
849
             T = V4;
850
   end Ekind_In;
851
 
852
   function Ekind_In
853
     (T  : Entity_Kind;
854
      V1 : Entity_Kind;
855
      V2 : Entity_Kind;
856
      V3 : Entity_Kind;
857
      V4 : Entity_Kind;
858
      V5 : Entity_Kind) return Boolean
859
   is
860
   begin
861
      return T = V1 or else
862
             T = V2 or else
863
             T = V3 or else
864
             T = V4 or else
865
             T = V5;
866
   end Ekind_In;
867
 
868
   function Ekind_In
869
     (T  : Entity_Kind;
870
      V1 : Entity_Kind;
871
      V2 : Entity_Kind;
872
      V3 : Entity_Kind;
873
      V4 : Entity_Kind;
874
      V5 : Entity_Kind;
875
      V6 : Entity_Kind) return Boolean
876
   is
877
   begin
878
      return T = V1 or else
879
             T = V2 or else
880
             T = V3 or else
881
             T = V4 or else
882
             T = V5 or else
883
             T = V6;
884
   end Ekind_In;
885
 
886
   function Ekind_In
887
     (E  : Entity_Id;
888
      V1 : Entity_Kind;
889
      V2 : Entity_Kind) return Boolean
890
   is
891
   begin
892
      return Ekind_In (Ekind (E), V1, V2);
893
   end Ekind_In;
894
 
895
   function Ekind_In
896
     (E  : Entity_Id;
897
      V1 : Entity_Kind;
898
      V2 : Entity_Kind;
899
      V3 : Entity_Kind) return Boolean
900
   is
901
   begin
902
      return Ekind_In (Ekind (E), V1, V2, V3);
903
   end Ekind_In;
904
 
905
   function Ekind_In
906
     (E  : Entity_Id;
907
      V1 : Entity_Kind;
908
      V2 : Entity_Kind;
909
      V3 : Entity_Kind;
910
      V4 : Entity_Kind) return Boolean
911
   is
912
   begin
913
      return Ekind_In (Ekind (E), V1, V2, V3, V4);
914
   end Ekind_In;
915
 
916
   function Ekind_In
917
     (E  : Entity_Id;
918
      V1 : Entity_Kind;
919
      V2 : Entity_Kind;
920
      V3 : Entity_Kind;
921
      V4 : Entity_Kind;
922
      V5 : Entity_Kind) return Boolean
923
   is
924
   begin
925
      return Ekind_In (Ekind (E), V1, V2, V3, V4, V5);
926
   end Ekind_In;
927
 
928
   function Ekind_In
929
     (E  : Entity_Id;
930
      V1 : Entity_Kind;
931
      V2 : Entity_Kind;
932
      V3 : Entity_Kind;
933
      V4 : Entity_Kind;
934
      V5 : Entity_Kind;
935
      V6 : Entity_Kind) return Boolean
936
   is
937
   begin
938
      return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6);
939
   end Ekind_In;
940
 
941
   ------------------------
942
   -- Set_Reporting_Proc --
943
   ------------------------
944
 
945
   procedure Set_Reporting_Proc (P : Report_Proc) is
946
   begin
947
      pragma Assert (Reporting_Proc = null);
948
      Reporting_Proc := P;
949
   end Set_Reporting_Proc;
950
 
951
   ------------------
952
   -- Error_Posted --
953
   ------------------
954
 
955
   function Error_Posted (N : Node_Id) return Boolean is
956
   begin
957
      pragma Assert (N <= Nodes.Last);
958
      return Nodes.Table (N).Error_Posted;
959
   end Error_Posted;
960
 
961
   -----------------------
962
   -- Exchange_Entities --
963
   -----------------------
964
 
965
   procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is
966
      Temp_Ent : Node_Record;
967
 
968
   begin
969
      pragma Assert (Has_Extension (E1)
970
        and then Has_Extension (E2)
971
        and then not Nodes.Table (E1).In_List
972
        and then not Nodes.Table (E2).In_List);
973
 
974
      --  Exchange the contents of the two entities
975
 
976
      Temp_Ent := Nodes.Table (E1);
977
      Nodes.Table (E1) := Nodes.Table (E2);
978
      Nodes.Table (E2) := Temp_Ent;
979
      Temp_Ent := Nodes.Table (E1 + 1);
980
      Nodes.Table (E1 + 1) := Nodes.Table (E2 + 1);
981
      Nodes.Table (E2 + 1) := Temp_Ent;
982
      Temp_Ent := Nodes.Table (E1 + 2);
983
      Nodes.Table (E1 + 2) := Nodes.Table (E2 + 2);
984
      Nodes.Table (E2 + 2) := Temp_Ent;
985
      Temp_Ent := Nodes.Table (E1 + 3);
986
      Nodes.Table (E1 + 3) := Nodes.Table (E2 + 3);
987
      Nodes.Table (E2 + 3) := Temp_Ent;
988
      Temp_Ent := Nodes.Table (E1 + 4);
989
      Nodes.Table (E1 + 4) := Nodes.Table (E2 + 4);
990
      Nodes.Table (E2 + 4) := Temp_Ent;
991
 
992
      --  That exchange exchanged the parent pointers as well, which is what
993
      --  we want, but we need to patch up the defining identifier pointers
994
      --  in the parent nodes (the child pointers) to match this switch
995
      --  unless for Implicit types entities which have no parent, in which
996
      --  case we don't do anything otherwise we won't be able to revert back
997
      --  to the original situation.
998
 
999
      --  Shouldn't this use Is_Itype instead of the Parent test
1000
 
1001
      if Present (Parent (E1)) and then Present (Parent (E2)) then
1002
         Set_Defining_Identifier (Parent (E1), E1);
1003
         Set_Defining_Identifier (Parent (E2), E2);
1004
      end if;
1005
   end Exchange_Entities;
1006
 
1007
   -----------------
1008
   -- Extend_Node --
1009
   -----------------
1010
 
1011
   function Extend_Node (Node : Node_Id) return Entity_Id is
1012
      Result : Entity_Id;
1013
 
1014
      procedure Debug_Extend_Node;
1015
      pragma Inline (Debug_Extend_Node);
1016
      --  Debug routine for debug flag N
1017
 
1018
      -----------------------
1019
      -- Debug_Extend_Node --
1020
      -----------------------
1021
 
1022
      procedure Debug_Extend_Node is
1023
      begin
1024
         if Debug_Flag_N then
1025
            Write_Str ("Extend node ");
1026
            Write_Int (Int (Node));
1027
 
1028
            if Result = Node then
1029
               Write_Str (" in place");
1030
            else
1031
               Write_Str (" copied to ");
1032
               Write_Int (Int (Result));
1033
            end if;
1034
 
1035
            --  Write_Eol;
1036
         end if;
1037
      end Debug_Extend_Node;
1038
 
1039
   --  Start of processing for Extend_Node
1040
 
1041
   begin
1042
      pragma Assert (not (Has_Extension (Node)));
1043
      Result := Allocate_Initialize_Node (Node, With_Extension => True);
1044
      pragma Debug (Debug_Extend_Node);
1045
      return Result;
1046
   end Extend_Node;
1047
 
1048
   -----------------
1049
   -- Fix_Parents --
1050
   -----------------
1051
 
1052
   procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id) is
1053
 
1054
      procedure Fix_Parent (Field : Union_Id);
1055
      --  Fixup one parent pointer. Field is checked to see if it points to
1056
      --  a node, list, or element list that has a parent that points to
1057
      --  Ref_Node. If so, the parent is reset to point to Fix_Node.
1058
 
1059
      ----------------
1060
      -- Fix_Parent --
1061
      ----------------
1062
 
1063
      procedure Fix_Parent (Field : Union_Id) is
1064
      begin
1065
         --  Fix parent of node that is referenced by Field. Note that we must
1066
         --  exclude the case where the node is a member of a list, because in
1067
         --  this case the parent is the parent of the list.
1068
 
1069
         if Field in Node_Range
1070
           and then Present (Node_Id (Field))
1071
           and then not Nodes.Table (Node_Id (Field)).In_List
1072
           and then Parent (Node_Id (Field)) = Ref_Node
1073
         then
1074
            Set_Parent (Node_Id (Field), Fix_Node);
1075
 
1076
         --  Fix parent of list that is referenced by Field
1077
 
1078
         elsif Field in List_Range
1079
           and then Present (List_Id (Field))
1080
           and then Parent (List_Id (Field)) = Ref_Node
1081
         then
1082
            Set_Parent (List_Id (Field), Fix_Node);
1083
         end if;
1084
      end Fix_Parent;
1085
 
1086
   --  Start of processing for Fix_Parents
1087
 
1088
   begin
1089
      Fix_Parent (Field1 (Fix_Node));
1090
      Fix_Parent (Field2 (Fix_Node));
1091
      Fix_Parent (Field3 (Fix_Node));
1092
      Fix_Parent (Field4 (Fix_Node));
1093
      Fix_Parent (Field5 (Fix_Node));
1094
   end Fix_Parents;
1095
 
1096
   -----------------------------------
1097
   -- Get_Comes_From_Source_Default --
1098
   -----------------------------------
1099
 
1100
   function Get_Comes_From_Source_Default return Boolean is
1101
   begin
1102
      return Default_Node.Comes_From_Source;
1103
   end Get_Comes_From_Source_Default;
1104
 
1105
   -----------------
1106
   -- Has_Aspects --
1107
   -----------------
1108
 
1109
   function Has_Aspects (N : Node_Id) return Boolean is
1110
   begin
1111
      pragma Assert (N <= Nodes.Last);
1112
      return Nodes.Table (N).Has_Aspects;
1113
   end Has_Aspects;
1114
 
1115
   -------------------
1116
   -- Has_Extension --
1117
   -------------------
1118
 
1119
   function Has_Extension (N : Node_Id) return Boolean is
1120
   begin
1121
      return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension;
1122
   end Has_Extension;
1123
 
1124
   ----------------
1125
   -- Initialize --
1126
   ----------------
1127
 
1128
   procedure Initialize is
1129
      Dummy : Node_Id;
1130
      pragma Warnings (Off, Dummy);
1131
 
1132
   begin
1133
      Node_Count := 0;
1134
      Atree_Private_Part.Nodes.Init;
1135
      Orig_Nodes.Init;
1136
      Paren_Counts.Init;
1137
 
1138
      --  Allocate Empty node
1139
 
1140
      Dummy := New_Node (N_Empty, No_Location);
1141
      Set_Name1 (Empty, No_Name);
1142
 
1143
      --  Allocate Error node, and set Error_Posted, since we certainly
1144
      --  only generate an Error node if we do post some kind of error!
1145
 
1146
      Dummy := New_Node (N_Error, No_Location);
1147
      Set_Name1 (Error, Error_Name);
1148
      Set_Error_Posted (Error, True);
1149
   end Initialize;
1150
 
1151
   --------------------------
1152
   -- Is_Rewrite_Insertion --
1153
   --------------------------
1154
 
1155
   function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is
1156
   begin
1157
      return Nodes.Table (Node).Rewrite_Ins;
1158
   end Is_Rewrite_Insertion;
1159
 
1160
   -----------------------------
1161
   -- Is_Rewrite_Substitution --
1162
   -----------------------------
1163
 
1164
   function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is
1165
   begin
1166
      return Orig_Nodes.Table (Node) /= Node;
1167
   end Is_Rewrite_Substitution;
1168
 
1169
   ------------------
1170
   -- Last_Node_Id --
1171
   ------------------
1172
 
1173
   function Last_Node_Id return Node_Id is
1174
   begin
1175
      return Nodes.Last;
1176
   end Last_Node_Id;
1177
 
1178
   ----------
1179
   -- Lock --
1180
   ----------
1181
 
1182
   procedure Lock is
1183
   begin
1184
      Nodes.Locked := True;
1185
      Orig_Nodes.Locked := True;
1186
      Nodes.Release;
1187
      Orig_Nodes.Release;
1188
   end Lock;
1189
 
1190
   ----------------------------
1191
   -- Mark_Rewrite_Insertion --
1192
   ----------------------------
1193
 
1194
   procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is
1195
   begin
1196
      Nodes.Table (New_Node).Rewrite_Ins := True;
1197
   end Mark_Rewrite_Insertion;
1198
 
1199
   --------------
1200
   -- New_Copy --
1201
   --------------
1202
 
1203
   function New_Copy (Source : Node_Id) return Node_Id is
1204
      New_Id : Node_Id := Source;
1205
 
1206
   begin
1207
      if Source > Empty_Or_Error then
1208
         New_Id := Allocate_Initialize_Node (Source, Has_Extension (Source));
1209
 
1210
         Nodes.Table (New_Id).Link := Empty_List_Or_Node;
1211
         Nodes.Table (New_Id).In_List := False;
1212
 
1213
         --  If the original is marked as a rewrite insertion, then unmark the
1214
         --  copy, since we inserted the original, not the copy.
1215
 
1216
         Nodes.Table (New_Id).Rewrite_Ins := False;
1217
         pragma Debug (New_Node_Debugging_Output (New_Id));
1218
 
1219
         --  Clear Is_Overloaded since we cannot have semantic interpretations
1220
         --  of this new node.
1221
 
1222
         if Nkind (Source) in N_Subexpr then
1223
            Set_Is_Overloaded (New_Id, False);
1224
         end if;
1225
 
1226
         --  Always clear Has_Aspects, the caller must take care of copying
1227
         --  aspects if this is required for the particular situation.
1228
 
1229
         Set_Has_Aspects (New_Id, False);
1230
      end if;
1231
 
1232
      return New_Id;
1233
   end New_Copy;
1234
 
1235
   ----------------
1236
   -- New_Entity --
1237
   ----------------
1238
 
1239
   function New_Entity
1240
     (New_Node_Kind : Node_Kind;
1241
      New_Sloc      : Source_Ptr) return Entity_Id
1242
   is
1243
      Ent : Entity_Id;
1244
 
1245
   begin
1246
      pragma Assert (New_Node_Kind in N_Entity);
1247
 
1248
      Ent := Allocate_Initialize_Node (Empty, With_Extension => True);
1249
 
1250
      --  If this is a node with a real location and we are generating
1251
      --  source nodes, then reset Current_Error_Node. This is useful
1252
      --  if we bomb during parsing to get a error location for the bomb.
1253
 
1254
      if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1255
         Current_Error_Node := Ent;
1256
      end if;
1257
 
1258
      Nodes.Table (Ent).Nkind  := New_Node_Kind;
1259
      Nodes.Table (Ent).Sloc   := New_Sloc;
1260
      pragma Debug (New_Node_Debugging_Output (Ent));
1261
 
1262
      return Ent;
1263
   end New_Entity;
1264
 
1265
   --------------
1266
   -- New_Node --
1267
   --------------
1268
 
1269
   function New_Node
1270
     (New_Node_Kind : Node_Kind;
1271
      New_Sloc      : Source_Ptr) return Node_Id
1272
   is
1273
      Nod : Node_Id;
1274
 
1275
   begin
1276
      pragma Assert (New_Node_Kind not in N_Entity);
1277
      Nod := Allocate_Initialize_Node (Empty, With_Extension => False);
1278
      Nodes.Table (Nod).Nkind := New_Node_Kind;
1279
      Nodes.Table (Nod).Sloc  := New_Sloc;
1280
      pragma Debug (New_Node_Debugging_Output (Nod));
1281
 
1282
      --  If this is a node with a real location and we are generating source
1283
      --  nodes, then reset Current_Error_Node. This is useful if we bomb
1284
      --  during parsing to get an error location for the bomb.
1285
 
1286
      if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1287
         Current_Error_Node := Nod;
1288
      end if;
1289
 
1290
      return Nod;
1291
   end New_Node;
1292
 
1293
   -------------------------
1294
   -- New_Node_Breakpoint --
1295
   -------------------------
1296
 
1297
   procedure nn is
1298
   begin
1299
      Write_Str ("Watched node ");
1300
      Write_Int (Int (Watch_Node));
1301
      Write_Str (" created");
1302
      Write_Eol;
1303
   end nn;
1304
 
1305
   -------------------------------
1306
   -- New_Node_Debugging_Output --
1307
   -------------------------------
1308
 
1309
   procedure nnd (N : Node_Id) is
1310
      Node_Is_Watched : constant Boolean := N = Watch_Node;
1311
 
1312
   begin
1313
      if Debug_Flag_N or else Node_Is_Watched then
1314
         Node_Debug_Output ("Allocate", N);
1315
 
1316
         if Node_Is_Watched then
1317
            New_Node_Breakpoint;
1318
         end if;
1319
      end if;
1320
   end nnd;
1321
 
1322
   -----------
1323
   -- Nkind --
1324
   -----------
1325
 
1326
   function Nkind (N : Node_Id) return Node_Kind is
1327
   begin
1328
      return Nodes.Table (N).Nkind;
1329
   end Nkind;
1330
 
1331
   --------------
1332
   -- Nkind_In --
1333
   --------------
1334
 
1335
   function Nkind_In
1336
     (N  : Node_Id;
1337
      V1 : Node_Kind;
1338
      V2 : Node_Kind) return Boolean
1339
   is
1340
   begin
1341
      return Nkind_In (Nkind (N), V1, V2);
1342
   end Nkind_In;
1343
 
1344
   function Nkind_In
1345
     (N  : Node_Id;
1346
      V1 : Node_Kind;
1347
      V2 : Node_Kind;
1348
      V3 : Node_Kind) return Boolean
1349
   is
1350
   begin
1351
      return Nkind_In (Nkind (N), V1, V2, V3);
1352
   end Nkind_In;
1353
 
1354
   function Nkind_In
1355
     (N  : Node_Id;
1356
      V1 : Node_Kind;
1357
      V2 : Node_Kind;
1358
      V3 : Node_Kind;
1359
      V4 : Node_Kind) return Boolean
1360
   is
1361
   begin
1362
      return Nkind_In (Nkind (N), V1, V2, V3, V4);
1363
   end Nkind_In;
1364
 
1365
   function Nkind_In
1366
     (N  : Node_Id;
1367
      V1 : Node_Kind;
1368
      V2 : Node_Kind;
1369
      V3 : Node_Kind;
1370
      V4 : Node_Kind;
1371
      V5 : Node_Kind) return Boolean
1372
   is
1373
   begin
1374
      return Nkind_In (Nkind (N), V1, V2, V3, V4, V5);
1375
   end Nkind_In;
1376
 
1377
   function Nkind_In
1378
     (N  : Node_Id;
1379
      V1 : Node_Kind;
1380
      V2 : Node_Kind;
1381
      V3 : Node_Kind;
1382
      V4 : Node_Kind;
1383
      V5 : Node_Kind;
1384
      V6 : Node_Kind) return Boolean
1385
   is
1386
   begin
1387
      return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6);
1388
   end Nkind_In;
1389
 
1390
   function Nkind_In
1391
     (N  : Node_Id;
1392
      V1 : Node_Kind;
1393
      V2 : Node_Kind;
1394
      V3 : Node_Kind;
1395
      V4 : Node_Kind;
1396
      V5 : Node_Kind;
1397
      V6 : Node_Kind;
1398
      V7 : Node_Kind) return Boolean
1399
   is
1400
   begin
1401
      return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7);
1402
   end Nkind_In;
1403
 
1404
   function Nkind_In
1405
     (N  : Node_Id;
1406
      V1 : Node_Kind;
1407
      V2 : Node_Kind;
1408
      V3 : Node_Kind;
1409
      V4 : Node_Kind;
1410
      V5 : Node_Kind;
1411
      V6 : Node_Kind;
1412
      V7 : Node_Kind;
1413
      V8 : Node_Kind) return Boolean
1414
   is
1415
   begin
1416
      return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8);
1417
   end Nkind_In;
1418
 
1419
   function Nkind_In
1420
     (N  : Node_Id;
1421
      V1 : Node_Kind;
1422
      V2 : Node_Kind;
1423
      V3 : Node_Kind;
1424
      V4 : Node_Kind;
1425
      V5 : Node_Kind;
1426
      V6 : Node_Kind;
1427
      V7 : Node_Kind;
1428
      V8 : Node_Kind;
1429
      V9 : Node_Kind) return Boolean
1430
   is
1431
   begin
1432
      return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8, V9);
1433
   end Nkind_In;
1434
 
1435
   --------
1436
   -- No --
1437
   --------
1438
 
1439
   function No (N : Node_Id) return Boolean is
1440
   begin
1441
      return N = Empty;
1442
   end No;
1443
 
1444
   -----------------------
1445
   -- Node_Debug_Output --
1446
   -----------------------
1447
 
1448
   procedure Node_Debug_Output (Op : String; N : Node_Id) is
1449
   begin
1450
      Write_Str (Op);
1451
 
1452
      if Nkind (N) in N_Entity then
1453
         Write_Str (" entity");
1454
      else
1455
         Write_Str (" node");
1456
      end if;
1457
 
1458
      Write_Str (" Id = ");
1459
      Write_Int (Int (N));
1460
      Write_Str ("  ");
1461
      Write_Location (Sloc (N));
1462
      Write_Str ("  ");
1463
      Write_Str (Node_Kind'Image (Nkind (N)));
1464
      Write_Eol;
1465
   end Node_Debug_Output;
1466
 
1467
   -------------------
1468
   -- Nodes_Address --
1469
   -------------------
1470
 
1471
   function Nodes_Address return System.Address is
1472
   begin
1473
      return Nodes.Table (First_Node_Id)'Address;
1474
   end Nodes_Address;
1475
 
1476
   ---------------
1477
   -- Num_Nodes --
1478
   ---------------
1479
 
1480
   function Num_Nodes return Nat is
1481
   begin
1482
      return Node_Count;
1483
   end Num_Nodes;
1484
 
1485
   -------------------
1486
   -- Original_Node --
1487
   -------------------
1488
 
1489
   function Original_Node (Node : Node_Id) return Node_Id is
1490
   begin
1491
      return Orig_Nodes.Table (Node);
1492
   end Original_Node;
1493
 
1494
   -----------------
1495
   -- Paren_Count --
1496
   -----------------
1497
 
1498
   function Paren_Count (N : Node_Id) return Nat is
1499
      C : Nat := 0;
1500
 
1501
   begin
1502
      pragma Assert (N <= Nodes.Last);
1503
 
1504
      if Nodes.Table (N).Pflag1 then
1505
         C := C + 1;
1506
      end if;
1507
 
1508
      if Nodes.Table (N).Pflag2 then
1509
         C := C + 2;
1510
      end if;
1511
 
1512
      --  Value of 0,1,2 returned as is
1513
 
1514
      if C <= 2 then
1515
         return C;
1516
 
1517
      --  Value of 3 means we search the table, and we must find an entry
1518
 
1519
      else
1520
         for J in Paren_Counts.First .. Paren_Counts.Last loop
1521
            if N = Paren_Counts.Table (J).Nod then
1522
               return Paren_Counts.Table (J).Count;
1523
            end if;
1524
         end loop;
1525
 
1526
         raise Program_Error;
1527
      end if;
1528
   end Paren_Count;
1529
 
1530
   ------------
1531
   -- Parent --
1532
   ------------
1533
 
1534
   function Parent (N : Node_Id) return Node_Id is
1535
   begin
1536
      if Is_List_Member (N) then
1537
         return Parent (List_Containing (N));
1538
      else
1539
         return Node_Id (Nodes.Table (N).Link);
1540
      end if;
1541
   end Parent;
1542
 
1543
   -------------
1544
   -- Present --
1545
   -------------
1546
 
1547
   function Present (N : Node_Id) return Boolean is
1548
   begin
1549
      return N /= Empty;
1550
   end Present;
1551
 
1552
   --------------------------------
1553
   -- Preserve_Comes_From_Source --
1554
   --------------------------------
1555
 
1556
   procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is
1557
   begin
1558
      Nodes.Table (NewN).Comes_From_Source :=
1559
        Nodes.Table (OldN).Comes_From_Source;
1560
   end Preserve_Comes_From_Source;
1561
 
1562
   -------------------
1563
   -- Relocate_Node --
1564
   -------------------
1565
 
1566
   function Relocate_Node (Source : Node_Id) return Node_Id is
1567
      New_Node : Node_Id;
1568
 
1569
   begin
1570
      if No (Source) then
1571
         return Empty;
1572
      end if;
1573
 
1574
      New_Node := New_Copy (Source);
1575
      Fix_Parents (Ref_Node => Source, Fix_Node => New_Node);
1576
 
1577
      --  We now set the parent of the new node to be the same as the
1578
      --  parent of the source. Almost always this parent will be
1579
      --  replaced by a new value when the relocated node is reattached
1580
      --  to the tree, but by doing it now, we ensure that this node is
1581
      --  not even temporarily disconnected from the tree. Note that this
1582
      --  does not happen free, because in the list case, the parent does
1583
      --  not get set.
1584
 
1585
      Set_Parent (New_Node, Parent (Source));
1586
 
1587
      --  If the node being relocated was a rewriting of some original
1588
      --  node, then the relocated node has the same original node.
1589
 
1590
      if Orig_Nodes.Table (Source) /= Source then
1591
         Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source);
1592
      end if;
1593
 
1594
      return New_Node;
1595
   end Relocate_Node;
1596
 
1597
   -------------
1598
   -- Replace --
1599
   -------------
1600
 
1601
   procedure Replace (Old_Node, New_Node : Node_Id) is
1602
      Old_Post : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
1603
      Old_HasA : constant Boolean := Nodes.Table (Old_Node).Has_Aspects;
1604
      Old_CFS  : constant Boolean := Nodes.Table (Old_Node).Comes_From_Source;
1605
 
1606
   begin
1607
      pragma Assert
1608
        (not Has_Extension (Old_Node)
1609
          and not Has_Extension (New_Node)
1610
          and not Nodes.Table (New_Node).In_List);
1611
 
1612
      --  Do copy, preserving link and in list status and required flags
1613
 
1614
      Copy_Node (Source => New_Node, Destination => Old_Node);
1615
      Nodes.Table (Old_Node).Comes_From_Source := Old_CFS;
1616
      Nodes.Table (Old_Node).Error_Posted      := Old_Post;
1617
      Nodes.Table (Old_Node).Has_Aspects       := Old_HasA;
1618
 
1619
      --  Fix parents of substituted node, since it has changed identity
1620
 
1621
      Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1622
 
1623
      --  Since we are doing a replace, we assume that the original node
1624
      --  is intended to become the new replaced node. The call would be
1625
      --  to Rewrite if there were an intention to save the original node.
1626
 
1627
      Orig_Nodes.Table (Old_Node) := Old_Node;
1628
 
1629
      --  Invoke the reporting procedure (if available)
1630
 
1631
      if Reporting_Proc /= null then
1632
         Reporting_Proc.all (Target => Old_Node, Source => New_Node);
1633
      end if;
1634
   end Replace;
1635
 
1636
   -------------
1637
   -- Rewrite --
1638
   -------------
1639
 
1640
   procedure Rewrite (Old_Node, New_Node : Node_Id) is
1641
      Old_Error_P : constant Boolean  := Nodes.Table (Old_Node).Error_Posted;
1642
      --  This field is always preserved in the new node
1643
 
1644
      Old_Has_Aspects : constant Boolean := Nodes.Table (Old_Node).Has_Aspects;
1645
      --  This field is always preserved in the new node
1646
 
1647
      Old_Paren_Count     : Nat;
1648
      Old_Must_Not_Freeze : Boolean;
1649
      --  These fields are preserved in the new node only if the new node
1650
      --  and the old node are both subexpression nodes.
1651
 
1652
      --  Note: it is a violation of abstraction levels for Must_Not_Freeze
1653
      --  to be referenced like this. ???
1654
 
1655
      Sav_Node : Node_Id;
1656
 
1657
   begin
1658
      pragma Assert
1659
        (not Has_Extension (Old_Node)
1660
          and not Has_Extension (New_Node)
1661
          and not Nodes.Table (New_Node).In_List);
1662
      pragma Debug (Rewrite_Debugging_Output (Old_Node, New_Node));
1663
 
1664
      if Nkind (Old_Node) in N_Subexpr then
1665
         Old_Paren_Count     := Paren_Count (Old_Node);
1666
         Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node);
1667
      else
1668
         Old_Paren_Count     := 0;
1669
         Old_Must_Not_Freeze := False;
1670
      end if;
1671
 
1672
      --  Allocate a new node, to be used to preserve the original contents
1673
      --  of the Old_Node, for possible later retrival by Original_Node and
1674
      --  make an entry in the Orig_Nodes table. This is only done if we have
1675
      --  not already rewritten the node, as indicated by an Orig_Nodes entry
1676
      --  that does not reference the Old_Node.
1677
 
1678
      if Orig_Nodes.Table (Old_Node) = Old_Node then
1679
         Sav_Node := New_Copy (Old_Node);
1680
         Orig_Nodes.Table (Sav_Node) := Sav_Node;
1681
         Orig_Nodes.Table (Old_Node) := Sav_Node;
1682
 
1683
         --  Both the old and new copies of the node will share the same list
1684
         --  of aspect specifications if aspect specifications are present.
1685
 
1686
         if Has_Aspects (Sav_Node) then
1687
            Set_Has_Aspects (Sav_Node, False);
1688
            Set_Aspect_Specifications
1689
              (Sav_Node, Aspect_Specifications (Old_Node));
1690
         end if;
1691
      end if;
1692
 
1693
      --  Copy substitute node into place, preserving old fields as required
1694
 
1695
      Copy_Node (Source => New_Node, Destination => Old_Node);
1696
      Nodes.Table (Old_Node).Error_Posted := Old_Error_P;
1697
      Nodes.Table (Old_Node).Has_Aspects  := Old_Has_Aspects;
1698
 
1699
      if Nkind (New_Node) in N_Subexpr then
1700
         Set_Paren_Count     (Old_Node, Old_Paren_Count);
1701
         Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze);
1702
      end if;
1703
 
1704
      Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1705
 
1706
      --  Invoke the reporting procedure (if available)
1707
 
1708
      if Reporting_Proc /= null then
1709
         Reporting_Proc.all (Target => Old_Node, Source => New_Node);
1710
      end if;
1711
   end Rewrite;
1712
 
1713
   -------------------------
1714
   -- Rewrite_Breakpoint --
1715
   -------------------------
1716
 
1717
   procedure rr is
1718
   begin
1719
      Write_Str ("Watched node ");
1720
      Write_Int (Int (Watch_Node));
1721
      Write_Str (" rewritten");
1722
      Write_Eol;
1723
   end rr;
1724
 
1725
   ------------------------------
1726
   -- Rewrite_Debugging_Output --
1727
   ------------------------------
1728
 
1729
   procedure rrd (Old_Node, New_Node : Node_Id) is
1730
      Node_Is_Watched : constant Boolean := Old_Node = Watch_Node;
1731
 
1732
   begin
1733
      if Debug_Flag_N or else Node_Is_Watched then
1734
         Node_Debug_Output ("Rewrite", Old_Node);
1735
         Node_Debug_Output ("into",    New_Node);
1736
 
1737
         if Node_Is_Watched then
1738
            Rewrite_Breakpoint;
1739
         end if;
1740
      end if;
1741
   end rrd;
1742
 
1743
   ------------------
1744
   -- Set_Analyzed --
1745
   ------------------
1746
 
1747
   procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is
1748
   begin
1749
      Nodes.Table (N).Analyzed := Val;
1750
   end Set_Analyzed;
1751
 
1752
   ---------------------------
1753
   -- Set_Comes_From_Source --
1754
   ---------------------------
1755
 
1756
   procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is
1757
   begin
1758
      pragma Assert (N <= Nodes.Last);
1759
      Nodes.Table (N).Comes_From_Source := Val;
1760
   end Set_Comes_From_Source;
1761
 
1762
   -----------------------------------
1763
   -- Set_Comes_From_Source_Default --
1764
   -----------------------------------
1765
 
1766
   procedure Set_Comes_From_Source_Default (Default : Boolean) is
1767
   begin
1768
      Default_Node.Comes_From_Source := Default;
1769
   end Set_Comes_From_Source_Default;
1770
 
1771
   ---------------
1772
   -- Set_Ekind --
1773
   ---------------
1774
 
1775
   procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is
1776
   begin
1777
      pragma Assert (Nkind (E) in N_Entity);
1778
      Nodes.Table (E + 1).Nkind := E_To_N (Val);
1779
   end Set_Ekind;
1780
 
1781
   ----------------------
1782
   -- Set_Error_Posted --
1783
   ----------------------
1784
 
1785
   procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is
1786
   begin
1787
      Nodes.Table (N).Error_Posted := Val;
1788
   end Set_Error_Posted;
1789
 
1790
   ---------------------
1791
   -- Set_Has_Aspects --
1792
   ---------------------
1793
 
1794
   procedure Set_Has_Aspects (N : Node_Id; Val : Boolean := True) is
1795
   begin
1796
      pragma Assert (N <= Nodes.Last);
1797
      Nodes.Table (N).Has_Aspects := Val;
1798
   end Set_Has_Aspects;
1799
 
1800
   -----------------------
1801
   -- Set_Original_Node --
1802
   -----------------------
1803
 
1804
   procedure Set_Original_Node (N : Node_Id; Val : Node_Id) is
1805
   begin
1806
      Orig_Nodes.Table (N) := Val;
1807
   end Set_Original_Node;
1808
 
1809
   ---------------------
1810
   -- Set_Paren_Count --
1811
   ---------------------
1812
 
1813
   procedure Set_Paren_Count (N : Node_Id; Val : Nat) is
1814
   begin
1815
      pragma Assert (Nkind (N) in N_Subexpr);
1816
 
1817
      --  Value of 0,1,2 stored as is
1818
 
1819
      if Val <= 2 then
1820
         Nodes.Table (N).Pflag1 := (Val mod 2 /= 0);
1821
         Nodes.Table (N).Pflag2 := (Val = 2);
1822
 
1823
      --  Value of 3 or greater stores 3 in node and makes table entry
1824
 
1825
      else
1826
         Nodes.Table (N).Pflag1 := True;
1827
         Nodes.Table (N).Pflag2 := True;
1828
 
1829
         for J in Paren_Counts.First .. Paren_Counts.Last loop
1830
            if N = Paren_Counts.Table (J).Nod then
1831
               Paren_Counts.Table (J).Count := Val;
1832
               return;
1833
            end if;
1834
         end loop;
1835
 
1836
         Paren_Counts.Append ((Nod => N, Count => Val));
1837
      end if;
1838
   end Set_Paren_Count;
1839
 
1840
   ----------------
1841
   -- Set_Parent --
1842
   ----------------
1843
 
1844
   procedure Set_Parent (N : Node_Id; Val : Node_Id) is
1845
   begin
1846
      pragma Assert (not Nodes.Table (N).In_List);
1847
      Nodes.Table (N).Link := Union_Id (Val);
1848
   end Set_Parent;
1849
 
1850
   --------------
1851
   -- Set_Sloc --
1852
   --------------
1853
 
1854
   procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is
1855
   begin
1856
      Nodes.Table (N).Sloc := Val;
1857
   end Set_Sloc;
1858
 
1859
   ----------
1860
   -- Sloc --
1861
   ----------
1862
 
1863
   function Sloc (N : Node_Id) return Source_Ptr is
1864
   begin
1865
      return Nodes.Table (N).Sloc;
1866
   end Sloc;
1867
 
1868
   -------------------
1869
   -- Traverse_Func --
1870
   -------------------
1871
 
1872
   function Traverse_Func (Node : Node_Id) return Traverse_Final_Result is
1873
 
1874
      function Traverse_Field
1875
        (Nod : Node_Id;
1876
         Fld : Union_Id;
1877
         FN  : Field_Num) return Traverse_Final_Result;
1878
      --  Fld is one of the fields of Nod. If the field points to syntactic
1879
      --  node or list, then this node or list is traversed, and the result is
1880
      --  the result of this traversal. Otherwise a value of True is returned
1881
      --  with no processing. FN is the number of the field (1 .. 5).
1882
 
1883
      --------------------
1884
      -- Traverse_Field --
1885
      --------------------
1886
 
1887
      function Traverse_Field
1888
        (Nod : Node_Id;
1889
         Fld : Union_Id;
1890
         FN  : Field_Num) return Traverse_Final_Result
1891
      is
1892
      begin
1893
         if Fld = Union_Id (Empty) then
1894
            return OK;
1895
 
1896
         --  Descendent is a node
1897
 
1898
         elsif Fld in Node_Range then
1899
 
1900
            --  Traverse descendent that is syntactic subtree node
1901
 
1902
            if Is_Syntactic_Field (Nkind (Nod), FN) then
1903
               return Traverse_Func (Node_Id (Fld));
1904
 
1905
            --  Node that is not a syntactic subtree
1906
 
1907
            else
1908
               return OK;
1909
            end if;
1910
 
1911
         --  Descendent is a list
1912
 
1913
         elsif Fld in List_Range then
1914
 
1915
            --  Traverse descendent that is a syntactic subtree list
1916
 
1917
            if Is_Syntactic_Field (Nkind (Nod), FN) then
1918
               declare
1919
                  Elmt : Node_Id := First (List_Id (Fld));
1920
               begin
1921
                  while Present (Elmt) loop
1922
                     if Traverse_Func (Elmt) = Abandon then
1923
                        return Abandon;
1924
                     else
1925
                        Next (Elmt);
1926
                     end if;
1927
                  end loop;
1928
 
1929
                  return OK;
1930
               end;
1931
 
1932
            --  List that is not a syntactic subtree
1933
 
1934
            else
1935
               return OK;
1936
            end if;
1937
 
1938
         --  Field was not a node or a list
1939
 
1940
         else
1941
            return OK;
1942
         end if;
1943
      end Traverse_Field;
1944
 
1945
      Cur_Node : Node_Id := Node;
1946
 
1947
   --  Start of processing for Traverse_Func
1948
 
1949
   begin
1950
      --  We walk Field2 last, and if it is a node, we eliminate the tail
1951
      --  recursion by jumping back to this label. This is because Field2 is
1952
      --  where the Left_Opnd field of N_Op_Concat is stored, and in practice
1953
      --  concatenations are sometimes deeply nested, as in X1&X2&...&XN. This
1954
      --  trick prevents us from running out of memory in that case. We don't
1955
      --  bother eliminating the tail recursion if Field2 is a list.
1956
 
1957
      <<Tail_Recurse>>
1958
 
1959
      case Process (Cur_Node) is
1960
         when Abandon =>
1961
            return Abandon;
1962
 
1963
         when Skip =>
1964
            return OK;
1965
 
1966
         when OK =>
1967
            null;
1968
 
1969
         when OK_Orig =>
1970
            Cur_Node := Original_Node (Cur_Node);
1971
      end case;
1972
 
1973
      if Traverse_Field (Cur_Node, Field1 (Cur_Node), 1) = Abandon
1974
           or else  --  skip Field2 here
1975
         Traverse_Field (Cur_Node, Field3 (Cur_Node), 3) = Abandon
1976
           or else
1977
         Traverse_Field (Cur_Node, Field4 (Cur_Node), 4) = Abandon
1978
           or else
1979
         Traverse_Field (Cur_Node, Field5 (Cur_Node), 5) = Abandon
1980
      then
1981
         return Abandon;
1982
      end if;
1983
 
1984
      if Field2 (Cur_Node) not in Node_Range then
1985
         return Traverse_Field (Cur_Node, Field2 (Cur_Node), 2);
1986
 
1987
      elsif Is_Syntactic_Field (Nkind (Cur_Node), 2)
1988
        and then Field2 (Cur_Node) /= Empty_List_Or_Node
1989
      then
1990
         --  Here is the tail recursion step, we reset Cur_Node and jump back
1991
         --  to the start of the procedure, which has the same semantic effect
1992
         --  as a call.
1993
 
1994
         Cur_Node := Node_Id (Field2 (Cur_Node));
1995
         goto Tail_Recurse;
1996
      end if;
1997
 
1998
      return OK;
1999
   end Traverse_Func;
2000
 
2001
   -------------------
2002
   -- Traverse_Proc --
2003
   -------------------
2004
 
2005
   procedure Traverse_Proc (Node : Node_Id) is
2006
      function Traverse is new Traverse_Func (Process);
2007
      Discard : Traverse_Final_Result;
2008
      pragma Warnings (Off, Discard);
2009
   begin
2010
      Discard := Traverse (Node);
2011
   end Traverse_Proc;
2012
 
2013
   ---------------
2014
   -- Tree_Read --
2015
   ---------------
2016
 
2017
   procedure Tree_Read is
2018
   begin
2019
      Tree_Read_Int (Node_Count);
2020
      Nodes.Tree_Read;
2021
      Orig_Nodes.Tree_Read;
2022
      Paren_Counts.Tree_Read;
2023
   end Tree_Read;
2024
 
2025
   ----------------
2026
   -- Tree_Write --
2027
   ----------------
2028
 
2029
   procedure Tree_Write is
2030
   begin
2031
      Tree_Write_Int (Node_Count);
2032
      Nodes.Tree_Write;
2033
      Orig_Nodes.Tree_Write;
2034
      Paren_Counts.Tree_Write;
2035
   end Tree_Write;
2036
 
2037
   ------------------------------
2038
   -- Unchecked Access Package --
2039
   ------------------------------
2040
 
2041
   package body Unchecked_Access is
2042
 
2043
      function Field1 (N : Node_Id) return Union_Id is
2044
      begin
2045
         pragma Assert (N <= Nodes.Last);
2046
         return Nodes.Table (N).Field1;
2047
      end Field1;
2048
 
2049
      function Field2 (N : Node_Id) return Union_Id is
2050
      begin
2051
         pragma Assert (N <= Nodes.Last);
2052
         return Nodes.Table (N).Field2;
2053
      end Field2;
2054
 
2055
      function Field3 (N : Node_Id) return Union_Id is
2056
      begin
2057
         pragma Assert (N <= Nodes.Last);
2058
         return Nodes.Table (N).Field3;
2059
      end Field3;
2060
 
2061
      function Field4 (N : Node_Id) return Union_Id is
2062
      begin
2063
         pragma Assert (N <= Nodes.Last);
2064
         return Nodes.Table (N).Field4;
2065
      end Field4;
2066
 
2067
      function Field5 (N : Node_Id) return Union_Id is
2068
      begin
2069
         pragma Assert (N <= Nodes.Last);
2070
         return Nodes.Table (N).Field5;
2071
      end Field5;
2072
 
2073
      function Field6 (N : Node_Id) return Union_Id is
2074
      begin
2075
         pragma Assert (Nkind (N) in N_Entity);
2076
         return Nodes.Table (N + 1).Field6;
2077
      end Field6;
2078
 
2079
      function Field7 (N : Node_Id) return Union_Id is
2080
      begin
2081
         pragma Assert (Nkind (N) in N_Entity);
2082
         return Nodes.Table (N + 1).Field7;
2083
      end Field7;
2084
 
2085
      function Field8 (N : Node_Id) return Union_Id is
2086
      begin
2087
         pragma Assert (Nkind (N) in N_Entity);
2088
         return Nodes.Table (N + 1).Field8;
2089
      end Field8;
2090
 
2091
      function Field9 (N : Node_Id) return Union_Id is
2092
      begin
2093
         pragma Assert (Nkind (N) in N_Entity);
2094
         return Nodes.Table (N + 1).Field9;
2095
      end Field9;
2096
 
2097
      function Field10 (N : Node_Id) return Union_Id is
2098
      begin
2099
         pragma Assert (Nkind (N) in N_Entity);
2100
         return Nodes.Table (N + 1).Field10;
2101
      end Field10;
2102
 
2103
      function Field11 (N : Node_Id) return Union_Id is
2104
      begin
2105
         pragma Assert (Nkind (N) in N_Entity);
2106
         return Nodes.Table (N + 1).Field11;
2107
      end Field11;
2108
 
2109
      function Field12 (N : Node_Id) return Union_Id is
2110
      begin
2111
         pragma Assert (Nkind (N) in N_Entity);
2112
         return Nodes.Table (N + 1).Field12;
2113
      end Field12;
2114
 
2115
      function Field13 (N : Node_Id) return Union_Id is
2116
      begin
2117
         pragma Assert (Nkind (N) in N_Entity);
2118
         return Nodes.Table (N + 2).Field6;
2119
      end Field13;
2120
 
2121
      function Field14 (N : Node_Id) return Union_Id is
2122
      begin
2123
         pragma Assert (Nkind (N) in N_Entity);
2124
         return Nodes.Table (N + 2).Field7;
2125
      end Field14;
2126
 
2127
      function Field15 (N : Node_Id) return Union_Id is
2128
      begin
2129
         pragma Assert (Nkind (N) in N_Entity);
2130
         return Nodes.Table (N + 2).Field8;
2131
      end Field15;
2132
 
2133
      function Field16 (N : Node_Id) return Union_Id is
2134
      begin
2135
         pragma Assert (Nkind (N) in N_Entity);
2136
         return Nodes.Table (N + 2).Field9;
2137
      end Field16;
2138
 
2139
      function Field17 (N : Node_Id) return Union_Id is
2140
      begin
2141
         pragma Assert (Nkind (N) in N_Entity);
2142
         return Nodes.Table (N + 2).Field10;
2143
      end Field17;
2144
 
2145
      function Field18 (N : Node_Id) return Union_Id is
2146
      begin
2147
         pragma Assert (Nkind (N) in N_Entity);
2148
         return Nodes.Table (N + 2).Field11;
2149
      end Field18;
2150
 
2151
      function Field19 (N : Node_Id) return Union_Id is
2152
      begin
2153
         pragma Assert (Nkind (N) in N_Entity);
2154
         return Nodes.Table (N + 3).Field6;
2155
      end Field19;
2156
 
2157
      function Field20 (N : Node_Id) return Union_Id is
2158
      begin
2159
         pragma Assert (Nkind (N) in N_Entity);
2160
         return Nodes.Table (N + 3).Field7;
2161
      end Field20;
2162
 
2163
      function Field21 (N : Node_Id) return Union_Id is
2164
      begin
2165
         pragma Assert (Nkind (N) in N_Entity);
2166
         return Nodes.Table (N + 3).Field8;
2167
      end Field21;
2168
 
2169
      function Field22 (N : Node_Id) return Union_Id is
2170
      begin
2171
         pragma Assert (Nkind (N) in N_Entity);
2172
         return Nodes.Table (N + 3).Field9;
2173
      end Field22;
2174
 
2175
      function Field23 (N : Node_Id) return Union_Id is
2176
      begin
2177
         pragma Assert (Nkind (N) in N_Entity);
2178
         return Nodes.Table (N + 3).Field10;
2179
      end Field23;
2180
 
2181
      function Field24 (N : Node_Id) return Union_Id is
2182
      begin
2183
         pragma Assert (Nkind (N) in N_Entity);
2184
         return Nodes.Table (N + 4).Field6;
2185
      end Field24;
2186
 
2187
      function Field25 (N : Node_Id) return Union_Id is
2188
      begin
2189
         pragma Assert (Nkind (N) in N_Entity);
2190
         return Nodes.Table (N + 4).Field7;
2191
      end Field25;
2192
 
2193
      function Field26 (N : Node_Id) return Union_Id is
2194
      begin
2195
         pragma Assert (Nkind (N) in N_Entity);
2196
         return Nodes.Table (N + 4).Field8;
2197
      end Field26;
2198
 
2199
      function Field27 (N : Node_Id) return Union_Id is
2200
      begin
2201
         pragma Assert (Nkind (N) in N_Entity);
2202
         return Nodes.Table (N + 4).Field9;
2203
      end Field27;
2204
 
2205
      function Field28 (N : Node_Id) return Union_Id is
2206
      begin
2207
         pragma Assert (Nkind (N) in N_Entity);
2208
         return Nodes.Table (N + 4).Field10;
2209
      end Field28;
2210
 
2211
      function Field29 (N : Node_Id) return Union_Id is
2212
      begin
2213
         pragma Assert (Nkind (N) in N_Entity);
2214
         return Nodes.Table (N + 4).Field11;
2215
      end Field29;
2216
 
2217
      function Node1 (N : Node_Id) return Node_Id is
2218
      begin
2219
         pragma Assert (N <= Nodes.Last);
2220
         return Node_Id (Nodes.Table (N).Field1);
2221
      end Node1;
2222
 
2223
      function Node2 (N : Node_Id) return Node_Id is
2224
      begin
2225
         pragma Assert (N <= Nodes.Last);
2226
         return Node_Id (Nodes.Table (N).Field2);
2227
      end Node2;
2228
 
2229
      function Node3 (N : Node_Id) return Node_Id is
2230
      begin
2231
         pragma Assert (N <= Nodes.Last);
2232
         return Node_Id (Nodes.Table (N).Field3);
2233
      end Node3;
2234
 
2235
      function Node4 (N : Node_Id) return Node_Id is
2236
      begin
2237
         pragma Assert (N <= Nodes.Last);
2238
         return Node_Id (Nodes.Table (N).Field4);
2239
      end Node4;
2240
 
2241
      function Node5 (N : Node_Id) return Node_Id is
2242
      begin
2243
         pragma Assert (N <= Nodes.Last);
2244
         return Node_Id (Nodes.Table (N).Field5);
2245
      end Node5;
2246
 
2247
      function Node6 (N : Node_Id) return Node_Id is
2248
      begin
2249
         pragma Assert (Nkind (N) in N_Entity);
2250
         return Node_Id (Nodes.Table (N + 1).Field6);
2251
      end Node6;
2252
 
2253
      function Node7 (N : Node_Id) return Node_Id is
2254
      begin
2255
         pragma Assert (Nkind (N) in N_Entity);
2256
         return Node_Id (Nodes.Table (N + 1).Field7);
2257
      end Node7;
2258
 
2259
      function Node8 (N : Node_Id) return Node_Id is
2260
      begin
2261
         pragma Assert (Nkind (N) in N_Entity);
2262
         return Node_Id (Nodes.Table (N + 1).Field8);
2263
      end Node8;
2264
 
2265
      function Node9 (N : Node_Id) return Node_Id is
2266
      begin
2267
         pragma Assert (Nkind (N) in N_Entity);
2268
         return Node_Id (Nodes.Table (N + 1).Field9);
2269
      end Node9;
2270
 
2271
      function Node10 (N : Node_Id) return Node_Id is
2272
      begin
2273
         pragma Assert (Nkind (N) in N_Entity);
2274
         return Node_Id (Nodes.Table (N + 1).Field10);
2275
      end Node10;
2276
 
2277
      function Node11 (N : Node_Id) return Node_Id is
2278
      begin
2279
         pragma Assert (Nkind (N) in N_Entity);
2280
         return Node_Id (Nodes.Table (N + 1).Field11);
2281
      end Node11;
2282
 
2283
      function Node12 (N : Node_Id) return Node_Id is
2284
      begin
2285
         pragma Assert (Nkind (N) in N_Entity);
2286
         return Node_Id (Nodes.Table (N + 1).Field12);
2287
      end Node12;
2288
 
2289
      function Node13 (N : Node_Id) return Node_Id is
2290
      begin
2291
         pragma Assert (Nkind (N) in N_Entity);
2292
         return Node_Id (Nodes.Table (N + 2).Field6);
2293
      end Node13;
2294
 
2295
      function Node14 (N : Node_Id) return Node_Id is
2296
      begin
2297
         pragma Assert (Nkind (N) in N_Entity);
2298
         return Node_Id (Nodes.Table (N + 2).Field7);
2299
      end Node14;
2300
 
2301
      function Node15 (N : Node_Id) return Node_Id is
2302
      begin
2303
         pragma Assert (Nkind (N) in N_Entity);
2304
         return Node_Id (Nodes.Table (N + 2).Field8);
2305
      end Node15;
2306
 
2307
      function Node16 (N : Node_Id) return Node_Id is
2308
      begin
2309
         pragma Assert (Nkind (N) in N_Entity);
2310
         return Node_Id (Nodes.Table (N + 2).Field9);
2311
      end Node16;
2312
 
2313
      function Node17 (N : Node_Id) return Node_Id is
2314
      begin
2315
         pragma Assert (Nkind (N) in N_Entity);
2316
         return Node_Id (Nodes.Table (N + 2).Field10);
2317
      end Node17;
2318
 
2319
      function Node18 (N : Node_Id) return Node_Id is
2320
      begin
2321
         pragma Assert (Nkind (N) in N_Entity);
2322
         return Node_Id (Nodes.Table (N + 2).Field11);
2323
      end Node18;
2324
 
2325
      function Node19 (N : Node_Id) return Node_Id is
2326
      begin
2327
         pragma Assert (Nkind (N) in N_Entity);
2328
         return Node_Id (Nodes.Table (N + 3).Field6);
2329
      end Node19;
2330
 
2331
      function Node20 (N : Node_Id) return Node_Id is
2332
      begin
2333
         pragma Assert (Nkind (N) in N_Entity);
2334
         return Node_Id (Nodes.Table (N + 3).Field7);
2335
      end Node20;
2336
 
2337
      function Node21 (N : Node_Id) return Node_Id is
2338
      begin
2339
         pragma Assert (Nkind (N) in N_Entity);
2340
         return Node_Id (Nodes.Table (N + 3).Field8);
2341
      end Node21;
2342
 
2343
      function Node22 (N : Node_Id) return Node_Id is
2344
      begin
2345
         pragma Assert (Nkind (N) in N_Entity);
2346
         return Node_Id (Nodes.Table (N + 3).Field9);
2347
      end Node22;
2348
 
2349
      function Node23 (N : Node_Id) return Node_Id is
2350
      begin
2351
         pragma Assert (Nkind (N) in N_Entity);
2352
         return Node_Id (Nodes.Table (N + 3).Field10);
2353
      end Node23;
2354
 
2355
      function Node24 (N : Node_Id) return Node_Id is
2356
      begin
2357
         pragma Assert (Nkind (N) in N_Entity);
2358
         return Node_Id (Nodes.Table (N + 4).Field6);
2359
      end Node24;
2360
 
2361
      function Node25 (N : Node_Id) return Node_Id is
2362
      begin
2363
         pragma Assert (Nkind (N) in N_Entity);
2364
         return Node_Id (Nodes.Table (N + 4).Field7);
2365
      end Node25;
2366
 
2367
      function Node26 (N : Node_Id) return Node_Id is
2368
      begin
2369
         pragma Assert (Nkind (N) in N_Entity);
2370
         return Node_Id (Nodes.Table (N + 4).Field8);
2371
      end Node26;
2372
 
2373
      function Node27 (N : Node_Id) return Node_Id is
2374
      begin
2375
         pragma Assert (Nkind (N) in N_Entity);
2376
         return Node_Id (Nodes.Table (N + 4).Field9);
2377
      end Node27;
2378
 
2379
      function Node28 (N : Node_Id) return Node_Id is
2380
      begin
2381
         pragma Assert (Nkind (N) in N_Entity);
2382
         return Node_Id (Nodes.Table (N + 4).Field10);
2383
      end Node28;
2384
 
2385
      function Node29 (N : Node_Id) return Node_Id is
2386
      begin
2387
         pragma Assert (Nkind (N) in N_Entity);
2388
         return Node_Id (Nodes.Table (N + 4).Field11);
2389
      end Node29;
2390
 
2391
      function List1 (N : Node_Id) return List_Id is
2392
      begin
2393
         pragma Assert (N <= Nodes.Last);
2394
         return List_Id (Nodes.Table (N).Field1);
2395
      end List1;
2396
 
2397
      function List2 (N : Node_Id) return List_Id is
2398
      begin
2399
         pragma Assert (N <= Nodes.Last);
2400
         return List_Id (Nodes.Table (N).Field2);
2401
      end List2;
2402
 
2403
      function List3 (N : Node_Id) return List_Id is
2404
      begin
2405
         pragma Assert (N <= Nodes.Last);
2406
         return List_Id (Nodes.Table (N).Field3);
2407
      end List3;
2408
 
2409
      function List4 (N : Node_Id) return List_Id is
2410
      begin
2411
         pragma Assert (N <= Nodes.Last);
2412
         return List_Id (Nodes.Table (N).Field4);
2413
      end List4;
2414
 
2415
      function List5 (N : Node_Id) return List_Id is
2416
      begin
2417
         pragma Assert (N <= Nodes.Last);
2418
         return List_Id (Nodes.Table (N).Field5);
2419
      end List5;
2420
 
2421
      function List10 (N : Node_Id) return List_Id is
2422
      begin
2423
         pragma Assert (Nkind (N) in N_Entity);
2424
         return List_Id (Nodes.Table (N + 1).Field10);
2425
      end List10;
2426
 
2427
      function List14 (N : Node_Id) return List_Id is
2428
      begin
2429
         pragma Assert (Nkind (N) in N_Entity);
2430
         return List_Id (Nodes.Table (N + 2).Field7);
2431
      end List14;
2432
 
2433
      function List25 (N : Node_Id) return List_Id is
2434
      begin
2435
         pragma Assert (Nkind (N) in N_Entity);
2436
         return List_Id (Nodes.Table (N + 4).Field7);
2437
      end List25;
2438
 
2439
      function Elist1 (N : Node_Id) return Elist_Id is
2440
         pragma Assert (N <= Nodes.Last);
2441
         Value : constant Union_Id := Nodes.Table (N).Field1;
2442
      begin
2443
         if Value = 0 then
2444
            return No_Elist;
2445
         else
2446
            return Elist_Id (Value);
2447
         end if;
2448
      end Elist1;
2449
 
2450
      function Elist2 (N : Node_Id) return Elist_Id is
2451
         pragma Assert (N <= Nodes.Last);
2452
         Value : constant Union_Id := Nodes.Table (N).Field2;
2453
      begin
2454
         if Value = 0 then
2455
            return No_Elist;
2456
         else
2457
            return Elist_Id (Value);
2458
         end if;
2459
      end Elist2;
2460
 
2461
      function Elist3 (N : Node_Id) return Elist_Id is
2462
         pragma Assert (N <= Nodes.Last);
2463
         Value : constant Union_Id := Nodes.Table (N).Field3;
2464
      begin
2465
         if Value = 0 then
2466
            return No_Elist;
2467
         else
2468
            return Elist_Id (Value);
2469
         end if;
2470
      end Elist3;
2471
 
2472
      function Elist4 (N : Node_Id) return Elist_Id is
2473
         pragma Assert (N <= Nodes.Last);
2474
         Value : constant Union_Id := Nodes.Table (N).Field4;
2475
      begin
2476
         if Value = 0 then
2477
            return No_Elist;
2478
         else
2479
            return Elist_Id (Value);
2480
         end if;
2481
      end Elist4;
2482
 
2483
      function Elist5 (N : Node_Id) return Elist_Id is
2484
         pragma Assert (N <= Nodes.Last);
2485
         Value : constant Union_Id := Nodes.Table (N).Field5;
2486
      begin
2487
         if Value = 0 then
2488
            return No_Elist;
2489
         else
2490
            return Elist_Id (Value);
2491
         end if;
2492
      end Elist5;
2493
 
2494
      function Elist8 (N : Node_Id) return Elist_Id is
2495
         pragma Assert (Nkind (N) in N_Entity);
2496
         Value : constant Union_Id := Nodes.Table (N + 1).Field8;
2497
      begin
2498
         if Value = 0 then
2499
            return No_Elist;
2500
         else
2501
            return Elist_Id (Value);
2502
         end if;
2503
      end Elist8;
2504
 
2505
      function Elist10 (N : Node_Id) return Elist_Id is
2506
         pragma Assert (Nkind (N) in N_Entity);
2507
         Value : constant Union_Id := Nodes.Table (N + 1).Field10;
2508
      begin
2509
         if Value = 0 then
2510
            return No_Elist;
2511
         else
2512
            return Elist_Id (Value);
2513
         end if;
2514
      end Elist10;
2515
 
2516
      function Elist13 (N : Node_Id) return Elist_Id is
2517
         pragma Assert (Nkind (N) in N_Entity);
2518
         Value : constant Union_Id := Nodes.Table (N + 2).Field6;
2519
      begin
2520
         if Value = 0 then
2521
            return No_Elist;
2522
         else
2523
            return Elist_Id (Value);
2524
         end if;
2525
      end Elist13;
2526
 
2527
      function Elist15 (N : Node_Id) return Elist_Id is
2528
         pragma Assert (Nkind (N) in N_Entity);
2529
         Value : constant Union_Id := Nodes.Table (N + 2).Field8;
2530
      begin
2531
         if Value = 0 then
2532
            return No_Elist;
2533
         else
2534
            return Elist_Id (Value);
2535
         end if;
2536
      end Elist15;
2537
 
2538
      function Elist16 (N : Node_Id) return Elist_Id is
2539
         pragma Assert (Nkind (N) in N_Entity);
2540
         Value : constant Union_Id := Nodes.Table (N + 2).Field9;
2541
      begin
2542
         if Value = 0 then
2543
            return No_Elist;
2544
         else
2545
            return Elist_Id (Value);
2546
         end if;
2547
      end Elist16;
2548
 
2549
      function Elist18 (N : Node_Id) return Elist_Id is
2550
         pragma Assert (Nkind (N) in N_Entity);
2551
         Value : constant Union_Id := Nodes.Table (N + 2).Field11;
2552
      begin
2553
         if Value = 0 then
2554
            return No_Elist;
2555
         else
2556
            return Elist_Id (Value);
2557
         end if;
2558
      end Elist18;
2559
 
2560
      function Elist21 (N : Node_Id) return Elist_Id is
2561
         pragma Assert (Nkind (N) in N_Entity);
2562
         Value : constant Union_Id := Nodes.Table (N + 3).Field8;
2563
      begin
2564
         if Value = 0 then
2565
            return No_Elist;
2566
         else
2567
            return Elist_Id (Value);
2568
         end if;
2569
      end Elist21;
2570
 
2571
      function Elist23 (N : Node_Id) return Elist_Id is
2572
         pragma Assert (Nkind (N) in N_Entity);
2573
         Value : constant Union_Id := Nodes.Table (N + 3).Field10;
2574
      begin
2575
         if Value = 0 then
2576
            return No_Elist;
2577
         else
2578
            return Elist_Id (Value);
2579
         end if;
2580
      end Elist23;
2581
 
2582
      function Elist24 (N : Node_Id) return Elist_Id is
2583
         pragma Assert (Nkind (N) in N_Entity);
2584
         Value : constant Union_Id := Nodes.Table (N + 4).Field6;
2585
      begin
2586
         if Value = 0 then
2587
            return No_Elist;
2588
         else
2589
            return Elist_Id (Value);
2590
         end if;
2591
      end Elist24;
2592
 
2593
      function Elist25 (N : Node_Id) return Elist_Id is
2594
         pragma Assert (Nkind (N) in N_Entity);
2595
         Value : constant Union_Id := Nodes.Table (N + 4).Field7;
2596
      begin
2597
         if Value = 0 then
2598
            return No_Elist;
2599
         else
2600
            return Elist_Id (Value);
2601
         end if;
2602
      end Elist25;
2603
 
2604
      function Elist26 (N : Node_Id) return Elist_Id is
2605
         pragma Assert (Nkind (N) in N_Entity);
2606
         Value : constant Union_Id := Nodes.Table (N + 4).Field8;
2607
      begin
2608
         if Value = 0 then
2609
            return No_Elist;
2610
         else
2611
            return Elist_Id (Value);
2612
         end if;
2613
      end Elist26;
2614
 
2615
      function Name1 (N : Node_Id) return Name_Id is
2616
      begin
2617
         pragma Assert (N <= Nodes.Last);
2618
         return Name_Id (Nodes.Table (N).Field1);
2619
      end Name1;
2620
 
2621
      function Name2 (N : Node_Id) return Name_Id is
2622
      begin
2623
         pragma Assert (N <= Nodes.Last);
2624
         return Name_Id (Nodes.Table (N).Field2);
2625
      end Name2;
2626
 
2627
      function Str3 (N : Node_Id) return String_Id is
2628
      begin
2629
         pragma Assert (N <= Nodes.Last);
2630
         return String_Id (Nodes.Table (N).Field3);
2631
      end Str3;
2632
 
2633
      function Uint2 (N : Node_Id) return Uint is
2634
         pragma Assert (N <= Nodes.Last);
2635
         U : constant Union_Id := Nodes.Table (N).Field2;
2636
      begin
2637
         if U = 0 then
2638
            return Uint_0;
2639
         else
2640
            return From_Union (U);
2641
         end if;
2642
      end Uint2;
2643
 
2644
      function Uint3 (N : Node_Id) return Uint is
2645
         pragma Assert (N <= Nodes.Last);
2646
         U : constant Union_Id := Nodes.Table (N).Field3;
2647
      begin
2648
         if U = 0 then
2649
            return Uint_0;
2650
         else
2651
            return From_Union (U);
2652
         end if;
2653
      end Uint3;
2654
 
2655
      function Uint4 (N : Node_Id) return Uint is
2656
         pragma Assert (N <= Nodes.Last);
2657
         U : constant Union_Id := Nodes.Table (N).Field4;
2658
      begin
2659
         if U = 0 then
2660
            return Uint_0;
2661
         else
2662
            return From_Union (U);
2663
         end if;
2664
      end Uint4;
2665
 
2666
      function Uint5 (N : Node_Id) return Uint is
2667
         pragma Assert (N <= Nodes.Last);
2668
         U : constant Union_Id := Nodes.Table (N).Field5;
2669
      begin
2670
         if U = 0 then
2671
            return Uint_0;
2672
         else
2673
            return From_Union (U);
2674
         end if;
2675
      end Uint5;
2676
 
2677
      function Uint8 (N : Node_Id) return Uint is
2678
         pragma Assert (Nkind (N) in N_Entity);
2679
         U : constant Union_Id := Nodes.Table (N + 1).Field8;
2680
      begin
2681
         if U = 0 then
2682
            return Uint_0;
2683
         else
2684
            return From_Union (U);
2685
         end if;
2686
      end Uint8;
2687
 
2688
      function Uint9 (N : Node_Id) return Uint is
2689
         pragma Assert (Nkind (N) in N_Entity);
2690
         U : constant Union_Id := Nodes.Table (N + 1).Field9;
2691
      begin
2692
         if U = 0 then
2693
            return Uint_0;
2694
         else
2695
            return From_Union (U);
2696
         end if;
2697
      end Uint9;
2698
 
2699
      function Uint10 (N : Node_Id) return Uint is
2700
         pragma Assert (Nkind (N) in N_Entity);
2701
         U : constant Union_Id := Nodes.Table (N + 1).Field10;
2702
      begin
2703
         if U = 0 then
2704
            return Uint_0;
2705
         else
2706
            return From_Union (U);
2707
         end if;
2708
      end Uint10;
2709
 
2710
      function Uint11 (N : Node_Id) return Uint is
2711
         pragma Assert (Nkind (N) in N_Entity);
2712
         U : constant Union_Id := Nodes.Table (N + 1).Field11;
2713
      begin
2714
         if U = 0 then
2715
            return Uint_0;
2716
         else
2717
            return From_Union (U);
2718
         end if;
2719
      end Uint11;
2720
 
2721
      function Uint12 (N : Node_Id) return Uint is
2722
         pragma Assert (Nkind (N) in N_Entity);
2723
         U : constant Union_Id := Nodes.Table (N + 1).Field12;
2724
      begin
2725
         if U = 0 then
2726
            return Uint_0;
2727
         else
2728
            return From_Union (U);
2729
         end if;
2730
      end Uint12;
2731
 
2732
      function Uint13 (N : Node_Id) return Uint is
2733
         pragma Assert (Nkind (N) in N_Entity);
2734
         U : constant Union_Id := Nodes.Table (N + 2).Field6;
2735
      begin
2736
         if U = 0 then
2737
            return Uint_0;
2738
         else
2739
            return From_Union (U);
2740
         end if;
2741
      end Uint13;
2742
 
2743
      function Uint14 (N : Node_Id) return Uint is
2744
         pragma Assert (Nkind (N) in N_Entity);
2745
         U : constant Union_Id := Nodes.Table (N + 2).Field7;
2746
      begin
2747
         if U = 0 then
2748
            return Uint_0;
2749
         else
2750
            return From_Union (U);
2751
         end if;
2752
      end Uint14;
2753
 
2754
      function Uint15 (N : Node_Id) return Uint is
2755
         pragma Assert (Nkind (N) in N_Entity);
2756
         U : constant Union_Id := Nodes.Table (N + 2).Field8;
2757
      begin
2758
         if U = 0 then
2759
            return Uint_0;
2760
         else
2761
            return From_Union (U);
2762
         end if;
2763
      end Uint15;
2764
 
2765
      function Uint16 (N : Node_Id) return Uint is
2766
         pragma Assert (Nkind (N) in N_Entity);
2767
         U : constant Union_Id := Nodes.Table (N + 2).Field9;
2768
      begin
2769
         if U = 0 then
2770
            return Uint_0;
2771
         else
2772
            return From_Union (U);
2773
         end if;
2774
      end Uint16;
2775
 
2776
      function Uint17 (N : Node_Id) return Uint is
2777
         pragma Assert (Nkind (N) in N_Entity);
2778
         U : constant Union_Id := Nodes.Table (N + 2).Field10;
2779
      begin
2780
         if U = 0 then
2781
            return Uint_0;
2782
         else
2783
            return From_Union (U);
2784
         end if;
2785
      end Uint17;
2786
 
2787
      function Uint22 (N : Node_Id) return Uint is
2788
         pragma Assert (Nkind (N) in N_Entity);
2789
         U : constant Union_Id := Nodes.Table (N + 3).Field9;
2790
      begin
2791
         if U = 0 then
2792
            return Uint_0;
2793
         else
2794
            return From_Union (U);
2795
         end if;
2796
      end Uint22;
2797
 
2798
      function Ureal3 (N : Node_Id) return Ureal is
2799
      begin
2800
         pragma Assert (N <= Nodes.Last);
2801
         return From_Union (Nodes.Table (N).Field3);
2802
      end Ureal3;
2803
 
2804
      function Ureal18 (N : Node_Id) return Ureal is
2805
      begin
2806
         pragma Assert (Nkind (N) in N_Entity);
2807
         return From_Union (Nodes.Table (N + 2).Field11);
2808
      end Ureal18;
2809
 
2810
      function Ureal21 (N : Node_Id) return Ureal is
2811
      begin
2812
         pragma Assert (Nkind (N) in N_Entity);
2813
         return From_Union (Nodes.Table (N + 3).Field8);
2814
      end Ureal21;
2815
 
2816
      function Flag4 (N : Node_Id) return Boolean is
2817
      begin
2818
         pragma Assert (N <= Nodes.Last);
2819
         return Nodes.Table (N).Flag4;
2820
      end Flag4;
2821
 
2822
      function Flag5 (N : Node_Id) return Boolean is
2823
      begin
2824
         pragma Assert (N <= Nodes.Last);
2825
         return Nodes.Table (N).Flag5;
2826
      end Flag5;
2827
 
2828
      function Flag6 (N : Node_Id) return Boolean is
2829
      begin
2830
         pragma Assert (N <= Nodes.Last);
2831
         return Nodes.Table (N).Flag6;
2832
      end Flag6;
2833
 
2834
      function Flag7 (N : Node_Id) return Boolean is
2835
      begin
2836
         pragma Assert (N <= Nodes.Last);
2837
         return Nodes.Table (N).Flag7;
2838
      end Flag7;
2839
 
2840
      function Flag8 (N : Node_Id) return Boolean is
2841
      begin
2842
         pragma Assert (N <= Nodes.Last);
2843
         return Nodes.Table (N).Flag8;
2844
      end Flag8;
2845
 
2846
      function Flag9 (N : Node_Id) return Boolean is
2847
      begin
2848
         pragma Assert (N <= Nodes.Last);
2849
         return Nodes.Table (N).Flag9;
2850
      end Flag9;
2851
 
2852
      function Flag10 (N : Node_Id) return Boolean is
2853
      begin
2854
         pragma Assert (N <= Nodes.Last);
2855
         return Nodes.Table (N).Flag10;
2856
      end Flag10;
2857
 
2858
      function Flag11 (N : Node_Id) return Boolean is
2859
      begin
2860
         pragma Assert (N <= Nodes.Last);
2861
         return Nodes.Table (N).Flag11;
2862
      end Flag11;
2863
 
2864
      function Flag12 (N : Node_Id) return Boolean is
2865
      begin
2866
         pragma Assert (N <= Nodes.Last);
2867
         return Nodes.Table (N).Flag12;
2868
      end Flag12;
2869
 
2870
      function Flag13 (N : Node_Id) return Boolean is
2871
      begin
2872
         pragma Assert (N <= Nodes.Last);
2873
         return Nodes.Table (N).Flag13;
2874
      end Flag13;
2875
 
2876
      function Flag14 (N : Node_Id) return Boolean is
2877
      begin
2878
         pragma Assert (N <= Nodes.Last);
2879
         return Nodes.Table (N).Flag14;
2880
      end Flag14;
2881
 
2882
      function Flag15 (N : Node_Id) return Boolean is
2883
      begin
2884
         pragma Assert (N <= Nodes.Last);
2885
         return Nodes.Table (N).Flag15;
2886
      end Flag15;
2887
 
2888
      function Flag16 (N : Node_Id) return Boolean is
2889
      begin
2890
         pragma Assert (N <= Nodes.Last);
2891
         return Nodes.Table (N).Flag16;
2892
      end Flag16;
2893
 
2894
      function Flag17 (N : Node_Id) return Boolean is
2895
      begin
2896
         pragma Assert (N <= Nodes.Last);
2897
         return Nodes.Table (N).Flag17;
2898
      end Flag17;
2899
 
2900
      function Flag18 (N : Node_Id) return Boolean is
2901
      begin
2902
         pragma Assert (N <= Nodes.Last);
2903
         return Nodes.Table (N).Flag18;
2904
      end Flag18;
2905
 
2906
      function Flag19 (N : Node_Id) return Boolean is
2907
      begin
2908
         pragma Assert (Nkind (N) in N_Entity);
2909
         return Nodes.Table (N + 1).In_List;
2910
      end Flag19;
2911
 
2912
      function Flag20 (N : Node_Id) return Boolean is
2913
      begin
2914
         pragma Assert (Nkind (N) in N_Entity);
2915
         return Nodes.Table (N + 1).Has_Aspects;
2916
      end Flag20;
2917
 
2918
      function Flag21 (N : Node_Id) return Boolean is
2919
      begin
2920
         pragma Assert (Nkind (N) in N_Entity);
2921
         return Nodes.Table (N + 1).Rewrite_Ins;
2922
      end Flag21;
2923
 
2924
      function Flag22 (N : Node_Id) return Boolean is
2925
      begin
2926
         pragma Assert (Nkind (N) in N_Entity);
2927
         return Nodes.Table (N + 1).Analyzed;
2928
      end Flag22;
2929
 
2930
      function Flag23 (N : Node_Id) return Boolean is
2931
      begin
2932
         pragma Assert (Nkind (N) in N_Entity);
2933
         return Nodes.Table (N + 1).Comes_From_Source;
2934
      end Flag23;
2935
 
2936
      function Flag24 (N : Node_Id) return Boolean is
2937
      begin
2938
         pragma Assert (Nkind (N) in N_Entity);
2939
         return Nodes.Table (N + 1).Error_Posted;
2940
      end Flag24;
2941
 
2942
      function Flag25 (N : Node_Id) return Boolean is
2943
      begin
2944
         pragma Assert (Nkind (N) in N_Entity);
2945
         return Nodes.Table (N + 1).Flag4;
2946
      end Flag25;
2947
 
2948
      function Flag26 (N : Node_Id) return Boolean is
2949
      begin
2950
         pragma Assert (Nkind (N) in N_Entity);
2951
         return Nodes.Table (N + 1).Flag5;
2952
      end Flag26;
2953
 
2954
      function Flag27 (N : Node_Id) return Boolean is
2955
      begin
2956
         pragma Assert (Nkind (N) in N_Entity);
2957
         return Nodes.Table (N + 1).Flag6;
2958
      end Flag27;
2959
 
2960
      function Flag28 (N : Node_Id) return Boolean is
2961
      begin
2962
         pragma Assert (Nkind (N) in N_Entity);
2963
         return Nodes.Table (N + 1).Flag7;
2964
      end Flag28;
2965
 
2966
      function Flag29 (N : Node_Id) return Boolean is
2967
      begin
2968
         pragma Assert (Nkind (N) in N_Entity);
2969
         return Nodes.Table (N + 1).Flag8;
2970
      end Flag29;
2971
 
2972
      function Flag30 (N : Node_Id) return Boolean is
2973
      begin
2974
         pragma Assert (Nkind (N) in N_Entity);
2975
         return Nodes.Table (N + 1).Flag9;
2976
      end Flag30;
2977
 
2978
      function Flag31 (N : Node_Id) return Boolean is
2979
      begin
2980
         pragma Assert (Nkind (N) in N_Entity);
2981
         return Nodes.Table (N + 1).Flag10;
2982
      end Flag31;
2983
 
2984
      function Flag32 (N : Node_Id) return Boolean is
2985
      begin
2986
         pragma Assert (Nkind (N) in N_Entity);
2987
         return Nodes.Table (N + 1).Flag11;
2988
      end Flag32;
2989
 
2990
      function Flag33 (N : Node_Id) return Boolean is
2991
      begin
2992
         pragma Assert (Nkind (N) in N_Entity);
2993
         return Nodes.Table (N + 1).Flag12;
2994
      end Flag33;
2995
 
2996
      function Flag34 (N : Node_Id) return Boolean is
2997
      begin
2998
         pragma Assert (Nkind (N) in N_Entity);
2999
         return Nodes.Table (N + 1).Flag13;
3000
      end Flag34;
3001
 
3002
      function Flag35 (N : Node_Id) return Boolean is
3003
      begin
3004
         pragma Assert (Nkind (N) in N_Entity);
3005
         return Nodes.Table (N + 1).Flag14;
3006
      end Flag35;
3007
 
3008
      function Flag36 (N : Node_Id) return Boolean is
3009
      begin
3010
         pragma Assert (Nkind (N) in N_Entity);
3011
         return Nodes.Table (N + 1).Flag15;
3012
      end Flag36;
3013
 
3014
      function Flag37 (N : Node_Id) return Boolean is
3015
      begin
3016
         pragma Assert (Nkind (N) in N_Entity);
3017
         return Nodes.Table (N + 1).Flag16;
3018
      end Flag37;
3019
 
3020
      function Flag38 (N : Node_Id) return Boolean is
3021
      begin
3022
         pragma Assert (Nkind (N) in N_Entity);
3023
         return Nodes.Table (N + 1).Flag17;
3024
      end Flag38;
3025
 
3026
      function Flag39 (N : Node_Id) return Boolean is
3027
      begin
3028
         pragma Assert (Nkind (N) in N_Entity);
3029
         return Nodes.Table (N + 1).Flag18;
3030
      end Flag39;
3031
 
3032
      function Flag40 (N : Node_Id) return Boolean is
3033
      begin
3034
         pragma Assert (Nkind (N) in N_Entity);
3035
         return Nodes.Table (N + 2).In_List;
3036
      end Flag40;
3037
 
3038
      function Flag41 (N : Node_Id) return Boolean is
3039
      begin
3040
         pragma Assert (Nkind (N) in N_Entity);
3041
         return Nodes.Table (N + 2).Has_Aspects;
3042
      end Flag41;
3043
 
3044
      function Flag42 (N : Node_Id) return Boolean is
3045
      begin
3046
         pragma Assert (Nkind (N) in N_Entity);
3047
         return Nodes.Table (N + 2).Rewrite_Ins;
3048
      end Flag42;
3049
 
3050
      function Flag43 (N : Node_Id) return Boolean is
3051
      begin
3052
         pragma Assert (Nkind (N) in N_Entity);
3053
         return Nodes.Table (N + 2).Analyzed;
3054
      end Flag43;
3055
 
3056
      function Flag44 (N : Node_Id) return Boolean is
3057
      begin
3058
         pragma Assert (Nkind (N) in N_Entity);
3059
         return Nodes.Table (N + 2).Comes_From_Source;
3060
      end Flag44;
3061
 
3062
      function Flag45 (N : Node_Id) return Boolean is
3063
      begin
3064
         pragma Assert (Nkind (N) in N_Entity);
3065
         return Nodes.Table (N + 2).Error_Posted;
3066
      end Flag45;
3067
 
3068
      function Flag46 (N : Node_Id) return Boolean is
3069
      begin
3070
         pragma Assert (Nkind (N) in N_Entity);
3071
         return Nodes.Table (N + 2).Flag4;
3072
      end Flag46;
3073
 
3074
      function Flag47 (N : Node_Id) return Boolean is
3075
      begin
3076
         pragma Assert (Nkind (N) in N_Entity);
3077
         return Nodes.Table (N + 2).Flag5;
3078
      end Flag47;
3079
 
3080
      function Flag48 (N : Node_Id) return Boolean is
3081
      begin
3082
         pragma Assert (Nkind (N) in N_Entity);
3083
         return Nodes.Table (N + 2).Flag6;
3084
      end Flag48;
3085
 
3086
      function Flag49 (N : Node_Id) return Boolean is
3087
      begin
3088
         pragma Assert (Nkind (N) in N_Entity);
3089
         return Nodes.Table (N + 2).Flag7;
3090
      end Flag49;
3091
 
3092
      function Flag50 (N : Node_Id) return Boolean is
3093
      begin
3094
         pragma Assert (Nkind (N) in N_Entity);
3095
         return Nodes.Table (N + 2).Flag8;
3096
      end Flag50;
3097
 
3098
      function Flag51 (N : Node_Id) return Boolean is
3099
      begin
3100
         pragma Assert (Nkind (N) in N_Entity);
3101
         return Nodes.Table (N + 2).Flag9;
3102
      end Flag51;
3103
 
3104
      function Flag52 (N : Node_Id) return Boolean is
3105
      begin
3106
         pragma Assert (Nkind (N) in N_Entity);
3107
         return Nodes.Table (N + 2).Flag10;
3108
      end Flag52;
3109
 
3110
      function Flag53 (N : Node_Id) return Boolean is
3111
      begin
3112
         pragma Assert (Nkind (N) in N_Entity);
3113
         return Nodes.Table (N + 2).Flag11;
3114
      end Flag53;
3115
 
3116
      function Flag54 (N : Node_Id) return Boolean is
3117
      begin
3118
         pragma Assert (Nkind (N) in N_Entity);
3119
         return Nodes.Table (N + 2).Flag12;
3120
      end Flag54;
3121
 
3122
      function Flag55 (N : Node_Id) return Boolean is
3123
      begin
3124
         pragma Assert (Nkind (N) in N_Entity);
3125
         return Nodes.Table (N + 2).Flag13;
3126
      end Flag55;
3127
 
3128
      function Flag56 (N : Node_Id) return Boolean is
3129
      begin
3130
         pragma Assert (Nkind (N) in N_Entity);
3131
         return Nodes.Table (N + 2).Flag14;
3132
      end Flag56;
3133
 
3134
      function Flag57 (N : Node_Id) return Boolean is
3135
      begin
3136
         pragma Assert (Nkind (N) in N_Entity);
3137
         return Nodes.Table (N + 2).Flag15;
3138
      end Flag57;
3139
 
3140
      function Flag58 (N : Node_Id) return Boolean is
3141
      begin
3142
         pragma Assert (Nkind (N) in N_Entity);
3143
         return Nodes.Table (N + 2).Flag16;
3144
      end Flag58;
3145
 
3146
      function Flag59 (N : Node_Id) return Boolean is
3147
      begin
3148
         pragma Assert (Nkind (N) in N_Entity);
3149
         return Nodes.Table (N + 2).Flag17;
3150
      end Flag59;
3151
 
3152
      function Flag60 (N : Node_Id) return Boolean is
3153
      begin
3154
         pragma Assert (Nkind (N) in N_Entity);
3155
         return Nodes.Table (N + 2).Flag18;
3156
      end Flag60;
3157
 
3158
      function Flag61 (N : Node_Id) return Boolean is
3159
      begin
3160
         pragma Assert (Nkind (N) in N_Entity);
3161
         return Nodes.Table (N + 1).Pflag1;
3162
      end Flag61;
3163
 
3164
      function Flag62 (N : Node_Id) return Boolean is
3165
      begin
3166
         pragma Assert (Nkind (N) in N_Entity);
3167
         return Nodes.Table (N + 1).Pflag2;
3168
      end Flag62;
3169
 
3170
      function Flag63 (N : Node_Id) return Boolean is
3171
      begin
3172
         pragma Assert (Nkind (N) in N_Entity);
3173
         return Nodes.Table (N + 2).Pflag1;
3174
      end Flag63;
3175
 
3176
      function Flag64 (N : Node_Id) return Boolean is
3177
      begin
3178
         pragma Assert (Nkind (N) in N_Entity);
3179
         return Nodes.Table (N + 2).Pflag2;
3180
      end Flag64;
3181
 
3182
      function Flag65 (N : Node_Id) return Boolean is
3183
      begin
3184
         pragma Assert (Nkind (N) in N_Entity);
3185
         return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
3186
      end Flag65;
3187
 
3188
      function Flag66 (N : Node_Id) return Boolean is
3189
      begin
3190
         pragma Assert (Nkind (N) in N_Entity);
3191
         return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
3192
      end Flag66;
3193
 
3194
      function Flag67 (N : Node_Id) return Boolean is
3195
      begin
3196
         pragma Assert (Nkind (N) in N_Entity);
3197
         return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
3198
      end Flag67;
3199
 
3200
      function Flag68 (N : Node_Id) return Boolean is
3201
      begin
3202
         pragma Assert (Nkind (N) in N_Entity);
3203
         return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
3204
      end Flag68;
3205
 
3206
      function Flag69 (N : Node_Id) return Boolean is
3207
      begin
3208
         pragma Assert (Nkind (N) in N_Entity);
3209
         return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
3210
      end Flag69;
3211
 
3212
      function Flag70 (N : Node_Id) return Boolean is
3213
      begin
3214
         pragma Assert (Nkind (N) in N_Entity);
3215
         return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
3216
      end Flag70;
3217
 
3218
      function Flag71 (N : Node_Id) return Boolean is
3219
      begin
3220
         pragma Assert (Nkind (N) in N_Entity);
3221
         return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
3222
      end Flag71;
3223
 
3224
      function Flag72 (N : Node_Id) return Boolean is
3225
      begin
3226
         pragma Assert (Nkind (N) in N_Entity);
3227
         return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
3228
      end Flag72;
3229
 
3230
      function Flag73 (N : Node_Id) return Boolean is
3231
      begin
3232
         pragma Assert (Nkind (N) in N_Entity);
3233
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
3234
      end Flag73;
3235
 
3236
      function Flag74 (N : Node_Id) return Boolean is
3237
      begin
3238
         pragma Assert (Nkind (N) in N_Entity);
3239
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
3240
      end Flag74;
3241
 
3242
      function Flag75 (N : Node_Id) return Boolean is
3243
      begin
3244
         pragma Assert (Nkind (N) in N_Entity);
3245
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
3246
      end Flag75;
3247
 
3248
      function Flag76 (N : Node_Id) return Boolean is
3249
      begin
3250
         pragma Assert (Nkind (N) in N_Entity);
3251
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
3252
      end Flag76;
3253
 
3254
      function Flag77 (N : Node_Id) return Boolean is
3255
      begin
3256
         pragma Assert (Nkind (N) in N_Entity);
3257
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
3258
      end Flag77;
3259
 
3260
      function Flag78 (N : Node_Id) return Boolean is
3261
      begin
3262
         pragma Assert (Nkind (N) in N_Entity);
3263
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
3264
      end Flag78;
3265
 
3266
      function Flag79 (N : Node_Id) return Boolean is
3267
      begin
3268
         pragma Assert (Nkind (N) in N_Entity);
3269
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
3270
      end Flag79;
3271
 
3272
      function Flag80 (N : Node_Id) return Boolean is
3273
      begin
3274
         pragma Assert (Nkind (N) in N_Entity);
3275
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
3276
      end Flag80;
3277
 
3278
      function Flag81 (N : Node_Id) return Boolean is
3279
      begin
3280
         pragma Assert (Nkind (N) in N_Entity);
3281
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
3282
      end Flag81;
3283
 
3284
      function Flag82 (N : Node_Id) return Boolean is
3285
      begin
3286
         pragma Assert (Nkind (N) in N_Entity);
3287
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
3288
      end Flag82;
3289
 
3290
      function Flag83 (N : Node_Id) return Boolean is
3291
      begin
3292
         pragma Assert (Nkind (N) in N_Entity);
3293
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
3294
      end Flag83;
3295
 
3296
      function Flag84 (N : Node_Id) return Boolean is
3297
      begin
3298
         pragma Assert (Nkind (N) in N_Entity);
3299
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
3300
      end Flag84;
3301
 
3302
      function Flag85 (N : Node_Id) return Boolean is
3303
      begin
3304
         pragma Assert (Nkind (N) in N_Entity);
3305
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
3306
      end Flag85;
3307
 
3308
      function Flag86 (N : Node_Id) return Boolean is
3309
      begin
3310
         pragma Assert (Nkind (N) in N_Entity);
3311
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
3312
      end Flag86;
3313
 
3314
      function Flag87 (N : Node_Id) return Boolean is
3315
      begin
3316
         pragma Assert (Nkind (N) in N_Entity);
3317
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
3318
      end Flag87;
3319
 
3320
      function Flag88 (N : Node_Id) return Boolean is
3321
      begin
3322
         pragma Assert (Nkind (N) in N_Entity);
3323
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
3324
      end Flag88;
3325
 
3326
      function Flag89 (N : Node_Id) return Boolean is
3327
      begin
3328
         pragma Assert (Nkind (N) in N_Entity);
3329
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
3330
      end Flag89;
3331
 
3332
      function Flag90 (N : Node_Id) return Boolean is
3333
      begin
3334
         pragma Assert (Nkind (N) in N_Entity);
3335
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
3336
      end Flag90;
3337
 
3338
      function Flag91 (N : Node_Id) return Boolean is
3339
      begin
3340
         pragma Assert (Nkind (N) in N_Entity);
3341
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
3342
      end Flag91;
3343
 
3344
      function Flag92 (N : Node_Id) return Boolean is
3345
      begin
3346
         pragma Assert (Nkind (N) in N_Entity);
3347
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
3348
      end Flag92;
3349
 
3350
      function Flag93 (N : Node_Id) return Boolean is
3351
      begin
3352
         pragma Assert (Nkind (N) in N_Entity);
3353
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
3354
      end Flag93;
3355
 
3356
      function Flag94 (N : Node_Id) return Boolean is
3357
      begin
3358
         pragma Assert (Nkind (N) in N_Entity);
3359
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
3360
      end Flag94;
3361
 
3362
      function Flag95 (N : Node_Id) return Boolean is
3363
      begin
3364
         pragma Assert (Nkind (N) in N_Entity);
3365
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
3366
      end Flag95;
3367
 
3368
      function Flag96 (N : Node_Id) return Boolean is
3369
      begin
3370
         pragma Assert (Nkind (N) in N_Entity);
3371
         return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
3372
      end Flag96;
3373
 
3374
      function Flag97 (N : Node_Id) return Boolean is
3375
      begin
3376
         pragma Assert (Nkind (N) in N_Entity);
3377
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
3378
      end Flag97;
3379
 
3380
      function Flag98 (N : Node_Id) return Boolean is
3381
      begin
3382
         pragma Assert (Nkind (N) in N_Entity);
3383
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
3384
      end Flag98;
3385
 
3386
      function Flag99 (N : Node_Id) return Boolean is
3387
      begin
3388
         pragma Assert (Nkind (N) in N_Entity);
3389
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
3390
      end Flag99;
3391
 
3392
      function Flag100 (N : Node_Id) return Boolean is
3393
      begin
3394
         pragma Assert (Nkind (N) in N_Entity);
3395
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
3396
      end Flag100;
3397
 
3398
      function Flag101 (N : Node_Id) return Boolean is
3399
      begin
3400
         pragma Assert (Nkind (N) in N_Entity);
3401
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
3402
      end Flag101;
3403
 
3404
      function Flag102 (N : Node_Id) return Boolean is
3405
      begin
3406
         pragma Assert (Nkind (N) in N_Entity);
3407
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
3408
      end Flag102;
3409
 
3410
      function Flag103 (N : Node_Id) return Boolean is
3411
      begin
3412
         pragma Assert (Nkind (N) in N_Entity);
3413
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
3414
      end Flag103;
3415
 
3416
      function Flag104 (N : Node_Id) return Boolean is
3417
      begin
3418
         pragma Assert (Nkind (N) in N_Entity);
3419
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
3420
      end Flag104;
3421
 
3422
      function Flag105 (N : Node_Id) return Boolean is
3423
      begin
3424
         pragma Assert (Nkind (N) in N_Entity);
3425
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
3426
      end Flag105;
3427
 
3428
      function Flag106 (N : Node_Id) return Boolean is
3429
      begin
3430
         pragma Assert (Nkind (N) in N_Entity);
3431
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
3432
      end Flag106;
3433
 
3434
      function Flag107 (N : Node_Id) return Boolean is
3435
      begin
3436
         pragma Assert (Nkind (N) in N_Entity);
3437
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
3438
      end Flag107;
3439
 
3440
      function Flag108 (N : Node_Id) return Boolean is
3441
      begin
3442
         pragma Assert (Nkind (N) in N_Entity);
3443
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
3444
      end Flag108;
3445
 
3446
      function Flag109 (N : Node_Id) return Boolean is
3447
      begin
3448
         pragma Assert (Nkind (N) in N_Entity);
3449
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
3450
      end Flag109;
3451
 
3452
      function Flag110 (N : Node_Id) return Boolean is
3453
      begin
3454
         pragma Assert (Nkind (N) in N_Entity);
3455
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
3456
      end Flag110;
3457
 
3458
      function Flag111 (N : Node_Id) return Boolean is
3459
      begin
3460
         pragma Assert (Nkind (N) in N_Entity);
3461
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
3462
      end Flag111;
3463
 
3464
      function Flag112 (N : Node_Id) return Boolean is
3465
      begin
3466
         pragma Assert (Nkind (N) in N_Entity);
3467
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
3468
      end Flag112;
3469
 
3470
      function Flag113 (N : Node_Id) return Boolean is
3471
      begin
3472
         pragma Assert (Nkind (N) in N_Entity);
3473
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
3474
      end Flag113;
3475
 
3476
      function Flag114 (N : Node_Id) return Boolean is
3477
      begin
3478
         pragma Assert (Nkind (N) in N_Entity);
3479
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
3480
      end Flag114;
3481
 
3482
      function Flag115 (N : Node_Id) return Boolean is
3483
      begin
3484
         pragma Assert (Nkind (N) in N_Entity);
3485
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
3486
      end Flag115;
3487
 
3488
      function Flag116 (N : Node_Id) return Boolean is
3489
      begin
3490
         pragma Assert (Nkind (N) in N_Entity);
3491
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
3492
      end Flag116;
3493
 
3494
      function Flag117 (N : Node_Id) return Boolean is
3495
      begin
3496
         pragma Assert (Nkind (N) in N_Entity);
3497
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
3498
      end Flag117;
3499
 
3500
      function Flag118 (N : Node_Id) return Boolean is
3501
      begin
3502
         pragma Assert (Nkind (N) in N_Entity);
3503
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
3504
      end Flag118;
3505
 
3506
      function Flag119 (N : Node_Id) return Boolean is
3507
      begin
3508
         pragma Assert (Nkind (N) in N_Entity);
3509
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
3510
      end Flag119;
3511
 
3512
      function Flag120 (N : Node_Id) return Boolean is
3513
      begin
3514
         pragma Assert (Nkind (N) in N_Entity);
3515
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
3516
      end Flag120;
3517
 
3518
      function Flag121 (N : Node_Id) return Boolean is
3519
      begin
3520
         pragma Assert (Nkind (N) in N_Entity);
3521
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
3522
      end Flag121;
3523
 
3524
      function Flag122 (N : Node_Id) return Boolean is
3525
      begin
3526
         pragma Assert (Nkind (N) in N_Entity);
3527
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
3528
      end Flag122;
3529
 
3530
      function Flag123 (N : Node_Id) return Boolean is
3531
      begin
3532
         pragma Assert (Nkind (N) in N_Entity);
3533
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
3534
      end Flag123;
3535
 
3536
      function Flag124 (N : Node_Id) return Boolean is
3537
      begin
3538
         pragma Assert (Nkind (N) in N_Entity);
3539
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
3540
      end Flag124;
3541
 
3542
      function Flag125 (N : Node_Id) return Boolean is
3543
      begin
3544
         pragma Assert (Nkind (N) in N_Entity);
3545
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
3546
      end Flag125;
3547
 
3548
      function Flag126 (N : Node_Id) return Boolean is
3549
      begin
3550
         pragma Assert (Nkind (N) in N_Entity);
3551
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
3552
      end Flag126;
3553
 
3554
      function Flag127 (N : Node_Id) return Boolean is
3555
      begin
3556
         pragma Assert (Nkind (N) in N_Entity);
3557
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
3558
      end Flag127;
3559
 
3560
      function Flag128 (N : Node_Id) return Boolean is
3561
      begin
3562
         pragma Assert (Nkind (N) in N_Entity);
3563
         return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
3564
      end Flag128;
3565
 
3566
      function Flag129 (N : Node_Id) return Boolean is
3567
      begin
3568
         pragma Assert (Nkind (N) in N_Entity);
3569
         return Nodes.Table (N + 3).In_List;
3570
      end Flag129;
3571
 
3572
      function Flag130 (N : Node_Id) return Boolean is
3573
      begin
3574
         pragma Assert (Nkind (N) in N_Entity);
3575
         return Nodes.Table (N + 3).Has_Aspects;
3576
      end Flag130;
3577
 
3578
      function Flag131 (N : Node_Id) return Boolean is
3579
      begin
3580
         pragma Assert (Nkind (N) in N_Entity);
3581
         return Nodes.Table (N + 3).Rewrite_Ins;
3582
      end Flag131;
3583
 
3584
      function Flag132 (N : Node_Id) return Boolean is
3585
      begin
3586
         pragma Assert (Nkind (N) in N_Entity);
3587
         return Nodes.Table (N + 3).Analyzed;
3588
      end Flag132;
3589
 
3590
      function Flag133 (N : Node_Id) return Boolean is
3591
      begin
3592
         pragma Assert (Nkind (N) in N_Entity);
3593
         return Nodes.Table (N + 3).Comes_From_Source;
3594
      end Flag133;
3595
 
3596
      function Flag134 (N : Node_Id) return Boolean is
3597
      begin
3598
         pragma Assert (Nkind (N) in N_Entity);
3599
         return Nodes.Table (N + 3).Error_Posted;
3600
      end Flag134;
3601
 
3602
      function Flag135 (N : Node_Id) return Boolean is
3603
      begin
3604
         pragma Assert (Nkind (N) in N_Entity);
3605
         return Nodes.Table (N + 3).Flag4;
3606
      end Flag135;
3607
 
3608
      function Flag136 (N : Node_Id) return Boolean is
3609
      begin
3610
         pragma Assert (Nkind (N) in N_Entity);
3611
         return Nodes.Table (N + 3).Flag5;
3612
      end Flag136;
3613
 
3614
      function Flag137 (N : Node_Id) return Boolean is
3615
      begin
3616
         pragma Assert (Nkind (N) in N_Entity);
3617
         return Nodes.Table (N + 3).Flag6;
3618
      end Flag137;
3619
 
3620
      function Flag138 (N : Node_Id) return Boolean is
3621
      begin
3622
         pragma Assert (Nkind (N) in N_Entity);
3623
         return Nodes.Table (N + 3).Flag7;
3624
      end Flag138;
3625
 
3626
      function Flag139 (N : Node_Id) return Boolean is
3627
      begin
3628
         pragma Assert (Nkind (N) in N_Entity);
3629
         return Nodes.Table (N + 3).Flag8;
3630
      end Flag139;
3631
 
3632
      function Flag140 (N : Node_Id) return Boolean is
3633
      begin
3634
         pragma Assert (Nkind (N) in N_Entity);
3635
         return Nodes.Table (N + 3).Flag9;
3636
      end Flag140;
3637
 
3638
      function Flag141 (N : Node_Id) return Boolean is
3639
      begin
3640
         pragma Assert (Nkind (N) in N_Entity);
3641
         return Nodes.Table (N + 3).Flag10;
3642
      end Flag141;
3643
 
3644
      function Flag142 (N : Node_Id) return Boolean is
3645
      begin
3646
         pragma Assert (Nkind (N) in N_Entity);
3647
         return Nodes.Table (N + 3).Flag11;
3648
      end Flag142;
3649
 
3650
      function Flag143 (N : Node_Id) return Boolean is
3651
      begin
3652
         pragma Assert (Nkind (N) in N_Entity);
3653
         return Nodes.Table (N + 3).Flag12;
3654
      end Flag143;
3655
 
3656
      function Flag144 (N : Node_Id) return Boolean is
3657
      begin
3658
         pragma Assert (Nkind (N) in N_Entity);
3659
         return Nodes.Table (N + 3).Flag13;
3660
      end Flag144;
3661
 
3662
      function Flag145 (N : Node_Id) return Boolean is
3663
      begin
3664
         pragma Assert (Nkind (N) in N_Entity);
3665
         return Nodes.Table (N + 3).Flag14;
3666
      end Flag145;
3667
 
3668
      function Flag146 (N : Node_Id) return Boolean is
3669
      begin
3670
         pragma Assert (Nkind (N) in N_Entity);
3671
         return Nodes.Table (N + 3).Flag15;
3672
      end Flag146;
3673
 
3674
      function Flag147 (N : Node_Id) return Boolean is
3675
      begin
3676
         pragma Assert (Nkind (N) in N_Entity);
3677
         return Nodes.Table (N + 3).Flag16;
3678
      end Flag147;
3679
 
3680
      function Flag148 (N : Node_Id) return Boolean is
3681
      begin
3682
         pragma Assert (Nkind (N) in N_Entity);
3683
         return Nodes.Table (N + 3).Flag17;
3684
      end Flag148;
3685
 
3686
      function Flag149 (N : Node_Id) return Boolean is
3687
      begin
3688
         pragma Assert (Nkind (N) in N_Entity);
3689
         return Nodes.Table (N + 3).Flag18;
3690
      end Flag149;
3691
 
3692
      function Flag150 (N : Node_Id) return Boolean is
3693
      begin
3694
         pragma Assert (Nkind (N) in N_Entity);
3695
         return Nodes.Table (N + 3).Pflag1;
3696
      end Flag150;
3697
 
3698
      function Flag151 (N : Node_Id) return Boolean is
3699
      begin
3700
         pragma Assert (Nkind (N) in N_Entity);
3701
         return Nodes.Table (N + 3).Pflag2;
3702
      end Flag151;
3703
 
3704
      function Flag152 (N : Node_Id) return Boolean is
3705
      begin
3706
         pragma Assert (Nkind (N) in N_Entity);
3707
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
3708
      end Flag152;
3709
 
3710
      function Flag153 (N : Node_Id) return Boolean is
3711
      begin
3712
         pragma Assert (Nkind (N) in N_Entity);
3713
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
3714
      end Flag153;
3715
 
3716
      function Flag154 (N : Node_Id) return Boolean is
3717
      begin
3718
         pragma Assert (Nkind (N) in N_Entity);
3719
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
3720
      end Flag154;
3721
 
3722
      function Flag155 (N : Node_Id) return Boolean is
3723
      begin
3724
         pragma Assert (Nkind (N) in N_Entity);
3725
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
3726
      end Flag155;
3727
 
3728
      function Flag156 (N : Node_Id) return Boolean is
3729
      begin
3730
         pragma Assert (Nkind (N) in N_Entity);
3731
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
3732
      end Flag156;
3733
 
3734
      function Flag157 (N : Node_Id) return Boolean is
3735
      begin
3736
         pragma Assert (Nkind (N) in N_Entity);
3737
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
3738
      end Flag157;
3739
 
3740
      function Flag158 (N : Node_Id) return Boolean is
3741
      begin
3742
         pragma Assert (Nkind (N) in N_Entity);
3743
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
3744
      end Flag158;
3745
 
3746
      function Flag159 (N : Node_Id) return Boolean is
3747
      begin
3748
         pragma Assert (Nkind (N) in N_Entity);
3749
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
3750
      end Flag159;
3751
 
3752
      function Flag160 (N : Node_Id) return Boolean is
3753
      begin
3754
         pragma Assert (Nkind (N) in N_Entity);
3755
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
3756
      end Flag160;
3757
 
3758
      function Flag161 (N : Node_Id) return Boolean is
3759
      begin
3760
         pragma Assert (Nkind (N) in N_Entity);
3761
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
3762
      end Flag161;
3763
 
3764
      function Flag162 (N : Node_Id) return Boolean is
3765
      begin
3766
         pragma Assert (Nkind (N) in N_Entity);
3767
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
3768
      end Flag162;
3769
 
3770
      function Flag163 (N : Node_Id) return Boolean is
3771
      begin
3772
         pragma Assert (Nkind (N) in N_Entity);
3773
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
3774
      end Flag163;
3775
 
3776
      function Flag164 (N : Node_Id) return Boolean is
3777
      begin
3778
         pragma Assert (Nkind (N) in N_Entity);
3779
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
3780
      end Flag164;
3781
 
3782
      function Flag165 (N : Node_Id) return Boolean is
3783
      begin
3784
         pragma Assert (Nkind (N) in N_Entity);
3785
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
3786
      end Flag165;
3787
 
3788
      function Flag166 (N : Node_Id) return Boolean is
3789
      begin
3790
         pragma Assert (Nkind (N) in N_Entity);
3791
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
3792
      end Flag166;
3793
 
3794
      function Flag167 (N : Node_Id) return Boolean is
3795
      begin
3796
         pragma Assert (Nkind (N) in N_Entity);
3797
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
3798
      end Flag167;
3799
 
3800
      function Flag168 (N : Node_Id) return Boolean is
3801
      begin
3802
         pragma Assert (Nkind (N) in N_Entity);
3803
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
3804
      end Flag168;
3805
 
3806
      function Flag169 (N : Node_Id) return Boolean is
3807
      begin
3808
         pragma Assert (Nkind (N) in N_Entity);
3809
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
3810
      end Flag169;
3811
 
3812
      function Flag170 (N : Node_Id) return Boolean is
3813
      begin
3814
         pragma Assert (Nkind (N) in N_Entity);
3815
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
3816
      end Flag170;
3817
 
3818
      function Flag171 (N : Node_Id) return Boolean is
3819
      begin
3820
         pragma Assert (Nkind (N) in N_Entity);
3821
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
3822
      end Flag171;
3823
 
3824
      function Flag172 (N : Node_Id) return Boolean is
3825
      begin
3826
         pragma Assert (Nkind (N) in N_Entity);
3827
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
3828
      end Flag172;
3829
 
3830
      function Flag173 (N : Node_Id) return Boolean is
3831
      begin
3832
         pragma Assert (Nkind (N) in N_Entity);
3833
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
3834
      end Flag173;
3835
 
3836
      function Flag174 (N : Node_Id) return Boolean is
3837
      begin
3838
         pragma Assert (Nkind (N) in N_Entity);
3839
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
3840
      end Flag174;
3841
 
3842
      function Flag175 (N : Node_Id) return Boolean is
3843
      begin
3844
         pragma Assert (Nkind (N) in N_Entity);
3845
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
3846
      end Flag175;
3847
 
3848
      function Flag176 (N : Node_Id) return Boolean is
3849
      begin
3850
         pragma Assert (Nkind (N) in N_Entity);
3851
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
3852
      end Flag176;
3853
 
3854
      function Flag177 (N : Node_Id) return Boolean is
3855
      begin
3856
         pragma Assert (Nkind (N) in N_Entity);
3857
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
3858
      end Flag177;
3859
 
3860
      function Flag178 (N : Node_Id) return Boolean is
3861
      begin
3862
         pragma Assert (Nkind (N) in N_Entity);
3863
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
3864
      end Flag178;
3865
 
3866
      function Flag179 (N : Node_Id) return Boolean is
3867
      begin
3868
         pragma Assert (Nkind (N) in N_Entity);
3869
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
3870
      end Flag179;
3871
 
3872
      function Flag180 (N : Node_Id) return Boolean is
3873
      begin
3874
         pragma Assert (Nkind (N) in N_Entity);
3875
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
3876
      end Flag180;
3877
 
3878
      function Flag181 (N : Node_Id) return Boolean is
3879
      begin
3880
         pragma Assert (Nkind (N) in N_Entity);
3881
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
3882
      end Flag181;
3883
 
3884
      function Flag182 (N : Node_Id) return Boolean is
3885
      begin
3886
         pragma Assert (Nkind (N) in N_Entity);
3887
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
3888
      end Flag182;
3889
 
3890
      function Flag183 (N : Node_Id) return Boolean is
3891
      begin
3892
         pragma Assert (Nkind (N) in N_Entity);
3893
         return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
3894
      end Flag183;
3895
 
3896
      function Flag184 (N : Node_Id) return Boolean is
3897
      begin
3898
         pragma Assert (Nkind (N) in N_Entity);
3899
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag184;
3900
      end Flag184;
3901
 
3902
      function Flag185 (N : Node_Id) return Boolean is
3903
      begin
3904
         pragma Assert (Nkind (N) in N_Entity);
3905
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag185;
3906
      end Flag185;
3907
 
3908
      function Flag186 (N : Node_Id) return Boolean is
3909
      begin
3910
         pragma Assert (Nkind (N) in N_Entity);
3911
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag186;
3912
      end Flag186;
3913
 
3914
      function Flag187 (N : Node_Id) return Boolean is
3915
      begin
3916
         pragma Assert (Nkind (N) in N_Entity);
3917
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag187;
3918
      end Flag187;
3919
 
3920
      function Flag188 (N : Node_Id) return Boolean is
3921
      begin
3922
         pragma Assert (Nkind (N) in N_Entity);
3923
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag188;
3924
      end Flag188;
3925
 
3926
      function Flag189 (N : Node_Id) return Boolean is
3927
      begin
3928
         pragma Assert (Nkind (N) in N_Entity);
3929
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag189;
3930
      end Flag189;
3931
 
3932
      function Flag190 (N : Node_Id) return Boolean is
3933
      begin
3934
         pragma Assert (Nkind (N) in N_Entity);
3935
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag190;
3936
      end Flag190;
3937
 
3938
      function Flag191 (N : Node_Id) return Boolean is
3939
      begin
3940
         pragma Assert (Nkind (N) in N_Entity);
3941
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag191;
3942
      end Flag191;
3943
 
3944
      function Flag192 (N : Node_Id) return Boolean is
3945
      begin
3946
         pragma Assert (Nkind (N) in N_Entity);
3947
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag192;
3948
      end Flag192;
3949
 
3950
      function Flag193 (N : Node_Id) return Boolean is
3951
      begin
3952
         pragma Assert (Nkind (N) in N_Entity);
3953
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag193;
3954
      end Flag193;
3955
 
3956
      function Flag194 (N : Node_Id) return Boolean is
3957
      begin
3958
         pragma Assert (Nkind (N) in N_Entity);
3959
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag194;
3960
      end Flag194;
3961
 
3962
      function Flag195 (N : Node_Id) return Boolean is
3963
      begin
3964
         pragma Assert (Nkind (N) in N_Entity);
3965
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag195;
3966
      end Flag195;
3967
 
3968
      function Flag196 (N : Node_Id) return Boolean is
3969
      begin
3970
         pragma Assert (Nkind (N) in N_Entity);
3971
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag196;
3972
      end Flag196;
3973
 
3974
      function Flag197 (N : Node_Id) return Boolean is
3975
      begin
3976
         pragma Assert (Nkind (N) in N_Entity);
3977
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag197;
3978
      end Flag197;
3979
 
3980
      function Flag198 (N : Node_Id) return Boolean is
3981
      begin
3982
         pragma Assert (Nkind (N) in N_Entity);
3983
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag198;
3984
      end Flag198;
3985
 
3986
      function Flag199 (N : Node_Id) return Boolean is
3987
      begin
3988
         pragma Assert (Nkind (N) in N_Entity);
3989
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag199;
3990
      end Flag199;
3991
 
3992
      function Flag200 (N : Node_Id) return Boolean is
3993
      begin
3994
         pragma Assert (Nkind (N) in N_Entity);
3995
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag200;
3996
      end Flag200;
3997
 
3998
      function Flag201 (N : Node_Id) return Boolean is
3999
      begin
4000
         pragma Assert (Nkind (N) in N_Entity);
4001
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag201;
4002
      end Flag201;
4003
 
4004
      function Flag202 (N : Node_Id) return Boolean is
4005
      begin
4006
         pragma Assert (Nkind (N) in N_Entity);
4007
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag202;
4008
      end Flag202;
4009
 
4010
      function Flag203 (N : Node_Id) return Boolean is
4011
      begin
4012
         pragma Assert (Nkind (N) in N_Entity);
4013
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag203;
4014
      end Flag203;
4015
 
4016
      function Flag204 (N : Node_Id) return Boolean is
4017
      begin
4018
         pragma Assert (Nkind (N) in N_Entity);
4019
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag204;
4020
      end Flag204;
4021
 
4022
      function Flag205 (N : Node_Id) return Boolean is
4023
      begin
4024
         pragma Assert (Nkind (N) in N_Entity);
4025
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag205;
4026
      end Flag205;
4027
 
4028
      function Flag206 (N : Node_Id) return Boolean is
4029
      begin
4030
         pragma Assert (Nkind (N) in N_Entity);
4031
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag206;
4032
      end Flag206;
4033
 
4034
      function Flag207 (N : Node_Id) return Boolean is
4035
      begin
4036
         pragma Assert (Nkind (N) in N_Entity);
4037
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag207;
4038
      end Flag207;
4039
 
4040
      function Flag208 (N : Node_Id) return Boolean is
4041
      begin
4042
         pragma Assert (Nkind (N) in N_Entity);
4043
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag208;
4044
      end Flag208;
4045
 
4046
      function Flag209 (N : Node_Id) return Boolean is
4047
      begin
4048
         pragma Assert (Nkind (N) in N_Entity);
4049
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag209;
4050
      end Flag209;
4051
 
4052
      function Flag210 (N : Node_Id) return Boolean is
4053
      begin
4054
         pragma Assert (Nkind (N) in N_Entity);
4055
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag210;
4056
      end Flag210;
4057
 
4058
      function Flag211 (N : Node_Id) return Boolean is
4059
      begin
4060
         pragma Assert (Nkind (N) in N_Entity);
4061
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag211;
4062
      end Flag211;
4063
 
4064
      function Flag212 (N : Node_Id) return Boolean is
4065
      begin
4066
         pragma Assert (Nkind (N) in N_Entity);
4067
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag212;
4068
      end Flag212;
4069
 
4070
      function Flag213 (N : Node_Id) return Boolean is
4071
      begin
4072
         pragma Assert (Nkind (N) in N_Entity);
4073
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag213;
4074
      end Flag213;
4075
 
4076
      function Flag214 (N : Node_Id) return Boolean is
4077
      begin
4078
         pragma Assert (Nkind (N) in N_Entity);
4079
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag214;
4080
      end Flag214;
4081
 
4082
      function Flag215 (N : Node_Id) return Boolean is
4083
      begin
4084
         pragma Assert (Nkind (N) in N_Entity);
4085
         return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag215;
4086
      end Flag215;
4087
 
4088
      function Flag216 (N : Node_Id) return Boolean is
4089
      begin
4090
         pragma Assert (Nkind (N) in N_Entity);
4091
         return Nodes.Table (N + 4).In_List;
4092
      end Flag216;
4093
 
4094
      function Flag217 (N : Node_Id) return Boolean is
4095
      begin
4096
         pragma Assert (Nkind (N) in N_Entity);
4097
         return Nodes.Table (N + 4).Has_Aspects;
4098
      end Flag217;
4099
 
4100
      function Flag218 (N : Node_Id) return Boolean is
4101
      begin
4102
         pragma Assert (Nkind (N) in N_Entity);
4103
         return Nodes.Table (N + 4).Rewrite_Ins;
4104
      end Flag218;
4105
 
4106
      function Flag219 (N : Node_Id) return Boolean is
4107
      begin
4108
         pragma Assert (Nkind (N) in N_Entity);
4109
         return Nodes.Table (N + 4).Analyzed;
4110
      end Flag219;
4111
 
4112
      function Flag220 (N : Node_Id) return Boolean is
4113
      begin
4114
         pragma Assert (Nkind (N) in N_Entity);
4115
         return Nodes.Table (N + 4).Comes_From_Source;
4116
      end Flag220;
4117
 
4118
      function Flag221 (N : Node_Id) return Boolean is
4119
      begin
4120
         pragma Assert (Nkind (N) in N_Entity);
4121
         return Nodes.Table (N + 4).Error_Posted;
4122
      end Flag221;
4123
 
4124
      function Flag222 (N : Node_Id) return Boolean is
4125
      begin
4126
         pragma Assert (Nkind (N) in N_Entity);
4127
         return Nodes.Table (N + 4).Flag4;
4128
      end Flag222;
4129
 
4130
      function Flag223 (N : Node_Id) return Boolean is
4131
      begin
4132
         pragma Assert (Nkind (N) in N_Entity);
4133
         return Nodes.Table (N + 4).Flag5;
4134
      end Flag223;
4135
 
4136
      function Flag224 (N : Node_Id) return Boolean is
4137
      begin
4138
         pragma Assert (Nkind (N) in N_Entity);
4139
         return Nodes.Table (N + 4).Flag6;
4140
      end Flag224;
4141
 
4142
      function Flag225 (N : Node_Id) return Boolean is
4143
      begin
4144
         pragma Assert (Nkind (N) in N_Entity);
4145
         return Nodes.Table (N + 4).Flag7;
4146
      end Flag225;
4147
 
4148
      function Flag226 (N : Node_Id) return Boolean is
4149
      begin
4150
         pragma Assert (Nkind (N) in N_Entity);
4151
         return Nodes.Table (N + 4).Flag8;
4152
      end Flag226;
4153
 
4154
      function Flag227 (N : Node_Id) return Boolean is
4155
      begin
4156
         pragma Assert (Nkind (N) in N_Entity);
4157
         return Nodes.Table (N + 4).Flag9;
4158
      end Flag227;
4159
 
4160
      function Flag228 (N : Node_Id) return Boolean is
4161
      begin
4162
         pragma Assert (Nkind (N) in N_Entity);
4163
         return Nodes.Table (N + 4).Flag10;
4164
      end Flag228;
4165
 
4166
      function Flag229 (N : Node_Id) return Boolean is
4167
      begin
4168
         pragma Assert (Nkind (N) in N_Entity);
4169
         return Nodes.Table (N + 4).Flag11;
4170
      end Flag229;
4171
 
4172
      function Flag230 (N : Node_Id) return Boolean is
4173
      begin
4174
         pragma Assert (Nkind (N) in N_Entity);
4175
         return Nodes.Table (N + 4).Flag12;
4176
      end Flag230;
4177
 
4178
      function Flag231 (N : Node_Id) return Boolean is
4179
      begin
4180
         pragma Assert (Nkind (N) in N_Entity);
4181
         return Nodes.Table (N + 4).Flag13;
4182
      end Flag231;
4183
 
4184
      function Flag232 (N : Node_Id) return Boolean is
4185
      begin
4186
         pragma Assert (Nkind (N) in N_Entity);
4187
         return Nodes.Table (N + 4).Flag14;
4188
      end Flag232;
4189
 
4190
      function Flag233 (N : Node_Id) return Boolean is
4191
      begin
4192
         pragma Assert (Nkind (N) in N_Entity);
4193
         return Nodes.Table (N + 4).Flag15;
4194
      end Flag233;
4195
 
4196
      function Flag234 (N : Node_Id) return Boolean is
4197
      begin
4198
         pragma Assert (Nkind (N) in N_Entity);
4199
         return Nodes.Table (N + 4).Flag16;
4200
      end Flag234;
4201
 
4202
      function Flag235 (N : Node_Id) return Boolean is
4203
      begin
4204
         pragma Assert (Nkind (N) in N_Entity);
4205
         return Nodes.Table (N + 4).Flag17;
4206
      end Flag235;
4207
 
4208
      function Flag236 (N : Node_Id) return Boolean is
4209
      begin
4210
         pragma Assert (Nkind (N) in N_Entity);
4211
         return Nodes.Table (N + 4).Flag18;
4212
      end Flag236;
4213
 
4214
      function Flag237 (N : Node_Id) return Boolean is
4215
      begin
4216
         pragma Assert (Nkind (N) in N_Entity);
4217
         return Nodes.Table (N + 4).Pflag1;
4218
      end Flag237;
4219
 
4220
      function Flag238 (N : Node_Id) return Boolean is
4221
      begin
4222
         pragma Assert (Nkind (N) in N_Entity);
4223
         return Nodes.Table (N + 4).Pflag2;
4224
      end Flag238;
4225
 
4226
      function Flag239 (N : Node_Id) return Boolean is
4227
      begin
4228
         pragma Assert (Nkind (N) in N_Entity);
4229
         return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag239;
4230
      end Flag239;
4231
 
4232
      function Flag240 (N : Node_Id) return Boolean is
4233
      begin
4234
         pragma Assert (Nkind (N) in N_Entity);
4235
         return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag240;
4236
      end Flag240;
4237
 
4238
      function Flag241 (N : Node_Id) return Boolean is
4239
      begin
4240
         pragma Assert (Nkind (N) in N_Entity);
4241
         return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag241;
4242
      end Flag241;
4243
 
4244
      function Flag242 (N : Node_Id) return Boolean is
4245
      begin
4246
         pragma Assert (Nkind (N) in N_Entity);
4247
         return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag242;
4248
      end Flag242;
4249
 
4250
      function Flag243 (N : Node_Id) return Boolean is
4251
      begin
4252
         pragma Assert (Nkind (N) in N_Entity);
4253
         return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag243;
4254
      end Flag243;
4255
 
4256
      function Flag244 (N : Node_Id) return Boolean is
4257
      begin
4258
         pragma Assert (Nkind (N) in N_Entity);
4259
         return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag244;
4260
      end Flag244;
4261
 
4262
      function Flag245 (N : Node_Id) return Boolean is
4263
      begin
4264
         pragma Assert (Nkind (N) in N_Entity);
4265
         return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag245;
4266
      end Flag245;
4267
 
4268
      function Flag246 (N : Node_Id) return Boolean is
4269
      begin
4270
         pragma Assert (Nkind (N) in N_Entity);
4271
         return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag246;
4272
      end Flag246;
4273
 
4274
      function Flag247 (N : Node_Id) return Boolean is
4275
      begin
4276
         pragma Assert (Nkind (N) in N_Entity);
4277
         return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag247;
4278
      end Flag247;
4279
 
4280
      function Flag248 (N : Node_Id) return Boolean is
4281
      begin
4282
         pragma Assert (Nkind (N) in N_Entity);
4283
         return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag248;
4284
      end Flag248;
4285
 
4286
      function Flag249 (N : Node_Id) return Boolean is
4287
      begin
4288
         pragma Assert (Nkind (N) in N_Entity);
4289
         return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag249;
4290
      end Flag249;
4291
 
4292
      function Flag250 (N : Node_Id) return Boolean is
4293
      begin
4294
         pragma Assert (Nkind (N) in N_Entity);
4295
         return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag250;
4296
      end Flag250;
4297
 
4298
      function Flag251 (N : Node_Id) return Boolean is
4299
      begin
4300
         pragma Assert (Nkind (N) in N_Entity);
4301
         return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag251;
4302
      end Flag251;
4303
 
4304
      function Flag252 (N : Node_Id) return Boolean is
4305
      begin
4306
         pragma Assert (Nkind (N) in N_Entity);
4307
         return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag252;
4308
      end Flag252;
4309
 
4310
      function Flag253 (N : Node_Id) return Boolean is
4311
      begin
4312
         pragma Assert (Nkind (N) in N_Entity);
4313
         return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag253;
4314
      end Flag253;
4315
 
4316
      function Flag254 (N : Node_Id) return Boolean is
4317
      begin
4318
         pragma Assert (Nkind (N) in N_Entity);
4319
         return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag254;
4320
      end Flag254;
4321
 
4322
      procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
4323
      begin
4324
         pragma Assert (N <= Nodes.Last);
4325
         Nodes.Table (N).Nkind := Val;
4326
      end Set_Nkind;
4327
 
4328
      procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
4329
      begin
4330
         pragma Assert (N <= Nodes.Last);
4331
         Nodes.Table (N).Field1 := Val;
4332
      end Set_Field1;
4333
 
4334
      procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
4335
      begin
4336
         pragma Assert (N <= Nodes.Last);
4337
         Nodes.Table (N).Field2 := Val;
4338
      end Set_Field2;
4339
 
4340
      procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
4341
      begin
4342
         pragma Assert (N <= Nodes.Last);
4343
         Nodes.Table (N).Field3 := Val;
4344
      end Set_Field3;
4345
 
4346
      procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
4347
      begin
4348
         pragma Assert (N <= Nodes.Last);
4349
         Nodes.Table (N).Field4 := Val;
4350
      end Set_Field4;
4351
 
4352
      procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
4353
      begin
4354
         pragma Assert (N <= Nodes.Last);
4355
         Nodes.Table (N).Field5 := Val;
4356
      end Set_Field5;
4357
 
4358
      procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
4359
      begin
4360
         pragma Assert (Nkind (N) in N_Entity);
4361
         Nodes.Table (N + 1).Field6 := Val;
4362
      end Set_Field6;
4363
 
4364
      procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
4365
      begin
4366
         pragma Assert (Nkind (N) in N_Entity);
4367
         Nodes.Table (N + 1).Field7 := Val;
4368
      end Set_Field7;
4369
 
4370
      procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
4371
      begin
4372
         pragma Assert (Nkind (N) in N_Entity);
4373
         Nodes.Table (N + 1).Field8 := Val;
4374
      end Set_Field8;
4375
 
4376
      procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
4377
      begin
4378
         pragma Assert (Nkind (N) in N_Entity);
4379
         Nodes.Table (N + 1).Field9 := Val;
4380
      end Set_Field9;
4381
 
4382
      procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
4383
      begin
4384
         pragma Assert (Nkind (N) in N_Entity);
4385
         Nodes.Table (N + 1).Field10 := Val;
4386
      end Set_Field10;
4387
 
4388
      procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
4389
      begin
4390
         pragma Assert (Nkind (N) in N_Entity);
4391
         Nodes.Table (N + 1).Field11 := Val;
4392
      end Set_Field11;
4393
 
4394
      procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
4395
      begin
4396
         pragma Assert (Nkind (N) in N_Entity);
4397
         Nodes.Table (N + 1).Field12 := Val;
4398
      end Set_Field12;
4399
 
4400
      procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
4401
      begin
4402
         pragma Assert (Nkind (N) in N_Entity);
4403
         Nodes.Table (N + 2).Field6 := Val;
4404
      end Set_Field13;
4405
 
4406
      procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
4407
      begin
4408
         pragma Assert (Nkind (N) in N_Entity);
4409
         Nodes.Table (N + 2).Field7 := Val;
4410
      end Set_Field14;
4411
 
4412
      procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
4413
      begin
4414
         pragma Assert (Nkind (N) in N_Entity);
4415
         Nodes.Table (N + 2).Field8 := Val;
4416
      end Set_Field15;
4417
 
4418
      procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
4419
      begin
4420
         pragma Assert (Nkind (N) in N_Entity);
4421
         Nodes.Table (N + 2).Field9 := Val;
4422
      end Set_Field16;
4423
 
4424
      procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
4425
      begin
4426
         pragma Assert (Nkind (N) in N_Entity);
4427
         Nodes.Table (N + 2).Field10 := Val;
4428
      end Set_Field17;
4429
 
4430
      procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
4431
      begin
4432
         pragma Assert (Nkind (N) in N_Entity);
4433
         Nodes.Table (N + 2).Field11 := Val;
4434
      end Set_Field18;
4435
 
4436
      procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
4437
      begin
4438
         pragma Assert (Nkind (N) in N_Entity);
4439
         Nodes.Table (N + 3).Field6 := Val;
4440
      end Set_Field19;
4441
 
4442
      procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
4443
      begin
4444
         pragma Assert (Nkind (N) in N_Entity);
4445
         Nodes.Table (N + 3).Field7 := Val;
4446
      end Set_Field20;
4447
 
4448
      procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
4449
      begin
4450
         pragma Assert (Nkind (N) in N_Entity);
4451
         Nodes.Table (N + 3).Field8 := Val;
4452
      end Set_Field21;
4453
 
4454
      procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
4455
      begin
4456
         pragma Assert (Nkind (N) in N_Entity);
4457
         Nodes.Table (N + 3).Field9 := Val;
4458
      end Set_Field22;
4459
 
4460
      procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
4461
      begin
4462
         pragma Assert (Nkind (N) in N_Entity);
4463
         Nodes.Table (N + 3).Field10 := Val;
4464
      end Set_Field23;
4465
 
4466
      procedure Set_Field24 (N : Node_Id; Val : Union_Id) is
4467
      begin
4468
         pragma Assert (Nkind (N) in N_Entity);
4469
         Nodes.Table (N + 4).Field6 := Val;
4470
      end Set_Field24;
4471
 
4472
      procedure Set_Field25 (N : Node_Id; Val : Union_Id) is
4473
      begin
4474
         pragma Assert (Nkind (N) in N_Entity);
4475
         Nodes.Table (N + 4).Field7 := Val;
4476
      end Set_Field25;
4477
 
4478
      procedure Set_Field26 (N : Node_Id; Val : Union_Id) is
4479
      begin
4480
         pragma Assert (Nkind (N) in N_Entity);
4481
         Nodes.Table (N + 4).Field8 := Val;
4482
      end Set_Field26;
4483
 
4484
      procedure Set_Field27 (N : Node_Id; Val : Union_Id) is
4485
      begin
4486
         pragma Assert (Nkind (N) in N_Entity);
4487
         Nodes.Table (N + 4).Field9 := Val;
4488
      end Set_Field27;
4489
 
4490
      procedure Set_Field28 (N : Node_Id; Val : Union_Id) is
4491
      begin
4492
         pragma Assert (Nkind (N) in N_Entity);
4493
         Nodes.Table (N + 4).Field10 := Val;
4494
      end Set_Field28;
4495
 
4496
      procedure Set_Field29 (N : Node_Id; Val : Union_Id) is
4497
      begin
4498
         pragma Assert (Nkind (N) in N_Entity);
4499
         Nodes.Table (N + 4).Field11 := Val;
4500
      end Set_Field29;
4501
 
4502
      procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
4503
      begin
4504
         pragma Assert (N <= Nodes.Last);
4505
         Nodes.Table (N).Field1 := Union_Id (Val);
4506
      end Set_Node1;
4507
 
4508
      procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
4509
      begin
4510
         pragma Assert (N <= Nodes.Last);
4511
         Nodes.Table (N).Field2 := Union_Id (Val);
4512
      end Set_Node2;
4513
 
4514
      procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
4515
      begin
4516
         pragma Assert (N <= Nodes.Last);
4517
         Nodes.Table (N).Field3 := Union_Id (Val);
4518
      end Set_Node3;
4519
 
4520
      procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
4521
      begin
4522
         pragma Assert (N <= Nodes.Last);
4523
         Nodes.Table (N).Field4 := Union_Id (Val);
4524
      end Set_Node4;
4525
 
4526
      procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
4527
      begin
4528
         pragma Assert (N <= Nodes.Last);
4529
         Nodes.Table (N).Field5 := Union_Id (Val);
4530
      end Set_Node5;
4531
 
4532
      procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
4533
      begin
4534
         pragma Assert (Nkind (N) in N_Entity);
4535
         Nodes.Table (N + 1).Field6 := Union_Id (Val);
4536
      end Set_Node6;
4537
 
4538
      procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
4539
      begin
4540
         pragma Assert (Nkind (N) in N_Entity);
4541
         Nodes.Table (N + 1).Field7 := Union_Id (Val);
4542
      end Set_Node7;
4543
 
4544
      procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
4545
      begin
4546
         pragma Assert (Nkind (N) in N_Entity);
4547
         Nodes.Table (N + 1).Field8 := Union_Id (Val);
4548
      end Set_Node8;
4549
 
4550
      procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
4551
      begin
4552
         pragma Assert (Nkind (N) in N_Entity);
4553
         Nodes.Table (N + 1).Field9 := Union_Id (Val);
4554
      end Set_Node9;
4555
 
4556
      procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
4557
      begin
4558
         pragma Assert (Nkind (N) in N_Entity);
4559
         Nodes.Table (N + 1).Field10 := Union_Id (Val);
4560
      end Set_Node10;
4561
 
4562
      procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
4563
      begin
4564
         pragma Assert (Nkind (N) in N_Entity);
4565
         Nodes.Table (N + 1).Field11 := Union_Id (Val);
4566
      end Set_Node11;
4567
 
4568
      procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
4569
      begin
4570
         pragma Assert (Nkind (N) in N_Entity);
4571
         Nodes.Table (N + 1).Field12 := Union_Id (Val);
4572
      end Set_Node12;
4573
 
4574
      procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
4575
      begin
4576
         pragma Assert (Nkind (N) in N_Entity);
4577
         Nodes.Table (N + 2).Field6 := Union_Id (Val);
4578
      end Set_Node13;
4579
 
4580
      procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
4581
      begin
4582
         pragma Assert (Nkind (N) in N_Entity);
4583
         Nodes.Table (N + 2).Field7 := Union_Id (Val);
4584
      end Set_Node14;
4585
 
4586
      procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
4587
      begin
4588
         pragma Assert (Nkind (N) in N_Entity);
4589
         Nodes.Table (N + 2).Field8 := Union_Id (Val);
4590
      end Set_Node15;
4591
 
4592
      procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
4593
      begin
4594
         pragma Assert (Nkind (N) in N_Entity);
4595
         Nodes.Table (N + 2).Field9 := Union_Id (Val);
4596
      end Set_Node16;
4597
 
4598
      procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
4599
      begin
4600
         pragma Assert (Nkind (N) in N_Entity);
4601
         Nodes.Table (N + 2).Field10 := Union_Id (Val);
4602
      end Set_Node17;
4603
 
4604
      procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
4605
      begin
4606
         pragma Assert (Nkind (N) in N_Entity);
4607
         Nodes.Table (N + 2).Field11 := Union_Id (Val);
4608
      end Set_Node18;
4609
 
4610
      procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
4611
      begin
4612
         pragma Assert (Nkind (N) in N_Entity);
4613
         Nodes.Table (N + 3).Field6 := Union_Id (Val);
4614
      end Set_Node19;
4615
 
4616
      procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
4617
      begin
4618
         pragma Assert (Nkind (N) in N_Entity);
4619
         Nodes.Table (N + 3).Field7 := Union_Id (Val);
4620
      end Set_Node20;
4621
 
4622
      procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
4623
      begin
4624
         pragma Assert (Nkind (N) in N_Entity);
4625
         Nodes.Table (N + 3).Field8 := Union_Id (Val);
4626
      end Set_Node21;
4627
 
4628
      procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
4629
      begin
4630
         pragma Assert (Nkind (N) in N_Entity);
4631
         Nodes.Table (N + 3).Field9 := Union_Id (Val);
4632
      end Set_Node22;
4633
 
4634
      procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
4635
      begin
4636
         pragma Assert (Nkind (N) in N_Entity);
4637
         Nodes.Table (N + 3).Field10 := Union_Id (Val);
4638
      end Set_Node23;
4639
 
4640
      procedure Set_Node24 (N : Node_Id; Val : Node_Id) is
4641
      begin
4642
         pragma Assert (Nkind (N) in N_Entity);
4643
         Nodes.Table (N + 4).Field6 := Union_Id (Val);
4644
      end Set_Node24;
4645
 
4646
      procedure Set_Node25 (N : Node_Id; Val : Node_Id) is
4647
      begin
4648
         pragma Assert (Nkind (N) in N_Entity);
4649
         Nodes.Table (N + 4).Field7 := Union_Id (Val);
4650
      end Set_Node25;
4651
 
4652
      procedure Set_Node26 (N : Node_Id; Val : Node_Id) is
4653
      begin
4654
         pragma Assert (Nkind (N) in N_Entity);
4655
         Nodes.Table (N + 4).Field8 := Union_Id (Val);
4656
      end Set_Node26;
4657
 
4658
      procedure Set_Node27 (N : Node_Id; Val : Node_Id) is
4659
      begin
4660
         pragma Assert (Nkind (N) in N_Entity);
4661
         Nodes.Table (N + 4).Field9 := Union_Id (Val);
4662
      end Set_Node27;
4663
 
4664
      procedure Set_Node28 (N : Node_Id; Val : Node_Id) is
4665
      begin
4666
         pragma Assert (Nkind (N) in N_Entity);
4667
         Nodes.Table (N + 4).Field10 := Union_Id (Val);
4668
      end Set_Node28;
4669
 
4670
      procedure Set_Node29 (N : Node_Id; Val : Node_Id) is
4671
      begin
4672
         pragma Assert (Nkind (N) in N_Entity);
4673
         Nodes.Table (N + 4).Field11 := Union_Id (Val);
4674
      end Set_Node29;
4675
 
4676
      procedure Set_List1 (N : Node_Id; Val : List_Id) is
4677
      begin
4678
         pragma Assert (N <= Nodes.Last);
4679
         Nodes.Table (N).Field1 := Union_Id (Val);
4680
      end Set_List1;
4681
 
4682
      procedure Set_List2 (N : Node_Id; Val : List_Id) is
4683
      begin
4684
         pragma Assert (N <= Nodes.Last);
4685
         Nodes.Table (N).Field2 := Union_Id (Val);
4686
      end Set_List2;
4687
 
4688
      procedure Set_List3 (N : Node_Id; Val : List_Id) is
4689
      begin
4690
         pragma Assert (N <= Nodes.Last);
4691
         Nodes.Table (N).Field3 := Union_Id (Val);
4692
      end Set_List3;
4693
 
4694
      procedure Set_List4 (N : Node_Id; Val : List_Id) is
4695
      begin
4696
         pragma Assert (N <= Nodes.Last);
4697
         Nodes.Table (N).Field4 := Union_Id (Val);
4698
      end Set_List4;
4699
 
4700
      procedure Set_List5 (N : Node_Id; Val : List_Id) is
4701
      begin
4702
         pragma Assert (N <= Nodes.Last);
4703
         Nodes.Table (N).Field5 := Union_Id (Val);
4704
      end Set_List5;
4705
 
4706
      procedure Set_List10 (N : Node_Id; Val : List_Id) is
4707
      begin
4708
         pragma Assert (Nkind (N) in N_Entity);
4709
         Nodes.Table (N + 1).Field10 := Union_Id (Val);
4710
      end Set_List10;
4711
 
4712
      procedure Set_List14 (N : Node_Id; Val : List_Id) is
4713
      begin
4714
         pragma Assert (Nkind (N) in N_Entity);
4715
         Nodes.Table (N + 2).Field7 := Union_Id (Val);
4716
      end Set_List14;
4717
 
4718
      procedure Set_List25 (N : Node_Id; Val : List_Id) is
4719
      begin
4720
         pragma Assert (Nkind (N) in N_Entity);
4721
         Nodes.Table (N + 4).Field7 := Union_Id (Val);
4722
      end Set_List25;
4723
 
4724
      procedure Set_Elist1 (N : Node_Id; Val : Elist_Id) is
4725
      begin
4726
         Nodes.Table (N).Field1 := Union_Id (Val);
4727
      end Set_Elist1;
4728
 
4729
      procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
4730
      begin
4731
         Nodes.Table (N).Field2 := Union_Id (Val);
4732
      end Set_Elist2;
4733
 
4734
      procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
4735
      begin
4736
         Nodes.Table (N).Field3 := Union_Id (Val);
4737
      end Set_Elist3;
4738
 
4739
      procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
4740
      begin
4741
         Nodes.Table (N).Field4 := Union_Id (Val);
4742
      end Set_Elist4;
4743
 
4744
      procedure Set_Elist5 (N : Node_Id; Val : Elist_Id) is
4745
      begin
4746
         Nodes.Table (N).Field5 := Union_Id (Val);
4747
      end Set_Elist5;
4748
 
4749
      procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
4750
      begin
4751
         pragma Assert (Nkind (N) in N_Entity);
4752
         Nodes.Table (N + 1).Field8 := Union_Id (Val);
4753
      end Set_Elist8;
4754
 
4755
      procedure Set_Elist10 (N : Node_Id; Val : Elist_Id) is
4756
      begin
4757
         pragma Assert (Nkind (N) in N_Entity);
4758
         Nodes.Table (N + 1).Field10 := Union_Id (Val);
4759
      end Set_Elist10;
4760
 
4761
      procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
4762
      begin
4763
         pragma Assert (Nkind (N) in N_Entity);
4764
         Nodes.Table (N + 2).Field6 := Union_Id (Val);
4765
      end Set_Elist13;
4766
 
4767
      procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
4768
      begin
4769
         pragma Assert (Nkind (N) in N_Entity);
4770
         Nodes.Table (N + 2).Field8 := Union_Id (Val);
4771
      end Set_Elist15;
4772
 
4773
      procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
4774
      begin
4775
         pragma Assert (Nkind (N) in N_Entity);
4776
         Nodes.Table (N + 2).Field9 := Union_Id (Val);
4777
      end Set_Elist16;
4778
 
4779
      procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
4780
      begin
4781
         pragma Assert (Nkind (N) in N_Entity);
4782
         Nodes.Table (N + 2).Field11 := Union_Id (Val);
4783
      end Set_Elist18;
4784
 
4785
      procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
4786
      begin
4787
         pragma Assert (Nkind (N) in N_Entity);
4788
         Nodes.Table (N + 3).Field8 := Union_Id (Val);
4789
      end Set_Elist21;
4790
 
4791
      procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
4792
      begin
4793
         pragma Assert (Nkind (N) in N_Entity);
4794
         Nodes.Table (N + 3).Field10 := Union_Id (Val);
4795
      end Set_Elist23;
4796
 
4797
      procedure Set_Elist24 (N : Node_Id; Val : Elist_Id) is
4798
      begin
4799
         pragma Assert (Nkind (N) in N_Entity);
4800
         Nodes.Table (N + 4).Field6 := Union_Id (Val);
4801
      end Set_Elist24;
4802
 
4803
      procedure Set_Elist25 (N : Node_Id; Val : Elist_Id) is
4804
      begin
4805
         pragma Assert (Nkind (N) in N_Entity);
4806
         Nodes.Table (N + 4).Field7 := Union_Id (Val);
4807
      end Set_Elist25;
4808
 
4809
      procedure Set_Elist26 (N : Node_Id; Val : Elist_Id) is
4810
      begin
4811
         pragma Assert (Nkind (N) in N_Entity);
4812
         Nodes.Table (N + 4).Field8 := Union_Id (Val);
4813
      end Set_Elist26;
4814
 
4815
      procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
4816
      begin
4817
         pragma Assert (N <= Nodes.Last);
4818
         Nodes.Table (N).Field1 := Union_Id (Val);
4819
      end Set_Name1;
4820
 
4821
      procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
4822
      begin
4823
         pragma Assert (N <= Nodes.Last);
4824
         Nodes.Table (N).Field2 := Union_Id (Val);
4825
      end Set_Name2;
4826
 
4827
      procedure Set_Str3 (N : Node_Id; Val : String_Id) is
4828
      begin
4829
         pragma Assert (N <= Nodes.Last);
4830
         Nodes.Table (N).Field3 := Union_Id (Val);
4831
      end Set_Str3;
4832
 
4833
      procedure Set_Uint2 (N : Node_Id; Val : Uint) is
4834
      begin
4835
         pragma Assert (N <= Nodes.Last);
4836
         Nodes.Table (N).Field2 := To_Union (Val);
4837
      end Set_Uint2;
4838
 
4839
      procedure Set_Uint3 (N : Node_Id; Val : Uint) is
4840
      begin
4841
         pragma Assert (N <= Nodes.Last);
4842
         Nodes.Table (N).Field3 := To_Union (Val);
4843
      end Set_Uint3;
4844
 
4845
      procedure Set_Uint4 (N : Node_Id; Val : Uint) is
4846
      begin
4847
         pragma Assert (N <= Nodes.Last);
4848
         Nodes.Table (N).Field4 := To_Union (Val);
4849
      end Set_Uint4;
4850
 
4851
      procedure Set_Uint5 (N : Node_Id; Val : Uint) is
4852
      begin
4853
         pragma Assert (N <= Nodes.Last);
4854
         Nodes.Table (N).Field5 := To_Union (Val);
4855
      end Set_Uint5;
4856
 
4857
      procedure Set_Uint8 (N : Node_Id; Val : Uint) is
4858
      begin
4859
         pragma Assert (Nkind (N) in N_Entity);
4860
         Nodes.Table (N + 1).Field8 := To_Union (Val);
4861
      end Set_Uint8;
4862
 
4863
      procedure Set_Uint9 (N : Node_Id; Val : Uint) is
4864
      begin
4865
         pragma Assert (Nkind (N) in N_Entity);
4866
         Nodes.Table (N + 1).Field9 := To_Union (Val);
4867
      end Set_Uint9;
4868
 
4869
      procedure Set_Uint10 (N : Node_Id; Val : Uint) is
4870
      begin
4871
         pragma Assert (Nkind (N) in N_Entity);
4872
         Nodes.Table (N + 1).Field10 := To_Union (Val);
4873
      end Set_Uint10;
4874
 
4875
      procedure Set_Uint11 (N : Node_Id; Val : Uint) is
4876
      begin
4877
         pragma Assert (Nkind (N) in N_Entity);
4878
         Nodes.Table (N + 1).Field11 := To_Union (Val);
4879
      end Set_Uint11;
4880
 
4881
      procedure Set_Uint12 (N : Node_Id; Val : Uint) is
4882
      begin
4883
         pragma Assert (Nkind (N) in N_Entity);
4884
         Nodes.Table (N + 1).Field12 := To_Union (Val);
4885
      end Set_Uint12;
4886
 
4887
      procedure Set_Uint13 (N : Node_Id; Val : Uint) is
4888
      begin
4889
         pragma Assert (Nkind (N) in N_Entity);
4890
         Nodes.Table (N + 2).Field6 := To_Union (Val);
4891
      end Set_Uint13;
4892
 
4893
      procedure Set_Uint14 (N : Node_Id; Val : Uint) is
4894
      begin
4895
         pragma Assert (Nkind (N) in N_Entity);
4896
         Nodes.Table (N + 2).Field7 := To_Union (Val);
4897
      end Set_Uint14;
4898
 
4899
      procedure Set_Uint15 (N : Node_Id; Val : Uint) is
4900
      begin
4901
         pragma Assert (Nkind (N) in N_Entity);
4902
         Nodes.Table (N + 2).Field8 := To_Union (Val);
4903
      end Set_Uint15;
4904
 
4905
      procedure Set_Uint16 (N : Node_Id; Val : Uint) is
4906
      begin
4907
         pragma Assert (Nkind (N) in N_Entity);
4908
         Nodes.Table (N + 2).Field9 := To_Union (Val);
4909
      end Set_Uint16;
4910
 
4911
      procedure Set_Uint17 (N : Node_Id; Val : Uint) is
4912
      begin
4913
         pragma Assert (Nkind (N) in N_Entity);
4914
         Nodes.Table (N + 2).Field10 := To_Union (Val);
4915
      end Set_Uint17;
4916
 
4917
      procedure Set_Uint22 (N : Node_Id; Val : Uint) is
4918
      begin
4919
         pragma Assert (Nkind (N) in N_Entity);
4920
         Nodes.Table (N + 3).Field9 := To_Union (Val);
4921
      end Set_Uint22;
4922
 
4923
      procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
4924
      begin
4925
         pragma Assert (N <= Nodes.Last);
4926
         Nodes.Table (N).Field3 := To_Union (Val);
4927
      end Set_Ureal3;
4928
 
4929
      procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
4930
      begin
4931
         pragma Assert (Nkind (N) in N_Entity);
4932
         Nodes.Table (N + 2).Field11 := To_Union (Val);
4933
      end Set_Ureal18;
4934
 
4935
      procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
4936
      begin
4937
         pragma Assert (Nkind (N) in N_Entity);
4938
         Nodes.Table (N + 3).Field8 := To_Union (Val);
4939
      end Set_Ureal21;
4940
 
4941
      procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
4942
      begin
4943
         pragma Assert (N <= Nodes.Last);
4944
         Nodes.Table (N).Flag4 := Val;
4945
      end Set_Flag4;
4946
 
4947
      procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
4948
      begin
4949
         pragma Assert (N <= Nodes.Last);
4950
         Nodes.Table (N).Flag5 := Val;
4951
      end Set_Flag5;
4952
 
4953
      procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
4954
      begin
4955
         pragma Assert (N <= Nodes.Last);
4956
         Nodes.Table (N).Flag6 := Val;
4957
      end Set_Flag6;
4958
 
4959
      procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
4960
      begin
4961
         pragma Assert (N <= Nodes.Last);
4962
         Nodes.Table (N).Flag7 := Val;
4963
      end Set_Flag7;
4964
 
4965
      procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
4966
      begin
4967
         pragma Assert (N <= Nodes.Last);
4968
         Nodes.Table (N).Flag8 := Val;
4969
      end Set_Flag8;
4970
 
4971
      procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
4972
      begin
4973
         pragma Assert (N <= Nodes.Last);
4974
         Nodes.Table (N).Flag9 := Val;
4975
      end Set_Flag9;
4976
 
4977
      procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
4978
      begin
4979
         pragma Assert (N <= Nodes.Last);
4980
         Nodes.Table (N).Flag10 := Val;
4981
      end Set_Flag10;
4982
 
4983
      procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
4984
      begin
4985
         pragma Assert (N <= Nodes.Last);
4986
         Nodes.Table (N).Flag11 := Val;
4987
      end Set_Flag11;
4988
 
4989
      procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
4990
      begin
4991
         pragma Assert (N <= Nodes.Last);
4992
         Nodes.Table (N).Flag12 := Val;
4993
      end Set_Flag12;
4994
 
4995
      procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
4996
      begin
4997
         pragma Assert (N <= Nodes.Last);
4998
         Nodes.Table (N).Flag13 := Val;
4999
      end Set_Flag13;
5000
 
5001
      procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
5002
      begin
5003
         pragma Assert (N <= Nodes.Last);
5004
         Nodes.Table (N).Flag14 := Val;
5005
      end Set_Flag14;
5006
 
5007
      procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
5008
      begin
5009
         pragma Assert (N <= Nodes.Last);
5010
         Nodes.Table (N).Flag15 := Val;
5011
      end Set_Flag15;
5012
 
5013
      procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
5014
      begin
5015
         pragma Assert (N <= Nodes.Last);
5016
         Nodes.Table (N).Flag16 := Val;
5017
      end Set_Flag16;
5018
 
5019
      procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
5020
      begin
5021
         pragma Assert (N <= Nodes.Last);
5022
         Nodes.Table (N).Flag17 := Val;
5023
      end Set_Flag17;
5024
 
5025
      procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
5026
      begin
5027
         pragma Assert (N <= Nodes.Last);
5028
         Nodes.Table (N).Flag18 := Val;
5029
      end Set_Flag18;
5030
 
5031
      procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
5032
      begin
5033
         pragma Assert (Nkind (N) in N_Entity);
5034
         Nodes.Table (N + 1).In_List := Val;
5035
      end Set_Flag19;
5036
 
5037
      procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
5038
      begin
5039
         pragma Assert (Nkind (N) in N_Entity);
5040
         Nodes.Table (N + 1).Has_Aspects := Val;
5041
      end Set_Flag20;
5042
 
5043
      procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
5044
      begin
5045
         pragma Assert (Nkind (N) in N_Entity);
5046
         Nodes.Table (N + 1).Rewrite_Ins := Val;
5047
      end Set_Flag21;
5048
 
5049
      procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
5050
      begin
5051
         pragma Assert (Nkind (N) in N_Entity);
5052
         Nodes.Table (N + 1).Analyzed := Val;
5053
      end Set_Flag22;
5054
 
5055
      procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
5056
      begin
5057
         pragma Assert (Nkind (N) in N_Entity);
5058
         Nodes.Table (N + 1).Comes_From_Source := Val;
5059
      end Set_Flag23;
5060
 
5061
      procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
5062
      begin
5063
         pragma Assert (Nkind (N) in N_Entity);
5064
         Nodes.Table (N + 1).Error_Posted := Val;
5065
      end Set_Flag24;
5066
 
5067
      procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
5068
      begin
5069
         pragma Assert (Nkind (N) in N_Entity);
5070
         Nodes.Table (N + 1).Flag4 := Val;
5071
      end Set_Flag25;
5072
 
5073
      procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
5074
      begin
5075
         pragma Assert (Nkind (N) in N_Entity);
5076
         Nodes.Table (N + 1).Flag5 := Val;
5077
      end Set_Flag26;
5078
 
5079
      procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
5080
      begin
5081
         pragma Assert (Nkind (N) in N_Entity);
5082
         Nodes.Table (N + 1).Flag6 := Val;
5083
      end Set_Flag27;
5084
 
5085
      procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
5086
      begin
5087
         pragma Assert (Nkind (N) in N_Entity);
5088
         Nodes.Table (N + 1).Flag7 := Val;
5089
      end Set_Flag28;
5090
 
5091
      procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
5092
      begin
5093
         pragma Assert (Nkind (N) in N_Entity);
5094
         Nodes.Table (N + 1).Flag8 := Val;
5095
      end Set_Flag29;
5096
 
5097
      procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
5098
      begin
5099
         pragma Assert (Nkind (N) in N_Entity);
5100
         Nodes.Table (N + 1).Flag9 := Val;
5101
      end Set_Flag30;
5102
 
5103
      procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
5104
      begin
5105
         pragma Assert (Nkind (N) in N_Entity);
5106
         Nodes.Table (N + 1).Flag10 := Val;
5107
      end Set_Flag31;
5108
 
5109
      procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
5110
      begin
5111
         pragma Assert (Nkind (N) in N_Entity);
5112
         Nodes.Table (N + 1).Flag11 := Val;
5113
      end Set_Flag32;
5114
 
5115
      procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
5116
      begin
5117
         pragma Assert (Nkind (N) in N_Entity);
5118
         Nodes.Table (N + 1).Flag12 := Val;
5119
      end Set_Flag33;
5120
 
5121
      procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
5122
      begin
5123
         pragma Assert (Nkind (N) in N_Entity);
5124
         Nodes.Table (N + 1).Flag13 := Val;
5125
      end Set_Flag34;
5126
 
5127
      procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
5128
      begin
5129
         pragma Assert (Nkind (N) in N_Entity);
5130
         Nodes.Table (N + 1).Flag14 := Val;
5131
      end Set_Flag35;
5132
 
5133
      procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
5134
      begin
5135
         pragma Assert (Nkind (N) in N_Entity);
5136
         Nodes.Table (N + 1).Flag15 := Val;
5137
      end Set_Flag36;
5138
 
5139
      procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
5140
      begin
5141
         pragma Assert (Nkind (N) in N_Entity);
5142
         Nodes.Table (N + 1).Flag16 := Val;
5143
      end Set_Flag37;
5144
 
5145
      procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
5146
      begin
5147
         pragma Assert (Nkind (N) in N_Entity);
5148
         Nodes.Table (N + 1).Flag17 := Val;
5149
      end Set_Flag38;
5150
 
5151
      procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
5152
      begin
5153
         pragma Assert (Nkind (N) in N_Entity);
5154
         Nodes.Table (N + 1).Flag18 := Val;
5155
      end Set_Flag39;
5156
 
5157
      procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
5158
      begin
5159
         pragma Assert (Nkind (N) in N_Entity);
5160
         Nodes.Table (N + 2).In_List := Val;
5161
      end Set_Flag40;
5162
 
5163
      procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
5164
      begin
5165
         pragma Assert (Nkind (N) in N_Entity);
5166
         Nodes.Table (N + 2).Has_Aspects := Val;
5167
      end Set_Flag41;
5168
 
5169
      procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
5170
      begin
5171
         pragma Assert (Nkind (N) in N_Entity);
5172
         Nodes.Table (N + 2).Rewrite_Ins := Val;
5173
      end Set_Flag42;
5174
 
5175
      procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
5176
      begin
5177
         pragma Assert (Nkind (N) in N_Entity);
5178
         Nodes.Table (N + 2).Analyzed := Val;
5179
      end Set_Flag43;
5180
 
5181
      procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
5182
      begin
5183
         pragma Assert (Nkind (N) in N_Entity);
5184
         Nodes.Table (N + 2).Comes_From_Source := Val;
5185
      end Set_Flag44;
5186
 
5187
      procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
5188
      begin
5189
         pragma Assert (Nkind (N) in N_Entity);
5190
         Nodes.Table (N + 2).Error_Posted := Val;
5191
      end Set_Flag45;
5192
 
5193
      procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
5194
      begin
5195
         pragma Assert (Nkind (N) in N_Entity);
5196
         Nodes.Table (N + 2).Flag4 := Val;
5197
      end Set_Flag46;
5198
 
5199
      procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
5200
      begin
5201
         pragma Assert (Nkind (N) in N_Entity);
5202
         Nodes.Table (N + 2).Flag5 := Val;
5203
      end Set_Flag47;
5204
 
5205
      procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
5206
      begin
5207
         pragma Assert (Nkind (N) in N_Entity);
5208
         Nodes.Table (N + 2).Flag6 := Val;
5209
      end Set_Flag48;
5210
 
5211
      procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
5212
      begin
5213
         pragma Assert (Nkind (N) in N_Entity);
5214
         Nodes.Table (N + 2).Flag7 := Val;
5215
      end Set_Flag49;
5216
 
5217
      procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
5218
      begin
5219
         pragma Assert (Nkind (N) in N_Entity);
5220
         Nodes.Table (N + 2).Flag8 := Val;
5221
      end Set_Flag50;
5222
 
5223
      procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
5224
      begin
5225
         pragma Assert (Nkind (N) in N_Entity);
5226
         Nodes.Table (N + 2).Flag9 := Val;
5227
      end Set_Flag51;
5228
 
5229
      procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
5230
      begin
5231
         pragma Assert (Nkind (N) in N_Entity);
5232
         Nodes.Table (N + 2).Flag10 := Val;
5233
      end Set_Flag52;
5234
 
5235
      procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
5236
      begin
5237
         pragma Assert (Nkind (N) in N_Entity);
5238
         Nodes.Table (N + 2).Flag11 := Val;
5239
      end Set_Flag53;
5240
 
5241
      procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
5242
      begin
5243
         pragma Assert (Nkind (N) in N_Entity);
5244
         Nodes.Table (N + 2).Flag12 := Val;
5245
      end Set_Flag54;
5246
 
5247
      procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
5248
      begin
5249
         pragma Assert (Nkind (N) in N_Entity);
5250
         Nodes.Table (N + 2).Flag13 := Val;
5251
      end Set_Flag55;
5252
 
5253
      procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
5254
      begin
5255
         pragma Assert (Nkind (N) in N_Entity);
5256
         Nodes.Table (N + 2).Flag14 := Val;
5257
      end Set_Flag56;
5258
 
5259
      procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
5260
      begin
5261
         pragma Assert (Nkind (N) in N_Entity);
5262
         Nodes.Table (N + 2).Flag15 := Val;
5263
      end Set_Flag57;
5264
 
5265
      procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
5266
      begin
5267
         pragma Assert (Nkind (N) in N_Entity);
5268
         Nodes.Table (N + 2).Flag16 := Val;
5269
      end Set_Flag58;
5270
 
5271
      procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
5272
      begin
5273
         pragma Assert (Nkind (N) in N_Entity);
5274
         Nodes.Table (N + 2).Flag17 := Val;
5275
      end Set_Flag59;
5276
 
5277
      procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
5278
      begin
5279
         pragma Assert (Nkind (N) in N_Entity);
5280
         Nodes.Table (N + 2).Flag18 := Val;
5281
      end Set_Flag60;
5282
 
5283
      procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
5284
      begin
5285
         pragma Assert (Nkind (N) in N_Entity);
5286
         Nodes.Table (N + 1).Pflag1 := Val;
5287
      end Set_Flag61;
5288
 
5289
      procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
5290
      begin
5291
         pragma Assert (Nkind (N) in N_Entity);
5292
         Nodes.Table (N + 1).Pflag2 := Val;
5293
      end Set_Flag62;
5294
 
5295
      procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
5296
      begin
5297
         pragma Assert (Nkind (N) in N_Entity);
5298
         Nodes.Table (N + 2).Pflag1 := Val;
5299
      end Set_Flag63;
5300
 
5301
      procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
5302
      begin
5303
         pragma Assert (Nkind (N) in N_Entity);
5304
         Nodes.Table (N + 2).Pflag2 := Val;
5305
      end Set_Flag64;
5306
 
5307
      procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
5308
      begin
5309
         pragma Assert (Nkind (N) in N_Entity);
5310
         To_Flag_Byte_Ptr
5311
           (Node_Kind_Ptr'
5312
             (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
5313
      end Set_Flag65;
5314
 
5315
      procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
5316
      begin
5317
         pragma Assert (Nkind (N) in N_Entity);
5318
         To_Flag_Byte_Ptr
5319
           (Node_Kind_Ptr'
5320
             (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
5321
      end Set_Flag66;
5322
 
5323
      procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
5324
      begin
5325
         pragma Assert (Nkind (N) in N_Entity);
5326
         To_Flag_Byte_Ptr
5327
           (Node_Kind_Ptr'
5328
             (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
5329
      end Set_Flag67;
5330
 
5331
      procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
5332
      begin
5333
         pragma Assert (Nkind (N) in N_Entity);
5334
         To_Flag_Byte_Ptr
5335
           (Node_Kind_Ptr'
5336
             (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
5337
      end Set_Flag68;
5338
 
5339
      procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
5340
      begin
5341
         pragma Assert (Nkind (N) in N_Entity);
5342
         To_Flag_Byte_Ptr
5343
           (Node_Kind_Ptr'
5344
             (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
5345
      end Set_Flag69;
5346
 
5347
      procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
5348
      begin
5349
         pragma Assert (Nkind (N) in N_Entity);
5350
         To_Flag_Byte_Ptr
5351
           (Node_Kind_Ptr'
5352
             (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
5353
      end Set_Flag70;
5354
 
5355
      procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
5356
      begin
5357
         pragma Assert (Nkind (N) in N_Entity);
5358
         To_Flag_Byte_Ptr
5359
           (Node_Kind_Ptr'
5360
             (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
5361
      end Set_Flag71;
5362
 
5363
      procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
5364
      begin
5365
         pragma Assert (Nkind (N) in N_Entity);
5366
         To_Flag_Byte_Ptr
5367
           (Node_Kind_Ptr'
5368
             (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
5369
      end Set_Flag72;
5370
 
5371
      procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
5372
      begin
5373
         pragma Assert (Nkind (N) in N_Entity);
5374
         To_Flag_Word_Ptr
5375
           (Union_Id_Ptr'
5376
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
5377
      end Set_Flag73;
5378
 
5379
      procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
5380
      begin
5381
         pragma Assert (Nkind (N) in N_Entity);
5382
         To_Flag_Word_Ptr
5383
           (Union_Id_Ptr'
5384
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
5385
      end Set_Flag74;
5386
 
5387
      procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
5388
      begin
5389
         pragma Assert (Nkind (N) in N_Entity);
5390
         To_Flag_Word_Ptr
5391
           (Union_Id_Ptr'
5392
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
5393
      end Set_Flag75;
5394
 
5395
      procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
5396
      begin
5397
         pragma Assert (Nkind (N) in N_Entity);
5398
         To_Flag_Word_Ptr
5399
           (Union_Id_Ptr'
5400
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
5401
      end Set_Flag76;
5402
 
5403
      procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
5404
      begin
5405
         pragma Assert (Nkind (N) in N_Entity);
5406
         To_Flag_Word_Ptr
5407
           (Union_Id_Ptr'
5408
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
5409
      end Set_Flag77;
5410
 
5411
      procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
5412
      begin
5413
         pragma Assert (Nkind (N) in N_Entity);
5414
         To_Flag_Word_Ptr
5415
           (Union_Id_Ptr'
5416
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
5417
      end Set_Flag78;
5418
 
5419
      procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
5420
      begin
5421
         pragma Assert (Nkind (N) in N_Entity);
5422
         To_Flag_Word_Ptr
5423
           (Union_Id_Ptr'
5424
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
5425
      end Set_Flag79;
5426
 
5427
      procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
5428
      begin
5429
         pragma Assert (Nkind (N) in N_Entity);
5430
         To_Flag_Word_Ptr
5431
           (Union_Id_Ptr'
5432
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
5433
      end Set_Flag80;
5434
 
5435
      procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
5436
      begin
5437
         pragma Assert (Nkind (N) in N_Entity);
5438
         To_Flag_Word_Ptr
5439
           (Union_Id_Ptr'
5440
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
5441
      end Set_Flag81;
5442
 
5443
      procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
5444
      begin
5445
         pragma Assert (Nkind (N) in N_Entity);
5446
         To_Flag_Word_Ptr
5447
           (Union_Id_Ptr'
5448
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
5449
      end Set_Flag82;
5450
 
5451
      procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
5452
      begin
5453
         pragma Assert (Nkind (N) in N_Entity);
5454
         To_Flag_Word_Ptr
5455
           (Union_Id_Ptr'
5456
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
5457
      end Set_Flag83;
5458
 
5459
      procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
5460
      begin
5461
         pragma Assert (Nkind (N) in N_Entity);
5462
         To_Flag_Word_Ptr
5463
           (Union_Id_Ptr'
5464
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
5465
      end Set_Flag84;
5466
 
5467
      procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
5468
      begin
5469
         pragma Assert (Nkind (N) in N_Entity);
5470
         To_Flag_Word_Ptr
5471
           (Union_Id_Ptr'
5472
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
5473
      end Set_Flag85;
5474
 
5475
      procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
5476
      begin
5477
         pragma Assert (Nkind (N) in N_Entity);
5478
         To_Flag_Word_Ptr
5479
           (Union_Id_Ptr'
5480
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
5481
      end Set_Flag86;
5482
 
5483
      procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
5484
      begin
5485
         pragma Assert (Nkind (N) in N_Entity);
5486
         To_Flag_Word_Ptr
5487
           (Union_Id_Ptr'
5488
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
5489
      end Set_Flag87;
5490
 
5491
      procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
5492
      begin
5493
         pragma Assert (Nkind (N) in N_Entity);
5494
         To_Flag_Word_Ptr
5495
           (Union_Id_Ptr'
5496
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
5497
      end Set_Flag88;
5498
 
5499
      procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
5500
      begin
5501
         pragma Assert (Nkind (N) in N_Entity);
5502
         To_Flag_Word_Ptr
5503
           (Union_Id_Ptr'
5504
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
5505
      end Set_Flag89;
5506
 
5507
      procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
5508
      begin
5509
         pragma Assert (Nkind (N) in N_Entity);
5510
         To_Flag_Word_Ptr
5511
           (Union_Id_Ptr'
5512
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
5513
      end Set_Flag90;
5514
 
5515
      procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
5516
      begin
5517
         pragma Assert (Nkind (N) in N_Entity);
5518
         To_Flag_Word_Ptr
5519
           (Union_Id_Ptr'
5520
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
5521
      end Set_Flag91;
5522
 
5523
      procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
5524
      begin
5525
         pragma Assert (Nkind (N) in N_Entity);
5526
         To_Flag_Word_Ptr
5527
           (Union_Id_Ptr'
5528
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
5529
      end Set_Flag92;
5530
 
5531
      procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
5532
      begin
5533
         pragma Assert (Nkind (N) in N_Entity);
5534
         To_Flag_Word_Ptr
5535
           (Union_Id_Ptr'
5536
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
5537
      end Set_Flag93;
5538
 
5539
      procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
5540
      begin
5541
         pragma Assert (Nkind (N) in N_Entity);
5542
         To_Flag_Word_Ptr
5543
           (Union_Id_Ptr'
5544
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
5545
      end Set_Flag94;
5546
 
5547
      procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
5548
      begin
5549
         pragma Assert (Nkind (N) in N_Entity);
5550
         To_Flag_Word_Ptr
5551
           (Union_Id_Ptr'
5552
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
5553
      end Set_Flag95;
5554
 
5555
      procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
5556
      begin
5557
         pragma Assert (Nkind (N) in N_Entity);
5558
         To_Flag_Word_Ptr
5559
           (Union_Id_Ptr'
5560
             (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
5561
      end Set_Flag96;
5562
 
5563
      procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
5564
      begin
5565
         pragma Assert (Nkind (N) in N_Entity);
5566
         To_Flag_Word2_Ptr
5567
           (Union_Id_Ptr'
5568
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
5569
      end Set_Flag97;
5570
 
5571
      procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
5572
      begin
5573
         pragma Assert (Nkind (N) in N_Entity);
5574
         To_Flag_Word2_Ptr
5575
           (Union_Id_Ptr'
5576
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
5577
      end Set_Flag98;
5578
 
5579
      procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
5580
      begin
5581
         pragma Assert (Nkind (N) in N_Entity);
5582
         To_Flag_Word2_Ptr
5583
           (Union_Id_Ptr'
5584
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
5585
      end Set_Flag99;
5586
 
5587
      procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
5588
      begin
5589
         pragma Assert (Nkind (N) in N_Entity);
5590
         To_Flag_Word2_Ptr
5591
           (Union_Id_Ptr'
5592
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
5593
      end Set_Flag100;
5594
 
5595
      procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
5596
      begin
5597
         pragma Assert (Nkind (N) in N_Entity);
5598
         To_Flag_Word2_Ptr
5599
           (Union_Id_Ptr'
5600
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
5601
      end Set_Flag101;
5602
 
5603
      procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
5604
      begin
5605
         pragma Assert (Nkind (N) in N_Entity);
5606
         To_Flag_Word2_Ptr
5607
           (Union_Id_Ptr'
5608
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
5609
      end Set_Flag102;
5610
 
5611
      procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
5612
      begin
5613
         pragma Assert (Nkind (N) in N_Entity);
5614
         To_Flag_Word2_Ptr
5615
           (Union_Id_Ptr'
5616
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
5617
      end Set_Flag103;
5618
 
5619
      procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
5620
      begin
5621
         pragma Assert (Nkind (N) in N_Entity);
5622
         To_Flag_Word2_Ptr
5623
           (Union_Id_Ptr'
5624
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
5625
      end Set_Flag104;
5626
 
5627
      procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
5628
      begin
5629
         pragma Assert (Nkind (N) in N_Entity);
5630
         To_Flag_Word2_Ptr
5631
           (Union_Id_Ptr'
5632
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
5633
      end Set_Flag105;
5634
 
5635
      procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
5636
      begin
5637
         pragma Assert (Nkind (N) in N_Entity);
5638
         To_Flag_Word2_Ptr
5639
           (Union_Id_Ptr'
5640
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
5641
      end Set_Flag106;
5642
 
5643
      procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
5644
      begin
5645
         pragma Assert (Nkind (N) in N_Entity);
5646
         To_Flag_Word2_Ptr
5647
           (Union_Id_Ptr'
5648
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
5649
      end Set_Flag107;
5650
 
5651
      procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
5652
      begin
5653
         pragma Assert (Nkind (N) in N_Entity);
5654
         To_Flag_Word2_Ptr
5655
           (Union_Id_Ptr'
5656
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
5657
      end Set_Flag108;
5658
 
5659
      procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
5660
      begin
5661
         pragma Assert (Nkind (N) in N_Entity);
5662
         To_Flag_Word2_Ptr
5663
           (Union_Id_Ptr'
5664
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
5665
      end Set_Flag109;
5666
 
5667
      procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
5668
      begin
5669
         pragma Assert (Nkind (N) in N_Entity);
5670
         To_Flag_Word2_Ptr
5671
           (Union_Id_Ptr'
5672
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
5673
      end Set_Flag110;
5674
 
5675
      procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
5676
      begin
5677
         pragma Assert (Nkind (N) in N_Entity);
5678
         To_Flag_Word2_Ptr
5679
           (Union_Id_Ptr'
5680
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
5681
      end Set_Flag111;
5682
 
5683
      procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
5684
      begin
5685
         pragma Assert (Nkind (N) in N_Entity);
5686
         To_Flag_Word2_Ptr
5687
           (Union_Id_Ptr'
5688
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
5689
      end Set_Flag112;
5690
 
5691
      procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
5692
      begin
5693
         pragma Assert (Nkind (N) in N_Entity);
5694
         To_Flag_Word2_Ptr
5695
           (Union_Id_Ptr'
5696
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
5697
      end Set_Flag113;
5698
 
5699
      procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
5700
      begin
5701
         pragma Assert (Nkind (N) in N_Entity);
5702
         To_Flag_Word2_Ptr
5703
           (Union_Id_Ptr'
5704
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
5705
      end Set_Flag114;
5706
 
5707
      procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
5708
      begin
5709
         pragma Assert (Nkind (N) in N_Entity);
5710
         To_Flag_Word2_Ptr
5711
           (Union_Id_Ptr'
5712
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
5713
      end Set_Flag115;
5714
 
5715
      procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
5716
      begin
5717
         pragma Assert (Nkind (N) in N_Entity);
5718
         To_Flag_Word2_Ptr
5719
           (Union_Id_Ptr'
5720
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
5721
      end Set_Flag116;
5722
 
5723
      procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
5724
      begin
5725
         pragma Assert (Nkind (N) in N_Entity);
5726
         To_Flag_Word2_Ptr
5727
           (Union_Id_Ptr'
5728
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
5729
      end Set_Flag117;
5730
 
5731
      procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
5732
      begin
5733
         pragma Assert (Nkind (N) in N_Entity);
5734
         To_Flag_Word2_Ptr
5735
           (Union_Id_Ptr'
5736
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
5737
      end Set_Flag118;
5738
 
5739
      procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
5740
      begin
5741
         pragma Assert (Nkind (N) in N_Entity);
5742
         To_Flag_Word2_Ptr
5743
           (Union_Id_Ptr'
5744
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
5745
      end Set_Flag119;
5746
 
5747
      procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
5748
      begin
5749
         pragma Assert (Nkind (N) in N_Entity);
5750
         To_Flag_Word2_Ptr
5751
           (Union_Id_Ptr'
5752
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
5753
      end Set_Flag120;
5754
 
5755
      procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
5756
      begin
5757
         pragma Assert (Nkind (N) in N_Entity);
5758
         To_Flag_Word2_Ptr
5759
           (Union_Id_Ptr'
5760
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
5761
      end Set_Flag121;
5762
 
5763
      procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
5764
      begin
5765
         pragma Assert (Nkind (N) in N_Entity);
5766
         To_Flag_Word2_Ptr
5767
           (Union_Id_Ptr'
5768
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
5769
      end Set_Flag122;
5770
 
5771
      procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
5772
      begin
5773
         pragma Assert (Nkind (N) in N_Entity);
5774
         To_Flag_Word2_Ptr
5775
           (Union_Id_Ptr'
5776
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
5777
      end Set_Flag123;
5778
 
5779
      procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
5780
      begin
5781
         pragma Assert (Nkind (N) in N_Entity);
5782
         To_Flag_Word2_Ptr
5783
           (Union_Id_Ptr'
5784
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
5785
      end Set_Flag124;
5786
 
5787
      procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
5788
      begin
5789
         pragma Assert (Nkind (N) in N_Entity);
5790
         To_Flag_Word2_Ptr
5791
           (Union_Id_Ptr'
5792
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
5793
      end Set_Flag125;
5794
 
5795
      procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
5796
      begin
5797
         pragma Assert (Nkind (N) in N_Entity);
5798
         To_Flag_Word2_Ptr
5799
           (Union_Id_Ptr'
5800
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
5801
      end Set_Flag126;
5802
 
5803
      procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
5804
      begin
5805
         pragma Assert (Nkind (N) in N_Entity);
5806
         To_Flag_Word2_Ptr
5807
           (Union_Id_Ptr'
5808
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
5809
      end Set_Flag127;
5810
 
5811
      procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
5812
      begin
5813
         pragma Assert (Nkind (N) in N_Entity);
5814
         To_Flag_Word2_Ptr
5815
           (Union_Id_Ptr'
5816
             (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
5817
      end Set_Flag128;
5818
 
5819
      procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
5820
      begin
5821
         pragma Assert (Nkind (N) in N_Entity);
5822
         Nodes.Table (N + 3).In_List := Val;
5823
      end Set_Flag129;
5824
 
5825
      procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
5826
      begin
5827
         pragma Assert (Nkind (N) in N_Entity);
5828
         Nodes.Table (N + 3).Has_Aspects := Val;
5829
      end Set_Flag130;
5830
 
5831
      procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
5832
      begin
5833
         pragma Assert (Nkind (N) in N_Entity);
5834
         Nodes.Table (N + 3).Rewrite_Ins := Val;
5835
      end Set_Flag131;
5836
 
5837
      procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
5838
      begin
5839
         pragma Assert (Nkind (N) in N_Entity);
5840
         Nodes.Table (N + 3).Analyzed := Val;
5841
      end Set_Flag132;
5842
 
5843
      procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
5844
      begin
5845
         pragma Assert (Nkind (N) in N_Entity);
5846
         Nodes.Table (N + 3).Comes_From_Source := Val;
5847
      end Set_Flag133;
5848
 
5849
      procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
5850
      begin
5851
         pragma Assert (Nkind (N) in N_Entity);
5852
         Nodes.Table (N + 3).Error_Posted := Val;
5853
      end Set_Flag134;
5854
 
5855
      procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
5856
      begin
5857
         pragma Assert (Nkind (N) in N_Entity);
5858
         Nodes.Table (N + 3).Flag4 := Val;
5859
      end Set_Flag135;
5860
 
5861
      procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
5862
      begin
5863
         pragma Assert (Nkind (N) in N_Entity);
5864
         Nodes.Table (N + 3).Flag5 := Val;
5865
      end Set_Flag136;
5866
 
5867
      procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
5868
      begin
5869
         pragma Assert (Nkind (N) in N_Entity);
5870
         Nodes.Table (N + 3).Flag6 := Val;
5871
      end Set_Flag137;
5872
 
5873
      procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
5874
      begin
5875
         pragma Assert (Nkind (N) in N_Entity);
5876
         Nodes.Table (N + 3).Flag7 := Val;
5877
      end Set_Flag138;
5878
 
5879
      procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
5880
      begin
5881
         pragma Assert (Nkind (N) in N_Entity);
5882
         Nodes.Table (N + 3).Flag8 := Val;
5883
      end Set_Flag139;
5884
 
5885
      procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
5886
      begin
5887
         pragma Assert (Nkind (N) in N_Entity);
5888
         Nodes.Table (N + 3).Flag9 := Val;
5889
      end Set_Flag140;
5890
 
5891
      procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
5892
      begin
5893
         pragma Assert (Nkind (N) in N_Entity);
5894
         Nodes.Table (N + 3).Flag10 := Val;
5895
      end Set_Flag141;
5896
 
5897
      procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
5898
      begin
5899
         pragma Assert (Nkind (N) in N_Entity);
5900
         Nodes.Table (N + 3).Flag11 := Val;
5901
      end Set_Flag142;
5902
 
5903
      procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
5904
      begin
5905
         pragma Assert (Nkind (N) in N_Entity);
5906
         Nodes.Table (N + 3).Flag12 := Val;
5907
      end Set_Flag143;
5908
 
5909
      procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
5910
      begin
5911
         pragma Assert (Nkind (N) in N_Entity);
5912
         Nodes.Table (N + 3).Flag13 := Val;
5913
      end Set_Flag144;
5914
 
5915
      procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
5916
      begin
5917
         pragma Assert (Nkind (N) in N_Entity);
5918
         Nodes.Table (N + 3).Flag14 := Val;
5919
      end Set_Flag145;
5920
 
5921
      procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
5922
      begin
5923
         pragma Assert (Nkind (N) in N_Entity);
5924
         Nodes.Table (N + 3).Flag15 := Val;
5925
      end Set_Flag146;
5926
 
5927
      procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
5928
      begin
5929
         pragma Assert (Nkind (N) in N_Entity);
5930
         Nodes.Table (N + 3).Flag16 := Val;
5931
      end Set_Flag147;
5932
 
5933
      procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
5934
      begin
5935
         pragma Assert (Nkind (N) in N_Entity);
5936
         Nodes.Table (N + 3).Flag17 := Val;
5937
      end Set_Flag148;
5938
 
5939
      procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
5940
      begin
5941
         pragma Assert (Nkind (N) in N_Entity);
5942
         Nodes.Table (N + 3).Flag18 := Val;
5943
      end Set_Flag149;
5944
 
5945
      procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
5946
      begin
5947
         pragma Assert (Nkind (N) in N_Entity);
5948
         Nodes.Table (N + 3).Pflag1 := Val;
5949
      end Set_Flag150;
5950
 
5951
      procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
5952
      begin
5953
         pragma Assert (Nkind (N) in N_Entity);
5954
         Nodes.Table (N + 3).Pflag2 := Val;
5955
      end Set_Flag151;
5956
 
5957
      procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
5958
      begin
5959
         pragma Assert (Nkind (N) in N_Entity);
5960
         To_Flag_Word3_Ptr
5961
           (Union_Id_Ptr'
5962
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
5963
      end Set_Flag152;
5964
 
5965
      procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
5966
      begin
5967
         pragma Assert (Nkind (N) in N_Entity);
5968
         To_Flag_Word3_Ptr
5969
           (Union_Id_Ptr'
5970
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
5971
      end Set_Flag153;
5972
 
5973
      procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
5974
      begin
5975
         pragma Assert (Nkind (N) in N_Entity);
5976
         To_Flag_Word3_Ptr
5977
           (Union_Id_Ptr'
5978
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
5979
      end Set_Flag154;
5980
 
5981
      procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
5982
      begin
5983
         pragma Assert (Nkind (N) in N_Entity);
5984
         To_Flag_Word3_Ptr
5985
           (Union_Id_Ptr'
5986
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
5987
      end Set_Flag155;
5988
 
5989
      procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
5990
      begin
5991
         pragma Assert (Nkind (N) in N_Entity);
5992
         To_Flag_Word3_Ptr
5993
           (Union_Id_Ptr'
5994
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
5995
      end Set_Flag156;
5996
 
5997
      procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
5998
      begin
5999
         pragma Assert (Nkind (N) in N_Entity);
6000
         To_Flag_Word3_Ptr
6001
           (Union_Id_Ptr'
6002
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
6003
      end Set_Flag157;
6004
 
6005
      procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
6006
      begin
6007
         pragma Assert (Nkind (N) in N_Entity);
6008
         To_Flag_Word3_Ptr
6009
           (Union_Id_Ptr'
6010
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
6011
      end Set_Flag158;
6012
 
6013
      procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
6014
      begin
6015
         pragma Assert (Nkind (N) in N_Entity);
6016
         To_Flag_Word3_Ptr
6017
           (Union_Id_Ptr'
6018
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
6019
      end Set_Flag159;
6020
 
6021
      procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
6022
      begin
6023
         pragma Assert (Nkind (N) in N_Entity);
6024
         To_Flag_Word3_Ptr
6025
           (Union_Id_Ptr'
6026
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
6027
      end Set_Flag160;
6028
 
6029
      procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
6030
      begin
6031
         pragma Assert (Nkind (N) in N_Entity);
6032
         To_Flag_Word3_Ptr
6033
           (Union_Id_Ptr'
6034
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
6035
      end Set_Flag161;
6036
 
6037
      procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
6038
      begin
6039
         pragma Assert (Nkind (N) in N_Entity);
6040
         To_Flag_Word3_Ptr
6041
           (Union_Id_Ptr'
6042
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
6043
      end Set_Flag162;
6044
 
6045
      procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
6046
      begin
6047
         pragma Assert (Nkind (N) in N_Entity);
6048
         To_Flag_Word3_Ptr
6049
           (Union_Id_Ptr'
6050
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
6051
      end Set_Flag163;
6052
 
6053
      procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
6054
      begin
6055
         pragma Assert (Nkind (N) in N_Entity);
6056
         To_Flag_Word3_Ptr
6057
           (Union_Id_Ptr'
6058
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
6059
      end Set_Flag164;
6060
 
6061
      procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
6062
      begin
6063
         pragma Assert (Nkind (N) in N_Entity);
6064
         To_Flag_Word3_Ptr
6065
           (Union_Id_Ptr'
6066
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
6067
      end Set_Flag165;
6068
 
6069
      procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
6070
      begin
6071
         pragma Assert (Nkind (N) in N_Entity);
6072
         To_Flag_Word3_Ptr
6073
           (Union_Id_Ptr'
6074
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
6075
      end Set_Flag166;
6076
 
6077
      procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
6078
      begin
6079
         pragma Assert (Nkind (N) in N_Entity);
6080
         To_Flag_Word3_Ptr
6081
           (Union_Id_Ptr'
6082
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
6083
      end Set_Flag167;
6084
 
6085
      procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
6086
      begin
6087
         pragma Assert (Nkind (N) in N_Entity);
6088
         To_Flag_Word3_Ptr
6089
           (Union_Id_Ptr'
6090
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
6091
      end Set_Flag168;
6092
 
6093
      procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
6094
      begin
6095
         pragma Assert (Nkind (N) in N_Entity);
6096
         To_Flag_Word3_Ptr
6097
           (Union_Id_Ptr'
6098
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
6099
      end Set_Flag169;
6100
 
6101
      procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
6102
      begin
6103
         pragma Assert (Nkind (N) in N_Entity);
6104
         To_Flag_Word3_Ptr
6105
           (Union_Id_Ptr'
6106
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
6107
      end Set_Flag170;
6108
 
6109
      procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
6110
      begin
6111
         pragma Assert (Nkind (N) in N_Entity);
6112
         To_Flag_Word3_Ptr
6113
           (Union_Id_Ptr'
6114
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
6115
      end Set_Flag171;
6116
 
6117
      procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
6118
      begin
6119
         pragma Assert (Nkind (N) in N_Entity);
6120
         To_Flag_Word3_Ptr
6121
           (Union_Id_Ptr'
6122
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
6123
      end Set_Flag172;
6124
 
6125
      procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
6126
      begin
6127
         pragma Assert (Nkind (N) in N_Entity);
6128
         To_Flag_Word3_Ptr
6129
           (Union_Id_Ptr'
6130
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
6131
      end Set_Flag173;
6132
 
6133
      procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
6134
      begin
6135
         pragma Assert (Nkind (N) in N_Entity);
6136
         To_Flag_Word3_Ptr
6137
           (Union_Id_Ptr'
6138
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
6139
      end Set_Flag174;
6140
 
6141
      procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
6142
      begin
6143
         pragma Assert (Nkind (N) in N_Entity);
6144
         To_Flag_Word3_Ptr
6145
           (Union_Id_Ptr'
6146
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
6147
      end Set_Flag175;
6148
 
6149
      procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
6150
      begin
6151
         pragma Assert (Nkind (N) in N_Entity);
6152
         To_Flag_Word3_Ptr
6153
           (Union_Id_Ptr'
6154
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
6155
      end Set_Flag176;
6156
 
6157
      procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
6158
      begin
6159
         pragma Assert (Nkind (N) in N_Entity);
6160
         To_Flag_Word3_Ptr
6161
           (Union_Id_Ptr'
6162
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
6163
      end Set_Flag177;
6164
 
6165
      procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
6166
      begin
6167
         pragma Assert (Nkind (N) in N_Entity);
6168
         To_Flag_Word3_Ptr
6169
           (Union_Id_Ptr'
6170
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
6171
      end Set_Flag178;
6172
 
6173
      procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
6174
      begin
6175
         pragma Assert (Nkind (N) in N_Entity);
6176
         To_Flag_Word3_Ptr
6177
           (Union_Id_Ptr'
6178
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
6179
      end Set_Flag179;
6180
 
6181
      procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
6182
      begin
6183
         pragma Assert (Nkind (N) in N_Entity);
6184
         To_Flag_Word3_Ptr
6185
           (Union_Id_Ptr'
6186
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
6187
      end Set_Flag180;
6188
 
6189
      procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
6190
      begin
6191
         pragma Assert (Nkind (N) in N_Entity);
6192
         To_Flag_Word3_Ptr
6193
           (Union_Id_Ptr'
6194
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
6195
      end Set_Flag181;
6196
 
6197
      procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
6198
      begin
6199
         pragma Assert (Nkind (N) in N_Entity);
6200
         To_Flag_Word3_Ptr
6201
           (Union_Id_Ptr'
6202
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
6203
      end Set_Flag182;
6204
 
6205
      procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
6206
      begin
6207
         pragma Assert (Nkind (N) in N_Entity);
6208
         To_Flag_Word3_Ptr
6209
           (Union_Id_Ptr'
6210
             (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
6211
      end Set_Flag183;
6212
 
6213
      procedure Set_Flag184 (N : Node_Id; Val : Boolean) is
6214
      begin
6215
         pragma Assert (Nkind (N) in N_Entity);
6216
         To_Flag_Word4_Ptr
6217
           (Union_Id_Ptr'
6218
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag184 := Val;
6219
      end Set_Flag184;
6220
 
6221
      procedure Set_Flag185 (N : Node_Id; Val : Boolean) is
6222
      begin
6223
         pragma Assert (Nkind (N) in N_Entity);
6224
         To_Flag_Word4_Ptr
6225
           (Union_Id_Ptr'
6226
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag185 := Val;
6227
      end Set_Flag185;
6228
 
6229
      procedure Set_Flag186 (N : Node_Id; Val : Boolean) is
6230
      begin
6231
         pragma Assert (Nkind (N) in N_Entity);
6232
         To_Flag_Word4_Ptr
6233
           (Union_Id_Ptr'
6234
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag186 := Val;
6235
      end Set_Flag186;
6236
 
6237
      procedure Set_Flag187 (N : Node_Id; Val : Boolean) is
6238
      begin
6239
         pragma Assert (Nkind (N) in N_Entity);
6240
         To_Flag_Word4_Ptr
6241
           (Union_Id_Ptr'
6242
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag187 := Val;
6243
      end Set_Flag187;
6244
 
6245
      procedure Set_Flag188 (N : Node_Id; Val : Boolean) is
6246
      begin
6247
         pragma Assert (Nkind (N) in N_Entity);
6248
         To_Flag_Word4_Ptr
6249
           (Union_Id_Ptr'
6250
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag188 := Val;
6251
      end Set_Flag188;
6252
 
6253
      procedure Set_Flag189 (N : Node_Id; Val : Boolean) is
6254
      begin
6255
         pragma Assert (Nkind (N) in N_Entity);
6256
         To_Flag_Word4_Ptr
6257
           (Union_Id_Ptr'
6258
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag189 := Val;
6259
      end Set_Flag189;
6260
 
6261
      procedure Set_Flag190 (N : Node_Id; Val : Boolean) is
6262
      begin
6263
         pragma Assert (Nkind (N) in N_Entity);
6264
         To_Flag_Word4_Ptr
6265
           (Union_Id_Ptr'
6266
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag190 := Val;
6267
      end Set_Flag190;
6268
 
6269
      procedure Set_Flag191 (N : Node_Id; Val : Boolean) is
6270
      begin
6271
         pragma Assert (Nkind (N) in N_Entity);
6272
         To_Flag_Word4_Ptr
6273
           (Union_Id_Ptr'
6274
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag191 := Val;
6275
      end Set_Flag191;
6276
 
6277
      procedure Set_Flag192 (N : Node_Id; Val : Boolean) is
6278
      begin
6279
         pragma Assert (Nkind (N) in N_Entity);
6280
         To_Flag_Word4_Ptr
6281
           (Union_Id_Ptr'
6282
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag192 := Val;
6283
      end Set_Flag192;
6284
 
6285
      procedure Set_Flag193 (N : Node_Id; Val : Boolean) is
6286
      begin
6287
         pragma Assert (Nkind (N) in N_Entity);
6288
         To_Flag_Word4_Ptr
6289
           (Union_Id_Ptr'
6290
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag193 := Val;
6291
      end Set_Flag193;
6292
 
6293
      procedure Set_Flag194 (N : Node_Id; Val : Boolean) is
6294
      begin
6295
         pragma Assert (Nkind (N) in N_Entity);
6296
         To_Flag_Word4_Ptr
6297
           (Union_Id_Ptr'
6298
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag194 := Val;
6299
      end Set_Flag194;
6300
 
6301
      procedure Set_Flag195 (N : Node_Id; Val : Boolean) is
6302
      begin
6303
         pragma Assert (Nkind (N) in N_Entity);
6304
         To_Flag_Word4_Ptr
6305
           (Union_Id_Ptr'
6306
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag195 := Val;
6307
      end Set_Flag195;
6308
 
6309
      procedure Set_Flag196 (N : Node_Id; Val : Boolean) is
6310
      begin
6311
         pragma Assert (Nkind (N) in N_Entity);
6312
         To_Flag_Word4_Ptr
6313
           (Union_Id_Ptr'
6314
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag196 := Val;
6315
      end Set_Flag196;
6316
 
6317
      procedure Set_Flag197 (N : Node_Id; Val : Boolean) is
6318
      begin
6319
         pragma Assert (Nkind (N) in N_Entity);
6320
         To_Flag_Word4_Ptr
6321
           (Union_Id_Ptr'
6322
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag197 := Val;
6323
      end Set_Flag197;
6324
 
6325
      procedure Set_Flag198 (N : Node_Id; Val : Boolean) is
6326
      begin
6327
         pragma Assert (Nkind (N) in N_Entity);
6328
         To_Flag_Word4_Ptr
6329
           (Union_Id_Ptr'
6330
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag198 := Val;
6331
      end Set_Flag198;
6332
 
6333
      procedure Set_Flag199 (N : Node_Id; Val : Boolean) is
6334
      begin
6335
         pragma Assert (Nkind (N) in N_Entity);
6336
         To_Flag_Word4_Ptr
6337
           (Union_Id_Ptr'
6338
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag199 := Val;
6339
      end Set_Flag199;
6340
 
6341
      procedure Set_Flag200 (N : Node_Id; Val : Boolean) is
6342
      begin
6343
         pragma Assert (Nkind (N) in N_Entity);
6344
         To_Flag_Word4_Ptr
6345
           (Union_Id_Ptr'
6346
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag200 := Val;
6347
      end Set_Flag200;
6348
 
6349
      procedure Set_Flag201 (N : Node_Id; Val : Boolean) is
6350
      begin
6351
         pragma Assert (Nkind (N) in N_Entity);
6352
         To_Flag_Word4_Ptr
6353
           (Union_Id_Ptr'
6354
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag201 := Val;
6355
      end Set_Flag201;
6356
 
6357
      procedure Set_Flag202 (N : Node_Id; Val : Boolean) is
6358
      begin
6359
         pragma Assert (Nkind (N) in N_Entity);
6360
         To_Flag_Word4_Ptr
6361
           (Union_Id_Ptr'
6362
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag202 := Val;
6363
      end Set_Flag202;
6364
 
6365
      procedure Set_Flag203 (N : Node_Id; Val : Boolean) is
6366
      begin
6367
         pragma Assert (Nkind (N) in N_Entity);
6368
         To_Flag_Word4_Ptr
6369
           (Union_Id_Ptr'
6370
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag203 := Val;
6371
      end Set_Flag203;
6372
 
6373
      procedure Set_Flag204 (N : Node_Id; Val : Boolean) is
6374
      begin
6375
         pragma Assert (Nkind (N) in N_Entity);
6376
         To_Flag_Word4_Ptr
6377
           (Union_Id_Ptr'
6378
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag204 := Val;
6379
      end Set_Flag204;
6380
 
6381
      procedure Set_Flag205 (N : Node_Id; Val : Boolean) is
6382
      begin
6383
         pragma Assert (Nkind (N) in N_Entity);
6384
         To_Flag_Word4_Ptr
6385
           (Union_Id_Ptr'
6386
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag205 := Val;
6387
      end Set_Flag205;
6388
 
6389
      procedure Set_Flag206 (N : Node_Id; Val : Boolean) is
6390
      begin
6391
         pragma Assert (Nkind (N) in N_Entity);
6392
         To_Flag_Word4_Ptr
6393
           (Union_Id_Ptr'
6394
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag206 := Val;
6395
      end Set_Flag206;
6396
 
6397
      procedure Set_Flag207 (N : Node_Id; Val : Boolean) is
6398
      begin
6399
         pragma Assert (Nkind (N) in N_Entity);
6400
         To_Flag_Word4_Ptr
6401
           (Union_Id_Ptr'
6402
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag207 := Val;
6403
      end Set_Flag207;
6404
 
6405
      procedure Set_Flag208 (N : Node_Id; Val : Boolean) is
6406
      begin
6407
         pragma Assert (Nkind (N) in N_Entity);
6408
         To_Flag_Word4_Ptr
6409
           (Union_Id_Ptr'
6410
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag208 := Val;
6411
      end Set_Flag208;
6412
 
6413
      procedure Set_Flag209 (N : Node_Id; Val : Boolean) is
6414
      begin
6415
         pragma Assert (Nkind (N) in N_Entity);
6416
         To_Flag_Word4_Ptr
6417
           (Union_Id_Ptr'
6418
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag209 := Val;
6419
      end Set_Flag209;
6420
 
6421
      procedure Set_Flag210 (N : Node_Id; Val : Boolean) is
6422
      begin
6423
         pragma Assert (Nkind (N) in N_Entity);
6424
         To_Flag_Word4_Ptr
6425
           (Union_Id_Ptr'
6426
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag210 := Val;
6427
      end Set_Flag210;
6428
 
6429
      procedure Set_Flag211 (N : Node_Id; Val : Boolean) is
6430
      begin
6431
         pragma Assert (Nkind (N) in N_Entity);
6432
         To_Flag_Word4_Ptr
6433
           (Union_Id_Ptr'
6434
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag211 := Val;
6435
      end Set_Flag211;
6436
 
6437
      procedure Set_Flag212 (N : Node_Id; Val : Boolean) is
6438
      begin
6439
         pragma Assert (Nkind (N) in N_Entity);
6440
         To_Flag_Word4_Ptr
6441
           (Union_Id_Ptr'
6442
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag212 := Val;
6443
      end Set_Flag212;
6444
 
6445
      procedure Set_Flag213 (N : Node_Id; Val : Boolean) is
6446
      begin
6447
         pragma Assert (Nkind (N) in N_Entity);
6448
         To_Flag_Word4_Ptr
6449
           (Union_Id_Ptr'
6450
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag213 := Val;
6451
      end Set_Flag213;
6452
 
6453
      procedure Set_Flag214 (N : Node_Id; Val : Boolean) is
6454
      begin
6455
         pragma Assert (Nkind (N) in N_Entity);
6456
         To_Flag_Word4_Ptr
6457
           (Union_Id_Ptr'
6458
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag214 := Val;
6459
      end Set_Flag214;
6460
 
6461
      procedure Set_Flag215 (N : Node_Id; Val : Boolean) is
6462
      begin
6463
         pragma Assert (Nkind (N) in N_Entity);
6464
         To_Flag_Word4_Ptr
6465
           (Union_Id_Ptr'
6466
             (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag215 := Val;
6467
      end Set_Flag215;
6468
 
6469
      procedure Set_Flag216 (N : Node_Id; Val : Boolean) is
6470
      begin
6471
         pragma Assert (Nkind (N) in N_Entity);
6472
         Nodes.Table (N + 4).In_List := Val;
6473
      end Set_Flag216;
6474
 
6475
      procedure Set_Flag217 (N : Node_Id; Val : Boolean) is
6476
      begin
6477
         pragma Assert (Nkind (N) in N_Entity);
6478
         Nodes.Table (N + 4).Has_Aspects := Val;
6479
      end Set_Flag217;
6480
 
6481
      procedure Set_Flag218 (N : Node_Id; Val : Boolean) is
6482
      begin
6483
         pragma Assert (Nkind (N) in N_Entity);
6484
         Nodes.Table (N + 4).Rewrite_Ins := Val;
6485
      end Set_Flag218;
6486
 
6487
      procedure Set_Flag219 (N : Node_Id; Val : Boolean) is
6488
      begin
6489
         pragma Assert (Nkind (N) in N_Entity);
6490
         Nodes.Table (N + 4).Analyzed := Val;
6491
      end Set_Flag219;
6492
 
6493
      procedure Set_Flag220 (N : Node_Id; Val : Boolean) is
6494
      begin
6495
         pragma Assert (Nkind (N) in N_Entity);
6496
         Nodes.Table (N + 4).Comes_From_Source := Val;
6497
      end Set_Flag220;
6498
 
6499
      procedure Set_Flag221 (N : Node_Id; Val : Boolean) is
6500
      begin
6501
         pragma Assert (Nkind (N) in N_Entity);
6502
         Nodes.Table (N + 4).Error_Posted := Val;
6503
      end Set_Flag221;
6504
 
6505
      procedure Set_Flag222 (N : Node_Id; Val : Boolean) is
6506
      begin
6507
         pragma Assert (Nkind (N) in N_Entity);
6508
         Nodes.Table (N + 4).Flag4 := Val;
6509
      end Set_Flag222;
6510
 
6511
      procedure Set_Flag223 (N : Node_Id; Val : Boolean) is
6512
      begin
6513
         pragma Assert (Nkind (N) in N_Entity);
6514
         Nodes.Table (N + 4).Flag5 := Val;
6515
      end Set_Flag223;
6516
 
6517
      procedure Set_Flag224 (N : Node_Id; Val : Boolean) is
6518
      begin
6519
         pragma Assert (Nkind (N) in N_Entity);
6520
         Nodes.Table (N + 4).Flag6 := Val;
6521
      end Set_Flag224;
6522
 
6523
      procedure Set_Flag225 (N : Node_Id; Val : Boolean) is
6524
      begin
6525
         pragma Assert (Nkind (N) in N_Entity);
6526
         Nodes.Table (N + 4).Flag7 := Val;
6527
      end Set_Flag225;
6528
 
6529
      procedure Set_Flag226 (N : Node_Id; Val : Boolean) is
6530
      begin
6531
         pragma Assert (Nkind (N) in N_Entity);
6532
         Nodes.Table (N + 4).Flag8 := Val;
6533
      end Set_Flag226;
6534
 
6535
      procedure Set_Flag227 (N : Node_Id; Val : Boolean) is
6536
      begin
6537
         pragma Assert (Nkind (N) in N_Entity);
6538
         Nodes.Table (N + 4).Flag9 := Val;
6539
      end Set_Flag227;
6540
 
6541
      procedure Set_Flag228 (N : Node_Id; Val : Boolean) is
6542
      begin
6543
         pragma Assert (Nkind (N) in N_Entity);
6544
         Nodes.Table (N + 4).Flag10 := Val;
6545
      end Set_Flag228;
6546
 
6547
      procedure Set_Flag229 (N : Node_Id; Val : Boolean) is
6548
      begin
6549
         pragma Assert (Nkind (N) in N_Entity);
6550
         Nodes.Table (N + 4).Flag11 := Val;
6551
      end Set_Flag229;
6552
 
6553
      procedure Set_Flag230 (N : Node_Id; Val : Boolean) is
6554
      begin
6555
         pragma Assert (Nkind (N) in N_Entity);
6556
         Nodes.Table (N + 4).Flag12 := Val;
6557
      end Set_Flag230;
6558
 
6559
      procedure Set_Flag231 (N : Node_Id; Val : Boolean) is
6560
      begin
6561
         pragma Assert (Nkind (N) in N_Entity);
6562
         Nodes.Table (N + 4).Flag13 := Val;
6563
      end Set_Flag231;
6564
 
6565
      procedure Set_Flag232 (N : Node_Id; Val : Boolean) is
6566
      begin
6567
         pragma Assert (Nkind (N) in N_Entity);
6568
         Nodes.Table (N + 4).Flag14 := Val;
6569
      end Set_Flag232;
6570
 
6571
      procedure Set_Flag233 (N : Node_Id; Val : Boolean) is
6572
      begin
6573
         pragma Assert (Nkind (N) in N_Entity);
6574
         Nodes.Table (N + 4).Flag15 := Val;
6575
      end Set_Flag233;
6576
 
6577
      procedure Set_Flag234 (N : Node_Id; Val : Boolean) is
6578
      begin
6579
         pragma Assert (Nkind (N) in N_Entity);
6580
         Nodes.Table (N + 4).Flag16 := Val;
6581
      end Set_Flag234;
6582
 
6583
      procedure Set_Flag235 (N : Node_Id; Val : Boolean) is
6584
      begin
6585
         pragma Assert (Nkind (N) in N_Entity);
6586
         Nodes.Table (N + 4).Flag17 := Val;
6587
      end Set_Flag235;
6588
 
6589
      procedure Set_Flag236 (N : Node_Id; Val : Boolean) is
6590
      begin
6591
         pragma Assert (Nkind (N) in N_Entity);
6592
         Nodes.Table (N + 4).Flag18 := Val;
6593
      end Set_Flag236;
6594
 
6595
      procedure Set_Flag237 (N : Node_Id; Val : Boolean) is
6596
      begin
6597
         pragma Assert (Nkind (N) in N_Entity);
6598
         Nodes.Table (N + 4).Pflag1 := Val;
6599
      end Set_Flag237;
6600
 
6601
      procedure Set_Flag238 (N : Node_Id; Val : Boolean) is
6602
      begin
6603
         pragma Assert (Nkind (N) in N_Entity);
6604
         Nodes.Table (N + 4).Pflag2 := Val;
6605
      end Set_Flag238;
6606
 
6607
      procedure Set_Flag239 (N : Node_Id; Val : Boolean) is
6608
      begin
6609
         pragma Assert (Nkind (N) in N_Entity);
6610
         To_Flag_Byte2_Ptr
6611
           (Node_Kind_Ptr'
6612
             (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag239 := Val;
6613
      end Set_Flag239;
6614
 
6615
      procedure Set_Flag240 (N : Node_Id; Val : Boolean) is
6616
      begin
6617
         pragma Assert (Nkind (N) in N_Entity);
6618
         To_Flag_Byte2_Ptr
6619
           (Node_Kind_Ptr'
6620
             (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag240 := Val;
6621
      end Set_Flag240;
6622
 
6623
      procedure Set_Flag241 (N : Node_Id; Val : Boolean) is
6624
      begin
6625
         pragma Assert (Nkind (N) in N_Entity);
6626
         To_Flag_Byte2_Ptr
6627
           (Node_Kind_Ptr'
6628
             (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag241 := Val;
6629
      end Set_Flag241;
6630
 
6631
      procedure Set_Flag242 (N : Node_Id; Val : Boolean) is
6632
      begin
6633
         pragma Assert (Nkind (N) in N_Entity);
6634
         To_Flag_Byte2_Ptr
6635
           (Node_Kind_Ptr'
6636
             (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag242 := Val;
6637
      end Set_Flag242;
6638
 
6639
      procedure Set_Flag243 (N : Node_Id; Val : Boolean) is
6640
      begin
6641
         pragma Assert (Nkind (N) in N_Entity);
6642
         To_Flag_Byte2_Ptr
6643
           (Node_Kind_Ptr'
6644
             (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag243 := Val;
6645
      end Set_Flag243;
6646
 
6647
      procedure Set_Flag244 (N : Node_Id; Val : Boolean) is
6648
      begin
6649
         pragma Assert (Nkind (N) in N_Entity);
6650
         To_Flag_Byte2_Ptr
6651
           (Node_Kind_Ptr'
6652
             (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag244 := Val;
6653
      end Set_Flag244;
6654
 
6655
      procedure Set_Flag245 (N : Node_Id; Val : Boolean) is
6656
      begin
6657
         pragma Assert (Nkind (N) in N_Entity);
6658
         To_Flag_Byte2_Ptr
6659
           (Node_Kind_Ptr'
6660
             (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag245 := Val;
6661
      end Set_Flag245;
6662
 
6663
      procedure Set_Flag246 (N : Node_Id; Val : Boolean) is
6664
      begin
6665
         pragma Assert (Nkind (N) in N_Entity);
6666
         To_Flag_Byte2_Ptr
6667
           (Node_Kind_Ptr'
6668
             (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag246 := Val;
6669
      end Set_Flag246;
6670
 
6671
      procedure Set_Flag247 (N : Node_Id; Val : Boolean) is
6672
      begin
6673
         pragma Assert (Nkind (N) in N_Entity);
6674
         To_Flag_Byte3_Ptr
6675
           (Node_Kind_Ptr'
6676
             (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag247 := Val;
6677
      end Set_Flag247;
6678
 
6679
      procedure Set_Flag248 (N : Node_Id; Val : Boolean) is
6680
      begin
6681
         pragma Assert (Nkind (N) in N_Entity);
6682
         To_Flag_Byte3_Ptr
6683
           (Node_Kind_Ptr'
6684
             (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag248 := Val;
6685
      end Set_Flag248;
6686
 
6687
      procedure Set_Flag249 (N : Node_Id; Val : Boolean) is
6688
      begin
6689
         pragma Assert (Nkind (N) in N_Entity);
6690
         To_Flag_Byte3_Ptr
6691
           (Node_Kind_Ptr'
6692
             (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag249 := Val;
6693
      end Set_Flag249;
6694
 
6695
      procedure Set_Flag250 (N : Node_Id; Val : Boolean) is
6696
      begin
6697
         pragma Assert (Nkind (N) in N_Entity);
6698
         To_Flag_Byte3_Ptr
6699
           (Node_Kind_Ptr'
6700
             (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag250 := Val;
6701
      end Set_Flag250;
6702
 
6703
      procedure Set_Flag251 (N : Node_Id; Val : Boolean) is
6704
      begin
6705
         pragma Assert (Nkind (N) in N_Entity);
6706
         To_Flag_Byte3_Ptr
6707
           (Node_Kind_Ptr'
6708
             (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag251 := Val;
6709
      end Set_Flag251;
6710
 
6711
      procedure Set_Flag252 (N : Node_Id; Val : Boolean) is
6712
      begin
6713
         pragma Assert (Nkind (N) in N_Entity);
6714
         To_Flag_Byte3_Ptr
6715
           (Node_Kind_Ptr'
6716
             (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag252 := Val;
6717
      end Set_Flag252;
6718
 
6719
      procedure Set_Flag253 (N : Node_Id; Val : Boolean) is
6720
      begin
6721
         pragma Assert (Nkind (N) in N_Entity);
6722
         To_Flag_Byte3_Ptr
6723
           (Node_Kind_Ptr'
6724
             (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag253 := Val;
6725
      end Set_Flag253;
6726
 
6727
      procedure Set_Flag254 (N : Node_Id; Val : Boolean) is
6728
      begin
6729
         pragma Assert (Nkind (N) in N_Entity);
6730
         To_Flag_Byte3_Ptr
6731
           (Node_Kind_Ptr'
6732
             (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag254 := Val;
6733
      end Set_Flag254;
6734
 
6735
      procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is
6736
      begin
6737
         pragma Assert (N <= Nodes.Last);
6738
 
6739
         if Val > Error then
6740
            Set_Parent (N => Val, Val => N);
6741
         end if;
6742
 
6743
         Set_Node1 (N, Val);
6744
      end Set_Node1_With_Parent;
6745
 
6746
      procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is
6747
      begin
6748
         pragma Assert (N <= Nodes.Last);
6749
 
6750
         if Val > Error then
6751
            Set_Parent (N => Val, Val => N);
6752
         end if;
6753
 
6754
         Set_Node2 (N, Val);
6755
      end Set_Node2_With_Parent;
6756
 
6757
      procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is
6758
      begin
6759
         pragma Assert (N <= Nodes.Last);
6760
 
6761
         if Val > Error then
6762
            Set_Parent (N => Val, Val => N);
6763
         end if;
6764
 
6765
         Set_Node3 (N, Val);
6766
      end Set_Node3_With_Parent;
6767
 
6768
      procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is
6769
      begin
6770
         pragma Assert (N <= Nodes.Last);
6771
 
6772
         if Val > Error then
6773
            Set_Parent (N => Val, Val => N);
6774
         end if;
6775
 
6776
         Set_Node4 (N, Val);
6777
      end Set_Node4_With_Parent;
6778
 
6779
      procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
6780
      begin
6781
         pragma Assert (N <= Nodes.Last);
6782
 
6783
         if Val > Error then
6784
            Set_Parent (N => Val, Val => N);
6785
         end if;
6786
 
6787
         Set_Node5 (N, Val);
6788
      end Set_Node5_With_Parent;
6789
 
6790
      procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
6791
      begin
6792
         pragma Assert (N <= Nodes.Last);
6793
         if Val /= No_List and then Val /= Error_List then
6794
            Set_Parent (Val, N);
6795
         end if;
6796
         Set_List1 (N, Val);
6797
      end Set_List1_With_Parent;
6798
 
6799
      procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
6800
      begin
6801
         pragma Assert (N <= Nodes.Last);
6802
         if Val /= No_List and then Val /= Error_List then
6803
            Set_Parent (Val, N);
6804
         end if;
6805
         Set_List2 (N, Val);
6806
      end Set_List2_With_Parent;
6807
 
6808
      procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
6809
      begin
6810
         pragma Assert (N <= Nodes.Last);
6811
         if Val /= No_List and then Val /= Error_List then
6812
            Set_Parent (Val, N);
6813
         end if;
6814
         Set_List3 (N, Val);
6815
      end Set_List3_With_Parent;
6816
 
6817
      procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
6818
      begin
6819
         pragma Assert (N <= Nodes.Last);
6820
         if Val /= No_List and then Val /= Error_List then
6821
            Set_Parent (Val, N);
6822
         end if;
6823
         Set_List4 (N, Val);
6824
      end Set_List4_With_Parent;
6825
 
6826
      procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
6827
      begin
6828
         pragma Assert (N <= Nodes.Last);
6829
         if Val /= No_List and then Val /= Error_List then
6830
            Set_Parent (Val, N);
6831
         end if;
6832
         Set_List5 (N, Val);
6833
      end Set_List5_With_Parent;
6834
 
6835
   end Unchecked_Access;
6836
 
6837
   ------------
6838
   -- Unlock --
6839
   ------------
6840
 
6841
   procedure Unlock is
6842
   begin
6843
      Nodes.Locked := False;
6844
      Orig_Nodes.Locked := False;
6845
   end Unlock;
6846
 
6847
end Atree;

powered by: WebSVN 2.1.0

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