1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2010, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 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. --
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. --
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/>. --
27 -- GNAT was originally developed by the GNAT team at New York University. --
28 -- Extensive contributions were provided by Ada Core Technologies Inc. --
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 Debug; use Debug;
40 with Nlists; use Nlists;
42 with Output; use Output;
43 with Sinput; use Sinput;
44 with SCIL_LL; use SCIL_LL;
45 with Tree_IO; use Tree_IO;
53 -- Suppose you find that node 12345 is messed up. You might want to find
54 -- the code that created that node. There are two ways to do this:
56 -- One way is to set a conditional breakpoint on New_Node_Debugging_Output
58 -- break nnd if n = 12345
59 -- and run gnat1 again from the beginning.
61 -- The other way is to set a breakpoint near the beginning (e.g. on
62 -- gnat1drv), and run. Then set Watch_Node (nickname "ww") to 12345 in gdb:
64 -- and set a breakpoint on New_Node_Breakpoint (nickname "nn"). Continue.
66 -- Either way, gnat1 will stop when node 12345 is created
68 -- The second method is much faster
70 -- Similarly, rr and rrd allow breaking on rewriting of a given node
72 ww : Node_Id'Base := Node_Id'First - 1;
73 pragma Export (Ada, ww); -- trick the optimizer
74 Watch_Node : Node_Id'Base renames ww;
75 -- Node to "watch"; that is, whenever a node is created, we check if it
76 -- is equal to Watch_Node, and if so, call New_Node_Breakpoint. You have
77 -- presumably set a breakpoint on New_Node_Breakpoint. Note that the
78 -- initial value of Node_Id'First - 1 ensures that by default, no node
79 -- will be equal to Watch_Node.
82 pragma Export (Ada, nn);
83 procedure New_Node_Breakpoint renames nn;
84 -- This doesn't do anything interesting; it's just for setting breakpoint
85 -- on as explained above.
87 procedure nnd (N : Node_Id);
88 pragma Export (Ada, nnd);
89 procedure New_Node_Debugging_Output (N : Node_Id) renames nnd;
90 -- For debugging. If debugging is turned on, New_Node and New_Entity call
91 -- this. If debug flag N is turned on, this prints out the new node.
93 -- If Node = Watch_Node, this prints out the new node and calls
94 -- New_Node_Breakpoint. Otherwise, does nothing.
97 pragma Export (Ada, rr);
98 procedure Rewrite_Breakpoint renames rr;
99 -- This doesn't do anything interesting; it's just for setting breakpoint
100 -- on as explained above.
102 procedure rrd (Old_Node, New_Node : Node_Id);
103 pragma Export (Ada, rrd);
104 procedure Rewrite_Debugging_Output
105 (Old_Node, New_Node : Node_Id) renames rrd;
106 -- For debugging. If debugging is turned on, Rewrite calls this. If debug
107 -- flag N is turned on, this prints out the new node.
109 -- If Old_Node = Watch_Node, this prints out the old and new nodes and
110 -- calls Rewrite_Breakpoint. Otherwise, does nothing.
112 procedure Node_Debug_Output (Op : String; N : Node_Id);
113 -- Common code for nnd and rrd, writes Op followed by information about N
115 -----------------------------
116 -- Local Objects and Types --
117 -----------------------------
120 -- Count allocated nodes for Num_Nodes function
122 use Unchecked_Access;
123 -- We are allowed to see these from within our own body!
125 use Atree_Private_Part;
126 -- We are also allowed to see our private data structures!
128 -- Functions used to store Entity_Kind value in Nkind field
130 -- The following declarations are used to store flags 65-72 in the
131 -- Nkind field of the third component of an extended (entity) node.
133 type Flag_Byte is record
144 pragma Pack (Flag_Byte);
145 for Flag_Byte'Size use 8;
147 type Flag_Byte_Ptr is access all Flag_Byte;
148 type Node_Kind_Ptr is access all Node_Kind;
150 function To_Flag_Byte is new
151 Unchecked_Conversion (Node_Kind, Flag_Byte);
153 function To_Flag_Byte_Ptr is new
154 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);
156 -- The following declarations are used to store flags 73-96 and the
157 -- Convention field in the Field12 field of the third component of an
158 -- extended (Entity) node.
160 type Flag_Word is record
188 Convention : Convention_Id;
191 pragma Pack (Flag_Word);
192 for Flag_Word'Size use 32;
193 for Flag_Word'Alignment use 4;
195 type Flag_Word_Ptr is access all Flag_Word;
196 type Union_Id_Ptr is access all Union_Id;
198 function To_Flag_Word is new
199 Unchecked_Conversion (Union_Id, Flag_Word);
201 function To_Flag_Word_Ptr is new
202 Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr);
204 -- The following declarations are used to store flags 97-128 in the
205 -- Field12 field of the fourth component of an extended (entity) node.
207 type Flag_Word2 is record
245 pragma Pack (Flag_Word2);
246 for Flag_Word2'Size use 32;
247 for Flag_Word2'Alignment use 4;
249 type Flag_Word2_Ptr is access all Flag_Word2;
251 function To_Flag_Word2 is new
252 Unchecked_Conversion (Union_Id, Flag_Word2);
254 function To_Flag_Word2_Ptr is new
255 Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr);
257 -- The following declarations are used to store flags 152-183 in the
258 -- Field11 field of the fourth component of an extended (entity) node.
260 type Flag_Word3 is record
298 pragma Pack (Flag_Word3);
299 for Flag_Word3'Size use 32;
300 for Flag_Word3'Alignment use 4;
302 type Flag_Word3_Ptr is access all Flag_Word3;
304 function To_Flag_Word3 is new
305 Unchecked_Conversion (Union_Id, Flag_Word3);
307 function To_Flag_Word3_Ptr is new
308 Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr);
310 -- The following declarations are used to store flags 184-215 in the
311 -- Field11 field of the fifth component of an extended (entity) node.
313 type Flag_Word4 is record
351 pragma Pack (Flag_Word4);
352 for Flag_Word4'Size use 32;
353 for Flag_Word4'Alignment use 4;
355 type Flag_Word4_Ptr is access all Flag_Word4;
357 function To_Flag_Word4 is new
358 Unchecked_Conversion (Union_Id, Flag_Word4);
360 function To_Flag_Word4_Ptr is new
361 Unchecked_Conversion (Union_Id_Ptr, Flag_Word4_Ptr);
363 -- The following declarations are used to store flags 216-247 in the
364 -- Field12 field of the fifth component of an extended (entity) node.
366 type Flag_Word5 is record
404 pragma Pack (Flag_Word5);
405 for Flag_Word5'Size use 32;
406 for Flag_Word5'Alignment use 4;
408 type Flag_Word5_Ptr is access all Flag_Word5;
410 function To_Flag_Word5 is new
411 Unchecked_Conversion (Union_Id, Flag_Word5);
413 function To_Flag_Word5_Ptr is new
414 Unchecked_Conversion (Union_Id_Ptr, Flag_Word5_Ptr);
416 --------------------------------------------------
417 -- Implementation of Tree Substitution Routines --
418 --------------------------------------------------
420 -- A separate table keeps track of the mapping between rewritten nodes
421 -- and their corresponding original tree nodes. Rewrite makes an entry
422 -- in this table for use by Original_Node. By default, if no call is
423 -- Rewrite, the entry in this table points to the original unwritten node.
425 -- Note: eventually, this should be a field in the Node directly, but
426 -- for now we do not want to disturb the efficiency of a power of 2
429 package Orig_Nodes is new Table.Table (
430 Table_Component_Type => Node_Id,
431 Table_Index_Type => Node_Id'Base,
432 Table_Low_Bound => First_Node_Id,
433 Table_Initial => Alloc.Orig_Nodes_Initial,
434 Table_Increment => Alloc.Orig_Nodes_Increment,
435 Table_Name => "Orig_Nodes");
437 --------------------------
438 -- Paren_Count Handling --
439 --------------------------
441 -- As noted in the spec, the paren count in a sub-expression node has
442 -- four possible values 0,1,2, and 3. The value 3 really means 3 or more,
443 -- and we use an auxiliary serially scanned table to record the actual
444 -- count. A serial search is fine, only pathological programs will use
445 -- entries in this table. Normal programs won't use it at all.
447 type Paren_Count_Entry is record
449 -- The node to which this count applies
451 Count : Nat range 3 .. Nat'Last;
452 -- The count of parentheses, which will be in the indicated range
455 package Paren_Counts is new Table.Table (
456 Table_Component_Type => Paren_Count_Entry,
457 Table_Index_Type => Int,
458 Table_Low_Bound => 0,
460 Table_Increment => 200,
461 Table_Name => "Paren_Counts");
463 -----------------------
464 -- Local Subprograms --
465 -----------------------
467 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id);
468 -- Fixup parent pointers for the syntactic children of Fix_Node after
469 -- a copy, setting them to Fix_Node when they pointed to Ref_Node.
471 function Allocate_Initialize_Node
473 With_Extension : Boolean) return Node_Id;
474 -- Allocate a new node or node extension. If Src is not empty,
475 -- the information for the newly-allocated node is copied from it.
477 ------------------------------
478 -- Allocate_Initialize_Node --
479 ------------------------------
481 function Allocate_Initialize_Node
483 With_Extension : Boolean) return Node_Id
485 New_Id : Node_Id := Src;
486 Nod : Node_Record := Default_Node;
487 Ext1 : Node_Record := Default_Node_Extension;
488 Ext2 : Node_Record := Default_Node_Extension;
489 Ext3 : Node_Record := Default_Node_Extension;
490 Ext4 : Node_Record := Default_Node_Extension;
493 if Present (Src) then
494 Nod := Nodes.Table (Src);
496 if Has_Extension (Src) then
497 Ext1 := Nodes.Table (Src + 1);
498 Ext2 := Nodes.Table (Src + 2);
499 Ext3 := Nodes.Table (Src + 3);
500 Ext4 := Nodes.Table (Src + 4);
504 if not (Present (Src)
505 and then not Has_Extension (Src)
506 and then With_Extension
507 and then Src = Nodes.Last)
509 -- We are allocating a new node, or extending a node
510 -- other than Nodes.Last.
513 New_Id := Nodes.Last;
514 Orig_Nodes.Append (New_Id);
515 Node_Count := Node_Count + 1;
518 -- Specifically copy Paren_Count to deal with creating new table entry
519 -- if the parentheses count is at the maximum possible value already.
521 if Present (Src) and then Nkind (Src) in N_Subexpr then
522 Set_Paren_Count (New_Id, Paren_Count (Src));
525 -- Set extension nodes if required
527 if With_Extension then
534 Orig_Nodes.Set_Last (Nodes.Last);
535 Allocate_List_Tables (Nodes.Last);
537 -- Update the SCIL_Node field (if available)
539 if Generate_SCIL then
540 Set_SCIL_Node (New_Id, Get_SCIL_Node (Src));
544 end Allocate_Initialize_Node;
550 function Analyzed (N : Node_Id) return Boolean is
552 pragma Assert (N <= Nodes.Last);
553 return Nodes.Table (N).Analyzed;
556 --------------------------
557 -- Basic_Set_Convention --
558 --------------------------
560 procedure Basic_Set_Convention (E : Entity_Id; Val : Convention_Id) is
562 pragma Assert (Nkind (E) in N_Entity);
565 (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention := Val;
566 end Basic_Set_Convention;
572 procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is
573 Save_Sloc : constant Source_Ptr := Sloc (N);
574 Save_In_List : constant Boolean := Nodes.Table (N).In_List;
575 Save_Link : constant Union_Id := Nodes.Table (N).Link;
576 Save_CFS : constant Boolean := Nodes.Table (N).Comes_From_Source;
577 Save_Posted : constant Boolean := Nodes.Table (N).Error_Posted;
578 Par_Count : Nat := 0;
581 if Nkind (N) in N_Subexpr then
582 Par_Count := Paren_Count (N);
585 Nodes.Table (N) := Default_Node;
586 Nodes.Table (N).Sloc := Save_Sloc;
587 Nodes.Table (N).In_List := Save_In_List;
588 Nodes.Table (N).Link := Save_Link;
589 Nodes.Table (N).Comes_From_Source := Save_CFS;
590 Nodes.Table (N).Nkind := New_Node_Kind;
591 Nodes.Table (N).Error_Posted := Save_Posted;
593 if New_Node_Kind in N_Subexpr then
594 Set_Paren_Count (N, Par_Count);
598 -----------------------
599 -- Comes_From_Source --
600 -----------------------
602 function Comes_From_Source (N : Node_Id) return Boolean is
604 pragma Assert (N <= Nodes.Last);
605 return Nodes.Table (N).Comes_From_Source;
606 end Comes_From_Source;
612 function Convention (E : Entity_Id) return Convention_Id is
614 pragma Assert (Nkind (E) in N_Entity);
615 return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention;
622 procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is
623 Save_In_List : constant Boolean := Nodes.Table (Destination).In_List;
624 Save_Link : constant Union_Id := Nodes.Table (Destination).Link;
627 Nodes.Table (Destination) := Nodes.Table (Source);
628 Nodes.Table (Destination).In_List := Save_In_List;
629 Nodes.Table (Destination).Link := Save_Link;
631 -- Specifically set Paren_Count to make sure auxiliary table entry
632 -- gets correctly made if the parentheses count is at the max value.
634 if Nkind (Destination) in N_Subexpr then
635 Set_Paren_Count (Destination, Paren_Count (Source));
638 -- Deal with copying extension nodes if present
640 if Has_Extension (Source) then
641 pragma Assert (Has_Extension (Destination));
642 Nodes.Table (Destination + 1) := Nodes.Table (Source + 1);
643 Nodes.Table (Destination + 2) := Nodes.Table (Source + 2);
644 Nodes.Table (Destination + 3) := Nodes.Table (Source + 3);
645 Nodes.Table (Destination + 4) := Nodes.Table (Source + 4);
648 pragma Assert (not Has_Extension (Source));
653 ------------------------
654 -- Copy_Separate_Tree --
655 ------------------------
657 function Copy_Separate_Tree (Source : Node_Id) return Node_Id is
660 function Copy_Entity (E : Entity_Id) return Entity_Id;
661 -- Copy Entity, copying only the Ekind and Chars fields
663 function Copy_List (List : List_Id) return List_Id;
666 function Possible_Copy (Field : Union_Id) return Union_Id;
667 -- Given a field, returns a copy of the node or list if its parent
668 -- is the current source node, and otherwise returns the input
674 function Copy_Entity (E : Entity_Id) return Entity_Id is
678 case N_Entity (Nkind (E)) is
679 when N_Defining_Identifier =>
680 New_Ent := New_Entity (N_Defining_Identifier, Sloc (E));
682 when N_Defining_Character_Literal =>
683 New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E));
685 when N_Defining_Operator_Symbol =>
686 New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E));
689 Set_Chars (New_Ent, Chars (E));
697 function Copy_List (List : List_Id) return List_Id is
702 if List = No_List then
709 while Present (E) loop
710 if Has_Extension (E) then
711 Append (Copy_Entity (E), NL);
713 Append (Copy_Separate_Tree (E), NL);
727 function Possible_Copy (Field : Union_Id) return Union_Id is
731 if Field in Node_Range then
732 New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field)));
734 if Parent (Node_Id (Field)) = Source then
735 Set_Parent (Node_Id (New_N), New_Id);
740 elsif Field in List_Range then
741 New_N := Union_Id (Copy_List (List_Id (Field)));
743 if Parent (List_Id (Field)) = Source then
744 Set_Parent (List_Id (New_N), New_Id);
754 -- Start of processing for Copy_Separate_Tree
757 if Source <= Empty_Or_Error then
760 elsif Has_Extension (Source) then
761 return Copy_Entity (Source);
764 New_Id := New_Copy (Source);
766 -- Recursively copy descendents
768 Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id)));
769 Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id)));
770 Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id)));
771 Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id)));
772 Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id)));
774 -- Set Entity field to Empty
775 -- Why is this done??? and why is it always right to do it???
777 if Nkind (New_Id) in N_Has_Entity
778 or else Nkind (New_Id) = N_Freeze_Entity
780 Set_Entity (New_Id, Empty);
783 -- All done, return copied node
787 end Copy_Separate_Tree;
793 function Ekind (E : Entity_Id) return Entity_Kind is
795 pragma Assert (Nkind (E) in N_Entity);
796 return N_To_E (Nodes.Table (E + 1).Nkind);
806 V2 : Entity_Kind) return Boolean
809 return T = V1 or else
817 V3 : Entity_Kind) return Boolean
820 return T = V1 or else
830 V4 : Entity_Kind) return Boolean
833 return T = V1 or else
845 V5 : Entity_Kind) return Boolean
848 return T = V1 or else
862 V6 : Entity_Kind) return Boolean
865 return T = V1 or else
876 V2 : Entity_Kind) return Boolean
879 return Ekind_In (Ekind (E), V1, V2);
886 V3 : Entity_Kind) return Boolean
889 return Ekind_In (Ekind (E), V1, V2, V3);
897 V4 : Entity_Kind) return Boolean
900 return Ekind_In (Ekind (E), V1, V2, V3, V4);
909 V5 : Entity_Kind) return Boolean
912 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5);
922 V6 : Entity_Kind) return Boolean
925 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6);
932 function Error_Posted (N : Node_Id) return Boolean is
934 pragma Assert (N <= Nodes.Last);
935 return Nodes.Table (N).Error_Posted;
938 -----------------------
939 -- Exchange_Entities --
940 -----------------------
942 procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is
943 Temp_Ent : Node_Record;
946 pragma Assert (Has_Extension (E1)
947 and then Has_Extension (E2)
948 and then not Nodes.Table (E1).In_List
949 and then not Nodes.Table (E2).In_List);
951 -- Exchange the contents of the two entities
953 Temp_Ent := Nodes.Table (E1);
954 Nodes.Table (E1) := Nodes.Table (E2);
955 Nodes.Table (E2) := Temp_Ent;
956 Temp_Ent := Nodes.Table (E1 + 1);
957 Nodes.Table (E1 + 1) := Nodes.Table (E2 + 1);
958 Nodes.Table (E2 + 1) := Temp_Ent;
959 Temp_Ent := Nodes.Table (E1 + 2);
960 Nodes.Table (E1 + 2) := Nodes.Table (E2 + 2);
961 Nodes.Table (E2 + 2) := Temp_Ent;
962 Temp_Ent := Nodes.Table (E1 + 3);
963 Nodes.Table (E1 + 3) := Nodes.Table (E2 + 3);
964 Nodes.Table (E2 + 3) := Temp_Ent;
965 Temp_Ent := Nodes.Table (E1 + 4);
966 Nodes.Table (E1 + 4) := Nodes.Table (E2 + 4);
967 Nodes.Table (E2 + 4) := Temp_Ent;
969 -- That exchange exchanged the parent pointers as well, which is what
970 -- we want, but we need to patch up the defining identifier pointers
971 -- in the parent nodes (the child pointers) to match this switch
972 -- unless for Implicit types entities which have no parent, in which
973 -- case we don't do anything otherwise we won't be able to revert back
974 -- to the original situation.
976 -- Shouldn't this use Is_Itype instead of the Parent test
978 if Present (Parent (E1)) and then Present (Parent (E2)) then
979 Set_Defining_Identifier (Parent (E1), E1);
980 Set_Defining_Identifier (Parent (E2), E2);
982 end Exchange_Entities;
988 function Extend_Node (Node : Node_Id) return Entity_Id is
991 procedure Debug_Extend_Node;
992 pragma Inline (Debug_Extend_Node);
993 -- Debug routine for debug flag N
995 -----------------------
996 -- Debug_Extend_Node --
997 -----------------------
999 procedure Debug_Extend_Node is
1001 if Debug_Flag_N then
1002 Write_Str ("Extend node ");
1003 Write_Int (Int (Node));
1005 if Result = Node then
1006 Write_Str (" in place");
1008 Write_Str (" copied to ");
1009 Write_Int (Int (Result));
1014 end Debug_Extend_Node;
1016 -- Start of processing for Extend_Node
1019 pragma Assert (not (Has_Extension (Node)));
1020 Result := Allocate_Initialize_Node (Node, With_Extension => True);
1021 pragma Debug (Debug_Extend_Node);
1029 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id) is
1031 procedure Fix_Parent (Field : Union_Id);
1032 -- Fixup one parent pointer. Field is checked to see if it points to
1033 -- a node, list, or element list that has a parent that points to
1034 -- Ref_Node. If so, the parent is reset to point to Fix_Node.
1040 procedure Fix_Parent (Field : Union_Id) is
1042 -- Fix parent of node that is referenced by Field. Note that we must
1043 -- exclude the case where the node is a member of a list, because in
1044 -- this case the parent is the parent of the list.
1046 if Field in Node_Range
1047 and then Present (Node_Id (Field))
1048 and then not Nodes.Table (Node_Id (Field)).In_List
1049 and then Parent (Node_Id (Field)) = Ref_Node
1051 Set_Parent (Node_Id (Field), Fix_Node);
1053 -- Fix parent of list that is referenced by Field
1055 elsif Field in List_Range
1056 and then Present (List_Id (Field))
1057 and then Parent (List_Id (Field)) = Ref_Node
1059 Set_Parent (List_Id (Field), Fix_Node);
1063 -- Start of processing for Fix_Parents
1066 Fix_Parent (Field1 (Fix_Node));
1067 Fix_Parent (Field2 (Fix_Node));
1068 Fix_Parent (Field3 (Fix_Node));
1069 Fix_Parent (Field4 (Fix_Node));
1070 Fix_Parent (Field5 (Fix_Node));
1073 -----------------------------------
1074 -- Get_Comes_From_Source_Default --
1075 -----------------------------------
1077 function Get_Comes_From_Source_Default return Boolean is
1079 return Default_Node.Comes_From_Source;
1080 end Get_Comes_From_Source_Default;
1086 function Has_Extension (N : Node_Id) return Boolean is
1088 return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension;
1095 procedure Initialize is
1097 pragma Warnings (Off, Dummy);
1101 Atree_Private_Part.Nodes.Init;
1105 -- Allocate Empty node
1107 Dummy := New_Node (N_Empty, No_Location);
1108 Set_Name1 (Empty, No_Name);
1110 -- Allocate Error node, and set Error_Posted, since we certainly
1111 -- only generate an Error node if we do post some kind of error!
1113 Dummy := New_Node (N_Error, No_Location);
1114 Set_Name1 (Error, Error_Name);
1115 Set_Error_Posted (Error, True);
1118 --------------------------
1119 -- Is_Rewrite_Insertion --
1120 --------------------------
1122 function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is
1124 return Nodes.Table (Node).Rewrite_Ins;
1125 end Is_Rewrite_Insertion;
1127 -----------------------------
1128 -- Is_Rewrite_Substitution --
1129 -----------------------------
1131 function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is
1133 return Orig_Nodes.Table (Node) /= Node;
1134 end Is_Rewrite_Substitution;
1140 function Last_Node_Id return Node_Id is
1151 Nodes.Locked := True;
1152 Orig_Nodes.Locked := True;
1157 ----------------------------
1158 -- Mark_Rewrite_Insertion --
1159 ----------------------------
1161 procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is
1163 Nodes.Table (New_Node).Rewrite_Ins := True;
1164 end Mark_Rewrite_Insertion;
1170 function New_Copy (Source : Node_Id) return Node_Id is
1171 New_Id : Node_Id := Source;
1174 if Source > Empty_Or_Error then
1176 New_Id := Allocate_Initialize_Node (Source, Has_Extension (Source));
1178 Nodes.Table (New_Id).Link := Empty_List_Or_Node;
1179 Nodes.Table (New_Id).In_List := False;
1181 -- If the original is marked as a rewrite insertion, then unmark
1182 -- the copy, since we inserted the original, not the copy.
1184 Nodes.Table (New_Id).Rewrite_Ins := False;
1185 pragma Debug (New_Node_Debugging_Output (New_Id));
1196 (New_Node_Kind : Node_Kind;
1197 New_Sloc : Source_Ptr) return Entity_Id
1202 pragma Assert (New_Node_Kind in N_Entity);
1204 Ent := Allocate_Initialize_Node (Empty, With_Extension => True);
1206 -- If this is a node with a real location and we are generating
1207 -- source nodes, then reset Current_Error_Node. This is useful
1208 -- if we bomb during parsing to get a error location for the bomb.
1210 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1211 Current_Error_Node := Ent;
1214 Nodes.Table (Ent).Nkind := New_Node_Kind;
1215 Nodes.Table (Ent).Sloc := New_Sloc;
1216 pragma Debug (New_Node_Debugging_Output (Ent));
1226 (New_Node_Kind : Node_Kind;
1227 New_Sloc : Source_Ptr) return Node_Id
1232 pragma Assert (New_Node_Kind not in N_Entity);
1233 Nod := Allocate_Initialize_Node (Empty, With_Extension => False);
1234 Nodes.Table (Nod).Nkind := New_Node_Kind;
1235 Nodes.Table (Nod).Sloc := New_Sloc;
1236 pragma Debug (New_Node_Debugging_Output (Nod));
1238 -- If this is a node with a real location and we are generating source
1239 -- nodes, then reset Current_Error_Node. This is useful if we bomb
1240 -- during parsing to get an error location for the bomb.
1242 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1243 Current_Error_Node := Nod;
1249 -------------------------
1250 -- New_Node_Breakpoint --
1251 -------------------------
1253 procedure nn is -- New_Node_Breakpoint
1255 Write_Str ("Watched node ");
1256 Write_Int (Int (Watch_Node));
1257 Write_Str (" created");
1261 -------------------------------
1262 -- New_Node_Debugging_Output --
1263 -------------------------------
1265 procedure nnd (N : Node_Id) is -- New_Node_Debugging_Output
1266 Node_Is_Watched : constant Boolean := N = Watch_Node;
1269 if Debug_Flag_N or else Node_Is_Watched then
1270 Node_Debug_Output ("Allocate", N);
1272 if Node_Is_Watched then
1273 New_Node_Breakpoint;
1282 function Nkind (N : Node_Id) return Node_Kind is
1284 return Nodes.Table (N).Nkind;
1294 V2 : Node_Kind) return Boolean
1297 return Nkind_In (Nkind (N), V1, V2);
1304 V3 : Node_Kind) return Boolean
1307 return Nkind_In (Nkind (N), V1, V2, V3);
1315 V4 : Node_Kind) return Boolean
1318 return Nkind_In (Nkind (N), V1, V2, V3, V4);
1327 V5 : Node_Kind) return Boolean
1330 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5);
1340 V6 : Node_Kind) return Boolean
1343 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6);
1354 V7 : Node_Kind) return Boolean
1357 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7);
1369 V8 : Node_Kind) return Boolean
1372 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8);
1385 V9 : Node_Kind) return Boolean
1388 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8, V9);
1395 function No (N : Node_Id) return Boolean is
1400 -----------------------
1401 -- Node_Debug_Output --
1402 -----------------------
1404 procedure Node_Debug_Output (Op : String; N : Node_Id) is
1408 if Nkind (N) in N_Entity then
1409 Write_Str (" entity");
1411 Write_Str (" node");
1414 Write_Str (" Id = ");
1415 Write_Int (Int (N));
1417 Write_Location (Sloc (N));
1419 Write_Str (Node_Kind'Image (Nkind (N)));
1421 end Node_Debug_Output;
1427 function Nodes_Address return System.Address is
1429 return Nodes.Table (First_Node_Id)'Address;
1436 function Num_Nodes return Nat is
1445 function Original_Node (Node : Node_Id) return Node_Id is
1447 return Orig_Nodes.Table (Node);
1454 function Paren_Count (N : Node_Id) return Nat is
1458 pragma Assert (N <= Nodes.Last);
1460 if Nodes.Table (N).Pflag1 then
1464 if Nodes.Table (N).Pflag2 then
1468 -- Value of 0,1,2 returned as is
1473 -- Value of 3 means we search the table, and we must find an entry
1476 for J in Paren_Counts.First .. Paren_Counts.Last loop
1477 if N = Paren_Counts.Table (J).Nod then
1478 return Paren_Counts.Table (J).Count;
1482 raise Program_Error;
1490 function Parent (N : Node_Id) return Node_Id is
1492 if Is_List_Member (N) then
1493 return Parent (List_Containing (N));
1495 return Node_Id (Nodes.Table (N).Link);
1503 function Present (N : Node_Id) return Boolean is
1508 --------------------------------
1509 -- Preserve_Comes_From_Source --
1510 --------------------------------
1512 procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is
1514 Nodes.Table (NewN).Comes_From_Source :=
1515 Nodes.Table (OldN).Comes_From_Source;
1516 end Preserve_Comes_From_Source;
1522 function Relocate_Node (Source : Node_Id) return Node_Id is
1530 New_Node := New_Copy (Source);
1531 Fix_Parents (Ref_Node => Source, Fix_Node => New_Node);
1533 -- We now set the parent of the new node to be the same as the
1534 -- parent of the source. Almost always this parent will be
1535 -- replaced by a new value when the relocated node is reattached
1536 -- to the tree, but by doing it now, we ensure that this node is
1537 -- not even temporarily disconnected from the tree. Note that this
1538 -- does not happen free, because in the list case, the parent does
1541 Set_Parent (New_Node, Parent (Source));
1543 -- If the node being relocated was a rewriting of some original
1544 -- node, then the relocated node has the same original node.
1546 if Orig_Nodes.Table (Source) /= Source then
1547 Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source);
1557 procedure Replace (Old_Node, New_Node : Node_Id) is
1558 Old_Post : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
1559 Old_CFS : constant Boolean := Nodes.Table (Old_Node).Comes_From_Source;
1563 (not Has_Extension (Old_Node)
1564 and not Has_Extension (New_Node)
1565 and not Nodes.Table (New_Node).In_List);
1567 -- Do copy, preserving link and in list status and comes from source
1569 Copy_Node (Source => New_Node, Destination => Old_Node);
1570 Nodes.Table (Old_Node).Comes_From_Source := Old_CFS;
1571 Nodes.Table (Old_Node).Error_Posted := Old_Post;
1573 -- Fix parents of substituted node, since it has changed identity
1575 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1577 -- Since we are doing a replace, we assume that the original node
1578 -- is intended to become the new replaced node. The call would be
1579 -- to Rewrite if there were an intention to save the original node.
1581 Orig_Nodes.Table (Old_Node) := Old_Node;
1583 -- Update the SCIL_Node field (if available)
1585 if Generate_SCIL then
1586 Set_SCIL_Node (Old_Node, Get_SCIL_Node (New_Node));
1594 procedure Rewrite (Old_Node, New_Node : Node_Id) is
1595 Old_Error_P : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
1596 -- This fields is always preserved in the new node
1598 Old_Paren_Count : Nat;
1599 Old_Must_Not_Freeze : Boolean;
1600 -- These fields are preserved in the new node only if the new node
1601 -- and the old node are both subexpression nodes.
1603 -- Note: it is a violation of abstraction levels for Must_Not_Freeze
1604 -- to be referenced like this. ???
1610 (not Has_Extension (Old_Node)
1611 and not Has_Extension (New_Node)
1612 and not Nodes.Table (New_Node).In_List);
1613 pragma Debug (Rewrite_Debugging_Output (Old_Node, New_Node));
1615 if Nkind (Old_Node) in N_Subexpr then
1616 Old_Paren_Count := Paren_Count (Old_Node);
1617 Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node);
1619 Old_Paren_Count := 0;
1620 Old_Must_Not_Freeze := False;
1623 -- Allocate a new node, to be used to preserve the original contents
1624 -- of the Old_Node, for possible later retrival by Original_Node and
1625 -- make an entry in the Orig_Nodes table. This is only done if we have
1626 -- not already rewritten the node, as indicated by an Orig_Nodes entry
1627 -- that does not reference the Old_Node.
1629 if Orig_Nodes.Table (Old_Node) = Old_Node then
1630 Sav_Node := New_Copy (Old_Node);
1631 Orig_Nodes.Table (Sav_Node) := Sav_Node;
1632 Orig_Nodes.Table (Old_Node) := Sav_Node;
1635 -- Copy substitute node into place, preserving old fields as required
1637 Copy_Node (Source => New_Node, Destination => Old_Node);
1638 Nodes.Table (Old_Node).Error_Posted := Old_Error_P;
1640 if Nkind (New_Node) in N_Subexpr then
1641 Set_Paren_Count (Old_Node, Old_Paren_Count);
1642 Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze);
1645 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1647 -- Update the SCIL_Node field (if available)
1649 if Generate_SCIL then
1650 Set_SCIL_Node (Old_Node, Get_SCIL_Node (New_Node));
1654 -------------------------
1655 -- Rewrite_Breakpoint --
1656 -------------------------
1658 procedure rr is -- Rewrite_Breakpoint
1660 Write_Str ("Watched node ");
1661 Write_Int (Int (Watch_Node));
1662 Write_Str (" rewritten");
1666 ------------------------------
1667 -- Rewrite_Debugging_Output --
1668 ------------------------------
1670 procedure rrd (Old_Node, New_Node : Node_Id) is -- Rewrite_Debugging_Output
1671 Node_Is_Watched : constant Boolean := Old_Node = Watch_Node;
1674 if Debug_Flag_N or else Node_Is_Watched then
1675 Node_Debug_Output ("Rewrite", Old_Node);
1676 Node_Debug_Output ("into", New_Node);
1678 if Node_Is_Watched then
1688 procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is
1690 Nodes.Table (N).Analyzed := Val;
1693 ---------------------------
1694 -- Set_Comes_From_Source --
1695 ---------------------------
1697 procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is
1699 pragma Assert (N <= Nodes.Last);
1700 Nodes.Table (N).Comes_From_Source := Val;
1701 end Set_Comes_From_Source;
1703 -----------------------------------
1704 -- Set_Comes_From_Source_Default --
1705 -----------------------------------
1707 procedure Set_Comes_From_Source_Default (Default : Boolean) is
1709 Default_Node.Comes_From_Source := Default;
1710 end Set_Comes_From_Source_Default;
1716 procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is
1718 pragma Assert (Nkind (E) in N_Entity);
1719 Nodes.Table (E + 1).Nkind := E_To_N (Val);
1722 ----------------------
1723 -- Set_Error_Posted --
1724 ----------------------
1726 procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is
1728 Nodes.Table (N).Error_Posted := Val;
1729 end Set_Error_Posted;
1731 ---------------------
1732 -- Set_Paren_Count --
1733 ---------------------
1735 procedure Set_Paren_Count (N : Node_Id; Val : Nat) is
1737 pragma Assert (Nkind (N) in N_Subexpr);
1739 -- Value of 0,1,2 stored as is
1742 Nodes.Table (N).Pflag1 := (Val mod 2 /= 0);
1743 Nodes.Table (N).Pflag2 := (Val = 2);
1745 -- Value of 3 or greater stores 3 in node and makes table entry
1748 Nodes.Table (N).Pflag1 := True;
1749 Nodes.Table (N).Pflag2 := True;
1751 for J in Paren_Counts.First .. Paren_Counts.Last loop
1752 if N = Paren_Counts.Table (J).Nod then
1753 Paren_Counts.Table (J).Count := Val;
1758 Paren_Counts.Append ((Nod => N, Count => Val));
1760 end Set_Paren_Count;
1766 procedure Set_Parent (N : Node_Id; Val : Node_Id) is
1768 pragma Assert (not Nodes.Table (N).In_List);
1769 Nodes.Table (N).Link := Union_Id (Val);
1776 procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is
1778 Nodes.Table (N).Sloc := Val;
1785 function Sloc (N : Node_Id) return Source_Ptr is
1787 return Nodes.Table (N).Sloc;
1794 function Traverse_Func (Node : Node_Id) return Traverse_Final_Result is
1796 function Traverse_Field
1799 FN : Field_Num) return Traverse_Final_Result;
1800 -- Fld is one of the fields of Nod. If the field points to syntactic
1801 -- node or list, then this node or list is traversed, and the result is
1802 -- the result of this traversal. Otherwise a value of True is returned
1803 -- with no processing. FN is the number of the field (1 .. 5).
1805 --------------------
1806 -- Traverse_Field --
1807 --------------------
1809 function Traverse_Field
1812 FN : Field_Num) return Traverse_Final_Result
1815 if Fld = Union_Id (Empty) then
1818 -- Descendent is a node
1820 elsif Fld in Node_Range then
1822 -- Traverse descendent that is syntactic subtree node
1824 if Is_Syntactic_Field (Nkind (Nod), FN) then
1825 return Traverse_Func (Node_Id (Fld));
1827 -- Node that is not a syntactic subtree
1833 -- Descendent is a list
1835 elsif Fld in List_Range then
1837 -- Traverse descendent that is a syntactic subtree list
1839 if Is_Syntactic_Field (Nkind (Nod), FN) then
1841 Elmt : Node_Id := First (List_Id (Fld));
1843 while Present (Elmt) loop
1844 if Traverse_Func (Elmt) = Abandon then
1854 -- List that is not a syntactic subtree
1860 -- Field was not a node or a list
1867 Cur_Node : Node_Id := Node;
1869 -- Start of processing for Traverse_Func
1872 -- We walk Field2 last, and if it is a node, we eliminate the tail
1873 -- recursion by jumping back to this label. This is because Field2 is
1874 -- where the Left_Opnd field of N_Op_Concat is stored, and in practice
1875 -- concatenations are sometimes deeply nested, as in X1&X2&...&XN. This
1876 -- trick prevents us from running out of memory in that case. We don't
1877 -- bother eliminating the tail recursion if Field2 is a list.
1881 case Process (Cur_Node) is
1892 Cur_Node := Original_Node (Cur_Node);
1895 if Traverse_Field (Cur_Node, Field1 (Cur_Node), 1) = Abandon
1896 or else -- skip Field2 here
1897 Traverse_Field (Cur_Node, Field3 (Cur_Node), 3) = Abandon
1899 Traverse_Field (Cur_Node, Field4 (Cur_Node), 4) = Abandon
1901 Traverse_Field (Cur_Node, Field5 (Cur_Node), 5) = Abandon
1906 if Field2 (Cur_Node) not in Node_Range then
1907 return Traverse_Field (Cur_Node, Field2 (Cur_Node), 2);
1909 elsif Is_Syntactic_Field (Nkind (Cur_Node), 2)
1910 and then Field2 (Cur_Node) /= Empty_List_Or_Node
1912 -- Here is the tail recursion step, we reset Cur_Node and jump back
1913 -- to the start of the procedure, which has the same semantic effect
1916 Cur_Node := Node_Id (Field2 (Cur_Node));
1927 procedure Traverse_Proc (Node : Node_Id) is
1928 function Traverse is new Traverse_Func (Process);
1929 Discard : Traverse_Final_Result;
1930 pragma Warnings (Off, Discard);
1932 Discard := Traverse (Node);
1939 procedure Tree_Read is
1941 Tree_Read_Int (Node_Count);
1943 Orig_Nodes.Tree_Read;
1944 Paren_Counts.Tree_Read;
1951 procedure Tree_Write is
1953 Tree_Write_Int (Node_Count);
1955 Orig_Nodes.Tree_Write;
1956 Paren_Counts.Tree_Write;
1959 ------------------------------
1960 -- Unchecked Access Package --
1961 ------------------------------
1963 package body Unchecked_Access is
1965 function Field1 (N : Node_Id) return Union_Id is
1967 pragma Assert (N <= Nodes.Last);
1968 return Nodes.Table (N).Field1;
1971 function Field2 (N : Node_Id) return Union_Id is
1973 pragma Assert (N <= Nodes.Last);
1974 return Nodes.Table (N).Field2;
1977 function Field3 (N : Node_Id) return Union_Id is
1979 pragma Assert (N <= Nodes.Last);
1980 return Nodes.Table (N).Field3;
1983 function Field4 (N : Node_Id) return Union_Id is
1985 pragma Assert (N <= Nodes.Last);
1986 return Nodes.Table (N).Field4;
1989 function Field5 (N : Node_Id) return Union_Id is
1991 pragma Assert (N <= Nodes.Last);
1992 return Nodes.Table (N).Field5;
1995 function Field6 (N : Node_Id) return Union_Id is
1997 pragma Assert (Nkind (N) in N_Entity);
1998 return Nodes.Table (N + 1).Field6;
2001 function Field7 (N : Node_Id) return Union_Id is
2003 pragma Assert (Nkind (N) in N_Entity);
2004 return Nodes.Table (N + 1).Field7;
2007 function Field8 (N : Node_Id) return Union_Id is
2009 pragma Assert (Nkind (N) in N_Entity);
2010 return Nodes.Table (N + 1).Field8;
2013 function Field9 (N : Node_Id) return Union_Id is
2015 pragma Assert (Nkind (N) in N_Entity);
2016 return Nodes.Table (N + 1).Field9;
2019 function Field10 (N : Node_Id) return Union_Id is
2021 pragma Assert (Nkind (N) in N_Entity);
2022 return Nodes.Table (N + 1).Field10;
2025 function Field11 (N : Node_Id) return Union_Id is
2027 pragma Assert (Nkind (N) in N_Entity);
2028 return Nodes.Table (N + 1).Field11;
2031 function Field12 (N : Node_Id) return Union_Id is
2033 pragma Assert (Nkind (N) in N_Entity);
2034 return Nodes.Table (N + 1).Field12;
2037 function Field13 (N : Node_Id) return Union_Id is
2039 pragma Assert (Nkind (N) in N_Entity);
2040 return Nodes.Table (N + 2).Field6;
2043 function Field14 (N : Node_Id) return Union_Id is
2045 pragma Assert (Nkind (N) in N_Entity);
2046 return Nodes.Table (N + 2).Field7;
2049 function Field15 (N : Node_Id) return Union_Id is
2051 pragma Assert (Nkind (N) in N_Entity);
2052 return Nodes.Table (N + 2).Field8;
2055 function Field16 (N : Node_Id) return Union_Id is
2057 pragma Assert (Nkind (N) in N_Entity);
2058 return Nodes.Table (N + 2).Field9;
2061 function Field17 (N : Node_Id) return Union_Id is
2063 pragma Assert (Nkind (N) in N_Entity);
2064 return Nodes.Table (N + 2).Field10;
2067 function Field18 (N : Node_Id) return Union_Id is
2069 pragma Assert (Nkind (N) in N_Entity);
2070 return Nodes.Table (N + 2).Field11;
2073 function Field19 (N : Node_Id) return Union_Id is
2075 pragma Assert (Nkind (N) in N_Entity);
2076 return Nodes.Table (N + 3).Field6;
2079 function Field20 (N : Node_Id) return Union_Id is
2081 pragma Assert (Nkind (N) in N_Entity);
2082 return Nodes.Table (N + 3).Field7;
2085 function Field21 (N : Node_Id) return Union_Id is
2087 pragma Assert (Nkind (N) in N_Entity);
2088 return Nodes.Table (N + 3).Field8;
2091 function Field22 (N : Node_Id) return Union_Id is
2093 pragma Assert (Nkind (N) in N_Entity);
2094 return Nodes.Table (N + 3).Field9;
2097 function Field23 (N : Node_Id) return Union_Id is
2099 pragma Assert (Nkind (N) in N_Entity);
2100 return Nodes.Table (N + 3).Field10;
2103 function Field24 (N : Node_Id) return Union_Id is
2105 pragma Assert (Nkind (N) in N_Entity);
2106 return Nodes.Table (N + 4).Field6;
2109 function Field25 (N : Node_Id) return Union_Id is
2111 pragma Assert (Nkind (N) in N_Entity);
2112 return Nodes.Table (N + 4).Field7;
2115 function Field26 (N : Node_Id) return Union_Id is
2117 pragma Assert (Nkind (N) in N_Entity);
2118 return Nodes.Table (N + 4).Field8;
2121 function Field27 (N : Node_Id) return Union_Id is
2123 pragma Assert (Nkind (N) in N_Entity);
2124 return Nodes.Table (N + 4).Field9;
2127 function Field28 (N : Node_Id) return Union_Id is
2129 pragma Assert (Nkind (N) in N_Entity);
2130 return Nodes.Table (N + 4).Field10;
2133 function Node1 (N : Node_Id) return Node_Id is
2135 pragma Assert (N <= Nodes.Last);
2136 return Node_Id (Nodes.Table (N).Field1);
2139 function Node2 (N : Node_Id) return Node_Id is
2141 pragma Assert (N <= Nodes.Last);
2142 return Node_Id (Nodes.Table (N).Field2);
2145 function Node3 (N : Node_Id) return Node_Id is
2147 pragma Assert (N <= Nodes.Last);
2148 return Node_Id (Nodes.Table (N).Field3);
2151 function Node4 (N : Node_Id) return Node_Id is
2153 pragma Assert (N <= Nodes.Last);
2154 return Node_Id (Nodes.Table (N).Field4);
2157 function Node5 (N : Node_Id) return Node_Id is
2159 pragma Assert (N <= Nodes.Last);
2160 return Node_Id (Nodes.Table (N).Field5);
2163 function Node6 (N : Node_Id) return Node_Id is
2165 pragma Assert (Nkind (N) in N_Entity);
2166 return Node_Id (Nodes.Table (N + 1).Field6);
2169 function Node7 (N : Node_Id) return Node_Id is
2171 pragma Assert (Nkind (N) in N_Entity);
2172 return Node_Id (Nodes.Table (N + 1).Field7);
2175 function Node8 (N : Node_Id) return Node_Id is
2177 pragma Assert (Nkind (N) in N_Entity);
2178 return Node_Id (Nodes.Table (N + 1).Field8);
2181 function Node9 (N : Node_Id) return Node_Id is
2183 pragma Assert (Nkind (N) in N_Entity);
2184 return Node_Id (Nodes.Table (N + 1).Field9);
2187 function Node10 (N : Node_Id) return Node_Id is
2189 pragma Assert (Nkind (N) in N_Entity);
2190 return Node_Id (Nodes.Table (N + 1).Field10);
2193 function Node11 (N : Node_Id) return Node_Id is
2195 pragma Assert (Nkind (N) in N_Entity);
2196 return Node_Id (Nodes.Table (N + 1).Field11);
2199 function Node12 (N : Node_Id) return Node_Id is
2201 pragma Assert (Nkind (N) in N_Entity);
2202 return Node_Id (Nodes.Table (N + 1).Field12);
2205 function Node13 (N : Node_Id) return Node_Id is
2207 pragma Assert (Nkind (N) in N_Entity);
2208 return Node_Id (Nodes.Table (N + 2).Field6);
2211 function Node14 (N : Node_Id) return Node_Id is
2213 pragma Assert (Nkind (N) in N_Entity);
2214 return Node_Id (Nodes.Table (N + 2).Field7);
2217 function Node15 (N : Node_Id) return Node_Id is
2219 pragma Assert (Nkind (N) in N_Entity);
2220 return Node_Id (Nodes.Table (N + 2).Field8);
2223 function Node16 (N : Node_Id) return Node_Id is
2225 pragma Assert (Nkind (N) in N_Entity);
2226 return Node_Id (Nodes.Table (N + 2).Field9);
2229 function Node17 (N : Node_Id) return Node_Id is
2231 pragma Assert (Nkind (N) in N_Entity);
2232 return Node_Id (Nodes.Table (N + 2).Field10);
2235 function Node18 (N : Node_Id) return Node_Id is
2237 pragma Assert (Nkind (N) in N_Entity);
2238 return Node_Id (Nodes.Table (N + 2).Field11);
2241 function Node19 (N : Node_Id) return Node_Id is
2243 pragma Assert (Nkind (N) in N_Entity);
2244 return Node_Id (Nodes.Table (N + 3).Field6);
2247 function Node20 (N : Node_Id) return Node_Id is
2249 pragma Assert (Nkind (N) in N_Entity);
2250 return Node_Id (Nodes.Table (N + 3).Field7);
2253 function Node21 (N : Node_Id) return Node_Id is
2255 pragma Assert (Nkind (N) in N_Entity);
2256 return Node_Id (Nodes.Table (N + 3).Field8);
2259 function Node22 (N : Node_Id) return Node_Id is
2261 pragma Assert (Nkind (N) in N_Entity);
2262 return Node_Id (Nodes.Table (N + 3).Field9);
2265 function Node23 (N : Node_Id) return Node_Id is
2267 pragma Assert (Nkind (N) in N_Entity);
2268 return Node_Id (Nodes.Table (N + 3).Field10);
2271 function Node24 (N : Node_Id) return Node_Id is
2273 pragma Assert (Nkind (N) in N_Entity);
2274 return Node_Id (Nodes.Table (N + 4).Field6);
2277 function Node25 (N : Node_Id) return Node_Id is
2279 pragma Assert (Nkind (N) in N_Entity);
2280 return Node_Id (Nodes.Table (N + 4).Field7);
2283 function Node26 (N : Node_Id) return Node_Id is
2285 pragma Assert (Nkind (N) in N_Entity);
2286 return Node_Id (Nodes.Table (N + 4).Field8);
2289 function Node27 (N : Node_Id) return Node_Id is
2291 pragma Assert (Nkind (N) in N_Entity);
2292 return Node_Id (Nodes.Table (N + 4).Field9);
2295 function Node28 (N : Node_Id) return Node_Id is
2297 pragma Assert (Nkind (N) in N_Entity);
2298 return Node_Id (Nodes.Table (N + 4).Field10);
2301 function List1 (N : Node_Id) return List_Id is
2303 pragma Assert (N <= Nodes.Last);
2304 return List_Id (Nodes.Table (N).Field1);
2307 function List2 (N : Node_Id) return List_Id is
2309 pragma Assert (N <= Nodes.Last);
2310 return List_Id (Nodes.Table (N).Field2);
2313 function List3 (N : Node_Id) return List_Id is
2315 pragma Assert (N <= Nodes.Last);
2316 return List_Id (Nodes.Table (N).Field3);
2319 function List4 (N : Node_Id) return List_Id is
2321 pragma Assert (N <= Nodes.Last);
2322 return List_Id (Nodes.Table (N).Field4);
2325 function List5 (N : Node_Id) return List_Id is
2327 pragma Assert (N <= Nodes.Last);
2328 return List_Id (Nodes.Table (N).Field5);
2331 function List10 (N : Node_Id) return List_Id is
2333 pragma Assert (Nkind (N) in N_Entity);
2334 return List_Id (Nodes.Table (N + 1).Field10);
2337 function List14 (N : Node_Id) return List_Id is
2339 pragma Assert (Nkind (N) in N_Entity);
2340 return List_Id (Nodes.Table (N + 2).Field7);
2343 function Elist1 (N : Node_Id) return Elist_Id is
2344 pragma Assert (N <= Nodes.Last);
2345 Value : constant Union_Id := Nodes.Table (N).Field1;
2350 return Elist_Id (Value);
2354 function Elist2 (N : Node_Id) return Elist_Id is
2355 pragma Assert (N <= Nodes.Last);
2356 Value : constant Union_Id := Nodes.Table (N).Field2;
2361 return Elist_Id (Value);
2365 function Elist3 (N : Node_Id) return Elist_Id is
2366 pragma Assert (N <= Nodes.Last);
2367 Value : constant Union_Id := Nodes.Table (N).Field3;
2372 return Elist_Id (Value);
2376 function Elist4 (N : Node_Id) return Elist_Id is
2377 pragma Assert (N <= Nodes.Last);
2378 Value : constant Union_Id := Nodes.Table (N).Field4;
2383 return Elist_Id (Value);
2387 function Elist8 (N : Node_Id) return Elist_Id is
2388 pragma Assert (Nkind (N) in N_Entity);
2389 Value : constant Union_Id := Nodes.Table (N + 1).Field8;
2394 return Elist_Id (Value);
2398 function Elist13 (N : Node_Id) return Elist_Id is
2399 pragma Assert (Nkind (N) in N_Entity);
2400 Value : constant Union_Id := Nodes.Table (N + 2).Field6;
2405 return Elist_Id (Value);
2409 function Elist15 (N : Node_Id) return Elist_Id is
2410 pragma Assert (Nkind (N) in N_Entity);
2411 Value : constant Union_Id := Nodes.Table (N + 2).Field8;
2416 return Elist_Id (Value);
2420 function Elist16 (N : Node_Id) return Elist_Id is
2421 pragma Assert (Nkind (N) in N_Entity);
2422 Value : constant Union_Id := Nodes.Table (N + 2).Field9;
2427 return Elist_Id (Value);
2431 function Elist18 (N : Node_Id) return Elist_Id is
2432 pragma Assert (Nkind (N) in N_Entity);
2433 Value : constant Union_Id := Nodes.Table (N + 2).Field11;
2438 return Elist_Id (Value);
2442 function Elist21 (N : Node_Id) return Elist_Id is
2443 pragma Assert (Nkind (N) in N_Entity);
2444 Value : constant Union_Id := Nodes.Table (N + 3).Field8;
2449 return Elist_Id (Value);
2453 function Elist23 (N : Node_Id) return Elist_Id is
2454 pragma Assert (Nkind (N) in N_Entity);
2455 Value : constant Union_Id := Nodes.Table (N + 3).Field10;
2460 return Elist_Id (Value);
2464 function Elist25 (N : Node_Id) return Elist_Id is
2465 pragma Assert (Nkind (N) in N_Entity);
2466 Value : constant Union_Id := Nodes.Table (N + 4).Field7;
2471 return Elist_Id (Value);
2475 function Elist26 (N : Node_Id) return Elist_Id is
2476 pragma Assert (Nkind (N) in N_Entity);
2477 Value : constant Union_Id := Nodes.Table (N + 4).Field8;
2482 return Elist_Id (Value);
2486 function Name1 (N : Node_Id) return Name_Id is
2488 pragma Assert (N <= Nodes.Last);
2489 return Name_Id (Nodes.Table (N).Field1);
2492 function Name2 (N : Node_Id) return Name_Id is
2494 pragma Assert (N <= Nodes.Last);
2495 return Name_Id (Nodes.Table (N).Field2);
2498 function Str3 (N : Node_Id) return String_Id is
2500 pragma Assert (N <= Nodes.Last);
2501 return String_Id (Nodes.Table (N).Field3);
2504 function Uint2 (N : Node_Id) return Uint is
2505 pragma Assert (N <= Nodes.Last);
2506 U : constant Union_Id := Nodes.Table (N).Field2;
2511 return From_Union (U);
2515 function Uint3 (N : Node_Id) return Uint is
2516 pragma Assert (N <= Nodes.Last);
2517 U : constant Union_Id := Nodes.Table (N).Field3;
2522 return From_Union (U);
2526 function Uint4 (N : Node_Id) return Uint is
2527 pragma Assert (N <= Nodes.Last);
2528 U : constant Union_Id := Nodes.Table (N).Field4;
2533 return From_Union (U);
2537 function Uint5 (N : Node_Id) return Uint is
2538 pragma Assert (N <= Nodes.Last);
2539 U : constant Union_Id := Nodes.Table (N).Field5;
2544 return From_Union (U);
2548 function Uint8 (N : Node_Id) return Uint is
2549 pragma Assert (Nkind (N) in N_Entity);
2550 U : constant Union_Id := Nodes.Table (N + 1).Field8;
2555 return From_Union (U);
2559 function Uint9 (N : Node_Id) return Uint is
2560 pragma Assert (Nkind (N) in N_Entity);
2561 U : constant Union_Id := Nodes.Table (N + 1).Field9;
2566 return From_Union (U);
2570 function Uint10 (N : Node_Id) return Uint is
2571 pragma Assert (Nkind (N) in N_Entity);
2572 U : constant Union_Id := Nodes.Table (N + 1).Field10;
2577 return From_Union (U);
2581 function Uint11 (N : Node_Id) return Uint is
2582 pragma Assert (Nkind (N) in N_Entity);
2583 U : constant Union_Id := Nodes.Table (N + 1).Field11;
2588 return From_Union (U);
2592 function Uint12 (N : Node_Id) return Uint is
2593 pragma Assert (Nkind (N) in N_Entity);
2594 U : constant Union_Id := Nodes.Table (N + 1).Field12;
2599 return From_Union (U);
2603 function Uint13 (N : Node_Id) return Uint is
2604 pragma Assert (Nkind (N) in N_Entity);
2605 U : constant Union_Id := Nodes.Table (N + 2).Field6;
2610 return From_Union (U);
2614 function Uint14 (N : Node_Id) return Uint is
2615 pragma Assert (Nkind (N) in N_Entity);
2616 U : constant Union_Id := Nodes.Table (N + 2).Field7;
2621 return From_Union (U);
2625 function Uint15 (N : Node_Id) return Uint is
2626 pragma Assert (Nkind (N) in N_Entity);
2627 U : constant Union_Id := Nodes.Table (N + 2).Field8;
2632 return From_Union (U);
2636 function Uint16 (N : Node_Id) return Uint is
2637 pragma Assert (Nkind (N) in N_Entity);
2638 U : constant Union_Id := Nodes.Table (N + 2).Field9;
2643 return From_Union (U);
2647 function Uint17 (N : Node_Id) return Uint is
2648 pragma Assert (Nkind (N) in N_Entity);
2649 U : constant Union_Id := Nodes.Table (N + 2).Field10;
2654 return From_Union (U);
2658 function Uint22 (N : Node_Id) return Uint is
2659 pragma Assert (Nkind (N) in N_Entity);
2660 U : constant Union_Id := Nodes.Table (N + 3).Field9;
2665 return From_Union (U);
2669 function Ureal3 (N : Node_Id) return Ureal is
2671 pragma Assert (N <= Nodes.Last);
2672 return From_Union (Nodes.Table (N).Field3);
2675 function Ureal18 (N : Node_Id) return Ureal is
2677 pragma Assert (Nkind (N) in N_Entity);
2678 return From_Union (Nodes.Table (N + 2).Field11);
2681 function Ureal21 (N : Node_Id) return Ureal is
2683 pragma Assert (Nkind (N) in N_Entity);
2684 return From_Union (Nodes.Table (N + 3).Field8);
2687 function Flag4 (N : Node_Id) return Boolean is
2689 pragma Assert (N <= Nodes.Last);
2690 return Nodes.Table (N).Flag4;
2693 function Flag5 (N : Node_Id) return Boolean is
2695 pragma Assert (N <= Nodes.Last);
2696 return Nodes.Table (N).Flag5;
2699 function Flag6 (N : Node_Id) return Boolean is
2701 pragma Assert (N <= Nodes.Last);
2702 return Nodes.Table (N).Flag6;
2705 function Flag7 (N : Node_Id) return Boolean is
2707 pragma Assert (N <= Nodes.Last);
2708 return Nodes.Table (N).Flag7;
2711 function Flag8 (N : Node_Id) return Boolean is
2713 pragma Assert (N <= Nodes.Last);
2714 return Nodes.Table (N).Flag8;
2717 function Flag9 (N : Node_Id) return Boolean is
2719 pragma Assert (N <= Nodes.Last);
2720 return Nodes.Table (N).Flag9;
2723 function Flag10 (N : Node_Id) return Boolean is
2725 pragma Assert (N <= Nodes.Last);
2726 return Nodes.Table (N).Flag10;
2729 function Flag11 (N : Node_Id) return Boolean is
2731 pragma Assert (N <= Nodes.Last);
2732 return Nodes.Table (N).Flag11;
2735 function Flag12 (N : Node_Id) return Boolean is
2737 pragma Assert (N <= Nodes.Last);
2738 return Nodes.Table (N).Flag12;
2741 function Flag13 (N : Node_Id) return Boolean is
2743 pragma Assert (N <= Nodes.Last);
2744 return Nodes.Table (N).Flag13;
2747 function Flag14 (N : Node_Id) return Boolean is
2749 pragma Assert (N <= Nodes.Last);
2750 return Nodes.Table (N).Flag14;
2753 function Flag15 (N : Node_Id) return Boolean is
2755 pragma Assert (N <= Nodes.Last);
2756 return Nodes.Table (N).Flag15;
2759 function Flag16 (N : Node_Id) return Boolean is
2761 pragma Assert (N <= Nodes.Last);
2762 return Nodes.Table (N).Flag16;
2765 function Flag17 (N : Node_Id) return Boolean is
2767 pragma Assert (N <= Nodes.Last);
2768 return Nodes.Table (N).Flag17;
2771 function Flag18 (N : Node_Id) return Boolean is
2773 pragma Assert (N <= Nodes.Last);
2774 return Nodes.Table (N).Flag18;
2777 function Flag19 (N : Node_Id) return Boolean is
2779 pragma Assert (Nkind (N) in N_Entity);
2780 return Nodes.Table (N + 1).In_List;
2783 function Flag20 (N : Node_Id) return Boolean is
2785 pragma Assert (Nkind (N) in N_Entity);
2786 return Nodes.Table (N + 1).Unused_1;
2789 function Flag21 (N : Node_Id) return Boolean is
2791 pragma Assert (Nkind (N) in N_Entity);
2792 return Nodes.Table (N + 1).Rewrite_Ins;
2795 function Flag22 (N : Node_Id) return Boolean is
2797 pragma Assert (Nkind (N) in N_Entity);
2798 return Nodes.Table (N + 1).Analyzed;
2801 function Flag23 (N : Node_Id) return Boolean is
2803 pragma Assert (Nkind (N) in N_Entity);
2804 return Nodes.Table (N + 1).Comes_From_Source;
2807 function Flag24 (N : Node_Id) return Boolean is
2809 pragma Assert (Nkind (N) in N_Entity);
2810 return Nodes.Table (N + 1).Error_Posted;
2813 function Flag25 (N : Node_Id) return Boolean is
2815 pragma Assert (Nkind (N) in N_Entity);
2816 return Nodes.Table (N + 1).Flag4;
2819 function Flag26 (N : Node_Id) return Boolean is
2821 pragma Assert (Nkind (N) in N_Entity);
2822 return Nodes.Table (N + 1).Flag5;
2825 function Flag27 (N : Node_Id) return Boolean is
2827 pragma Assert (Nkind (N) in N_Entity);
2828 return Nodes.Table (N + 1).Flag6;
2831 function Flag28 (N : Node_Id) return Boolean is
2833 pragma Assert (Nkind (N) in N_Entity);
2834 return Nodes.Table (N + 1).Flag7;
2837 function Flag29 (N : Node_Id) return Boolean is
2839 pragma Assert (Nkind (N) in N_Entity);
2840 return Nodes.Table (N + 1).Flag8;
2843 function Flag30 (N : Node_Id) return Boolean is
2845 pragma Assert (Nkind (N) in N_Entity);
2846 return Nodes.Table (N + 1).Flag9;
2849 function Flag31 (N : Node_Id) return Boolean is
2851 pragma Assert (Nkind (N) in N_Entity);
2852 return Nodes.Table (N + 1).Flag10;
2855 function Flag32 (N : Node_Id) return Boolean is
2857 pragma Assert (Nkind (N) in N_Entity);
2858 return Nodes.Table (N + 1).Flag11;
2861 function Flag33 (N : Node_Id) return Boolean is
2863 pragma Assert (Nkind (N) in N_Entity);
2864 return Nodes.Table (N + 1).Flag12;
2867 function Flag34 (N : Node_Id) return Boolean is
2869 pragma Assert (Nkind (N) in N_Entity);
2870 return Nodes.Table (N + 1).Flag13;
2873 function Flag35 (N : Node_Id) return Boolean is
2875 pragma Assert (Nkind (N) in N_Entity);
2876 return Nodes.Table (N + 1).Flag14;
2879 function Flag36 (N : Node_Id) return Boolean is
2881 pragma Assert (Nkind (N) in N_Entity);
2882 return Nodes.Table (N + 1).Flag15;
2885 function Flag37 (N : Node_Id) return Boolean is
2887 pragma Assert (Nkind (N) in N_Entity);
2888 return Nodes.Table (N + 1).Flag16;
2891 function Flag38 (N : Node_Id) return Boolean is
2893 pragma Assert (Nkind (N) in N_Entity);
2894 return Nodes.Table (N + 1).Flag17;
2897 function Flag39 (N : Node_Id) return Boolean is
2899 pragma Assert (Nkind (N) in N_Entity);
2900 return Nodes.Table (N + 1).Flag18;
2903 function Flag40 (N : Node_Id) return Boolean is
2905 pragma Assert (Nkind (N) in N_Entity);
2906 return Nodes.Table (N + 2).In_List;
2909 function Flag41 (N : Node_Id) return Boolean is
2911 pragma Assert (Nkind (N) in N_Entity);
2912 return Nodes.Table (N + 2).Unused_1;
2915 function Flag42 (N : Node_Id) return Boolean is
2917 pragma Assert (Nkind (N) in N_Entity);
2918 return Nodes.Table (N + 2).Rewrite_Ins;
2921 function Flag43 (N : Node_Id) return Boolean is
2923 pragma Assert (Nkind (N) in N_Entity);
2924 return Nodes.Table (N + 2).Analyzed;
2927 function Flag44 (N : Node_Id) return Boolean is
2929 pragma Assert (Nkind (N) in N_Entity);
2930 return Nodes.Table (N + 2).Comes_From_Source;
2933 function Flag45 (N : Node_Id) return Boolean is
2935 pragma Assert (Nkind (N) in N_Entity);
2936 return Nodes.Table (N + 2).Error_Posted;
2939 function Flag46 (N : Node_Id) return Boolean is
2941 pragma Assert (Nkind (N) in N_Entity);
2942 return Nodes.Table (N + 2).Flag4;
2945 function Flag47 (N : Node_Id) return Boolean is
2947 pragma Assert (Nkind (N) in N_Entity);
2948 return Nodes.Table (N + 2).Flag5;
2951 function Flag48 (N : Node_Id) return Boolean is
2953 pragma Assert (Nkind (N) in N_Entity);
2954 return Nodes.Table (N + 2).Flag6;
2957 function Flag49 (N : Node_Id) return Boolean is
2959 pragma Assert (Nkind (N) in N_Entity);
2960 return Nodes.Table (N + 2).Flag7;
2963 function Flag50 (N : Node_Id) return Boolean is
2965 pragma Assert (Nkind (N) in N_Entity);
2966 return Nodes.Table (N + 2).Flag8;
2969 function Flag51 (N : Node_Id) return Boolean is
2971 pragma Assert (Nkind (N) in N_Entity);
2972 return Nodes.Table (N + 2).Flag9;
2975 function Flag52 (N : Node_Id) return Boolean is
2977 pragma Assert (Nkind (N) in N_Entity);
2978 return Nodes.Table (N + 2).Flag10;
2981 function Flag53 (N : Node_Id) return Boolean is
2983 pragma Assert (Nkind (N) in N_Entity);
2984 return Nodes.Table (N + 2).Flag11;
2987 function Flag54 (N : Node_Id) return Boolean is
2989 pragma Assert (Nkind (N) in N_Entity);
2990 return Nodes.Table (N + 2).Flag12;
2993 function Flag55 (N : Node_Id) return Boolean is
2995 pragma Assert (Nkind (N) in N_Entity);
2996 return Nodes.Table (N + 2).Flag13;
2999 function Flag56 (N : Node_Id) return Boolean is
3001 pragma Assert (Nkind (N) in N_Entity);
3002 return Nodes.Table (N + 2).Flag14;
3005 function Flag57 (N : Node_Id) return Boolean is
3007 pragma Assert (Nkind (N) in N_Entity);
3008 return Nodes.Table (N + 2).Flag15;
3011 function Flag58 (N : Node_Id) return Boolean is
3013 pragma Assert (Nkind (N) in N_Entity);
3014 return Nodes.Table (N + 2).Flag16;
3017 function Flag59 (N : Node_Id) return Boolean is
3019 pragma Assert (Nkind (N) in N_Entity);
3020 return Nodes.Table (N + 2).Flag17;
3023 function Flag60 (N : Node_Id) return Boolean is
3025 pragma Assert (Nkind (N) in N_Entity);
3026 return Nodes.Table (N + 2).Flag18;
3029 function Flag61 (N : Node_Id) return Boolean is
3031 pragma Assert (Nkind (N) in N_Entity);
3032 return Nodes.Table (N + 1).Pflag1;
3035 function Flag62 (N : Node_Id) return Boolean is
3037 pragma Assert (Nkind (N) in N_Entity);
3038 return Nodes.Table (N + 1).Pflag2;
3041 function Flag63 (N : Node_Id) return Boolean is
3043 pragma Assert (Nkind (N) in N_Entity);
3044 return Nodes.Table (N + 2).Pflag1;
3047 function Flag64 (N : Node_Id) return Boolean is
3049 pragma Assert (Nkind (N) in N_Entity);
3050 return Nodes.Table (N + 2).Pflag2;
3053 function Flag65 (N : Node_Id) return Boolean is
3055 pragma Assert (Nkind (N) in N_Entity);
3056 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
3059 function Flag66 (N : Node_Id) return Boolean is
3061 pragma Assert (Nkind (N) in N_Entity);
3062 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
3065 function Flag67 (N : Node_Id) return Boolean is
3067 pragma Assert (Nkind (N) in N_Entity);
3068 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
3071 function Flag68 (N : Node_Id) return Boolean is
3073 pragma Assert (Nkind (N) in N_Entity);
3074 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
3077 function Flag69 (N : Node_Id) return Boolean is
3079 pragma Assert (Nkind (N) in N_Entity);
3080 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
3083 function Flag70 (N : Node_Id) return Boolean is
3085 pragma Assert (Nkind (N) in N_Entity);
3086 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
3089 function Flag71 (N : Node_Id) return Boolean is
3091 pragma Assert (Nkind (N) in N_Entity);
3092 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
3095 function Flag72 (N : Node_Id) return Boolean is
3097 pragma Assert (Nkind (N) in N_Entity);
3098 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
3101 function Flag73 (N : Node_Id) return Boolean is
3103 pragma Assert (Nkind (N) in N_Entity);
3104 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
3107 function Flag74 (N : Node_Id) return Boolean is
3109 pragma Assert (Nkind (N) in N_Entity);
3110 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
3113 function Flag75 (N : Node_Id) return Boolean is
3115 pragma Assert (Nkind (N) in N_Entity);
3116 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
3119 function Flag76 (N : Node_Id) return Boolean is
3121 pragma Assert (Nkind (N) in N_Entity);
3122 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
3125 function Flag77 (N : Node_Id) return Boolean is
3127 pragma Assert (Nkind (N) in N_Entity);
3128 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
3131 function Flag78 (N : Node_Id) return Boolean is
3133 pragma Assert (Nkind (N) in N_Entity);
3134 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
3137 function Flag79 (N : Node_Id) return Boolean is
3139 pragma Assert (Nkind (N) in N_Entity);
3140 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
3143 function Flag80 (N : Node_Id) return Boolean is
3145 pragma Assert (Nkind (N) in N_Entity);
3146 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
3149 function Flag81 (N : Node_Id) return Boolean is
3151 pragma Assert (Nkind (N) in N_Entity);
3152 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
3155 function Flag82 (N : Node_Id) return Boolean is
3157 pragma Assert (Nkind (N) in N_Entity);
3158 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
3161 function Flag83 (N : Node_Id) return Boolean is
3163 pragma Assert (Nkind (N) in N_Entity);
3164 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
3167 function Flag84 (N : Node_Id) return Boolean is
3169 pragma Assert (Nkind (N) in N_Entity);
3170 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
3173 function Flag85 (N : Node_Id) return Boolean is
3175 pragma Assert (Nkind (N) in N_Entity);
3176 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
3179 function Flag86 (N : Node_Id) return Boolean is
3181 pragma Assert (Nkind (N) in N_Entity);
3182 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
3185 function Flag87 (N : Node_Id) return Boolean is
3187 pragma Assert (Nkind (N) in N_Entity);
3188 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
3191 function Flag88 (N : Node_Id) return Boolean is
3193 pragma Assert (Nkind (N) in N_Entity);
3194 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
3197 function Flag89 (N : Node_Id) return Boolean is
3199 pragma Assert (Nkind (N) in N_Entity);
3200 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
3203 function Flag90 (N : Node_Id) return Boolean is
3205 pragma Assert (Nkind (N) in N_Entity);
3206 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
3209 function Flag91 (N : Node_Id) return Boolean is
3211 pragma Assert (Nkind (N) in N_Entity);
3212 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
3215 function Flag92 (N : Node_Id) return Boolean is
3217 pragma Assert (Nkind (N) in N_Entity);
3218 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
3221 function Flag93 (N : Node_Id) return Boolean is
3223 pragma Assert (Nkind (N) in N_Entity);
3224 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
3227 function Flag94 (N : Node_Id) return Boolean is
3229 pragma Assert (Nkind (N) in N_Entity);
3230 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
3233 function Flag95 (N : Node_Id) return Boolean is
3235 pragma Assert (Nkind (N) in N_Entity);
3236 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
3239 function Flag96 (N : Node_Id) return Boolean is
3241 pragma Assert (Nkind (N) in N_Entity);
3242 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
3245 function Flag97 (N : Node_Id) return Boolean is
3247 pragma Assert (Nkind (N) in N_Entity);
3248 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
3251 function Flag98 (N : Node_Id) return Boolean is
3253 pragma Assert (Nkind (N) in N_Entity);
3254 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
3257 function Flag99 (N : Node_Id) return Boolean is
3259 pragma Assert (Nkind (N) in N_Entity);
3260 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
3263 function Flag100 (N : Node_Id) return Boolean is
3265 pragma Assert (Nkind (N) in N_Entity);
3266 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
3269 function Flag101 (N : Node_Id) return Boolean is
3271 pragma Assert (Nkind (N) in N_Entity);
3272 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
3275 function Flag102 (N : Node_Id) return Boolean is
3277 pragma Assert (Nkind (N) in N_Entity);
3278 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
3281 function Flag103 (N : Node_Id) return Boolean is
3283 pragma Assert (Nkind (N) in N_Entity);
3284 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
3287 function Flag104 (N : Node_Id) return Boolean is
3289 pragma Assert (Nkind (N) in N_Entity);
3290 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
3293 function Flag105 (N : Node_Id) return Boolean is
3295 pragma Assert (Nkind (N) in N_Entity);
3296 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
3299 function Flag106 (N : Node_Id) return Boolean is
3301 pragma Assert (Nkind (N) in N_Entity);
3302 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
3305 function Flag107 (N : Node_Id) return Boolean is
3307 pragma Assert (Nkind (N) in N_Entity);
3308 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
3311 function Flag108 (N : Node_Id) return Boolean is
3313 pragma Assert (Nkind (N) in N_Entity);
3314 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
3317 function Flag109 (N : Node_Id) return Boolean is
3319 pragma Assert (Nkind (N) in N_Entity);
3320 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
3323 function Flag110 (N : Node_Id) return Boolean is
3325 pragma Assert (Nkind (N) in N_Entity);
3326 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
3329 function Flag111 (N : Node_Id) return Boolean is
3331 pragma Assert (Nkind (N) in N_Entity);
3332 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
3335 function Flag112 (N : Node_Id) return Boolean is
3337 pragma Assert (Nkind (N) in N_Entity);
3338 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
3341 function Flag113 (N : Node_Id) return Boolean is
3343 pragma Assert (Nkind (N) in N_Entity);
3344 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
3347 function Flag114 (N : Node_Id) return Boolean is
3349 pragma Assert (Nkind (N) in N_Entity);
3350 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
3353 function Flag115 (N : Node_Id) return Boolean is
3355 pragma Assert (Nkind (N) in N_Entity);
3356 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
3359 function Flag116 (N : Node_Id) return Boolean is
3361 pragma Assert (Nkind (N) in N_Entity);
3362 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
3365 function Flag117 (N : Node_Id) return Boolean is
3367 pragma Assert (Nkind (N) in N_Entity);
3368 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
3371 function Flag118 (N : Node_Id) return Boolean is
3373 pragma Assert (Nkind (N) in N_Entity);
3374 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
3377 function Flag119 (N : Node_Id) return Boolean is
3379 pragma Assert (Nkind (N) in N_Entity);
3380 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
3383 function Flag120 (N : Node_Id) return Boolean is
3385 pragma Assert (Nkind (N) in N_Entity);
3386 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
3389 function Flag121 (N : Node_Id) return Boolean is
3391 pragma Assert (Nkind (N) in N_Entity);
3392 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
3395 function Flag122 (N : Node_Id) return Boolean is
3397 pragma Assert (Nkind (N) in N_Entity);
3398 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
3401 function Flag123 (N : Node_Id) return Boolean is
3403 pragma Assert (Nkind (N) in N_Entity);
3404 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
3407 function Flag124 (N : Node_Id) return Boolean is
3409 pragma Assert (Nkind (N) in N_Entity);
3410 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
3413 function Flag125 (N : Node_Id) return Boolean is
3415 pragma Assert (Nkind (N) in N_Entity);
3416 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
3419 function Flag126 (N : Node_Id) return Boolean is
3421 pragma Assert (Nkind (N) in N_Entity);
3422 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
3425 function Flag127 (N : Node_Id) return Boolean is
3427 pragma Assert (Nkind (N) in N_Entity);
3428 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
3431 function Flag128 (N : Node_Id) return Boolean is
3433 pragma Assert (Nkind (N) in N_Entity);
3434 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
3437 function Flag129 (N : Node_Id) return Boolean is
3439 pragma Assert (Nkind (N) in N_Entity);
3440 return Nodes.Table (N + 3).In_List;
3443 function Flag130 (N : Node_Id) return Boolean is
3445 pragma Assert (Nkind (N) in N_Entity);
3446 return Nodes.Table (N + 3).Unused_1;
3449 function Flag131 (N : Node_Id) return Boolean is
3451 pragma Assert (Nkind (N) in N_Entity);
3452 return Nodes.Table (N + 3).Rewrite_Ins;
3455 function Flag132 (N : Node_Id) return Boolean is
3457 pragma Assert (Nkind (N) in N_Entity);
3458 return Nodes.Table (N + 3).Analyzed;
3461 function Flag133 (N : Node_Id) return Boolean is
3463 pragma Assert (Nkind (N) in N_Entity);
3464 return Nodes.Table (N + 3).Comes_From_Source;
3467 function Flag134 (N : Node_Id) return Boolean is
3469 pragma Assert (Nkind (N) in N_Entity);
3470 return Nodes.Table (N + 3).Error_Posted;
3473 function Flag135 (N : Node_Id) return Boolean is
3475 pragma Assert (Nkind (N) in N_Entity);
3476 return Nodes.Table (N + 3).Flag4;
3479 function Flag136 (N : Node_Id) return Boolean is
3481 pragma Assert (Nkind (N) in N_Entity);
3482 return Nodes.Table (N + 3).Flag5;
3485 function Flag137 (N : Node_Id) return Boolean is
3487 pragma Assert (Nkind (N) in N_Entity);
3488 return Nodes.Table (N + 3).Flag6;
3491 function Flag138 (N : Node_Id) return Boolean is
3493 pragma Assert (Nkind (N) in N_Entity);
3494 return Nodes.Table (N + 3).Flag7;
3497 function Flag139 (N : Node_Id) return Boolean is
3499 pragma Assert (Nkind (N) in N_Entity);
3500 return Nodes.Table (N + 3).Flag8;
3503 function Flag140 (N : Node_Id) return Boolean is
3505 pragma Assert (Nkind (N) in N_Entity);
3506 return Nodes.Table (N + 3).Flag9;
3509 function Flag141 (N : Node_Id) return Boolean is
3511 pragma Assert (Nkind (N) in N_Entity);
3512 return Nodes.Table (N + 3).Flag10;
3515 function Flag142 (N : Node_Id) return Boolean is
3517 pragma Assert (Nkind (N) in N_Entity);
3518 return Nodes.Table (N + 3).Flag11;
3521 function Flag143 (N : Node_Id) return Boolean is
3523 pragma Assert (Nkind (N) in N_Entity);
3524 return Nodes.Table (N + 3).Flag12;
3527 function Flag144 (N : Node_Id) return Boolean is
3529 pragma Assert (Nkind (N) in N_Entity);
3530 return Nodes.Table (N + 3).Flag13;
3533 function Flag145 (N : Node_Id) return Boolean is
3535 pragma Assert (Nkind (N) in N_Entity);
3536 return Nodes.Table (N + 3).Flag14;
3539 function Flag146 (N : Node_Id) return Boolean is
3541 pragma Assert (Nkind (N) in N_Entity);
3542 return Nodes.Table (N + 3).Flag15;
3545 function Flag147 (N : Node_Id) return Boolean is
3547 pragma Assert (Nkind (N) in N_Entity);
3548 return Nodes.Table (N + 3).Flag16;
3551 function Flag148 (N : Node_Id) return Boolean is
3553 pragma Assert (Nkind (N) in N_Entity);
3554 return Nodes.Table (N + 3).Flag17;
3557 function Flag149 (N : Node_Id) return Boolean is
3559 pragma Assert (Nkind (N) in N_Entity);
3560 return Nodes.Table (N + 3).Flag18;
3563 function Flag150 (N : Node_Id) return Boolean is
3565 pragma Assert (Nkind (N) in N_Entity);
3566 return Nodes.Table (N + 3).Pflag1;
3569 function Flag151 (N : Node_Id) return Boolean is
3571 pragma Assert (Nkind (N) in N_Entity);
3572 return Nodes.Table (N + 3).Pflag2;
3575 function Flag152 (N : Node_Id) return Boolean is
3577 pragma Assert (Nkind (N) in N_Entity);
3578 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
3581 function Flag153 (N : Node_Id) return Boolean is
3583 pragma Assert (Nkind (N) in N_Entity);
3584 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
3587 function Flag154 (N : Node_Id) return Boolean is
3589 pragma Assert (Nkind (N) in N_Entity);
3590 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
3593 function Flag155 (N : Node_Id) return Boolean is
3595 pragma Assert (Nkind (N) in N_Entity);
3596 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
3599 function Flag156 (N : Node_Id) return Boolean is
3601 pragma Assert (Nkind (N) in N_Entity);
3602 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
3605 function Flag157 (N : Node_Id) return Boolean is
3607 pragma Assert (Nkind (N) in N_Entity);
3608 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
3611 function Flag158 (N : Node_Id) return Boolean is
3613 pragma Assert (Nkind (N) in N_Entity);
3614 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
3617 function Flag159 (N : Node_Id) return Boolean is
3619 pragma Assert (Nkind (N) in N_Entity);
3620 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
3623 function Flag160 (N : Node_Id) return Boolean is
3625 pragma Assert (Nkind (N) in N_Entity);
3626 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
3629 function Flag161 (N : Node_Id) return Boolean is
3631 pragma Assert (Nkind (N) in N_Entity);
3632 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
3635 function Flag162 (N : Node_Id) return Boolean is
3637 pragma Assert (Nkind (N) in N_Entity);
3638 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
3641 function Flag163 (N : Node_Id) return Boolean is
3643 pragma Assert (Nkind (N) in N_Entity);
3644 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
3647 function Flag164 (N : Node_Id) return Boolean is
3649 pragma Assert (Nkind (N) in N_Entity);
3650 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
3653 function Flag165 (N : Node_Id) return Boolean is
3655 pragma Assert (Nkind (N) in N_Entity);
3656 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
3659 function Flag166 (N : Node_Id) return Boolean is
3661 pragma Assert (Nkind (N) in N_Entity);
3662 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
3665 function Flag167 (N : Node_Id) return Boolean is
3667 pragma Assert (Nkind (N) in N_Entity);
3668 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
3671 function Flag168 (N : Node_Id) return Boolean is
3673 pragma Assert (Nkind (N) in N_Entity);
3674 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
3677 function Flag169 (N : Node_Id) return Boolean is
3679 pragma Assert (Nkind (N) in N_Entity);
3680 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
3683 function Flag170 (N : Node_Id) return Boolean is
3685 pragma Assert (Nkind (N) in N_Entity);
3686 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
3689 function Flag171 (N : Node_Id) return Boolean is
3691 pragma Assert (Nkind (N) in N_Entity);
3692 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
3695 function Flag172 (N : Node_Id) return Boolean is
3697 pragma Assert (Nkind (N) in N_Entity);
3698 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
3701 function Flag173 (N : Node_Id) return Boolean is
3703 pragma Assert (Nkind (N) in N_Entity);
3704 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
3707 function Flag174 (N : Node_Id) return Boolean is
3709 pragma Assert (Nkind (N) in N_Entity);
3710 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
3713 function Flag175 (N : Node_Id) return Boolean is
3715 pragma Assert (Nkind (N) in N_Entity);
3716 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
3719 function Flag176 (N : Node_Id) return Boolean is
3721 pragma Assert (Nkind (N) in N_Entity);
3722 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
3725 function Flag177 (N : Node_Id) return Boolean is
3727 pragma Assert (Nkind (N) in N_Entity);
3728 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
3731 function Flag178 (N : Node_Id) return Boolean is
3733 pragma Assert (Nkind (N) in N_Entity);
3734 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
3737 function Flag179 (N : Node_Id) return Boolean is
3739 pragma Assert (Nkind (N) in N_Entity);
3740 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
3743 function Flag180 (N : Node_Id) return Boolean is
3745 pragma Assert (Nkind (N) in N_Entity);
3746 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
3749 function Flag181 (N : Node_Id) return Boolean is
3751 pragma Assert (Nkind (N) in N_Entity);
3752 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
3755 function Flag182 (N : Node_Id) return Boolean is
3757 pragma Assert (Nkind (N) in N_Entity);
3758 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
3761 function Flag183 (N : Node_Id) return Boolean is
3763 pragma Assert (Nkind (N) in N_Entity);
3764 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
3767 function Flag184 (N : Node_Id) return Boolean is
3769 pragma Assert (Nkind (N) in N_Entity);
3770 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag184;
3773 function Flag185 (N : Node_Id) return Boolean is
3775 pragma Assert (Nkind (N) in N_Entity);
3776 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag185;
3779 function Flag186 (N : Node_Id) return Boolean is
3781 pragma Assert (Nkind (N) in N_Entity);
3782 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag186;
3785 function Flag187 (N : Node_Id) return Boolean is
3787 pragma Assert (Nkind (N) in N_Entity);
3788 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag187;
3791 function Flag188 (N : Node_Id) return Boolean is
3793 pragma Assert (Nkind (N) in N_Entity);
3794 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag188;
3797 function Flag189 (N : Node_Id) return Boolean is
3799 pragma Assert (Nkind (N) in N_Entity);
3800 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag189;
3803 function Flag190 (N : Node_Id) return Boolean is
3805 pragma Assert (Nkind (N) in N_Entity);
3806 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag190;
3809 function Flag191 (N : Node_Id) return Boolean is
3811 pragma Assert (Nkind (N) in N_Entity);
3812 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag191;
3815 function Flag192 (N : Node_Id) return Boolean is
3817 pragma Assert (Nkind (N) in N_Entity);
3818 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag192;
3821 function Flag193 (N : Node_Id) return Boolean is
3823 pragma Assert (Nkind (N) in N_Entity);
3824 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag193;
3827 function Flag194 (N : Node_Id) return Boolean is
3829 pragma Assert (Nkind (N) in N_Entity);
3830 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag194;
3833 function Flag195 (N : Node_Id) return Boolean is
3835 pragma Assert (Nkind (N) in N_Entity);
3836 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag195;
3839 function Flag196 (N : Node_Id) return Boolean is
3841 pragma Assert (Nkind (N) in N_Entity);
3842 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag196;
3845 function Flag197 (N : Node_Id) return Boolean is
3847 pragma Assert (Nkind (N) in N_Entity);
3848 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag197;
3851 function Flag198 (N : Node_Id) return Boolean is
3853 pragma Assert (Nkind (N) in N_Entity);
3854 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag198;
3857 function Flag199 (N : Node_Id) return Boolean is
3859 pragma Assert (Nkind (N) in N_Entity);
3860 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag199;
3863 function Flag200 (N : Node_Id) return Boolean is
3865 pragma Assert (Nkind (N) in N_Entity);
3866 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag200;
3869 function Flag201 (N : Node_Id) return Boolean is
3871 pragma Assert (Nkind (N) in N_Entity);
3872 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag201;
3875 function Flag202 (N : Node_Id) return Boolean is
3877 pragma Assert (Nkind (N) in N_Entity);
3878 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag202;
3881 function Flag203 (N : Node_Id) return Boolean is
3883 pragma Assert (Nkind (N) in N_Entity);
3884 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag203;
3887 function Flag204 (N : Node_Id) return Boolean is
3889 pragma Assert (Nkind (N) in N_Entity);
3890 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag204;
3893 function Flag205 (N : Node_Id) return Boolean is
3895 pragma Assert (Nkind (N) in N_Entity);
3896 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag205;
3899 function Flag206 (N : Node_Id) return Boolean is
3901 pragma Assert (Nkind (N) in N_Entity);
3902 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag206;
3905 function Flag207 (N : Node_Id) return Boolean is
3907 pragma Assert (Nkind (N) in N_Entity);
3908 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag207;
3911 function Flag208 (N : Node_Id) return Boolean is
3913 pragma Assert (Nkind (N) in N_Entity);
3914 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag208;
3917 function Flag209 (N : Node_Id) return Boolean is
3919 pragma Assert (Nkind (N) in N_Entity);
3920 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag209;
3923 function Flag210 (N : Node_Id) return Boolean is
3925 pragma Assert (Nkind (N) in N_Entity);
3926 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag210;
3929 function Flag211 (N : Node_Id) return Boolean is
3931 pragma Assert (Nkind (N) in N_Entity);
3932 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag211;
3935 function Flag212 (N : Node_Id) return Boolean is
3937 pragma Assert (Nkind (N) in N_Entity);
3938 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag212;
3941 function Flag213 (N : Node_Id) return Boolean is
3943 pragma Assert (Nkind (N) in N_Entity);
3944 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag213;
3947 function Flag214 (N : Node_Id) return Boolean is
3949 pragma Assert (Nkind (N) in N_Entity);
3950 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag214;
3953 function Flag215 (N : Node_Id) return Boolean is
3955 pragma Assert (Nkind (N) in N_Entity);
3956 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag215;
3959 function Flag216 (N : Node_Id) return Boolean is
3961 pragma Assert (Nkind (N) in N_Entity);
3962 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag216;
3965 function Flag217 (N : Node_Id) return Boolean is
3967 pragma Assert (Nkind (N) in N_Entity);
3968 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag217;
3971 function Flag218 (N : Node_Id) return Boolean is
3973 pragma Assert (Nkind (N) in N_Entity);
3974 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag218;
3977 function Flag219 (N : Node_Id) return Boolean is
3979 pragma Assert (Nkind (N) in N_Entity);
3980 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag219;
3983 function Flag220 (N : Node_Id) return Boolean is
3985 pragma Assert (Nkind (N) in N_Entity);
3986 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag220;
3989 function Flag221 (N : Node_Id) return Boolean is
3991 pragma Assert (Nkind (N) in N_Entity);
3992 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag221;
3995 function Flag222 (N : Node_Id) return Boolean is
3997 pragma Assert (Nkind (N) in N_Entity);
3998 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag222;
4001 function Flag223 (N : Node_Id) return Boolean is
4003 pragma Assert (Nkind (N) in N_Entity);
4004 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag223;
4007 function Flag224 (N : Node_Id) return Boolean is
4009 pragma Assert (Nkind (N) in N_Entity);
4010 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag224;
4013 function Flag225 (N : Node_Id) return Boolean is
4015 pragma Assert (Nkind (N) in N_Entity);
4016 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag225;
4019 function Flag226 (N : Node_Id) return Boolean is
4021 pragma Assert (Nkind (N) in N_Entity);
4022 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag226;
4025 function Flag227 (N : Node_Id) return Boolean is
4027 pragma Assert (Nkind (N) in N_Entity);
4028 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag227;
4031 function Flag228 (N : Node_Id) return Boolean is
4033 pragma Assert (Nkind (N) in N_Entity);
4034 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag228;
4037 function Flag229 (N : Node_Id) return Boolean is
4039 pragma Assert (Nkind (N) in N_Entity);
4040 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag229;
4043 function Flag230 (N : Node_Id) return Boolean is
4045 pragma Assert (Nkind (N) in N_Entity);
4046 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag230;
4049 function Flag231 (N : Node_Id) return Boolean is
4051 pragma Assert (Nkind (N) in N_Entity);
4052 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag231;
4055 function Flag232 (N : Node_Id) return Boolean is
4057 pragma Assert (Nkind (N) in N_Entity);
4058 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag232;
4061 function Flag233 (N : Node_Id) return Boolean is
4063 pragma Assert (Nkind (N) in N_Entity);
4064 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag233;
4067 function Flag234 (N : Node_Id) return Boolean is
4069 pragma Assert (Nkind (N) in N_Entity);
4070 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag234;
4073 function Flag235 (N : Node_Id) return Boolean is
4075 pragma Assert (Nkind (N) in N_Entity);
4076 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag235;
4079 function Flag236 (N : Node_Id) return Boolean is
4081 pragma Assert (Nkind (N) in N_Entity);
4082 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag236;
4085 function Flag237 (N : Node_Id) return Boolean is
4087 pragma Assert (Nkind (N) in N_Entity);
4088 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag237;
4091 function Flag238 (N : Node_Id) return Boolean is
4093 pragma Assert (Nkind (N) in N_Entity);
4094 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag238;
4097 function Flag239 (N : Node_Id) return Boolean is
4099 pragma Assert (Nkind (N) in N_Entity);
4100 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag239;
4103 function Flag240 (N : Node_Id) return Boolean is
4105 pragma Assert (Nkind (N) in N_Entity);
4106 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag240;
4109 function Flag241 (N : Node_Id) return Boolean is
4111 pragma Assert (Nkind (N) in N_Entity);
4112 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag241;
4115 function Flag242 (N : Node_Id) return Boolean is
4117 pragma Assert (Nkind (N) in N_Entity);
4118 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag242;
4121 function Flag243 (N : Node_Id) return Boolean is
4123 pragma Assert (Nkind (N) in N_Entity);
4124 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag243;
4127 function Flag244 (N : Node_Id) return Boolean is
4129 pragma Assert (Nkind (N) in N_Entity);
4130 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag244;
4133 function Flag245 (N : Node_Id) return Boolean is
4135 pragma Assert (Nkind (N) in N_Entity);
4136 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag245;
4139 function Flag246 (N : Node_Id) return Boolean is
4141 pragma Assert (Nkind (N) in N_Entity);
4142 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag246;
4145 function Flag247 (N : Node_Id) return Boolean is
4147 pragma Assert (Nkind (N) in N_Entity);
4148 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag247;
4151 procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
4153 pragma Assert (N <= Nodes.Last);
4154 Nodes.Table (N).Nkind := Val;
4157 procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
4159 pragma Assert (N <= Nodes.Last);
4160 Nodes.Table (N).Field1 := Val;
4163 procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
4165 pragma Assert (N <= Nodes.Last);
4166 Nodes.Table (N).Field2 := Val;
4169 procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
4171 pragma Assert (N <= Nodes.Last);
4172 Nodes.Table (N).Field3 := Val;
4175 procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
4177 pragma Assert (N <= Nodes.Last);
4178 Nodes.Table (N).Field4 := Val;
4181 procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
4183 pragma Assert (N <= Nodes.Last);
4184 Nodes.Table (N).Field5 := Val;
4187 procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
4189 pragma Assert (Nkind (N) in N_Entity);
4190 Nodes.Table (N + 1).Field6 := Val;
4193 procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
4195 pragma Assert (Nkind (N) in N_Entity);
4196 Nodes.Table (N + 1).Field7 := Val;
4199 procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
4201 pragma Assert (Nkind (N) in N_Entity);
4202 Nodes.Table (N + 1).Field8 := Val;
4205 procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
4207 pragma Assert (Nkind (N) in N_Entity);
4208 Nodes.Table (N + 1).Field9 := Val;
4211 procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
4213 pragma Assert (Nkind (N) in N_Entity);
4214 Nodes.Table (N + 1).Field10 := Val;
4217 procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
4219 pragma Assert (Nkind (N) in N_Entity);
4220 Nodes.Table (N + 1).Field11 := Val;
4223 procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
4225 pragma Assert (Nkind (N) in N_Entity);
4226 Nodes.Table (N + 1).Field12 := Val;
4229 procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
4231 pragma Assert (Nkind (N) in N_Entity);
4232 Nodes.Table (N + 2).Field6 := Val;
4235 procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
4237 pragma Assert (Nkind (N) in N_Entity);
4238 Nodes.Table (N + 2).Field7 := Val;
4241 procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
4243 pragma Assert (Nkind (N) in N_Entity);
4244 Nodes.Table (N + 2).Field8 := Val;
4247 procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
4249 pragma Assert (Nkind (N) in N_Entity);
4250 Nodes.Table (N + 2).Field9 := Val;
4253 procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
4255 pragma Assert (Nkind (N) in N_Entity);
4256 Nodes.Table (N + 2).Field10 := Val;
4259 procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
4261 pragma Assert (Nkind (N) in N_Entity);
4262 Nodes.Table (N + 2).Field11 := Val;
4265 procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
4267 pragma Assert (Nkind (N) in N_Entity);
4268 Nodes.Table (N + 3).Field6 := Val;
4271 procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
4273 pragma Assert (Nkind (N) in N_Entity);
4274 Nodes.Table (N + 3).Field7 := Val;
4277 procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
4279 pragma Assert (Nkind (N) in N_Entity);
4280 Nodes.Table (N + 3).Field8 := Val;
4283 procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
4285 pragma Assert (Nkind (N) in N_Entity);
4286 Nodes.Table (N + 3).Field9 := Val;
4289 procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
4291 pragma Assert (Nkind (N) in N_Entity);
4292 Nodes.Table (N + 3).Field10 := Val;
4295 procedure Set_Field24 (N : Node_Id; Val : Union_Id) is
4297 pragma Assert (Nkind (N) in N_Entity);
4298 Nodes.Table (N + 4).Field6 := Val;
4301 procedure Set_Field25 (N : Node_Id; Val : Union_Id) is
4303 pragma Assert (Nkind (N) in N_Entity);
4304 Nodes.Table (N + 4).Field7 := Val;
4307 procedure Set_Field26 (N : Node_Id; Val : Union_Id) is
4309 pragma Assert (Nkind (N) in N_Entity);
4310 Nodes.Table (N + 4).Field8 := Val;
4313 procedure Set_Field27 (N : Node_Id; Val : Union_Id) is
4315 pragma Assert (Nkind (N) in N_Entity);
4316 Nodes.Table (N + 4).Field9 := Val;
4319 procedure Set_Field28 (N : Node_Id; Val : Union_Id) is
4321 pragma Assert (Nkind (N) in N_Entity);
4322 Nodes.Table (N + 4).Field10 := Val;
4325 procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
4327 pragma Assert (N <= Nodes.Last);
4328 Nodes.Table (N).Field1 := Union_Id (Val);
4331 procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
4333 pragma Assert (N <= Nodes.Last);
4334 Nodes.Table (N).Field2 := Union_Id (Val);
4337 procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
4339 pragma Assert (N <= Nodes.Last);
4340 Nodes.Table (N).Field3 := Union_Id (Val);
4343 procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
4345 pragma Assert (N <= Nodes.Last);
4346 Nodes.Table (N).Field4 := Union_Id (Val);
4349 procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
4351 pragma Assert (N <= Nodes.Last);
4352 Nodes.Table (N).Field5 := Union_Id (Val);
4355 procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
4357 pragma Assert (Nkind (N) in N_Entity);
4358 Nodes.Table (N + 1).Field6 := Union_Id (Val);
4361 procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
4363 pragma Assert (Nkind (N) in N_Entity);
4364 Nodes.Table (N + 1).Field7 := Union_Id (Val);
4367 procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
4369 pragma Assert (Nkind (N) in N_Entity);
4370 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4373 procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
4375 pragma Assert (Nkind (N) in N_Entity);
4376 Nodes.Table (N + 1).Field9 := Union_Id (Val);
4379 procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
4381 pragma Assert (Nkind (N) in N_Entity);
4382 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4385 procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
4387 pragma Assert (Nkind (N) in N_Entity);
4388 Nodes.Table (N + 1).Field11 := Union_Id (Val);
4391 procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
4393 pragma Assert (Nkind (N) in N_Entity);
4394 Nodes.Table (N + 1).Field12 := Union_Id (Val);
4397 procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
4399 pragma Assert (Nkind (N) in N_Entity);
4400 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4403 procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
4405 pragma Assert (Nkind (N) in N_Entity);
4406 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4409 procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
4411 pragma Assert (Nkind (N) in N_Entity);
4412 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4415 procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
4417 pragma Assert (Nkind (N) in N_Entity);
4418 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4421 procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
4423 pragma Assert (Nkind (N) in N_Entity);
4424 Nodes.Table (N + 2).Field10 := Union_Id (Val);
4427 procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
4429 pragma Assert (Nkind (N) in N_Entity);
4430 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4433 procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
4435 pragma Assert (Nkind (N) in N_Entity);
4436 Nodes.Table (N + 3).Field6 := Union_Id (Val);
4439 procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
4441 pragma Assert (Nkind (N) in N_Entity);
4442 Nodes.Table (N + 3).Field7 := Union_Id (Val);
4445 procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
4447 pragma Assert (Nkind (N) in N_Entity);
4448 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4451 procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
4453 pragma Assert (Nkind (N) in N_Entity);
4454 Nodes.Table (N + 3).Field9 := Union_Id (Val);
4457 procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
4459 pragma Assert (Nkind (N) in N_Entity);
4460 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4463 procedure Set_Node24 (N : Node_Id; Val : Node_Id) is
4465 pragma Assert (Nkind (N) in N_Entity);
4466 Nodes.Table (N + 4).Field6 := Union_Id (Val);
4469 procedure Set_Node25 (N : Node_Id; Val : Node_Id) is
4471 pragma Assert (Nkind (N) in N_Entity);
4472 Nodes.Table (N + 4).Field7 := Union_Id (Val);
4475 procedure Set_Node26 (N : Node_Id; Val : Node_Id) is
4477 pragma Assert (Nkind (N) in N_Entity);
4478 Nodes.Table (N + 4).Field8 := Union_Id (Val);
4481 procedure Set_Node27 (N : Node_Id; Val : Node_Id) is
4483 pragma Assert (Nkind (N) in N_Entity);
4484 Nodes.Table (N + 4).Field9 := Union_Id (Val);
4487 procedure Set_Node28 (N : Node_Id; Val : Node_Id) is
4489 pragma Assert (Nkind (N) in N_Entity);
4490 Nodes.Table (N + 4).Field10 := Union_Id (Val);
4493 procedure Set_List1 (N : Node_Id; Val : List_Id) is
4495 pragma Assert (N <= Nodes.Last);
4496 Nodes.Table (N).Field1 := Union_Id (Val);
4499 procedure Set_List2 (N : Node_Id; Val : List_Id) is
4501 pragma Assert (N <= Nodes.Last);
4502 Nodes.Table (N).Field2 := Union_Id (Val);
4505 procedure Set_List3 (N : Node_Id; Val : List_Id) is
4507 pragma Assert (N <= Nodes.Last);
4508 Nodes.Table (N).Field3 := Union_Id (Val);
4511 procedure Set_List4 (N : Node_Id; Val : List_Id) is
4513 pragma Assert (N <= Nodes.Last);
4514 Nodes.Table (N).Field4 := Union_Id (Val);
4517 procedure Set_List5 (N : Node_Id; Val : List_Id) is
4519 pragma Assert (N <= Nodes.Last);
4520 Nodes.Table (N).Field5 := Union_Id (Val);
4523 procedure Set_List10 (N : Node_Id; Val : List_Id) is
4525 pragma Assert (Nkind (N) in N_Entity);
4526 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4529 procedure Set_List14 (N : Node_Id; Val : List_Id) is
4531 pragma Assert (Nkind (N) in N_Entity);
4532 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4535 procedure Set_Elist1 (N : Node_Id; Val : Elist_Id) is
4537 Nodes.Table (N).Field1 := Union_Id (Val);
4540 procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
4542 Nodes.Table (N).Field2 := Union_Id (Val);
4545 procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
4547 Nodes.Table (N).Field3 := Union_Id (Val);
4550 procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
4552 Nodes.Table (N).Field4 := Union_Id (Val);
4555 procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
4557 pragma Assert (Nkind (N) in N_Entity);
4558 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4561 procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
4563 pragma Assert (Nkind (N) in N_Entity);
4564 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4567 procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
4569 pragma Assert (Nkind (N) in N_Entity);
4570 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4573 procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
4575 pragma Assert (Nkind (N) in N_Entity);
4576 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4579 procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
4581 pragma Assert (Nkind (N) in N_Entity);
4582 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4585 procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
4587 pragma Assert (Nkind (N) in N_Entity);
4588 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4591 procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
4593 pragma Assert (Nkind (N) in N_Entity);
4594 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4597 procedure Set_Elist25 (N : Node_Id; Val : Elist_Id) is
4599 pragma Assert (Nkind (N) in N_Entity);
4600 Nodes.Table (N + 4).Field7 := Union_Id (Val);
4603 procedure Set_Elist26 (N : Node_Id; Val : Elist_Id) is
4605 pragma Assert (Nkind (N) in N_Entity);
4606 Nodes.Table (N + 4).Field8 := Union_Id (Val);
4609 procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
4611 pragma Assert (N <= Nodes.Last);
4612 Nodes.Table (N).Field1 := Union_Id (Val);
4615 procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
4617 pragma Assert (N <= Nodes.Last);
4618 Nodes.Table (N).Field2 := Union_Id (Val);
4621 procedure Set_Str3 (N : Node_Id; Val : String_Id) is
4623 pragma Assert (N <= Nodes.Last);
4624 Nodes.Table (N).Field3 := Union_Id (Val);
4627 procedure Set_Uint2 (N : Node_Id; Val : Uint) is
4629 pragma Assert (N <= Nodes.Last);
4630 Nodes.Table (N).Field2 := To_Union (Val);
4633 procedure Set_Uint3 (N : Node_Id; Val : Uint) is
4635 pragma Assert (N <= Nodes.Last);
4636 Nodes.Table (N).Field3 := To_Union (Val);
4639 procedure Set_Uint4 (N : Node_Id; Val : Uint) is
4641 pragma Assert (N <= Nodes.Last);
4642 Nodes.Table (N).Field4 := To_Union (Val);
4645 procedure Set_Uint5 (N : Node_Id; Val : Uint) is
4647 pragma Assert (N <= Nodes.Last);
4648 Nodes.Table (N).Field5 := To_Union (Val);
4651 procedure Set_Uint8 (N : Node_Id; Val : Uint) is
4653 pragma Assert (Nkind (N) in N_Entity);
4654 Nodes.Table (N + 1).Field8 := To_Union (Val);
4657 procedure Set_Uint9 (N : Node_Id; Val : Uint) is
4659 pragma Assert (Nkind (N) in N_Entity);
4660 Nodes.Table (N + 1).Field9 := To_Union (Val);
4663 procedure Set_Uint10 (N : Node_Id; Val : Uint) is
4665 pragma Assert (Nkind (N) in N_Entity);
4666 Nodes.Table (N + 1).Field10 := To_Union (Val);
4669 procedure Set_Uint11 (N : Node_Id; Val : Uint) is
4671 pragma Assert (Nkind (N) in N_Entity);
4672 Nodes.Table (N + 1).Field11 := To_Union (Val);
4675 procedure Set_Uint12 (N : Node_Id; Val : Uint) is
4677 pragma Assert (Nkind (N) in N_Entity);
4678 Nodes.Table (N + 1).Field12 := To_Union (Val);
4681 procedure Set_Uint13 (N : Node_Id; Val : Uint) is
4683 pragma Assert (Nkind (N) in N_Entity);
4684 Nodes.Table (N + 2).Field6 := To_Union (Val);
4687 procedure Set_Uint14 (N : Node_Id; Val : Uint) is
4689 pragma Assert (Nkind (N) in N_Entity);
4690 Nodes.Table (N + 2).Field7 := To_Union (Val);
4693 procedure Set_Uint15 (N : Node_Id; Val : Uint) is
4695 pragma Assert (Nkind (N) in N_Entity);
4696 Nodes.Table (N + 2).Field8 := To_Union (Val);
4699 procedure Set_Uint16 (N : Node_Id; Val : Uint) is
4701 pragma Assert (Nkind (N) in N_Entity);
4702 Nodes.Table (N + 2).Field9 := To_Union (Val);
4705 procedure Set_Uint17 (N : Node_Id; Val : Uint) is
4707 pragma Assert (Nkind (N) in N_Entity);
4708 Nodes.Table (N + 2).Field10 := To_Union (Val);
4711 procedure Set_Uint22 (N : Node_Id; Val : Uint) is
4713 pragma Assert (Nkind (N) in N_Entity);
4714 Nodes.Table (N + 3).Field9 := To_Union (Val);
4717 procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
4719 pragma Assert (N <= Nodes.Last);
4720 Nodes.Table (N).Field3 := To_Union (Val);
4723 procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
4725 pragma Assert (Nkind (N) in N_Entity);
4726 Nodes.Table (N + 2).Field11 := To_Union (Val);
4729 procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
4731 pragma Assert (Nkind (N) in N_Entity);
4732 Nodes.Table (N + 3).Field8 := To_Union (Val);
4735 procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
4737 pragma Assert (N <= Nodes.Last);
4738 Nodes.Table (N).Flag4 := Val;
4741 procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
4743 pragma Assert (N <= Nodes.Last);
4744 Nodes.Table (N).Flag5 := Val;
4747 procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
4749 pragma Assert (N <= Nodes.Last);
4750 Nodes.Table (N).Flag6 := Val;
4753 procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
4755 pragma Assert (N <= Nodes.Last);
4756 Nodes.Table (N).Flag7 := Val;
4759 procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
4761 pragma Assert (N <= Nodes.Last);
4762 Nodes.Table (N).Flag8 := Val;
4765 procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
4767 pragma Assert (N <= Nodes.Last);
4768 Nodes.Table (N).Flag9 := Val;
4771 procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
4773 pragma Assert (N <= Nodes.Last);
4774 Nodes.Table (N).Flag10 := Val;
4777 procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
4779 pragma Assert (N <= Nodes.Last);
4780 Nodes.Table (N).Flag11 := Val;
4783 procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
4785 pragma Assert (N <= Nodes.Last);
4786 Nodes.Table (N).Flag12 := Val;
4789 procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
4791 pragma Assert (N <= Nodes.Last);
4792 Nodes.Table (N).Flag13 := Val;
4795 procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
4797 pragma Assert (N <= Nodes.Last);
4798 Nodes.Table (N).Flag14 := Val;
4801 procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
4803 pragma Assert (N <= Nodes.Last);
4804 Nodes.Table (N).Flag15 := Val;
4807 procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
4809 pragma Assert (N <= Nodes.Last);
4810 Nodes.Table (N).Flag16 := Val;
4813 procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
4815 pragma Assert (N <= Nodes.Last);
4816 Nodes.Table (N).Flag17 := Val;
4819 procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
4821 pragma Assert (N <= Nodes.Last);
4822 Nodes.Table (N).Flag18 := Val;
4825 procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
4827 pragma Assert (Nkind (N) in N_Entity);
4828 Nodes.Table (N + 1).In_List := Val;
4831 procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
4833 pragma Assert (Nkind (N) in N_Entity);
4834 Nodes.Table (N + 1).Unused_1 := Val;
4837 procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
4839 pragma Assert (Nkind (N) in N_Entity);
4840 Nodes.Table (N + 1).Rewrite_Ins := Val;
4843 procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
4845 pragma Assert (Nkind (N) in N_Entity);
4846 Nodes.Table (N + 1).Analyzed := Val;
4849 procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
4851 pragma Assert (Nkind (N) in N_Entity);
4852 Nodes.Table (N + 1).Comes_From_Source := Val;
4855 procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
4857 pragma Assert (Nkind (N) in N_Entity);
4858 Nodes.Table (N + 1).Error_Posted := Val;
4861 procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
4863 pragma Assert (Nkind (N) in N_Entity);
4864 Nodes.Table (N + 1).Flag4 := Val;
4867 procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
4869 pragma Assert (Nkind (N) in N_Entity);
4870 Nodes.Table (N + 1).Flag5 := Val;
4873 procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
4875 pragma Assert (Nkind (N) in N_Entity);
4876 Nodes.Table (N + 1).Flag6 := Val;
4879 procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
4881 pragma Assert (Nkind (N) in N_Entity);
4882 Nodes.Table (N + 1).Flag7 := Val;
4885 procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
4887 pragma Assert (Nkind (N) in N_Entity);
4888 Nodes.Table (N + 1).Flag8 := Val;
4891 procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
4893 pragma Assert (Nkind (N) in N_Entity);
4894 Nodes.Table (N + 1).Flag9 := Val;
4897 procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
4899 pragma Assert (Nkind (N) in N_Entity);
4900 Nodes.Table (N + 1).Flag10 := Val;
4903 procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
4905 pragma Assert (Nkind (N) in N_Entity);
4906 Nodes.Table (N + 1).Flag11 := Val;
4909 procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
4911 pragma Assert (Nkind (N) in N_Entity);
4912 Nodes.Table (N + 1).Flag12 := Val;
4915 procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
4917 pragma Assert (Nkind (N) in N_Entity);
4918 Nodes.Table (N + 1).Flag13 := Val;
4921 procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
4923 pragma Assert (Nkind (N) in N_Entity);
4924 Nodes.Table (N + 1).Flag14 := Val;
4927 procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
4929 pragma Assert (Nkind (N) in N_Entity);
4930 Nodes.Table (N + 1).Flag15 := Val;
4933 procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
4935 pragma Assert (Nkind (N) in N_Entity);
4936 Nodes.Table (N + 1).Flag16 := Val;
4939 procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
4941 pragma Assert (Nkind (N) in N_Entity);
4942 Nodes.Table (N + 1).Flag17 := Val;
4945 procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
4947 pragma Assert (Nkind (N) in N_Entity);
4948 Nodes.Table (N + 1).Flag18 := Val;
4951 procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
4953 pragma Assert (Nkind (N) in N_Entity);
4954 Nodes.Table (N + 2).In_List := Val;
4957 procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
4959 pragma Assert (Nkind (N) in N_Entity);
4960 Nodes.Table (N + 2).Unused_1 := Val;
4963 procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
4965 pragma Assert (Nkind (N) in N_Entity);
4966 Nodes.Table (N + 2).Rewrite_Ins := Val;
4969 procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
4971 pragma Assert (Nkind (N) in N_Entity);
4972 Nodes.Table (N + 2).Analyzed := Val;
4975 procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
4977 pragma Assert (Nkind (N) in N_Entity);
4978 Nodes.Table (N + 2).Comes_From_Source := Val;
4981 procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
4983 pragma Assert (Nkind (N) in N_Entity);
4984 Nodes.Table (N + 2).Error_Posted := Val;
4987 procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
4989 pragma Assert (Nkind (N) in N_Entity);
4990 Nodes.Table (N + 2).Flag4 := Val;
4993 procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
4995 pragma Assert (Nkind (N) in N_Entity);
4996 Nodes.Table (N + 2).Flag5 := Val;
4999 procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
5001 pragma Assert (Nkind (N) in N_Entity);
5002 Nodes.Table (N + 2).Flag6 := Val;
5005 procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
5007 pragma Assert (Nkind (N) in N_Entity);
5008 Nodes.Table (N + 2).Flag7 := Val;
5011 procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
5013 pragma Assert (Nkind (N) in N_Entity);
5014 Nodes.Table (N + 2).Flag8 := Val;
5017 procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
5019 pragma Assert (Nkind (N) in N_Entity);
5020 Nodes.Table (N + 2).Flag9 := Val;
5023 procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
5025 pragma Assert (Nkind (N) in N_Entity);
5026 Nodes.Table (N + 2).Flag10 := Val;
5029 procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
5031 pragma Assert (Nkind (N) in N_Entity);
5032 Nodes.Table (N + 2).Flag11 := Val;
5035 procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
5037 pragma Assert (Nkind (N) in N_Entity);
5038 Nodes.Table (N + 2).Flag12 := Val;
5041 procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
5043 pragma Assert (Nkind (N) in N_Entity);
5044 Nodes.Table (N + 2).Flag13 := Val;
5047 procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
5049 pragma Assert (Nkind (N) in N_Entity);
5050 Nodes.Table (N + 2).Flag14 := Val;
5053 procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
5055 pragma Assert (Nkind (N) in N_Entity);
5056 Nodes.Table (N + 2).Flag15 := Val;
5059 procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
5061 pragma Assert (Nkind (N) in N_Entity);
5062 Nodes.Table (N + 2).Flag16 := Val;
5065 procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
5067 pragma Assert (Nkind (N) in N_Entity);
5068 Nodes.Table (N + 2).Flag17 := Val;
5071 procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
5073 pragma Assert (Nkind (N) in N_Entity);
5074 Nodes.Table (N + 2).Flag18 := Val;
5077 procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
5079 pragma Assert (Nkind (N) in N_Entity);
5080 Nodes.Table (N + 1).Pflag1 := Val;
5083 procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
5085 pragma Assert (Nkind (N) in N_Entity);
5086 Nodes.Table (N + 1).Pflag2 := Val;
5089 procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
5091 pragma Assert (Nkind (N) in N_Entity);
5092 Nodes.Table (N + 2).Pflag1 := Val;
5095 procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
5097 pragma Assert (Nkind (N) in N_Entity);
5098 Nodes.Table (N + 2).Pflag2 := Val;
5101 procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
5103 pragma Assert (Nkind (N) in N_Entity);
5106 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
5109 procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
5111 pragma Assert (Nkind (N) in N_Entity);
5114 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
5117 procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
5119 pragma Assert (Nkind (N) in N_Entity);
5122 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
5125 procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
5127 pragma Assert (Nkind (N) in N_Entity);
5130 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
5133 procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
5135 pragma Assert (Nkind (N) in N_Entity);
5138 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
5141 procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
5143 pragma Assert (Nkind (N) in N_Entity);
5146 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
5149 procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
5151 pragma Assert (Nkind (N) in N_Entity);
5154 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
5157 procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
5159 pragma Assert (Nkind (N) in N_Entity);
5162 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
5165 procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
5167 pragma Assert (Nkind (N) in N_Entity);
5170 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
5173 procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
5175 pragma Assert (Nkind (N) in N_Entity);
5178 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
5181 procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
5183 pragma Assert (Nkind (N) in N_Entity);
5186 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
5189 procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
5191 pragma Assert (Nkind (N) in N_Entity);
5194 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
5197 procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
5199 pragma Assert (Nkind (N) in N_Entity);
5202 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
5205 procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
5207 pragma Assert (Nkind (N) in N_Entity);
5210 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
5213 procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
5215 pragma Assert (Nkind (N) in N_Entity);
5218 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
5221 procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
5223 pragma Assert (Nkind (N) in N_Entity);
5226 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
5229 procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
5231 pragma Assert (Nkind (N) in N_Entity);
5234 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
5237 procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
5239 pragma Assert (Nkind (N) in N_Entity);
5242 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
5245 procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
5247 pragma Assert (Nkind (N) in N_Entity);
5250 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
5253 procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
5255 pragma Assert (Nkind (N) in N_Entity);
5258 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
5261 procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
5263 pragma Assert (Nkind (N) in N_Entity);
5266 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
5269 procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
5271 pragma Assert (Nkind (N) in N_Entity);
5274 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
5277 procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
5279 pragma Assert (Nkind (N) in N_Entity);
5282 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
5285 procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
5287 pragma Assert (Nkind (N) in N_Entity);
5290 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
5293 procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
5295 pragma Assert (Nkind (N) in N_Entity);
5298 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
5301 procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
5303 pragma Assert (Nkind (N) in N_Entity);
5306 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
5309 procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
5311 pragma Assert (Nkind (N) in N_Entity);
5314 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
5317 procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
5319 pragma Assert (Nkind (N) in N_Entity);
5322 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
5325 procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
5327 pragma Assert (Nkind (N) in N_Entity);
5330 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
5333 procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
5335 pragma Assert (Nkind (N) in N_Entity);
5338 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
5341 procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
5343 pragma Assert (Nkind (N) in N_Entity);
5346 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
5349 procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
5351 pragma Assert (Nkind (N) in N_Entity);
5354 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
5357 procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
5359 pragma Assert (Nkind (N) in N_Entity);
5362 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
5365 procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
5367 pragma Assert (Nkind (N) in N_Entity);
5370 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
5373 procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
5375 pragma Assert (Nkind (N) in N_Entity);
5378 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
5381 procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
5383 pragma Assert (Nkind (N) in N_Entity);
5386 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
5389 procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
5391 pragma Assert (Nkind (N) in N_Entity);
5394 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
5397 procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
5399 pragma Assert (Nkind (N) in N_Entity);
5402 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
5405 procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
5407 pragma Assert (Nkind (N) in N_Entity);
5410 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
5413 procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
5415 pragma Assert (Nkind (N) in N_Entity);
5418 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
5421 procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
5423 pragma Assert (Nkind (N) in N_Entity);
5426 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
5429 procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
5431 pragma Assert (Nkind (N) in N_Entity);
5434 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
5437 procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
5439 pragma Assert (Nkind (N) in N_Entity);
5442 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
5445 procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
5447 pragma Assert (Nkind (N) in N_Entity);
5450 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
5453 procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
5455 pragma Assert (Nkind (N) in N_Entity);
5458 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
5461 procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
5463 pragma Assert (Nkind (N) in N_Entity);
5466 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
5469 procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
5471 pragma Assert (Nkind (N) in N_Entity);
5474 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
5477 procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
5479 pragma Assert (Nkind (N) in N_Entity);
5482 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
5485 procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
5487 pragma Assert (Nkind (N) in N_Entity);
5490 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
5493 procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
5495 pragma Assert (Nkind (N) in N_Entity);
5498 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
5501 procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
5503 pragma Assert (Nkind (N) in N_Entity);
5506 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
5509 procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
5511 pragma Assert (Nkind (N) in N_Entity);
5514 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
5517 procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
5519 pragma Assert (Nkind (N) in N_Entity);
5522 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
5525 procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
5527 pragma Assert (Nkind (N) in N_Entity);
5530 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
5533 procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
5535 pragma Assert (Nkind (N) in N_Entity);
5538 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
5541 procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
5543 pragma Assert (Nkind (N) in N_Entity);
5546 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
5549 procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
5551 pragma Assert (Nkind (N) in N_Entity);
5554 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
5557 procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
5559 pragma Assert (Nkind (N) in N_Entity);
5562 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
5565 procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
5567 pragma Assert (Nkind (N) in N_Entity);
5570 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
5573 procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
5575 pragma Assert (Nkind (N) in N_Entity);
5578 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
5581 procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
5583 pragma Assert (Nkind (N) in N_Entity);
5586 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
5589 procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
5591 pragma Assert (Nkind (N) in N_Entity);
5594 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
5597 procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
5599 pragma Assert (Nkind (N) in N_Entity);
5602 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
5605 procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
5607 pragma Assert (Nkind (N) in N_Entity);
5610 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
5613 procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
5615 pragma Assert (Nkind (N) in N_Entity);
5616 Nodes.Table (N + 3).In_List := Val;
5619 procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
5621 pragma Assert (Nkind (N) in N_Entity);
5622 Nodes.Table (N + 3).Unused_1 := Val;
5625 procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
5627 pragma Assert (Nkind (N) in N_Entity);
5628 Nodes.Table (N + 3).Rewrite_Ins := Val;
5631 procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
5633 pragma Assert (Nkind (N) in N_Entity);
5634 Nodes.Table (N + 3).Analyzed := Val;
5637 procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
5639 pragma Assert (Nkind (N) in N_Entity);
5640 Nodes.Table (N + 3).Comes_From_Source := Val;
5643 procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
5645 pragma Assert (Nkind (N) in N_Entity);
5646 Nodes.Table (N + 3).Error_Posted := Val;
5649 procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
5651 pragma Assert (Nkind (N) in N_Entity);
5652 Nodes.Table (N + 3).Flag4 := Val;
5655 procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
5657 pragma Assert (Nkind (N) in N_Entity);
5658 Nodes.Table (N + 3).Flag5 := Val;
5661 procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
5663 pragma Assert (Nkind (N) in N_Entity);
5664 Nodes.Table (N + 3).Flag6 := Val;
5667 procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
5669 pragma Assert (Nkind (N) in N_Entity);
5670 Nodes.Table (N + 3).Flag7 := Val;
5673 procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
5675 pragma Assert (Nkind (N) in N_Entity);
5676 Nodes.Table (N + 3).Flag8 := Val;
5679 procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
5681 pragma Assert (Nkind (N) in N_Entity);
5682 Nodes.Table (N + 3).Flag9 := Val;
5685 procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
5687 pragma Assert (Nkind (N) in N_Entity);
5688 Nodes.Table (N + 3).Flag10 := Val;
5691 procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
5693 pragma Assert (Nkind (N) in N_Entity);
5694 Nodes.Table (N + 3).Flag11 := Val;
5697 procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
5699 pragma Assert (Nkind (N) in N_Entity);
5700 Nodes.Table (N + 3).Flag12 := Val;
5703 procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
5705 pragma Assert (Nkind (N) in N_Entity);
5706 Nodes.Table (N + 3).Flag13 := Val;
5709 procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
5711 pragma Assert (Nkind (N) in N_Entity);
5712 Nodes.Table (N + 3).Flag14 := Val;
5715 procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
5717 pragma Assert (Nkind (N) in N_Entity);
5718 Nodes.Table (N + 3).Flag15 := Val;
5721 procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
5723 pragma Assert (Nkind (N) in N_Entity);
5724 Nodes.Table (N + 3).Flag16 := Val;
5727 procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
5729 pragma Assert (Nkind (N) in N_Entity);
5730 Nodes.Table (N + 3).Flag17 := Val;
5733 procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
5735 pragma Assert (Nkind (N) in N_Entity);
5736 Nodes.Table (N + 3).Flag18 := Val;
5739 procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
5741 pragma Assert (Nkind (N) in N_Entity);
5742 Nodes.Table (N + 3).Pflag1 := Val;
5745 procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
5747 pragma Assert (Nkind (N) in N_Entity);
5748 Nodes.Table (N + 3).Pflag2 := Val;
5751 procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
5753 pragma Assert (Nkind (N) in N_Entity);
5756 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
5759 procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
5761 pragma Assert (Nkind (N) in N_Entity);
5764 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
5767 procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
5769 pragma Assert (Nkind (N) in N_Entity);
5772 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
5775 procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
5777 pragma Assert (Nkind (N) in N_Entity);
5780 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
5783 procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
5785 pragma Assert (Nkind (N) in N_Entity);
5788 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
5791 procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
5793 pragma Assert (Nkind (N) in N_Entity);
5796 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
5799 procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
5801 pragma Assert (Nkind (N) in N_Entity);
5804 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
5807 procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
5809 pragma Assert (Nkind (N) in N_Entity);
5812 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
5815 procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
5817 pragma Assert (Nkind (N) in N_Entity);
5820 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
5823 procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
5825 pragma Assert (Nkind (N) in N_Entity);
5828 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
5831 procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
5833 pragma Assert (Nkind (N) in N_Entity);
5836 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
5839 procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
5841 pragma Assert (Nkind (N) in N_Entity);
5844 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
5847 procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
5849 pragma Assert (Nkind (N) in N_Entity);
5852 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
5855 procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
5857 pragma Assert (Nkind (N) in N_Entity);
5860 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
5863 procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
5865 pragma Assert (Nkind (N) in N_Entity);
5868 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
5871 procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
5873 pragma Assert (Nkind (N) in N_Entity);
5876 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
5879 procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
5881 pragma Assert (Nkind (N) in N_Entity);
5884 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
5887 procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
5889 pragma Assert (Nkind (N) in N_Entity);
5892 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
5895 procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
5897 pragma Assert (Nkind (N) in N_Entity);
5900 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
5903 procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
5905 pragma Assert (Nkind (N) in N_Entity);
5908 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
5911 procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
5913 pragma Assert (Nkind (N) in N_Entity);
5916 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
5919 procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
5921 pragma Assert (Nkind (N) in N_Entity);
5924 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
5927 procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
5929 pragma Assert (Nkind (N) in N_Entity);
5932 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
5935 procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
5937 pragma Assert (Nkind (N) in N_Entity);
5940 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
5943 procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
5945 pragma Assert (Nkind (N) in N_Entity);
5948 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
5951 procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
5953 pragma Assert (Nkind (N) in N_Entity);
5956 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
5959 procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
5961 pragma Assert (Nkind (N) in N_Entity);
5964 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
5967 procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
5969 pragma Assert (Nkind (N) in N_Entity);
5972 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
5975 procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
5977 pragma Assert (Nkind (N) in N_Entity);
5980 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
5983 procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
5985 pragma Assert (Nkind (N) in N_Entity);
5988 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
5991 procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
5993 pragma Assert (Nkind (N) in N_Entity);
5996 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
5999 procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
6001 pragma Assert (Nkind (N) in N_Entity);
6004 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
6007 procedure Set_Flag184 (N : Node_Id; Val : Boolean) is
6009 pragma Assert (Nkind (N) in N_Entity);
6012 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag184 := Val;
6015 procedure Set_Flag185 (N : Node_Id; Val : Boolean) is
6017 pragma Assert (Nkind (N) in N_Entity);
6020 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag185 := Val;
6023 procedure Set_Flag186 (N : Node_Id; Val : Boolean) is
6025 pragma Assert (Nkind (N) in N_Entity);
6028 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag186 := Val;
6031 procedure Set_Flag187 (N : Node_Id; Val : Boolean) is
6033 pragma Assert (Nkind (N) in N_Entity);
6036 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag187 := Val;
6039 procedure Set_Flag188 (N : Node_Id; Val : Boolean) is
6041 pragma Assert (Nkind (N) in N_Entity);
6044 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag188 := Val;
6047 procedure Set_Flag189 (N : Node_Id; Val : Boolean) is
6049 pragma Assert (Nkind (N) in N_Entity);
6052 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag189 := Val;
6055 procedure Set_Flag190 (N : Node_Id; Val : Boolean) is
6057 pragma Assert (Nkind (N) in N_Entity);
6060 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag190 := Val;
6063 procedure Set_Flag191 (N : Node_Id; Val : Boolean) is
6065 pragma Assert (Nkind (N) in N_Entity);
6068 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag191 := Val;
6071 procedure Set_Flag192 (N : Node_Id; Val : Boolean) is
6073 pragma Assert (Nkind (N) in N_Entity);
6076 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag192 := Val;
6079 procedure Set_Flag193 (N : Node_Id; Val : Boolean) is
6081 pragma Assert (Nkind (N) in N_Entity);
6084 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag193 := Val;
6087 procedure Set_Flag194 (N : Node_Id; Val : Boolean) is
6089 pragma Assert (Nkind (N) in N_Entity);
6092 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag194 := Val;
6095 procedure Set_Flag195 (N : Node_Id; Val : Boolean) is
6097 pragma Assert (Nkind (N) in N_Entity);
6100 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag195 := Val;
6103 procedure Set_Flag196 (N : Node_Id; Val : Boolean) is
6105 pragma Assert (Nkind (N) in N_Entity);
6108 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag196 := Val;
6111 procedure Set_Flag197 (N : Node_Id; Val : Boolean) is
6113 pragma Assert (Nkind (N) in N_Entity);
6116 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag197 := Val;
6119 procedure Set_Flag198 (N : Node_Id; Val : Boolean) is
6121 pragma Assert (Nkind (N) in N_Entity);
6124 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag198 := Val;
6127 procedure Set_Flag199 (N : Node_Id; Val : Boolean) is
6129 pragma Assert (Nkind (N) in N_Entity);
6132 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag199 := Val;
6135 procedure Set_Flag200 (N : Node_Id; Val : Boolean) is
6137 pragma Assert (Nkind (N) in N_Entity);
6140 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag200 := Val;
6143 procedure Set_Flag201 (N : Node_Id; Val : Boolean) is
6145 pragma Assert (Nkind (N) in N_Entity);
6148 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag201 := Val;
6151 procedure Set_Flag202 (N : Node_Id; Val : Boolean) is
6153 pragma Assert (Nkind (N) in N_Entity);
6156 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag202 := Val;
6159 procedure Set_Flag203 (N : Node_Id; Val : Boolean) is
6161 pragma Assert (Nkind (N) in N_Entity);
6164 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag203 := Val;
6167 procedure Set_Flag204 (N : Node_Id; Val : Boolean) is
6169 pragma Assert (Nkind (N) in N_Entity);
6172 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag204 := Val;
6175 procedure Set_Flag205 (N : Node_Id; Val : Boolean) is
6177 pragma Assert (Nkind (N) in N_Entity);
6180 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag205 := Val;
6183 procedure Set_Flag206 (N : Node_Id; Val : Boolean) is
6185 pragma Assert (Nkind (N) in N_Entity);
6188 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag206 := Val;
6191 procedure Set_Flag207 (N : Node_Id; Val : Boolean) is
6193 pragma Assert (Nkind (N) in N_Entity);
6196 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag207 := Val;
6199 procedure Set_Flag208 (N : Node_Id; Val : Boolean) is
6201 pragma Assert (Nkind (N) in N_Entity);
6204 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag208 := Val;
6207 procedure Set_Flag209 (N : Node_Id; Val : Boolean) is
6209 pragma Assert (Nkind (N) in N_Entity);
6212 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag209 := Val;
6215 procedure Set_Flag210 (N : Node_Id; Val : Boolean) is
6217 pragma Assert (Nkind (N) in N_Entity);
6220 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag210 := Val;
6223 procedure Set_Flag211 (N : Node_Id; Val : Boolean) is
6225 pragma Assert (Nkind (N) in N_Entity);
6228 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag211 := Val;
6231 procedure Set_Flag212 (N : Node_Id; Val : Boolean) is
6233 pragma Assert (Nkind (N) in N_Entity);
6236 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag212 := Val;
6239 procedure Set_Flag213 (N : Node_Id; Val : Boolean) is
6241 pragma Assert (Nkind (N) in N_Entity);
6244 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag213 := Val;
6247 procedure Set_Flag214 (N : Node_Id; Val : Boolean) is
6249 pragma Assert (Nkind (N) in N_Entity);
6252 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag214 := Val;
6255 procedure Set_Flag215 (N : Node_Id; Val : Boolean) is
6257 pragma Assert (Nkind (N) in N_Entity);
6260 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag215 := Val;
6263 procedure Set_Flag216 (N : Node_Id; Val : Boolean) is
6265 pragma Assert (Nkind (N) in N_Entity);
6268 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag216 := Val;
6271 procedure Set_Flag217 (N : Node_Id; Val : Boolean) is
6273 pragma Assert (Nkind (N) in N_Entity);
6276 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag217 := Val;
6279 procedure Set_Flag218 (N : Node_Id; Val : Boolean) is
6281 pragma Assert (Nkind (N) in N_Entity);
6284 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag218 := Val;
6287 procedure Set_Flag219 (N : Node_Id; Val : Boolean) is
6289 pragma Assert (Nkind (N) in N_Entity);
6292 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag219 := Val;
6295 procedure Set_Flag220 (N : Node_Id; Val : Boolean) is
6297 pragma Assert (Nkind (N) in N_Entity);
6300 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag220 := Val;
6303 procedure Set_Flag221 (N : Node_Id; Val : Boolean) is
6305 pragma Assert (Nkind (N) in N_Entity);
6308 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag221 := Val;
6311 procedure Set_Flag222 (N : Node_Id; Val : Boolean) is
6313 pragma Assert (Nkind (N) in N_Entity);
6316 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag222 := Val;
6319 procedure Set_Flag223 (N : Node_Id; Val : Boolean) is
6321 pragma Assert (Nkind (N) in N_Entity);
6324 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag223 := Val;
6327 procedure Set_Flag224 (N : Node_Id; Val : Boolean) is
6329 pragma Assert (Nkind (N) in N_Entity);
6332 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag224 := Val;
6335 procedure Set_Flag225 (N : Node_Id; Val : Boolean) is
6337 pragma Assert (Nkind (N) in N_Entity);
6340 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag225 := Val;
6343 procedure Set_Flag226 (N : Node_Id; Val : Boolean) is
6345 pragma Assert (Nkind (N) in N_Entity);
6348 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag226 := Val;
6351 procedure Set_Flag227 (N : Node_Id; Val : Boolean) is
6353 pragma Assert (Nkind (N) in N_Entity);
6356 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag227 := Val;
6359 procedure Set_Flag228 (N : Node_Id; Val : Boolean) is
6361 pragma Assert (Nkind (N) in N_Entity);
6364 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag228 := Val;
6367 procedure Set_Flag229 (N : Node_Id; Val : Boolean) is
6369 pragma Assert (Nkind (N) in N_Entity);
6372 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag229 := Val;
6375 procedure Set_Flag230 (N : Node_Id; Val : Boolean) is
6377 pragma Assert (Nkind (N) in N_Entity);
6380 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag230 := Val;
6383 procedure Set_Flag231 (N : Node_Id; Val : Boolean) is
6385 pragma Assert (Nkind (N) in N_Entity);
6388 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag231 := Val;
6391 procedure Set_Flag232 (N : Node_Id; Val : Boolean) is
6393 pragma Assert (Nkind (N) in N_Entity);
6396 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag232 := Val;
6399 procedure Set_Flag233 (N : Node_Id; Val : Boolean) is
6401 pragma Assert (Nkind (N) in N_Entity);
6404 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag233 := Val;
6407 procedure Set_Flag234 (N : Node_Id; Val : Boolean) is
6409 pragma Assert (Nkind (N) in N_Entity);
6412 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag234 := Val;
6415 procedure Set_Flag235 (N : Node_Id; Val : Boolean) is
6417 pragma Assert (Nkind (N) in N_Entity);
6420 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag235 := Val;
6423 procedure Set_Flag236 (N : Node_Id; Val : Boolean) is
6425 pragma Assert (Nkind (N) in N_Entity);
6428 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag236 := Val;
6431 procedure Set_Flag237 (N : Node_Id; Val : Boolean) is
6433 pragma Assert (Nkind (N) in N_Entity);
6436 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag237 := Val;
6439 procedure Set_Flag238 (N : Node_Id; Val : Boolean) is
6441 pragma Assert (Nkind (N) in N_Entity);
6444 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag238 := Val;
6447 procedure Set_Flag239 (N : Node_Id; Val : Boolean) is
6449 pragma Assert (Nkind (N) in N_Entity);
6452 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag239 := Val;
6455 procedure Set_Flag240 (N : Node_Id; Val : Boolean) is
6457 pragma Assert (Nkind (N) in N_Entity);
6460 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag240 := Val;
6463 procedure Set_Flag241 (N : Node_Id; Val : Boolean) is
6465 pragma Assert (Nkind (N) in N_Entity);
6468 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag241 := Val;
6471 procedure Set_Flag242 (N : Node_Id; Val : Boolean) is
6473 pragma Assert (Nkind (N) in N_Entity);
6476 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag242 := Val;
6479 procedure Set_Flag243 (N : Node_Id; Val : Boolean) is
6481 pragma Assert (Nkind (N) in N_Entity);
6484 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag243 := Val;
6487 procedure Set_Flag244 (N : Node_Id; Val : Boolean) is
6489 pragma Assert (Nkind (N) in N_Entity);
6492 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag244 := Val;
6495 procedure Set_Flag245 (N : Node_Id; Val : Boolean) is
6497 pragma Assert (Nkind (N) in N_Entity);
6500 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag245 := Val;
6503 procedure Set_Flag246 (N : Node_Id; Val : Boolean) is
6505 pragma Assert (Nkind (N) in N_Entity);
6508 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag246 := Val;
6511 procedure Set_Flag247 (N : Node_Id; Val : Boolean) is
6513 pragma Assert (Nkind (N) in N_Entity);
6516 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag247 := Val;
6519 procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is
6521 pragma Assert (N <= Nodes.Last);
6524 Set_Parent (N => Val, Val => N);
6528 end Set_Node1_With_Parent;
6530 procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is
6532 pragma Assert (N <= Nodes.Last);
6535 Set_Parent (N => Val, Val => N);
6539 end Set_Node2_With_Parent;
6541 procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is
6543 pragma Assert (N <= Nodes.Last);
6546 Set_Parent (N => Val, Val => N);
6550 end Set_Node3_With_Parent;
6552 procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is
6554 pragma Assert (N <= Nodes.Last);
6557 Set_Parent (N => Val, Val => N);
6561 end Set_Node4_With_Parent;
6563 procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
6565 pragma Assert (N <= Nodes.Last);
6568 Set_Parent (N => Val, Val => N);
6572 end Set_Node5_With_Parent;
6574 procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
6576 pragma Assert (N <= Nodes.Last);
6577 if Val /= No_List and then Val /= Error_List then
6578 Set_Parent (Val, N);
6581 end Set_List1_With_Parent;
6583 procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
6585 pragma Assert (N <= Nodes.Last);
6586 if Val /= No_List and then Val /= Error_List then
6587 Set_Parent (Val, N);
6590 end Set_List2_With_Parent;
6592 procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
6594 pragma Assert (N <= Nodes.Last);
6595 if Val /= No_List and then Val /= Error_List then
6596 Set_Parent (Val, N);
6599 end Set_List3_With_Parent;
6601 procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
6603 pragma Assert (N <= Nodes.Last);
6604 if Val /= No_List and then Val /= Error_List then
6605 Set_Parent (Val, N);
6608 end Set_List4_With_Parent;
6610 procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
6612 pragma Assert (N <= Nodes.Last);
6613 if Val /= No_List and then Val /= Error_List then
6614 Set_Parent (Val, N);
6617 end Set_List5_With_Parent;
6619 end Unchecked_Access;
6627 Nodes.Locked := False;
6628 Orig_Nodes.Locked := False;