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