File : atree.adb
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- A T R E E --
6 -- --
7 -- B o d y --
8 -- --
9 -- Copyright (C) 1992-2016, Free Software Foundation, Inc. --
10 -- --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. --
17 -- --
18 -- --
19 -- --
20 -- --
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 Opt; use Opt;
43 with Output; use Output;
44 with Sinput; use Sinput;
45 with Tree_IO; use Tree_IO;
46
47 with GNAT.Heap_Sort_G;
48
49 package body Atree is
50
51 Reporting_Proc : Report_Proc := null;
52 -- Record argument to last call to Set_Reporting_Proc
53
54 ---------------
55 -- Debugging --
56 ---------------
57
58 -- Suppose you find that node 12345 is messed up. You might want to find
59 -- the code that created that node. There are two ways to do this:
60
61 -- One way is to set a conditional breakpoint on New_Node_Debugging_Output
62 -- (nickname "nnd"):
63 -- break nnd if n = 12345
64 -- and run gnat1 again from the beginning.
65
66 -- The other way is to set a breakpoint near the beginning (e.g. on
67 -- gnat1drv), and run. Then set Watch_Node (nickname "ww") to 12345 in gdb:
68 -- ww := 12345
69 -- and set a breakpoint on New_Node_Breakpoint (nickname "nn"). Continue.
70
71 -- Either way, gnat1 will stop when node 12345 is created
72
73 -- The second method is much faster
74
75 -- Similarly, rr and rrd allow breaking on rewriting of a given node
76
77 ww : Node_Id'Base := Node_Id'First - 1;
78 pragma Export (Ada, ww); -- trick the optimizer
79 Watch_Node : Node_Id'Base renames ww;
80 -- Node to "watch"; that is, whenever a node is created, we check if it
81 -- is equal to Watch_Node, and if so, call New_Node_Breakpoint. You have
82 -- presumably set a breakpoint on New_Node_Breakpoint. Note that the
83 -- initial value of Node_Id'First - 1 ensures that by default, no node
84 -- will be equal to Watch_Node.
85
86 procedure nn;
87 pragma Export (Ada, nn);
88 procedure New_Node_Breakpoint renames nn;
89 -- This doesn't do anything interesting; it's just for setting breakpoint
90 -- on as explained above.
91
92 procedure nnd (N : Node_Id);
93 pragma Export (Ada, nnd);
94 procedure New_Node_Debugging_Output (N : Node_Id) renames nnd;
95 -- For debugging. If debugging is turned on, New_Node and New_Entity call
96 -- this. If debug flag N is turned on, this prints out the new node.
97 --
98 -- If Node = Watch_Node, this prints out the new node and calls
99 -- New_Node_Breakpoint. Otherwise, does nothing.
100
101 procedure rr;
102 pragma Export (Ada, rr);
103 procedure Rewrite_Breakpoint renames rr;
104 -- This doesn't do anything interesting; it's just for setting breakpoint
105 -- on as explained above.
106
107 procedure rrd (Old_Node, New_Node : Node_Id);
108 pragma Export (Ada, rrd);
109 procedure Rewrite_Debugging_Output
110 (Old_Node, New_Node : Node_Id) renames rrd;
111 -- For debugging. If debugging is turned on, Rewrite calls this. If debug
112 -- flag N is turned on, this prints out the new node.
113 --
114 -- If Old_Node = Watch_Node, this prints out the old and new nodes and
115 -- calls Rewrite_Breakpoint. Otherwise, does nothing.
116
117 procedure Node_Debug_Output (Op : String; N : Node_Id);
118 -- Common code for nnd and rrd, writes Op followed by information about N
119
120 procedure Print_Statistics;
121 pragma Export (Ada, Print_Statistics);
122 -- Print various statistics on the tables maintained by the package
123
124 -----------------------------
125 -- Local Objects and Types --
126 -----------------------------
127
128 Node_Count : Nat;
129 -- Count allocated nodes for Num_Nodes function
130
131 use Unchecked_Access;
132 -- We are allowed to see these from within our own body
133
134 use Atree_Private_Part;
135 -- We are also allowed to see our private data structures
136
137 -- Functions used to store Entity_Kind value in Nkind field
138
139 -- The following declarations are used to store flags 65-72 in the
140 -- Nkind field of the third component of an extended (entity) node.
141
142 type Flag_Byte is record
143 Flag65 : Boolean;
144 Flag66 : Boolean;
145 Flag67 : Boolean;
146 Flag68 : Boolean;
147 Flag69 : Boolean;
148 Flag70 : Boolean;
149 Flag71 : Boolean;
150 Flag72 : Boolean;
151 end record;
152
153 pragma Pack (Flag_Byte);
154 for Flag_Byte'Size use 8;
155
156 type Flag_Byte_Ptr is access all Flag_Byte;
157 type Node_Kind_Ptr is access all Node_Kind;
158
159 function To_Flag_Byte is new
160 Unchecked_Conversion (Node_Kind, Flag_Byte);
161
162 function To_Flag_Byte_Ptr is new
163 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);
164
165 -- The following declarations are used to store flags 239-246 in the
166 -- Nkind field of the fourth component of an extended (entity) node.
167
168 type Flag_Byte2 is record
169 Flag239 : Boolean;
170 Flag240 : Boolean;
171 Flag241 : Boolean;
172 Flag242 : Boolean;
173 Flag243 : Boolean;
174 Flag244 : Boolean;
175 Flag245 : Boolean;
176 Flag246 : Boolean;
177 end record;
178
179 pragma Pack (Flag_Byte2);
180 for Flag_Byte2'Size use 8;
181
182 type Flag_Byte2_Ptr is access all Flag_Byte2;
183
184 function To_Flag_Byte2 is new
185 Unchecked_Conversion (Node_Kind, Flag_Byte2);
186
187 function To_Flag_Byte2_Ptr is new
188 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte2_Ptr);
189
190 -- The following declarations are used to store flags 247-254 in the
191 -- Nkind field of the fifth component of an extended (entity) node.
192
193 type Flag_Byte3 is record
194 Flag247 : Boolean;
195 Flag248 : Boolean;
196 Flag249 : Boolean;
197 Flag250 : Boolean;
198 Flag251 : Boolean;
199 Flag252 : Boolean;
200 Flag253 : Boolean;
201 Flag254 : Boolean;
202 end record;
203
204 pragma Pack (Flag_Byte3);
205 for Flag_Byte3'Size use 8;
206
207 type Flag_Byte3_Ptr is access all Flag_Byte3;
208
209 function To_Flag_Byte3 is new
210 Unchecked_Conversion (Node_Kind, Flag_Byte3);
211
212 function To_Flag_Byte3_Ptr is new
213 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte3_Ptr);
214
215 -- The following declarations are used to store flags 310-317 in the
216 -- Nkind field of the sixth component of an extended (entity) node.
217
218 type Flag_Byte4 is record
219 Flag310 : Boolean;
220 Flag311 : Boolean;
221 Flag312 : Boolean;
222 Flag313 : Boolean;
223 Flag314 : Boolean;
224 Flag315 : Boolean;
225 Flag316 : Boolean;
226 Flag317 : Boolean;
227 end record;
228
229 pragma Pack (Flag_Byte4);
230 for Flag_Byte4'Size use 8;
231
232 type Flag_Byte4_Ptr is access all Flag_Byte4;
233
234 function To_Flag_Byte4 is new
235 Unchecked_Conversion (Node_Kind, Flag_Byte4);
236
237 function To_Flag_Byte4_Ptr is new
238 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte4_Ptr);
239
240 -- The following declarations are used to store flags 73-96 and the
241 -- Convention field in the Field12 field of the third component of an
242 -- extended (Entity) node.
243
244 type Flag_Word is record
245 Flag73 : Boolean;
246 Flag74 : Boolean;
247 Flag75 : Boolean;
248 Flag76 : Boolean;
249 Flag77 : Boolean;
250 Flag78 : Boolean;
251 Flag79 : Boolean;
252 Flag80 : Boolean;
253
254 Flag81 : Boolean;
255 Flag82 : Boolean;
256 Flag83 : Boolean;
257 Flag84 : Boolean;
258 Flag85 : Boolean;
259 Flag86 : Boolean;
260 Flag87 : Boolean;
261 Flag88 : Boolean;
262
263 Flag89 : Boolean;
264 Flag90 : Boolean;
265 Flag91 : Boolean;
266 Flag92 : Boolean;
267 Flag93 : Boolean;
268 Flag94 : Boolean;
269 Flag95 : Boolean;
270 Flag96 : Boolean;
271
272 Convention : Convention_Id;
273 end record;
274
275 pragma Pack (Flag_Word);
276 for Flag_Word'Size use 32;
277 for Flag_Word'Alignment use 4;
278
279 type Flag_Word_Ptr is access all Flag_Word;
280 type Union_Id_Ptr is access all Union_Id;
281
282 function To_Flag_Word is new
283 Unchecked_Conversion (Union_Id, Flag_Word);
284
285 function To_Flag_Word_Ptr is new
286 Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr);
287
288 -- The following declarations are used to store flags 97-128 in the
289 -- Field12 field of the fourth component of an extended (entity) node.
290
291 type Flag_Word2 is record
292 Flag97 : Boolean;
293 Flag98 : Boolean;
294 Flag99 : Boolean;
295 Flag100 : Boolean;
296 Flag101 : Boolean;
297 Flag102 : Boolean;
298 Flag103 : Boolean;
299 Flag104 : Boolean;
300
301 Flag105 : Boolean;
302 Flag106 : Boolean;
303 Flag107 : Boolean;
304 Flag108 : Boolean;
305 Flag109 : Boolean;
306 Flag110 : Boolean;
307 Flag111 : Boolean;
308 Flag112 : Boolean;
309
310 Flag113 : Boolean;
311 Flag114 : Boolean;
312 Flag115 : Boolean;
313 Flag116 : Boolean;
314 Flag117 : Boolean;
315 Flag118 : Boolean;
316 Flag119 : Boolean;
317 Flag120 : Boolean;
318
319 Flag121 : Boolean;
320 Flag122 : Boolean;
321 Flag123 : Boolean;
322 Flag124 : Boolean;
323 Flag125 : Boolean;
324 Flag126 : Boolean;
325 Flag127 : Boolean;
326 Flag128 : Boolean;
327 end record;
328
329 pragma Pack (Flag_Word2);
330 for Flag_Word2'Size use 32;
331 for Flag_Word2'Alignment use 4;
332
333 type Flag_Word2_Ptr is access all Flag_Word2;
334
335 function To_Flag_Word2 is new
336 Unchecked_Conversion (Union_Id, Flag_Word2);
337
338 function To_Flag_Word2_Ptr is new
339 Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr);
340
341 -- The following declarations are used to store flags 152-183 in the
342 -- Field11 field of the fourth component of an extended (entity) node.
343
344 type Flag_Word3 is record
345 Flag152 : Boolean;
346 Flag153 : Boolean;
347 Flag154 : Boolean;
348 Flag155 : Boolean;
349 Flag156 : Boolean;
350 Flag157 : Boolean;
351 Flag158 : Boolean;
352 Flag159 : Boolean;
353
354 Flag160 : Boolean;
355 Flag161 : Boolean;
356 Flag162 : Boolean;
357 Flag163 : Boolean;
358 Flag164 : Boolean;
359 Flag165 : Boolean;
360 Flag166 : Boolean;
361 Flag167 : Boolean;
362
363 Flag168 : Boolean;
364 Flag169 : Boolean;
365 Flag170 : Boolean;
366 Flag171 : Boolean;
367 Flag172 : Boolean;
368 Flag173 : Boolean;
369 Flag174 : Boolean;
370 Flag175 : Boolean;
371
372 Flag176 : Boolean;
373 Flag177 : Boolean;
374 Flag178 : Boolean;
375 Flag179 : Boolean;
376 Flag180 : Boolean;
377 Flag181 : Boolean;
378 Flag182 : Boolean;
379 Flag183 : Boolean;
380 end record;
381
382 pragma Pack (Flag_Word3);
383 for Flag_Word3'Size use 32;
384 for Flag_Word3'Alignment use 4;
385
386 type Flag_Word3_Ptr is access all Flag_Word3;
387
388 function To_Flag_Word3 is new
389 Unchecked_Conversion (Union_Id, Flag_Word3);
390
391 function To_Flag_Word3_Ptr is new
392 Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr);
393
394 -- The following declarations are used to store flags 184-215 in the
395 -- Field12 field of the fifth component of an extended (entity) node.
396
397 type Flag_Word4 is record
398 Flag184 : Boolean;
399 Flag185 : Boolean;
400 Flag186 : Boolean;
401 Flag187 : Boolean;
402 Flag188 : Boolean;
403 Flag189 : Boolean;
404 Flag190 : Boolean;
405 Flag191 : Boolean;
406
407 Flag192 : Boolean;
408 Flag193 : Boolean;
409 Flag194 : Boolean;
410 Flag195 : Boolean;
411 Flag196 : Boolean;
412 Flag197 : Boolean;
413 Flag198 : Boolean;
414 Flag199 : Boolean;
415
416 Flag200 : Boolean;
417 Flag201 : Boolean;
418 Flag202 : Boolean;
419 Flag203 : Boolean;
420 Flag204 : Boolean;
421 Flag205 : Boolean;
422 Flag206 : Boolean;
423 Flag207 : Boolean;
424
425 Flag208 : Boolean;
426 Flag209 : Boolean;
427 Flag210 : Boolean;
428 Flag211 : Boolean;
429 Flag212 : Boolean;
430 Flag213 : Boolean;
431 Flag214 : Boolean;
432 Flag215 : Boolean;
433 end record;
434
435 pragma Pack (Flag_Word4);
436 for Flag_Word4'Size use 32;
437 for Flag_Word4'Alignment use 4;
438
439 type Flag_Word4_Ptr is access all Flag_Word4;
440
441 function To_Flag_Word4 is new
442 Unchecked_Conversion (Union_Id, Flag_Word4);
443
444 function To_Flag_Word4_Ptr is new
445 Unchecked_Conversion (Union_Id_Ptr, Flag_Word4_Ptr);
446
447 -- The following declarations are used to store flags 255-286 in the
448 -- Field12 field of the sixth component of an extended (entity) node.
449
450 type Flag_Word5 is record
451 Flag255 : Boolean;
452 Flag256 : Boolean;
453 Flag257 : Boolean;
454 Flag258 : Boolean;
455 Flag259 : Boolean;
456 Flag260 : Boolean;
457 Flag261 : Boolean;
458 Flag262 : Boolean;
459
460 Flag263 : Boolean;
461 Flag264 : Boolean;
462 Flag265 : Boolean;
463 Flag266 : Boolean;
464 Flag267 : Boolean;
465 Flag268 : Boolean;
466 Flag269 : Boolean;
467 Flag270 : Boolean;
468
469 Flag271 : Boolean;
470 Flag272 : Boolean;
471 Flag273 : Boolean;
472 Flag274 : Boolean;
473 Flag275 : Boolean;
474 Flag276 : Boolean;
475 Flag277 : Boolean;
476 Flag278 : Boolean;
477
478 Flag279 : Boolean;
479 Flag280 : Boolean;
480 Flag281 : Boolean;
481 Flag282 : Boolean;
482 Flag283 : Boolean;
483 Flag284 : Boolean;
484 Flag285 : Boolean;
485 Flag286 : Boolean;
486 end record;
487
488 pragma Pack (Flag_Word5);
489 for Flag_Word5'Size use 32;
490 for Flag_Word5'Alignment use 4;
491
492 type Flag_Word5_Ptr is access all Flag_Word5;
493
494 function To_Flag_Word5 is new
495 Unchecked_Conversion (Union_Id, Flag_Word5);
496
497 function To_Flag_Word5_Ptr is new
498 Unchecked_Conversion (Union_Id_Ptr, Flag_Word5_Ptr);
499
500 --------------------------------------------------
501 -- Implementation of Tree Substitution Routines --
502 --------------------------------------------------
503
504 -- A separate table keeps track of the mapping between rewritten nodes
505 -- and their corresponding original tree nodes. Rewrite makes an entry
506 -- in this table for use by Original_Node. By default, if no call is
507 -- Rewrite, the entry in this table points to the original unwritten node.
508
509 -- Note: eventually, this should be a field in the Node directly, but
510 -- for now we do not want to disturb the efficiency of a power of 2
511 -- for the node size
512
513 package Orig_Nodes is new Table.Table (
514 Table_Component_Type => Node_Id,
515 Table_Index_Type => Node_Id'Base,
516 Table_Low_Bound => First_Node_Id,
517 Table_Initial => Alloc.Orig_Nodes_Initial,
518 Table_Increment => Alloc.Orig_Nodes_Increment,
519 Table_Name => "Orig_Nodes");
520
521 --------------------------
522 -- Paren_Count Handling --
523 --------------------------
524
525 -- As noted in the spec, the paren count in a sub-expression node has
526 -- four possible values 0,1,2, and 3. The value 3 really means 3 or more,
527 -- and we use an auxiliary serially scanned table to record the actual
528 -- count. A serial search is fine, only pathological programs will use
529 -- entries in this table. Normal programs won't use it at all.
530
531 type Paren_Count_Entry is record
532 Nod : Node_Id;
533 -- The node to which this count applies
534
535 Count : Nat range 3 .. Nat'Last;
536 -- The count of parentheses, which will be in the indicated range
537 end record;
538
539 package Paren_Counts is new Table.Table (
540 Table_Component_Type => Paren_Count_Entry,
541 Table_Index_Type => Int,
542 Table_Low_Bound => 0,
543 Table_Initial => 10,
544 Table_Increment => 200,
545 Table_Name => "Paren_Counts");
546
547 -----------------------
548 -- Local Subprograms --
549 -----------------------
550
551 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id);
552 -- Fixup parent pointers for the syntactic children of Fix_Node after
553 -- a copy, setting them to Fix_Node when they pointed to Ref_Node.
554
555 function Allocate_Initialize_Node
556 (Src : Node_Id;
557 With_Extension : Boolean) return Node_Id;
558 -- Allocate a new node or node extension. If Src is not empty, the
559 -- information for the newly-allocated node is copied from it.
560
561 ------------------------------
562 -- Allocate_Initialize_Node --
563 ------------------------------
564
565 function Allocate_Initialize_Node
566 (Src : Node_Id;
567 With_Extension : Boolean) return Node_Id
568 is
569 New_Id : Node_Id;
570
571 begin
572 if Present (Src)
573 and then not Has_Extension (Src)
574 and then With_Extension
575 and then Src = Nodes.Last
576 then
577 New_Id := Src;
578
579 -- We are allocating a new node, or extending a node other than
580 -- Nodes.Last.
581
582 else
583 if Present (Src) then
584 Nodes.Append (Nodes.Table (Src));
585 Flags.Append (Flags.Table (Src));
586 else
587 Nodes.Append (Default_Node);
588 Flags.Append (Default_Flags);
589 end if;
590
591 New_Id := Nodes.Last;
592 Orig_Nodes.Append (New_Id);
593 Node_Count := Node_Count + 1;
594 end if;
595
596 -- Mark the node as ignored Ghost if it is created in an ignored Ghost
597 -- region.
598
599 if Ghost_Mode = Ignore then
600 Set_Is_Ignored_Ghost_Node (New_Id);
601 end if;
602
603 -- Clear Check_Actuals to False
604
605 Set_Check_Actuals (New_Id, False);
606
607 -- Specifically copy Paren_Count to deal with creating new table entry
608 -- if the parentheses count is at the maximum possible value already.
609
610 if Present (Src) and then Nkind (Src) in N_Subexpr then
611 Set_Paren_Count (New_Id, Paren_Count (Src));
612 end if;
613
614 -- Set extension nodes if required
615
616 if With_Extension then
617 if Present (Src) and then Has_Extension (Src) then
618 for J in 1 .. Num_Extension_Nodes loop
619 Nodes.Append (Nodes.Table (Src + J));
620 Flags.Append (Flags.Table (Src + J));
621 end loop;
622 else
623 for J in 1 .. Num_Extension_Nodes loop
624 Nodes.Append (Default_Node_Extension);
625 Flags.Append (Default_Flags);
626 end loop;
627 end if;
628 end if;
629
630 Orig_Nodes.Set_Last (Nodes.Last);
631 Allocate_List_Tables (Nodes.Last);
632
633 -- Invoke the reporting procedure (if available)
634
635 if Reporting_Proc /= null then
636 Reporting_Proc.all (Target => New_Id, Source => Src);
637 end if;
638
639 return New_Id;
640 end Allocate_Initialize_Node;
641
642 --------------
643 -- Analyzed --
644 --------------
645
646 function Analyzed (N : Node_Id) return Boolean is
647 begin
648 pragma Assert (N <= Nodes.Last);
649 return Nodes.Table (N).Analyzed;
650 end Analyzed;
651
652 --------------------------
653 -- Basic_Set_Convention --
654 --------------------------
655
656 procedure Basic_Set_Convention (E : Entity_Id; Val : Convention_Id) is
657 begin
658 pragma Assert (Nkind (E) in N_Entity);
659 To_Flag_Word_Ptr
660 (Union_Id_Ptr'
661 (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention := Val;
662 end Basic_Set_Convention;
663
664 -------------------
665 -- Check_Actuals --
666 -------------------
667
668 function Check_Actuals (N : Node_Id) return Boolean is
669 begin
670 return Flags.Table (N).Check_Actuals;
671 end Check_Actuals;
672
673 --------------------------
674 -- Check_Error_Detected --
675 --------------------------
676
677 procedure Check_Error_Detected is
678 begin
679 -- An anomaly has been detected which is assumed to be a consequence of
680 -- a previous serious error or configurable run time violation. Raise
681 -- an exception if no such error has been detected.
682
683 if Serious_Errors_Detected = 0
684 and then Configurable_Run_Time_Violations = 0
685 then
686 raise Program_Error;
687 end if;
688 end Check_Error_Detected;
689
690 -----------------
691 -- Change_Node --
692 -----------------
693
694 procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is
695 Save_Sloc : constant Source_Ptr := Sloc (N);
696 Save_In_List : constant Boolean := Nodes.Table (N).In_List;
697 Save_Link : constant Union_Id := Nodes.Table (N).Link;
698 Save_CFS : constant Boolean := Nodes.Table (N).Comes_From_Source;
699 Save_Posted : constant Boolean := Nodes.Table (N).Error_Posted;
700 Par_Count : Nat := 0;
701
702 begin
703 if Nkind (N) in N_Subexpr then
704 Par_Count := Paren_Count (N);
705 end if;
706
707 Nodes.Table (N) := Default_Node;
708 Nodes.Table (N).Sloc := Save_Sloc;
709 Nodes.Table (N).In_List := Save_In_List;
710 Nodes.Table (N).Link := Save_Link;
711 Nodes.Table (N).Comes_From_Source := Save_CFS;
712 Nodes.Table (N).Nkind := New_Node_Kind;
713 Nodes.Table (N).Error_Posted := Save_Posted;
714
715 Flags.Table (N) := Default_Flags;
716
717 if New_Node_Kind in N_Subexpr then
718 Set_Paren_Count (N, Par_Count);
719 end if;
720 end Change_Node;
721
722 -----------------------
723 -- Comes_From_Source --
724 -----------------------
725
726 function Comes_From_Source (N : Node_Id) return Boolean is
727 begin
728 pragma Assert (N <= Nodes.Last);
729 return Nodes.Table (N).Comes_From_Source;
730 end Comes_From_Source;
731
732 ----------------
733 -- Convention --
734 ----------------
735
736 function Convention (E : Entity_Id) return Convention_Id is
737 begin
738 pragma Assert (Nkind (E) in N_Entity);
739 return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention;
740 end Convention;
741
742 ---------------
743 -- Copy_Node --
744 ---------------
745
746 procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is
747 Save_In_List : constant Boolean := Nodes.Table (Destination).In_List;
748 Save_Link : constant Union_Id := Nodes.Table (Destination).Link;
749
750 begin
751 Nodes.Table (Destination) := Nodes.Table (Source);
752 Nodes.Table (Destination).In_List := Save_In_List;
753 Nodes.Table (Destination).Link := Save_Link;
754
755 Flags.Table (Destination) := Flags.Table (Source);
756
757 -- Specifically set Paren_Count to make sure auxiliary table entry
758 -- gets correctly made if the parentheses count is at the max value.
759
760 if Nkind (Destination) in N_Subexpr then
761 Set_Paren_Count (Destination, Paren_Count (Source));
762 end if;
763
764 -- Deal with copying extension nodes if present. No need to copy flags
765 -- table entries, since they are always zero for extending components.
766
767 if Has_Extension (Source) then
768 pragma Assert (Has_Extension (Destination));
769
770 for J in 1 .. Num_Extension_Nodes loop
771 Nodes.Table (Destination + J) := Nodes.Table (Source + J);
772 end loop;
773
774 else
775 pragma Assert (not Has_Extension (Source));
776 null;
777 end if;
778 end Copy_Node;
779
780 ------------------------
781 -- Copy_Separate_List --
782 ------------------------
783
784 function Copy_Separate_List (Source : List_Id) return List_Id is
785 Result : constant List_Id := New_List;
786 Nod : Node_Id;
787
788 begin
789 Nod := First (Source);
790 while Present (Nod) loop
791 Append (Copy_Separate_Tree (Nod), Result);
792 Next (Nod);
793 end loop;
794
795 return Result;
796 end Copy_Separate_List;
797
798 ------------------------
799 -- Copy_Separate_Tree --
800 ------------------------
801
802 function Copy_Separate_Tree (Source : Node_Id) return Node_Id is
803 New_Id : Node_Id;
804
805 function Copy_Entity (E : Entity_Id) return Entity_Id;
806 -- Copy Entity, copying only the Ekind and Chars fields
807
808 function Copy_List (List : List_Id) return List_Id;
809 -- Copy list
810
811 function Possible_Copy (Field : Union_Id) return Union_Id;
812 -- Given a field, returns a copy of the node or list if its parent is
813 -- the current source node, and otherwise returns the input.
814
815 -----------------
816 -- Copy_Entity --
817 -----------------
818
819 function Copy_Entity (E : Entity_Id) return Entity_Id is
820 New_Ent : Entity_Id;
821
822 begin
823 -- Build appropriate node
824
825 case N_Entity (Nkind (E)) is
826 when N_Defining_Identifier =>
827 New_Ent := New_Entity (N_Defining_Identifier, Sloc (E));
828
829 when N_Defining_Character_Literal =>
830 New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E));
831
832 when N_Defining_Operator_Symbol =>
833 New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E));
834 end case;
835
836 Set_Chars (New_Ent, Chars (E));
837 -- Set_Comes_From_Source (New_Ent, Comes_From_Source (E));
838 return New_Ent;
839 end Copy_Entity;
840
841 ---------------
842 -- Copy_List --
843 ---------------
844
845 function Copy_List (List : List_Id) return List_Id is
846 NL : List_Id;
847 E : Node_Id;
848
849 begin
850 if List = No_List then
851 return No_List;
852
853 else
854 NL := New_List;
855
856 E := First (List);
857 while Present (E) loop
858 if Has_Extension (E) then
859 Append (Copy_Entity (E), NL);
860 else
861 Append (Copy_Separate_Tree (E), NL);
862 end if;
863
864 Next (E);
865 end loop;
866
867 return NL;
868 end if;
869 end Copy_List;
870
871 -------------------
872 -- Possible_Copy --
873 -------------------
874
875 function Possible_Copy (Field : Union_Id) return Union_Id is
876 New_N : Union_Id;
877
878 begin
879 if Field in Node_Range then
880 New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field)));
881
882 if Parent (Node_Id (Field)) = Source then
883 Set_Parent (Node_Id (New_N), New_Id);
884 end if;
885
886 return New_N;
887
888 elsif Field in List_Range then
889 New_N := Union_Id (Copy_List (List_Id (Field)));
890
891 if Parent (List_Id (Field)) = Source then
892 Set_Parent (List_Id (New_N), New_Id);
893 end if;
894
895 return New_N;
896
897 else
898 return Field;
899 end if;
900 end Possible_Copy;
901
902 -- Start of processing for Copy_Separate_Tree
903
904 begin
905 if Source <= Empty_Or_Error then
906 return Source;
907
908 elsif Has_Extension (Source) then
909 return Copy_Entity (Source);
910
911 else
912 New_Id := New_Copy (Source);
913
914 -- Recursively copy descendants
915
916 Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id)));
917 Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id)));
918 Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id)));
919 Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id)));
920 Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id)));
921
922 -- Explicitly copy the aspect specifications as those do not reside
923 -- in a node field.
924
925 if Permits_Aspect_Specifications (Source)
926 and then Has_Aspects (Source)
927 then
928 Set_Aspect_Specifications
929 (New_Id, Copy_List (Aspect_Specifications (Source)));
930 end if;
931
932 -- Set Entity field to Empty to ensure that no entity references
933 -- are shared between the two, if the source is already analyzed.
934
935 if Nkind (New_Id) in N_Has_Entity
936 or else Nkind (New_Id) = N_Freeze_Entity
937 then
938 Set_Entity (New_Id, Empty);
939 end if;
940
941 -- Reset all Etype fields and Analyzed flags, because input tree may
942 -- have been fully or partially analyzed.
943
944 if Nkind (New_Id) in N_Has_Etype then
945 Set_Etype (New_Id, Empty);
946 end if;
947
948 Set_Analyzed (New_Id, False);
949
950 -- Rather special case, if we have an expanded name, then change
951 -- it back into a selected component, so that the tree looks the
952 -- way it did coming out of the parser. This will change back
953 -- when we analyze the selected component node.
954
955 if Nkind (New_Id) = N_Expanded_Name then
956
957 -- The following code is a bit kludgy. It would be cleaner to
958 -- Add an entry Change_Expanded_Name_To_Selected_Component to
959 -- Sinfo.CN, but that's an earthquake, because it has the wrong
960 -- license, and Atree is used outside the compiler, e.g. in the
961 -- binder and in ASIS, so we don't want to add that dependency.
962
963 -- Consequently we have no choice but to hold our noses and do
964 -- the change manually. At least we are Atree, so this odd use
965 -- of Atree.Unchecked_Access is at least all in the family.
966
967 -- Change the node type
968
969 Atree.Unchecked_Access.Set_Nkind (New_Id, N_Selected_Component);
970
971 -- Clear the Chars field which is not present in a selected
972 -- component node, so we don't want a junk value around.
973
974 Set_Node1 (New_Id, Empty);
975 end if;
976
977 -- All done, return copied node
978
979 return New_Id;
980 end if;
981 end Copy_Separate_Tree;
982
983 -----------
984 -- Ekind --
985 -----------
986
987 function Ekind (E : Entity_Id) return Entity_Kind is
988 begin
989 pragma Assert (Nkind (E) in N_Entity);
990 return N_To_E (Nodes.Table (E + 1).Nkind);
991 end Ekind;
992
993 --------------
994 -- Ekind_In --
995 --------------
996
997 function Ekind_In
998 (T : Entity_Kind;
999 V1 : Entity_Kind;
1000 V2 : Entity_Kind) return Boolean
1001 is
1002 begin
1003 return T = V1 or else
1004 T = V2;
1005 end Ekind_In;
1006
1007 function Ekind_In
1008 (T : Entity_Kind;
1009 V1 : Entity_Kind;
1010 V2 : Entity_Kind;
1011 V3 : Entity_Kind) return Boolean
1012 is
1013 begin
1014 return T = V1 or else
1015 T = V2 or else
1016 T = V3;
1017 end Ekind_In;
1018
1019 function Ekind_In
1020 (T : Entity_Kind;
1021 V1 : Entity_Kind;
1022 V2 : Entity_Kind;
1023 V3 : Entity_Kind;
1024 V4 : Entity_Kind) return Boolean
1025 is
1026 begin
1027 return T = V1 or else
1028 T = V2 or else
1029 T = V3 or else
1030 T = V4;
1031 end Ekind_In;
1032
1033 function Ekind_In
1034 (T : Entity_Kind;
1035 V1 : Entity_Kind;
1036 V2 : Entity_Kind;
1037 V3 : Entity_Kind;
1038 V4 : Entity_Kind;
1039 V5 : Entity_Kind) return Boolean
1040 is
1041 begin
1042 return T = V1 or else
1043 T = V2 or else
1044 T = V3 or else
1045 T = V4 or else
1046 T = V5;
1047 end Ekind_In;
1048
1049 function Ekind_In
1050 (T : Entity_Kind;
1051 V1 : Entity_Kind;
1052 V2 : Entity_Kind;
1053 V3 : Entity_Kind;
1054 V4 : Entity_Kind;
1055 V5 : Entity_Kind;
1056 V6 : Entity_Kind) return Boolean
1057 is
1058 begin
1059 return T = V1 or else
1060 T = V2 or else
1061 T = V3 or else
1062 T = V4 or else
1063 T = V5 or else
1064 T = V6;
1065 end Ekind_In;
1066
1067 function Ekind_In
1068 (T : Entity_Kind;
1069 V1 : Entity_Kind;
1070 V2 : Entity_Kind;
1071 V3 : Entity_Kind;
1072 V4 : Entity_Kind;
1073 V5 : Entity_Kind;
1074 V6 : Entity_Kind;
1075 V7 : Entity_Kind) return Boolean
1076 is
1077 begin
1078 return T = V1 or else
1079 T = V2 or else
1080 T = V3 or else
1081 T = V4 or else
1082 T = V5 or else
1083 T = V6 or else
1084 T = V7;
1085 end Ekind_In;
1086
1087 function Ekind_In
1088 (T : Entity_Kind;
1089 V1 : Entity_Kind;
1090 V2 : Entity_Kind;
1091 V3 : Entity_Kind;
1092 V4 : Entity_Kind;
1093 V5 : Entity_Kind;
1094 V6 : Entity_Kind;
1095 V7 : Entity_Kind;
1096 V8 : Entity_Kind) return Boolean
1097 is
1098 begin
1099 return T = V1 or else
1100 T = V2 or else
1101 T = V3 or else
1102 T = V4 or else
1103 T = V5 or else
1104 T = V6 or else
1105 T = V7 or else
1106 T = V8;
1107 end Ekind_In;
1108
1109 function Ekind_In
1110 (T : Entity_Kind;
1111 V1 : Entity_Kind;
1112 V2 : Entity_Kind;
1113 V3 : Entity_Kind;
1114 V4 : Entity_Kind;
1115 V5 : Entity_Kind;
1116 V6 : Entity_Kind;
1117 V7 : Entity_Kind;
1118 V8 : Entity_Kind;
1119 V9 : Entity_Kind) return Boolean
1120 is
1121 begin
1122 return T = V1 or else
1123 T = V2 or else
1124 T = V3 or else
1125 T = V4 or else
1126 T = V5 or else
1127 T = V6 or else
1128 T = V7 or else
1129 T = V8 or else
1130 T = V9;
1131 end Ekind_In;
1132
1133 function Ekind_In
1134 (T : Entity_Kind;
1135 V1 : Entity_Kind;
1136 V2 : Entity_Kind;
1137 V3 : Entity_Kind;
1138 V4 : Entity_Kind;
1139 V5 : Entity_Kind;
1140 V6 : Entity_Kind;
1141 V7 : Entity_Kind;
1142 V8 : Entity_Kind;
1143 V9 : Entity_Kind;
1144 V10 : Entity_Kind) return Boolean
1145 is
1146 begin
1147 return T = V1 or else
1148 T = V2 or else
1149 T = V3 or else
1150 T = V4 or else
1151 T = V5 or else
1152 T = V6 or else
1153 T = V7 or else
1154 T = V8 or else
1155 T = V9 or else
1156 T = V10;
1157 end Ekind_In;
1158
1159 function Ekind_In
1160 (T : Entity_Kind;
1161 V1 : Entity_Kind;
1162 V2 : Entity_Kind;
1163 V3 : Entity_Kind;
1164 V4 : Entity_Kind;
1165 V5 : Entity_Kind;
1166 V6 : Entity_Kind;
1167 V7 : Entity_Kind;
1168 V8 : Entity_Kind;
1169 V9 : Entity_Kind;
1170 V10 : Entity_Kind;
1171 V11 : Entity_Kind) return Boolean
1172 is
1173 begin
1174 return T = V1 or else
1175 T = V2 or else
1176 T = V3 or else
1177 T = V4 or else
1178 T = V5 or else
1179 T = V6 or else
1180 T = V7 or else
1181 T = V8 or else
1182 T = V9 or else
1183 T = V10 or else
1184 T = V11;
1185 end Ekind_In;
1186
1187 function Ekind_In
1188 (E : Entity_Id;
1189 V1 : Entity_Kind;
1190 V2 : Entity_Kind) return Boolean
1191 is
1192 begin
1193 return Ekind_In (Ekind (E), V1, V2);
1194 end Ekind_In;
1195
1196 function Ekind_In
1197 (E : Entity_Id;
1198 V1 : Entity_Kind;
1199 V2 : Entity_Kind;
1200 V3 : Entity_Kind) return Boolean
1201 is
1202 begin
1203 return Ekind_In (Ekind (E), V1, V2, V3);
1204 end Ekind_In;
1205
1206 function Ekind_In
1207 (E : Entity_Id;
1208 V1 : Entity_Kind;
1209 V2 : Entity_Kind;
1210 V3 : Entity_Kind;
1211 V4 : Entity_Kind) return Boolean
1212 is
1213 begin
1214 return Ekind_In (Ekind (E), V1, V2, V3, V4);
1215 end Ekind_In;
1216
1217 function Ekind_In
1218 (E : Entity_Id;
1219 V1 : Entity_Kind;
1220 V2 : Entity_Kind;
1221 V3 : Entity_Kind;
1222 V4 : Entity_Kind;
1223 V5 : Entity_Kind) return Boolean
1224 is
1225 begin
1226 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5);
1227 end Ekind_In;
1228
1229 function Ekind_In
1230 (E : Entity_Id;
1231 V1 : Entity_Kind;
1232 V2 : Entity_Kind;
1233 V3 : Entity_Kind;
1234 V4 : Entity_Kind;
1235 V5 : Entity_Kind;
1236 V6 : Entity_Kind) return Boolean
1237 is
1238 begin
1239 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6);
1240 end Ekind_In;
1241
1242 function Ekind_In
1243 (E : Entity_Id;
1244 V1 : Entity_Kind;
1245 V2 : Entity_Kind;
1246 V3 : Entity_Kind;
1247 V4 : Entity_Kind;
1248 V5 : Entity_Kind;
1249 V6 : Entity_Kind;
1250 V7 : Entity_Kind) return Boolean
1251 is
1252 begin
1253 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7);
1254 end Ekind_In;
1255
1256 function Ekind_In
1257 (E : Entity_Id;
1258 V1 : Entity_Kind;
1259 V2 : Entity_Kind;
1260 V3 : Entity_Kind;
1261 V4 : Entity_Kind;
1262 V5 : Entity_Kind;
1263 V6 : Entity_Kind;
1264 V7 : Entity_Kind;
1265 V8 : Entity_Kind) return Boolean
1266 is
1267 begin
1268 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7, V8);
1269 end Ekind_In;
1270
1271 function Ekind_In
1272 (E : Entity_Id;
1273 V1 : Entity_Kind;
1274 V2 : Entity_Kind;
1275 V3 : Entity_Kind;
1276 V4 : Entity_Kind;
1277 V5 : Entity_Kind;
1278 V6 : Entity_Kind;
1279 V7 : Entity_Kind;
1280 V8 : Entity_Kind;
1281 V9 : Entity_Kind) return Boolean
1282 is
1283 begin
1284 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7, V8, V9);
1285 end Ekind_In;
1286
1287 function Ekind_In
1288 (E : Entity_Id;
1289 V1 : Entity_Kind;
1290 V2 : Entity_Kind;
1291 V3 : Entity_Kind;
1292 V4 : Entity_Kind;
1293 V5 : Entity_Kind;
1294 V6 : Entity_Kind;
1295 V7 : Entity_Kind;
1296 V8 : Entity_Kind;
1297 V9 : Entity_Kind;
1298 V10 : Entity_Kind) return Boolean
1299 is
1300 begin
1301 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7, V8, V9, V10);
1302 end Ekind_In;
1303
1304 function Ekind_In
1305 (E : Entity_Id;
1306 V1 : Entity_Kind;
1307 V2 : Entity_Kind;
1308 V3 : Entity_Kind;
1309 V4 : Entity_Kind;
1310 V5 : Entity_Kind;
1311 V6 : Entity_Kind;
1312 V7 : Entity_Kind;
1313 V8 : Entity_Kind;
1314 V9 : Entity_Kind;
1315 V10 : Entity_Kind;
1316 V11 : Entity_Kind) return Boolean
1317 is
1318 begin
1319 return
1320 Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11);
1321 end Ekind_In;
1322
1323 ------------------------
1324 -- Set_Reporting_Proc --
1325 ------------------------
1326
1327 procedure Set_Reporting_Proc (P : Report_Proc) is
1328 begin
1329 pragma Assert (Reporting_Proc = null);
1330 Reporting_Proc := P;
1331 end Set_Reporting_Proc;
1332
1333 ------------------
1334 -- Error_Posted --
1335 ------------------
1336
1337 function Error_Posted (N : Node_Id) return Boolean is
1338 begin
1339 pragma Assert (N <= Nodes.Last);
1340 return Nodes.Table (N).Error_Posted;
1341 end Error_Posted;
1342
1343 -----------------------
1344 -- Exchange_Entities --
1345 -----------------------
1346
1347 procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is
1348 Temp_Ent : Node_Record;
1349 Temp_Flg : Flags_Byte;
1350
1351 begin
1352 pragma Assert (True
1353 and then Has_Extension (E1)
1354 and then Has_Extension (E2)
1355 and then not Nodes.Table (E1).In_List
1356 and then not Nodes.Table (E2).In_List);
1357
1358 -- Exchange the contents of the two entities
1359
1360 for J in 0 .. Num_Extension_Nodes loop
1361 Temp_Ent := Nodes.Table (E1 + J);
1362 Nodes.Table (E1 + J) := Nodes.Table (E2 + J);
1363 Nodes.Table (E2 + J) := Temp_Ent;
1364 end loop;
1365
1366 -- Exchange flag bytes for first component. No need to do the exchange
1367 -- for the other components, since the flag bytes are always zero.
1368
1369 Temp_Flg := Flags.Table (E1);
1370 Flags.Table (E1) := Flags.Table (E2);
1371 Flags.Table (E2) := Temp_Flg;
1372
1373 -- That exchange exchanged the parent pointers as well, which is what
1374 -- we want, but we need to patch up the defining identifier pointers
1375 -- in the parent nodes (the child pointers) to match this switch
1376 -- unless for Implicit types entities which have no parent, in which
1377 -- case we don't do anything otherwise we won't be able to revert back
1378 -- to the original situation.
1379
1380 -- Shouldn't this use Is_Itype instead of the Parent test
1381
1382 if Present (Parent (E1)) and then Present (Parent (E2)) then
1383 Set_Defining_Identifier (Parent (E1), E1);
1384 Set_Defining_Identifier (Parent (E2), E2);
1385 end if;
1386 end Exchange_Entities;
1387
1388 -----------------
1389 -- Extend_Node --
1390 -----------------
1391
1392 function Extend_Node (Node : Node_Id) return Entity_Id is
1393 Result : Entity_Id;
1394
1395 procedure Debug_Extend_Node;
1396 pragma Inline (Debug_Extend_Node);
1397 -- Debug routine for debug flag N
1398
1399 -----------------------
1400 -- Debug_Extend_Node --
1401 -----------------------
1402
1403 procedure Debug_Extend_Node is
1404 begin
1405 if Debug_Flag_N then
1406 Write_Str ("Extend node ");
1407 Write_Int (Int (Node));
1408
1409 if Result = Node then
1410 Write_Str (" in place");
1411 else
1412 Write_Str (" copied to ");
1413 Write_Int (Int (Result));
1414 end if;
1415
1416 -- Write_Eol;
1417 end if;
1418 end Debug_Extend_Node;
1419
1420 -- Start of processing for Extend_Node
1421
1422 begin
1423 pragma Assert (not (Has_Extension (Node)));
1424 Result := Allocate_Initialize_Node (Node, With_Extension => True);
1425 pragma Debug (Debug_Extend_Node);
1426 return Result;
1427 end Extend_Node;
1428
1429 -----------------
1430 -- Fix_Parents --
1431 -----------------
1432
1433 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id) is
1434
1435 procedure Fix_Parent (Field : Union_Id);
1436 -- Fixup one parent pointer. Field is checked to see if it points to
1437 -- a node, list, or element list that has a parent that points to
1438 -- Ref_Node. If so, the parent is reset to point to Fix_Node.
1439
1440 ----------------
1441 -- Fix_Parent --
1442 ----------------
1443
1444 procedure Fix_Parent (Field : Union_Id) is
1445 begin
1446 -- Fix parent of node that is referenced by Field. Note that we must
1447 -- exclude the case where the node is a member of a list, because in
1448 -- this case the parent is the parent of the list.
1449
1450 if Field in Node_Range
1451 and then Present (Node_Id (Field))
1452 and then not Nodes.Table (Node_Id (Field)).In_List
1453 and then Parent (Node_Id (Field)) = Ref_Node
1454 then
1455 Set_Parent (Node_Id (Field), Fix_Node);
1456
1457 -- Fix parent of list that is referenced by Field
1458
1459 elsif Field in List_Range
1460 and then Present (List_Id (Field))
1461 and then Parent (List_Id (Field)) = Ref_Node
1462 then
1463 Set_Parent (List_Id (Field), Fix_Node);
1464 end if;
1465 end Fix_Parent;
1466
1467 -- Start of processing for Fix_Parents
1468
1469 begin
1470 Fix_Parent (Field1 (Fix_Node));
1471 Fix_Parent (Field2 (Fix_Node));
1472 Fix_Parent (Field3 (Fix_Node));
1473 Fix_Parent (Field4 (Fix_Node));
1474 Fix_Parent (Field5 (Fix_Node));
1475 end Fix_Parents;
1476
1477 -------------------
1478 -- Flags_Address --
1479 -------------------
1480
1481 function Flags_Address return System.Address is
1482 begin
1483 return Flags.Table (First_Node_Id)'Address;
1484 end Flags_Address;
1485
1486 -----------------------------------
1487 -- Get_Comes_From_Source_Default --
1488 -----------------------------------
1489
1490 function Get_Comes_From_Source_Default return Boolean is
1491 begin
1492 return Default_Node.Comes_From_Source;
1493 end Get_Comes_From_Source_Default;
1494
1495 -----------------
1496 -- Has_Aspects --
1497 -----------------
1498
1499 function Has_Aspects (N : Node_Id) return Boolean is
1500 begin
1501 pragma Assert (N <= Nodes.Last);
1502 return Nodes.Table (N).Has_Aspects;
1503 end Has_Aspects;
1504
1505 -------------------
1506 -- Has_Extension --
1507 -------------------
1508
1509 function Has_Extension (N : Node_Id) return Boolean is
1510 begin
1511 return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension;
1512 end Has_Extension;
1513
1514 ----------------
1515 -- Initialize --
1516 ----------------
1517
1518 procedure Initialize is
1519 Dummy : Node_Id;
1520 pragma Warnings (Off, Dummy);
1521
1522 begin
1523 Node_Count := 0;
1524 Atree_Private_Part.Nodes.Init;
1525 Atree_Private_Part.Flags.Init;
1526 Orig_Nodes.Init;
1527 Paren_Counts.Init;
1528
1529 -- Allocate Empty node
1530
1531 Dummy := New_Node (N_Empty, No_Location);
1532 Set_Name1 (Empty, No_Name);
1533
1534 -- Allocate Error node, and set Error_Posted, since we certainly
1535 -- only generate an Error node if we do post some kind of error.
1536
1537 Dummy := New_Node (N_Error, No_Location);
1538 Set_Name1 (Error, Error_Name);
1539 Set_Error_Posted (Error, True);
1540 end Initialize;
1541
1542 ---------------------------
1543 -- Is_Ignored_Ghost_Node --
1544 ---------------------------
1545
1546 function Is_Ignored_Ghost_Node (N : Node_Id) return Boolean is
1547 begin
1548 return Flags.Table (N).Is_Ignored_Ghost_Node;
1549 end Is_Ignored_Ghost_Node;
1550
1551 --------------------------
1552 -- Is_Rewrite_Insertion --
1553 --------------------------
1554
1555 function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is
1556 begin
1557 return Nodes.Table (Node).Rewrite_Ins;
1558 end Is_Rewrite_Insertion;
1559
1560 -----------------------------
1561 -- Is_Rewrite_Substitution --
1562 -----------------------------
1563
1564 function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is
1565 begin
1566 return Orig_Nodes.Table (Node) /= Node;
1567 end Is_Rewrite_Substitution;
1568
1569 ------------------
1570 -- Last_Node_Id --
1571 ------------------
1572
1573 function Last_Node_Id return Node_Id is
1574 begin
1575 return Nodes.Last;
1576 end Last_Node_Id;
1577
1578 ----------
1579 -- Lock --
1580 ----------
1581
1582 procedure Lock is
1583 begin
1584 Nodes.Locked := True;
1585 Flags.Locked := True;
1586 Orig_Nodes.Locked := True;
1587 Nodes.Release;
1588 Flags.Release;
1589 Orig_Nodes.Release;
1590 end Lock;
1591
1592 ----------------------------
1593 -- Mark_Rewrite_Insertion --
1594 ----------------------------
1595
1596 procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is
1597 begin
1598 Nodes.Table (New_Node).Rewrite_Ins := True;
1599 end Mark_Rewrite_Insertion;
1600
1601 --------------
1602 -- New_Copy --
1603 --------------
1604
1605 function New_Copy (Source : Node_Id) return Node_Id is
1606 New_Id : Node_Id := Source;
1607
1608 begin
1609 if Source > Empty_Or_Error then
1610 New_Id := Allocate_Initialize_Node (Source, Has_Extension (Source));
1611
1612 Nodes.Table (New_Id).Link := Empty_List_Or_Node;
1613 Nodes.Table (New_Id).In_List := False;
1614
1615 -- If the original is marked as a rewrite insertion, then unmark the
1616 -- copy, since we inserted the original, not the copy.
1617
1618 Nodes.Table (New_Id).Rewrite_Ins := False;
1619 pragma Debug (New_Node_Debugging_Output (New_Id));
1620
1621 -- Clear Is_Overloaded since we cannot have semantic interpretations
1622 -- of this new node.
1623
1624 if Nkind (Source) in N_Subexpr then
1625 Set_Is_Overloaded (New_Id, False);
1626 end if;
1627
1628 -- Always clear Has_Aspects, the caller must take care of copying
1629 -- aspects if this is required for the particular situation.
1630
1631 Set_Has_Aspects (New_Id, False);
1632 end if;
1633
1634 return New_Id;
1635 end New_Copy;
1636
1637 ----------------
1638 -- New_Entity --
1639 ----------------
1640
1641 function New_Entity
1642 (New_Node_Kind : Node_Kind;
1643 New_Sloc : Source_Ptr) return Entity_Id
1644 is
1645 Ent : Entity_Id;
1646
1647 begin
1648 pragma Assert (New_Node_Kind in N_Entity);
1649
1650 Ent := Allocate_Initialize_Node (Empty, With_Extension => True);
1651
1652 -- If this is a node with a real location and we are generating
1653 -- source nodes, then reset Current_Error_Node. This is useful
1654 -- if we bomb during parsing to get a error location for the bomb.
1655
1656 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1657 Current_Error_Node := Ent;
1658 end if;
1659
1660 Nodes.Table (Ent).Nkind := New_Node_Kind;
1661 Nodes.Table (Ent).Sloc := New_Sloc;
1662 pragma Debug (New_Node_Debugging_Output (Ent));
1663
1664 return Ent;
1665 end New_Entity;
1666
1667 --------------
1668 -- New_Node --
1669 --------------
1670
1671 function New_Node
1672 (New_Node_Kind : Node_Kind;
1673 New_Sloc : Source_Ptr) return Node_Id
1674 is
1675 Nod : Node_Id;
1676
1677 begin
1678 pragma Assert (New_Node_Kind not in N_Entity);
1679 Nod := Allocate_Initialize_Node (Empty, With_Extension => False);
1680 Nodes.Table (Nod).Nkind := New_Node_Kind;
1681 Nodes.Table (Nod).Sloc := New_Sloc;
1682 pragma Debug (New_Node_Debugging_Output (Nod));
1683
1684 -- If this is a node with a real location and we are generating source
1685 -- nodes, then reset Current_Error_Node. This is useful if we bomb
1686 -- during parsing to get an error location for the bomb.
1687
1688 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1689 Current_Error_Node := Nod;
1690 end if;
1691
1692 return Nod;
1693 end New_Node;
1694
1695 -------------------------
1696 -- New_Node_Breakpoint --
1697 -------------------------
1698
1699 procedure nn is
1700 begin
1701 Write_Str ("Watched node ");
1702 Write_Int (Int (Watch_Node));
1703 Write_Str (" created");
1704 Write_Eol;
1705 end nn;
1706
1707 -------------------------------
1708 -- New_Node_Debugging_Output --
1709 -------------------------------
1710
1711 procedure nnd (N : Node_Id) is
1712 Node_Is_Watched : constant Boolean := N = Watch_Node;
1713
1714 begin
1715 if Debug_Flag_N or else Node_Is_Watched then
1716 Node_Debug_Output ("Allocate", N);
1717
1718 if Node_Is_Watched then
1719 New_Node_Breakpoint;
1720 end if;
1721 end if;
1722 end nnd;
1723
1724 -----------
1725 -- Nkind --
1726 -----------
1727
1728 function Nkind (N : Node_Id) return Node_Kind is
1729 begin
1730 return Nodes.Table (N).Nkind;
1731 end Nkind;
1732
1733 --------------
1734 -- Nkind_In --
1735 --------------
1736
1737 function Nkind_In
1738 (N : Node_Id;
1739 V1 : Node_Kind;
1740 V2 : Node_Kind) return Boolean
1741 is
1742 begin
1743 return Nkind_In (Nkind (N), V1, V2);
1744 end Nkind_In;
1745
1746 function Nkind_In
1747 (N : Node_Id;
1748 V1 : Node_Kind;
1749 V2 : Node_Kind;
1750 V3 : Node_Kind) return Boolean
1751 is
1752 begin
1753 return Nkind_In (Nkind (N), V1, V2, V3);
1754 end Nkind_In;
1755
1756 function Nkind_In
1757 (N : Node_Id;
1758 V1 : Node_Kind;
1759 V2 : Node_Kind;
1760 V3 : Node_Kind;
1761 V4 : Node_Kind) return Boolean
1762 is
1763 begin
1764 return Nkind_In (Nkind (N), V1, V2, V3, V4);
1765 end Nkind_In;
1766
1767 function Nkind_In
1768 (N : Node_Id;
1769 V1 : Node_Kind;
1770 V2 : Node_Kind;
1771 V3 : Node_Kind;
1772 V4 : Node_Kind;
1773 V5 : Node_Kind) return Boolean
1774 is
1775 begin
1776 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5);
1777 end Nkind_In;
1778
1779 function Nkind_In
1780 (N : Node_Id;
1781 V1 : Node_Kind;
1782 V2 : Node_Kind;
1783 V3 : Node_Kind;
1784 V4 : Node_Kind;
1785 V5 : Node_Kind;
1786 V6 : Node_Kind) return Boolean
1787 is
1788 begin
1789 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6);
1790 end Nkind_In;
1791
1792 function Nkind_In
1793 (N : Node_Id;
1794 V1 : Node_Kind;
1795 V2 : Node_Kind;
1796 V3 : Node_Kind;
1797 V4 : Node_Kind;
1798 V5 : Node_Kind;
1799 V6 : Node_Kind;
1800 V7 : Node_Kind) return Boolean
1801 is
1802 begin
1803 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7);
1804 end Nkind_In;
1805
1806 function Nkind_In
1807 (N : Node_Id;
1808 V1 : Node_Kind;
1809 V2 : Node_Kind;
1810 V3 : Node_Kind;
1811 V4 : Node_Kind;
1812 V5 : Node_Kind;
1813 V6 : Node_Kind;
1814 V7 : Node_Kind;
1815 V8 : Node_Kind) return Boolean
1816 is
1817 begin
1818 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8);
1819 end Nkind_In;
1820
1821 function Nkind_In
1822 (N : Node_Id;
1823 V1 : Node_Kind;
1824 V2 : Node_Kind;
1825 V3 : Node_Kind;
1826 V4 : Node_Kind;
1827 V5 : Node_Kind;
1828 V6 : Node_Kind;
1829 V7 : Node_Kind;
1830 V8 : Node_Kind;
1831 V9 : Node_Kind) return Boolean
1832 is
1833 begin
1834 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8, V9);
1835 end Nkind_In;
1836
1837 --------
1838 -- No --
1839 --------
1840
1841 function No (N : Node_Id) return Boolean is
1842 begin
1843 return N = Empty;
1844 end No;
1845
1846 -----------------------
1847 -- Node_Debug_Output --
1848 -----------------------
1849
1850 procedure Node_Debug_Output (Op : String; N : Node_Id) is
1851 begin
1852 Write_Str (Op);
1853
1854 if Nkind (N) in N_Entity then
1855 Write_Str (" entity");
1856 else
1857 Write_Str (" node");
1858 end if;
1859
1860 Write_Str (" Id = ");
1861 Write_Int (Int (N));
1862 Write_Str (" ");
1863 Write_Location (Sloc (N));
1864 Write_Str (" ");
1865 Write_Str (Node_Kind'Image (Nkind (N)));
1866 Write_Eol;
1867 end Node_Debug_Output;
1868
1869 -------------------
1870 -- Nodes_Address --
1871 -------------------
1872
1873 function Nodes_Address return System.Address is
1874 begin
1875 return Nodes.Table (First_Node_Id)'Address;
1876 end Nodes_Address;
1877
1878 ---------------
1879 -- Num_Nodes --
1880 ---------------
1881
1882 function Num_Nodes return Nat is
1883 begin
1884 return Node_Count;
1885 end Num_Nodes;
1886
1887 -------------------
1888 -- Original_Node --
1889 -------------------
1890
1891 function Original_Node (Node : Node_Id) return Node_Id is
1892 begin
1893 return Orig_Nodes.Table (Node);
1894 end Original_Node;
1895
1896 -----------------
1897 -- Paren_Count --
1898 -----------------
1899
1900 function Paren_Count (N : Node_Id) return Nat is
1901 C : Nat := 0;
1902
1903 begin
1904 pragma Assert (N <= Nodes.Last);
1905
1906 if Nodes.Table (N).Pflag1 then
1907 C := C + 1;
1908 end if;
1909
1910 if Nodes.Table (N).Pflag2 then
1911 C := C + 2;
1912 end if;
1913
1914 -- Value of 0,1,2 returned as is
1915
1916 if C <= 2 then
1917 return C;
1918
1919 -- Value of 3 means we search the table, and we must find an entry
1920
1921 else
1922 for J in Paren_Counts.First .. Paren_Counts.Last loop
1923 if N = Paren_Counts.Table (J).Nod then
1924 return Paren_Counts.Table (J).Count;
1925 end if;
1926 end loop;
1927
1928 raise Program_Error;
1929 end if;
1930 end Paren_Count;
1931
1932 ------------
1933 -- Parent --
1934 ------------
1935
1936 function Parent (N : Node_Id) return Node_Id is
1937 begin
1938 if Is_List_Member (N) then
1939 return Parent (List_Containing (N));
1940 else
1941 return Node_Id (Nodes.Table (N).Link);
1942 end if;
1943 end Parent;
1944
1945 -------------
1946 -- Present --
1947 -------------
1948
1949 function Present (N : Node_Id) return Boolean is
1950 begin
1951 return N /= Empty;
1952 end Present;
1953
1954 --------------------------------
1955 -- Preserve_Comes_From_Source --
1956 --------------------------------
1957
1958 procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is
1959 begin
1960 Nodes.Table (NewN).Comes_From_Source :=
1961 Nodes.Table (OldN).Comes_From_Source;
1962 end Preserve_Comes_From_Source;
1963
1964 ----------------------
1965 -- Print_Statistics --
1966 ----------------------
1967
1968 procedure Print_Statistics is
1969 N_Count : constant Natural := Natural (Nodes.Last - First_Node_Id + 1);
1970 E_Count : Natural := 0;
1971
1972 begin
1973 Write_Str ("Number of entities: ");
1974 Write_Eol;
1975
1976 declare
1977 function CP_Lt (Op1, Op2 : Natural) return Boolean;
1978 -- Compare routine for Sort
1979
1980 procedure CP_Move (From : Natural; To : Natural);
1981 -- Move routine for Sort
1982
1983 Kind_Count : array (Node_Kind) of Natural := (others => 0);
1984 -- Array of occurrence count per node kind
1985
1986 Kind_Max : constant Natural := Node_Kind'Pos (N_Unused_At_End) - 1;
1987 -- The index of the largest (interesting) node kind
1988
1989 Ranking : array (0 .. Kind_Max) of Node_Kind;
1990 -- Ranking array for node kinds (index 0 is used for the temporary)
1991
1992 package Sorting is new GNAT.Heap_Sort_G (CP_Move, CP_Lt);
1993
1994 function CP_Lt (Op1, Op2 : Natural) return Boolean is
1995 begin
1996 return Kind_Count (Ranking (Op2)) < Kind_Count (Ranking (Op1));
1997 end CP_Lt;
1998
1999 procedure CP_Move (From : Natural; To : Natural) is
2000 begin
2001 Ranking (To) := Ranking (From);
2002 end CP_Move;
2003
2004 begin
2005 -- Count the number of occurrences of each node kind
2006
2007 for I in First_Node_Id .. Nodes.Last loop
2008 declare
2009 Nkind : constant Node_Kind := Nodes.Table (I).Nkind;
2010 begin
2011 if not Nodes.Table (I).Is_Extension then
2012 Kind_Count (Nkind) := Kind_Count (Nkind) + 1;
2013 end if;
2014 end;
2015 end loop;
2016
2017 -- Sort the node kinds by number of occurrences
2018
2019 for N in 1 .. Kind_Max loop
2020 Ranking (N) := Node_Kind'Val (N);
2021 end loop;
2022
2023 Sorting.Sort (Kind_Max);
2024
2025 -- Print the list in descending order
2026
2027 for N in 1 .. Kind_Max loop
2028 declare
2029 Count : constant Natural := Kind_Count (Ranking (N));
2030 begin
2031 if Count > 0 then
2032 Write_Str (" ");
2033 Write_Str (Node_Kind'Image (Ranking (N)));
2034 Write_Str (": ");
2035 Write_Int (Int (Count));
2036 Write_Eol;
2037
2038 E_Count := E_Count + Count;
2039 end if;
2040 end;
2041 end loop;
2042 end;
2043
2044 Write_Str ("Total number of entities: ");
2045 Write_Int (Int (E_Count));
2046 Write_Eol;
2047
2048 Write_Str ("Maximum number of nodes per entity: ");
2049 Write_Int (Int (Num_Extension_Nodes + 1));
2050 Write_Eol;
2051
2052 Write_Str ("Number of allocated nodes: ");
2053 Write_Int (Int (N_Count));
2054 Write_Eol;
2055
2056 Write_Str ("Ratio allocated nodes/entities: ");
2057 Write_Int (Int (Long_Long_Integer (N_Count) * 100 /
2058 Long_Long_Integer (E_Count)));
2059 Write_Str ("/100");
2060 Write_Eol;
2061
2062 Write_Str ("Size of a node in bytes: ");
2063 Write_Int (Int (Node_Record'Size) / Storage_Unit);
2064 Write_Eol;
2065
2066 Write_Str ("Memory consumption in bytes: ");
2067 Write_Int (Int (Long_Long_Integer (N_Count) *
2068 (Node_Record'Size / Storage_Unit)));
2069 Write_Eol;
2070 end Print_Statistics;
2071
2072 -------------------
2073 -- Relocate_Node --
2074 -------------------
2075
2076 function Relocate_Node (Source : Node_Id) return Node_Id is
2077 New_Node : Node_Id;
2078
2079 begin
2080 if No (Source) then
2081 return Empty;
2082 end if;
2083
2084 New_Node := New_Copy (Source);
2085 Fix_Parents (Ref_Node => Source, Fix_Node => New_Node);
2086
2087 -- We now set the parent of the new node to be the same as the parent of
2088 -- the source. Almost always this parent will be replaced by a new value
2089 -- when the relocated node is reattached to the tree, but by doing it
2090 -- now, we ensure that this node is not even temporarily disconnected
2091 -- from the tree. Note that this does not happen free, because in the
2092 -- list case, the parent does not get set.
2093
2094 Set_Parent (New_Node, Parent (Source));
2095
2096 -- If the node being relocated was a rewriting of some original node,
2097 -- then the relocated node has the same original node.
2098
2099 if Orig_Nodes.Table (Source) /= Source then
2100 Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source);
2101 end if;
2102
2103 return New_Node;
2104 end Relocate_Node;
2105
2106 -------------
2107 -- Replace --
2108 -------------
2109
2110 procedure Replace (Old_Node, New_Node : Node_Id) is
2111 Old_Post : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
2112 Old_HasA : constant Boolean := Nodes.Table (Old_Node).Has_Aspects;
2113 Old_CFS : constant Boolean := Nodes.Table (Old_Node).Comes_From_Source;
2114
2115 begin
2116 pragma Assert
2117 (not Has_Extension (Old_Node)
2118 and not Has_Extension (New_Node)
2119 and not Nodes.Table (New_Node).In_List);
2120
2121 -- Do copy, preserving link and in list status and required flags
2122
2123 Copy_Node (Source => New_Node, Destination => Old_Node);
2124 Nodes.Table (Old_Node).Comes_From_Source := Old_CFS;
2125 Nodes.Table (Old_Node).Error_Posted := Old_Post;
2126 Nodes.Table (Old_Node).Has_Aspects := Old_HasA;
2127
2128 -- Fix parents of substituted node, since it has changed identity
2129
2130 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
2131
2132 -- Since we are doing a replace, we assume that the original node
2133 -- is intended to become the new replaced node. The call would be
2134 -- to Rewrite if there were an intention to save the original node.
2135
2136 Orig_Nodes.Table (Old_Node) := Old_Node;
2137
2138 -- Invoke the reporting procedure (if available)
2139
2140 if Reporting_Proc /= null then
2141 Reporting_Proc.all (Target => Old_Node, Source => New_Node);
2142 end if;
2143 end Replace;
2144
2145 -------------
2146 -- Rewrite --
2147 -------------
2148
2149 procedure Rewrite (Old_Node, New_Node : Node_Id) is
2150 Old_Error_P : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
2151 -- This field is always preserved in the new node
2152
2153 Old_Has_Aspects : constant Boolean := Nodes.Table (Old_Node).Has_Aspects;
2154 -- This field is always preserved in the new node
2155
2156 Old_Paren_Count : Nat;
2157 Old_Must_Not_Freeze : Boolean;
2158 -- These fields are preserved in the new node only if the new node
2159 -- and the old node are both subexpression nodes.
2160
2161 -- Note: it is a violation of abstraction levels for Must_Not_Freeze
2162 -- to be referenced like this. ???
2163
2164 Sav_Node : Node_Id;
2165
2166 begin
2167 pragma Assert
2168 (not Has_Extension (Old_Node)
2169 and not Has_Extension (New_Node)
2170 and not Nodes.Table (New_Node).In_List);
2171 pragma Debug (Rewrite_Debugging_Output (Old_Node, New_Node));
2172
2173 if Nkind (Old_Node) in N_Subexpr then
2174 Old_Paren_Count := Paren_Count (Old_Node);
2175 Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node);
2176 else
2177 Old_Paren_Count := 0;
2178 Old_Must_Not_Freeze := False;
2179 end if;
2180
2181 -- Allocate a new node, to be used to preserve the original contents
2182 -- of the Old_Node, for possible later retrival by Original_Node and
2183 -- make an entry in the Orig_Nodes table. This is only done if we have
2184 -- not already rewritten the node, as indicated by an Orig_Nodes entry
2185 -- that does not reference the Old_Node.
2186
2187 if Orig_Nodes.Table (Old_Node) = Old_Node then
2188 Sav_Node := New_Copy (Old_Node);
2189 Orig_Nodes.Table (Sav_Node) := Sav_Node;
2190 Orig_Nodes.Table (Old_Node) := Sav_Node;
2191
2192 -- Both the old and new copies of the node will share the same list
2193 -- of aspect specifications if aspect specifications are present.
2194
2195 if Old_Has_Aspects then
2196 Set_Aspect_Specifications
2197 (Sav_Node, Aspect_Specifications (Old_Node));
2198 end if;
2199 end if;
2200
2201 -- Copy substitute node into place, preserving old fields as required
2202
2203 Copy_Node (Source => New_Node, Destination => Old_Node);
2204 Nodes.Table (Old_Node).Error_Posted := Old_Error_P;
2205 Nodes.Table (Old_Node).Has_Aspects := Old_Has_Aspects;
2206
2207 if Nkind (New_Node) in N_Subexpr then
2208 Set_Paren_Count (Old_Node, Old_Paren_Count);
2209 Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze);
2210 end if;
2211
2212 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
2213
2214 -- Invoke the reporting procedure (if available)
2215
2216 if Reporting_Proc /= null then
2217 Reporting_Proc.all (Target => Old_Node, Source => New_Node);
2218 end if;
2219 end Rewrite;
2220
2221 -------------------------
2222 -- Rewrite_Breakpoint --
2223 -------------------------
2224
2225 procedure rr is
2226 begin
2227 Write_Str ("Watched node ");
2228 Write_Int (Int (Watch_Node));
2229 Write_Str (" rewritten");
2230 Write_Eol;
2231 end rr;
2232
2233 ------------------------------
2234 -- Rewrite_Debugging_Output --
2235 ------------------------------
2236
2237 procedure rrd (Old_Node, New_Node : Node_Id) is
2238 Node_Is_Watched : constant Boolean := Old_Node = Watch_Node;
2239
2240 begin
2241 if Debug_Flag_N or else Node_Is_Watched then
2242 Node_Debug_Output ("Rewrite", Old_Node);
2243 Node_Debug_Output ("into", New_Node);
2244
2245 if Node_Is_Watched then
2246 Rewrite_Breakpoint;
2247 end if;
2248 end if;
2249 end rrd;
2250
2251 ------------------
2252 -- Set_Analyzed --
2253 ------------------
2254
2255 procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is
2256 begin
2257 Nodes.Table (N).Analyzed := Val;
2258 end Set_Analyzed;
2259
2260 -----------------------
2261 -- Set_Check_Actuals --
2262 -----------------------
2263
2264 procedure Set_Check_Actuals (N : Node_Id; Val : Boolean := True) is
2265 begin
2266 Flags.Table (N).Check_Actuals := Val;
2267 end Set_Check_Actuals;
2268
2269 ---------------------------
2270 -- Set_Comes_From_Source --
2271 ---------------------------
2272
2273 procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is
2274 begin
2275 pragma Assert (N <= Nodes.Last);
2276 Nodes.Table (N).Comes_From_Source := Val;
2277 end Set_Comes_From_Source;
2278
2279 -----------------------------------
2280 -- Set_Comes_From_Source_Default --
2281 -----------------------------------
2282
2283 procedure Set_Comes_From_Source_Default (Default : Boolean) is
2284 begin
2285 Default_Node.Comes_From_Source := Default;
2286 end Set_Comes_From_Source_Default;
2287
2288 ---------------
2289 -- Set_Ekind --
2290 ---------------
2291
2292 procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is
2293 begin
2294 pragma Assert (Nkind (E) in N_Entity);
2295 Nodes.Table (E + 1).Nkind := E_To_N (Val);
2296 end Set_Ekind;
2297
2298 ----------------------
2299 -- Set_Error_Posted --
2300 ----------------------
2301
2302 procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is
2303 begin
2304 Nodes.Table (N).Error_Posted := Val;
2305 end Set_Error_Posted;
2306
2307 ---------------------
2308 -- Set_Has_Aspects --
2309 ---------------------
2310
2311 procedure Set_Has_Aspects (N : Node_Id; Val : Boolean := True) is
2312 begin
2313 pragma Assert (N <= Nodes.Last);
2314 Nodes.Table (N).Has_Aspects := Val;
2315 end Set_Has_Aspects;
2316
2317 -------------------------------
2318 -- Set_Is_Ignored_Ghost_Node --
2319 -------------------------------
2320
2321 procedure Set_Is_Ignored_Ghost_Node (N : Node_Id; Val : Boolean := True) is
2322 begin
2323 Flags.Table (N).Is_Ignored_Ghost_Node := Val;
2324 end Set_Is_Ignored_Ghost_Node;
2325
2326 -----------------------
2327 -- Set_Original_Node --
2328 -----------------------
2329
2330 procedure Set_Original_Node (N : Node_Id; Val : Node_Id) is
2331 begin
2332 Orig_Nodes.Table (N) := Val;
2333 end Set_Original_Node;
2334
2335 ---------------------
2336 -- Set_Paren_Count --
2337 ---------------------
2338
2339 procedure Set_Paren_Count (N : Node_Id; Val : Nat) is
2340 begin
2341 pragma Assert (Nkind (N) in N_Subexpr);
2342
2343 -- Value of 0,1,2 stored as is
2344
2345 if Val <= 2 then
2346 Nodes.Table (N).Pflag1 := (Val mod 2 /= 0);
2347 Nodes.Table (N).Pflag2 := (Val = 2);
2348
2349 -- Value of 3 or greater stores 3 in node and makes table entry
2350
2351 else
2352 Nodes.Table (N).Pflag1 := True;
2353 Nodes.Table (N).Pflag2 := True;
2354
2355 for J in Paren_Counts.First .. Paren_Counts.Last loop
2356 if N = Paren_Counts.Table (J).Nod then
2357 Paren_Counts.Table (J).Count := Val;
2358 return;
2359 end if;
2360 end loop;
2361
2362 Paren_Counts.Append ((Nod => N, Count => Val));
2363 end if;
2364 end Set_Paren_Count;
2365
2366 ----------------
2367 -- Set_Parent --
2368 ----------------
2369
2370 procedure Set_Parent (N : Node_Id; Val : Node_Id) is
2371 begin
2372 pragma Assert (not Nodes.Table (N).In_List);
2373 Nodes.Table (N).Link := Union_Id (Val);
2374 end Set_Parent;
2375
2376 --------------
2377 -- Set_Sloc --
2378 --------------
2379
2380 procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is
2381 begin
2382 Nodes.Table (N).Sloc := Val;
2383 end Set_Sloc;
2384
2385 ----------
2386 -- Sloc --
2387 ----------
2388
2389 function Sloc (N : Node_Id) return Source_Ptr is
2390 begin
2391 return Nodes.Table (N).Sloc;
2392 end Sloc;
2393
2394 -------------------
2395 -- Traverse_Func --
2396 -------------------
2397
2398 function Traverse_Func (Node : Node_Id) return Traverse_Final_Result is
2399
2400 function Traverse_Field
2401 (Nod : Node_Id;
2402 Fld : Union_Id;
2403 FN : Field_Num) return Traverse_Final_Result;
2404 -- Fld is one of the fields of Nod. If the field points to syntactic
2405 -- node or list, then this node or list is traversed, and the result is
2406 -- the result of this traversal. Otherwise a value of True is returned
2407 -- with no processing. FN is the number of the field (1 .. 5).
2408
2409 --------------------
2410 -- Traverse_Field --
2411 --------------------
2412
2413 function Traverse_Field
2414 (Nod : Node_Id;
2415 Fld : Union_Id;
2416 FN : Field_Num) return Traverse_Final_Result
2417 is
2418 begin
2419 if Fld = Union_Id (Empty) then
2420 return OK;
2421
2422 -- Descendant is a node
2423
2424 elsif Fld in Node_Range then
2425
2426 -- Traverse descendant that is syntactic subtree node
2427
2428 if Is_Syntactic_Field (Nkind (Nod), FN) then
2429 return Traverse_Func (Node_Id (Fld));
2430
2431 -- Node that is not a syntactic subtree
2432
2433 else
2434 return OK;
2435 end if;
2436
2437 -- Descendant is a list
2438
2439 elsif Fld in List_Range then
2440
2441 -- Traverse descendant that is a syntactic subtree list
2442
2443 if Is_Syntactic_Field (Nkind (Nod), FN) then
2444 declare
2445 Elmt : Node_Id := First (List_Id (Fld));
2446
2447 begin
2448 while Present (Elmt) loop
2449 if Traverse_Func (Elmt) = Abandon then
2450 return Abandon;
2451 else
2452 Next (Elmt);
2453 end if;
2454 end loop;
2455
2456 return OK;
2457 end;
2458
2459 -- List that is not a syntactic subtree
2460
2461 else
2462 return OK;
2463 end if;
2464
2465 -- Field was not a node or a list
2466
2467 else
2468 return OK;
2469 end if;
2470 end Traverse_Field;
2471
2472 Cur_Node : Node_Id := Node;
2473
2474 -- Start of processing for Traverse_Func
2475
2476 begin
2477 -- We walk Field2 last, and if it is a node, we eliminate the tail
2478 -- recursion by jumping back to this label. This is because Field2 is
2479 -- where the Left_Opnd field of N_Op_Concat is stored, and in practice
2480 -- concatenations are sometimes deeply nested, as in X1&X2&...&XN. This
2481 -- trick prevents us from running out of memory in that case. We don't
2482 -- bother eliminating the tail recursion if Field2 is a list.
2483
2484 <<Tail_Recurse>>
2485
2486 case Process (Cur_Node) is
2487 when Abandon =>
2488 return Abandon;
2489
2490 when Skip =>
2491 return OK;
2492
2493 when OK =>
2494 null;
2495
2496 when OK_Orig =>
2497 Cur_Node := Original_Node (Cur_Node);
2498 end case;
2499
2500 if Traverse_Field (Cur_Node, Field1 (Cur_Node), 1) = Abandon
2501 or else -- skip Field2 here
2502 Traverse_Field (Cur_Node, Field3 (Cur_Node), 3) = Abandon
2503 or else
2504 Traverse_Field (Cur_Node, Field4 (Cur_Node), 4) = Abandon
2505 or else
2506 Traverse_Field (Cur_Node, Field5 (Cur_Node), 5) = Abandon
2507 then
2508 return Abandon;
2509 end if;
2510
2511 if Field2 (Cur_Node) not in Node_Range then
2512 return Traverse_Field (Cur_Node, Field2 (Cur_Node), 2);
2513
2514 elsif Is_Syntactic_Field (Nkind (Cur_Node), 2)
2515 and then Field2 (Cur_Node) /= Empty_List_Or_Node
2516 then
2517 -- Here is the tail recursion step, we reset Cur_Node and jump back
2518 -- to the start of the procedure, which has the same semantic effect
2519 -- as a call.
2520
2521 Cur_Node := Node_Id (Field2 (Cur_Node));
2522 goto Tail_Recurse;
2523 end if;
2524
2525 return OK;
2526 end Traverse_Func;
2527
2528 -------------------
2529 -- Traverse_Proc --
2530 -------------------
2531
2532 procedure Traverse_Proc (Node : Node_Id) is
2533 function Traverse is new Traverse_Func (Process);
2534 Discard : Traverse_Final_Result;
2535 pragma Warnings (Off, Discard);
2536 begin
2537 Discard := Traverse (Node);
2538 end Traverse_Proc;
2539
2540 ---------------
2541 -- Tree_Read --
2542 ---------------
2543
2544 procedure Tree_Read is
2545 begin
2546 Tree_Read_Int (Node_Count);
2547 Nodes.Tree_Read;
2548 Flags.Tree_Read;
2549 Orig_Nodes.Tree_Read;
2550 Paren_Counts.Tree_Read;
2551 end Tree_Read;
2552
2553 ----------------
2554 -- Tree_Write --
2555 ----------------
2556
2557 procedure Tree_Write is
2558 begin
2559 Tree_Write_Int (Node_Count);
2560 Nodes.Tree_Write;
2561 Flags.Tree_Write;
2562 Orig_Nodes.Tree_Write;
2563 Paren_Counts.Tree_Write;
2564 end Tree_Write;
2565
2566 ------------------------------
2567 -- Unchecked Access Package --
2568 ------------------------------
2569
2570 package body Unchecked_Access is
2571
2572 function Field1 (N : Node_Id) return Union_Id is
2573 begin
2574 pragma Assert (N <= Nodes.Last);
2575 return Nodes.Table (N).Field1;
2576 end Field1;
2577
2578 function Field2 (N : Node_Id) return Union_Id is
2579 begin
2580 pragma Assert (N <= Nodes.Last);
2581 return Nodes.Table (N).Field2;
2582 end Field2;
2583
2584 function Field3 (N : Node_Id) return Union_Id is
2585 begin
2586 pragma Assert (N <= Nodes.Last);
2587 return Nodes.Table (N).Field3;
2588 end Field3;
2589
2590 function Field4 (N : Node_Id) return Union_Id is
2591 begin
2592 pragma Assert (N <= Nodes.Last);
2593 return Nodes.Table (N).Field4;
2594 end Field4;
2595
2596 function Field5 (N : Node_Id) return Union_Id is
2597 begin
2598 pragma Assert (N <= Nodes.Last);
2599 return Nodes.Table (N).Field5;
2600 end Field5;
2601
2602 function Field6 (N : Node_Id) return Union_Id is
2603 begin
2604 pragma Assert (Nkind (N) in N_Entity);
2605 return Nodes.Table (N + 1).Field6;
2606 end Field6;
2607
2608 function Field7 (N : Node_Id) return Union_Id is
2609 begin
2610 pragma Assert (Nkind (N) in N_Entity);
2611 return Nodes.Table (N + 1).Field7;
2612 end Field7;
2613
2614 function Field8 (N : Node_Id) return Union_Id is
2615 begin
2616 pragma Assert (Nkind (N) in N_Entity);
2617 return Nodes.Table (N + 1).Field8;
2618 end Field8;
2619
2620 function Field9 (N : Node_Id) return Union_Id is
2621 begin
2622 pragma Assert (Nkind (N) in N_Entity);
2623 return Nodes.Table (N + 1).Field9;
2624 end Field9;
2625
2626 function Field10 (N : Node_Id) return Union_Id is
2627 begin
2628 pragma Assert (Nkind (N) in N_Entity);
2629 return Nodes.Table (N + 1).Field10;
2630 end Field10;
2631
2632 function Field11 (N : Node_Id) return Union_Id is
2633 begin
2634 pragma Assert (Nkind (N) in N_Entity);
2635 return Nodes.Table (N + 1).Field11;
2636 end Field11;
2637
2638 function Field12 (N : Node_Id) return Union_Id is
2639 begin
2640 pragma Assert (Nkind (N) in N_Entity);
2641 return Nodes.Table (N + 1).Field12;
2642 end Field12;
2643
2644 function Field13 (N : Node_Id) return Union_Id is
2645 begin
2646 pragma Assert (Nkind (N) in N_Entity);
2647 return Nodes.Table (N + 2).Field6;
2648 end Field13;
2649
2650 function Field14 (N : Node_Id) return Union_Id is
2651 begin
2652 pragma Assert (Nkind (N) in N_Entity);
2653 return Nodes.Table (N + 2).Field7;
2654 end Field14;
2655
2656 function Field15 (N : Node_Id) return Union_Id is
2657 begin
2658 pragma Assert (Nkind (N) in N_Entity);
2659 return Nodes.Table (N + 2).Field8;
2660 end Field15;
2661
2662 function Field16 (N : Node_Id) return Union_Id is
2663 begin
2664 pragma Assert (Nkind (N) in N_Entity);
2665 return Nodes.Table (N + 2).Field9;
2666 end Field16;
2667
2668 function Field17 (N : Node_Id) return Union_Id is
2669 begin
2670 pragma Assert (Nkind (N) in N_Entity);
2671 return Nodes.Table (N + 2).Field10;
2672 end Field17;
2673
2674 function Field18 (N : Node_Id) return Union_Id is
2675 begin
2676 pragma Assert (Nkind (N) in N_Entity);
2677 return Nodes.Table (N + 2).Field11;
2678 end Field18;
2679
2680 function Field19 (N : Node_Id) return Union_Id is
2681 begin
2682 pragma Assert (Nkind (N) in N_Entity);
2683 return Nodes.Table (N + 3).Field6;
2684 end Field19;
2685
2686 function Field20 (N : Node_Id) return Union_Id is
2687 begin
2688 pragma Assert (Nkind (N) in N_Entity);
2689 return Nodes.Table (N + 3).Field7;
2690 end Field20;
2691
2692 function Field21 (N : Node_Id) return Union_Id is
2693 begin
2694 pragma Assert (Nkind (N) in N_Entity);
2695 return Nodes.Table (N + 3).Field8;
2696 end Field21;
2697
2698 function Field22 (N : Node_Id) return Union_Id is
2699 begin
2700 pragma Assert (Nkind (N) in N_Entity);
2701 return Nodes.Table (N + 3).Field9;
2702 end Field22;
2703
2704 function Field23 (N : Node_Id) return Union_Id is
2705 begin
2706 pragma Assert (Nkind (N) in N_Entity);
2707 return Nodes.Table (N + 3).Field10;
2708 end Field23;
2709
2710 function Field24 (N : Node_Id) return Union_Id is
2711 begin
2712 pragma Assert (Nkind (N) in N_Entity);
2713 return Nodes.Table (N + 4).Field6;
2714 end Field24;
2715
2716 function Field25 (N : Node_Id) return Union_Id is
2717 begin
2718 pragma Assert (Nkind (N) in N_Entity);
2719 return Nodes.Table (N + 4).Field7;
2720 end Field25;
2721
2722 function Field26 (N : Node_Id) return Union_Id is
2723 begin
2724 pragma Assert (Nkind (N) in N_Entity);
2725 return Nodes.Table (N + 4).Field8;
2726 end Field26;
2727
2728 function Field27 (N : Node_Id) return Union_Id is
2729 begin
2730 pragma Assert (Nkind (N) in N_Entity);
2731 return Nodes.Table (N + 4).Field9;
2732 end Field27;
2733
2734 function Field28 (N : Node_Id) return Union_Id is
2735 begin
2736 pragma Assert (Nkind (N) in N_Entity);
2737 return Nodes.Table (N + 4).Field10;
2738 end Field28;
2739
2740 function Field29 (N : Node_Id) return Union_Id is
2741 begin
2742 pragma Assert (Nkind (N) in N_Entity);
2743 return Nodes.Table (N + 4).Field11;
2744 end Field29;
2745
2746 function Field30 (N : Node_Id) return Union_Id is
2747 begin
2748 pragma Assert (Nkind (N) in N_Entity);
2749 return Nodes.Table (N + 5).Field6;
2750 end Field30;
2751
2752 function Field31 (N : Node_Id) return Union_Id is
2753 begin
2754 pragma Assert (Nkind (N) in N_Entity);
2755 return Nodes.Table (N + 5).Field7;
2756 end Field31;
2757
2758 function Field32 (N : Node_Id) return Union_Id is
2759 begin
2760 pragma Assert (Nkind (N) in N_Entity);
2761 return Nodes.Table (N + 5).Field8;
2762 end Field32;
2763
2764 function Field33 (N : Node_Id) return Union_Id is
2765 begin
2766 pragma Assert (Nkind (N) in N_Entity);
2767 return Nodes.Table (N + 5).Field9;
2768 end Field33;
2769
2770 function Field34 (N : Node_Id) return Union_Id is
2771 begin
2772 pragma Assert (Nkind (N) in N_Entity);
2773 return Nodes.Table (N + 5).Field10;
2774 end Field34;
2775
2776 function Field35 (N : Node_Id) return Union_Id is
2777 begin
2778 pragma Assert (Nkind (N) in N_Entity);
2779 return Nodes.Table (N + 5).Field11;
2780 end Field35;
2781
2782 function Field36 (N : Node_Id) return Union_Id is
2783 begin
2784 pragma Assert (Nkind (N) in N_Entity);
2785 return Nodes.Table (N + 6).Field6;
2786 end Field36;
2787
2788 function Field37 (N : Node_Id) return Union_Id is
2789 begin
2790 pragma Assert (Nkind (N) in N_Entity);
2791 return Nodes.Table (N + 6).Field7;
2792 end Field37;
2793
2794 function Field38 (N : Node_Id) return Union_Id is
2795 begin
2796 pragma Assert (Nkind (N) in N_Entity);
2797 return Nodes.Table (N + 6).Field8;
2798 end Field38;
2799
2800 function Field39 (N : Node_Id) return Union_Id is
2801 begin
2802 pragma Assert (Nkind (N) in N_Entity);
2803 return Nodes.Table (N + 6).Field9;
2804 end Field39;
2805
2806 function Field40 (N : Node_Id) return Union_Id is
2807 begin
2808 pragma Assert (Nkind (N) in N_Entity);
2809 return Nodes.Table (N + 6).Field10;
2810 end Field40;
2811
2812 function Field41 (N : Node_Id) return Union_Id is
2813 begin
2814 pragma Assert (Nkind (N) in N_Entity);
2815 return Nodes.Table (N + 6).Field11;
2816 end Field41;
2817
2818 function Node1 (N : Node_Id) return Node_Id is
2819 begin
2820 pragma Assert (N <= Nodes.Last);
2821 return Node_Id (Nodes.Table (N).Field1);
2822 end Node1;
2823
2824 function Node2 (N : Node_Id) return Node_Id is
2825 begin
2826 pragma Assert (N <= Nodes.Last);
2827 return Node_Id (Nodes.Table (N).Field2);
2828 end Node2;
2829
2830 function Node3 (N : Node_Id) return Node_Id is
2831 begin
2832 pragma Assert (N <= Nodes.Last);
2833 return Node_Id (Nodes.Table (N).Field3);
2834 end Node3;
2835
2836 function Node4 (N : Node_Id) return Node_Id is
2837 begin
2838 pragma Assert (N <= Nodes.Last);
2839 return Node_Id (Nodes.Table (N).Field4);
2840 end Node4;
2841
2842 function Node5 (N : Node_Id) return Node_Id is
2843 begin
2844 pragma Assert (N <= Nodes.Last);
2845 return Node_Id (Nodes.Table (N).Field5);
2846 end Node5;
2847
2848 function Node6 (N : Node_Id) return Node_Id is
2849 begin
2850 pragma Assert (Nkind (N) in N_Entity);
2851 return Node_Id (Nodes.Table (N + 1).Field6);
2852 end Node6;
2853
2854 function Node7 (N : Node_Id) return Node_Id is
2855 begin
2856 pragma Assert (Nkind (N) in N_Entity);
2857 return Node_Id (Nodes.Table (N + 1).Field7);
2858 end Node7;
2859
2860 function Node8 (N : Node_Id) return Node_Id is
2861 begin
2862 pragma Assert (Nkind (N) in N_Entity);
2863 return Node_Id (Nodes.Table (N + 1).Field8);
2864 end Node8;
2865
2866 function Node9 (N : Node_Id) return Node_Id is
2867 begin
2868 pragma Assert (Nkind (N) in N_Entity);
2869 return Node_Id (Nodes.Table (N + 1).Field9);
2870 end Node9;
2871
2872 function Node10 (N : Node_Id) return Node_Id is
2873 begin
2874 pragma Assert (Nkind (N) in N_Entity);
2875 return Node_Id (Nodes.Table (N + 1).Field10);
2876 end Node10;
2877
2878 function Node11 (N : Node_Id) return Node_Id is
2879 begin
2880 pragma Assert (Nkind (N) in N_Entity);
2881 return Node_Id (Nodes.Table (N + 1).Field11);
2882 end Node11;
2883
2884 function Node12 (N : Node_Id) return Node_Id is
2885 begin
2886 pragma Assert (Nkind (N) in N_Entity);
2887 return Node_Id (Nodes.Table (N + 1).Field12);
2888 end Node12;
2889
2890 function Node13 (N : Node_Id) return Node_Id is
2891 begin
2892 pragma Assert (Nkind (N) in N_Entity);
2893 return Node_Id (Nodes.Table (N + 2).Field6);
2894 end Node13;
2895
2896 function Node14 (N : Node_Id) return Node_Id is
2897 begin
2898 pragma Assert (Nkind (N) in N_Entity);
2899 return Node_Id (Nodes.Table (N + 2).Field7);
2900 end Node14;
2901
2902 function Node15 (N : Node_Id) return Node_Id is
2903 begin
2904 pragma Assert (Nkind (N) in N_Entity);
2905 return Node_Id (Nodes.Table (N + 2).Field8);
2906 end Node15;
2907
2908 function Node16 (N : Node_Id) return Node_Id is
2909 begin
2910 pragma Assert (Nkind (N) in N_Entity);
2911 return Node_Id (Nodes.Table (N + 2).Field9);
2912 end Node16;
2913
2914 function Node17 (N : Node_Id) return Node_Id is
2915 begin
2916 pragma Assert (Nkind (N) in N_Entity);
2917 return Node_Id (Nodes.Table (N + 2).Field10);
2918 end Node17;
2919
2920 function Node18 (N : Node_Id) return Node_Id is
2921 begin
2922 pragma Assert (Nkind (N) in N_Entity);
2923 return Node_Id (Nodes.Table (N + 2).Field11);
2924 end Node18;
2925
2926 function Node19 (N : Node_Id) return Node_Id is
2927 begin
2928 pragma Assert (Nkind (N) in N_Entity);
2929 return Node_Id (Nodes.Table (N + 3).Field6);
2930 end Node19;
2931
2932 function Node20 (N : Node_Id) return Node_Id is
2933 begin
2934 pragma Assert (Nkind (N) in N_Entity);
2935 return Node_Id (Nodes.Table (N + 3).Field7);
2936 end Node20;
2937
2938 function Node21 (N : Node_Id) return Node_Id is
2939 begin
2940 pragma Assert (Nkind (N) in N_Entity);
2941 return Node_Id (Nodes.Table (N + 3).Field8);
2942 end Node21;
2943
2944 function Node22 (N : Node_Id) return Node_Id is
2945 begin
2946 pragma Assert (Nkind (N) in N_Entity);
2947 return Node_Id (Nodes.Table (N + 3).Field9);
2948 end Node22;
2949
2950 function Node23 (N : Node_Id) return Node_Id is
2951 begin
2952 pragma Assert (Nkind (N) in N_Entity);
2953 return Node_Id (Nodes.Table (N + 3).Field10);
2954 end Node23;
2955
2956 function Node24 (N : Node_Id) return Node_Id is
2957 begin
2958 pragma Assert (Nkind (N) in N_Entity);
2959 return Node_Id (Nodes.Table (N + 4).Field6);
2960 end Node24;
2961
2962 function Node25 (N : Node_Id) return Node_Id is
2963 begin
2964 pragma Assert (Nkind (N) in N_Entity);
2965 return Node_Id (Nodes.Table (N + 4).Field7);
2966 end Node25;
2967
2968 function Node26 (N : Node_Id) return Node_Id is
2969 begin
2970 pragma Assert (Nkind (N) in N_Entity);
2971 return Node_Id (Nodes.Table (N + 4).Field8);
2972 end Node26;
2973
2974 function Node27 (N : Node_Id) return Node_Id is
2975 begin
2976 pragma Assert (Nkind (N) in N_Entity);
2977 return Node_Id (Nodes.Table (N + 4).Field9);
2978 end Node27;
2979
2980 function Node28 (N : Node_Id) return Node_Id is
2981 begin
2982 pragma Assert (Nkind (N) in N_Entity);
2983 return Node_Id (Nodes.Table (N + 4).Field10);
2984 end Node28;
2985
2986 function Node29 (N : Node_Id) return Node_Id is
2987 begin
2988 pragma Assert (Nkind (N) in N_Entity);
2989 return Node_Id (Nodes.Table (N + 4).Field11);
2990 end Node29;
2991
2992 function Node30 (N : Node_Id) return Node_Id is
2993 begin
2994 pragma Assert (Nkind (N) in N_Entity);
2995 return Node_Id (Nodes.Table (N + 5).Field6);
2996 end Node30;
2997
2998 function Node31 (N : Node_Id) return Node_Id is
2999 begin
3000 pragma Assert (Nkind (N) in N_Entity);
3001 return Node_Id (Nodes.Table (N + 5).Field7);
3002 end Node31;
3003
3004 function Node32 (N : Node_Id) return Node_Id is
3005 begin
3006 pragma Assert (Nkind (N) in N_Entity);
3007 return Node_Id (Nodes.Table (N + 5).Field8);
3008 end Node32;
3009
3010 function Node33 (N : Node_Id) return Node_Id is
3011 begin
3012 pragma Assert (Nkind (N) in N_Entity);
3013 return Node_Id (Nodes.Table (N + 5).Field9);
3014 end Node33;
3015
3016 function Node34 (N : Node_Id) return Node_Id is
3017 begin
3018 pragma Assert (Nkind (N) in N_Entity);
3019 return Node_Id (Nodes.Table (N + 5).Field10);
3020 end Node34;
3021
3022 function Node35 (N : Node_Id) return Node_Id is
3023 begin
3024 pragma Assert (Nkind (N) in N_Entity);
3025 return Node_Id (Nodes.Table (N + 5).Field11);
3026 end Node35;
3027
3028 function Node36 (N : Node_Id) return Node_Id is
3029 begin
3030 pragma Assert (Nkind (N) in N_Entity);
3031 return Node_Id (Nodes.Table (N + 6).Field6);
3032 end Node36;
3033
3034 function Node37 (N : Node_Id) return Node_Id is
3035 begin
3036 pragma Assert (Nkind (N) in N_Entity);
3037 return Node_Id (Nodes.Table (N + 6).Field7);
3038 end Node37;
3039
3040 function Node38 (N : Node_Id) return Node_Id is
3041 begin
3042 pragma Assert (Nkind (N) in N_Entity);
3043 return Node_Id (Nodes.Table (N + 6).Field8);
3044 end Node38;
3045
3046 function Node39 (N : Node_Id) return Node_Id is
3047 begin
3048 pragma Assert (Nkind (N) in N_Entity);
3049 return Node_Id (Nodes.Table (N + 6).Field9);
3050 end Node39;
3051
3052 function Node40 (N : Node_Id) return Node_Id is
3053 begin
3054 pragma Assert (Nkind (N) in N_Entity);
3055 return Node_Id (Nodes.Table (N + 6).Field10);
3056 end Node40;
3057
3058 function Node41 (N : Node_Id) return Node_Id is
3059 begin
3060 pragma Assert (Nkind (N) in N_Entity);
3061 return Node_Id (Nodes.Table (N + 6).Field11);
3062 end Node41;
3063
3064 function List1 (N : Node_Id) return List_Id is
3065 begin
3066 pragma Assert (N <= Nodes.Last);
3067 return List_Id (Nodes.Table (N).Field1);
3068 end List1;
3069
3070 function List2 (N : Node_Id) return List_Id is
3071 begin
3072 pragma Assert (N <= Nodes.Last);
3073 return List_Id (Nodes.Table (N).Field2);
3074 end List2;
3075
3076 function List3 (N : Node_Id) return List_Id is
3077 begin
3078 pragma Assert (N <= Nodes.Last);
3079 return List_Id (Nodes.Table (N).Field3);
3080 end List3;
3081
3082 function List4 (N : Node_Id) return List_Id is
3083 begin
3084 pragma Assert (N <= Nodes.Last);
3085 return List_Id (Nodes.Table (N).Field4);
3086 end List4;
3087
3088 function List5 (N : Node_Id) return List_Id is
3089 begin
3090 pragma Assert (N <= Nodes.Last);
3091 return List_Id (Nodes.Table (N).Field5);
3092 end List5;
3093
3094 function List10 (N : Node_Id) return List_Id is
3095 begin
3096 pragma Assert (Nkind (N) in N_Entity);
3097 return List_Id (Nodes.Table (N + 1).Field10);
3098 end List10;
3099
3100 function List14 (N : Node_Id) return List_Id is
3101 begin
3102 pragma Assert (Nkind (N) in N_Entity);
3103 return List_Id (Nodes.Table (N + 2).Field7);
3104 end List14;
3105
3106 function List25 (N : Node_Id) return List_Id is
3107 begin
3108 pragma Assert (Nkind (N) in N_Entity);
3109 return List_Id (Nodes.Table (N + 4).Field7);
3110 end List25;
3111
3112 function List38 (N : Node_Id) return List_Id is
3113 begin
3114 return List_Id (Nodes.Table (N + 6).Field8);
3115 end List38;
3116
3117 function List39 (N : Node_Id) return List_Id is
3118 begin
3119 return List_Id (Nodes.Table (N + 6).Field9);
3120 end List39;
3121
3122 function Elist1 (N : Node_Id) return Elist_Id is
3123 pragma Assert (N <= Nodes.Last);
3124 Value : constant Union_Id := Nodes.Table (N).Field1;
3125 begin
3126 if Value = 0 then
3127 return No_Elist;
3128 else
3129 return Elist_Id (Value);
3130 end if;
3131 end Elist1;
3132
3133 function Elist2 (N : Node_Id) return Elist_Id is
3134 pragma Assert (N <= Nodes.Last);
3135 Value : constant Union_Id := Nodes.Table (N).Field2;
3136 begin
3137 if Value = 0 then
3138 return No_Elist;
3139 else
3140 return Elist_Id (Value);
3141 end if;
3142 end Elist2;
3143
3144 function Elist3 (N : Node_Id) return Elist_Id is
3145 pragma Assert (N <= Nodes.Last);
3146 Value : constant Union_Id := Nodes.Table (N).Field3;
3147 begin
3148 if Value = 0 then
3149 return No_Elist;
3150 else
3151 return Elist_Id (Value);
3152 end if;
3153 end Elist3;
3154
3155 function Elist4 (N : Node_Id) return Elist_Id is
3156 pragma Assert (N <= Nodes.Last);
3157 Value : constant Union_Id := Nodes.Table (N).Field4;
3158 begin
3159 if Value = 0 then
3160 return No_Elist;
3161 else
3162 return Elist_Id (Value);
3163 end if;
3164 end Elist4;
3165
3166 function Elist5 (N : Node_Id) return Elist_Id is
3167 pragma Assert (N <= Nodes.Last);
3168 Value : constant Union_Id := Nodes.Table (N).Field5;
3169 begin
3170 if Value = 0 then
3171 return No_Elist;
3172 else
3173 return Elist_Id (Value);
3174 end if;
3175 end Elist5;
3176
3177 function Elist8 (N : Node_Id) return Elist_Id is
3178 pragma Assert (Nkind (N) in N_Entity);
3179 Value : constant Union_Id := Nodes.Table (N + 1).Field8;
3180 begin
3181 if Value = 0 then
3182 return No_Elist;
3183 else
3184 return Elist_Id (Value);
3185 end if;
3186 end Elist8;
3187
3188 function Elist9 (N : Node_Id) return Elist_Id is
3189 pragma Assert (Nkind (N) in N_Entity);
3190 Value : constant Union_Id := Nodes.Table (N + 1).Field9;
3191 begin
3192 if Value = 0 then
3193 return No_Elist;
3194 else
3195 return Elist_Id (Value);
3196 end if;
3197 end Elist9;
3198
3199 function Elist10 (N : Node_Id) return Elist_Id is
3200 pragma Assert (Nkind (N) in N_Entity);
3201 Value : constant Union_Id := Nodes.Table (N + 1).Field10;
3202 begin
3203 if Value = 0 then
3204 return No_Elist;
3205 else
3206 return Elist_Id (Value);
3207 end if;
3208 end Elist10;
3209
3210 function Elist11 (N : Node_Id) return Elist_Id is
3211 pragma Assert (Nkind (N) in N_Entity);
3212 Value : constant Union_Id := Nodes.Table (N + 1).Field11;
3213 begin
3214 if Value = 0 then
3215 return No_Elist;
3216 else
3217 return Elist_Id (Value);
3218 end if;
3219 end Elist11;
3220
3221 function Elist13 (N : Node_Id) return Elist_Id is
3222 pragma Assert (Nkind (N) in N_Entity);
3223 Value : constant Union_Id := Nodes.Table (N + 2).Field6;
3224 begin
3225 if Value = 0 then
3226 return No_Elist;
3227 else
3228 return Elist_Id (Value);
3229 end if;
3230 end Elist13;
3231
3232 function Elist15 (N : Node_Id) return Elist_Id is
3233 pragma Assert (Nkind (N) in N_Entity);
3234 Value : constant Union_Id := Nodes.Table (N + 2).Field8;
3235 begin
3236 if Value = 0 then
3237 return No_Elist;
3238 else
3239 return Elist_Id (Value);
3240 end if;
3241 end Elist15;
3242
3243 function Elist16 (N : Node_Id) return Elist_Id is
3244 pragma Assert (Nkind (N) in N_Entity);
3245 Value : constant Union_Id := Nodes.Table (N + 2).Field9;
3246 begin
3247 if Value = 0 then
3248 return No_Elist;
3249 else
3250 return Elist_Id (Value);
3251 end if;
3252 end Elist16;
3253
3254 function Elist18 (N : Node_Id) return Elist_Id is
3255 pragma Assert (Nkind (N) in N_Entity);
3256 Value : constant Union_Id := Nodes.Table (N + 2).Field11;
3257 begin
3258 if Value = 0 then
3259 return No_Elist;
3260 else
3261 return Elist_Id (Value);
3262 end if;
3263 end Elist18;
3264
3265 function Elist21 (N : Node_Id) return Elist_Id is
3266 pragma Assert (Nkind (N) in N_Entity);
3267 Value : constant Union_Id := Nodes.Table (N + 3).Field8;
3268 begin
3269 if Value = 0 then
3270 return No_Elist;
3271 else
3272 return Elist_Id (Value);
3273 end if;
3274 end Elist21;
3275
3276 function Elist23 (N : Node_Id) return Elist_Id is
3277 pragma Assert (Nkind (N) in N_Entity);
3278 Value : constant Union_Id := Nodes.Table (N + 3).Field10;
3279 begin
3280 if Value = 0 then
3281 return No_Elist;
3282 else
3283 return Elist_Id (Value);
3284 end if;
3285 end Elist23;
3286
3287 function Elist24 (N : Node_Id) return Elist_Id is
3288 pragma Assert (Nkind (N) in N_Entity);
3289 Value : constant Union_Id := Nodes.Table (N + 4).Field6;
3290 begin
3291 if Value = 0 then
3292 return No_Elist;
3293 else
3294 return Elist_Id (Value);
3295 end if;
3296 end Elist24;
3297
3298 function Elist25 (N : Node_Id) return Elist_Id is
3299 pragma Assert (Nkind (N) in N_Entity);
3300 Value : constant Union_Id := Nodes.Table (N + 4).Field7;
3301 begin
3302 if Value = 0 then
3303 return No_Elist;
3304 else
3305 return Elist_Id (Value);
3306 end if;
3307 end Elist25;
3308
3309 function Elist26 (N : Node_Id) return Elist_Id is
3310 pragma Assert (Nkind (N) in N_Entity);
3311 Value : constant Union_Id := Nodes.Table (N + 4).Field8;
3312 begin
3313 if Value = 0 then
3314 return No_Elist;
3315 else
3316 return Elist_Id (Value);
3317 end if;
3318 end Elist26;
3319
3320 function Elist29 (N : Node_Id) return Elist_Id is
3321 pragma Assert (Nkind (N) in N_Entity);
3322 Value : constant Union_Id := Nodes.Table (N + 4).Field11;
3323 begin
3324 if Value = 0 then
3325 return No_Elist;
3326 else
3327 return Elist_Id (Value);
3328 end if;
3329 end Elist29;
3330
3331 function Elist36 (N : Node_Id) return Elist_Id is
3332 pragma Assert (Nkind (N) in N_Entity);
3333 Value : constant Union_Id := Nodes.Table (N + 6).Field6;
3334 begin
3335 if Value = 0 then
3336 return No_Elist;
3337 else
3338 return Elist_Id (Value);
3339 end if;
3340 end Elist36;
3341
3342 function Name1 (N : Node_Id) return Name_Id is
3343 begin
3344 pragma Assert (N <= Nodes.Last);
3345 return Name_Id (Nodes.Table (N).Field1);
3346 end Name1;
3347
3348 function Name2 (N : Node_Id) return Name_Id is
3349 begin
3350 pragma Assert (N <= Nodes.Last);
3351 return Name_Id (Nodes.Table (N).Field2);
3352 end Name2;
3353
3354 function Str3 (N : Node_Id) return String_Id is
3355 begin
3356 pragma Assert (N <= Nodes.Last);
3357 return String_Id (Nodes.Table (N).Field3);
3358 end Str3;
3359
3360 function Uint2 (N : Node_Id) return Uint is
3361 pragma Assert (N <= Nodes.Last);
3362 U : constant Union_Id := Nodes.Table (N).Field2;
3363 begin
3364 if U = 0 then
3365 return Uint_0;
3366 else
3367 return From_Union (U);
3368 end if;
3369 end Uint2;
3370
3371 function Uint3 (N : Node_Id) return Uint is
3372 pragma Assert (N <= Nodes.Last);
3373 U : constant Union_Id := Nodes.Table (N).Field3;
3374 begin
3375 if U = 0 then
3376 return Uint_0;
3377 else
3378 return From_Union (U);
3379 end if;
3380 end Uint3;
3381
3382 function Uint4 (N : Node_Id) return Uint is
3383 pragma Assert (N <= Nodes.Last);
3384 U : constant Union_Id := Nodes.Table (N).Field4;
3385 begin
3386 if U = 0 then
3387 return Uint_0;
3388 else
3389 return From_Union (U);
3390 end if;
3391 end Uint4;
3392
3393 function Uint5 (N : Node_Id) return Uint is
3394 pragma Assert (N <= Nodes.Last);
3395 U : constant Union_Id := Nodes.Table (N).Field5;
3396 begin
3397 if U = 0 then
3398 return Uint_0;
3399 else
3400 return From_Union (U);
3401 end if;
3402 end Uint5;
3403
3404 function Uint8 (N : Node_Id) return Uint is
3405 pragma Assert (Nkind (N) in N_Entity);
3406 U : constant Union_Id := Nodes.Table (N + 1).Field8;
3407 begin
3408 if U = 0 then
3409 return Uint_0;
3410 else
3411 return From_Union (U);
3412 end if;
3413 end Uint8;
3414
3415 function Uint9 (N : Node_Id) return Uint is
3416 pragma Assert (Nkind (N) in N_Entity);
3417 U : constant Union_Id := Nodes.Table (N + 1).Field9;
3418 begin
3419 if U = 0 then
3420 return Uint_0;
3421 else
3422 return From_Union (U);
3423 end if;
3424 end Uint9;
3425
3426 function Uint10 (N : Node_Id) return Uint is
3427 pragma Assert (Nkind (N) in N_Entity);
3428 U : constant Union_Id := Nodes.Table (N + 1).Field10;
3429 begin
3430 if U = 0 then
3431 return Uint_0;
3432 else
3433 return From_Union (U);
3434 end if;
3435 end Uint10;
3436
3437 function Uint11 (N : Node_Id) return Uint is
3438 pragma Assert (Nkind (N) in N_Entity);
3439 U : constant Union_Id := Nodes.Table (N + 1).Field11;
3440 begin
3441 if U = 0 then
3442 return Uint_0;
3443 else
3444 return From_Union (U);
3445 end if;
3446 end Uint11;
3447
3448 function Uint12 (N : Node_Id) return Uint is
3449 pragma Assert (Nkind (N) in N_Entity);
3450 U : constant Union_Id := Nodes.Table (N + 1).Field12;
3451 begin
3452 if U = 0 then
3453 return Uint_0;
3454 else
3455 return From_Union (U);
3456 end if;
3457 end Uint12;
3458
3459 function Uint13 (N : Node_Id) return Uint is
3460 pragma Assert (Nkind (N) in N_Entity);
3461 U : constant Union_Id := Nodes.Table (N + 2).Field6;
3462 begin
3463 if U = 0 then
3464 return Uint_0;
3465 else
3466 return From_Union (U);
3467 end if;
3468 end Uint13;
3469
3470 function Uint14 (N : Node_Id) return Uint is
3471 pragma Assert (Nkind (N) in N_Entity);
3472 U : constant Union_Id := Nodes.Table (N + 2).Field7;
3473 begin
3474 if U = 0 then
3475 return Uint_0;
3476 else
3477 return From_Union (U);
3478 end if;
3479 end Uint14;
3480
3481 function Uint15 (N : Node_Id) return Uint is
3482 pragma Assert (Nkind (N) in N_Entity);
3483 U : constant Union_Id := Nodes.Table (N + 2).Field8;
3484 begin
3485 if U = 0 then
3486 return Uint_0;
3487 else
3488 return From_Union (U);
3489 end if;
3490 end Uint15;
3491
3492 function Uint16 (N : Node_Id) return Uint is
3493 pragma Assert (Nkind (N) in N_Entity);
3494 U : constant Union_Id := Nodes.Table (N + 2).Field9;
3495 begin
3496 if U = 0 then
3497 return Uint_0;
3498 else
3499 return From_Union (U);
3500 end if;
3501 end Uint16;
3502
3503 function Uint17 (N : Node_Id) return Uint is
3504 pragma Assert (Nkind (N) in N_Entity);
3505 U : constant Union_Id := Nodes.Table (N + 2).Field10;
3506 begin
3507 if U = 0 then
3508 return Uint_0;
3509 else
3510 return From_Union (U);
3511 end if;
3512 end Uint17;
3513
3514 function Uint22 (N : Node_Id) return Uint is
3515 pragma Assert (Nkind (N) in N_Entity);
3516 U : constant Union_Id := Nodes.Table (N + 3).Field9;
3517 begin
3518 if U = 0 then
3519 return Uint_0;
3520 else
3521 return From_Union (U);
3522 end if;
3523 end Uint22;
3524
3525 function Uint24 (N : Node_Id) return Uint is
3526 pragma Assert (Nkind (N) in N_Entity);
3527 U : constant Union_Id := Nodes.Table (N + 4).Field6;
3528 begin
3529 if U = 0 then
3530 return Uint_0;
3531 else
3532 return From_Union (U);
3533 end if;
3534 end Uint24;
3535
3536 function Ureal3 (N : Node_Id) return Ureal is
3537 begin
3538 pragma Assert (N <= Nodes.Last);
3539 return From_Union (Nodes.Table (N).Field3);
3540 end Ureal3;
3541
3542 function Ureal18 (N : Node_Id) return Ureal is
3543 begin
3544 pragma Assert (Nkind (N) in N_Entity);
3545 return From_Union (Nodes.Table (N + 2).Field11);
3546 end Ureal18;
3547
3548 function Ureal21 (N : Node_Id) return Ureal is
3549 begin
3550 pragma Assert (Nkind (N) in N_Entity);
3551 return From_Union (Nodes.Table (N + 3).Field8);
3552 end Ureal21;
3553
3554 function Flag0 (N : Node_Id) return Boolean is
3555 begin
3556 pragma Assert (N <= Nodes.Last);
3557 return Flags.Table (N).Flag0;
3558 end Flag0;
3559
3560 function Flag1 (N : Node_Id) return Boolean is
3561 begin
3562 pragma Assert (N <= Nodes.Last);
3563 return Flags.Table (N).Flag1;
3564 end Flag1;
3565
3566 function Flag2 (N : Node_Id) return Boolean is
3567 begin
3568 pragma Assert (N <= Nodes.Last);
3569 return Flags.Table (N).Flag2;
3570 end Flag2;
3571
3572 function Flag3 (N : Node_Id) return Boolean is
3573 begin
3574 pragma Assert (N <= Nodes.Last);
3575 return Flags.Table (N).Flag3;
3576 end Flag3;
3577
3578 function Flag4 (N : Node_Id) return Boolean is
3579 begin
3580 pragma Assert (N <= Nodes.Last);
3581 return Nodes.Table (N).Flag4;
3582 end Flag4;
3583
3584 function Flag5 (N : Node_Id) return Boolean is
3585 begin
3586 pragma Assert (N <= Nodes.Last);
3587 return Nodes.Table (N).Flag5;
3588 end Flag5;
3589
3590 function Flag6 (N : Node_Id) return Boolean is
3591 begin
3592 pragma Assert (N <= Nodes.Last);
3593 return Nodes.Table (N).Flag6;
3594 end Flag6;
3595
3596 function Flag7 (N : Node_Id) return Boolean is
3597 begin
3598 pragma Assert (N <= Nodes.Last);
3599 return Nodes.Table (N).Flag7;
3600 end Flag7;
3601
3602 function Flag8 (N : Node_Id) return Boolean is
3603 begin
3604 pragma Assert (N <= Nodes.Last);
3605 return Nodes.Table (N).Flag8;
3606 end Flag8;
3607
3608 function Flag9 (N : Node_Id) return Boolean is
3609 begin
3610 pragma Assert (N <= Nodes.Last);
3611 return Nodes.Table (N).Flag9;
3612 end Flag9;
3613
3614 function Flag10 (N : Node_Id) return Boolean is
3615 begin
3616 pragma Assert (N <= Nodes.Last);
3617 return Nodes.Table (N).Flag10;
3618 end Flag10;
3619
3620 function Flag11 (N : Node_Id) return Boolean is
3621 begin
3622 pragma Assert (N <= Nodes.Last);
3623 return Nodes.Table (N).Flag11;
3624 end Flag11;
3625
3626 function Flag12 (N : Node_Id) return Boolean is
3627 begin
3628 pragma Assert (N <= Nodes.Last);
3629 return Nodes.Table (N).Flag12;
3630 end Flag12;
3631
3632 function Flag13 (N : Node_Id) return Boolean is
3633 begin
3634 pragma Assert (N <= Nodes.Last);
3635 return Nodes.Table (N).Flag13;
3636 end Flag13;
3637
3638 function Flag14 (N : Node_Id) return Boolean is
3639 begin
3640 pragma Assert (N <= Nodes.Last);
3641 return Nodes.Table (N).Flag14;
3642 end Flag14;
3643
3644 function Flag15 (N : Node_Id) return Boolean is
3645 begin
3646 pragma Assert (N <= Nodes.Last);
3647 return Nodes.Table (N).Flag15;
3648 end Flag15;
3649
3650 function Flag16 (N : Node_Id) return Boolean is
3651 begin
3652 pragma Assert (N <= Nodes.Last);
3653 return Nodes.Table (N).Flag16;
3654 end Flag16;
3655
3656 function Flag17 (N : Node_Id) return Boolean is
3657 begin
3658 pragma Assert (N <= Nodes.Last);
3659 return Nodes.Table (N).Flag17;
3660 end Flag17;
3661
3662 function Flag18 (N : Node_Id) return Boolean is
3663 begin
3664 pragma Assert (N <= Nodes.Last);
3665 return Nodes.Table (N).Flag18;
3666 end Flag18;
3667
3668 function Flag19 (N : Node_Id) return Boolean is
3669 begin
3670 pragma Assert (Nkind (N) in N_Entity);
3671 return Nodes.Table (N + 1).In_List;
3672 end Flag19;
3673
3674 function Flag20 (N : Node_Id) return Boolean is
3675 begin
3676 pragma Assert (Nkind (N) in N_Entity);
3677 return Nodes.Table (N + 1).Has_Aspects;
3678 end Flag20;
3679
3680 function Flag21 (N : Node_Id) return Boolean is
3681 begin
3682 pragma Assert (Nkind (N) in N_Entity);
3683 return Nodes.Table (N + 1).Rewrite_Ins;
3684 end Flag21;
3685
3686 function Flag22 (N : Node_Id) return Boolean is
3687 begin
3688 pragma Assert (Nkind (N) in N_Entity);
3689 return Nodes.Table (N + 1).Analyzed;
3690 end Flag22;
3691
3692 function Flag23 (N : Node_Id) return Boolean is
3693 begin
3694 pragma Assert (Nkind (N) in N_Entity);
3695 return Nodes.Table (N + 1).Comes_From_Source;
3696 end Flag23;
3697
3698 function Flag24 (N : Node_Id) return Boolean is
3699 begin
3700 pragma Assert (Nkind (N) in N_Entity);
3701 return Nodes.Table (N + 1).Error_Posted;
3702 end Flag24;
3703
3704 function Flag25 (N : Node_Id) return Boolean is
3705 begin
3706 pragma Assert (Nkind (N) in N_Entity);
3707 return Nodes.Table (N + 1).Flag4;
3708 end Flag25;
3709
3710 function Flag26 (N : Node_Id) return Boolean is
3711 begin
3712 pragma Assert (Nkind (N) in N_Entity);
3713 return Nodes.Table (N + 1).Flag5;
3714 end Flag26;
3715
3716 function Flag27 (N : Node_Id) return Boolean is
3717 begin
3718 pragma Assert (Nkind (N) in N_Entity);
3719 return Nodes.Table (N + 1).Flag6;
3720 end Flag27;
3721
3722 function Flag28 (N : Node_Id) return Boolean is
3723 begin
3724 pragma Assert (Nkind (N) in N_Entity);
3725 return Nodes.Table (N + 1).Flag7;
3726 end Flag28;
3727
3728 function Flag29 (N : Node_Id) return Boolean is
3729 begin
3730 pragma Assert (Nkind (N) in N_Entity);
3731 return Nodes.Table (N + 1).Flag8;
3732 end Flag29;
3733
3734 function Flag30 (N : Node_Id) return Boolean is
3735 begin
3736 pragma Assert (Nkind (N) in N_Entity);
3737 return Nodes.Table (N + 1).Flag9;
3738 end Flag30;
3739
3740 function Flag31 (N : Node_Id) return Boolean is
3741 begin
3742 pragma Assert (Nkind (N) in N_Entity);
3743 return Nodes.Table (N + 1).Flag10;
3744 end Flag31;
3745
3746 function Flag32 (N : Node_Id) return Boolean is
3747 begin
3748 pragma Assert (Nkind (N) in N_Entity);
3749 return Nodes.Table (N + 1).Flag11;
3750 end Flag32;
3751
3752 function Flag33 (N : Node_Id) return Boolean is
3753 begin
3754 pragma Assert (Nkind (N) in N_Entity);
3755 return Nodes.Table (N + 1).Flag12;
3756 end Flag33;
3757
3758 function Flag34 (N : Node_Id) return Boolean is
3759 begin
3760 pragma Assert (Nkind (N) in N_Entity);
3761 return Nodes.Table (N + 1).Flag13;
3762 end Flag34;
3763
3764 function Flag35 (N : Node_Id) return Boolean is
3765 begin
3766 pragma Assert (Nkind (N) in N_Entity);
3767 return Nodes.Table (N + 1).Flag14;
3768 end Flag35;
3769
3770 function Flag36 (N : Node_Id) return Boolean is
3771 begin
3772 pragma Assert (Nkind (N) in N_Entity);
3773 return Nodes.Table (N + 1).Flag15;
3774 end Flag36;
3775
3776 function Flag37 (N : Node_Id) return Boolean is
3777 begin
3778 pragma Assert (Nkind (N) in N_Entity);
3779 return Nodes.Table (N + 1).Flag16;
3780 end Flag37;
3781
3782 function Flag38 (N : Node_Id) return Boolean is
3783 begin
3784 pragma Assert (Nkind (N) in N_Entity);
3785 return Nodes.Table (N + 1).Flag17;
3786 end Flag38;
3787
3788 function Flag39 (N : Node_Id) return Boolean is
3789 begin
3790 pragma Assert (Nkind (N) in N_Entity);
3791 return Nodes.Table (N + 1).Flag18;
3792 end Flag39;
3793
3794 function Flag40 (N : Node_Id) return Boolean is
3795 begin
3796 pragma Assert (Nkind (N) in N_Entity);
3797 return Nodes.Table (N + 2).In_List;
3798 end Flag40;
3799
3800 function Flag41 (N : Node_Id) return Boolean is
3801 begin
3802 pragma Assert (Nkind (N) in N_Entity);
3803 return Nodes.Table (N + 2).Has_Aspects;
3804 end Flag41;
3805
3806 function Flag42 (N : Node_Id) return Boolean is
3807 begin
3808 pragma Assert (Nkind (N) in N_Entity);
3809 return Nodes.Table (N + 2).Rewrite_Ins;
3810 end Flag42;
3811
3812 function Flag43 (N : Node_Id) return Boolean is
3813 begin
3814 pragma Assert (Nkind (N) in N_Entity);
3815 return Nodes.Table (N + 2).Analyzed;
3816 end Flag43;
3817
3818 function Flag44 (N : Node_Id) return Boolean is
3819 begin
3820 pragma Assert (Nkind (N) in N_Entity);
3821 return Nodes.Table (N + 2).Comes_From_Source;
3822 end Flag44;
3823
3824 function Flag45 (N : Node_Id) return Boolean is
3825 begin
3826 pragma Assert (Nkind (N) in N_Entity);
3827 return Nodes.Table (N + 2).Error_Posted;
3828 end Flag45;
3829
3830 function Flag46 (N : Node_Id) return Boolean is
3831 begin
3832 pragma Assert (Nkind (N) in N_Entity);
3833 return Nodes.Table (N + 2).Flag4;
3834 end Flag46;
3835
3836 function Flag47 (N : Node_Id) return Boolean is
3837 begin
3838 pragma Assert (Nkind (N) in N_Entity);
3839 return Nodes.Table (N + 2).Flag5;
3840 end Flag47;
3841
3842 function Flag48 (N : Node_Id) return Boolean is
3843 begin
3844 pragma Assert (Nkind (N) in N_Entity);
3845 return Nodes.Table (N + 2).Flag6;
3846 end Flag48;
3847
3848 function Flag49 (N : Node_Id) return Boolean is
3849 begin
3850 pragma Assert (Nkind (N) in N_Entity);
3851 return Nodes.Table (N + 2).Flag7;
3852 end Flag49;
3853
3854 function Flag50 (N : Node_Id) return Boolean is
3855 begin
3856 pragma Assert (Nkind (N) in N_Entity);
3857 return Nodes.Table (N + 2).Flag8;
3858 end Flag50;
3859
3860 function Flag51 (N : Node_Id) return Boolean is
3861 begin
3862 pragma Assert (Nkind (N) in N_Entity);
3863 return Nodes.Table (N + 2).Flag9;
3864 end Flag51;
3865
3866 function Flag52 (N : Node_Id) return Boolean is
3867 begin
3868 pragma Assert (Nkind (N) in N_Entity);
3869 return Nodes.Table (N + 2).Flag10;
3870 end Flag52;
3871
3872 function Flag53 (N : Node_Id) return Boolean is
3873 begin
3874 pragma Assert (Nkind (N) in N_Entity);
3875 return Nodes.Table (N + 2).Flag11;
3876 end Flag53;
3877
3878 function Flag54 (N : Node_Id) return Boolean is
3879 begin
3880 pragma Assert (Nkind (N) in N_Entity);
3881 return Nodes.Table (N + 2).Flag12;
3882 end Flag54;
3883
3884 function Flag55 (N : Node_Id) return Boolean is
3885 begin
3886 pragma Assert (Nkind (N) in N_Entity);
3887 return Nodes.Table (N + 2).Flag13;
3888 end Flag55;
3889
3890 function Flag56 (N : Node_Id) return Boolean is
3891 begin
3892 pragma Assert (Nkind (N) in N_Entity);
3893 return Nodes.Table (N + 2).Flag14;
3894 end Flag56;
3895
3896 function Flag57 (N : Node_Id) return Boolean is
3897 begin
3898 pragma Assert (Nkind (N) in N_Entity);
3899 return Nodes.Table (N + 2).Flag15;
3900 end Flag57;
3901
3902 function Flag58 (N : Node_Id) return Boolean is
3903 begin
3904 pragma Assert (Nkind (N) in N_Entity);
3905 return Nodes.Table (N + 2).Flag16;
3906 end Flag58;
3907
3908 function Flag59 (N : Node_Id) return Boolean is
3909 begin
3910 pragma Assert (Nkind (N) in N_Entity);
3911 return Nodes.Table (N + 2).Flag17;
3912 end Flag59;
3913
3914 function Flag60 (N : Node_Id) return Boolean is
3915 begin
3916 pragma Assert (Nkind (N) in N_Entity);
3917 return Nodes.Table (N + 2).Flag18;
3918 end Flag60;
3919
3920 function Flag61 (N : Node_Id) return Boolean is
3921 begin
3922 pragma Assert (Nkind (N) in N_Entity);
3923 return Nodes.Table (N + 1).Pflag1;
3924 end Flag61;
3925
3926 function Flag62 (N : Node_Id) return Boolean is
3927 begin
3928 pragma Assert (Nkind (N) in N_Entity);
3929 return Nodes.Table (N + 1).Pflag2;
3930 end Flag62;
3931
3932 function Flag63 (N : Node_Id) return Boolean is
3933 begin
3934 pragma Assert (Nkind (N) in N_Entity);
3935 return Nodes.Table (N + 2).Pflag1;
3936 end Flag63;
3937
3938 function Flag64 (N : Node_Id) return Boolean is
3939 begin
3940 pragma Assert (Nkind (N) in N_Entity);
3941 return Nodes.Table (N + 2).Pflag2;
3942 end Flag64;
3943
3944 function Flag65 (N : Node_Id) return Boolean is
3945 begin
3946 pragma Assert (Nkind (N) in N_Entity);
3947 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
3948 end Flag65;
3949
3950 function Flag66 (N : Node_Id) return Boolean is
3951 begin
3952 pragma Assert (Nkind (N) in N_Entity);
3953 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
3954 end Flag66;
3955
3956 function Flag67 (N : Node_Id) return Boolean is
3957 begin
3958 pragma Assert (Nkind (N) in N_Entity);
3959 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
3960 end Flag67;
3961
3962 function Flag68 (N : Node_Id) return Boolean is
3963 begin
3964 pragma Assert (Nkind (N) in N_Entity);
3965 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
3966 end Flag68;
3967
3968 function Flag69 (N : Node_Id) return Boolean is
3969 begin
3970 pragma Assert (Nkind (N) in N_Entity);
3971 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
3972 end Flag69;
3973
3974 function Flag70 (N : Node_Id) return Boolean is
3975 begin
3976 pragma Assert (Nkind (N) in N_Entity);
3977 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
3978 end Flag70;
3979
3980 function Flag71 (N : Node_Id) return Boolean is
3981 begin
3982 pragma Assert (Nkind (N) in N_Entity);
3983 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
3984 end Flag71;
3985
3986 function Flag72 (N : Node_Id) return Boolean is
3987 begin
3988 pragma Assert (Nkind (N) in N_Entity);
3989 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
3990 end Flag72;
3991
3992 function Flag73 (N : Node_Id) return Boolean is
3993 begin
3994 pragma Assert (Nkind (N) in N_Entity);
3995 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
3996 end Flag73;
3997
3998 function Flag74 (N : Node_Id) return Boolean is
3999 begin
4000 pragma Assert (Nkind (N) in N_Entity);
4001 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
4002 end Flag74;
4003
4004 function Flag75 (N : Node_Id) return Boolean is
4005 begin
4006 pragma Assert (Nkind (N) in N_Entity);
4007 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
4008 end Flag75;
4009
4010 function Flag76 (N : Node_Id) return Boolean is
4011 begin
4012 pragma Assert (Nkind (N) in N_Entity);
4013 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
4014 end Flag76;
4015
4016 function Flag77 (N : Node_Id) return Boolean is
4017 begin
4018 pragma Assert (Nkind (N) in N_Entity);
4019 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
4020 end Flag77;
4021
4022 function Flag78 (N : Node_Id) return Boolean is
4023 begin
4024 pragma Assert (Nkind (N) in N_Entity);
4025 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
4026 end Flag78;
4027
4028 function Flag79 (N : Node_Id) return Boolean is
4029 begin
4030 pragma Assert (Nkind (N) in N_Entity);
4031 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
4032 end Flag79;
4033
4034 function Flag80 (N : Node_Id) return Boolean is
4035 begin
4036 pragma Assert (Nkind (N) in N_Entity);
4037 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
4038 end Flag80;
4039
4040 function Flag81 (N : Node_Id) return Boolean is
4041 begin
4042 pragma Assert (Nkind (N) in N_Entity);
4043 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
4044 end Flag81;
4045
4046 function Flag82 (N : Node_Id) return Boolean is
4047 begin
4048 pragma Assert (Nkind (N) in N_Entity);
4049 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
4050 end Flag82;
4051
4052 function Flag83 (N : Node_Id) return Boolean is
4053 begin
4054 pragma Assert (Nkind (N) in N_Entity);
4055 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
4056 end Flag83;
4057
4058 function Flag84 (N : Node_Id) return Boolean is
4059 begin
4060 pragma Assert (Nkind (N) in N_Entity);
4061 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
4062 end Flag84;
4063
4064 function Flag85 (N : Node_Id) return Boolean is
4065 begin
4066 pragma Assert (Nkind (N) in N_Entity);
4067 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
4068 end Flag85;
4069
4070 function Flag86 (N : Node_Id) return Boolean is
4071 begin
4072 pragma Assert (Nkind (N) in N_Entity);
4073 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
4074 end Flag86;
4075
4076 function Flag87 (N : Node_Id) return Boolean is
4077 begin
4078 pragma Assert (Nkind (N) in N_Entity);
4079 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
4080 end Flag87;
4081
4082 function Flag88 (N : Node_Id) return Boolean is
4083 begin
4084 pragma Assert (Nkind (N) in N_Entity);
4085 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
4086 end Flag88;
4087
4088 function Flag89 (N : Node_Id) return Boolean is
4089 begin
4090 pragma Assert (Nkind (N) in N_Entity);
4091 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
4092 end Flag89;
4093
4094 function Flag90 (N : Node_Id) return Boolean is
4095 begin
4096 pragma Assert (Nkind (N) in N_Entity);
4097 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
4098 end Flag90;
4099
4100 function Flag91 (N : Node_Id) return Boolean is
4101 begin
4102 pragma Assert (Nkind (N) in N_Entity);
4103 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
4104 end Flag91;
4105
4106 function Flag92 (N : Node_Id) return Boolean is
4107 begin
4108 pragma Assert (Nkind (N) in N_Entity);
4109 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
4110 end Flag92;
4111
4112 function Flag93 (N : Node_Id) return Boolean is
4113 begin
4114 pragma Assert (Nkind (N) in N_Entity);
4115 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
4116 end Flag93;
4117
4118 function Flag94 (N : Node_Id) return Boolean is
4119 begin
4120 pragma Assert (Nkind (N) in N_Entity);
4121 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
4122 end Flag94;
4123
4124 function Flag95 (N : Node_Id) return Boolean is
4125 begin
4126 pragma Assert (Nkind (N) in N_Entity);
4127 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
4128 end Flag95;
4129
4130 function Flag96 (N : Node_Id) return Boolean is
4131 begin
4132 pragma Assert (Nkind (N) in N_Entity);
4133 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
4134 end Flag96;
4135
4136 function Flag97 (N : Node_Id) return Boolean is
4137 begin
4138 pragma Assert (Nkind (N) in N_Entity);
4139 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
4140 end Flag97;
4141
4142 function Flag98 (N : Node_Id) return Boolean is
4143 begin
4144 pragma Assert (Nkind (N) in N_Entity);
4145 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
4146 end Flag98;
4147
4148 function Flag99 (N : Node_Id) return Boolean is
4149 begin
4150 pragma Assert (Nkind (N) in N_Entity);
4151 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
4152 end Flag99;
4153
4154 function Flag100 (N : Node_Id) return Boolean is
4155 begin
4156 pragma Assert (Nkind (N) in N_Entity);
4157 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
4158 end Flag100;
4159
4160 function Flag101 (N : Node_Id) return Boolean is
4161 begin
4162 pragma Assert (Nkind (N) in N_Entity);
4163 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
4164 end Flag101;
4165
4166 function Flag102 (N : Node_Id) return Boolean is
4167 begin
4168 pragma Assert (Nkind (N) in N_Entity);
4169 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
4170 end Flag102;
4171
4172 function Flag103 (N : Node_Id) return Boolean is
4173 begin
4174 pragma Assert (Nkind (N) in N_Entity);
4175 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
4176 end Flag103;
4177
4178 function Flag104 (N : Node_Id) return Boolean is
4179 begin
4180 pragma Assert (Nkind (N) in N_Entity);
4181 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
4182 end Flag104;
4183
4184 function Flag105 (N : Node_Id) return Boolean is
4185 begin
4186 pragma Assert (Nkind (N) in N_Entity);
4187 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
4188 end Flag105;
4189
4190 function Flag106 (N : Node_Id) return Boolean is
4191 begin
4192 pragma Assert (Nkind (N) in N_Entity);
4193 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
4194 end Flag106;
4195
4196 function Flag107 (N : Node_Id) return Boolean is
4197 begin
4198 pragma Assert (Nkind (N) in N_Entity);
4199 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
4200 end Flag107;
4201
4202 function Flag108 (N : Node_Id) return Boolean is
4203 begin
4204 pragma Assert (Nkind (N) in N_Entity);
4205 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
4206 end Flag108;
4207
4208 function Flag109 (N : Node_Id) return Boolean is
4209 begin
4210 pragma Assert (Nkind (N) in N_Entity);
4211 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
4212 end Flag109;
4213
4214 function Flag110 (N : Node_Id) return Boolean is
4215 begin
4216 pragma Assert (Nkind (N) in N_Entity);
4217 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
4218 end Flag110;
4219
4220 function Flag111 (N : Node_Id) return Boolean is
4221 begin
4222 pragma Assert (Nkind (N) in N_Entity);
4223 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
4224 end Flag111;
4225
4226 function Flag112 (N : Node_Id) return Boolean is
4227 begin
4228 pragma Assert (Nkind (N) in N_Entity);
4229 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
4230 end Flag112;
4231
4232 function Flag113 (N : Node_Id) return Boolean is
4233 begin
4234 pragma Assert (Nkind (N) in N_Entity);
4235 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
4236 end Flag113;
4237
4238 function Flag114 (N : Node_Id) return Boolean is
4239 begin
4240 pragma Assert (Nkind (N) in N_Entity);
4241 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
4242 end Flag114;
4243
4244 function Flag115 (N : Node_Id) return Boolean is
4245 begin
4246 pragma Assert (Nkind (N) in N_Entity);
4247 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
4248 end Flag115;
4249
4250 function Flag116 (N : Node_Id) return Boolean is
4251 begin
4252 pragma Assert (Nkind (N) in N_Entity);
4253 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
4254 end Flag116;
4255
4256 function Flag117 (N : Node_Id) return Boolean is
4257 begin
4258 pragma Assert (Nkind (N) in N_Entity);
4259 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
4260 end Flag117;
4261
4262 function Flag118 (N : Node_Id) return Boolean is
4263 begin
4264 pragma Assert (Nkind (N) in N_Entity);
4265 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
4266 end Flag118;
4267
4268 function Flag119 (N : Node_Id) return Boolean is
4269 begin
4270 pragma Assert (Nkind (N) in N_Entity);
4271 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
4272 end Flag119;
4273
4274 function Flag120 (N : Node_Id) return Boolean is
4275 begin
4276 pragma Assert (Nkind (N) in N_Entity);
4277 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
4278 end Flag120;
4279
4280 function Flag121 (N : Node_Id) return Boolean is
4281 begin
4282 pragma Assert (Nkind (N) in N_Entity);
4283 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
4284 end Flag121;
4285
4286 function Flag122 (N : Node_Id) return Boolean is
4287 begin
4288 pragma Assert (Nkind (N) in N_Entity);
4289 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
4290 end Flag122;
4291
4292 function Flag123 (N : Node_Id) return Boolean is
4293 begin
4294 pragma Assert (Nkind (N) in N_Entity);
4295 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
4296 end Flag123;
4297
4298 function Flag124 (N : Node_Id) return Boolean is
4299 begin
4300 pragma Assert (Nkind (N) in N_Entity);
4301 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
4302 end Flag124;
4303
4304 function Flag125 (N : Node_Id) return Boolean is
4305 begin
4306 pragma Assert (Nkind (N) in N_Entity);
4307 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
4308 end Flag125;
4309
4310 function Flag126 (N : Node_Id) return Boolean is
4311 begin
4312 pragma Assert (Nkind (N) in N_Entity);
4313 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
4314 end Flag126;
4315
4316 function Flag127 (N : Node_Id) return Boolean is
4317 begin
4318 pragma Assert (Nkind (N) in N_Entity);
4319 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
4320 end Flag127;
4321
4322 function Flag128 (N : Node_Id) return Boolean is
4323 begin
4324 pragma Assert (Nkind (N) in N_Entity);
4325 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
4326 end Flag128;
4327
4328 function Flag129 (N : Node_Id) return Boolean is
4329 begin
4330 pragma Assert (Nkind (N) in N_Entity);
4331 return Nodes.Table (N + 3).In_List;
4332 end Flag129;
4333
4334 function Flag130 (N : Node_Id) return Boolean is
4335 begin
4336 pragma Assert (Nkind (N) in N_Entity);
4337 return Nodes.Table (N + 3).Has_Aspects;
4338 end Flag130;
4339
4340 function Flag131 (N : Node_Id) return Boolean is
4341 begin
4342 pragma Assert (Nkind (N) in N_Entity);
4343 return Nodes.Table (N + 3).Rewrite_Ins;
4344 end Flag131;
4345
4346 function Flag132 (N : Node_Id) return Boolean is
4347 begin
4348 pragma Assert (Nkind (N) in N_Entity);
4349 return Nodes.Table (N + 3).Analyzed;
4350 end Flag132;
4351
4352 function Flag133 (N : Node_Id) return Boolean is
4353 begin
4354 pragma Assert (Nkind (N) in N_Entity);
4355 return Nodes.Table (N + 3).Comes_From_Source;
4356 end Flag133;
4357
4358 function Flag134 (N : Node_Id) return Boolean is
4359 begin
4360 pragma Assert (Nkind (N) in N_Entity);
4361 return Nodes.Table (N + 3).Error_Posted;
4362 end Flag134;
4363
4364 function Flag135 (N : Node_Id) return Boolean is
4365 begin
4366 pragma Assert (Nkind (N) in N_Entity);
4367 return Nodes.Table (N + 3).Flag4;
4368 end Flag135;
4369
4370 function Flag136 (N : Node_Id) return Boolean is
4371 begin
4372 pragma Assert (Nkind (N) in N_Entity);
4373 return Nodes.Table (N + 3).Flag5;
4374 end Flag136;
4375
4376 function Flag137 (N : Node_Id) return Boolean is
4377 begin
4378 pragma Assert (Nkind (N) in N_Entity);
4379 return Nodes.Table (N + 3).Flag6;
4380 end Flag137;
4381
4382 function Flag138 (N : Node_Id) return Boolean is
4383 begin
4384 pragma Assert (Nkind (N) in N_Entity);
4385 return Nodes.Table (N + 3).Flag7;
4386 end Flag138;
4387
4388 function Flag139 (N : Node_Id) return Boolean is
4389 begin
4390 pragma Assert (Nkind (N) in N_Entity);
4391 return Nodes.Table (N + 3).Flag8;
4392 end Flag139;
4393
4394 function Flag140 (N : Node_Id) return Boolean is
4395 begin
4396 pragma Assert (Nkind (N) in N_Entity);
4397 return Nodes.Table (N + 3).Flag9;
4398 end Flag140;
4399
4400 function Flag141 (N : Node_Id) return Boolean is
4401 begin
4402 pragma Assert (Nkind (N) in N_Entity);
4403 return Nodes.Table (N + 3).Flag10;
4404 end Flag141;
4405
4406 function Flag142 (N : Node_Id) return Boolean is
4407 begin
4408 pragma Assert (Nkind (N) in N_Entity);
4409 return Nodes.Table (N + 3).Flag11;
4410 end Flag142;
4411
4412 function Flag143 (N : Node_Id) return Boolean is
4413 begin
4414 pragma Assert (Nkind (N) in N_Entity);
4415 return Nodes.Table (N + 3).Flag12;
4416 end Flag143;
4417
4418 function Flag144 (N : Node_Id) return Boolean is
4419 begin
4420 pragma Assert (Nkind (N) in N_Entity);
4421 return Nodes.Table (N + 3).Flag13;
4422 end Flag144;
4423
4424 function Flag145 (N : Node_Id) return Boolean is
4425 begin
4426 pragma Assert (Nkind (N) in N_Entity);
4427 return Nodes.Table (N + 3).Flag14;
4428 end Flag145;
4429
4430 function Flag146 (N : Node_Id) return Boolean is
4431 begin
4432 pragma Assert (Nkind (N) in N_Entity);
4433 return Nodes.Table (N + 3).Flag15;
4434 end Flag146;
4435
4436 function Flag147 (N : Node_Id) return Boolean is
4437 begin
4438 pragma Assert (Nkind (N) in N_Entity);
4439 return Nodes.Table (N + 3).Flag16;
4440 end Flag147;
4441
4442 function Flag148 (N : Node_Id) return Boolean is
4443 begin
4444 pragma Assert (Nkind (N) in N_Entity);
4445 return Nodes.Table (N + 3).Flag17;
4446 end Flag148;
4447
4448 function Flag149 (N : Node_Id) return Boolean is
4449 begin
4450 pragma Assert (Nkind (N) in N_Entity);
4451 return Nodes.Table (N + 3).Flag18;
4452 end Flag149;
4453
4454 function Flag150 (N : Node_Id) return Boolean is
4455 begin
4456 pragma Assert (Nkind (N) in N_Entity);
4457 return Nodes.Table (N + 3).Pflag1;
4458 end Flag150;
4459
4460 function Flag151 (N : Node_Id) return Boolean is
4461 begin
4462 pragma Assert (Nkind (N) in N_Entity);
4463 return Nodes.Table (N + 3).Pflag2;
4464 end Flag151;
4465
4466 function Flag152 (N : Node_Id) return Boolean is
4467 begin
4468 pragma Assert (Nkind (N) in N_Entity);
4469 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
4470 end Flag152;
4471
4472 function Flag153 (N : Node_Id) return Boolean is
4473 begin
4474 pragma Assert (Nkind (N) in N_Entity);
4475 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
4476 end Flag153;
4477
4478 function Flag154 (N : Node_Id) return Boolean is
4479 begin
4480 pragma Assert (Nkind (N) in N_Entity);
4481 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
4482 end Flag154;
4483
4484 function Flag155 (N : Node_Id) return Boolean is
4485 begin
4486 pragma Assert (Nkind (N) in N_Entity);
4487 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
4488 end Flag155;
4489
4490 function Flag156 (N : Node_Id) return Boolean is
4491 begin
4492 pragma Assert (Nkind (N) in N_Entity);
4493 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
4494 end Flag156;
4495
4496 function Flag157 (N : Node_Id) return Boolean is
4497 begin
4498 pragma Assert (Nkind (N) in N_Entity);
4499 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
4500 end Flag157;
4501
4502 function Flag158 (N : Node_Id) return Boolean is
4503 begin
4504 pragma Assert (Nkind (N) in N_Entity);
4505 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
4506 end Flag158;
4507
4508 function Flag159 (N : Node_Id) return Boolean is
4509 begin
4510 pragma Assert (Nkind (N) in N_Entity);
4511 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
4512 end Flag159;
4513
4514 function Flag160 (N : Node_Id) return Boolean is
4515 begin
4516 pragma Assert (Nkind (N) in N_Entity);
4517 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
4518 end Flag160;
4519
4520 function Flag161 (N : Node_Id) return Boolean is
4521 begin
4522 pragma Assert (Nkind (N) in N_Entity);
4523 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
4524 end Flag161;
4525
4526 function Flag162 (N : Node_Id) return Boolean is
4527 begin
4528 pragma Assert (Nkind (N) in N_Entity);
4529 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
4530 end Flag162;
4531
4532 function Flag163 (N : Node_Id) return Boolean is
4533 begin
4534 pragma Assert (Nkind (N) in N_Entity);
4535 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
4536 end Flag163;
4537
4538 function Flag164 (N : Node_Id) return Boolean is
4539 begin
4540 pragma Assert (Nkind (N) in N_Entity);
4541 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
4542 end Flag164;
4543
4544 function Flag165 (N : Node_Id) return Boolean is
4545 begin
4546 pragma Assert (Nkind (N) in N_Entity);
4547 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
4548 end Flag165;
4549
4550 function Flag166 (N : Node_Id) return Boolean is
4551 begin
4552 pragma Assert (Nkind (N) in N_Entity);
4553 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
4554 end Flag166;
4555
4556 function Flag167 (N : Node_Id) return Boolean is
4557 begin
4558 pragma Assert (Nkind (N) in N_Entity);
4559 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
4560 end Flag167;
4561
4562 function Flag168 (N : Node_Id) return Boolean is
4563 begin
4564 pragma Assert (Nkind (N) in N_Entity);
4565 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
4566 end Flag168;
4567
4568 function Flag169 (N : Node_Id) return Boolean is
4569 begin
4570 pragma Assert (Nkind (N) in N_Entity);
4571 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
4572 end Flag169;
4573
4574 function Flag170 (N : Node_Id) return Boolean is
4575 begin
4576 pragma Assert (Nkind (N) in N_Entity);
4577 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
4578 end Flag170;
4579
4580 function Flag171 (N : Node_Id) return Boolean is
4581 begin
4582 pragma Assert (Nkind (N) in N_Entity);
4583 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
4584 end Flag171;
4585
4586 function Flag172 (N : Node_Id) return Boolean is
4587 begin
4588 pragma Assert (Nkind (N) in N_Entity);
4589 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
4590 end Flag172;
4591
4592 function Flag173 (N : Node_Id) return Boolean is
4593 begin
4594 pragma Assert (Nkind (N) in N_Entity);
4595 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
4596 end Flag173;
4597
4598 function Flag174 (N : Node_Id) return Boolean is
4599 begin
4600 pragma Assert (Nkind (N) in N_Entity);
4601 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
4602 end Flag174;
4603
4604 function Flag175 (N : Node_Id) return Boolean is
4605 begin
4606 pragma Assert (Nkind (N) in N_Entity);
4607 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
4608 end Flag175;
4609
4610 function Flag176 (N : Node_Id) return Boolean is
4611 begin
4612 pragma Assert (Nkind (N) in N_Entity);
4613 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
4614 end Flag176;
4615
4616 function Flag177 (N : Node_Id) return Boolean is
4617 begin
4618 pragma Assert (Nkind (N) in N_Entity);
4619 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
4620 end Flag177;
4621
4622 function Flag178 (N : Node_Id) return Boolean is
4623 begin
4624 pragma Assert (Nkind (N) in N_Entity);
4625 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
4626 end Flag178;
4627
4628 function Flag179 (N : Node_Id) return Boolean is
4629 begin
4630 pragma Assert (Nkind (N) in N_Entity);
4631 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
4632 end Flag179;
4633
4634 function Flag180 (N : Node_Id) return Boolean is
4635 begin
4636 pragma Assert (Nkind (N) in N_Entity);
4637 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
4638 end Flag180;
4639
4640 function Flag181 (N : Node_Id) return Boolean is
4641 begin
4642 pragma Assert (Nkind (N) in N_Entity);
4643 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
4644 end Flag181;
4645
4646 function Flag182 (N : Node_Id) return Boolean is
4647 begin
4648 pragma Assert (Nkind (N) in N_Entity);
4649 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
4650 end Flag182;
4651
4652 function Flag183 (N : Node_Id) return Boolean is
4653 begin
4654 pragma Assert (Nkind (N) in N_Entity);
4655 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
4656 end Flag183;
4657
4658 function Flag184 (N : Node_Id) return Boolean is
4659 begin
4660 pragma Assert (Nkind (N) in N_Entity);
4661 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag184;
4662 end Flag184;
4663
4664 function Flag185 (N : Node_Id) return Boolean is
4665 begin
4666 pragma Assert (Nkind (N) in N_Entity);
4667 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag185;
4668 end Flag185;
4669
4670 function Flag186 (N : Node_Id) return Boolean is
4671 begin
4672 pragma Assert (Nkind (N) in N_Entity);
4673 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag186;
4674 end Flag186;
4675
4676 function Flag187 (N : Node_Id) return Boolean is
4677 begin
4678 pragma Assert (Nkind (N) in N_Entity);
4679 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag187;
4680 end Flag187;
4681
4682 function Flag188 (N : Node_Id) return Boolean is
4683 begin
4684 pragma Assert (Nkind (N) in N_Entity);
4685 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag188;
4686 end Flag188;
4687
4688 function Flag189 (N : Node_Id) return Boolean is
4689 begin
4690 pragma Assert (Nkind (N) in N_Entity);
4691 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag189;
4692 end Flag189;
4693
4694 function Flag190 (N : Node_Id) return Boolean is
4695 begin
4696 pragma Assert (Nkind (N) in N_Entity);
4697 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag190;
4698 end Flag190;
4699
4700 function Flag191 (N : Node_Id) return Boolean is
4701 begin
4702 pragma Assert (Nkind (N) in N_Entity);
4703 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag191;
4704 end Flag191;
4705
4706 function Flag192 (N : Node_Id) return Boolean is
4707 begin
4708 pragma Assert (Nkind (N) in N_Entity);
4709 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag192;
4710 end Flag192;
4711
4712 function Flag193 (N : Node_Id) return Boolean is
4713 begin
4714 pragma Assert (Nkind (N) in N_Entity);
4715 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag193;
4716 end Flag193;
4717
4718 function Flag194 (N : Node_Id) return Boolean is
4719 begin
4720 pragma Assert (Nkind (N) in N_Entity);
4721 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag194;
4722 end Flag194;
4723
4724 function Flag195 (N : Node_Id) return Boolean is
4725 begin
4726 pragma Assert (Nkind (N) in N_Entity);
4727 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag195;
4728 end Flag195;
4729
4730 function Flag196 (N : Node_Id) return Boolean is
4731 begin
4732 pragma Assert (Nkind (N) in N_Entity);
4733 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag196;
4734 end Flag196;
4735
4736 function Flag197 (N : Node_Id) return Boolean is
4737 begin
4738 pragma Assert (Nkind (N) in N_Entity);
4739 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag197;
4740 end Flag197;
4741
4742 function Flag198 (N : Node_Id) return Boolean is
4743 begin
4744 pragma Assert (Nkind (N) in N_Entity);
4745 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag198;
4746 end Flag198;
4747
4748 function Flag199 (N : Node_Id) return Boolean is
4749 begin
4750 pragma Assert (Nkind (N) in N_Entity);
4751 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag199;
4752 end Flag199;
4753
4754 function Flag200 (N : Node_Id) return Boolean is
4755 begin
4756 pragma Assert (Nkind (N) in N_Entity);
4757 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag200;
4758 end Flag200;
4759
4760 function Flag201 (N : Node_Id) return Boolean is
4761 begin
4762 pragma Assert (Nkind (N) in N_Entity);
4763 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag201;
4764 end Flag201;
4765
4766 function Flag202 (N : Node_Id) return Boolean is
4767 begin
4768 pragma Assert (Nkind (N) in N_Entity);
4769 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag202;
4770 end Flag202;
4771
4772 function Flag203 (N : Node_Id) return Boolean is
4773 begin
4774 pragma Assert (Nkind (N) in N_Entity);
4775 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag203;
4776 end Flag203;
4777
4778 function Flag204 (N : Node_Id) return Boolean is
4779 begin
4780 pragma Assert (Nkind (N) in N_Entity);
4781 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag204;
4782 end Flag204;
4783
4784 function Flag205 (N : Node_Id) return Boolean is
4785 begin
4786 pragma Assert (Nkind (N) in N_Entity);
4787 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag205;
4788 end Flag205;
4789
4790 function Flag206 (N : Node_Id) return Boolean is
4791 begin
4792 pragma Assert (Nkind (N) in N_Entity);
4793 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag206;
4794 end Flag206;
4795
4796 function Flag207 (N : Node_Id) return Boolean is
4797 begin
4798 pragma Assert (Nkind (N) in N_Entity);
4799 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag207;
4800 end Flag207;
4801
4802 function Flag208 (N : Node_Id) return Boolean is
4803 begin
4804 pragma Assert (Nkind (N) in N_Entity);
4805 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag208;
4806 end Flag208;
4807
4808 function Flag209 (N : Node_Id) return Boolean is
4809 begin
4810 pragma Assert (Nkind (N) in N_Entity);
4811 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag209;
4812 end Flag209;
4813
4814 function Flag210 (N : Node_Id) return Boolean is
4815 begin
4816 pragma Assert (Nkind (N) in N_Entity);
4817 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag210;
4818 end Flag210;
4819
4820 function Flag211 (N : Node_Id) return Boolean is
4821 begin
4822 pragma Assert (Nkind (N) in N_Entity);
4823 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag211;
4824 end Flag211;
4825
4826 function Flag212 (N : Node_Id) return Boolean is
4827 begin
4828 pragma Assert (Nkind (N) in N_Entity);
4829 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag212;
4830 end Flag212;
4831
4832 function Flag213 (N : Node_Id) return Boolean is
4833 begin
4834 pragma Assert (Nkind (N) in N_Entity);
4835 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag213;
4836 end Flag213;
4837
4838 function Flag214 (N : Node_Id) return Boolean is
4839 begin
4840 pragma Assert (Nkind (N) in N_Entity);
4841 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag214;
4842 end Flag214;
4843
4844 function Flag215 (N : Node_Id) return Boolean is
4845 begin
4846 pragma Assert (Nkind (N) in N_Entity);
4847 return To_Flag_Word4 (Nodes.Table (N + 4).Field12).Flag215;
4848 end Flag215;
4849
4850 function Flag216 (N : Node_Id) return Boolean is
4851 begin
4852 pragma Assert (Nkind (N) in N_Entity);
4853 return Nodes.Table (N + 4).In_List;
4854 end Flag216;
4855
4856 function Flag217 (N : Node_Id) return Boolean is
4857 begin
4858 pragma Assert (Nkind (N) in N_Entity);
4859 return Nodes.Table (N + 4).Has_Aspects;
4860 end Flag217;
4861
4862 function Flag218 (N : Node_Id) return Boolean is
4863 begin
4864 pragma Assert (Nkind (N) in N_Entity);
4865 return Nodes.Table (N + 4).Rewrite_Ins;
4866 end Flag218;
4867
4868 function Flag219 (N : Node_Id) return Boolean is
4869 begin
4870 pragma Assert (Nkind (N) in N_Entity);
4871 return Nodes.Table (N + 4).Analyzed;
4872 end Flag219;
4873
4874 function Flag220 (N : Node_Id) return Boolean is
4875 begin
4876 pragma Assert (Nkind (N) in N_Entity);
4877 return Nodes.Table (N + 4).Comes_From_Source;
4878 end Flag220;
4879
4880 function Flag221 (N : Node_Id) return Boolean is
4881 begin
4882 pragma Assert (Nkind (N) in N_Entity);
4883 return Nodes.Table (N + 4).Error_Posted;
4884 end Flag221;
4885
4886 function Flag222 (N : Node_Id) return Boolean is
4887 begin
4888 pragma Assert (Nkind (N) in N_Entity);
4889 return Nodes.Table (N + 4).Flag4;
4890 end Flag222;
4891
4892 function Flag223 (N : Node_Id) return Boolean is
4893 begin
4894 pragma Assert (Nkind (N) in N_Entity);
4895 return Nodes.Table (N + 4).Flag5;
4896 end Flag223;
4897
4898 function Flag224 (N : Node_Id) return Boolean is
4899 begin
4900 pragma Assert (Nkind (N) in N_Entity);
4901 return Nodes.Table (N + 4).Flag6;
4902 end Flag224;
4903
4904 function Flag225 (N : Node_Id) return Boolean is
4905 begin
4906 pragma Assert (Nkind (N) in N_Entity);
4907 return Nodes.Table (N + 4).Flag7;
4908 end Flag225;
4909
4910 function Flag226 (N : Node_Id) return Boolean is
4911 begin
4912 pragma Assert (Nkind (N) in N_Entity);
4913 return Nodes.Table (N + 4).Flag8;
4914 end Flag226;
4915
4916 function Flag227 (N : Node_Id) return Boolean is
4917 begin
4918 pragma Assert (Nkind (N) in N_Entity);
4919 return Nodes.Table (N + 4).Flag9;
4920 end Flag227;
4921
4922 function Flag228 (N : Node_Id) return Boolean is
4923 begin
4924 pragma Assert (Nkind (N) in N_Entity);
4925 return Nodes.Table (N + 4).Flag10;
4926 end Flag228;
4927
4928 function Flag229 (N : Node_Id) return Boolean is
4929 begin
4930 pragma Assert (Nkind (N) in N_Entity);
4931 return Nodes.Table (N + 4).Flag11;
4932 end Flag229;
4933
4934 function Flag230 (N : Node_Id) return Boolean is
4935 begin
4936 pragma Assert (Nkind (N) in N_Entity);
4937 return Nodes.Table (N + 4).Flag12;
4938 end Flag230;
4939
4940 function Flag231 (N : Node_Id) return Boolean is
4941 begin
4942 pragma Assert (Nkind (N) in N_Entity);
4943 return Nodes.Table (N + 4).Flag13;
4944 end Flag231;
4945
4946 function Flag232 (N : Node_Id) return Boolean is
4947 begin
4948 pragma Assert (Nkind (N) in N_Entity);
4949 return Nodes.Table (N + 4).Flag14;
4950 end Flag232;
4951
4952 function Flag233 (N : Node_Id) return Boolean is
4953 begin
4954 pragma Assert (Nkind (N) in N_Entity);
4955 return Nodes.Table (N + 4).Flag15;
4956 end Flag233;
4957
4958 function Flag234 (N : Node_Id) return Boolean is
4959 begin
4960 pragma Assert (Nkind (N) in N_Entity);
4961 return Nodes.Table (N + 4).Flag16;
4962 end Flag234;
4963
4964 function Flag235 (N : Node_Id) return Boolean is
4965 begin
4966 pragma Assert (Nkind (N) in N_Entity);
4967 return Nodes.Table (N + 4).Flag17;
4968 end Flag235;
4969
4970 function Flag236 (N : Node_Id) return Boolean is
4971 begin
4972 pragma Assert (Nkind (N) in N_Entity);
4973 return Nodes.Table (N + 4).Flag18;
4974 end Flag236;
4975
4976 function Flag237 (N : Node_Id) return Boolean is
4977 begin
4978 pragma Assert (Nkind (N) in N_Entity);
4979 return Nodes.Table (N + 4).Pflag1;
4980 end Flag237;
4981
4982 function Flag238 (N : Node_Id) return Boolean is
4983 begin
4984 pragma Assert (Nkind (N) in N_Entity);
4985 return Nodes.Table (N + 4).Pflag2;
4986 end Flag238;
4987
4988 function Flag239 (N : Node_Id) return Boolean is
4989 begin
4990 pragma Assert (Nkind (N) in N_Entity);
4991 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag239;
4992 end Flag239;
4993
4994 function Flag240 (N : Node_Id) return Boolean is
4995 begin
4996 pragma Assert (Nkind (N) in N_Entity);
4997 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag240;
4998 end Flag240;
4999
5000 function Flag241 (N : Node_Id) return Boolean is
5001 begin
5002 pragma Assert (Nkind (N) in N_Entity);
5003 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag241;
5004 end Flag241;
5005
5006 function Flag242 (N : Node_Id) return Boolean is
5007 begin
5008 pragma Assert (Nkind (N) in N_Entity);
5009 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag242;
5010 end Flag242;
5011
5012 function Flag243 (N : Node_Id) return Boolean is
5013 begin
5014 pragma Assert (Nkind (N) in N_Entity);
5015 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag243;
5016 end Flag243;
5017
5018 function Flag244 (N : Node_Id) return Boolean is
5019 begin
5020 pragma Assert (Nkind (N) in N_Entity);
5021 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag244;
5022 end Flag244;
5023
5024 function Flag245 (N : Node_Id) return Boolean is
5025 begin
5026 pragma Assert (Nkind (N) in N_Entity);
5027 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag245;
5028 end Flag245;
5029
5030 function Flag246 (N : Node_Id) return Boolean is
5031 begin
5032 pragma Assert (Nkind (N) in N_Entity);
5033 return To_Flag_Byte2 (Nodes.Table (N + 3).Nkind).Flag246;
5034 end Flag246;
5035
5036 function Flag247 (N : Node_Id) return Boolean is
5037 begin
5038 pragma Assert (Nkind (N) in N_Entity);
5039 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag247;
5040 end Flag247;
5041
5042 function Flag248 (N : Node_Id) return Boolean is
5043 begin
5044 pragma Assert (Nkind (N) in N_Entity);
5045 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag248;
5046 end Flag248;
5047
5048 function Flag249 (N : Node_Id) return Boolean is
5049 begin
5050 pragma Assert (Nkind (N) in N_Entity);
5051 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag249;
5052 end Flag249;
5053
5054 function Flag250 (N : Node_Id) return Boolean is
5055 begin
5056 pragma Assert (Nkind (N) in N_Entity);
5057 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag250;
5058 end Flag250;
5059
5060 function Flag251 (N : Node_Id) return Boolean is
5061 begin
5062 pragma Assert (Nkind (N) in N_Entity);
5063 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag251;
5064 end Flag251;
5065
5066 function Flag252 (N : Node_Id) return Boolean is
5067 begin
5068 pragma Assert (Nkind (N) in N_Entity);
5069 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag252;
5070 end Flag252;
5071
5072 function Flag253 (N : Node_Id) return Boolean is
5073 begin
5074 pragma Assert (Nkind (N) in N_Entity);
5075 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag253;
5076 end Flag253;
5077
5078 function Flag254 (N : Node_Id) return Boolean is
5079 begin
5080 pragma Assert (Nkind (N) in N_Entity);
5081 return To_Flag_Byte3 (Nodes.Table (N + 4).Nkind).Flag254;
5082 end Flag254;
5083
5084 function Flag255 (N : Node_Id) return Boolean is
5085 begin
5086 pragma Assert (Nkind (N) in N_Entity);
5087 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag255;
5088 end Flag255;
5089
5090 function Flag256 (N : Node_Id) return Boolean is
5091 begin
5092 pragma Assert (Nkind (N) in N_Entity);
5093 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag256;
5094 end Flag256;
5095
5096 function Flag257 (N : Node_Id) return Boolean is
5097 begin
5098 pragma Assert (Nkind (N) in N_Entity);
5099 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag257;
5100 end Flag257;
5101
5102 function Flag258 (N : Node_Id) return Boolean is
5103 begin
5104 pragma Assert (Nkind (N) in N_Entity);
5105 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag258;
5106 end Flag258;
5107
5108 function Flag259 (N : Node_Id) return Boolean is
5109 begin
5110 pragma Assert (Nkind (N) in N_Entity);
5111 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag259;
5112 end Flag259;
5113
5114 function Flag260 (N : Node_Id) return Boolean is
5115 begin
5116 pragma Assert (Nkind (N) in N_Entity);
5117 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag260;
5118 end Flag260;
5119
5120 function Flag261 (N : Node_Id) return Boolean is
5121 begin
5122 pragma Assert (Nkind (N) in N_Entity);
5123 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag261;
5124 end Flag261;
5125
5126 function Flag262 (N : Node_Id) return Boolean is
5127 begin
5128 pragma Assert (Nkind (N) in N_Entity);
5129 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag262;
5130 end Flag262;
5131
5132 function Flag263 (N : Node_Id) return Boolean is
5133 begin
5134 pragma Assert (Nkind (N) in N_Entity);
5135 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag263;
5136 end Flag263;
5137
5138 function Flag264 (N : Node_Id) return Boolean is
5139 begin
5140 pragma Assert (Nkind (N) in N_Entity);
5141 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag264;
5142 end Flag264;
5143
5144 function Flag265 (N : Node_Id) return Boolean is
5145 begin
5146 pragma Assert (Nkind (N) in N_Entity);
5147 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag265;
5148 end Flag265;
5149
5150 function Flag266 (N : Node_Id) return Boolean is
5151 begin
5152 pragma Assert (Nkind (N) in N_Entity);
5153 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag266;
5154 end Flag266;
5155
5156 function Flag267 (N : Node_Id) return Boolean is
5157 begin
5158 pragma Assert (Nkind (N) in N_Entity);
5159 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag267;
5160 end Flag267;
5161
5162 function Flag268 (N : Node_Id) return Boolean is
5163 begin
5164 pragma Assert (Nkind (N) in N_Entity);
5165 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag268;
5166 end Flag268;
5167
5168 function Flag269 (N : Node_Id) return Boolean is
5169 begin
5170 pragma Assert (Nkind (N) in N_Entity);
5171 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag269;
5172 end Flag269;
5173
5174 function Flag270 (N : Node_Id) return Boolean is
5175 begin
5176 pragma Assert (Nkind (N) in N_Entity);
5177 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag270;
5178 end Flag270;
5179
5180 function Flag271 (N : Node_Id) return Boolean is
5181 begin
5182 pragma Assert (Nkind (N) in N_Entity);
5183 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag271;
5184 end Flag271;
5185
5186 function Flag272 (N : Node_Id) return Boolean is
5187 begin
5188 pragma Assert (Nkind (N) in N_Entity);
5189 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag272;
5190 end Flag272;
5191
5192 function Flag273 (N : Node_Id) return Boolean is
5193 begin
5194 pragma Assert (Nkind (N) in N_Entity);
5195 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag273;
5196 end Flag273;
5197
5198 function Flag274 (N : Node_Id) return Boolean is
5199 begin
5200 pragma Assert (Nkind (N) in N_Entity);
5201 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag274;
5202 end Flag274;
5203
5204 function Flag275 (N : Node_Id) return Boolean is
5205 begin
5206 pragma Assert (Nkind (N) in N_Entity);
5207 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag275;
5208 end Flag275;
5209
5210 function Flag276 (N : Node_Id) return Boolean is
5211 begin
5212 pragma Assert (Nkind (N) in N_Entity);
5213 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag276;
5214 end Flag276;
5215
5216 function Flag277 (N : Node_Id) return Boolean is
5217 begin
5218 pragma Assert (Nkind (N) in N_Entity);
5219 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag277;
5220 end Flag277;
5221
5222 function Flag278 (N : Node_Id) return Boolean is
5223 begin
5224 pragma Assert (Nkind (N) in N_Entity);
5225 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag278;
5226 end Flag278;
5227
5228 function Flag279 (N : Node_Id) return Boolean is
5229 begin
5230 pragma Assert (Nkind (N) in N_Entity);
5231 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag279;
5232 end Flag279;
5233
5234 function Flag280 (N : Node_Id) return Boolean is
5235 begin
5236 pragma Assert (Nkind (N) in N_Entity);
5237 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag280;
5238 end Flag280;
5239
5240 function Flag281 (N : Node_Id) return Boolean is
5241 begin
5242 pragma Assert (Nkind (N) in N_Entity);
5243 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag281;
5244 end Flag281;
5245
5246 function Flag282 (N : Node_Id) return Boolean is
5247 begin
5248 pragma Assert (Nkind (N) in N_Entity);
5249 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag282;
5250 end Flag282;
5251
5252 function Flag283 (N : Node_Id) return Boolean is
5253 begin
5254 pragma Assert (Nkind (N) in N_Entity);
5255 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag283;
5256 end Flag283;
5257
5258 function Flag284 (N : Node_Id) return Boolean is
5259 begin
5260 pragma Assert (Nkind (N) in N_Entity);
5261 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag284;
5262 end Flag284;
5263
5264 function Flag285 (N : Node_Id) return Boolean is
5265 begin
5266 pragma Assert (Nkind (N) in N_Entity);
5267 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag285;
5268 end Flag285;
5269
5270 function Flag286 (N : Node_Id) return Boolean is
5271 begin
5272 pragma Assert (Nkind (N) in N_Entity);
5273 return To_Flag_Word5 (Nodes.Table (N + 5).Field12).Flag286;
5274 end Flag286;
5275
5276 function Flag287 (N : Node_Id) return Boolean is
5277 begin
5278 pragma Assert (Nkind (N) in N_Entity);
5279 return Nodes.Table (N + 5).In_List;
5280 end Flag287;
5281
5282 function Flag288 (N : Node_Id) return Boolean is
5283 begin
5284 pragma Assert (Nkind (N) in N_Entity);
5285 return Nodes.Table (N + 5).Has_Aspects;
5286 end Flag288;
5287
5288 function Flag289 (N : Node_Id) return Boolean is
5289 begin
5290 pragma Assert (Nkind (N) in N_Entity);
5291 return Nodes.Table (N + 5).Rewrite_Ins;
5292 end Flag289;
5293
5294 function Flag290 (N : Node_Id) return Boolean is
5295 begin
5296 pragma Assert (Nkind (N) in N_Entity);
5297 return Nodes.Table (N + 5).Analyzed;
5298 end Flag290;
5299
5300 function Flag291 (N : Node_Id) return Boolean is
5301 begin
5302 pragma Assert (Nkind (N) in N_Entity);
5303 return Nodes.Table (N + 5).Comes_From_Source;
5304 end Flag291;
5305
5306 function Flag292 (N : Node_Id) return Boolean is
5307 begin
5308 pragma Assert (Nkind (N) in N_Entity);
5309 return Nodes.Table (N + 5).Error_Posted;
5310 end Flag292;
5311
5312 function Flag293 (N : Node_Id) return Boolean is
5313 begin
5314 pragma Assert (Nkind (N) in N_Entity);
5315 return Nodes.Table (N + 5).Flag4;
5316 end Flag293;
5317
5318 function Flag294 (N : Node_Id) return Boolean is
5319 begin
5320 pragma Assert (Nkind (N) in N_Entity);
5321 return Nodes.Table (N + 5).Flag5;
5322 end Flag294;
5323
5324 function Flag295 (N : Node_Id) return Boolean is
5325 begin
5326 pragma Assert (Nkind (N) in N_Entity);
5327 return Nodes.Table (N + 5).Flag6;
5328 end Flag295;
5329
5330 function Flag296 (N : Node_Id) return Boolean is
5331 begin
5332 pragma Assert (Nkind (N) in N_Entity);
5333 return Nodes.Table (N + 5).Flag7;
5334 end Flag296;
5335
5336 function Flag297 (N : Node_Id) return Boolean is
5337 begin
5338 pragma Assert (Nkind (N) in N_Entity);
5339 return Nodes.Table (N + 5).Flag8;
5340 end Flag297;
5341
5342 function Flag298 (N : Node_Id) return Boolean is
5343 begin
5344 pragma Assert (Nkind (N) in N_Entity);
5345 return Nodes.Table (N + 5).Flag9;
5346 end Flag298;
5347
5348 function Flag299 (N : Node_Id) return Boolean is
5349 begin
5350 pragma Assert (Nkind (N) in N_Entity);
5351 return Nodes.Table (N + 5).Flag10;
5352 end Flag299;
5353
5354 function Flag300 (N : Node_Id) return Boolean is
5355 begin
5356 pragma Assert (Nkind (N) in N_Entity);
5357 return Nodes.Table (N + 5).Flag11;
5358 end Flag300;
5359
5360 function Flag301 (N : Node_Id) return Boolean is
5361 begin
5362 pragma Assert (Nkind (N) in N_Entity);
5363 return Nodes.Table (N + 5).Flag12;
5364 end Flag301;
5365
5366 function Flag302 (N : Node_Id) return Boolean is
5367 begin
5368 pragma Assert (Nkind (N) in N_Entity);
5369 return Nodes.Table (N + 5).Flag13;
5370 end Flag302;
5371
5372 function Flag303 (N : Node_Id) return Boolean is
5373 begin
5374 pragma Assert (Nkind (N) in N_Entity);
5375 return Nodes.Table (N + 5).Flag14;
5376 end Flag303;
5377
5378 function Flag304 (N : Node_Id) return Boolean is
5379 begin
5380 pragma Assert (Nkind (N) in N_Entity);
5381 return Nodes.Table (N + 5).Flag15;
5382 end Flag304;
5383
5384 function Flag305 (N : Node_Id) return Boolean is
5385 begin
5386 pragma Assert (Nkind (N) in N_Entity);
5387 return Nodes.Table (N + 5).Flag16;
5388 end Flag305;
5389
5390 function Flag306 (N : Node_Id) return Boolean is
5391 begin
5392 pragma Assert (Nkind (N) in N_Entity);
5393 return Nodes.Table (N + 5).Flag17;
5394 end Flag306;
5395
5396 function Flag307 (N : Node_Id) return Boolean is
5397 begin
5398 pragma Assert (Nkind (N) in N_Entity);
5399 return Nodes.Table (N + 5).Flag18;
5400 end Flag307;
5401
5402 function Flag308 (N : Node_Id) return Boolean is
5403 begin
5404 pragma Assert (Nkind (N) in N_Entity);
5405 return Nodes.Table (N + 5).Pflag1;
5406 end Flag308;
5407
5408 function Flag309 (N : Node_Id) return Boolean is
5409 begin
5410 pragma Assert (Nkind (N) in N_Entity);
5411 return Nodes.Table (N + 5).Pflag2;
5412 end Flag309;
5413
5414 function Flag310 (N : Node_Id) return Boolean is
5415 begin
5416 pragma Assert (Nkind (N) in N_Entity);
5417 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag310;
5418 end Flag310;
5419
5420 function Flag311 (N : Node_Id) return Boolean is
5421 begin
5422 pragma Assert (Nkind (N) in N_Entity);
5423 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag311;
5424 end Flag311;
5425
5426 function Flag312 (N : Node_Id) return Boolean is
5427 begin
5428 pragma Assert (Nkind (N) in N_Entity);
5429 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag312;
5430 end Flag312;
5431
5432 function Flag313 (N : Node_Id) return Boolean is
5433 begin
5434 pragma Assert (Nkind (N) in N_Entity);
5435 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag313;
5436 end Flag313;
5437
5438 function Flag314 (N : Node_Id) return Boolean is
5439 begin
5440 pragma Assert (Nkind (N) in N_Entity);
5441 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag314;
5442 end Flag314;
5443
5444 function Flag315 (N : Node_Id) return Boolean is
5445 begin
5446 pragma Assert (Nkind (N) in N_Entity);
5447 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag315;
5448 end Flag315;
5449
5450 function Flag316 (N : Node_Id) return Boolean is
5451 begin
5452 pragma Assert (Nkind (N) in N_Entity);
5453 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag316;
5454 end Flag316;
5455
5456 function Flag317 (N : Node_Id) return Boolean is
5457 begin
5458 pragma Assert (Nkind (N) in N_Entity);
5459 return To_Flag_Byte4 (Nodes.Table (N + 5).Nkind).Flag317;
5460 end Flag317;
5461
5462 procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
5463 begin
5464 pragma Assert (N <= Nodes.Last);
5465 Nodes.Table (N).Nkind := Val;
5466 end Set_Nkind;
5467
5468 procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
5469 begin
5470 pragma Assert (N <= Nodes.Last);
5471 Nodes.Table (N).Field1 := Val;
5472 end Set_Field1;
5473
5474 procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
5475 begin
5476 pragma Assert (N <= Nodes.Last);
5477 Nodes.Table (N).Field2 := Val;
5478 end Set_Field2;
5479
5480 procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
5481 begin
5482 pragma Assert (N <= Nodes.Last);
5483 Nodes.Table (N).Field3 := Val;
5484 end Set_Field3;
5485
5486 procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
5487 begin
5488 pragma Assert (N <= Nodes.Last);
5489 Nodes.Table (N).Field4 := Val;
5490 end Set_Field4;
5491
5492 procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
5493 begin
5494 pragma Assert (N <= Nodes.Last);
5495 Nodes.Table (N).Field5 := Val;
5496 end Set_Field5;
5497
5498 procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
5499 begin
5500 pragma Assert (Nkind (N) in N_Entity);
5501 Nodes.Table (N + 1).Field6 := Val;
5502 end Set_Field6;
5503
5504 procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
5505 begin
5506 pragma Assert (Nkind (N) in N_Entity);
5507 Nodes.Table (N + 1).Field7 := Val;
5508 end Set_Field7;
5509
5510 procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
5511 begin
5512 pragma Assert (Nkind (N) in N_Entity);
5513 Nodes.Table (N + 1).Field8 := Val;
5514 end Set_Field8;
5515
5516 procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
5517 begin
5518 pragma Assert (Nkind (N) in N_Entity);
5519 Nodes.Table (N + 1).Field9 := Val;
5520 end Set_Field9;
5521
5522 procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
5523 begin
5524 pragma Assert (Nkind (N) in N_Entity);
5525 Nodes.Table (N + 1).Field10 := Val;
5526 end Set_Field10;
5527
5528 procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
5529 begin
5530 pragma Assert (Nkind (N) in N_Entity);
5531 Nodes.Table (N + 1).Field11 := Val;
5532 end Set_Field11;
5533
5534 procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
5535 begin
5536 pragma Assert (Nkind (N) in N_Entity);
5537 Nodes.Table (N + 1).Field12 := Val;
5538 end Set_Field12;
5539
5540 procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
5541 begin
5542 pragma Assert (Nkind (N) in N_Entity);
5543 Nodes.Table (N + 2).Field6 := Val;
5544 end Set_Field13;
5545
5546 procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
5547 begin
5548 pragma Assert (Nkind (N) in N_Entity);
5549 Nodes.Table (N + 2).Field7 := Val;
5550 end Set_Field14;
5551
5552 procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
5553 begin
5554 pragma Assert (Nkind (N) in N_Entity);
5555 Nodes.Table (N + 2).Field8 := Val;
5556 end Set_Field15;
5557
5558 procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
5559 begin
5560 pragma Assert (Nkind (N) in N_Entity);
5561 Nodes.Table (N + 2).Field9 := Val;
5562 end Set_Field16;
5563
5564 procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
5565 begin
5566 pragma Assert (Nkind (N) in N_Entity);
5567 Nodes.Table (N + 2).Field10 := Val;
5568 end Set_Field17;
5569
5570 procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
5571 begin
5572 pragma Assert (Nkind (N) in N_Entity);
5573 Nodes.Table (N + 2).Field11 := Val;
5574 end Set_Field18;
5575
5576 procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
5577 begin
5578 pragma Assert (Nkind (N) in N_Entity);
5579 Nodes.Table (N + 3).Field6 := Val;
5580 end Set_Field19;
5581
5582 procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
5583 begin
5584 pragma Assert (Nkind (N) in N_Entity);
5585 Nodes.Table (N + 3).Field7 := Val;
5586 end Set_Field20;
5587
5588 procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
5589 begin
5590 pragma Assert (Nkind (N) in N_Entity);
5591 Nodes.Table (N + 3).Field8 := Val;
5592 end Set_Field21;
5593
5594 procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
5595 begin
5596 pragma Assert (Nkind (N) in N_Entity);
5597 Nodes.Table (N + 3).Field9 := Val;
5598 end Set_Field22;
5599
5600 procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
5601 begin
5602 pragma Assert (Nkind (N) in N_Entity);
5603 Nodes.Table (N + 3).Field10 := Val;
5604 end Set_Field23;
5605
5606 procedure Set_Field24 (N : Node_Id; Val : Union_Id) is
5607 begin
5608 pragma Assert (Nkind (N) in N_Entity);
5609 Nodes.Table (N + 4).Field6 := Val;
5610 end Set_Field24;
5611
5612 procedure Set_Field25 (N : Node_Id; Val : Union_Id) is
5613 begin
5614 pragma Assert (Nkind (N) in N_Entity);
5615 Nodes.Table (N + 4).Field7 := Val;
5616 end Set_Field25;
5617
5618 procedure Set_Field26 (N : Node_Id; Val : Union_Id) is
5619 begin
5620 pragma Assert (Nkind (N) in N_Entity);
5621 Nodes.Table (N + 4).Field8 := Val;
5622 end Set_Field26;
5623
5624 procedure Set_Field27 (N : Node_Id; Val : Union_Id) is
5625 begin
5626 pragma Assert (Nkind (N) in N_Entity);
5627 Nodes.Table (N + 4).Field9 := Val;
5628 end Set_Field27;
5629
5630 procedure Set_Field28 (N : Node_Id; Val : Union_Id) is
5631 begin
5632 pragma Assert (Nkind (N) in N_Entity);
5633 Nodes.Table (N + 4).Field10 := Val;
5634 end Set_Field28;
5635
5636 procedure Set_Field29 (N : Node_Id; Val : Union_Id) is
5637 begin
5638 pragma Assert (Nkind (N) in N_Entity);
5639 Nodes.Table (N + 4).Field11 := Val;
5640 end Set_Field29;
5641
5642 procedure Set_Field30 (N : Node_Id; Val : Union_Id) is
5643 begin
5644 pragma Assert (Nkind (N) in N_Entity);
5645 Nodes.Table (N + 5).Field6 := Val;
5646 end Set_Field30;
5647
5648 procedure Set_Field31 (N : Node_Id; Val : Union_Id) is
5649 begin
5650 pragma Assert (Nkind (N) in N_Entity);
5651 Nodes.Table (N + 5).Field7 := Val;
5652 end Set_Field31;
5653
5654 procedure Set_Field32 (N : Node_Id; Val : Union_Id) is
5655 begin
5656 pragma Assert (Nkind (N) in N_Entity);
5657 Nodes.Table (N + 5).Field8 := Val;
5658 end Set_Field32;
5659
5660 procedure Set_Field33 (N : Node_Id; Val : Union_Id) is
5661 begin
5662 pragma Assert (Nkind (N) in N_Entity);
5663 Nodes.Table (N + 5).Field9 := Val;
5664 end Set_Field33;
5665
5666 procedure Set_Field34 (N : Node_Id; Val : Union_Id) is
5667 begin
5668 pragma Assert (Nkind (N) in N_Entity);
5669 Nodes.Table (N + 5).Field10 := Val;
5670 end Set_Field34;
5671
5672 procedure Set_Field35 (N : Node_Id; Val : Union_Id) is
5673 begin
5674 pragma Assert (Nkind (N) in N_Entity);
5675 Nodes.Table (N + 5).Field11 := Val;
5676 end Set_Field35;
5677
5678 procedure Set_Field36 (N : Node_Id; Val : Union_Id) is
5679 begin
5680 pragma Assert (Nkind (N) in N_Entity);
5681 Nodes.Table (N + 6).Field6 := Val;
5682 end Set_Field36;
5683
5684 procedure Set_Field37 (N : Node_Id; Val : Union_Id) is
5685 begin
5686 pragma Assert (Nkind (N) in N_Entity);
5687 Nodes.Table (N + 6).Field7 := Val;
5688 end Set_Field37;
5689
5690 procedure Set_Field38 (N : Node_Id; Val : Union_Id) is
5691 begin
5692 pragma Assert (Nkind (N) in N_Entity);
5693 Nodes.Table (N + 6).Field8 := Val;
5694 end Set_Field38;
5695
5696 procedure Set_Field39 (N : Node_Id; Val : Union_Id) is
5697 begin
5698 pragma Assert (Nkind (N) in N_Entity);
5699 Nodes.Table (N + 6).Field9 := Val;
5700 end Set_Field39;
5701
5702 procedure Set_Field40 (N : Node_Id; Val : Union_Id) is
5703 begin
5704 pragma Assert (Nkind (N) in N_Entity);
5705 Nodes.Table (N + 6).Field10 := Val;
5706 end Set_Field40;
5707
5708 procedure Set_Field41 (N : Node_Id; Val : Union_Id) is
5709 begin
5710 pragma Assert (Nkind (N) in N_Entity);
5711 Nodes.Table (N + 6).Field11 := Val;
5712 end Set_Field41;
5713
5714 procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
5715 begin
5716 pragma Assert (N <= Nodes.Last);
5717 Nodes.Table (N).Field1 := Union_Id (Val);
5718 end Set_Node1;
5719
5720 procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
5721 begin
5722 pragma Assert (N <= Nodes.Last);
5723 Nodes.Table (N).Field2 := Union_Id (Val);
5724 end Set_Node2;
5725
5726 procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
5727 begin
5728 pragma Assert (N <= Nodes.Last);
5729 Nodes.Table (N).Field3 := Union_Id (Val);
5730 end Set_Node3;
5731
5732 procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
5733 begin
5734 pragma Assert (N <= Nodes.Last);
5735 Nodes.Table (N).Field4 := Union_Id (Val);
5736 end Set_Node4;
5737
5738 procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
5739 begin
5740 pragma Assert (N <= Nodes.Last);
5741 Nodes.Table (N).Field5 := Union_Id (Val);
5742 end Set_Node5;
5743
5744 procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
5745 begin
5746 pragma Assert (Nkind (N) in N_Entity);
5747 Nodes.Table (N + 1).Field6 := Union_Id (Val);
5748 end Set_Node6;
5749
5750 procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
5751 begin
5752 pragma Assert (Nkind (N) in N_Entity);
5753 Nodes.Table (N + 1).Field7 := Union_Id (Val);
5754 end Set_Node7;
5755
5756 procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
5757 begin
5758 pragma Assert (Nkind (N) in N_Entity);
5759 Nodes.Table (N + 1).Field8 := Union_Id (Val);
5760 end Set_Node8;
5761
5762 procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
5763 begin
5764 pragma Assert (Nkind (N) in N_Entity);
5765 Nodes.Table (N + 1).Field9 := Union_Id (Val);
5766 end Set_Node9;
5767
5768 procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
5769 begin
5770 pragma Assert (Nkind (N) in N_Entity);
5771 Nodes.Table (N + 1).Field10 := Union_Id (Val);
5772 end Set_Node10;
5773
5774 procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
5775 begin
5776 pragma Assert (Nkind (N) in N_Entity);
5777 Nodes.Table (N + 1).Field11 := Union_Id (Val);
5778 end Set_Node11;
5779
5780 procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
5781 begin
5782 pragma Assert (Nkind (N) in N_Entity);
5783 Nodes.Table (N + 1).Field12 := Union_Id (Val);
5784 end Set_Node12;
5785
5786 procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
5787 begin
5788 pragma Assert (Nkind (N) in N_Entity);
5789 Nodes.Table (N + 2).Field6 := Union_Id (Val);
5790 end Set_Node13;
5791
5792 procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
5793 begin
5794 pragma Assert (Nkind (N) in N_Entity);
5795 Nodes.Table (N + 2).Field7 := Union_Id (Val);
5796 end Set_Node14;
5797
5798 procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
5799 begin
5800 pragma Assert (Nkind (N) in N_Entity);
5801 Nodes.Table (N + 2).Field8 := Union_Id (Val);
5802 end Set_Node15;
5803
5804 procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
5805 begin
5806 pragma Assert (Nkind (N) in N_Entity);
5807 Nodes.Table (N + 2).Field9 := Union_Id (Val);
5808 end Set_Node16;
5809
5810 procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
5811 begin
5812 pragma Assert (Nkind (N) in N_Entity);
5813 Nodes.Table (N + 2).Field10 := Union_Id (Val);
5814 end Set_Node17;
5815
5816 procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
5817 begin
5818 pragma Assert (Nkind (N) in N_Entity);
5819 Nodes.Table (N + 2).Field11 := Union_Id (Val);
5820 end Set_Node18;
5821
5822 procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
5823 begin
5824 pragma Assert (Nkind (N) in N_Entity);
5825 Nodes.Table (N + 3).Field6 := Union_Id (Val);
5826 end Set_Node19;
5827
5828 procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
5829 begin
5830 pragma Assert (Nkind (N) in N_Entity);
5831 Nodes.Table (N + 3).Field7 := Union_Id (Val);
5832 end Set_Node20;
5833
5834 procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
5835 begin
5836 pragma Assert (Nkind (N) in N_Entity);
5837 Nodes.Table (N + 3).Field8 := Union_Id (Val);
5838 end Set_Node21;
5839
5840 procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
5841 begin
5842 pragma Assert (Nkind (N) in N_Entity);
5843 Nodes.Table (N + 3).Field9 := Union_Id (Val);
5844 end Set_Node22;
5845
5846 procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
5847 begin
5848 pragma Assert (Nkind (N) in N_Entity);
5849 Nodes.Table (N + 3).Field10 := Union_Id (Val);
5850 end Set_Node23;
5851
5852 procedure Set_Node24 (N : Node_Id; Val : Node_Id) is
5853 begin
5854 pragma Assert (Nkind (N) in N_Entity);
5855 Nodes.Table (N + 4).Field6 := Union_Id (Val);
5856 end Set_Node24;
5857
5858 procedure Set_Node25 (N : Node_Id; Val : Node_Id) is
5859 begin
5860 pragma Assert (Nkind (N) in N_Entity);
5861 Nodes.Table (N + 4).Field7 := Union_Id (Val);
5862 end Set_Node25;
5863
5864 procedure Set_Node26 (N : Node_Id; Val : Node_Id) is
5865 begin
5866 pragma Assert (Nkind (N) in N_Entity);
5867 Nodes.Table (N + 4).Field8 := Union_Id (Val);
5868 end Set_Node26;
5869
5870 procedure Set_Node27 (N : Node_Id; Val : Node_Id) is
5871 begin
5872 pragma Assert (Nkind (N) in N_Entity);
5873 Nodes.Table (N + 4).Field9 := Union_Id (Val);
5874 end Set_Node27;
5875
5876 procedure Set_Node28 (N : Node_Id; Val : Node_Id) is
5877 begin
5878 pragma Assert (Nkind (N) in N_Entity);
5879 Nodes.Table (N + 4).Field10 := Union_Id (Val);
5880 end Set_Node28;
5881
5882 procedure Set_Node29 (N : Node_Id; Val : Node_Id) is
5883 begin
5884 pragma Assert (Nkind (N) in N_Entity);
5885 Nodes.Table (N + 4).Field11 := Union_Id (Val);
5886 end Set_Node29;
5887
5888 procedure Set_Node30 (N : Node_Id; Val : Node_Id) is
5889 begin
5890 pragma Assert (Nkind (N) in N_Entity);
5891 Nodes.Table (N + 5).Field6 := Union_Id (Val);
5892 end Set_Node30;
5893
5894 procedure Set_Node31 (N : Node_Id; Val : Node_Id) is
5895 begin
5896 pragma Assert (Nkind (N) in N_Entity);
5897 Nodes.Table (N + 5).Field7 := Union_Id (Val);
5898 end Set_Node31;
5899
5900 procedure Set_Node32 (N : Node_Id; Val : Node_Id) is
5901 begin
5902 pragma Assert (Nkind (N) in N_Entity);
5903 Nodes.Table (N + 5).Field8 := Union_Id (Val);
5904 end Set_Node32;
5905
5906 procedure Set_Node33 (N : Node_Id; Val : Node_Id) is
5907 begin
5908 pragma Assert (Nkind (N) in N_Entity);
5909 Nodes.Table (N + 5).Field9 := Union_Id (Val);
5910 end Set_Node33;
5911
5912 procedure Set_Node34 (N : Node_Id; Val : Node_Id) is
5913 begin
5914 pragma Assert (Nkind (N) in N_Entity);
5915 Nodes.Table (N + 5).Field10 := Union_Id (Val);
5916 end Set_Node34;
5917
5918 procedure Set_Node35 (N : Node_Id; Val : Node_Id) is
5919 begin
5920 pragma Assert (Nkind (N) in N_Entity);
5921 Nodes.Table (N + 5).Field11 := Union_Id (Val);
5922 end Set_Node35;
5923
5924 procedure Set_Node36 (N : Node_Id; Val : Node_Id) is
5925 begin
5926 pragma Assert (Nkind (N) in N_Entity);
5927 Nodes.Table (N + 6).Field6 := Union_Id (Val);
5928 end Set_Node36;
5929
5930 procedure Set_Node37 (N : Node_Id; Val : Node_Id) is
5931 begin
5932 pragma Assert (Nkind (N) in N_Entity);
5933 Nodes.Table (N + 6).Field7 := Union_Id (Val);
5934 end Set_Node37;
5935
5936 procedure Set_Node38 (N : Node_Id; Val : Node_Id) is
5937 begin
5938 pragma Assert (Nkind (N) in N_Entity);
5939 Nodes.Table (N + 6).Field8 := Union_Id (Val);
5940 end Set_Node38;
5941
5942 procedure Set_Node39 (N : Node_Id; Val : Node_Id) is
5943 begin
5944 pragma Assert (Nkind (N) in N_Entity);
5945 Nodes.Table (N + 6).Field9 := Union_Id (Val);
5946 end Set_Node39;
5947
5948 procedure Set_Node40 (N : Node_Id; Val : Node_Id) is
5949 begin
5950 pragma Assert (Nkind (N) in N_Entity);
5951 Nodes.Table (N + 6).Field10 := Union_Id (Val);
5952 end Set_Node40;
5953
5954 procedure Set_Node41 (N : Node_Id; Val : Node_Id) is
5955 begin
5956 pragma Assert (Nkind (N) in N_Entity);
5957 Nodes.Table (N + 6).Field11 := Union_Id (Val);
5958 end Set_Node41;
5959
5960 procedure Set_List1 (N : Node_Id; Val : List_Id) is
5961 begin
5962 pragma Assert (N <= Nodes.Last);
5963 Nodes.Table (N).Field1 := Union_Id (Val);
5964 end Set_List1;
5965
5966 procedure Set_List2 (N : Node_Id; Val : List_Id) is
5967 begin
5968 pragma Assert (N <= Nodes.Last);
5969 Nodes.Table (N).Field2 := Union_Id (Val);
5970 end Set_List2;
5971
5972 procedure Set_List3 (N : Node_Id; Val : List_Id) is
5973 begin
5974 pragma Assert (N <= Nodes.Last);
5975 Nodes.Table (N).Field3 := Union_Id (Val);
5976 end Set_List3;
5977
5978 procedure Set_List4 (N : Node_Id; Val : List_Id) is
5979 begin
5980 pragma Assert (N <= Nodes.Last);
5981 Nodes.Table (N).Field4 := Union_Id (Val);
5982 end Set_List4;
5983
5984 procedure Set_List5 (N : Node_Id; Val : List_Id) is
5985 begin
5986 pragma Assert (N <= Nodes.Last);
5987 Nodes.Table (N).Field5 := Union_Id (Val);
5988 end Set_List5;
5989
5990 procedure Set_List10 (N : Node_Id; Val : List_Id) is
5991 begin
5992 pragma Assert (Nkind (N) in N_Entity);
5993 Nodes.Table (N + 1).Field10 := Union_Id (Val);
5994 end Set_List10;
5995
5996 procedure Set_List14 (N : Node_Id; Val : List_Id) is
5997 begin
5998 pragma Assert (Nkind (N) in N_Entity);
5999 Nodes.Table (N + 2).Field7 := Union_Id (Val);
6000 end Set_List14;
6001
6002 procedure Set_List25 (N : Node_Id; Val : List_Id) is
6003 begin
6004 pragma Assert (Nkind (N) in N_Entity);
6005 Nodes.Table (N + 4).Field7 := Union_Id (Val);
6006 end Set_List25;
6007
6008 procedure Set_List38 (N : Node_Id; Val : List_Id) is
6009 begin
6010 pragma Assert (Nkind (N) in N_Entity);
6011 Nodes.Table (N + 6).Field8 := Union_Id (Val);
6012 end Set_List38;
6013
6014 procedure Set_List39 (N : Node_Id; Val : List_Id) is
6015 begin
6016 pragma Assert (Nkind (N) in N_Entity);
6017 Nodes.Table (N + 6).Field9 := Union_Id (Val);
6018 end Set_List39;
6019
6020 procedure Set_Elist1 (N : Node_Id; Val : Elist_Id) is
6021 begin
6022 Nodes.Table (N).Field1 := Union_Id (Val);
6023 end Set_Elist1;
6024
6025 procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
6026 begin
6027 Nodes.Table (N).Field2 := Union_Id (Val);
6028 end Set_Elist2;
6029
6030 procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
6031 begin
6032 Nodes.Table (N).Field3 := Union_Id (Val);
6033 end Set_Elist3;
6034
6035 procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
6036 begin
6037 Nodes.Table (N).Field4 := Union_Id (Val);
6038 end Set_Elist4;
6039
6040 procedure Set_Elist5 (N : Node_Id; Val : Elist_Id) is
6041 begin
6042 Nodes.Table (N).Field5 := Union_Id (Val);
6043 end Set_Elist5;
6044
6045 procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
6046 begin
6047 pragma Assert (Nkind (N) in N_Entity);
6048 Nodes.Table (N + 1).Field8 := Union_Id (Val);
6049 end Set_Elist8;
6050
6051 procedure Set_Elist9 (N : Node_Id; Val : Elist_Id) is
6052 begin
6053 pragma Assert (Nkind (N) in N_Entity);
6054 Nodes.Table (N + 1).Field9 := Union_Id (Val);
6055 end Set_Elist9;
6056
6057 procedure Set_Elist10 (N : Node_Id; Val : Elist_Id) is
6058 begin
6059 pragma Assert (Nkind (N) in N_Entity);
6060 Nodes.Table (N + 1).Field10 := Union_Id (Val);
6061 end Set_Elist10;
6062
6063 procedure Set_Elist11 (N : Node_Id; Val : Elist_Id) is
6064 begin
6065 pragma Assert (Nkind (N) in N_Entity);
6066 Nodes.Table (N + 1).Field11 := Union_Id (Val);
6067 end Set_Elist11;
6068
6069 procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
6070 begin
6071 pragma Assert (Nkind (N) in N_Entity);
6072 Nodes.Table (N + 2).Field6 := Union_Id (Val);
6073 end Set_Elist13;
6074
6075 procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
6076 begin
6077 pragma Assert (Nkind (N) in N_Entity);
6078 Nodes.Table (N + 2).Field8 := Union_Id (Val);
6079 end Set_Elist15;
6080
6081 procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
6082 begin
6083 pragma Assert (Nkind (N) in N_Entity);
6084 Nodes.Table (N + 2).Field9 := Union_Id (Val);
6085 end Set_Elist16;
6086
6087 procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
6088 begin
6089 pragma Assert (Nkind (N) in N_Entity);
6090 Nodes.Table (N + 2).Field11 := Union_Id (Val);
6091 end Set_Elist18;
6092
6093 procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
6094 begin
6095 pragma Assert (Nkind (N) in N_Entity);
6096 Nodes.Table (N + 3).Field8 := Union_Id (Val);
6097 end Set_Elist21;
6098
6099 procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
6100 begin
6101 pragma Assert (Nkind (N) in N_Entity);
6102 Nodes.Table (N + 3).Field10 := Union_Id (Val);
6103 end Set_Elist23;
6104
6105 procedure Set_Elist24 (N : Node_Id; Val : Elist_Id) is
6106 begin
6107 pragma Assert (Nkind (N) in N_Entity);
6108 Nodes.Table (N + 4).Field6 := Union_Id (Val);
6109 end Set_Elist24;
6110
6111 procedure Set_Elist25 (N : Node_Id; Val : Elist_Id) is
6112 begin
6113 pragma Assert (Nkind (N) in N_Entity);
6114 Nodes.Table (N + 4).Field7 := Union_Id (Val);
6115 end Set_Elist25;
6116
6117 procedure Set_Elist26 (N : Node_Id; Val : Elist_Id) is
6118 begin
6119 pragma Assert (Nkind (N) in N_Entity);
6120 Nodes.Table (N + 4).Field8 := Union_Id (Val);
6121 end Set_Elist26;
6122
6123 procedure Set_Elist29 (N : Node_Id; Val : Elist_Id) is
6124 begin
6125 pragma Assert (Nkind (N) in N_Entity);
6126 Nodes.Table (N + 4).Field11 := Union_Id (Val);
6127 end Set_Elist29;
6128
6129 procedure Set_Elist36 (N : Node_Id; Val : Elist_Id) is
6130 begin
6131 pragma Assert (Nkind (N) in N_Entity);
6132 Nodes.Table (N + 6).Field6 := Union_Id (Val);
6133 end Set_Elist36;
6134
6135 procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
6136 begin
6137 pragma Assert (N <= Nodes.Last);
6138 Nodes.Table (N).Field1 := Union_Id (Val);
6139 end Set_Name1;
6140
6141 procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
6142 begin
6143 pragma Assert (N <= Nodes.Last);
6144 Nodes.Table (N).Field2 := Union_Id (Val);
6145 end Set_Name2;
6146
6147 procedure Set_Str3 (N : Node_Id; Val : String_Id) is
6148 begin
6149 pragma Assert (N <= Nodes.Last);
6150 Nodes.Table (N).Field3 := Union_Id (Val);
6151 end Set_Str3;
6152
6153 procedure Set_Uint2 (N : Node_Id; Val : Uint) is
6154 begin
6155 pragma Assert (N <= Nodes.Last);
6156 Nodes.Table (N).Field2 := To_Union (Val);
6157 end Set_Uint2;
6158
6159 procedure Set_Uint3 (N : Node_Id; Val : Uint) is
6160 begin
6161 pragma Assert (N <= Nodes.Last);
6162 Nodes.Table (N).Field3 := To_Union (Val);
6163 end Set_Uint3;
6164
6165 procedure Set_Uint4 (N : Node_Id; Val : Uint) is
6166 begin
6167 pragma Assert (N <= Nodes.Last);
6168 Nodes.Table (N).Field4 := To_Union (Val);
6169 end Set_Uint4;
6170
6171 procedure Set_Uint5 (N : Node_Id; Val : Uint) is
6172 begin
6173 pragma Assert (N <= Nodes.Last);
6174 Nodes.Table (N).Field5 := To_Union (Val);
6175 end Set_Uint5;
6176
6177 procedure Set_Uint8 (N : Node_Id; Val : Uint) is
6178 begin
6179 pragma Assert (Nkind (N) in N_Entity);
6180 Nodes.Table (N + 1).Field8 := To_Union (Val);
6181 end Set_Uint8;
6182
6183 procedure Set_Uint9 (N : Node_Id; Val : Uint) is
6184 begin
6185 pragma Assert (Nkind (N) in N_Entity);
6186 Nodes.Table (N + 1).Field9 := To_Union (Val);
6187 end Set_Uint9;
6188
6189 procedure Set_Uint10 (N : Node_Id; Val : Uint) is
6190 begin
6191 pragma Assert (Nkind (N) in N_Entity);
6192 Nodes.Table (N + 1).Field10 := To_Union (Val);
6193 end Set_Uint10;
6194
6195 procedure Set_Uint11 (N : Node_Id; Val : Uint) is
6196 begin
6197 pragma Assert (Nkind (N) in N_Entity);
6198 Nodes.Table (N + 1).Field11 := To_Union (Val);
6199 end Set_Uint11;
6200
6201 procedure Set_Uint12 (N : Node_Id; Val : Uint) is
6202 begin
6203 pragma Assert (Nkind (N) in N_Entity);
6204 Nodes.Table (N + 1).Field12 := To_Union (Val);
6205 end Set_Uint12;
6206
6207 procedure Set_Uint13 (N : Node_Id; Val : Uint) is
6208 begin
6209 pragma Assert (Nkind (N) in N_Entity);
6210 Nodes.Table (N + 2).Field6 := To_Union (Val);
6211 end Set_Uint13;
6212
6213 procedure Set_Uint14 (N : Node_Id; Val : Uint) is
6214 begin
6215 pragma Assert (Nkind (N) in N_Entity);
6216 Nodes.Table (N + 2).Field7 := To_Union (Val);
6217 end Set_Uint14;
6218
6219 procedure Set_Uint15 (N : Node_Id; Val : Uint) is
6220 begin
6221 pragma Assert (Nkind (N) in N_Entity);
6222 Nodes.Table (N + 2).Field8 := To_Union (Val);
6223 end Set_Uint15;
6224
6225 procedure Set_Uint16 (N : Node_Id; Val : Uint) is
6226 begin
6227 pragma Assert (Nkind (N) in N_Entity);
6228 Nodes.Table (N + 2).Field9 := To_Union (Val);
6229 end Set_Uint16;
6230
6231 procedure Set_Uint17 (N : Node_Id; Val : Uint) is
6232 begin
6233 pragma Assert (Nkind (N) in N_Entity);
6234 Nodes.Table (N + 2).Field10 := To_Union (Val);
6235 end Set_Uint17;
6236
6237 procedure Set_Uint22 (N : Node_Id; Val : Uint) is
6238 begin
6239 pragma Assert (Nkind (N) in N_Entity);
6240 Nodes.Table (N + 3).Field9 := To_Union (Val);
6241 end Set_Uint22;
6242
6243 procedure Set_Uint24 (N : Node_Id; Val : Uint) is
6244 begin
6245 pragma Assert (Nkind (N) in N_Entity);
6246 Nodes.Table (N + 4).Field6 := To_Union (Val);
6247 end Set_Uint24;
6248
6249 procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
6250 begin
6251 pragma Assert (N <= Nodes.Last);
6252 Nodes.Table (N).Field3 := To_Union (Val);
6253 end Set_Ureal3;
6254
6255 procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
6256 begin
6257 pragma Assert (Nkind (N) in N_Entity);
6258 Nodes.Table (N + 2).Field11 := To_Union (Val);
6259 end Set_Ureal18;
6260
6261 procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
6262 begin
6263 pragma Assert (Nkind (N) in N_Entity);
6264 Nodes.Table (N + 3).Field8 := To_Union (Val);
6265 end Set_Ureal21;
6266
6267 procedure Set_Flag0 (N : Node_Id; Val : Boolean) is
6268 begin
6269 pragma Assert (N <= Nodes.Last);
6270 Flags.Table (N).Flag0 := Val;
6271 end Set_Flag0;
6272
6273 procedure Set_Flag1 (N : Node_Id; Val : Boolean) is
6274 begin
6275 pragma Assert (N <= Nodes.Last);
6276 Flags.Table (N).Flag1 := Val;
6277 end Set_Flag1;
6278
6279 procedure Set_Flag2 (N : Node_Id; Val : Boolean) is
6280 begin
6281 pragma Assert (N <= Nodes.Last);
6282 Flags.Table (N).Flag2 := Val;
6283 end Set_Flag2;
6284
6285 procedure Set_Flag3 (N : Node_Id; Val : Boolean) is
6286 begin
6287 pragma Assert (N <= Nodes.Last);
6288 Flags.Table (N).Flag3 := Val;
6289 end Set_Flag3;
6290
6291 procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
6292 begin
6293 pragma Assert (N <= Nodes.Last);
6294 Nodes.Table (N).Flag4 := Val;
6295 end Set_Flag4;
6296
6297 procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
6298 begin
6299 pragma Assert (N <= Nodes.Last);
6300 Nodes.Table (N).Flag5 := Val;
6301 end Set_Flag5;
6302
6303 procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
6304 begin
6305 pragma Assert (N <= Nodes.Last);
6306 Nodes.Table (N).Flag6 := Val;
6307 end Set_Flag6;
6308
6309 procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
6310 begin
6311 pragma Assert (N <= Nodes.Last);
6312 Nodes.Table (N).Flag7 := Val;
6313 end Set_Flag7;
6314
6315 procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
6316 begin
6317 pragma Assert (N <= Nodes.Last);
6318 Nodes.Table (N).Flag8 := Val;
6319 end Set_Flag8;
6320
6321 procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
6322 begin
6323 pragma Assert (N <= Nodes.Last);
6324 Nodes.Table (N).Flag9 := Val;
6325 end Set_Flag9;
6326
6327 procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
6328 begin
6329 pragma Assert (N <= Nodes.Last);
6330 Nodes.Table (N).Flag10 := Val;
6331 end Set_Flag10;
6332
6333 procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
6334 begin
6335 pragma Assert (N <= Nodes.Last);
6336 Nodes.Table (N).Flag11 := Val;
6337 end Set_Flag11;
6338
6339 procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
6340 begin
6341 pragma Assert (N <= Nodes.Last);
6342 Nodes.Table (N).Flag12 := Val;
6343 end Set_Flag12;
6344
6345 procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
6346 begin
6347 pragma Assert (N <= Nodes.Last);
6348 Nodes.Table (N).Flag13 := Val;
6349 end Set_Flag13;
6350
6351 procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
6352 begin
6353 pragma Assert (N <= Nodes.Last);
6354 Nodes.Table (N).Flag14 := Val;
6355 end Set_Flag14;
6356
6357 procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
6358 begin
6359 pragma Assert (N <= Nodes.Last);
6360 Nodes.Table (N).Flag15 := Val;
6361 end Set_Flag15;
6362
6363 procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
6364 begin
6365 pragma Assert (N <= Nodes.Last);
6366 Nodes.Table (N).Flag16 := Val;
6367 end Set_Flag16;
6368
6369 procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
6370 begin
6371 pragma Assert (N <= Nodes.Last);
6372 Nodes.Table (N).Flag17 := Val;
6373 end Set_Flag17;
6374
6375 procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
6376 begin
6377 pragma Assert (N <= Nodes.Last);
6378 Nodes.Table (N).Flag18 := Val;
6379 end Set_Flag18;
6380
6381 procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
6382 begin
6383 pragma Assert (Nkind (N) in N_Entity);
6384 Nodes.Table (N + 1).In_List := Val;
6385 end Set_Flag19;
6386
6387 procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
6388 begin
6389 pragma Assert (Nkind (N) in N_Entity);
6390 Nodes.Table (N + 1).Has_Aspects := Val;
6391 end Set_Flag20;
6392
6393 procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
6394 begin
6395 pragma Assert (Nkind (N) in N_Entity);
6396 Nodes.Table (N + 1).Rewrite_Ins := Val;
6397 end Set_Flag21;
6398
6399 procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
6400 begin
6401 pragma Assert (Nkind (N) in N_Entity);
6402 Nodes.Table (N + 1).Analyzed := Val;
6403 end Set_Flag22;
6404
6405 procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
6406 begin
6407 pragma Assert (Nkind (N) in N_Entity);
6408 Nodes.Table (N + 1).Comes_From_Source := Val;
6409 end Set_Flag23;
6410
6411 procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
6412 begin
6413 pragma Assert (Nkind (N) in N_Entity);
6414 Nodes.Table (N + 1).Error_Posted := Val;
6415 end Set_Flag24;
6416
6417 procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
6418 begin
6419 pragma Assert (Nkind (N) in N_Entity);
6420 Nodes.Table (N + 1).Flag4 := Val;
6421 end Set_Flag25;
6422
6423 procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
6424 begin
6425 pragma Assert (Nkind (N) in N_Entity);
6426 Nodes.Table (N + 1).Flag5 := Val;
6427 end Set_Flag26;
6428
6429 procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
6430 begin
6431 pragma Assert (Nkind (N) in N_Entity);
6432 Nodes.Table (N + 1).Flag6 := Val;
6433 end Set_Flag27;
6434
6435 procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
6436 begin
6437 pragma Assert (Nkind (N) in N_Entity);
6438 Nodes.Table (N + 1).Flag7 := Val;
6439 end Set_Flag28;
6440
6441 procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
6442 begin
6443 pragma Assert (Nkind (N) in N_Entity);
6444 Nodes.Table (N + 1).Flag8 := Val;
6445 end Set_Flag29;
6446
6447 procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
6448 begin
6449 pragma Assert (Nkind (N) in N_Entity);
6450 Nodes.Table (N + 1).Flag9 := Val;
6451 end Set_Flag30;
6452
6453 procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
6454 begin
6455 pragma Assert (Nkind (N) in N_Entity);
6456 Nodes.Table (N + 1).Flag10 := Val;
6457 end Set_Flag31;
6458
6459 procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
6460 begin
6461 pragma Assert (Nkind (N) in N_Entity);
6462 Nodes.Table (N + 1).Flag11 := Val;
6463 end Set_Flag32;
6464
6465 procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
6466 begin
6467 pragma Assert (Nkind (N) in N_Entity);
6468 Nodes.Table (N + 1).Flag12 := Val;
6469 end Set_Flag33;
6470
6471 procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
6472 begin
6473 pragma Assert (Nkind (N) in N_Entity);
6474 Nodes.Table (N + 1).Flag13 := Val;
6475 end Set_Flag34;
6476
6477 procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
6478 begin
6479 pragma Assert (Nkind (N) in N_Entity);
6480 Nodes.Table (N + 1).Flag14 := Val;
6481 end Set_Flag35;
6482
6483 procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
6484 begin
6485 pragma Assert (Nkind (N) in N_Entity);
6486 Nodes.Table (N + 1).Flag15 := Val;
6487 end Set_Flag36;
6488
6489 procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
6490 begin
6491 pragma Assert (Nkind (N) in N_Entity);
6492 Nodes.Table (N + 1).Flag16 := Val;
6493 end Set_Flag37;
6494
6495 procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
6496 begin
6497 pragma Assert (Nkind (N) in N_Entity);
6498 Nodes.Table (N + 1).Flag17 := Val;
6499 end Set_Flag38;
6500
6501 procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
6502 begin
6503 pragma Assert (Nkind (N) in N_Entity);
6504 Nodes.Table (N + 1).Flag18 := Val;
6505 end Set_Flag39;
6506
6507 procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
6508 begin
6509 pragma Assert (Nkind (N) in N_Entity);
6510 Nodes.Table (N + 2).In_List := Val;
6511 end Set_Flag40;
6512
6513 procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
6514 begin
6515 pragma Assert (Nkind (N) in N_Entity);
6516 Nodes.Table (N + 2).Has_Aspects := Val;
6517 end Set_Flag41;
6518
6519 procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
6520 begin
6521 pragma Assert (Nkind (N) in N_Entity);
6522 Nodes.Table (N + 2).Rewrite_Ins := Val;
6523 end Set_Flag42;
6524
6525 procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
6526 begin
6527 pragma Assert (Nkind (N) in N_Entity);
6528 Nodes.Table (N + 2).Analyzed := Val;
6529 end Set_Flag43;
6530
6531 procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
6532 begin
6533 pragma Assert (Nkind (N) in N_Entity);
6534 Nodes.Table (N + 2).Comes_From_Source := Val;
6535 end Set_Flag44;
6536
6537 procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
6538 begin
6539 pragma Assert (Nkind (N) in N_Entity);
6540 Nodes.Table (N + 2).Error_Posted := Val;
6541 end Set_Flag45;
6542
6543 procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
6544 begin
6545 pragma Assert (Nkind (N) in N_Entity);
6546 Nodes.Table (N + 2).Flag4 := Val;
6547 end Set_Flag46;
6548
6549 procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
6550 begin
6551 pragma Assert (Nkind (N) in N_Entity);
6552 Nodes.Table (N + 2).Flag5 := Val;
6553 end Set_Flag47;
6554
6555 procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
6556 begin
6557 pragma Assert (Nkind (N) in N_Entity);
6558 Nodes.Table (N + 2).Flag6 := Val;
6559 end Set_Flag48;
6560
6561 procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
6562 begin
6563 pragma Assert (Nkind (N) in N_Entity);
6564 Nodes.Table (N + 2).Flag7 := Val;
6565 end Set_Flag49;
6566
6567 procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
6568 begin
6569 pragma Assert (Nkind (N) in N_Entity);
6570 Nodes.Table (N + 2).Flag8 := Val;
6571 end Set_Flag50;
6572
6573 procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
6574 begin
6575 pragma Assert (Nkind (N) in N_Entity);
6576 Nodes.Table (N + 2).Flag9 := Val;
6577 end Set_Flag51;
6578
6579 procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
6580 begin
6581 pragma Assert (Nkind (N) in N_Entity);
6582 Nodes.Table (N + 2).Flag10 := Val;
6583 end Set_Flag52;
6584
6585 procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
6586 begin
6587 pragma Assert (Nkind (N) in N_Entity);
6588 Nodes.Table (N + 2).Flag11 := Val;
6589 end Set_Flag53;
6590
6591 procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
6592 begin
6593 pragma Assert (Nkind (N) in N_Entity);
6594 Nodes.Table (N + 2).Flag12 := Val;
6595 end Set_Flag54;
6596
6597 procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
6598 begin
6599 pragma Assert (Nkind (N) in N_Entity);
6600 Nodes.Table (N + 2).Flag13 := Val;
6601 end Set_Flag55;
6602
6603 procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
6604 begin
6605 pragma Assert (Nkind (N) in N_Entity);
6606 Nodes.Table (N + 2).Flag14 := Val;
6607 end Set_Flag56;
6608
6609 procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
6610 begin
6611 pragma Assert (Nkind (N) in N_Entity);
6612 Nodes.Table (N + 2).Flag15 := Val;
6613 end Set_Flag57;
6614
6615 procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
6616 begin
6617 pragma Assert (Nkind (N) in N_Entity);
6618 Nodes.Table (N + 2).Flag16 := Val;
6619 end Set_Flag58;
6620
6621 procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
6622 begin
6623 pragma Assert (Nkind (N) in N_Entity);
6624 Nodes.Table (N + 2).Flag17 := Val;
6625 end Set_Flag59;
6626
6627 procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
6628 begin
6629 pragma Assert (Nkind (N) in N_Entity);
6630 Nodes.Table (N + 2).Flag18 := Val;
6631 end Set_Flag60;
6632
6633 procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
6634 begin
6635 pragma Assert (Nkind (N) in N_Entity);
6636 Nodes.Table (N + 1).Pflag1 := Val;
6637 end Set_Flag61;
6638
6639 procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
6640 begin
6641 pragma Assert (Nkind (N) in N_Entity);
6642 Nodes.Table (N + 1).Pflag2 := Val;
6643 end Set_Flag62;
6644
6645 procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
6646 begin
6647 pragma Assert (Nkind (N) in N_Entity);
6648 Nodes.Table (N + 2).Pflag1 := Val;
6649 end Set_Flag63;
6650
6651 procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
6652 begin
6653 pragma Assert (Nkind (N) in N_Entity);
6654 Nodes.Table (N + 2).Pflag2 := Val;
6655 end Set_Flag64;
6656
6657 procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
6658 begin
6659 pragma Assert (Nkind (N) in N_Entity);
6660 To_Flag_Byte_Ptr
6661 (Node_Kind_Ptr'
6662 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
6663 end Set_Flag65;
6664
6665 procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
6666 begin
6667 pragma Assert (Nkind (N) in N_Entity);
6668 To_Flag_Byte_Ptr
6669 (Node_Kind_Ptr'
6670 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
6671 end Set_Flag66;
6672
6673 procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
6674 begin
6675 pragma Assert (Nkind (N) in N_Entity);
6676 To_Flag_Byte_Ptr
6677 (Node_Kind_Ptr'
6678 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
6679 end Set_Flag67;
6680
6681 procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
6682 begin
6683 pragma Assert (Nkind (N) in N_Entity);
6684 To_Flag_Byte_Ptr
6685 (Node_Kind_Ptr'
6686 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
6687 end Set_Flag68;
6688
6689 procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
6690 begin
6691 pragma Assert (Nkind (N) in N_Entity);
6692 To_Flag_Byte_Ptr
6693 (Node_Kind_Ptr'
6694 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
6695 end Set_Flag69;
6696
6697 procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
6698 begin
6699 pragma Assert (Nkind (N) in N_Entity);
6700 To_Flag_Byte_Ptr
6701 (Node_Kind_Ptr'
6702 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
6703 end Set_Flag70;
6704
6705 procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
6706 begin
6707 pragma Assert (Nkind (N) in N_Entity);
6708 To_Flag_Byte_Ptr
6709 (Node_Kind_Ptr'
6710 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
6711 end Set_Flag71;
6712
6713 procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
6714 begin
6715 pragma Assert (Nkind (N) in N_Entity);
6716 To_Flag_Byte_Ptr
6717 (Node_Kind_Ptr'
6718 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
6719 end Set_Flag72;
6720
6721 procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
6722 begin
6723 pragma Assert (Nkind (N) in N_Entity);
6724 To_Flag_Word_Ptr
6725 (Union_Id_Ptr'
6726 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
6727 end Set_Flag73;
6728
6729 procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
6730 begin
6731 pragma Assert (Nkind (N) in N_Entity);
6732 To_Flag_Word_Ptr
6733 (Union_Id_Ptr'
6734 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
6735 end Set_Flag74;
6736
6737 procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
6738 begin
6739 pragma Assert (Nkind (N) in N_Entity);
6740 To_Flag_Word_Ptr
6741 (Union_Id_Ptr'
6742 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
6743 end Set_Flag75;
6744
6745 procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
6746 begin
6747 pragma Assert (Nkind (N) in N_Entity);
6748 To_Flag_Word_Ptr
6749 (Union_Id_Ptr'
6750 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
6751 end Set_Flag76;
6752
6753 procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
6754 begin
6755 pragma Assert (Nkind (N) in N_Entity);
6756 To_Flag_Word_Ptr
6757 (Union_Id_Ptr'
6758 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
6759 end Set_Flag77;
6760
6761 procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
6762 begin
6763 pragma Assert (Nkind (N) in N_Entity);
6764 To_Flag_Word_Ptr
6765 (Union_Id_Ptr'
6766 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
6767 end Set_Flag78;
6768
6769 procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
6770 begin
6771 pragma Assert (Nkind (N) in N_Entity);
6772 To_Flag_Word_Ptr
6773 (Union_Id_Ptr'
6774 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
6775 end Set_Flag79;
6776
6777 procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
6778 begin
6779 pragma Assert (Nkind (N) in N_Entity);
6780 To_Flag_Word_Ptr
6781 (Union_Id_Ptr'
6782 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
6783 end Set_Flag80;
6784
6785 procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
6786 begin
6787 pragma Assert (Nkind (N) in N_Entity);
6788 To_Flag_Word_Ptr
6789 (Union_Id_Ptr'
6790 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
6791 end Set_Flag81;
6792
6793 procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
6794 begin
6795 pragma Assert (Nkind (N) in N_Entity);
6796 To_Flag_Word_Ptr
6797 (Union_Id_Ptr'
6798 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
6799 end Set_Flag82;
6800
6801 procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
6802 begin
6803 pragma Assert (Nkind (N) in N_Entity);
6804 To_Flag_Word_Ptr
6805 (Union_Id_Ptr'
6806 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
6807 end Set_Flag83;
6808
6809 procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
6810 begin
6811 pragma Assert (Nkind (N) in N_Entity);
6812 To_Flag_Word_Ptr
6813 (Union_Id_Ptr'
6814 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
6815 end Set_Flag84;
6816
6817 procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
6818 begin
6819 pragma Assert (Nkind (N) in N_Entity);
6820 To_Flag_Word_Ptr
6821 (Union_Id_Ptr'
6822 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
6823 end Set_Flag85;
6824
6825 procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
6826 begin
6827 pragma Assert (Nkind (N) in N_Entity);
6828 To_Flag_Word_Ptr
6829 (Union_Id_Ptr'
6830 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
6831 end Set_Flag86;
6832
6833 procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
6834 begin
6835 pragma Assert (Nkind (N) in N_Entity);
6836 To_Flag_Word_Ptr
6837 (Union_Id_Ptr'
6838 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
6839 end Set_Flag87;
6840
6841 procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
6842 begin
6843 pragma Assert (Nkind (N) in N_Entity);
6844 To_Flag_Word_Ptr
6845 (Union_Id_Ptr'
6846 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
6847 end Set_Flag88;
6848
6849 procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
6850 begin
6851 pragma Assert (Nkind (N) in N_Entity);
6852 To_Flag_Word_Ptr
6853 (Union_Id_Ptr'
6854 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
6855 end Set_Flag89;
6856
6857 procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
6858 begin
6859 pragma Assert (Nkind (N) in N_Entity);
6860 To_Flag_Word_Ptr
6861 (Union_Id_Ptr'
6862 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
6863 end Set_Flag90;
6864
6865 procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
6866 begin
6867 pragma Assert (Nkind (N) in N_Entity);
6868 To_Flag_Word_Ptr
6869 (Union_Id_Ptr'
6870 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
6871 end Set_Flag91;
6872
6873 procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
6874 begin
6875 pragma Assert (Nkind (N) in N_Entity);
6876 To_Flag_Word_Ptr
6877 (Union_Id_Ptr'
6878 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
6879 end Set_Flag92;
6880
6881 procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
6882 begin
6883 pragma Assert (Nkind (N) in N_Entity);
6884 To_Flag_Word_Ptr
6885 (Union_Id_Ptr'
6886 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
6887 end Set_Flag93;
6888
6889 procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
6890 begin
6891 pragma Assert (Nkind (N) in N_Entity);
6892 To_Flag_Word_Ptr
6893 (Union_Id_Ptr'
6894 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
6895 end Set_Flag94;
6896
6897 procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
6898 begin
6899 pragma Assert (Nkind (N) in N_Entity);
6900 To_Flag_Word_Ptr
6901 (Union_Id_Ptr'
6902 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
6903 end Set_Flag95;
6904
6905 procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
6906 begin
6907 pragma Assert (Nkind (N) in N_Entity);
6908 To_Flag_Word_Ptr
6909 (Union_Id_Ptr'
6910 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
6911 end Set_Flag96;
6912
6913 procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
6914 begin
6915 pragma Assert (Nkind (N) in N_Entity);
6916 To_Flag_Word2_Ptr
6917 (Union_Id_Ptr'
6918 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
6919 end Set_Flag97;
6920
6921 procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
6922 begin
6923 pragma Assert (Nkind (N) in N_Entity);
6924 To_Flag_Word2_Ptr
6925 (Union_Id_Ptr'
6926 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
6927 end Set_Flag98;
6928
6929 procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
6930 begin
6931 pragma Assert (Nkind (N) in N_Entity);
6932 To_Flag_Word2_Ptr
6933 (Union_Id_Ptr'
6934 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
6935 end Set_Flag99;
6936
6937 procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
6938 begin
6939 pragma Assert (Nkind (N) in N_Entity);
6940 To_Flag_Word2_Ptr
6941 (Union_Id_Ptr'
6942 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
6943 end Set_Flag100;
6944
6945 procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
6946 begin
6947 pragma Assert (Nkind (N) in N_Entity);
6948 To_Flag_Word2_Ptr
6949 (Union_Id_Ptr'
6950 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
6951 end Set_Flag101;
6952
6953 procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
6954 begin
6955 pragma Assert (Nkind (N) in N_Entity);
6956 To_Flag_Word2_Ptr
6957 (Union_Id_Ptr'
6958 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
6959 end Set_Flag102;
6960
6961 procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
6962 begin
6963 pragma Assert (Nkind (N) in N_Entity);
6964 To_Flag_Word2_Ptr
6965 (Union_Id_Ptr'
6966 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
6967 end Set_Flag103;
6968
6969 procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
6970 begin
6971 pragma Assert (Nkind (N) in N_Entity);
6972 To_Flag_Word2_Ptr
6973 (Union_Id_Ptr'
6974 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
6975 end Set_Flag104;
6976
6977 procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
6978 begin
6979 pragma Assert (Nkind (N) in N_Entity);
6980 To_Flag_Word2_Ptr
6981 (Union_Id_Ptr'
6982 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
6983 end Set_Flag105;
6984
6985 procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
6986 begin
6987 pragma Assert (Nkind (N) in N_Entity);
6988 To_Flag_Word2_Ptr
6989 (Union_Id_Ptr'
6990 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
6991 end Set_Flag106;
6992
6993 procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
6994 begin
6995 pragma Assert (Nkind (N) in N_Entity);
6996 To_Flag_Word2_Ptr
6997 (Union_Id_Ptr'
6998 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
6999 end Set_Flag107;
7000
7001 procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
7002 begin
7003 pragma Assert (Nkind (N) in N_Entity);
7004 To_Flag_Word2_Ptr
7005 (Union_Id_Ptr'
7006 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
7007 end Set_Flag108;
7008
7009 procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
7010 begin
7011 pragma Assert (Nkind (N) in N_Entity);
7012 To_Flag_Word2_Ptr
7013 (Union_Id_Ptr'
7014 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
7015 end Set_Flag109;
7016
7017 procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
7018 begin
7019 pragma Assert (Nkind (N) in N_Entity);
7020 To_Flag_Word2_Ptr
7021 (Union_Id_Ptr'
7022 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
7023 end Set_Flag110;
7024
7025 procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
7026 begin
7027 pragma Assert (Nkind (N) in N_Entity);
7028 To_Flag_Word2_Ptr
7029 (Union_Id_Ptr'
7030 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
7031 end Set_Flag111;
7032
7033 procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
7034 begin
7035 pragma Assert (Nkind (N) in N_Entity);
7036 To_Flag_Word2_Ptr
7037 (Union_Id_Ptr'
7038 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
7039 end Set_Flag112;
7040
7041 procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
7042 begin
7043 pragma Assert (Nkind (N) in N_Entity);
7044 To_Flag_Word2_Ptr
7045 (Union_Id_Ptr'
7046 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
7047 end Set_Flag113;
7048
7049 procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
7050 begin
7051 pragma Assert (Nkind (N) in N_Entity);
7052 To_Flag_Word2_Ptr
7053 (Union_Id_Ptr'
7054 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
7055 end Set_Flag114;
7056
7057 procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
7058 begin
7059 pragma Assert (Nkind (N) in N_Entity);
7060 To_Flag_Word2_Ptr
7061 (Union_Id_Ptr'
7062 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
7063 end Set_Flag115;
7064
7065 procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
7066 begin
7067 pragma Assert (Nkind (N) in N_Entity);
7068 To_Flag_Word2_Ptr
7069 (Union_Id_Ptr'
7070 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
7071 end Set_Flag116;
7072
7073 procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
7074 begin
7075 pragma Assert (Nkind (N) in N_Entity);
7076 To_Flag_Word2_Ptr
7077 (Union_Id_Ptr'
7078 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
7079 end Set_Flag117;
7080
7081 procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
7082 begin
7083 pragma Assert (Nkind (N) in N_Entity);
7084 To_Flag_Word2_Ptr
7085 (Union_Id_Ptr'
7086 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
7087 end Set_Flag118;
7088
7089 procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
7090 begin
7091 pragma Assert (Nkind (N) in N_Entity);
7092 To_Flag_Word2_Ptr
7093 (Union_Id_Ptr'
7094 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
7095 end Set_Flag119;
7096
7097 procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
7098 begin
7099 pragma Assert (Nkind (N) in N_Entity);
7100 To_Flag_Word2_Ptr
7101 (Union_Id_Ptr'
7102 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
7103 end Set_Flag120;
7104
7105 procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
7106 begin
7107 pragma Assert (Nkind (N) in N_Entity);
7108 To_Flag_Word2_Ptr
7109 (Union_Id_Ptr'
7110 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
7111 end Set_Flag121;
7112
7113 procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
7114 begin
7115 pragma Assert (Nkind (N) in N_Entity);
7116 To_Flag_Word2_Ptr
7117 (Union_Id_Ptr'
7118 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
7119 end Set_Flag122;
7120
7121 procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
7122 begin
7123 pragma Assert (Nkind (N) in N_Entity);
7124 To_Flag_Word2_Ptr
7125 (Union_Id_Ptr'
7126 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
7127 end Set_Flag123;
7128
7129 procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
7130 begin
7131 pragma Assert (Nkind (N) in N_Entity);
7132 To_Flag_Word2_Ptr
7133 (Union_Id_Ptr'
7134 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
7135 end Set_Flag124;
7136
7137 procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
7138 begin
7139 pragma Assert (Nkind (N) in N_Entity);
7140 To_Flag_Word2_Ptr
7141 (Union_Id_Ptr'
7142 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
7143 end Set_Flag125;
7144
7145 procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
7146 begin
7147 pragma Assert (Nkind (N) in N_Entity);
7148 To_Flag_Word2_Ptr
7149 (Union_Id_Ptr'
7150 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
7151 end Set_Flag126;
7152
7153 procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
7154 begin
7155 pragma Assert (Nkind (N) in N_Entity);
7156 To_Flag_Word2_Ptr
7157 (Union_Id_Ptr'
7158 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
7159 end Set_Flag127;
7160
7161 procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
7162 begin
7163 pragma Assert (Nkind (N) in N_Entity);
7164 To_Flag_Word2_Ptr
7165 (Union_Id_Ptr'
7166 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
7167 end Set_Flag128;
7168
7169 procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
7170 begin
7171 pragma Assert (Nkind (N) in N_Entity);
7172 Nodes.Table (N + 3).In_List := Val;
7173 end Set_Flag129;
7174
7175 procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
7176 begin
7177 pragma Assert (Nkind (N) in N_Entity);
7178 Nodes.Table (N + 3).Has_Aspects := Val;
7179 end Set_Flag130;
7180
7181 procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
7182 begin
7183 pragma Assert (Nkind (N) in N_Entity);
7184 Nodes.Table (N + 3).Rewrite_Ins := Val;
7185 end Set_Flag131;
7186
7187 procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
7188 begin
7189 pragma Assert (Nkind (N) in N_Entity);
7190 Nodes.Table (N + 3).Analyzed := Val;
7191 end Set_Flag132;
7192
7193 procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
7194 begin
7195 pragma Assert (Nkind (N) in N_Entity);
7196 Nodes.Table (N + 3).Comes_From_Source := Val;
7197 end Set_Flag133;
7198
7199 procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
7200 begin
7201 pragma Assert (Nkind (N) in N_Entity);
7202 Nodes.Table (N + 3).Error_Posted := Val;
7203 end Set_Flag134;
7204
7205 procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
7206 begin
7207 pragma Assert (Nkind (N) in N_Entity);
7208 Nodes.Table (N + 3).Flag4 := Val;
7209 end Set_Flag135;
7210
7211 procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
7212 begin
7213 pragma Assert (Nkind (N) in N_Entity);
7214 Nodes.Table (N + 3).Flag5 := Val;
7215 end Set_Flag136;
7216
7217 procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
7218 begin
7219 pragma Assert (Nkind (N) in N_Entity);
7220 Nodes.Table (N + 3).Flag6 := Val;
7221 end Set_Flag137;
7222
7223 procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
7224 begin
7225 pragma Assert (Nkind (N) in N_Entity);
7226 Nodes.Table (N + 3).Flag7 := Val;
7227 end Set_Flag138;
7228
7229 procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
7230 begin
7231 pragma Assert (Nkind (N) in N_Entity);
7232 Nodes.Table (N + 3).Flag8 := Val;
7233 end Set_Flag139;
7234
7235 procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
7236 begin
7237 pragma Assert (Nkind (N) in N_Entity);
7238 Nodes.Table (N + 3).Flag9 := Val;
7239 end Set_Flag140;
7240
7241 procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
7242 begin
7243 pragma Assert (Nkind (N) in N_Entity);
7244 Nodes.Table (N + 3).Flag10 := Val;
7245 end Set_Flag141;
7246
7247 procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
7248 begin
7249 pragma Assert (Nkind (N) in N_Entity);
7250 Nodes.Table (N + 3).Flag11 := Val;
7251 end Set_Flag142;
7252
7253 procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
7254 begin
7255 pragma Assert (Nkind (N) in N_Entity);
7256 Nodes.Table (N + 3).Flag12 := Val;
7257 end Set_Flag143;
7258
7259 procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
7260 begin
7261 pragma Assert (Nkind (N) in N_Entity);
7262 Nodes.Table (N + 3).Flag13 := Val;
7263 end Set_Flag144;
7264
7265 procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
7266 begin
7267 pragma Assert (Nkind (N) in N_Entity);
7268 Nodes.Table (N + 3).Flag14 := Val;
7269 end Set_Flag145;
7270
7271 procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
7272 begin
7273 pragma Assert (Nkind (N) in N_Entity);
7274 Nodes.Table (N + 3).Flag15 := Val;
7275 end Set_Flag146;
7276
7277 procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
7278 begin
7279 pragma Assert (Nkind (N) in N_Entity);
7280 Nodes.Table (N + 3).Flag16 := Val;
7281 end Set_Flag147;
7282
7283 procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
7284 begin
7285 pragma Assert (Nkind (N) in N_Entity);
7286 Nodes.Table (N + 3).Flag17 := Val;
7287 end Set_Flag148;
7288
7289 procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
7290 begin
7291 pragma Assert (Nkind (N) in N_Entity);
7292 Nodes.Table (N + 3).Flag18 := Val;
7293 end Set_Flag149;
7294
7295 procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
7296 begin
7297 pragma Assert (Nkind (N) in N_Entity);
7298 Nodes.Table (N + 3).Pflag1 := Val;
7299 end Set_Flag150;
7300
7301 procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
7302 begin
7303 pragma Assert (Nkind (N) in N_Entity);
7304 Nodes.Table (N + 3).Pflag2 := Val;
7305 end Set_Flag151;
7306
7307 procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
7308 begin
7309 pragma Assert (Nkind (N) in N_Entity);
7310 To_Flag_Word3_Ptr
7311 (Union_Id_Ptr'
7312 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
7313 end Set_Flag152;
7314
7315 procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
7316 begin
7317 pragma Assert (Nkind (N) in N_Entity);
7318 To_Flag_Word3_Ptr
7319 (Union_Id_Ptr'
7320 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
7321 end Set_Flag153;
7322
7323 procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
7324 begin
7325 pragma Assert (Nkind (N) in N_Entity);
7326 To_Flag_Word3_Ptr
7327 (Union_Id_Ptr'
7328 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
7329 end Set_Flag154;
7330
7331 procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
7332 begin
7333 pragma Assert (Nkind (N) in N_Entity);
7334 To_Flag_Word3_Ptr
7335 (Union_Id_Ptr'
7336 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
7337 end Set_Flag155;
7338
7339 procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
7340 begin
7341 pragma Assert (Nkind (N) in N_Entity);
7342 To_Flag_Word3_Ptr
7343 (Union_Id_Ptr'
7344 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
7345 end Set_Flag156;
7346
7347 procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
7348 begin
7349 pragma Assert (Nkind (N) in N_Entity);
7350 To_Flag_Word3_Ptr
7351 (Union_Id_Ptr'
7352 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
7353 end Set_Flag157;
7354
7355 procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
7356 begin
7357 pragma Assert (Nkind (N) in N_Entity);
7358 To_Flag_Word3_Ptr
7359 (Union_Id_Ptr'
7360 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
7361 end Set_Flag158;
7362
7363 procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
7364 begin
7365 pragma Assert (Nkind (N) in N_Entity);
7366 To_Flag_Word3_Ptr
7367 (Union_Id_Ptr'
7368 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
7369 end Set_Flag159;
7370
7371 procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
7372 begin
7373 pragma Assert (Nkind (N) in N_Entity);
7374 To_Flag_Word3_Ptr
7375 (Union_Id_Ptr'
7376 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
7377 end Set_Flag160;
7378
7379 procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
7380 begin
7381 pragma Assert (Nkind (N) in N_Entity);
7382 To_Flag_Word3_Ptr
7383 (Union_Id_Ptr'
7384 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
7385 end Set_Flag161;
7386
7387 procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
7388 begin
7389 pragma Assert (Nkind (N) in N_Entity);
7390 To_Flag_Word3_Ptr
7391 (Union_Id_Ptr'
7392 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
7393 end Set_Flag162;
7394
7395 procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
7396 begin
7397 pragma Assert (Nkind (N) in N_Entity);
7398 To_Flag_Word3_Ptr
7399 (Union_Id_Ptr'
7400 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
7401 end Set_Flag163;
7402
7403 procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
7404 begin
7405 pragma Assert (Nkind (N) in N_Entity);
7406 To_Flag_Word3_Ptr
7407 (Union_Id_Ptr'
7408 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
7409 end Set_Flag164;
7410
7411 procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
7412 begin
7413 pragma Assert (Nkind (N) in N_Entity);
7414 To_Flag_Word3_Ptr
7415 (Union_Id_Ptr'
7416 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
7417 end Set_Flag165;
7418
7419 procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
7420 begin
7421 pragma Assert (Nkind (N) in N_Entity);
7422 To_Flag_Word3_Ptr
7423 (Union_Id_Ptr'
7424 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
7425 end Set_Flag166;
7426
7427 procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
7428 begin
7429 pragma Assert (Nkind (N) in N_Entity);
7430 To_Flag_Word3_Ptr
7431 (Union_Id_Ptr'
7432 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
7433 end Set_Flag167;
7434
7435 procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
7436 begin
7437 pragma Assert (Nkind (N) in N_Entity);
7438 To_Flag_Word3_Ptr
7439 (Union_Id_Ptr'
7440 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
7441 end Set_Flag168;
7442
7443 procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
7444 begin
7445 pragma Assert (Nkind (N) in N_Entity);
7446 To_Flag_Word3_Ptr
7447 (Union_Id_Ptr'
7448 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
7449 end Set_Flag169;
7450
7451 procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
7452 begin
7453 pragma Assert (Nkind (N) in N_Entity);
7454 To_Flag_Word3_Ptr
7455 (Union_Id_Ptr'
7456 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
7457 end Set_Flag170;
7458
7459 procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
7460 begin
7461 pragma Assert (Nkind (N) in N_Entity);
7462 To_Flag_Word3_Ptr
7463 (Union_Id_Ptr'
7464 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
7465 end Set_Flag171;
7466
7467 procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
7468 begin
7469 pragma Assert (Nkind (N) in N_Entity);
7470 To_Flag_Word3_Ptr
7471 (Union_Id_Ptr'
7472 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
7473 end Set_Flag172;
7474
7475 procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
7476 begin
7477 pragma Assert (Nkind (N) in N_Entity);
7478 To_Flag_Word3_Ptr
7479 (Union_Id_Ptr'
7480 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
7481 end Set_Flag173;
7482
7483 procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
7484 begin
7485 pragma Assert (Nkind (N) in N_Entity);
7486 To_Flag_Word3_Ptr
7487 (Union_Id_Ptr'
7488 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
7489 end Set_Flag174;
7490
7491 procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
7492 begin
7493 pragma Assert (Nkind (N) in N_Entity);
7494 To_Flag_Word3_Ptr
7495 (Union_Id_Ptr'
7496 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
7497 end Set_Flag175;
7498
7499 procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
7500 begin
7501 pragma Assert (Nkind (N) in N_Entity);
7502 To_Flag_Word3_Ptr
7503 (Union_Id_Ptr'
7504 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
7505 end Set_Flag176;
7506
7507 procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
7508 begin
7509 pragma Assert (Nkind (N) in N_Entity);
7510 To_Flag_Word3_Ptr
7511 (Union_Id_Ptr'
7512 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
7513 end Set_Flag177;
7514
7515 procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
7516 begin
7517 pragma Assert (Nkind (N) in N_Entity);
7518 To_Flag_Word3_Ptr
7519 (Union_Id_Ptr'
7520 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
7521 end Set_Flag178;
7522
7523 procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
7524 begin
7525 pragma Assert (Nkind (N) in N_Entity);
7526 To_Flag_Word3_Ptr
7527 (Union_Id_Ptr'
7528 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
7529 end Set_Flag179;
7530
7531 procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
7532 begin
7533 pragma Assert (Nkind (N) in N_Entity);
7534 To_Flag_Word3_Ptr
7535 (Union_Id_Ptr'
7536 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
7537 end Set_Flag180;
7538
7539 procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
7540 begin
7541 pragma Assert (Nkind (N) in N_Entity);
7542 To_Flag_Word3_Ptr
7543 (Union_Id_Ptr'
7544 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
7545 end Set_Flag181;
7546
7547 procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
7548 begin
7549 pragma Assert (Nkind (N) in N_Entity);
7550 To_Flag_Word3_Ptr
7551 (Union_Id_Ptr'
7552 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
7553 end Set_Flag182;
7554
7555 procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
7556 begin
7557 pragma Assert (Nkind (N) in N_Entity);
7558 To_Flag_Word3_Ptr
7559 (Union_Id_Ptr'
7560 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
7561 end Set_Flag183;
7562
7563 procedure Set_Flag184 (N : Node_Id; Val : Boolean) is
7564 begin
7565 pragma Assert (Nkind (N) in N_Entity);
7566 To_Flag_Word4_Ptr
7567 (Union_Id_Ptr'
7568 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag184 := Val;
7569 end Set_Flag184;
7570
7571 procedure Set_Flag185 (N : Node_Id; Val : Boolean) is
7572 begin
7573 pragma Assert (Nkind (N) in N_Entity);
7574 To_Flag_Word4_Ptr
7575 (Union_Id_Ptr'
7576 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag185 := Val;
7577 end Set_Flag185;
7578
7579 procedure Set_Flag186 (N : Node_Id; Val : Boolean) is
7580 begin
7581 pragma Assert (Nkind (N) in N_Entity);
7582 To_Flag_Word4_Ptr
7583 (Union_Id_Ptr'
7584 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag186 := Val;
7585 end Set_Flag186;
7586
7587 procedure Set_Flag187 (N : Node_Id; Val : Boolean) is
7588 begin
7589 pragma Assert (Nkind (N) in N_Entity);
7590 To_Flag_Word4_Ptr
7591 (Union_Id_Ptr'
7592 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag187 := Val;
7593 end Set_Flag187;
7594
7595 procedure Set_Flag188 (N : Node_Id; Val : Boolean) is
7596 begin
7597 pragma Assert (Nkind (N) in N_Entity);
7598 To_Flag_Word4_Ptr
7599 (Union_Id_Ptr'
7600 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag188 := Val;
7601 end Set_Flag188;
7602
7603 procedure Set_Flag189 (N : Node_Id; Val : Boolean) is
7604 begin
7605 pragma Assert (Nkind (N) in N_Entity);
7606 To_Flag_Word4_Ptr
7607 (Union_Id_Ptr'
7608 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag189 := Val;
7609 end Set_Flag189;
7610
7611 procedure Set_Flag190 (N : Node_Id; Val : Boolean) is
7612 begin
7613 pragma Assert (Nkind (N) in N_Entity);
7614 To_Flag_Word4_Ptr
7615 (Union_Id_Ptr'
7616 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag190 := Val;
7617 end Set_Flag190;
7618
7619 procedure Set_Flag191 (N : Node_Id; Val : Boolean) is
7620 begin
7621 pragma Assert (Nkind (N) in N_Entity);
7622 To_Flag_Word4_Ptr
7623 (Union_Id_Ptr'
7624 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag191 := Val;
7625 end Set_Flag191;
7626
7627 procedure Set_Flag192 (N : Node_Id; Val : Boolean) is
7628 begin
7629 pragma Assert (Nkind (N) in N_Entity);
7630 To_Flag_Word4_Ptr
7631 (Union_Id_Ptr'
7632 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag192 := Val;
7633 end Set_Flag192;
7634
7635 procedure Set_Flag193 (N : Node_Id; Val : Boolean) is
7636 begin
7637 pragma Assert (Nkind (N) in N_Entity);
7638 To_Flag_Word4_Ptr
7639 (Union_Id_Ptr'
7640 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag193 := Val;
7641 end Set_Flag193;
7642
7643 procedure Set_Flag194 (N : Node_Id; Val : Boolean) is
7644 begin
7645 pragma Assert (Nkind (N) in N_Entity);
7646 To_Flag_Word4_Ptr
7647 (Union_Id_Ptr'
7648 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag194 := Val;
7649 end Set_Flag194;
7650
7651 procedure Set_Flag195 (N : Node_Id; Val : Boolean) is
7652 begin
7653 pragma Assert (Nkind (N) in N_Entity);
7654 To_Flag_Word4_Ptr
7655 (Union_Id_Ptr'
7656 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag195 := Val;
7657 end Set_Flag195;
7658
7659 procedure Set_Flag196 (N : Node_Id; Val : Boolean) is
7660 begin
7661 pragma Assert (Nkind (N) in N_Entity);
7662 To_Flag_Word4_Ptr
7663 (Union_Id_Ptr'
7664 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag196 := Val;
7665 end Set_Flag196;
7666
7667 procedure Set_Flag197 (N : Node_Id; Val : Boolean) is
7668 begin
7669 pragma Assert (Nkind (N) in N_Entity);
7670 To_Flag_Word4_Ptr
7671 (Union_Id_Ptr'
7672 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag197 := Val;
7673 end Set_Flag197;
7674
7675 procedure Set_Flag198 (N : Node_Id; Val : Boolean) is
7676 begin
7677 pragma Assert (Nkind (N) in N_Entity);
7678 To_Flag_Word4_Ptr
7679 (Union_Id_Ptr'
7680 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag198 := Val;
7681 end Set_Flag198;
7682
7683 procedure Set_Flag199 (N : Node_Id; Val : Boolean) is
7684 begin
7685 pragma Assert (Nkind (N) in N_Entity);
7686 To_Flag_Word4_Ptr
7687 (Union_Id_Ptr'
7688 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag199 := Val;
7689 end Set_Flag199;
7690
7691 procedure Set_Flag200 (N : Node_Id; Val : Boolean) is
7692 begin
7693 pragma Assert (Nkind (N) in N_Entity);
7694 To_Flag_Word4_Ptr
7695 (Union_Id_Ptr'
7696 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag200 := Val;
7697 end Set_Flag200;
7698
7699 procedure Set_Flag201 (N : Node_Id; Val : Boolean) is
7700 begin
7701 pragma Assert (Nkind (N) in N_Entity);
7702 To_Flag_Word4_Ptr
7703 (Union_Id_Ptr'
7704 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag201 := Val;
7705 end Set_Flag201;
7706
7707 procedure Set_Flag202 (N : Node_Id; Val : Boolean) is
7708 begin
7709 pragma Assert (Nkind (N) in N_Entity);
7710 To_Flag_Word4_Ptr
7711 (Union_Id_Ptr'
7712 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag202 := Val;
7713 end Set_Flag202;
7714
7715 procedure Set_Flag203 (N : Node_Id; Val : Boolean) is
7716 begin
7717 pragma Assert (Nkind (N) in N_Entity);
7718 To_Flag_Word4_Ptr
7719 (Union_Id_Ptr'
7720 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag203 := Val;
7721 end Set_Flag203;
7722
7723 procedure Set_Flag204 (N : Node_Id; Val : Boolean) is
7724 begin
7725 pragma Assert (Nkind (N) in N_Entity);
7726 To_Flag_Word4_Ptr
7727 (Union_Id_Ptr'
7728 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag204 := Val;
7729 end Set_Flag204;
7730
7731 procedure Set_Flag205 (N : Node_Id; Val : Boolean) is
7732 begin
7733 pragma Assert (Nkind (N) in N_Entity);
7734 To_Flag_Word4_Ptr
7735 (Union_Id_Ptr'
7736 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag205 := Val;
7737 end Set_Flag205;
7738
7739 procedure Set_Flag206 (N : Node_Id; Val : Boolean) is
7740 begin
7741 pragma Assert (Nkind (N) in N_Entity);
7742 To_Flag_Word4_Ptr
7743 (Union_Id_Ptr'
7744 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag206 := Val;
7745 end Set_Flag206;
7746
7747 procedure Set_Flag207 (N : Node_Id; Val : Boolean) is
7748 begin
7749 pragma Assert (Nkind (N) in N_Entity);
7750 To_Flag_Word4_Ptr
7751 (Union_Id_Ptr'
7752 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag207 := Val;
7753 end Set_Flag207;
7754
7755 procedure Set_Flag208 (N : Node_Id; Val : Boolean) is
7756 begin
7757 pragma Assert (Nkind (N) in N_Entity);
7758 To_Flag_Word4_Ptr
7759 (Union_Id_Ptr'
7760 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag208 := Val;
7761 end Set_Flag208;
7762
7763 procedure Set_Flag209 (N : Node_Id; Val : Boolean) is
7764 begin
7765 pragma Assert (Nkind (N) in N_Entity);
7766 To_Flag_Word4_Ptr
7767 (Union_Id_Ptr'
7768 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag209 := Val;
7769 end Set_Flag209;
7770
7771 procedure Set_Flag210 (N : Node_Id; Val : Boolean) is
7772 begin
7773 pragma Assert (Nkind (N) in N_Entity);
7774 To_Flag_Word4_Ptr
7775 (Union_Id_Ptr'
7776 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag210 := Val;
7777 end Set_Flag210;
7778
7779 procedure Set_Flag211 (N : Node_Id; Val : Boolean) is
7780 begin
7781 pragma Assert (Nkind (N) in N_Entity);
7782 To_Flag_Word4_Ptr
7783 (Union_Id_Ptr'
7784 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag211 := Val;
7785 end Set_Flag211;
7786
7787 procedure Set_Flag212 (N : Node_Id; Val : Boolean) is
7788 begin
7789 pragma Assert (Nkind (N) in N_Entity);
7790 To_Flag_Word4_Ptr
7791 (Union_Id_Ptr'
7792 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag212 := Val;
7793 end Set_Flag212;
7794
7795 procedure Set_Flag213 (N : Node_Id; Val : Boolean) is
7796 begin
7797 pragma Assert (Nkind (N) in N_Entity);
7798 To_Flag_Word4_Ptr
7799 (Union_Id_Ptr'
7800 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag213 := Val;
7801 end Set_Flag213;
7802
7803 procedure Set_Flag214 (N : Node_Id; Val : Boolean) is
7804 begin
7805 pragma Assert (Nkind (N) in N_Entity);
7806 To_Flag_Word4_Ptr
7807 (Union_Id_Ptr'
7808 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag214 := Val;
7809 end Set_Flag214;
7810
7811 procedure Set_Flag215 (N : Node_Id; Val : Boolean) is
7812 begin
7813 pragma Assert (Nkind (N) in N_Entity);
7814 To_Flag_Word4_Ptr
7815 (Union_Id_Ptr'
7816 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag215 := Val;
7817 end Set_Flag215;
7818
7819 procedure Set_Flag216 (N : Node_Id; Val : Boolean) is
7820 begin
7821 pragma Assert (Nkind (N) in N_Entity);
7822 Nodes.Table (N + 4).In_List := Val;
7823 end Set_Flag216;
7824
7825 procedure Set_Flag217 (N : Node_Id; Val : Boolean) is
7826 begin
7827 pragma Assert (Nkind (N) in N_Entity);
7828 Nodes.Table (N + 4).Has_Aspects := Val;
7829 end Set_Flag217;
7830
7831 procedure Set_Flag218 (N : Node_Id; Val : Boolean) is
7832 begin
7833 pragma Assert (Nkind (N) in N_Entity);
7834 Nodes.Table (N + 4).Rewrite_Ins := Val;
7835 end Set_Flag218;
7836
7837 procedure Set_Flag219 (N : Node_Id; Val : Boolean) is
7838 begin
7839 pragma Assert (Nkind (N) in N_Entity);
7840 Nodes.Table (N + 4).Analyzed := Val;
7841 end Set_Flag219;
7842
7843 procedure Set_Flag220 (N : Node_Id; Val : Boolean) is
7844 begin
7845 pragma Assert (Nkind (N) in N_Entity);
7846 Nodes.Table (N + 4).Comes_From_Source := Val;
7847 end Set_Flag220;
7848
7849 procedure Set_Flag221 (N : Node_Id; Val : Boolean) is
7850 begin
7851 pragma Assert (Nkind (N) in N_Entity);
7852 Nodes.Table (N + 4).Error_Posted := Val;
7853 end Set_Flag221;
7854
7855 procedure Set_Flag222 (N : Node_Id; Val : Boolean) is
7856 begin
7857 pragma Assert (Nkind (N) in N_Entity);
7858 Nodes.Table (N + 4).Flag4 := Val;
7859 end Set_Flag222;
7860
7861 procedure Set_Flag223 (N : Node_Id; Val : Boolean) is
7862 begin
7863 pragma Assert (Nkind (N) in N_Entity);
7864 Nodes.Table (N + 4).Flag5 := Val;
7865 end Set_Flag223;
7866
7867 procedure Set_Flag224 (N : Node_Id; Val : Boolean) is
7868 begin
7869 pragma Assert (Nkind (N) in N_Entity);
7870 Nodes.Table (N + 4).Flag6 := Val;
7871 end Set_Flag224;
7872
7873 procedure Set_Flag225 (N : Node_Id; Val : Boolean) is
7874 begin
7875 pragma Assert (Nkind (N) in N_Entity);
7876 Nodes.Table (N + 4).Flag7 := Val;
7877 end Set_Flag225;
7878
7879 procedure Set_Flag226 (N : Node_Id; Val : Boolean) is
7880 begin
7881 pragma Assert (Nkind (N) in N_Entity);
7882 Nodes.Table (N + 4).Flag8 := Val;
7883 end Set_Flag226;
7884
7885 procedure Set_Flag227 (N : Node_Id; Val : Boolean) is
7886 begin
7887 pragma Assert (Nkind (N) in N_Entity);
7888 Nodes.Table (N + 4).Flag9 := Val;
7889 end Set_Flag227;
7890
7891 procedure Set_Flag228 (N : Node_Id; Val : Boolean) is
7892 begin
7893 pragma Assert (Nkind (N) in N_Entity);
7894 Nodes.Table (N + 4).Flag10 := Val;
7895 end Set_Flag228;
7896
7897 procedure Set_Flag229 (N : Node_Id; Val : Boolean) is
7898 begin
7899 pragma Assert (Nkind (N) in N_Entity);
7900 Nodes.Table (N + 4).Flag11 := Val;
7901 end Set_Flag229;
7902
7903 procedure Set_Flag230 (N : Node_Id; Val : Boolean) is
7904 begin
7905 pragma Assert (Nkind (N) in N_Entity);
7906 Nodes.Table (N + 4).Flag12 := Val;
7907 end Set_Flag230;
7908
7909 procedure Set_Flag231 (N : Node_Id; Val : Boolean) is
7910 begin
7911 pragma Assert (Nkind (N) in N_Entity);
7912 Nodes.Table (N + 4).Flag13 := Val;
7913 end Set_Flag231;
7914
7915 procedure Set_Flag232 (N : Node_Id; Val : Boolean) is
7916 begin
7917 pragma Assert (Nkind (N) in N_Entity);
7918 Nodes.Table (N + 4).Flag14 := Val;
7919 end Set_Flag232;
7920
7921 procedure Set_Flag233 (N : Node_Id; Val : Boolean) is
7922 begin
7923 pragma Assert (Nkind (N) in N_Entity);
7924 Nodes.Table (N + 4).Flag15 := Val;
7925 end Set_Flag233;
7926
7927 procedure Set_Flag234 (N : Node_Id; Val : Boolean) is
7928 begin
7929 pragma Assert (Nkind (N) in N_Entity);
7930 Nodes.Table (N + 4).Flag16 := Val;
7931 end Set_Flag234;
7932
7933 procedure Set_Flag235 (N : Node_Id; Val : Boolean) is
7934 begin
7935 pragma Assert (Nkind (N) in N_Entity);
7936 Nodes.Table (N + 4).Flag17 := Val;
7937 end Set_Flag235;
7938
7939 procedure Set_Flag236 (N : Node_Id; Val : Boolean) is
7940 begin
7941 pragma Assert (Nkind (N) in N_Entity);
7942 Nodes.Table (N + 4).Flag18 := Val;
7943 end Set_Flag236;
7944
7945 procedure Set_Flag237 (N : Node_Id; Val : Boolean) is
7946 begin
7947 pragma Assert (Nkind (N) in N_Entity);
7948 Nodes.Table (N + 4).Pflag1 := Val;
7949 end Set_Flag237;
7950
7951 procedure Set_Flag238 (N : Node_Id; Val : Boolean) is
7952 begin
7953 pragma Assert (Nkind (N) in N_Entity);
7954 Nodes.Table (N + 4).Pflag2 := Val;
7955 end Set_Flag238;
7956
7957 procedure Set_Flag239 (N : Node_Id; Val : Boolean) is
7958 begin
7959 pragma Assert (Nkind (N) in N_Entity);
7960 To_Flag_Byte2_Ptr
7961 (Node_Kind_Ptr'
7962 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag239 := Val;
7963 end Set_Flag239;
7964
7965 procedure Set_Flag240 (N : Node_Id; Val : Boolean) is
7966 begin
7967 pragma Assert (Nkind (N) in N_Entity);
7968 To_Flag_Byte2_Ptr
7969 (Node_Kind_Ptr'
7970 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag240 := Val;
7971 end Set_Flag240;
7972
7973 procedure Set_Flag241 (N : Node_Id; Val : Boolean) is
7974 begin
7975 pragma Assert (Nkind (N) in N_Entity);
7976 To_Flag_Byte2_Ptr
7977 (Node_Kind_Ptr'
7978 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag241 := Val;
7979 end Set_Flag241;
7980
7981 procedure Set_Flag242 (N : Node_Id; Val : Boolean) is
7982 begin
7983 pragma Assert (Nkind (N) in N_Entity);
7984 To_Flag_Byte2_Ptr
7985 (Node_Kind_Ptr'
7986 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag242 := Val;
7987 end Set_Flag242;
7988
7989 procedure Set_Flag243 (N : Node_Id; Val : Boolean) is
7990 begin
7991 pragma Assert (Nkind (N) in N_Entity);
7992 To_Flag_Byte2_Ptr
7993 (Node_Kind_Ptr'
7994 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag243 := Val;
7995 end Set_Flag243;
7996
7997 procedure Set_Flag244 (N : Node_Id; Val : Boolean) is
7998 begin
7999 pragma Assert (Nkind (N) in N_Entity);
8000 To_Flag_Byte2_Ptr
8001 (Node_Kind_Ptr'
8002 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag244 := Val;
8003 end Set_Flag244;
8004
8005 procedure Set_Flag245 (N : Node_Id; Val : Boolean) is
8006 begin
8007 pragma Assert (Nkind (N) in N_Entity);
8008 To_Flag_Byte2_Ptr
8009 (Node_Kind_Ptr'
8010 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag245 := Val;
8011 end Set_Flag245;
8012
8013 procedure Set_Flag246 (N : Node_Id; Val : Boolean) is
8014 begin
8015 pragma Assert (Nkind (N) in N_Entity);
8016 To_Flag_Byte2_Ptr
8017 (Node_Kind_Ptr'
8018 (Nodes.Table (N + 3).Nkind'Unrestricted_Access)).Flag246 := Val;
8019 end Set_Flag246;
8020
8021 procedure Set_Flag247 (N : Node_Id; Val : Boolean) is
8022 begin
8023 pragma Assert (Nkind (N) in N_Entity);
8024 To_Flag_Byte3_Ptr
8025 (Node_Kind_Ptr'
8026 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag247 := Val;
8027 end Set_Flag247;
8028
8029 procedure Set_Flag248 (N : Node_Id; Val : Boolean) is
8030 begin
8031 pragma Assert (Nkind (N) in N_Entity);
8032 To_Flag_Byte3_Ptr
8033 (Node_Kind_Ptr'
8034 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag248 := Val;
8035 end Set_Flag248;
8036
8037 procedure Set_Flag249 (N : Node_Id; Val : Boolean) is
8038 begin
8039 pragma Assert (Nkind (N) in N_Entity);
8040 To_Flag_Byte3_Ptr
8041 (Node_Kind_Ptr'
8042 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag249 := Val;
8043 end Set_Flag249;
8044
8045 procedure Set_Flag250 (N : Node_Id; Val : Boolean) is
8046 begin
8047 pragma Assert (Nkind (N) in N_Entity);
8048 To_Flag_Byte3_Ptr
8049 (Node_Kind_Ptr'
8050 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag250 := Val;
8051 end Set_Flag250;
8052
8053 procedure Set_Flag251 (N : Node_Id; Val : Boolean) is
8054 begin
8055 pragma Assert (Nkind (N) in N_Entity);
8056 To_Flag_Byte3_Ptr
8057 (Node_Kind_Ptr'
8058 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag251 := Val;
8059 end Set_Flag251;
8060
8061 procedure Set_Flag252 (N : Node_Id; Val : Boolean) is
8062 begin
8063 pragma Assert (Nkind (N) in N_Entity);
8064 To_Flag_Byte3_Ptr
8065 (Node_Kind_Ptr'
8066 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag252 := Val;
8067 end Set_Flag252;
8068
8069 procedure Set_Flag253 (N : Node_Id; Val : Boolean) is
8070 begin
8071 pragma Assert (Nkind (N) in N_Entity);
8072 To_Flag_Byte3_Ptr
8073 (Node_Kind_Ptr'
8074 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag253 := Val;
8075 end Set_Flag253;
8076
8077 procedure Set_Flag254 (N : Node_Id; Val : Boolean) is
8078 begin
8079 pragma Assert (Nkind (N) in N_Entity);
8080 To_Flag_Byte3_Ptr
8081 (Node_Kind_Ptr'
8082 (Nodes.Table (N + 4).Nkind'Unrestricted_Access)).Flag254 := Val;
8083 end Set_Flag254;
8084
8085 procedure Set_Flag255 (N : Node_Id; Val : Boolean) is
8086 begin
8087 pragma Assert (Nkind (N) in N_Entity);
8088 To_Flag_Word5_Ptr
8089 (Union_Id_Ptr'
8090 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag255 := Val;
8091 end Set_Flag255;
8092
8093 procedure Set_Flag256 (N : Node_Id; Val : Boolean) is
8094 begin
8095 pragma Assert (Nkind (N) in N_Entity);
8096 To_Flag_Word5_Ptr
8097 (Union_Id_Ptr'
8098 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag256 := Val;
8099 end Set_Flag256;
8100
8101 procedure Set_Flag257 (N : Node_Id; Val : Boolean) is
8102 begin
8103 pragma Assert (Nkind (N) in N_Entity);
8104 To_Flag_Word5_Ptr
8105 (Union_Id_Ptr'
8106 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag257 := Val;
8107 end Set_Flag257;
8108
8109 procedure Set_Flag258 (N : Node_Id; Val : Boolean) is
8110 begin
8111 pragma Assert (Nkind (N) in N_Entity);
8112 To_Flag_Word5_Ptr
8113 (Union_Id_Ptr'
8114 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag258 := Val;
8115 end Set_Flag258;
8116
8117 procedure Set_Flag259 (N : Node_Id; Val : Boolean) is
8118 begin
8119 pragma Assert (Nkind (N) in N_Entity);
8120 To_Flag_Word5_Ptr
8121 (Union_Id_Ptr'
8122 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag259 := Val;
8123 end Set_Flag259;
8124
8125 procedure Set_Flag260 (N : Node_Id; Val : Boolean) is
8126 begin
8127 pragma Assert (Nkind (N) in N_Entity);
8128 To_Flag_Word5_Ptr
8129 (Union_Id_Ptr'
8130 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag260 := Val;
8131 end Set_Flag260;
8132
8133 procedure Set_Flag261 (N : Node_Id; Val : Boolean) is
8134 begin
8135 pragma Assert (Nkind (N) in N_Entity);
8136 To_Flag_Word5_Ptr
8137 (Union_Id_Ptr'
8138 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag261 := Val;
8139 end Set_Flag261;
8140
8141 procedure Set_Flag262 (N : Node_Id; Val : Boolean) is
8142 begin
8143 pragma Assert (Nkind (N) in N_Entity);
8144 To_Flag_Word5_Ptr
8145 (Union_Id_Ptr'
8146 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag262 := Val;
8147 end Set_Flag262;
8148
8149 procedure Set_Flag263 (N : Node_Id; Val : Boolean) is
8150 begin
8151 pragma Assert (Nkind (N) in N_Entity);
8152 To_Flag_Word5_Ptr
8153 (Union_Id_Ptr'
8154 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag263 := Val;
8155 end Set_Flag263;
8156
8157 procedure Set_Flag264 (N : Node_Id; Val : Boolean) is
8158 begin
8159 pragma Assert (Nkind (N) in N_Entity);
8160 To_Flag_Word5_Ptr
8161 (Union_Id_Ptr'
8162 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag264 := Val;
8163 end Set_Flag264;
8164
8165 procedure Set_Flag265 (N : Node_Id; Val : Boolean) is
8166 begin
8167 pragma Assert (Nkind (N) in N_Entity);
8168 To_Flag_Word5_Ptr
8169 (Union_Id_Ptr'
8170 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag265 := Val;
8171 end Set_Flag265;
8172
8173 procedure Set_Flag266 (N : Node_Id; Val : Boolean) is
8174 begin
8175 pragma Assert (Nkind (N) in N_Entity);
8176 To_Flag_Word5_Ptr
8177 (Union_Id_Ptr'
8178 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag266 := Val;
8179 end Set_Flag266;
8180
8181 procedure Set_Flag267 (N : Node_Id; Val : Boolean) is
8182 begin
8183 pragma Assert (Nkind (N) in N_Entity);
8184 To_Flag_Word5_Ptr
8185 (Union_Id_Ptr'
8186 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag267 := Val;
8187 end Set_Flag267;
8188
8189 procedure Set_Flag268 (N : Node_Id; Val : Boolean) is
8190 begin
8191 pragma Assert (Nkind (N) in N_Entity);
8192 To_Flag_Word5_Ptr
8193 (Union_Id_Ptr'
8194 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag268 := Val;
8195 end Set_Flag268;
8196
8197 procedure Set_Flag269 (N : Node_Id; Val : Boolean) is
8198 begin
8199 pragma Assert (Nkind (N) in N_Entity);
8200 To_Flag_Word5_Ptr
8201 (Union_Id_Ptr'
8202 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag269 := Val;
8203 end Set_Flag269;
8204
8205 procedure Set_Flag270 (N : Node_Id; Val : Boolean) is
8206 begin
8207 pragma Assert (Nkind (N) in N_Entity);
8208 To_Flag_Word5_Ptr
8209 (Union_Id_Ptr'
8210 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag270 := Val;
8211 end Set_Flag270;
8212
8213 procedure Set_Flag271 (N : Node_Id; Val : Boolean) is
8214 begin
8215 pragma Assert (Nkind (N) in N_Entity);
8216 To_Flag_Word5_Ptr
8217 (Union_Id_Ptr'
8218 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag271 := Val;
8219 end Set_Flag271;
8220
8221 procedure Set_Flag272 (N : Node_Id; Val : Boolean) is
8222 begin
8223 pragma Assert (Nkind (N) in N_Entity);
8224 To_Flag_Word5_Ptr
8225 (Union_Id_Ptr'
8226 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag272 := Val;
8227 end Set_Flag272;
8228
8229 procedure Set_Flag273 (N : Node_Id; Val : Boolean) is
8230 begin
8231 pragma Assert (Nkind (N) in N_Entity);
8232 To_Flag_Word5_Ptr
8233 (Union_Id_Ptr'
8234 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag273 := Val;
8235 end Set_Flag273;
8236
8237 procedure Set_Flag274 (N : Node_Id; Val : Boolean) is
8238 begin
8239 pragma Assert (Nkind (N) in N_Entity);
8240 To_Flag_Word5_Ptr
8241 (Union_Id_Ptr'
8242 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag274 := Val;
8243 end Set_Flag274;
8244
8245 procedure Set_Flag275 (N : Node_Id; Val : Boolean) is
8246 begin
8247 pragma Assert (Nkind (N) in N_Entity);
8248 To_Flag_Word5_Ptr
8249 (Union_Id_Ptr'
8250 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag275 := Val;
8251 end Set_Flag275;
8252
8253 procedure Set_Flag276 (N : Node_Id; Val : Boolean) is
8254 begin
8255 pragma Assert (Nkind (N) in N_Entity);
8256 To_Flag_Word5_Ptr
8257 (Union_Id_Ptr'
8258 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag276 := Val;
8259 end Set_Flag276;
8260
8261 procedure Set_Flag277 (N : Node_Id; Val : Boolean) is
8262 begin
8263 pragma Assert (Nkind (N) in N_Entity);
8264 To_Flag_Word5_Ptr
8265 (Union_Id_Ptr'
8266 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag277 := Val;
8267 end Set_Flag277;
8268
8269 procedure Set_Flag278 (N : Node_Id; Val : Boolean) is
8270 begin
8271 pragma Assert (Nkind (N) in N_Entity);
8272 To_Flag_Word5_Ptr
8273 (Union_Id_Ptr'
8274 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag278 := Val;
8275 end Set_Flag278;
8276
8277 procedure Set_Flag279 (N : Node_Id; Val : Boolean) is
8278 begin
8279 pragma Assert (Nkind (N) in N_Entity);
8280 To_Flag_Word5_Ptr
8281 (Union_Id_Ptr'
8282 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag279 := Val;
8283 end Set_Flag279;
8284
8285 procedure Set_Flag280 (N : Node_Id; Val : Boolean) is
8286 begin
8287 pragma Assert (Nkind (N) in N_Entity);
8288 To_Flag_Word5_Ptr
8289 (Union_Id_Ptr'
8290 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag280 := Val;
8291 end Set_Flag280;
8292
8293 procedure Set_Flag281 (N : Node_Id; Val : Boolean) is
8294 begin
8295 pragma Assert (Nkind (N) in N_Entity);
8296 To_Flag_Word5_Ptr
8297 (Union_Id_Ptr'
8298 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag281 := Val;
8299 end Set_Flag281;
8300
8301 procedure Set_Flag282 (N : Node_Id; Val : Boolean) is
8302 begin
8303 pragma Assert (Nkind (N) in N_Entity);
8304 To_Flag_Word5_Ptr
8305 (Union_Id_Ptr'
8306 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag282 := Val;
8307 end Set_Flag282;
8308
8309 procedure Set_Flag283 (N : Node_Id; Val : Boolean) is
8310 begin
8311 pragma Assert (Nkind (N) in N_Entity);
8312 To_Flag_Word5_Ptr
8313 (Union_Id_Ptr'
8314 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag283 := Val;
8315 end Set_Flag283;
8316
8317 procedure Set_Flag284 (N : Node_Id; Val : Boolean) is
8318 begin
8319 pragma Assert (Nkind (N) in N_Entity);
8320 To_Flag_Word5_Ptr
8321 (Union_Id_Ptr'
8322 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag284 := Val;
8323 end Set_Flag284;
8324
8325 procedure Set_Flag285 (N : Node_Id; Val : Boolean) is
8326 begin
8327 pragma Assert (Nkind (N) in N_Entity);
8328 To_Flag_Word5_Ptr
8329 (Union_Id_Ptr'
8330 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag285 := Val;
8331 end Set_Flag285;
8332
8333 procedure Set_Flag286 (N : Node_Id; Val : Boolean) is
8334 begin
8335 pragma Assert (Nkind (N) in N_Entity);
8336 To_Flag_Word5_Ptr
8337 (Union_Id_Ptr'
8338 (Nodes.Table (N + 5).Field12'Unrestricted_Access)).Flag286 := Val;
8339 end Set_Flag286;
8340
8341 procedure Set_Flag287 (N : Node_Id; Val : Boolean) is
8342 begin
8343 pragma Assert (Nkind (N) in N_Entity);
8344 Nodes.Table (N + 5).In_List := Val;
8345 end Set_Flag287;
8346
8347 procedure Set_Flag288 (N : Node_Id; Val : Boolean) is
8348 begin
8349 pragma Assert (Nkind (N) in N_Entity);
8350 Nodes.Table (N + 5).Has_Aspects := Val;
8351 end Set_Flag288;
8352
8353 procedure Set_Flag289 (N : Node_Id; Val : Boolean) is
8354 begin
8355 pragma Assert (Nkind (N) in N_Entity);
8356 Nodes.Table (N + 5).Rewrite_Ins := Val;
8357 end Set_Flag289;
8358
8359 procedure Set_Flag290 (N : Node_Id; Val : Boolean) is
8360 begin
8361 pragma Assert (Nkind (N) in N_Entity);
8362 Nodes.Table (N + 5).Analyzed := Val;
8363 end Set_Flag290;
8364
8365 procedure Set_Flag291 (N : Node_Id; Val : Boolean) is
8366 begin
8367 pragma Assert (Nkind (N) in N_Entity);
8368 Nodes.Table (N + 5).Comes_From_Source := Val;
8369 end Set_Flag291;
8370
8371 procedure Set_Flag292 (N : Node_Id; Val : Boolean) is
8372 begin
8373 pragma Assert (Nkind (N) in N_Entity);
8374 Nodes.Table (N + 5).Error_Posted := Val;
8375 end Set_Flag292;
8376
8377 procedure Set_Flag293 (N : Node_Id; Val : Boolean) is
8378 begin
8379 pragma Assert (Nkind (N) in N_Entity);
8380 Nodes.Table (N + 5).Flag4 := Val;
8381 end Set_Flag293;
8382
8383 procedure Set_Flag294 (N : Node_Id; Val : Boolean) is
8384 begin
8385 pragma Assert (Nkind (N) in N_Entity);
8386 Nodes.Table (N + 5).Flag5 := Val;
8387 end Set_Flag294;
8388
8389 procedure Set_Flag295 (N : Node_Id; Val : Boolean) is
8390 begin
8391 pragma Assert (Nkind (N) in N_Entity);
8392 Nodes.Table (N + 5).Flag6 := Val;
8393 end Set_Flag295;
8394
8395 procedure Set_Flag296 (N : Node_Id; Val : Boolean) is
8396 begin
8397 pragma Assert (Nkind (N) in N_Entity);
8398 Nodes.Table (N + 5).Flag7 := Val;
8399 end Set_Flag296;
8400
8401 procedure Set_Flag297 (N : Node_Id; Val : Boolean) is
8402 begin
8403 pragma Assert (Nkind (N) in N_Entity);
8404 Nodes.Table (N + 5).Flag8 := Val;
8405 end Set_Flag297;
8406
8407 procedure Set_Flag298 (N : Node_Id; Val : Boolean) is
8408 begin
8409 pragma Assert (Nkind (N) in N_Entity);
8410 Nodes.Table (N + 5).Flag9 := Val;
8411 end Set_Flag298;
8412
8413 procedure Set_Flag299 (N : Node_Id; Val : Boolean) is
8414 begin
8415 pragma Assert (Nkind (N) in N_Entity);
8416 Nodes.Table (N + 5).Flag10 := Val;
8417 end Set_Flag299;
8418
8419 procedure Set_Flag300 (N : Node_Id; Val : Boolean) is
8420 begin
8421 pragma Assert (Nkind (N) in N_Entity);
8422 Nodes.Table (N + 5).Flag11 := Val;
8423 end Set_Flag300;
8424
8425 procedure Set_Flag301 (N : Node_Id; Val : Boolean) is
8426 begin
8427 pragma Assert (Nkind (N) in N_Entity);
8428 Nodes.Table (N + 5).Flag12 := Val;
8429 end Set_Flag301;
8430
8431 procedure Set_Flag302 (N : Node_Id; Val : Boolean) is
8432 begin
8433 pragma Assert (Nkind (N) in N_Entity);
8434 Nodes.Table (N + 5).Flag13 := Val;
8435 end Set_Flag302;
8436
8437 procedure Set_Flag303 (N : Node_Id; Val : Boolean) is
8438 begin
8439 pragma Assert (Nkind (N) in N_Entity);
8440 Nodes.Table (N + 5).Flag14 := Val;
8441 end Set_Flag303;
8442
8443 procedure Set_Flag304 (N : Node_Id; Val : Boolean) is
8444 begin
8445 pragma Assert (Nkind (N) in N_Entity);
8446 Nodes.Table (N + 5).Flag15 := Val;
8447 end Set_Flag304;
8448
8449 procedure Set_Flag305 (N : Node_Id; Val : Boolean) is
8450 begin
8451 pragma Assert (Nkind (N) in N_Entity);
8452 Nodes.Table (N + 5).Flag16 := Val;
8453 end Set_Flag305;
8454
8455 procedure Set_Flag306 (N : Node_Id; Val : Boolean) is
8456 begin
8457 pragma Assert (Nkind (N) in N_Entity);
8458 Nodes.Table (N + 5).Flag17 := Val;
8459 end Set_Flag306;
8460
8461 procedure Set_Flag307 (N : Node_Id; Val : Boolean) is
8462 begin
8463 pragma Assert (Nkind (N) in N_Entity);
8464 Nodes.Table (N + 5).Flag18 := Val;
8465 end Set_Flag307;
8466
8467 procedure Set_Flag308 (N : Node_Id; Val : Boolean) is
8468 begin
8469 pragma Assert (Nkind (N) in N_Entity);
8470 Nodes.Table (N + 5).Pflag1 := Val;
8471 end Set_Flag308;
8472
8473 procedure Set_Flag309 (N : Node_Id; Val : Boolean) is
8474 begin
8475 pragma Assert (Nkind (N) in N_Entity);
8476 Nodes.Table (N + 5).Pflag2 := Val;
8477 end Set_Flag309;
8478
8479 procedure Set_Flag310 (N : Node_Id; Val : Boolean) is
8480 begin
8481 pragma Assert (Nkind (N) in N_Entity);
8482 To_Flag_Byte4_Ptr
8483 (Node_Kind_Ptr'
8484 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag310 := Val;
8485 end Set_Flag310;
8486
8487 procedure Set_Flag311 (N : Node_Id; Val : Boolean) is
8488 begin
8489 pragma Assert (Nkind (N) in N_Entity);
8490 To_Flag_Byte4_Ptr
8491 (Node_Kind_Ptr'
8492 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag311 := Val;
8493 end Set_Flag311;
8494
8495 procedure Set_Flag312 (N : Node_Id; Val : Boolean) is
8496 begin
8497 pragma Assert (Nkind (N) in N_Entity);
8498 To_Flag_Byte4_Ptr
8499 (Node_Kind_Ptr'
8500 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag312 := Val;
8501 end Set_Flag312;
8502
8503 procedure Set_Flag313 (N : Node_Id; Val : Boolean) is
8504 begin
8505 pragma Assert (Nkind (N) in N_Entity);
8506 To_Flag_Byte4_Ptr
8507 (Node_Kind_Ptr'
8508 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag313 := Val;
8509 end Set_Flag313;
8510
8511 procedure Set_Flag314 (N : Node_Id; Val : Boolean) is
8512 begin
8513 pragma Assert (Nkind (N) in N_Entity);
8514 To_Flag_Byte4_Ptr
8515 (Node_Kind_Ptr'
8516 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag314 := Val;
8517 end Set_Flag314;
8518
8519 procedure Set_Flag315 (N : Node_Id; Val : Boolean) is
8520 begin
8521 pragma Assert (Nkind (N) in N_Entity);
8522 To_Flag_Byte4_Ptr
8523 (Node_Kind_Ptr'
8524 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag315 := Val;
8525 end Set_Flag315;
8526
8527 procedure Set_Flag316 (N : Node_Id; Val : Boolean) is
8528 begin
8529 pragma Assert (Nkind (N) in N_Entity);
8530 To_Flag_Byte4_Ptr
8531 (Node_Kind_Ptr'
8532 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag316 := Val;
8533 end Set_Flag316;
8534
8535 procedure Set_Flag317 (N : Node_Id; Val : Boolean) is
8536 begin
8537 pragma Assert (Nkind (N) in N_Entity);
8538 To_Flag_Byte4_Ptr
8539 (Node_Kind_Ptr'
8540 (Nodes.Table (N + 5).Nkind'Unrestricted_Access)).Flag317 := Val;
8541 end Set_Flag317;
8542
8543 procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is
8544 begin
8545 pragma Assert (N <= Nodes.Last);
8546
8547 if Val > Error then
8548 Set_Parent (N => Val, Val => N);
8549 end if;
8550
8551 Set_Node1 (N, Val);
8552 end Set_Node1_With_Parent;
8553
8554 procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is
8555 begin
8556 pragma Assert (N <= Nodes.Last);
8557
8558 if Val > Error then
8559 Set_Parent (N => Val, Val => N);
8560 end if;
8561
8562 Set_Node2 (N, Val);
8563 end Set_Node2_With_Parent;
8564
8565 procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is
8566 begin
8567 pragma Assert (N <= Nodes.Last);
8568
8569 if Val > Error then
8570 Set_Parent (N => Val, Val => N);
8571 end if;
8572
8573 Set_Node3 (N, Val);
8574 end Set_Node3_With_Parent;
8575
8576 procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is
8577 begin
8578 pragma Assert (N <= Nodes.Last);
8579
8580 if Val > Error then
8581 Set_Parent (N => Val, Val => N);
8582 end if;
8583
8584 Set_Node4 (N, Val);
8585 end Set_Node4_With_Parent;
8586
8587 procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
8588 begin
8589 pragma Assert (N <= Nodes.Last);
8590
8591 if Val > Error then
8592 Set_Parent (N => Val, Val => N);
8593 end if;
8594
8595 Set_Node5 (N, Val);
8596 end Set_Node5_With_Parent;
8597
8598 procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
8599 begin
8600 pragma Assert (N <= Nodes.Last);
8601 if Val /= No_List and then Val /= Error_List then
8602 Set_Parent (Val, N);
8603 end if;
8604 Set_List1 (N, Val);
8605 end Set_List1_With_Parent;
8606
8607 procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
8608 begin
8609 pragma Assert (N <= Nodes.Last);
8610 if Val /= No_List and then Val /= Error_List then
8611 Set_Parent (Val, N);
8612 end if;
8613 Set_List2 (N, Val);
8614 end Set_List2_With_Parent;
8615
8616 procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
8617 begin
8618 pragma Assert (N <= Nodes.Last);
8619 if Val /= No_List and then Val /= Error_List then
8620 Set_Parent (Val, N);
8621 end if;
8622 Set_List3 (N, Val);
8623 end Set_List3_With_Parent;
8624
8625 procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
8626 begin
8627 pragma Assert (N <= Nodes.Last);
8628 if Val /= No_List and then Val /= Error_List then
8629 Set_Parent (Val, N);
8630 end if;
8631 Set_List4 (N, Val);
8632 end Set_List4_With_Parent;
8633
8634 procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
8635 begin
8636 pragma Assert (N <= Nodes.Last);
8637 if Val /= No_List and then Val /= Error_List then
8638 Set_Parent (Val, N);
8639 end if;
8640 Set_List5 (N, Val);
8641 end Set_List5_With_Parent;
8642
8643 end Unchecked_Access;
8644
8645 ------------
8646 -- Unlock --
8647 ------------
8648
8649 procedure Unlock is
8650 begin
8651 Nodes.Locked := False;
8652 Flags.Locked := False;
8653 Orig_Nodes.Locked := False;
8654 end Unlock;
8655
8656 end Atree;