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;
41 with Output; use Output;
42 with Sinput; use Sinput;
43 with Tree_IO; use Tree_IO;
47 Reporting_Proc : Report_Proc := null;
48 -- Record argument to last call to Set_Reporting_Proc
54 -- Suppose you find that node 12345 is messed up. You might want to find
55 -- the code that created that node. There are two ways to do this:
57 -- One way is to set a conditional breakpoint on New_Node_Debugging_Output
59 -- break nnd if n = 12345
60 -- and run gnat1 again from the beginning.
62 -- The other way is to set a breakpoint near the beginning (e.g. on
63 -- gnat1drv), and run. Then set Watch_Node (nickname "ww") to 12345 in gdb:
65 -- and set a breakpoint on New_Node_Breakpoint (nickname "nn"). Continue.
67 -- Either way, gnat1 will stop when node 12345 is created
69 -- The second method is much faster
71 -- Similarly, rr and rrd allow breaking on rewriting of a given node
73 ww : Node_Id'Base := Node_Id'First - 1;
74 pragma Export (Ada, ww); -- trick the optimizer
75 Watch_Node : Node_Id'Base renames ww;
76 -- Node to "watch"; that is, whenever a node is created, we check if it
77 -- is equal to Watch_Node, and if so, call New_Node_Breakpoint. You have
78 -- presumably set a breakpoint on New_Node_Breakpoint. Note that the
79 -- initial value of Node_Id'First - 1 ensures that by default, no node
80 -- will be equal to Watch_Node.
83 pragma Export (Ada, nn);
84 procedure New_Node_Breakpoint renames nn;
85 -- This doesn't do anything interesting; it's just for setting breakpoint
86 -- on as explained above.
88 procedure nnd (N : Node_Id);
89 pragma Export (Ada, nnd);
90 procedure New_Node_Debugging_Output (N : Node_Id) renames nnd;
91 -- For debugging. If debugging is turned on, New_Node and New_Entity call
92 -- this. If debug flag N is turned on, this prints out the new node.
94 -- If Node = Watch_Node, this prints out the new node and calls
95 -- New_Node_Breakpoint. Otherwise, does nothing.
98 pragma Export (Ada, rr);
99 procedure Rewrite_Breakpoint renames rr;
100 -- This doesn't do anything interesting; it's just for setting breakpoint
101 -- on as explained above.
103 procedure rrd (Old_Node, New_Node : Node_Id);
104 pragma Export (Ada, rrd);
105 procedure Rewrite_Debugging_Output
106 (Old_Node, New_Node : Node_Id) renames rrd;
107 -- For debugging. If debugging is turned on, Rewrite calls this. If debug
108 -- flag N is turned on, this prints out the new node.
110 -- If Old_Node = Watch_Node, this prints out the old and new nodes and
111 -- calls Rewrite_Breakpoint. Otherwise, does nothing.
113 procedure Node_Debug_Output (Op : String; N : Node_Id);
114 -- Common code for nnd and rrd, writes Op followed by information about N
116 -----------------------------
117 -- Local Objects and Types --
118 -----------------------------
121 -- Count allocated nodes for Num_Nodes function
123 use Unchecked_Access;
124 -- We are allowed to see these from within our own body!
126 use Atree_Private_Part;
127 -- We are also allowed to see our private data structures!
129 -- Functions used to store Entity_Kind value in Nkind field
131 -- The following declarations are used to store flags 65-72 in the
132 -- Nkind field of the third component of an extended (entity) node.
134 type Flag_Byte is record
145 pragma Pack (Flag_Byte);
146 for Flag_Byte'Size use 8;
148 type Flag_Byte_Ptr is access all Flag_Byte;
149 type Node_Kind_Ptr is access all Node_Kind;
151 function To_Flag_Byte is new
152 Unchecked_Conversion (Node_Kind, Flag_Byte);
154 function To_Flag_Byte_Ptr is new
155 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);
157 -- The following declarations are used to store flags 73-96 and the
158 -- Convention field in the Field12 field of the third component of an
159 -- extended (Entity) node.
161 type Flag_Word is record
189 Convention : Convention_Id;
192 pragma Pack (Flag_Word);
193 for Flag_Word'Size use 32;
194 for Flag_Word'Alignment use 4;
196 type Flag_Word_Ptr is access all Flag_Word;
197 type Union_Id_Ptr is access all Union_Id;
199 function To_Flag_Word is new
200 Unchecked_Conversion (Union_Id, Flag_Word);
202 function To_Flag_Word_Ptr is new
203 Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr);
205 -- The following declarations are used to store flags 97-128 in the
206 -- Field12 field of the fourth component of an extended (entity) node.
208 type Flag_Word2 is record
246 pragma Pack (Flag_Word2);
247 for Flag_Word2'Size use 32;
248 for Flag_Word2'Alignment use 4;
250 type Flag_Word2_Ptr is access all Flag_Word2;
252 function To_Flag_Word2 is new
253 Unchecked_Conversion (Union_Id, Flag_Word2);
255 function To_Flag_Word2_Ptr is new
256 Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr);
258 -- The following declarations are used to store flags 152-183 in the
259 -- Field11 field of the fourth component of an extended (entity) node.
261 type Flag_Word3 is record
299 pragma Pack (Flag_Word3);
300 for Flag_Word3'Size use 32;
301 for Flag_Word3'Alignment use 4;
303 type Flag_Word3_Ptr is access all Flag_Word3;
305 function To_Flag_Word3 is new
306 Unchecked_Conversion (Union_Id, Flag_Word3);
308 function To_Flag_Word3_Ptr is new
309 Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr);
311 -- The following declarations are used to store flags 184-215 in the
312 -- Field11 field of the fifth component of an extended (entity) node.
314 type Flag_Word4 is record
352 pragma Pack (Flag_Word4);
353 for Flag_Word4'Size use 32;
354 for Flag_Word4'Alignment use 4;
356 type Flag_Word4_Ptr is access all Flag_Word4;
358 function To_Flag_Word4 is new
359 Unchecked_Conversion (Union_Id, Flag_Word4);
361 function To_Flag_Word4_Ptr is new
362 Unchecked_Conversion (Union_Id_Ptr, Flag_Word4_Ptr);
364 -- The following declarations are used to store flags 216-247 in the
365 -- Field12 field of the fifth component of an extended (entity) node.
367 type Flag_Word5 is record
405 pragma Pack (Flag_Word5);
406 for Flag_Word5'Size use 32;
407 for Flag_Word5'Alignment use 4;
409 type Flag_Word5_Ptr is access all Flag_Word5;
411 function To_Flag_Word5 is new
412 Unchecked_Conversion (Union_Id, Flag_Word5);
414 function To_Flag_Word5_Ptr is new
415 Unchecked_Conversion (Union_Id_Ptr, Flag_Word5_Ptr);
417 --------------------------------------------------
418 -- Implementation of Tree Substitution Routines --
419 --------------------------------------------------
421 -- A separate table keeps track of the mapping between rewritten nodes
422 -- and their corresponding original tree nodes. Rewrite makes an entry
423 -- in this table for use by Original_Node. By default, if no call is
424 -- Rewrite, the entry in this table points to the original unwritten node.
426 -- Note: eventually, this should be a field in the Node directly, but
427 -- for now we do not want to disturb the efficiency of a power of 2
430 package Orig_Nodes is new Table.Table (
431 Table_Component_Type => Node_Id,
432 Table_Index_Type => Node_Id'Base,
433 Table_Low_Bound => First_Node_Id,
434 Table_Initial => Alloc.Orig_Nodes_Initial,
435 Table_Increment => Alloc.Orig_Nodes_Increment,
436 Table_Name => "Orig_Nodes");
438 --------------------------
439 -- Paren_Count Handling --
440 --------------------------
442 -- As noted in the spec, the paren count in a sub-expression node has
443 -- four possible values 0,1,2, and 3. The value 3 really means 3 or more,
444 -- and we use an auxiliary serially scanned table to record the actual
445 -- count. A serial search is fine, only pathological programs will use
446 -- entries in this table. Normal programs won't use it at all.
448 type Paren_Count_Entry is record
450 -- The node to which this count applies
452 Count : Nat range 3 .. Nat'Last;
453 -- The count of parentheses, which will be in the indicated range
456 package Paren_Counts is new Table.Table (
457 Table_Component_Type => Paren_Count_Entry,
458 Table_Index_Type => Int,
459 Table_Low_Bound => 0,
461 Table_Increment => 200,
462 Table_Name => "Paren_Counts");
464 -----------------------
465 -- Local Subprograms --
466 -----------------------
468 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id);
469 -- Fixup parent pointers for the syntactic children of Fix_Node after
470 -- a copy, setting them to Fix_Node when they pointed to Ref_Node.
472 function Allocate_Initialize_Node
474 With_Extension : Boolean) return Node_Id;
475 -- Allocate a new node or node extension. If Src is not empty,
476 -- the information for the newly-allocated node is copied from it.
478 ------------------------------
479 -- Allocate_Initialize_Node --
480 ------------------------------
482 function Allocate_Initialize_Node
484 With_Extension : Boolean) return Node_Id
486 New_Id : Node_Id := Src;
487 Nod : Node_Record := Default_Node;
488 Ext1 : Node_Record := Default_Node_Extension;
489 Ext2 : Node_Record := Default_Node_Extension;
490 Ext3 : Node_Record := Default_Node_Extension;
491 Ext4 : Node_Record := Default_Node_Extension;
494 if Present (Src) then
495 Nod := Nodes.Table (Src);
497 if Has_Extension (Src) then
498 Ext1 := Nodes.Table (Src + 1);
499 Ext2 := Nodes.Table (Src + 2);
500 Ext3 := Nodes.Table (Src + 3);
501 Ext4 := Nodes.Table (Src + 4);
505 if not (Present (Src)
506 and then not Has_Extension (Src)
507 and then With_Extension
508 and then Src = Nodes.Last)
510 -- We are allocating a new node, or extending a node
511 -- other than Nodes.Last.
514 New_Id := Nodes.Last;
515 Orig_Nodes.Append (New_Id);
516 Node_Count := Node_Count + 1;
519 -- Specifically copy Paren_Count to deal with creating new table entry
520 -- if the parentheses count is at the maximum possible value already.
522 if Present (Src) and then Nkind (Src) in N_Subexpr then
523 Set_Paren_Count (New_Id, Paren_Count (Src));
526 -- Set extension nodes if required
528 if With_Extension then
535 Orig_Nodes.Set_Last (Nodes.Last);
536 Allocate_List_Tables (Nodes.Last);
538 -- Invoke the reporting procedure (if available)
540 if Reporting_Proc /= null then
541 Reporting_Proc.all (Target => New_Id, Source => Src);
545 end Allocate_Initialize_Node;
551 function Analyzed (N : Node_Id) return Boolean is
553 pragma Assert (N <= Nodes.Last);
554 return Nodes.Table (N).Analyzed;
557 --------------------------
558 -- Basic_Set_Convention --
559 --------------------------
561 procedure Basic_Set_Convention (E : Entity_Id; Val : Convention_Id) is
563 pragma Assert (Nkind (E) in N_Entity);
566 (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention := Val;
567 end Basic_Set_Convention;
573 procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is
574 Save_Sloc : constant Source_Ptr := Sloc (N);
575 Save_In_List : constant Boolean := Nodes.Table (N).In_List;
576 Save_Link : constant Union_Id := Nodes.Table (N).Link;
577 Save_CFS : constant Boolean := Nodes.Table (N).Comes_From_Source;
578 Save_Posted : constant Boolean := Nodes.Table (N).Error_Posted;
579 Par_Count : Nat := 0;
582 if Nkind (N) in N_Subexpr then
583 Par_Count := Paren_Count (N);
586 Nodes.Table (N) := Default_Node;
587 Nodes.Table (N).Sloc := Save_Sloc;
588 Nodes.Table (N).In_List := Save_In_List;
589 Nodes.Table (N).Link := Save_Link;
590 Nodes.Table (N).Comes_From_Source := Save_CFS;
591 Nodes.Table (N).Nkind := New_Node_Kind;
592 Nodes.Table (N).Error_Posted := Save_Posted;
594 if New_Node_Kind in N_Subexpr then
595 Set_Paren_Count (N, Par_Count);
599 -----------------------
600 -- Comes_From_Source --
601 -----------------------
603 function Comes_From_Source (N : Node_Id) return Boolean is
605 pragma Assert (N <= Nodes.Last);
606 return Nodes.Table (N).Comes_From_Source;
607 end Comes_From_Source;
613 function Convention (E : Entity_Id) return Convention_Id is
615 pragma Assert (Nkind (E) in N_Entity);
616 return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention;
623 procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is
624 Save_In_List : constant Boolean := Nodes.Table (Destination).In_List;
625 Save_Link : constant Union_Id := Nodes.Table (Destination).Link;
628 Nodes.Table (Destination) := Nodes.Table (Source);
629 Nodes.Table (Destination).In_List := Save_In_List;
630 Nodes.Table (Destination).Link := Save_Link;
632 -- Specifically set Paren_Count to make sure auxiliary table entry
633 -- gets correctly made if the parentheses count is at the max value.
635 if Nkind (Destination) in N_Subexpr then
636 Set_Paren_Count (Destination, Paren_Count (Source));
639 -- Deal with copying extension nodes if present
641 if Has_Extension (Source) then
642 pragma Assert (Has_Extension (Destination));
643 Nodes.Table (Destination + 1) := Nodes.Table (Source + 1);
644 Nodes.Table (Destination + 2) := Nodes.Table (Source + 2);
645 Nodes.Table (Destination + 3) := Nodes.Table (Source + 3);
646 Nodes.Table (Destination + 4) := Nodes.Table (Source + 4);
649 pragma Assert (not Has_Extension (Source));
654 ------------------------
655 -- Copy_Separate_Tree --
656 ------------------------
658 function Copy_Separate_Tree (Source : Node_Id) return Node_Id is
661 function Copy_Entity (E : Entity_Id) return Entity_Id;
662 -- Copy Entity, copying only the Ekind and Chars fields
664 function Copy_List (List : List_Id) return List_Id;
667 function Possible_Copy (Field : Union_Id) return Union_Id;
668 -- Given a field, returns a copy of the node or list if its parent
669 -- is the current source node, and otherwise returns the input
675 function Copy_Entity (E : Entity_Id) return Entity_Id is
679 case N_Entity (Nkind (E)) is
680 when N_Defining_Identifier =>
681 New_Ent := New_Entity (N_Defining_Identifier, Sloc (E));
683 when N_Defining_Character_Literal =>
684 New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E));
686 when N_Defining_Operator_Symbol =>
687 New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E));
690 Set_Chars (New_Ent, Chars (E));
698 function Copy_List (List : List_Id) return List_Id is
703 if List = No_List then
710 while Present (E) loop
711 if Has_Extension (E) then
712 Append (Copy_Entity (E), NL);
714 Append (Copy_Separate_Tree (E), NL);
728 function Possible_Copy (Field : Union_Id) return Union_Id is
732 if Field in Node_Range then
733 New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field)));
735 if Parent (Node_Id (Field)) = Source then
736 Set_Parent (Node_Id (New_N), New_Id);
741 elsif Field in List_Range then
742 New_N := Union_Id (Copy_List (List_Id (Field)));
744 if Parent (List_Id (Field)) = Source then
745 Set_Parent (List_Id (New_N), New_Id);
755 -- Start of processing for Copy_Separate_Tree
758 if Source <= Empty_Or_Error then
761 elsif Has_Extension (Source) then
762 return Copy_Entity (Source);
765 New_Id := New_Copy (Source);
767 -- Recursively copy descendents
769 Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id)));
770 Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id)));
771 Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id)));
772 Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id)));
773 Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id)));
775 -- Set Entity field to Empty
776 -- Why is this done??? and why is it always right to do it???
778 if Nkind (New_Id) in N_Has_Entity
779 or else Nkind (New_Id) = N_Freeze_Entity
781 Set_Entity (New_Id, Empty);
784 -- All done, return copied node
788 end Copy_Separate_Tree;
794 function Ekind (E : Entity_Id) return Entity_Kind is
796 pragma Assert (Nkind (E) in N_Entity);
797 return N_To_E (Nodes.Table (E + 1).Nkind);
807 V2 : Entity_Kind) return Boolean
810 return T = V1 or else
818 V3 : Entity_Kind) return Boolean
821 return T = V1 or else
831 V4 : Entity_Kind) return Boolean
834 return T = V1 or else
846 V5 : Entity_Kind) return Boolean
849 return T = V1 or else
863 V6 : Entity_Kind) return Boolean
866 return T = V1 or else
877 V2 : Entity_Kind) return Boolean
880 return Ekind_In (Ekind (E), V1, V2);
887 V3 : Entity_Kind) return Boolean
890 return Ekind_In (Ekind (E), V1, V2, V3);
898 V4 : Entity_Kind) return Boolean
901 return Ekind_In (Ekind (E), V1, V2, V3, V4);
910 V5 : Entity_Kind) return Boolean
913 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5);
923 V6 : Entity_Kind) return Boolean
926 return Ekind_In (Ekind (E), V1, V2, V3, V4, V5, V6);
929 ------------------------
930 -- Set_Reporting_Proc --
931 ------------------------
933 procedure Set_Reporting_Proc (P : Report_Proc) is
935 pragma Assert (Reporting_Proc = null);
937 end Set_Reporting_Proc;
943 function Error_Posted (N : Node_Id) return Boolean is
945 pragma Assert (N <= Nodes.Last);
946 return Nodes.Table (N).Error_Posted;
949 -----------------------
950 -- Exchange_Entities --
951 -----------------------
953 procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is
954 Temp_Ent : Node_Record;
957 pragma Assert (Has_Extension (E1)
958 and then Has_Extension (E2)
959 and then not Nodes.Table (E1).In_List
960 and then not Nodes.Table (E2).In_List);
962 -- Exchange the contents of the two entities
964 Temp_Ent := Nodes.Table (E1);
965 Nodes.Table (E1) := Nodes.Table (E2);
966 Nodes.Table (E2) := Temp_Ent;
967 Temp_Ent := Nodes.Table (E1 + 1);
968 Nodes.Table (E1 + 1) := Nodes.Table (E2 + 1);
969 Nodes.Table (E2 + 1) := Temp_Ent;
970 Temp_Ent := Nodes.Table (E1 + 2);
971 Nodes.Table (E1 + 2) := Nodes.Table (E2 + 2);
972 Nodes.Table (E2 + 2) := Temp_Ent;
973 Temp_Ent := Nodes.Table (E1 + 3);
974 Nodes.Table (E1 + 3) := Nodes.Table (E2 + 3);
975 Nodes.Table (E2 + 3) := Temp_Ent;
976 Temp_Ent := Nodes.Table (E1 + 4);
977 Nodes.Table (E1 + 4) := Nodes.Table (E2 + 4);
978 Nodes.Table (E2 + 4) := Temp_Ent;
980 -- That exchange exchanged the parent pointers as well, which is what
981 -- we want, but we need to patch up the defining identifier pointers
982 -- in the parent nodes (the child pointers) to match this switch
983 -- unless for Implicit types entities which have no parent, in which
984 -- case we don't do anything otherwise we won't be able to revert back
985 -- to the original situation.
987 -- Shouldn't this use Is_Itype instead of the Parent test
989 if Present (Parent (E1)) and then Present (Parent (E2)) then
990 Set_Defining_Identifier (Parent (E1), E1);
991 Set_Defining_Identifier (Parent (E2), E2);
993 end Exchange_Entities;
999 function Extend_Node (Node : Node_Id) return Entity_Id is
1002 procedure Debug_Extend_Node;
1003 pragma Inline (Debug_Extend_Node);
1004 -- Debug routine for debug flag N
1006 -----------------------
1007 -- Debug_Extend_Node --
1008 -----------------------
1010 procedure Debug_Extend_Node is
1012 if Debug_Flag_N then
1013 Write_Str ("Extend node ");
1014 Write_Int (Int (Node));
1016 if Result = Node then
1017 Write_Str (" in place");
1019 Write_Str (" copied to ");
1020 Write_Int (Int (Result));
1025 end Debug_Extend_Node;
1027 -- Start of processing for Extend_Node
1030 pragma Assert (not (Has_Extension (Node)));
1031 Result := Allocate_Initialize_Node (Node, With_Extension => True);
1032 pragma Debug (Debug_Extend_Node);
1040 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id) is
1042 procedure Fix_Parent (Field : Union_Id);
1043 -- Fixup one parent pointer. Field is checked to see if it points to
1044 -- a node, list, or element list that has a parent that points to
1045 -- Ref_Node. If so, the parent is reset to point to Fix_Node.
1051 procedure Fix_Parent (Field : Union_Id) is
1053 -- Fix parent of node that is referenced by Field. Note that we must
1054 -- exclude the case where the node is a member of a list, because in
1055 -- this case the parent is the parent of the list.
1057 if Field in Node_Range
1058 and then Present (Node_Id (Field))
1059 and then not Nodes.Table (Node_Id (Field)).In_List
1060 and then Parent (Node_Id (Field)) = Ref_Node
1062 Set_Parent (Node_Id (Field), Fix_Node);
1064 -- Fix parent of list that is referenced by Field
1066 elsif Field in List_Range
1067 and then Present (List_Id (Field))
1068 and then Parent (List_Id (Field)) = Ref_Node
1070 Set_Parent (List_Id (Field), Fix_Node);
1074 -- Start of processing for Fix_Parents
1077 Fix_Parent (Field1 (Fix_Node));
1078 Fix_Parent (Field2 (Fix_Node));
1079 Fix_Parent (Field3 (Fix_Node));
1080 Fix_Parent (Field4 (Fix_Node));
1081 Fix_Parent (Field5 (Fix_Node));
1084 -----------------------------------
1085 -- Get_Comes_From_Source_Default --
1086 -----------------------------------
1088 function Get_Comes_From_Source_Default return Boolean is
1090 return Default_Node.Comes_From_Source;
1091 end Get_Comes_From_Source_Default;
1097 function Has_Extension (N : Node_Id) return Boolean is
1099 return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension;
1106 procedure Initialize is
1108 pragma Warnings (Off, Dummy);
1112 Atree_Private_Part.Nodes.Init;
1116 -- Allocate Empty node
1118 Dummy := New_Node (N_Empty, No_Location);
1119 Set_Name1 (Empty, No_Name);
1121 -- Allocate Error node, and set Error_Posted, since we certainly
1122 -- only generate an Error node if we do post some kind of error!
1124 Dummy := New_Node (N_Error, No_Location);
1125 Set_Name1 (Error, Error_Name);
1126 Set_Error_Posted (Error, True);
1129 --------------------------
1130 -- Is_Rewrite_Insertion --
1131 --------------------------
1133 function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is
1135 return Nodes.Table (Node).Rewrite_Ins;
1136 end Is_Rewrite_Insertion;
1138 -----------------------------
1139 -- Is_Rewrite_Substitution --
1140 -----------------------------
1142 function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is
1144 return Orig_Nodes.Table (Node) /= Node;
1145 end Is_Rewrite_Substitution;
1151 function Last_Node_Id return Node_Id is
1162 Nodes.Locked := True;
1163 Orig_Nodes.Locked := True;
1168 ----------------------------
1169 -- Mark_Rewrite_Insertion --
1170 ----------------------------
1172 procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is
1174 Nodes.Table (New_Node).Rewrite_Ins := True;
1175 end Mark_Rewrite_Insertion;
1181 function New_Copy (Source : Node_Id) return Node_Id is
1182 New_Id : Node_Id := Source;
1185 if Source > Empty_Or_Error then
1187 New_Id := Allocate_Initialize_Node (Source, Has_Extension (Source));
1189 Nodes.Table (New_Id).Link := Empty_List_Or_Node;
1190 Nodes.Table (New_Id).In_List := False;
1192 -- If the original is marked as a rewrite insertion, then unmark
1193 -- the copy, since we inserted the original, not the copy.
1195 Nodes.Table (New_Id).Rewrite_Ins := False;
1196 pragma Debug (New_Node_Debugging_Output (New_Id));
1207 (New_Node_Kind : Node_Kind;
1208 New_Sloc : Source_Ptr) return Entity_Id
1213 pragma Assert (New_Node_Kind in N_Entity);
1215 Ent := Allocate_Initialize_Node (Empty, With_Extension => True);
1217 -- If this is a node with a real location and we are generating
1218 -- source nodes, then reset Current_Error_Node. This is useful
1219 -- if we bomb during parsing to get a error location for the bomb.
1221 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1222 Current_Error_Node := Ent;
1225 Nodes.Table (Ent).Nkind := New_Node_Kind;
1226 Nodes.Table (Ent).Sloc := New_Sloc;
1227 pragma Debug (New_Node_Debugging_Output (Ent));
1237 (New_Node_Kind : Node_Kind;
1238 New_Sloc : Source_Ptr) return Node_Id
1243 pragma Assert (New_Node_Kind not in N_Entity);
1244 Nod := Allocate_Initialize_Node (Empty, With_Extension => False);
1245 Nodes.Table (Nod).Nkind := New_Node_Kind;
1246 Nodes.Table (Nod).Sloc := New_Sloc;
1247 pragma Debug (New_Node_Debugging_Output (Nod));
1249 -- If this is a node with a real location and we are generating source
1250 -- nodes, then reset Current_Error_Node. This is useful if we bomb
1251 -- during parsing to get an error location for the bomb.
1253 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1254 Current_Error_Node := Nod;
1260 -------------------------
1261 -- New_Node_Breakpoint --
1262 -------------------------
1266 Write_Str ("Watched node ");
1267 Write_Int (Int (Watch_Node));
1268 Write_Str (" created");
1272 -------------------------------
1273 -- New_Node_Debugging_Output --
1274 -------------------------------
1276 procedure nnd (N : Node_Id) is
1277 Node_Is_Watched : constant Boolean := N = Watch_Node;
1280 if Debug_Flag_N or else Node_Is_Watched then
1281 Node_Debug_Output ("Allocate", N);
1283 if Node_Is_Watched then
1284 New_Node_Breakpoint;
1293 function Nkind (N : Node_Id) return Node_Kind is
1295 return Nodes.Table (N).Nkind;
1305 V2 : Node_Kind) return Boolean
1308 return Nkind_In (Nkind (N), V1, V2);
1315 V3 : Node_Kind) return Boolean
1318 return Nkind_In (Nkind (N), V1, V2, V3);
1326 V4 : Node_Kind) return Boolean
1329 return Nkind_In (Nkind (N), V1, V2, V3, V4);
1338 V5 : Node_Kind) return Boolean
1341 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5);
1351 V6 : Node_Kind) return Boolean
1354 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6);
1365 V7 : Node_Kind) return Boolean
1368 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7);
1380 V8 : Node_Kind) return Boolean
1383 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8);
1396 V9 : Node_Kind) return Boolean
1399 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8, V9);
1406 function No (N : Node_Id) return Boolean is
1411 -----------------------
1412 -- Node_Debug_Output --
1413 -----------------------
1415 procedure Node_Debug_Output (Op : String; N : Node_Id) is
1419 if Nkind (N) in N_Entity then
1420 Write_Str (" entity");
1422 Write_Str (" node");
1425 Write_Str (" Id = ");
1426 Write_Int (Int (N));
1428 Write_Location (Sloc (N));
1430 Write_Str (Node_Kind'Image (Nkind (N)));
1432 end Node_Debug_Output;
1438 function Nodes_Address return System.Address is
1440 return Nodes.Table (First_Node_Id)'Address;
1447 function Num_Nodes return Nat is
1456 function Original_Node (Node : Node_Id) return Node_Id is
1458 return Orig_Nodes.Table (Node);
1465 function Paren_Count (N : Node_Id) return Nat is
1469 pragma Assert (N <= Nodes.Last);
1471 if Nodes.Table (N).Pflag1 then
1475 if Nodes.Table (N).Pflag2 then
1479 -- Value of 0,1,2 returned as is
1484 -- Value of 3 means we search the table, and we must find an entry
1487 for J in Paren_Counts.First .. Paren_Counts.Last loop
1488 if N = Paren_Counts.Table (J).Nod then
1489 return Paren_Counts.Table (J).Count;
1493 raise Program_Error;
1501 function Parent (N : Node_Id) return Node_Id is
1503 if Is_List_Member (N) then
1504 return Parent (List_Containing (N));
1506 return Node_Id (Nodes.Table (N).Link);
1514 function Present (N : Node_Id) return Boolean is
1519 --------------------------------
1520 -- Preserve_Comes_From_Source --
1521 --------------------------------
1523 procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is
1525 Nodes.Table (NewN).Comes_From_Source :=
1526 Nodes.Table (OldN).Comes_From_Source;
1527 end Preserve_Comes_From_Source;
1533 function Relocate_Node (Source : Node_Id) return Node_Id is
1541 New_Node := New_Copy (Source);
1542 Fix_Parents (Ref_Node => Source, Fix_Node => New_Node);
1544 -- We now set the parent of the new node to be the same as the
1545 -- parent of the source. Almost always this parent will be
1546 -- replaced by a new value when the relocated node is reattached
1547 -- to the tree, but by doing it now, we ensure that this node is
1548 -- not even temporarily disconnected from the tree. Note that this
1549 -- does not happen free, because in the list case, the parent does
1552 Set_Parent (New_Node, Parent (Source));
1554 -- If the node being relocated was a rewriting of some original
1555 -- node, then the relocated node has the same original node.
1557 if Orig_Nodes.Table (Source) /= Source then
1558 Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source);
1568 procedure Replace (Old_Node, New_Node : Node_Id) is
1569 Old_Post : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
1570 Old_CFS : constant Boolean := Nodes.Table (Old_Node).Comes_From_Source;
1574 (not Has_Extension (Old_Node)
1575 and not Has_Extension (New_Node)
1576 and not Nodes.Table (New_Node).In_List);
1578 -- Do copy, preserving link and in list status and comes from source
1580 Copy_Node (Source => New_Node, Destination => Old_Node);
1581 Nodes.Table (Old_Node).Comes_From_Source := Old_CFS;
1582 Nodes.Table (Old_Node).Error_Posted := Old_Post;
1584 -- Fix parents of substituted node, since it has changed identity
1586 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1588 -- Since we are doing a replace, we assume that the original node
1589 -- is intended to become the new replaced node. The call would be
1590 -- to Rewrite if there were an intention to save the original node.
1592 Orig_Nodes.Table (Old_Node) := Old_Node;
1594 -- Invoke the reporting procedure (if available)
1596 if Reporting_Proc /= null then
1597 Reporting_Proc.all (Target => Old_Node, Source => New_Node);
1605 procedure Rewrite (Old_Node, New_Node : Node_Id) is
1606 Old_Error_P : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
1607 -- This fields is always preserved in the new node
1609 Old_Paren_Count : Nat;
1610 Old_Must_Not_Freeze : Boolean;
1611 -- These fields are preserved in the new node only if the new node
1612 -- and the old node are both subexpression nodes.
1614 -- Note: it is a violation of abstraction levels for Must_Not_Freeze
1615 -- to be referenced like this. ???
1621 (not Has_Extension (Old_Node)
1622 and not Has_Extension (New_Node)
1623 and not Nodes.Table (New_Node).In_List);
1624 pragma Debug (Rewrite_Debugging_Output (Old_Node, New_Node));
1626 if Nkind (Old_Node) in N_Subexpr then
1627 Old_Paren_Count := Paren_Count (Old_Node);
1628 Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node);
1630 Old_Paren_Count := 0;
1631 Old_Must_Not_Freeze := False;
1634 -- Allocate a new node, to be used to preserve the original contents
1635 -- of the Old_Node, for possible later retrival by Original_Node and
1636 -- make an entry in the Orig_Nodes table. This is only done if we have
1637 -- not already rewritten the node, as indicated by an Orig_Nodes entry
1638 -- that does not reference the Old_Node.
1640 if Orig_Nodes.Table (Old_Node) = Old_Node then
1641 Sav_Node := New_Copy (Old_Node);
1642 Orig_Nodes.Table (Sav_Node) := Sav_Node;
1643 Orig_Nodes.Table (Old_Node) := Sav_Node;
1646 -- Copy substitute node into place, preserving old fields as required
1648 Copy_Node (Source => New_Node, Destination => Old_Node);
1649 Nodes.Table (Old_Node).Error_Posted := Old_Error_P;
1651 if Nkind (New_Node) in N_Subexpr then
1652 Set_Paren_Count (Old_Node, Old_Paren_Count);
1653 Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze);
1656 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1658 -- Invoke the reporting procedure (if available)
1660 if Reporting_Proc /= null then
1661 Reporting_Proc.all (Target => Old_Node, Source => New_Node);
1665 -------------------------
1666 -- Rewrite_Breakpoint --
1667 -------------------------
1671 Write_Str ("Watched node ");
1672 Write_Int (Int (Watch_Node));
1673 Write_Str (" rewritten");
1677 ------------------------------
1678 -- Rewrite_Debugging_Output --
1679 ------------------------------
1681 procedure rrd (Old_Node, New_Node : Node_Id) is
1682 Node_Is_Watched : constant Boolean := Old_Node = Watch_Node;
1685 if Debug_Flag_N or else Node_Is_Watched then
1686 Node_Debug_Output ("Rewrite", Old_Node);
1687 Node_Debug_Output ("into", New_Node);
1689 if Node_Is_Watched then
1699 procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is
1701 Nodes.Table (N).Analyzed := Val;
1704 ---------------------------
1705 -- Set_Comes_From_Source --
1706 ---------------------------
1708 procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is
1710 pragma Assert (N <= Nodes.Last);
1711 Nodes.Table (N).Comes_From_Source := Val;
1712 end Set_Comes_From_Source;
1714 -----------------------------------
1715 -- Set_Comes_From_Source_Default --
1716 -----------------------------------
1718 procedure Set_Comes_From_Source_Default (Default : Boolean) is
1720 Default_Node.Comes_From_Source := Default;
1721 end Set_Comes_From_Source_Default;
1727 procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is
1729 pragma Assert (Nkind (E) in N_Entity);
1730 Nodes.Table (E + 1).Nkind := E_To_N (Val);
1733 ----------------------
1734 -- Set_Error_Posted --
1735 ----------------------
1737 procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is
1739 Nodes.Table (N).Error_Posted := Val;
1740 end Set_Error_Posted;
1742 ---------------------
1743 -- Set_Paren_Count --
1744 ---------------------
1746 procedure Set_Paren_Count (N : Node_Id; Val : Nat) is
1748 pragma Assert (Nkind (N) in N_Subexpr);
1750 -- Value of 0,1,2 stored as is
1753 Nodes.Table (N).Pflag1 := (Val mod 2 /= 0);
1754 Nodes.Table (N).Pflag2 := (Val = 2);
1756 -- Value of 3 or greater stores 3 in node and makes table entry
1759 Nodes.Table (N).Pflag1 := True;
1760 Nodes.Table (N).Pflag2 := True;
1762 for J in Paren_Counts.First .. Paren_Counts.Last loop
1763 if N = Paren_Counts.Table (J).Nod then
1764 Paren_Counts.Table (J).Count := Val;
1769 Paren_Counts.Append ((Nod => N, Count => Val));
1771 end Set_Paren_Count;
1777 procedure Set_Parent (N : Node_Id; Val : Node_Id) is
1779 pragma Assert (not Nodes.Table (N).In_List);
1780 Nodes.Table (N).Link := Union_Id (Val);
1787 procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is
1789 Nodes.Table (N).Sloc := Val;
1796 function Sloc (N : Node_Id) return Source_Ptr is
1798 return Nodes.Table (N).Sloc;
1805 function Traverse_Func (Node : Node_Id) return Traverse_Final_Result is
1807 function Traverse_Field
1810 FN : Field_Num) return Traverse_Final_Result;
1811 -- Fld is one of the fields of Nod. If the field points to syntactic
1812 -- node or list, then this node or list is traversed, and the result is
1813 -- the result of this traversal. Otherwise a value of True is returned
1814 -- with no processing. FN is the number of the field (1 .. 5).
1816 --------------------
1817 -- Traverse_Field --
1818 --------------------
1820 function Traverse_Field
1823 FN : Field_Num) return Traverse_Final_Result
1826 if Fld = Union_Id (Empty) then
1829 -- Descendent is a node
1831 elsif Fld in Node_Range then
1833 -- Traverse descendent that is syntactic subtree node
1835 if Is_Syntactic_Field (Nkind (Nod), FN) then
1836 return Traverse_Func (Node_Id (Fld));
1838 -- Node that is not a syntactic subtree
1844 -- Descendent is a list
1846 elsif Fld in List_Range then
1848 -- Traverse descendent that is a syntactic subtree list
1850 if Is_Syntactic_Field (Nkind (Nod), FN) then
1852 Elmt : Node_Id := First (List_Id (Fld));
1854 while Present (Elmt) loop
1855 if Traverse_Func (Elmt) = Abandon then
1865 -- List that is not a syntactic subtree
1871 -- Field was not a node or a list
1878 Cur_Node : Node_Id := Node;
1880 -- Start of processing for Traverse_Func
1883 -- We walk Field2 last, and if it is a node, we eliminate the tail
1884 -- recursion by jumping back to this label. This is because Field2 is
1885 -- where the Left_Opnd field of N_Op_Concat is stored, and in practice
1886 -- concatenations are sometimes deeply nested, as in X1&X2&...&XN. This
1887 -- trick prevents us from running out of memory in that case. We don't
1888 -- bother eliminating the tail recursion if Field2 is a list.
1892 case Process (Cur_Node) is
1903 Cur_Node := Original_Node (Cur_Node);
1906 if Traverse_Field (Cur_Node, Field1 (Cur_Node), 1) = Abandon
1907 or else -- skip Field2 here
1908 Traverse_Field (Cur_Node, Field3 (Cur_Node), 3) = Abandon
1910 Traverse_Field (Cur_Node, Field4 (Cur_Node), 4) = Abandon
1912 Traverse_Field (Cur_Node, Field5 (Cur_Node), 5) = Abandon
1917 if Field2 (Cur_Node) not in Node_Range then
1918 return Traverse_Field (Cur_Node, Field2 (Cur_Node), 2);
1920 elsif Is_Syntactic_Field (Nkind (Cur_Node), 2)
1921 and then Field2 (Cur_Node) /= Empty_List_Or_Node
1923 -- Here is the tail recursion step, we reset Cur_Node and jump back
1924 -- to the start of the procedure, which has the same semantic effect
1927 Cur_Node := Node_Id (Field2 (Cur_Node));
1938 procedure Traverse_Proc (Node : Node_Id) is
1939 function Traverse is new Traverse_Func (Process);
1940 Discard : Traverse_Final_Result;
1941 pragma Warnings (Off, Discard);
1943 Discard := Traverse (Node);
1950 procedure Tree_Read is
1952 Tree_Read_Int (Node_Count);
1954 Orig_Nodes.Tree_Read;
1955 Paren_Counts.Tree_Read;
1962 procedure Tree_Write is
1964 Tree_Write_Int (Node_Count);
1966 Orig_Nodes.Tree_Write;
1967 Paren_Counts.Tree_Write;
1970 ------------------------------
1971 -- Unchecked Access Package --
1972 ------------------------------
1974 package body Unchecked_Access is
1976 function Field1 (N : Node_Id) return Union_Id is
1978 pragma Assert (N <= Nodes.Last);
1979 return Nodes.Table (N).Field1;
1982 function Field2 (N : Node_Id) return Union_Id is
1984 pragma Assert (N <= Nodes.Last);
1985 return Nodes.Table (N).Field2;
1988 function Field3 (N : Node_Id) return Union_Id is
1990 pragma Assert (N <= Nodes.Last);
1991 return Nodes.Table (N).Field3;
1994 function Field4 (N : Node_Id) return Union_Id is
1996 pragma Assert (N <= Nodes.Last);
1997 return Nodes.Table (N).Field4;
2000 function Field5 (N : Node_Id) return Union_Id is
2002 pragma Assert (N <= Nodes.Last);
2003 return Nodes.Table (N).Field5;
2006 function Field6 (N : Node_Id) return Union_Id is
2008 pragma Assert (Nkind (N) in N_Entity);
2009 return Nodes.Table (N + 1).Field6;
2012 function Field7 (N : Node_Id) return Union_Id is
2014 pragma Assert (Nkind (N) in N_Entity);
2015 return Nodes.Table (N + 1).Field7;
2018 function Field8 (N : Node_Id) return Union_Id is
2020 pragma Assert (Nkind (N) in N_Entity);
2021 return Nodes.Table (N + 1).Field8;
2024 function Field9 (N : Node_Id) return Union_Id is
2026 pragma Assert (Nkind (N) in N_Entity);
2027 return Nodes.Table (N + 1).Field9;
2030 function Field10 (N : Node_Id) return Union_Id is
2032 pragma Assert (Nkind (N) in N_Entity);
2033 return Nodes.Table (N + 1).Field10;
2036 function Field11 (N : Node_Id) return Union_Id is
2038 pragma Assert (Nkind (N) in N_Entity);
2039 return Nodes.Table (N + 1).Field11;
2042 function Field12 (N : Node_Id) return Union_Id is
2044 pragma Assert (Nkind (N) in N_Entity);
2045 return Nodes.Table (N + 1).Field12;
2048 function Field13 (N : Node_Id) return Union_Id is
2050 pragma Assert (Nkind (N) in N_Entity);
2051 return Nodes.Table (N + 2).Field6;
2054 function Field14 (N : Node_Id) return Union_Id is
2056 pragma Assert (Nkind (N) in N_Entity);
2057 return Nodes.Table (N + 2).Field7;
2060 function Field15 (N : Node_Id) return Union_Id is
2062 pragma Assert (Nkind (N) in N_Entity);
2063 return Nodes.Table (N + 2).Field8;
2066 function Field16 (N : Node_Id) return Union_Id is
2068 pragma Assert (Nkind (N) in N_Entity);
2069 return Nodes.Table (N + 2).Field9;
2072 function Field17 (N : Node_Id) return Union_Id is
2074 pragma Assert (Nkind (N) in N_Entity);
2075 return Nodes.Table (N + 2).Field10;
2078 function Field18 (N : Node_Id) return Union_Id is
2080 pragma Assert (Nkind (N) in N_Entity);
2081 return Nodes.Table (N + 2).Field11;
2084 function Field19 (N : Node_Id) return Union_Id is
2086 pragma Assert (Nkind (N) in N_Entity);
2087 return Nodes.Table (N + 3).Field6;
2090 function Field20 (N : Node_Id) return Union_Id is
2092 pragma Assert (Nkind (N) in N_Entity);
2093 return Nodes.Table (N + 3).Field7;
2096 function Field21 (N : Node_Id) return Union_Id is
2098 pragma Assert (Nkind (N) in N_Entity);
2099 return Nodes.Table (N + 3).Field8;
2102 function Field22 (N : Node_Id) return Union_Id is
2104 pragma Assert (Nkind (N) in N_Entity);
2105 return Nodes.Table (N + 3).Field9;
2108 function Field23 (N : Node_Id) return Union_Id is
2110 pragma Assert (Nkind (N) in N_Entity);
2111 return Nodes.Table (N + 3).Field10;
2114 function Field24 (N : Node_Id) return Union_Id is
2116 pragma Assert (Nkind (N) in N_Entity);
2117 return Nodes.Table (N + 4).Field6;
2120 function Field25 (N : Node_Id) return Union_Id is
2122 pragma Assert (Nkind (N) in N_Entity);
2123 return Nodes.Table (N + 4).Field7;
2126 function Field26 (N : Node_Id) return Union_Id is
2128 pragma Assert (Nkind (N) in N_Entity);
2129 return Nodes.Table (N + 4).Field8;
2132 function Field27 (N : Node_Id) return Union_Id is
2134 pragma Assert (Nkind (N) in N_Entity);
2135 return Nodes.Table (N + 4).Field9;
2138 function Field28 (N : Node_Id) return Union_Id is
2140 pragma Assert (Nkind (N) in N_Entity);
2141 return Nodes.Table (N + 4).Field10;
2144 function Node1 (N : Node_Id) return Node_Id is
2146 pragma Assert (N <= Nodes.Last);
2147 return Node_Id (Nodes.Table (N).Field1);
2150 function Node2 (N : Node_Id) return Node_Id is
2152 pragma Assert (N <= Nodes.Last);
2153 return Node_Id (Nodes.Table (N).Field2);
2156 function Node3 (N : Node_Id) return Node_Id is
2158 pragma Assert (N <= Nodes.Last);
2159 return Node_Id (Nodes.Table (N).Field3);
2162 function Node4 (N : Node_Id) return Node_Id is
2164 pragma Assert (N <= Nodes.Last);
2165 return Node_Id (Nodes.Table (N).Field4);
2168 function Node5 (N : Node_Id) return Node_Id is
2170 pragma Assert (N <= Nodes.Last);
2171 return Node_Id (Nodes.Table (N).Field5);
2174 function Node6 (N : Node_Id) return Node_Id is
2176 pragma Assert (Nkind (N) in N_Entity);
2177 return Node_Id (Nodes.Table (N + 1).Field6);
2180 function Node7 (N : Node_Id) return Node_Id is
2182 pragma Assert (Nkind (N) in N_Entity);
2183 return Node_Id (Nodes.Table (N + 1).Field7);
2186 function Node8 (N : Node_Id) return Node_Id is
2188 pragma Assert (Nkind (N) in N_Entity);
2189 return Node_Id (Nodes.Table (N + 1).Field8);
2192 function Node9 (N : Node_Id) return Node_Id is
2194 pragma Assert (Nkind (N) in N_Entity);
2195 return Node_Id (Nodes.Table (N + 1).Field9);
2198 function Node10 (N : Node_Id) return Node_Id is
2200 pragma Assert (Nkind (N) in N_Entity);
2201 return Node_Id (Nodes.Table (N + 1).Field10);
2204 function Node11 (N : Node_Id) return Node_Id is
2206 pragma Assert (Nkind (N) in N_Entity);
2207 return Node_Id (Nodes.Table (N + 1).Field11);
2210 function Node12 (N : Node_Id) return Node_Id is
2212 pragma Assert (Nkind (N) in N_Entity);
2213 return Node_Id (Nodes.Table (N + 1).Field12);
2216 function Node13 (N : Node_Id) return Node_Id is
2218 pragma Assert (Nkind (N) in N_Entity);
2219 return Node_Id (Nodes.Table (N + 2).Field6);
2222 function Node14 (N : Node_Id) return Node_Id is
2224 pragma Assert (Nkind (N) in N_Entity);
2225 return Node_Id (Nodes.Table (N + 2).Field7);
2228 function Node15 (N : Node_Id) return Node_Id is
2230 pragma Assert (Nkind (N) in N_Entity);
2231 return Node_Id (Nodes.Table (N + 2).Field8);
2234 function Node16 (N : Node_Id) return Node_Id is
2236 pragma Assert (Nkind (N) in N_Entity);
2237 return Node_Id (Nodes.Table (N + 2).Field9);
2240 function Node17 (N : Node_Id) return Node_Id is
2242 pragma Assert (Nkind (N) in N_Entity);
2243 return Node_Id (Nodes.Table (N + 2).Field10);
2246 function Node18 (N : Node_Id) return Node_Id is
2248 pragma Assert (Nkind (N) in N_Entity);
2249 return Node_Id (Nodes.Table (N + 2).Field11);
2252 function Node19 (N : Node_Id) return Node_Id is
2254 pragma Assert (Nkind (N) in N_Entity);
2255 return Node_Id (Nodes.Table (N + 3).Field6);
2258 function Node20 (N : Node_Id) return Node_Id is
2260 pragma Assert (Nkind (N) in N_Entity);
2261 return Node_Id (Nodes.Table (N + 3).Field7);
2264 function Node21 (N : Node_Id) return Node_Id is
2266 pragma Assert (Nkind (N) in N_Entity);
2267 return Node_Id (Nodes.Table (N + 3).Field8);
2270 function Node22 (N : Node_Id) return Node_Id is
2272 pragma Assert (Nkind (N) in N_Entity);
2273 return Node_Id (Nodes.Table (N + 3).Field9);
2276 function Node23 (N : Node_Id) return Node_Id is
2278 pragma Assert (Nkind (N) in N_Entity);
2279 return Node_Id (Nodes.Table (N + 3).Field10);
2282 function Node24 (N : Node_Id) return Node_Id is
2284 pragma Assert (Nkind (N) in N_Entity);
2285 return Node_Id (Nodes.Table (N + 4).Field6);
2288 function Node25 (N : Node_Id) return Node_Id is
2290 pragma Assert (Nkind (N) in N_Entity);
2291 return Node_Id (Nodes.Table (N + 4).Field7);
2294 function Node26 (N : Node_Id) return Node_Id is
2296 pragma Assert (Nkind (N) in N_Entity);
2297 return Node_Id (Nodes.Table (N + 4).Field8);
2300 function Node27 (N : Node_Id) return Node_Id is
2302 pragma Assert (Nkind (N) in N_Entity);
2303 return Node_Id (Nodes.Table (N + 4).Field9);
2306 function Node28 (N : Node_Id) return Node_Id is
2308 pragma Assert (Nkind (N) in N_Entity);
2309 return Node_Id (Nodes.Table (N + 4).Field10);
2312 function List1 (N : Node_Id) return List_Id is
2314 pragma Assert (N <= Nodes.Last);
2315 return List_Id (Nodes.Table (N).Field1);
2318 function List2 (N : Node_Id) return List_Id is
2320 pragma Assert (N <= Nodes.Last);
2321 return List_Id (Nodes.Table (N).Field2);
2324 function List3 (N : Node_Id) return List_Id is
2326 pragma Assert (N <= Nodes.Last);
2327 return List_Id (Nodes.Table (N).Field3);
2330 function List4 (N : Node_Id) return List_Id is
2332 pragma Assert (N <= Nodes.Last);
2333 return List_Id (Nodes.Table (N).Field4);
2336 function List5 (N : Node_Id) return List_Id is
2338 pragma Assert (N <= Nodes.Last);
2339 return List_Id (Nodes.Table (N).Field5);
2342 function List10 (N : Node_Id) return List_Id is
2344 pragma Assert (Nkind (N) in N_Entity);
2345 return List_Id (Nodes.Table (N + 1).Field10);
2348 function List14 (N : Node_Id) return List_Id is
2350 pragma Assert (Nkind (N) in N_Entity);
2351 return List_Id (Nodes.Table (N + 2).Field7);
2354 function Elist1 (N : Node_Id) return Elist_Id is
2355 pragma Assert (N <= Nodes.Last);
2356 Value : constant Union_Id := Nodes.Table (N).Field1;
2361 return Elist_Id (Value);
2365 function Elist2 (N : Node_Id) return Elist_Id is
2366 pragma Assert (N <= Nodes.Last);
2367 Value : constant Union_Id := Nodes.Table (N).Field2;
2372 return Elist_Id (Value);
2376 function Elist3 (N : Node_Id) return Elist_Id is
2377 pragma Assert (N <= Nodes.Last);
2378 Value : constant Union_Id := Nodes.Table (N).Field3;
2383 return Elist_Id (Value);
2387 function Elist4 (N : Node_Id) return Elist_Id is
2388 pragma Assert (N <= Nodes.Last);
2389 Value : constant Union_Id := Nodes.Table (N).Field4;
2394 return Elist_Id (Value);
2398 function Elist8 (N : Node_Id) return Elist_Id is
2399 pragma Assert (Nkind (N) in N_Entity);
2400 Value : constant Union_Id := Nodes.Table (N + 1).Field8;
2405 return Elist_Id (Value);
2409 function Elist13 (N : Node_Id) return Elist_Id is
2410 pragma Assert (Nkind (N) in N_Entity);
2411 Value : constant Union_Id := Nodes.Table (N + 2).Field6;
2416 return Elist_Id (Value);
2420 function Elist15 (N : Node_Id) return Elist_Id is
2421 pragma Assert (Nkind (N) in N_Entity);
2422 Value : constant Union_Id := Nodes.Table (N + 2).Field8;
2427 return Elist_Id (Value);
2431 function Elist16 (N : Node_Id) return Elist_Id is
2432 pragma Assert (Nkind (N) in N_Entity);
2433 Value : constant Union_Id := Nodes.Table (N + 2).Field9;
2438 return Elist_Id (Value);
2442 function Elist18 (N : Node_Id) return Elist_Id is
2443 pragma Assert (Nkind (N) in N_Entity);
2444 Value : constant Union_Id := Nodes.Table (N + 2).Field11;
2449 return Elist_Id (Value);
2453 function Elist21 (N : Node_Id) return Elist_Id is
2454 pragma Assert (Nkind (N) in N_Entity);
2455 Value : constant Union_Id := Nodes.Table (N + 3).Field8;
2460 return Elist_Id (Value);
2464 function Elist23 (N : Node_Id) return Elist_Id is
2465 pragma Assert (Nkind (N) in N_Entity);
2466 Value : constant Union_Id := Nodes.Table (N + 3).Field10;
2471 return Elist_Id (Value);
2475 function Elist25 (N : Node_Id) return Elist_Id is
2476 pragma Assert (Nkind (N) in N_Entity);
2477 Value : constant Union_Id := Nodes.Table (N + 4).Field7;
2482 return Elist_Id (Value);
2486 function Elist26 (N : Node_Id) return Elist_Id is
2487 pragma Assert (Nkind (N) in N_Entity);
2488 Value : constant Union_Id := Nodes.Table (N + 4).Field8;
2493 return Elist_Id (Value);
2497 function Name1 (N : Node_Id) return Name_Id is
2499 pragma Assert (N <= Nodes.Last);
2500 return Name_Id (Nodes.Table (N).Field1);
2503 function Name2 (N : Node_Id) return Name_Id is
2505 pragma Assert (N <= Nodes.Last);
2506 return Name_Id (Nodes.Table (N).Field2);
2509 function Str3 (N : Node_Id) return String_Id is
2511 pragma Assert (N <= Nodes.Last);
2512 return String_Id (Nodes.Table (N).Field3);
2515 function Uint2 (N : Node_Id) return Uint is
2516 pragma Assert (N <= Nodes.Last);
2517 U : constant Union_Id := Nodes.Table (N).Field2;
2522 return From_Union (U);
2526 function Uint3 (N : Node_Id) return Uint is
2527 pragma Assert (N <= Nodes.Last);
2528 U : constant Union_Id := Nodes.Table (N).Field3;
2533 return From_Union (U);
2537 function Uint4 (N : Node_Id) return Uint is
2538 pragma Assert (N <= Nodes.Last);
2539 U : constant Union_Id := Nodes.Table (N).Field4;
2544 return From_Union (U);
2548 function Uint5 (N : Node_Id) return Uint is
2549 pragma Assert (N <= Nodes.Last);
2550 U : constant Union_Id := Nodes.Table (N).Field5;
2555 return From_Union (U);
2559 function Uint8 (N : Node_Id) return Uint is
2560 pragma Assert (Nkind (N) in N_Entity);
2561 U : constant Union_Id := Nodes.Table (N + 1).Field8;
2566 return From_Union (U);
2570 function Uint9 (N : Node_Id) return Uint is
2571 pragma Assert (Nkind (N) in N_Entity);
2572 U : constant Union_Id := Nodes.Table (N + 1).Field9;
2577 return From_Union (U);
2581 function Uint10 (N : Node_Id) return Uint is
2582 pragma Assert (Nkind (N) in N_Entity);
2583 U : constant Union_Id := Nodes.Table (N + 1).Field10;
2588 return From_Union (U);
2592 function Uint11 (N : Node_Id) return Uint is
2593 pragma Assert (Nkind (N) in N_Entity);
2594 U : constant Union_Id := Nodes.Table (N + 1).Field11;
2599 return From_Union (U);
2603 function Uint12 (N : Node_Id) return Uint is
2604 pragma Assert (Nkind (N) in N_Entity);
2605 U : constant Union_Id := Nodes.Table (N + 1).Field12;
2610 return From_Union (U);
2614 function Uint13 (N : Node_Id) return Uint is
2615 pragma Assert (Nkind (N) in N_Entity);
2616 U : constant Union_Id := Nodes.Table (N + 2).Field6;
2621 return From_Union (U);
2625 function Uint14 (N : Node_Id) return Uint is
2626 pragma Assert (Nkind (N) in N_Entity);
2627 U : constant Union_Id := Nodes.Table (N + 2).Field7;
2632 return From_Union (U);
2636 function Uint15 (N : Node_Id) return Uint is
2637 pragma Assert (Nkind (N) in N_Entity);
2638 U : constant Union_Id := Nodes.Table (N + 2).Field8;
2643 return From_Union (U);
2647 function Uint16 (N : Node_Id) return Uint is
2648 pragma Assert (Nkind (N) in N_Entity);
2649 U : constant Union_Id := Nodes.Table (N + 2).Field9;
2654 return From_Union (U);
2658 function Uint17 (N : Node_Id) return Uint is
2659 pragma Assert (Nkind (N) in N_Entity);
2660 U : constant Union_Id := Nodes.Table (N + 2).Field10;
2665 return From_Union (U);
2669 function Uint22 (N : Node_Id) return Uint is
2670 pragma Assert (Nkind (N) in N_Entity);
2671 U : constant Union_Id := Nodes.Table (N + 3).Field9;
2676 return From_Union (U);
2680 function Ureal3 (N : Node_Id) return Ureal is
2682 pragma Assert (N <= Nodes.Last);
2683 return From_Union (Nodes.Table (N).Field3);
2686 function Ureal18 (N : Node_Id) return Ureal is
2688 pragma Assert (Nkind (N) in N_Entity);
2689 return From_Union (Nodes.Table (N + 2).Field11);
2692 function Ureal21 (N : Node_Id) return Ureal is
2694 pragma Assert (Nkind (N) in N_Entity);
2695 return From_Union (Nodes.Table (N + 3).Field8);
2698 function Flag4 (N : Node_Id) return Boolean is
2700 pragma Assert (N <= Nodes.Last);
2701 return Nodes.Table (N).Flag4;
2704 function Flag5 (N : Node_Id) return Boolean is
2706 pragma Assert (N <= Nodes.Last);
2707 return Nodes.Table (N).Flag5;
2710 function Flag6 (N : Node_Id) return Boolean is
2712 pragma Assert (N <= Nodes.Last);
2713 return Nodes.Table (N).Flag6;
2716 function Flag7 (N : Node_Id) return Boolean is
2718 pragma Assert (N <= Nodes.Last);
2719 return Nodes.Table (N).Flag7;
2722 function Flag8 (N : Node_Id) return Boolean is
2724 pragma Assert (N <= Nodes.Last);
2725 return Nodes.Table (N).Flag8;
2728 function Flag9 (N : Node_Id) return Boolean is
2730 pragma Assert (N <= Nodes.Last);
2731 return Nodes.Table (N).Flag9;
2734 function Flag10 (N : Node_Id) return Boolean is
2736 pragma Assert (N <= Nodes.Last);
2737 return Nodes.Table (N).Flag10;
2740 function Flag11 (N : Node_Id) return Boolean is
2742 pragma Assert (N <= Nodes.Last);
2743 return Nodes.Table (N).Flag11;
2746 function Flag12 (N : Node_Id) return Boolean is
2748 pragma Assert (N <= Nodes.Last);
2749 return Nodes.Table (N).Flag12;
2752 function Flag13 (N : Node_Id) return Boolean is
2754 pragma Assert (N <= Nodes.Last);
2755 return Nodes.Table (N).Flag13;
2758 function Flag14 (N : Node_Id) return Boolean is
2760 pragma Assert (N <= Nodes.Last);
2761 return Nodes.Table (N).Flag14;
2764 function Flag15 (N : Node_Id) return Boolean is
2766 pragma Assert (N <= Nodes.Last);
2767 return Nodes.Table (N).Flag15;
2770 function Flag16 (N : Node_Id) return Boolean is
2772 pragma Assert (N <= Nodes.Last);
2773 return Nodes.Table (N).Flag16;
2776 function Flag17 (N : Node_Id) return Boolean is
2778 pragma Assert (N <= Nodes.Last);
2779 return Nodes.Table (N).Flag17;
2782 function Flag18 (N : Node_Id) return Boolean is
2784 pragma Assert (N <= Nodes.Last);
2785 return Nodes.Table (N).Flag18;
2788 function Flag19 (N : Node_Id) return Boolean is
2790 pragma Assert (Nkind (N) in N_Entity);
2791 return Nodes.Table (N + 1).In_List;
2794 function Flag20 (N : Node_Id) return Boolean is
2796 pragma Assert (Nkind (N) in N_Entity);
2797 return Nodes.Table (N + 1).Unused_1;
2800 function Flag21 (N : Node_Id) return Boolean is
2802 pragma Assert (Nkind (N) in N_Entity);
2803 return Nodes.Table (N + 1).Rewrite_Ins;
2806 function Flag22 (N : Node_Id) return Boolean is
2808 pragma Assert (Nkind (N) in N_Entity);
2809 return Nodes.Table (N + 1).Analyzed;
2812 function Flag23 (N : Node_Id) return Boolean is
2814 pragma Assert (Nkind (N) in N_Entity);
2815 return Nodes.Table (N + 1).Comes_From_Source;
2818 function Flag24 (N : Node_Id) return Boolean is
2820 pragma Assert (Nkind (N) in N_Entity);
2821 return Nodes.Table (N + 1).Error_Posted;
2824 function Flag25 (N : Node_Id) return Boolean is
2826 pragma Assert (Nkind (N) in N_Entity);
2827 return Nodes.Table (N + 1).Flag4;
2830 function Flag26 (N : Node_Id) return Boolean is
2832 pragma Assert (Nkind (N) in N_Entity);
2833 return Nodes.Table (N + 1).Flag5;
2836 function Flag27 (N : Node_Id) return Boolean is
2838 pragma Assert (Nkind (N) in N_Entity);
2839 return Nodes.Table (N + 1).Flag6;
2842 function Flag28 (N : Node_Id) return Boolean is
2844 pragma Assert (Nkind (N) in N_Entity);
2845 return Nodes.Table (N + 1).Flag7;
2848 function Flag29 (N : Node_Id) return Boolean is
2850 pragma Assert (Nkind (N) in N_Entity);
2851 return Nodes.Table (N + 1).Flag8;
2854 function Flag30 (N : Node_Id) return Boolean is
2856 pragma Assert (Nkind (N) in N_Entity);
2857 return Nodes.Table (N + 1).Flag9;
2860 function Flag31 (N : Node_Id) return Boolean is
2862 pragma Assert (Nkind (N) in N_Entity);
2863 return Nodes.Table (N + 1).Flag10;
2866 function Flag32 (N : Node_Id) return Boolean is
2868 pragma Assert (Nkind (N) in N_Entity);
2869 return Nodes.Table (N + 1).Flag11;
2872 function Flag33 (N : Node_Id) return Boolean is
2874 pragma Assert (Nkind (N) in N_Entity);
2875 return Nodes.Table (N + 1).Flag12;
2878 function Flag34 (N : Node_Id) return Boolean is
2880 pragma Assert (Nkind (N) in N_Entity);
2881 return Nodes.Table (N + 1).Flag13;
2884 function Flag35 (N : Node_Id) return Boolean is
2886 pragma Assert (Nkind (N) in N_Entity);
2887 return Nodes.Table (N + 1).Flag14;
2890 function Flag36 (N : Node_Id) return Boolean is
2892 pragma Assert (Nkind (N) in N_Entity);
2893 return Nodes.Table (N + 1).Flag15;
2896 function Flag37 (N : Node_Id) return Boolean is
2898 pragma Assert (Nkind (N) in N_Entity);
2899 return Nodes.Table (N + 1).Flag16;
2902 function Flag38 (N : Node_Id) return Boolean is
2904 pragma Assert (Nkind (N) in N_Entity);
2905 return Nodes.Table (N + 1).Flag17;
2908 function Flag39 (N : Node_Id) return Boolean is
2910 pragma Assert (Nkind (N) in N_Entity);
2911 return Nodes.Table (N + 1).Flag18;
2914 function Flag40 (N : Node_Id) return Boolean is
2916 pragma Assert (Nkind (N) in N_Entity);
2917 return Nodes.Table (N + 2).In_List;
2920 function Flag41 (N : Node_Id) return Boolean is
2922 pragma Assert (Nkind (N) in N_Entity);
2923 return Nodes.Table (N + 2).Unused_1;
2926 function Flag42 (N : Node_Id) return Boolean is
2928 pragma Assert (Nkind (N) in N_Entity);
2929 return Nodes.Table (N + 2).Rewrite_Ins;
2932 function Flag43 (N : Node_Id) return Boolean is
2934 pragma Assert (Nkind (N) in N_Entity);
2935 return Nodes.Table (N + 2).Analyzed;
2938 function Flag44 (N : Node_Id) return Boolean is
2940 pragma Assert (Nkind (N) in N_Entity);
2941 return Nodes.Table (N + 2).Comes_From_Source;
2944 function Flag45 (N : Node_Id) return Boolean is
2946 pragma Assert (Nkind (N) in N_Entity);
2947 return Nodes.Table (N + 2).Error_Posted;
2950 function Flag46 (N : Node_Id) return Boolean is
2952 pragma Assert (Nkind (N) in N_Entity);
2953 return Nodes.Table (N + 2).Flag4;
2956 function Flag47 (N : Node_Id) return Boolean is
2958 pragma Assert (Nkind (N) in N_Entity);
2959 return Nodes.Table (N + 2).Flag5;
2962 function Flag48 (N : Node_Id) return Boolean is
2964 pragma Assert (Nkind (N) in N_Entity);
2965 return Nodes.Table (N + 2).Flag6;
2968 function Flag49 (N : Node_Id) return Boolean is
2970 pragma Assert (Nkind (N) in N_Entity);
2971 return Nodes.Table (N + 2).Flag7;
2974 function Flag50 (N : Node_Id) return Boolean is
2976 pragma Assert (Nkind (N) in N_Entity);
2977 return Nodes.Table (N + 2).Flag8;
2980 function Flag51 (N : Node_Id) return Boolean is
2982 pragma Assert (Nkind (N) in N_Entity);
2983 return Nodes.Table (N + 2).Flag9;
2986 function Flag52 (N : Node_Id) return Boolean is
2988 pragma Assert (Nkind (N) in N_Entity);
2989 return Nodes.Table (N + 2).Flag10;
2992 function Flag53 (N : Node_Id) return Boolean is
2994 pragma Assert (Nkind (N) in N_Entity);
2995 return Nodes.Table (N + 2).Flag11;
2998 function Flag54 (N : Node_Id) return Boolean is
3000 pragma Assert (Nkind (N) in N_Entity);
3001 return Nodes.Table (N + 2).Flag12;
3004 function Flag55 (N : Node_Id) return Boolean is
3006 pragma Assert (Nkind (N) in N_Entity);
3007 return Nodes.Table (N + 2).Flag13;
3010 function Flag56 (N : Node_Id) return Boolean is
3012 pragma Assert (Nkind (N) in N_Entity);
3013 return Nodes.Table (N + 2).Flag14;
3016 function Flag57 (N : Node_Id) return Boolean is
3018 pragma Assert (Nkind (N) in N_Entity);
3019 return Nodes.Table (N + 2).Flag15;
3022 function Flag58 (N : Node_Id) return Boolean is
3024 pragma Assert (Nkind (N) in N_Entity);
3025 return Nodes.Table (N + 2).Flag16;
3028 function Flag59 (N : Node_Id) return Boolean is
3030 pragma Assert (Nkind (N) in N_Entity);
3031 return Nodes.Table (N + 2).Flag17;
3034 function Flag60 (N : Node_Id) return Boolean is
3036 pragma Assert (Nkind (N) in N_Entity);
3037 return Nodes.Table (N + 2).Flag18;
3040 function Flag61 (N : Node_Id) return Boolean is
3042 pragma Assert (Nkind (N) in N_Entity);
3043 return Nodes.Table (N + 1).Pflag1;
3046 function Flag62 (N : Node_Id) return Boolean is
3048 pragma Assert (Nkind (N) in N_Entity);
3049 return Nodes.Table (N + 1).Pflag2;
3052 function Flag63 (N : Node_Id) return Boolean is
3054 pragma Assert (Nkind (N) in N_Entity);
3055 return Nodes.Table (N + 2).Pflag1;
3058 function Flag64 (N : Node_Id) return Boolean is
3060 pragma Assert (Nkind (N) in N_Entity);
3061 return Nodes.Table (N + 2).Pflag2;
3064 function Flag65 (N : Node_Id) return Boolean is
3066 pragma Assert (Nkind (N) in N_Entity);
3067 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
3070 function Flag66 (N : Node_Id) return Boolean is
3072 pragma Assert (Nkind (N) in N_Entity);
3073 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
3076 function Flag67 (N : Node_Id) return Boolean is
3078 pragma Assert (Nkind (N) in N_Entity);
3079 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
3082 function Flag68 (N : Node_Id) return Boolean is
3084 pragma Assert (Nkind (N) in N_Entity);
3085 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
3088 function Flag69 (N : Node_Id) return Boolean is
3090 pragma Assert (Nkind (N) in N_Entity);
3091 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
3094 function Flag70 (N : Node_Id) return Boolean is
3096 pragma Assert (Nkind (N) in N_Entity);
3097 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
3100 function Flag71 (N : Node_Id) return Boolean is
3102 pragma Assert (Nkind (N) in N_Entity);
3103 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
3106 function Flag72 (N : Node_Id) return Boolean is
3108 pragma Assert (Nkind (N) in N_Entity);
3109 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
3112 function Flag73 (N : Node_Id) return Boolean is
3114 pragma Assert (Nkind (N) in N_Entity);
3115 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
3118 function Flag74 (N : Node_Id) return Boolean is
3120 pragma Assert (Nkind (N) in N_Entity);
3121 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
3124 function Flag75 (N : Node_Id) return Boolean is
3126 pragma Assert (Nkind (N) in N_Entity);
3127 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
3130 function Flag76 (N : Node_Id) return Boolean is
3132 pragma Assert (Nkind (N) in N_Entity);
3133 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
3136 function Flag77 (N : Node_Id) return Boolean is
3138 pragma Assert (Nkind (N) in N_Entity);
3139 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
3142 function Flag78 (N : Node_Id) return Boolean is
3144 pragma Assert (Nkind (N) in N_Entity);
3145 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
3148 function Flag79 (N : Node_Id) return Boolean is
3150 pragma Assert (Nkind (N) in N_Entity);
3151 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
3154 function Flag80 (N : Node_Id) return Boolean is
3156 pragma Assert (Nkind (N) in N_Entity);
3157 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
3160 function Flag81 (N : Node_Id) return Boolean is
3162 pragma Assert (Nkind (N) in N_Entity);
3163 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
3166 function Flag82 (N : Node_Id) return Boolean is
3168 pragma Assert (Nkind (N) in N_Entity);
3169 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
3172 function Flag83 (N : Node_Id) return Boolean is
3174 pragma Assert (Nkind (N) in N_Entity);
3175 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
3178 function Flag84 (N : Node_Id) return Boolean is
3180 pragma Assert (Nkind (N) in N_Entity);
3181 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
3184 function Flag85 (N : Node_Id) return Boolean is
3186 pragma Assert (Nkind (N) in N_Entity);
3187 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
3190 function Flag86 (N : Node_Id) return Boolean is
3192 pragma Assert (Nkind (N) in N_Entity);
3193 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
3196 function Flag87 (N : Node_Id) return Boolean is
3198 pragma Assert (Nkind (N) in N_Entity);
3199 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
3202 function Flag88 (N : Node_Id) return Boolean is
3204 pragma Assert (Nkind (N) in N_Entity);
3205 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
3208 function Flag89 (N : Node_Id) return Boolean is
3210 pragma Assert (Nkind (N) in N_Entity);
3211 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
3214 function Flag90 (N : Node_Id) return Boolean is
3216 pragma Assert (Nkind (N) in N_Entity);
3217 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
3220 function Flag91 (N : Node_Id) return Boolean is
3222 pragma Assert (Nkind (N) in N_Entity);
3223 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
3226 function Flag92 (N : Node_Id) return Boolean is
3228 pragma Assert (Nkind (N) in N_Entity);
3229 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
3232 function Flag93 (N : Node_Id) return Boolean is
3234 pragma Assert (Nkind (N) in N_Entity);
3235 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
3238 function Flag94 (N : Node_Id) return Boolean is
3240 pragma Assert (Nkind (N) in N_Entity);
3241 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
3244 function Flag95 (N : Node_Id) return Boolean is
3246 pragma Assert (Nkind (N) in N_Entity);
3247 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
3250 function Flag96 (N : Node_Id) return Boolean is
3252 pragma Assert (Nkind (N) in N_Entity);
3253 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
3256 function Flag97 (N : Node_Id) return Boolean is
3258 pragma Assert (Nkind (N) in N_Entity);
3259 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
3262 function Flag98 (N : Node_Id) return Boolean is
3264 pragma Assert (Nkind (N) in N_Entity);
3265 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
3268 function Flag99 (N : Node_Id) return Boolean is
3270 pragma Assert (Nkind (N) in N_Entity);
3271 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
3274 function Flag100 (N : Node_Id) return Boolean is
3276 pragma Assert (Nkind (N) in N_Entity);
3277 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
3280 function Flag101 (N : Node_Id) return Boolean is
3282 pragma Assert (Nkind (N) in N_Entity);
3283 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
3286 function Flag102 (N : Node_Id) return Boolean is
3288 pragma Assert (Nkind (N) in N_Entity);
3289 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
3292 function Flag103 (N : Node_Id) return Boolean is
3294 pragma Assert (Nkind (N) in N_Entity);
3295 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
3298 function Flag104 (N : Node_Id) return Boolean is
3300 pragma Assert (Nkind (N) in N_Entity);
3301 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
3304 function Flag105 (N : Node_Id) return Boolean is
3306 pragma Assert (Nkind (N) in N_Entity);
3307 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
3310 function Flag106 (N : Node_Id) return Boolean is
3312 pragma Assert (Nkind (N) in N_Entity);
3313 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
3316 function Flag107 (N : Node_Id) return Boolean is
3318 pragma Assert (Nkind (N) in N_Entity);
3319 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
3322 function Flag108 (N : Node_Id) return Boolean is
3324 pragma Assert (Nkind (N) in N_Entity);
3325 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
3328 function Flag109 (N : Node_Id) return Boolean is
3330 pragma Assert (Nkind (N) in N_Entity);
3331 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
3334 function Flag110 (N : Node_Id) return Boolean is
3336 pragma Assert (Nkind (N) in N_Entity);
3337 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
3340 function Flag111 (N : Node_Id) return Boolean is
3342 pragma Assert (Nkind (N) in N_Entity);
3343 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
3346 function Flag112 (N : Node_Id) return Boolean is
3348 pragma Assert (Nkind (N) in N_Entity);
3349 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
3352 function Flag113 (N : Node_Id) return Boolean is
3354 pragma Assert (Nkind (N) in N_Entity);
3355 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
3358 function Flag114 (N : Node_Id) return Boolean is
3360 pragma Assert (Nkind (N) in N_Entity);
3361 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
3364 function Flag115 (N : Node_Id) return Boolean is
3366 pragma Assert (Nkind (N) in N_Entity);
3367 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
3370 function Flag116 (N : Node_Id) return Boolean is
3372 pragma Assert (Nkind (N) in N_Entity);
3373 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
3376 function Flag117 (N : Node_Id) return Boolean is
3378 pragma Assert (Nkind (N) in N_Entity);
3379 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
3382 function Flag118 (N : Node_Id) return Boolean is
3384 pragma Assert (Nkind (N) in N_Entity);
3385 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
3388 function Flag119 (N : Node_Id) return Boolean is
3390 pragma Assert (Nkind (N) in N_Entity);
3391 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
3394 function Flag120 (N : Node_Id) return Boolean is
3396 pragma Assert (Nkind (N) in N_Entity);
3397 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
3400 function Flag121 (N : Node_Id) return Boolean is
3402 pragma Assert (Nkind (N) in N_Entity);
3403 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
3406 function Flag122 (N : Node_Id) return Boolean is
3408 pragma Assert (Nkind (N) in N_Entity);
3409 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
3412 function Flag123 (N : Node_Id) return Boolean is
3414 pragma Assert (Nkind (N) in N_Entity);
3415 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
3418 function Flag124 (N : Node_Id) return Boolean is
3420 pragma Assert (Nkind (N) in N_Entity);
3421 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
3424 function Flag125 (N : Node_Id) return Boolean is
3426 pragma Assert (Nkind (N) in N_Entity);
3427 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
3430 function Flag126 (N : Node_Id) return Boolean is
3432 pragma Assert (Nkind (N) in N_Entity);
3433 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
3436 function Flag127 (N : Node_Id) return Boolean is
3438 pragma Assert (Nkind (N) in N_Entity);
3439 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
3442 function Flag128 (N : Node_Id) return Boolean is
3444 pragma Assert (Nkind (N) in N_Entity);
3445 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
3448 function Flag129 (N : Node_Id) return Boolean is
3450 pragma Assert (Nkind (N) in N_Entity);
3451 return Nodes.Table (N + 3).In_List;
3454 function Flag130 (N : Node_Id) return Boolean is
3456 pragma Assert (Nkind (N) in N_Entity);
3457 return Nodes.Table (N + 3).Unused_1;
3460 function Flag131 (N : Node_Id) return Boolean is
3462 pragma Assert (Nkind (N) in N_Entity);
3463 return Nodes.Table (N + 3).Rewrite_Ins;
3466 function Flag132 (N : Node_Id) return Boolean is
3468 pragma Assert (Nkind (N) in N_Entity);
3469 return Nodes.Table (N + 3).Analyzed;
3472 function Flag133 (N : Node_Id) return Boolean is
3474 pragma Assert (Nkind (N) in N_Entity);
3475 return Nodes.Table (N + 3).Comes_From_Source;
3478 function Flag134 (N : Node_Id) return Boolean is
3480 pragma Assert (Nkind (N) in N_Entity);
3481 return Nodes.Table (N + 3).Error_Posted;
3484 function Flag135 (N : Node_Id) return Boolean is
3486 pragma Assert (Nkind (N) in N_Entity);
3487 return Nodes.Table (N + 3).Flag4;
3490 function Flag136 (N : Node_Id) return Boolean is
3492 pragma Assert (Nkind (N) in N_Entity);
3493 return Nodes.Table (N + 3).Flag5;
3496 function Flag137 (N : Node_Id) return Boolean is
3498 pragma Assert (Nkind (N) in N_Entity);
3499 return Nodes.Table (N + 3).Flag6;
3502 function Flag138 (N : Node_Id) return Boolean is
3504 pragma Assert (Nkind (N) in N_Entity);
3505 return Nodes.Table (N + 3).Flag7;
3508 function Flag139 (N : Node_Id) return Boolean is
3510 pragma Assert (Nkind (N) in N_Entity);
3511 return Nodes.Table (N + 3).Flag8;
3514 function Flag140 (N : Node_Id) return Boolean is
3516 pragma Assert (Nkind (N) in N_Entity);
3517 return Nodes.Table (N + 3).Flag9;
3520 function Flag141 (N : Node_Id) return Boolean is
3522 pragma Assert (Nkind (N) in N_Entity);
3523 return Nodes.Table (N + 3).Flag10;
3526 function Flag142 (N : Node_Id) return Boolean is
3528 pragma Assert (Nkind (N) in N_Entity);
3529 return Nodes.Table (N + 3).Flag11;
3532 function Flag143 (N : Node_Id) return Boolean is
3534 pragma Assert (Nkind (N) in N_Entity);
3535 return Nodes.Table (N + 3).Flag12;
3538 function Flag144 (N : Node_Id) return Boolean is
3540 pragma Assert (Nkind (N) in N_Entity);
3541 return Nodes.Table (N + 3).Flag13;
3544 function Flag145 (N : Node_Id) return Boolean is
3546 pragma Assert (Nkind (N) in N_Entity);
3547 return Nodes.Table (N + 3).Flag14;
3550 function Flag146 (N : Node_Id) return Boolean is
3552 pragma Assert (Nkind (N) in N_Entity);
3553 return Nodes.Table (N + 3).Flag15;
3556 function Flag147 (N : Node_Id) return Boolean is
3558 pragma Assert (Nkind (N) in N_Entity);
3559 return Nodes.Table (N + 3).Flag16;
3562 function Flag148 (N : Node_Id) return Boolean is
3564 pragma Assert (Nkind (N) in N_Entity);
3565 return Nodes.Table (N + 3).Flag17;
3568 function Flag149 (N : Node_Id) return Boolean is
3570 pragma Assert (Nkind (N) in N_Entity);
3571 return Nodes.Table (N + 3).Flag18;
3574 function Flag150 (N : Node_Id) return Boolean is
3576 pragma Assert (Nkind (N) in N_Entity);
3577 return Nodes.Table (N + 3).Pflag1;
3580 function Flag151 (N : Node_Id) return Boolean is
3582 pragma Assert (Nkind (N) in N_Entity);
3583 return Nodes.Table (N + 3).Pflag2;
3586 function Flag152 (N : Node_Id) return Boolean is
3588 pragma Assert (Nkind (N) in N_Entity);
3589 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
3592 function Flag153 (N : Node_Id) return Boolean is
3594 pragma Assert (Nkind (N) in N_Entity);
3595 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
3598 function Flag154 (N : Node_Id) return Boolean is
3600 pragma Assert (Nkind (N) in N_Entity);
3601 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
3604 function Flag155 (N : Node_Id) return Boolean is
3606 pragma Assert (Nkind (N) in N_Entity);
3607 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
3610 function Flag156 (N : Node_Id) return Boolean is
3612 pragma Assert (Nkind (N) in N_Entity);
3613 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
3616 function Flag157 (N : Node_Id) return Boolean is
3618 pragma Assert (Nkind (N) in N_Entity);
3619 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
3622 function Flag158 (N : Node_Id) return Boolean is
3624 pragma Assert (Nkind (N) in N_Entity);
3625 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
3628 function Flag159 (N : Node_Id) return Boolean is
3630 pragma Assert (Nkind (N) in N_Entity);
3631 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
3634 function Flag160 (N : Node_Id) return Boolean is
3636 pragma Assert (Nkind (N) in N_Entity);
3637 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
3640 function Flag161 (N : Node_Id) return Boolean is
3642 pragma Assert (Nkind (N) in N_Entity);
3643 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
3646 function Flag162 (N : Node_Id) return Boolean is
3648 pragma Assert (Nkind (N) in N_Entity);
3649 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
3652 function Flag163 (N : Node_Id) return Boolean is
3654 pragma Assert (Nkind (N) in N_Entity);
3655 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
3658 function Flag164 (N : Node_Id) return Boolean is
3660 pragma Assert (Nkind (N) in N_Entity);
3661 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
3664 function Flag165 (N : Node_Id) return Boolean is
3666 pragma Assert (Nkind (N) in N_Entity);
3667 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
3670 function Flag166 (N : Node_Id) return Boolean is
3672 pragma Assert (Nkind (N) in N_Entity);
3673 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
3676 function Flag167 (N : Node_Id) return Boolean is
3678 pragma Assert (Nkind (N) in N_Entity);
3679 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
3682 function Flag168 (N : Node_Id) return Boolean is
3684 pragma Assert (Nkind (N) in N_Entity);
3685 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
3688 function Flag169 (N : Node_Id) return Boolean is
3690 pragma Assert (Nkind (N) in N_Entity);
3691 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
3694 function Flag170 (N : Node_Id) return Boolean is
3696 pragma Assert (Nkind (N) in N_Entity);
3697 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
3700 function Flag171 (N : Node_Id) return Boolean is
3702 pragma Assert (Nkind (N) in N_Entity);
3703 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
3706 function Flag172 (N : Node_Id) return Boolean is
3708 pragma Assert (Nkind (N) in N_Entity);
3709 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
3712 function Flag173 (N : Node_Id) return Boolean is
3714 pragma Assert (Nkind (N) in N_Entity);
3715 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
3718 function Flag174 (N : Node_Id) return Boolean is
3720 pragma Assert (Nkind (N) in N_Entity);
3721 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
3724 function Flag175 (N : Node_Id) return Boolean is
3726 pragma Assert (Nkind (N) in N_Entity);
3727 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
3730 function Flag176 (N : Node_Id) return Boolean is
3732 pragma Assert (Nkind (N) in N_Entity);
3733 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
3736 function Flag177 (N : Node_Id) return Boolean is
3738 pragma Assert (Nkind (N) in N_Entity);
3739 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
3742 function Flag178 (N : Node_Id) return Boolean is
3744 pragma Assert (Nkind (N) in N_Entity);
3745 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
3748 function Flag179 (N : Node_Id) return Boolean is
3750 pragma Assert (Nkind (N) in N_Entity);
3751 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
3754 function Flag180 (N : Node_Id) return Boolean is
3756 pragma Assert (Nkind (N) in N_Entity);
3757 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
3760 function Flag181 (N : Node_Id) return Boolean is
3762 pragma Assert (Nkind (N) in N_Entity);
3763 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
3766 function Flag182 (N : Node_Id) return Boolean is
3768 pragma Assert (Nkind (N) in N_Entity);
3769 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
3772 function Flag183 (N : Node_Id) return Boolean is
3774 pragma Assert (Nkind (N) in N_Entity);
3775 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
3778 function Flag184 (N : Node_Id) return Boolean is
3780 pragma Assert (Nkind (N) in N_Entity);
3781 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag184;
3784 function Flag185 (N : Node_Id) return Boolean is
3786 pragma Assert (Nkind (N) in N_Entity);
3787 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag185;
3790 function Flag186 (N : Node_Id) return Boolean is
3792 pragma Assert (Nkind (N) in N_Entity);
3793 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag186;
3796 function Flag187 (N : Node_Id) return Boolean is
3798 pragma Assert (Nkind (N) in N_Entity);
3799 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag187;
3802 function Flag188 (N : Node_Id) return Boolean is
3804 pragma Assert (Nkind (N) in N_Entity);
3805 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag188;
3808 function Flag189 (N : Node_Id) return Boolean is
3810 pragma Assert (Nkind (N) in N_Entity);
3811 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag189;
3814 function Flag190 (N : Node_Id) return Boolean is
3816 pragma Assert (Nkind (N) in N_Entity);
3817 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag190;
3820 function Flag191 (N : Node_Id) return Boolean is
3822 pragma Assert (Nkind (N) in N_Entity);
3823 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag191;
3826 function Flag192 (N : Node_Id) return Boolean is
3828 pragma Assert (Nkind (N) in N_Entity);
3829 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag192;
3832 function Flag193 (N : Node_Id) return Boolean is
3834 pragma Assert (Nkind (N) in N_Entity);
3835 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag193;
3838 function Flag194 (N : Node_Id) return Boolean is
3840 pragma Assert (Nkind (N) in N_Entity);
3841 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag194;
3844 function Flag195 (N : Node_Id) return Boolean is
3846 pragma Assert (Nkind (N) in N_Entity);
3847 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag195;
3850 function Flag196 (N : Node_Id) return Boolean is
3852 pragma Assert (Nkind (N) in N_Entity);
3853 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag196;
3856 function Flag197 (N : Node_Id) return Boolean is
3858 pragma Assert (Nkind (N) in N_Entity);
3859 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag197;
3862 function Flag198 (N : Node_Id) return Boolean is
3864 pragma Assert (Nkind (N) in N_Entity);
3865 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag198;
3868 function Flag199 (N : Node_Id) return Boolean is
3870 pragma Assert (Nkind (N) in N_Entity);
3871 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag199;
3874 function Flag200 (N : Node_Id) return Boolean is
3876 pragma Assert (Nkind (N) in N_Entity);
3877 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag200;
3880 function Flag201 (N : Node_Id) return Boolean is
3882 pragma Assert (Nkind (N) in N_Entity);
3883 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag201;
3886 function Flag202 (N : Node_Id) return Boolean is
3888 pragma Assert (Nkind (N) in N_Entity);
3889 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag202;
3892 function Flag203 (N : Node_Id) return Boolean is
3894 pragma Assert (Nkind (N) in N_Entity);
3895 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag203;
3898 function Flag204 (N : Node_Id) return Boolean is
3900 pragma Assert (Nkind (N) in N_Entity);
3901 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag204;
3904 function Flag205 (N : Node_Id) return Boolean is
3906 pragma Assert (Nkind (N) in N_Entity);
3907 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag205;
3910 function Flag206 (N : Node_Id) return Boolean is
3912 pragma Assert (Nkind (N) in N_Entity);
3913 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag206;
3916 function Flag207 (N : Node_Id) return Boolean is
3918 pragma Assert (Nkind (N) in N_Entity);
3919 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag207;
3922 function Flag208 (N : Node_Id) return Boolean is
3924 pragma Assert (Nkind (N) in N_Entity);
3925 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag208;
3928 function Flag209 (N : Node_Id) return Boolean is
3930 pragma Assert (Nkind (N) in N_Entity);
3931 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag209;
3934 function Flag210 (N : Node_Id) return Boolean is
3936 pragma Assert (Nkind (N) in N_Entity);
3937 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag210;
3940 function Flag211 (N : Node_Id) return Boolean is
3942 pragma Assert (Nkind (N) in N_Entity);
3943 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag211;
3946 function Flag212 (N : Node_Id) return Boolean is
3948 pragma Assert (Nkind (N) in N_Entity);
3949 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag212;
3952 function Flag213 (N : Node_Id) return Boolean is
3954 pragma Assert (Nkind (N) in N_Entity);
3955 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag213;
3958 function Flag214 (N : Node_Id) return Boolean is
3960 pragma Assert (Nkind (N) in N_Entity);
3961 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag214;
3964 function Flag215 (N : Node_Id) return Boolean is
3966 pragma Assert (Nkind (N) in N_Entity);
3967 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag215;
3970 function Flag216 (N : Node_Id) return Boolean is
3972 pragma Assert (Nkind (N) in N_Entity);
3973 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag216;
3976 function Flag217 (N : Node_Id) return Boolean is
3978 pragma Assert (Nkind (N) in N_Entity);
3979 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag217;
3982 function Flag218 (N : Node_Id) return Boolean is
3984 pragma Assert (Nkind (N) in N_Entity);
3985 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag218;
3988 function Flag219 (N : Node_Id) return Boolean is
3990 pragma Assert (Nkind (N) in N_Entity);
3991 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag219;
3994 function Flag220 (N : Node_Id) return Boolean is
3996 pragma Assert (Nkind (N) in N_Entity);
3997 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag220;
4000 function Flag221 (N : Node_Id) return Boolean is
4002 pragma Assert (Nkind (N) in N_Entity);
4003 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag221;
4006 function Flag222 (N : Node_Id) return Boolean is
4008 pragma Assert (Nkind (N) in N_Entity);
4009 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag222;
4012 function Flag223 (N : Node_Id) return Boolean is
4014 pragma Assert (Nkind (N) in N_Entity);
4015 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag223;
4018 function Flag224 (N : Node_Id) return Boolean is
4020 pragma Assert (Nkind (N) in N_Entity);
4021 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag224;
4024 function Flag225 (N : Node_Id) return Boolean is
4026 pragma Assert (Nkind (N) in N_Entity);
4027 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag225;
4030 function Flag226 (N : Node_Id) return Boolean is
4032 pragma Assert (Nkind (N) in N_Entity);
4033 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag226;
4036 function Flag227 (N : Node_Id) return Boolean is
4038 pragma Assert (Nkind (N) in N_Entity);
4039 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag227;
4042 function Flag228 (N : Node_Id) return Boolean is
4044 pragma Assert (Nkind (N) in N_Entity);
4045 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag228;
4048 function Flag229 (N : Node_Id) return Boolean is
4050 pragma Assert (Nkind (N) in N_Entity);
4051 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag229;
4054 function Flag230 (N : Node_Id) return Boolean is
4056 pragma Assert (Nkind (N) in N_Entity);
4057 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag230;
4060 function Flag231 (N : Node_Id) return Boolean is
4062 pragma Assert (Nkind (N) in N_Entity);
4063 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag231;
4066 function Flag232 (N : Node_Id) return Boolean is
4068 pragma Assert (Nkind (N) in N_Entity);
4069 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag232;
4072 function Flag233 (N : Node_Id) return Boolean is
4074 pragma Assert (Nkind (N) in N_Entity);
4075 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag233;
4078 function Flag234 (N : Node_Id) return Boolean is
4080 pragma Assert (Nkind (N) in N_Entity);
4081 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag234;
4084 function Flag235 (N : Node_Id) return Boolean is
4086 pragma Assert (Nkind (N) in N_Entity);
4087 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag235;
4090 function Flag236 (N : Node_Id) return Boolean is
4092 pragma Assert (Nkind (N) in N_Entity);
4093 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag236;
4096 function Flag237 (N : Node_Id) return Boolean is
4098 pragma Assert (Nkind (N) in N_Entity);
4099 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag237;
4102 function Flag238 (N : Node_Id) return Boolean is
4104 pragma Assert (Nkind (N) in N_Entity);
4105 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag238;
4108 function Flag239 (N : Node_Id) return Boolean is
4110 pragma Assert (Nkind (N) in N_Entity);
4111 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag239;
4114 function Flag240 (N : Node_Id) return Boolean is
4116 pragma Assert (Nkind (N) in N_Entity);
4117 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag240;
4120 function Flag241 (N : Node_Id) return Boolean is
4122 pragma Assert (Nkind (N) in N_Entity);
4123 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag241;
4126 function Flag242 (N : Node_Id) return Boolean is
4128 pragma Assert (Nkind (N) in N_Entity);
4129 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag242;
4132 function Flag243 (N : Node_Id) return Boolean is
4134 pragma Assert (Nkind (N) in N_Entity);
4135 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag243;
4138 function Flag244 (N : Node_Id) return Boolean is
4140 pragma Assert (Nkind (N) in N_Entity);
4141 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag244;
4144 function Flag245 (N : Node_Id) return Boolean is
4146 pragma Assert (Nkind (N) in N_Entity);
4147 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag245;
4150 function Flag246 (N : Node_Id) return Boolean is
4152 pragma Assert (Nkind (N) in N_Entity);
4153 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag246;
4156 function Flag247 (N : Node_Id) return Boolean is
4158 pragma Assert (Nkind (N) in N_Entity);
4159 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag247;
4162 procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
4164 pragma Assert (N <= Nodes.Last);
4165 Nodes.Table (N).Nkind := Val;
4168 procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
4170 pragma Assert (N <= Nodes.Last);
4171 Nodes.Table (N).Field1 := Val;
4174 procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
4176 pragma Assert (N <= Nodes.Last);
4177 Nodes.Table (N).Field2 := Val;
4180 procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
4182 pragma Assert (N <= Nodes.Last);
4183 Nodes.Table (N).Field3 := Val;
4186 procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
4188 pragma Assert (N <= Nodes.Last);
4189 Nodes.Table (N).Field4 := Val;
4192 procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
4194 pragma Assert (N <= Nodes.Last);
4195 Nodes.Table (N).Field5 := Val;
4198 procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
4200 pragma Assert (Nkind (N) in N_Entity);
4201 Nodes.Table (N + 1).Field6 := Val;
4204 procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
4206 pragma Assert (Nkind (N) in N_Entity);
4207 Nodes.Table (N + 1).Field7 := Val;
4210 procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
4212 pragma Assert (Nkind (N) in N_Entity);
4213 Nodes.Table (N + 1).Field8 := Val;
4216 procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
4218 pragma Assert (Nkind (N) in N_Entity);
4219 Nodes.Table (N + 1).Field9 := Val;
4222 procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
4224 pragma Assert (Nkind (N) in N_Entity);
4225 Nodes.Table (N + 1).Field10 := Val;
4228 procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
4230 pragma Assert (Nkind (N) in N_Entity);
4231 Nodes.Table (N + 1).Field11 := Val;
4234 procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
4236 pragma Assert (Nkind (N) in N_Entity);
4237 Nodes.Table (N + 1).Field12 := Val;
4240 procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
4242 pragma Assert (Nkind (N) in N_Entity);
4243 Nodes.Table (N + 2).Field6 := Val;
4246 procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
4248 pragma Assert (Nkind (N) in N_Entity);
4249 Nodes.Table (N + 2).Field7 := Val;
4252 procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
4254 pragma Assert (Nkind (N) in N_Entity);
4255 Nodes.Table (N + 2).Field8 := Val;
4258 procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
4260 pragma Assert (Nkind (N) in N_Entity);
4261 Nodes.Table (N + 2).Field9 := Val;
4264 procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
4266 pragma Assert (Nkind (N) in N_Entity);
4267 Nodes.Table (N + 2).Field10 := Val;
4270 procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
4272 pragma Assert (Nkind (N) in N_Entity);
4273 Nodes.Table (N + 2).Field11 := Val;
4276 procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
4278 pragma Assert (Nkind (N) in N_Entity);
4279 Nodes.Table (N + 3).Field6 := Val;
4282 procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
4284 pragma Assert (Nkind (N) in N_Entity);
4285 Nodes.Table (N + 3).Field7 := Val;
4288 procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
4290 pragma Assert (Nkind (N) in N_Entity);
4291 Nodes.Table (N + 3).Field8 := Val;
4294 procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
4296 pragma Assert (Nkind (N) in N_Entity);
4297 Nodes.Table (N + 3).Field9 := Val;
4300 procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
4302 pragma Assert (Nkind (N) in N_Entity);
4303 Nodes.Table (N + 3).Field10 := Val;
4306 procedure Set_Field24 (N : Node_Id; Val : Union_Id) is
4308 pragma Assert (Nkind (N) in N_Entity);
4309 Nodes.Table (N + 4).Field6 := Val;
4312 procedure Set_Field25 (N : Node_Id; Val : Union_Id) is
4314 pragma Assert (Nkind (N) in N_Entity);
4315 Nodes.Table (N + 4).Field7 := Val;
4318 procedure Set_Field26 (N : Node_Id; Val : Union_Id) is
4320 pragma Assert (Nkind (N) in N_Entity);
4321 Nodes.Table (N + 4).Field8 := Val;
4324 procedure Set_Field27 (N : Node_Id; Val : Union_Id) is
4326 pragma Assert (Nkind (N) in N_Entity);
4327 Nodes.Table (N + 4).Field9 := Val;
4330 procedure Set_Field28 (N : Node_Id; Val : Union_Id) is
4332 pragma Assert (Nkind (N) in N_Entity);
4333 Nodes.Table (N + 4).Field10 := Val;
4336 procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
4338 pragma Assert (N <= Nodes.Last);
4339 Nodes.Table (N).Field1 := Union_Id (Val);
4342 procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
4344 pragma Assert (N <= Nodes.Last);
4345 Nodes.Table (N).Field2 := Union_Id (Val);
4348 procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
4350 pragma Assert (N <= Nodes.Last);
4351 Nodes.Table (N).Field3 := Union_Id (Val);
4354 procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
4356 pragma Assert (N <= Nodes.Last);
4357 Nodes.Table (N).Field4 := Union_Id (Val);
4360 procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
4362 pragma Assert (N <= Nodes.Last);
4363 Nodes.Table (N).Field5 := Union_Id (Val);
4366 procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
4368 pragma Assert (Nkind (N) in N_Entity);
4369 Nodes.Table (N + 1).Field6 := Union_Id (Val);
4372 procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
4374 pragma Assert (Nkind (N) in N_Entity);
4375 Nodes.Table (N + 1).Field7 := Union_Id (Val);
4378 procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
4380 pragma Assert (Nkind (N) in N_Entity);
4381 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4384 procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
4386 pragma Assert (Nkind (N) in N_Entity);
4387 Nodes.Table (N + 1).Field9 := Union_Id (Val);
4390 procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
4392 pragma Assert (Nkind (N) in N_Entity);
4393 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4396 procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
4398 pragma Assert (Nkind (N) in N_Entity);
4399 Nodes.Table (N + 1).Field11 := Union_Id (Val);
4402 procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
4404 pragma Assert (Nkind (N) in N_Entity);
4405 Nodes.Table (N + 1).Field12 := Union_Id (Val);
4408 procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
4410 pragma Assert (Nkind (N) in N_Entity);
4411 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4414 procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
4416 pragma Assert (Nkind (N) in N_Entity);
4417 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4420 procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
4422 pragma Assert (Nkind (N) in N_Entity);
4423 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4426 procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
4428 pragma Assert (Nkind (N) in N_Entity);
4429 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4432 procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
4434 pragma Assert (Nkind (N) in N_Entity);
4435 Nodes.Table (N + 2).Field10 := Union_Id (Val);
4438 procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
4440 pragma Assert (Nkind (N) in N_Entity);
4441 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4444 procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
4446 pragma Assert (Nkind (N) in N_Entity);
4447 Nodes.Table (N + 3).Field6 := Union_Id (Val);
4450 procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
4452 pragma Assert (Nkind (N) in N_Entity);
4453 Nodes.Table (N + 3).Field7 := Union_Id (Val);
4456 procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
4458 pragma Assert (Nkind (N) in N_Entity);
4459 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4462 procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
4464 pragma Assert (Nkind (N) in N_Entity);
4465 Nodes.Table (N + 3).Field9 := Union_Id (Val);
4468 procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
4470 pragma Assert (Nkind (N) in N_Entity);
4471 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4474 procedure Set_Node24 (N : Node_Id; Val : Node_Id) is
4476 pragma Assert (Nkind (N) in N_Entity);
4477 Nodes.Table (N + 4).Field6 := Union_Id (Val);
4480 procedure Set_Node25 (N : Node_Id; Val : Node_Id) is
4482 pragma Assert (Nkind (N) in N_Entity);
4483 Nodes.Table (N + 4).Field7 := Union_Id (Val);
4486 procedure Set_Node26 (N : Node_Id; Val : Node_Id) is
4488 pragma Assert (Nkind (N) in N_Entity);
4489 Nodes.Table (N + 4).Field8 := Union_Id (Val);
4492 procedure Set_Node27 (N : Node_Id; Val : Node_Id) is
4494 pragma Assert (Nkind (N) in N_Entity);
4495 Nodes.Table (N + 4).Field9 := Union_Id (Val);
4498 procedure Set_Node28 (N : Node_Id; Val : Node_Id) is
4500 pragma Assert (Nkind (N) in N_Entity);
4501 Nodes.Table (N + 4).Field10 := Union_Id (Val);
4504 procedure Set_List1 (N : Node_Id; Val : List_Id) is
4506 pragma Assert (N <= Nodes.Last);
4507 Nodes.Table (N).Field1 := Union_Id (Val);
4510 procedure Set_List2 (N : Node_Id; Val : List_Id) is
4512 pragma Assert (N <= Nodes.Last);
4513 Nodes.Table (N).Field2 := Union_Id (Val);
4516 procedure Set_List3 (N : Node_Id; Val : List_Id) is
4518 pragma Assert (N <= Nodes.Last);
4519 Nodes.Table (N).Field3 := Union_Id (Val);
4522 procedure Set_List4 (N : Node_Id; Val : List_Id) is
4524 pragma Assert (N <= Nodes.Last);
4525 Nodes.Table (N).Field4 := Union_Id (Val);
4528 procedure Set_List5 (N : Node_Id; Val : List_Id) is
4530 pragma Assert (N <= Nodes.Last);
4531 Nodes.Table (N).Field5 := Union_Id (Val);
4534 procedure Set_List10 (N : Node_Id; Val : List_Id) is
4536 pragma Assert (Nkind (N) in N_Entity);
4537 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4540 procedure Set_List14 (N : Node_Id; Val : List_Id) is
4542 pragma Assert (Nkind (N) in N_Entity);
4543 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4546 procedure Set_Elist1 (N : Node_Id; Val : Elist_Id) is
4548 Nodes.Table (N).Field1 := Union_Id (Val);
4551 procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
4553 Nodes.Table (N).Field2 := Union_Id (Val);
4556 procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
4558 Nodes.Table (N).Field3 := Union_Id (Val);
4561 procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
4563 Nodes.Table (N).Field4 := Union_Id (Val);
4566 procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
4568 pragma Assert (Nkind (N) in N_Entity);
4569 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4572 procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
4574 pragma Assert (Nkind (N) in N_Entity);
4575 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4578 procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
4580 pragma Assert (Nkind (N) in N_Entity);
4581 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4584 procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
4586 pragma Assert (Nkind (N) in N_Entity);
4587 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4590 procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
4592 pragma Assert (Nkind (N) in N_Entity);
4593 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4596 procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
4598 pragma Assert (Nkind (N) in N_Entity);
4599 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4602 procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
4604 pragma Assert (Nkind (N) in N_Entity);
4605 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4608 procedure Set_Elist25 (N : Node_Id; Val : Elist_Id) is
4610 pragma Assert (Nkind (N) in N_Entity);
4611 Nodes.Table (N + 4).Field7 := Union_Id (Val);
4614 procedure Set_Elist26 (N : Node_Id; Val : Elist_Id) is
4616 pragma Assert (Nkind (N) in N_Entity);
4617 Nodes.Table (N + 4).Field8 := Union_Id (Val);
4620 procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
4622 pragma Assert (N <= Nodes.Last);
4623 Nodes.Table (N).Field1 := Union_Id (Val);
4626 procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
4628 pragma Assert (N <= Nodes.Last);
4629 Nodes.Table (N).Field2 := Union_Id (Val);
4632 procedure Set_Str3 (N : Node_Id; Val : String_Id) is
4634 pragma Assert (N <= Nodes.Last);
4635 Nodes.Table (N).Field3 := Union_Id (Val);
4638 procedure Set_Uint2 (N : Node_Id; Val : Uint) is
4640 pragma Assert (N <= Nodes.Last);
4641 Nodes.Table (N).Field2 := To_Union (Val);
4644 procedure Set_Uint3 (N : Node_Id; Val : Uint) is
4646 pragma Assert (N <= Nodes.Last);
4647 Nodes.Table (N).Field3 := To_Union (Val);
4650 procedure Set_Uint4 (N : Node_Id; Val : Uint) is
4652 pragma Assert (N <= Nodes.Last);
4653 Nodes.Table (N).Field4 := To_Union (Val);
4656 procedure Set_Uint5 (N : Node_Id; Val : Uint) is
4658 pragma Assert (N <= Nodes.Last);
4659 Nodes.Table (N).Field5 := To_Union (Val);
4662 procedure Set_Uint8 (N : Node_Id; Val : Uint) is
4664 pragma Assert (Nkind (N) in N_Entity);
4665 Nodes.Table (N + 1).Field8 := To_Union (Val);
4668 procedure Set_Uint9 (N : Node_Id; Val : Uint) is
4670 pragma Assert (Nkind (N) in N_Entity);
4671 Nodes.Table (N + 1).Field9 := To_Union (Val);
4674 procedure Set_Uint10 (N : Node_Id; Val : Uint) is
4676 pragma Assert (Nkind (N) in N_Entity);
4677 Nodes.Table (N + 1).Field10 := To_Union (Val);
4680 procedure Set_Uint11 (N : Node_Id; Val : Uint) is
4682 pragma Assert (Nkind (N) in N_Entity);
4683 Nodes.Table (N + 1).Field11 := To_Union (Val);
4686 procedure Set_Uint12 (N : Node_Id; Val : Uint) is
4688 pragma Assert (Nkind (N) in N_Entity);
4689 Nodes.Table (N + 1).Field12 := To_Union (Val);
4692 procedure Set_Uint13 (N : Node_Id; Val : Uint) is
4694 pragma Assert (Nkind (N) in N_Entity);
4695 Nodes.Table (N + 2).Field6 := To_Union (Val);
4698 procedure Set_Uint14 (N : Node_Id; Val : Uint) is
4700 pragma Assert (Nkind (N) in N_Entity);
4701 Nodes.Table (N + 2).Field7 := To_Union (Val);
4704 procedure Set_Uint15 (N : Node_Id; Val : Uint) is
4706 pragma Assert (Nkind (N) in N_Entity);
4707 Nodes.Table (N + 2).Field8 := To_Union (Val);
4710 procedure Set_Uint16 (N : Node_Id; Val : Uint) is
4712 pragma Assert (Nkind (N) in N_Entity);
4713 Nodes.Table (N + 2).Field9 := To_Union (Val);
4716 procedure Set_Uint17 (N : Node_Id; Val : Uint) is
4718 pragma Assert (Nkind (N) in N_Entity);
4719 Nodes.Table (N + 2).Field10 := To_Union (Val);
4722 procedure Set_Uint22 (N : Node_Id; Val : Uint) is
4724 pragma Assert (Nkind (N) in N_Entity);
4725 Nodes.Table (N + 3).Field9 := To_Union (Val);
4728 procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
4730 pragma Assert (N <= Nodes.Last);
4731 Nodes.Table (N).Field3 := To_Union (Val);
4734 procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
4736 pragma Assert (Nkind (N) in N_Entity);
4737 Nodes.Table (N + 2).Field11 := To_Union (Val);
4740 procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
4742 pragma Assert (Nkind (N) in N_Entity);
4743 Nodes.Table (N + 3).Field8 := To_Union (Val);
4746 procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
4748 pragma Assert (N <= Nodes.Last);
4749 Nodes.Table (N).Flag4 := Val;
4752 procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
4754 pragma Assert (N <= Nodes.Last);
4755 Nodes.Table (N).Flag5 := Val;
4758 procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
4760 pragma Assert (N <= Nodes.Last);
4761 Nodes.Table (N).Flag6 := Val;
4764 procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
4766 pragma Assert (N <= Nodes.Last);
4767 Nodes.Table (N).Flag7 := Val;
4770 procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
4772 pragma Assert (N <= Nodes.Last);
4773 Nodes.Table (N).Flag8 := Val;
4776 procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
4778 pragma Assert (N <= Nodes.Last);
4779 Nodes.Table (N).Flag9 := Val;
4782 procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
4784 pragma Assert (N <= Nodes.Last);
4785 Nodes.Table (N).Flag10 := Val;
4788 procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
4790 pragma Assert (N <= Nodes.Last);
4791 Nodes.Table (N).Flag11 := Val;
4794 procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
4796 pragma Assert (N <= Nodes.Last);
4797 Nodes.Table (N).Flag12 := Val;
4800 procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
4802 pragma Assert (N <= Nodes.Last);
4803 Nodes.Table (N).Flag13 := Val;
4806 procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
4808 pragma Assert (N <= Nodes.Last);
4809 Nodes.Table (N).Flag14 := Val;
4812 procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
4814 pragma Assert (N <= Nodes.Last);
4815 Nodes.Table (N).Flag15 := Val;
4818 procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
4820 pragma Assert (N <= Nodes.Last);
4821 Nodes.Table (N).Flag16 := Val;
4824 procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
4826 pragma Assert (N <= Nodes.Last);
4827 Nodes.Table (N).Flag17 := Val;
4830 procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
4832 pragma Assert (N <= Nodes.Last);
4833 Nodes.Table (N).Flag18 := Val;
4836 procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
4838 pragma Assert (Nkind (N) in N_Entity);
4839 Nodes.Table (N + 1).In_List := Val;
4842 procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
4844 pragma Assert (Nkind (N) in N_Entity);
4845 Nodes.Table (N + 1).Unused_1 := Val;
4848 procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
4850 pragma Assert (Nkind (N) in N_Entity);
4851 Nodes.Table (N + 1).Rewrite_Ins := Val;
4854 procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
4856 pragma Assert (Nkind (N) in N_Entity);
4857 Nodes.Table (N + 1).Analyzed := Val;
4860 procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
4862 pragma Assert (Nkind (N) in N_Entity);
4863 Nodes.Table (N + 1).Comes_From_Source := Val;
4866 procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
4868 pragma Assert (Nkind (N) in N_Entity);
4869 Nodes.Table (N + 1).Error_Posted := Val;
4872 procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
4874 pragma Assert (Nkind (N) in N_Entity);
4875 Nodes.Table (N + 1).Flag4 := Val;
4878 procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
4880 pragma Assert (Nkind (N) in N_Entity);
4881 Nodes.Table (N + 1).Flag5 := Val;
4884 procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
4886 pragma Assert (Nkind (N) in N_Entity);
4887 Nodes.Table (N + 1).Flag6 := Val;
4890 procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
4892 pragma Assert (Nkind (N) in N_Entity);
4893 Nodes.Table (N + 1).Flag7 := Val;
4896 procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
4898 pragma Assert (Nkind (N) in N_Entity);
4899 Nodes.Table (N + 1).Flag8 := Val;
4902 procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
4904 pragma Assert (Nkind (N) in N_Entity);
4905 Nodes.Table (N + 1).Flag9 := Val;
4908 procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
4910 pragma Assert (Nkind (N) in N_Entity);
4911 Nodes.Table (N + 1).Flag10 := Val;
4914 procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
4916 pragma Assert (Nkind (N) in N_Entity);
4917 Nodes.Table (N + 1).Flag11 := Val;
4920 procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
4922 pragma Assert (Nkind (N) in N_Entity);
4923 Nodes.Table (N + 1).Flag12 := Val;
4926 procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
4928 pragma Assert (Nkind (N) in N_Entity);
4929 Nodes.Table (N + 1).Flag13 := Val;
4932 procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
4934 pragma Assert (Nkind (N) in N_Entity);
4935 Nodes.Table (N + 1).Flag14 := Val;
4938 procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
4940 pragma Assert (Nkind (N) in N_Entity);
4941 Nodes.Table (N + 1).Flag15 := Val;
4944 procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
4946 pragma Assert (Nkind (N) in N_Entity);
4947 Nodes.Table (N + 1).Flag16 := Val;
4950 procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
4952 pragma Assert (Nkind (N) in N_Entity);
4953 Nodes.Table (N + 1).Flag17 := Val;
4956 procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
4958 pragma Assert (Nkind (N) in N_Entity);
4959 Nodes.Table (N + 1).Flag18 := Val;
4962 procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
4964 pragma Assert (Nkind (N) in N_Entity);
4965 Nodes.Table (N + 2).In_List := Val;
4968 procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
4970 pragma Assert (Nkind (N) in N_Entity);
4971 Nodes.Table (N + 2).Unused_1 := Val;
4974 procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
4976 pragma Assert (Nkind (N) in N_Entity);
4977 Nodes.Table (N + 2).Rewrite_Ins := Val;
4980 procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
4982 pragma Assert (Nkind (N) in N_Entity);
4983 Nodes.Table (N + 2).Analyzed := Val;
4986 procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
4988 pragma Assert (Nkind (N) in N_Entity);
4989 Nodes.Table (N + 2).Comes_From_Source := Val;
4992 procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
4994 pragma Assert (Nkind (N) in N_Entity);
4995 Nodes.Table (N + 2).Error_Posted := Val;
4998 procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
5000 pragma Assert (Nkind (N) in N_Entity);
5001 Nodes.Table (N + 2).Flag4 := Val;
5004 procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
5006 pragma Assert (Nkind (N) in N_Entity);
5007 Nodes.Table (N + 2).Flag5 := Val;
5010 procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
5012 pragma Assert (Nkind (N) in N_Entity);
5013 Nodes.Table (N + 2).Flag6 := Val;
5016 procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
5018 pragma Assert (Nkind (N) in N_Entity);
5019 Nodes.Table (N + 2).Flag7 := Val;
5022 procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
5024 pragma Assert (Nkind (N) in N_Entity);
5025 Nodes.Table (N + 2).Flag8 := Val;
5028 procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
5030 pragma Assert (Nkind (N) in N_Entity);
5031 Nodes.Table (N + 2).Flag9 := Val;
5034 procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
5036 pragma Assert (Nkind (N) in N_Entity);
5037 Nodes.Table (N + 2).Flag10 := Val;
5040 procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
5042 pragma Assert (Nkind (N) in N_Entity);
5043 Nodes.Table (N + 2).Flag11 := Val;
5046 procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
5048 pragma Assert (Nkind (N) in N_Entity);
5049 Nodes.Table (N + 2).Flag12 := Val;
5052 procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
5054 pragma Assert (Nkind (N) in N_Entity);
5055 Nodes.Table (N + 2).Flag13 := Val;
5058 procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
5060 pragma Assert (Nkind (N) in N_Entity);
5061 Nodes.Table (N + 2).Flag14 := Val;
5064 procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
5066 pragma Assert (Nkind (N) in N_Entity);
5067 Nodes.Table (N + 2).Flag15 := Val;
5070 procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
5072 pragma Assert (Nkind (N) in N_Entity);
5073 Nodes.Table (N + 2).Flag16 := Val;
5076 procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
5078 pragma Assert (Nkind (N) in N_Entity);
5079 Nodes.Table (N + 2).Flag17 := Val;
5082 procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
5084 pragma Assert (Nkind (N) in N_Entity);
5085 Nodes.Table (N + 2).Flag18 := Val;
5088 procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
5090 pragma Assert (Nkind (N) in N_Entity);
5091 Nodes.Table (N + 1).Pflag1 := Val;
5094 procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
5096 pragma Assert (Nkind (N) in N_Entity);
5097 Nodes.Table (N + 1).Pflag2 := Val;
5100 procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
5102 pragma Assert (Nkind (N) in N_Entity);
5103 Nodes.Table (N + 2).Pflag1 := Val;
5106 procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
5108 pragma Assert (Nkind (N) in N_Entity);
5109 Nodes.Table (N + 2).Pflag2 := Val;
5112 procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
5114 pragma Assert (Nkind (N) in N_Entity);
5117 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
5120 procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
5122 pragma Assert (Nkind (N) in N_Entity);
5125 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
5128 procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
5130 pragma Assert (Nkind (N) in N_Entity);
5133 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
5136 procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
5138 pragma Assert (Nkind (N) in N_Entity);
5141 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
5144 procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
5146 pragma Assert (Nkind (N) in N_Entity);
5149 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
5152 procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
5154 pragma Assert (Nkind (N) in N_Entity);
5157 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
5160 procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
5162 pragma Assert (Nkind (N) in N_Entity);
5165 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
5168 procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
5170 pragma Assert (Nkind (N) in N_Entity);
5173 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
5176 procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
5178 pragma Assert (Nkind (N) in N_Entity);
5181 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
5184 procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
5186 pragma Assert (Nkind (N) in N_Entity);
5189 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
5192 procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
5194 pragma Assert (Nkind (N) in N_Entity);
5197 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
5200 procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
5202 pragma Assert (Nkind (N) in N_Entity);
5205 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
5208 procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
5210 pragma Assert (Nkind (N) in N_Entity);
5213 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
5216 procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
5218 pragma Assert (Nkind (N) in N_Entity);
5221 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
5224 procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
5226 pragma Assert (Nkind (N) in N_Entity);
5229 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
5232 procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
5234 pragma Assert (Nkind (N) in N_Entity);
5237 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
5240 procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
5242 pragma Assert (Nkind (N) in N_Entity);
5245 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
5248 procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
5250 pragma Assert (Nkind (N) in N_Entity);
5253 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
5256 procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
5258 pragma Assert (Nkind (N) in N_Entity);
5261 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
5264 procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
5266 pragma Assert (Nkind (N) in N_Entity);
5269 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
5272 procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
5274 pragma Assert (Nkind (N) in N_Entity);
5277 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
5280 procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
5282 pragma Assert (Nkind (N) in N_Entity);
5285 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
5288 procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
5290 pragma Assert (Nkind (N) in N_Entity);
5293 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
5296 procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
5298 pragma Assert (Nkind (N) in N_Entity);
5301 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
5304 procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
5306 pragma Assert (Nkind (N) in N_Entity);
5309 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
5312 procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
5314 pragma Assert (Nkind (N) in N_Entity);
5317 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
5320 procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
5322 pragma Assert (Nkind (N) in N_Entity);
5325 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
5328 procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
5330 pragma Assert (Nkind (N) in N_Entity);
5333 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
5336 procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
5338 pragma Assert (Nkind (N) in N_Entity);
5341 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
5344 procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
5346 pragma Assert (Nkind (N) in N_Entity);
5349 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
5352 procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
5354 pragma Assert (Nkind (N) in N_Entity);
5357 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
5360 procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
5362 pragma Assert (Nkind (N) in N_Entity);
5365 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
5368 procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
5370 pragma Assert (Nkind (N) in N_Entity);
5373 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
5376 procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
5378 pragma Assert (Nkind (N) in N_Entity);
5381 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
5384 procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
5386 pragma Assert (Nkind (N) in N_Entity);
5389 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
5392 procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
5394 pragma Assert (Nkind (N) in N_Entity);
5397 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
5400 procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
5402 pragma Assert (Nkind (N) in N_Entity);
5405 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
5408 procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
5410 pragma Assert (Nkind (N) in N_Entity);
5413 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
5416 procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
5418 pragma Assert (Nkind (N) in N_Entity);
5421 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
5424 procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
5426 pragma Assert (Nkind (N) in N_Entity);
5429 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
5432 procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
5434 pragma Assert (Nkind (N) in N_Entity);
5437 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
5440 procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
5442 pragma Assert (Nkind (N) in N_Entity);
5445 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
5448 procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
5450 pragma Assert (Nkind (N) in N_Entity);
5453 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
5456 procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
5458 pragma Assert (Nkind (N) in N_Entity);
5461 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
5464 procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
5466 pragma Assert (Nkind (N) in N_Entity);
5469 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
5472 procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
5474 pragma Assert (Nkind (N) in N_Entity);
5477 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
5480 procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
5482 pragma Assert (Nkind (N) in N_Entity);
5485 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
5488 procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
5490 pragma Assert (Nkind (N) in N_Entity);
5493 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
5496 procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
5498 pragma Assert (Nkind (N) in N_Entity);
5501 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
5504 procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
5506 pragma Assert (Nkind (N) in N_Entity);
5509 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
5512 procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
5514 pragma Assert (Nkind (N) in N_Entity);
5517 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
5520 procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
5522 pragma Assert (Nkind (N) in N_Entity);
5525 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
5528 procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
5530 pragma Assert (Nkind (N) in N_Entity);
5533 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
5536 procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
5538 pragma Assert (Nkind (N) in N_Entity);
5541 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
5544 procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
5546 pragma Assert (Nkind (N) in N_Entity);
5549 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
5552 procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
5554 pragma Assert (Nkind (N) in N_Entity);
5557 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
5560 procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
5562 pragma Assert (Nkind (N) in N_Entity);
5565 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
5568 procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
5570 pragma Assert (Nkind (N) in N_Entity);
5573 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
5576 procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
5578 pragma Assert (Nkind (N) in N_Entity);
5581 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
5584 procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
5586 pragma Assert (Nkind (N) in N_Entity);
5589 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
5592 procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
5594 pragma Assert (Nkind (N) in N_Entity);
5597 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
5600 procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
5602 pragma Assert (Nkind (N) in N_Entity);
5605 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
5608 procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
5610 pragma Assert (Nkind (N) in N_Entity);
5613 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
5616 procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
5618 pragma Assert (Nkind (N) in N_Entity);
5621 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
5624 procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
5626 pragma Assert (Nkind (N) in N_Entity);
5627 Nodes.Table (N + 3).In_List := Val;
5630 procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
5632 pragma Assert (Nkind (N) in N_Entity);
5633 Nodes.Table (N + 3).Unused_1 := Val;
5636 procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
5638 pragma Assert (Nkind (N) in N_Entity);
5639 Nodes.Table (N + 3).Rewrite_Ins := Val;
5642 procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
5644 pragma Assert (Nkind (N) in N_Entity);
5645 Nodes.Table (N + 3).Analyzed := Val;
5648 procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
5650 pragma Assert (Nkind (N) in N_Entity);
5651 Nodes.Table (N + 3).Comes_From_Source := Val;
5654 procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
5656 pragma Assert (Nkind (N) in N_Entity);
5657 Nodes.Table (N + 3).Error_Posted := Val;
5660 procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
5662 pragma Assert (Nkind (N) in N_Entity);
5663 Nodes.Table (N + 3).Flag4 := Val;
5666 procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
5668 pragma Assert (Nkind (N) in N_Entity);
5669 Nodes.Table (N + 3).Flag5 := Val;
5672 procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
5674 pragma Assert (Nkind (N) in N_Entity);
5675 Nodes.Table (N + 3).Flag6 := Val;
5678 procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
5680 pragma Assert (Nkind (N) in N_Entity);
5681 Nodes.Table (N + 3).Flag7 := Val;
5684 procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
5686 pragma Assert (Nkind (N) in N_Entity);
5687 Nodes.Table (N + 3).Flag8 := Val;
5690 procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
5692 pragma Assert (Nkind (N) in N_Entity);
5693 Nodes.Table (N + 3).Flag9 := Val;
5696 procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
5698 pragma Assert (Nkind (N) in N_Entity);
5699 Nodes.Table (N + 3).Flag10 := Val;
5702 procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
5704 pragma Assert (Nkind (N) in N_Entity);
5705 Nodes.Table (N + 3).Flag11 := Val;
5708 procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
5710 pragma Assert (Nkind (N) in N_Entity);
5711 Nodes.Table (N + 3).Flag12 := Val;
5714 procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
5716 pragma Assert (Nkind (N) in N_Entity);
5717 Nodes.Table (N + 3).Flag13 := Val;
5720 procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
5722 pragma Assert (Nkind (N) in N_Entity);
5723 Nodes.Table (N + 3).Flag14 := Val;
5726 procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
5728 pragma Assert (Nkind (N) in N_Entity);
5729 Nodes.Table (N + 3).Flag15 := Val;
5732 procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
5734 pragma Assert (Nkind (N) in N_Entity);
5735 Nodes.Table (N + 3).Flag16 := Val;
5738 procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
5740 pragma Assert (Nkind (N) in N_Entity);
5741 Nodes.Table (N + 3).Flag17 := Val;
5744 procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
5746 pragma Assert (Nkind (N) in N_Entity);
5747 Nodes.Table (N + 3).Flag18 := Val;
5750 procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
5752 pragma Assert (Nkind (N) in N_Entity);
5753 Nodes.Table (N + 3).Pflag1 := Val;
5756 procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
5758 pragma Assert (Nkind (N) in N_Entity);
5759 Nodes.Table (N + 3).Pflag2 := Val;
5762 procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
5764 pragma Assert (Nkind (N) in N_Entity);
5767 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
5770 procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
5772 pragma Assert (Nkind (N) in N_Entity);
5775 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
5778 procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
5780 pragma Assert (Nkind (N) in N_Entity);
5783 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
5786 procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
5788 pragma Assert (Nkind (N) in N_Entity);
5791 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
5794 procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
5796 pragma Assert (Nkind (N) in N_Entity);
5799 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
5802 procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
5804 pragma Assert (Nkind (N) in N_Entity);
5807 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
5810 procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
5812 pragma Assert (Nkind (N) in N_Entity);
5815 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
5818 procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
5820 pragma Assert (Nkind (N) in N_Entity);
5823 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
5826 procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
5828 pragma Assert (Nkind (N) in N_Entity);
5831 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
5834 procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
5836 pragma Assert (Nkind (N) in N_Entity);
5839 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
5842 procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
5844 pragma Assert (Nkind (N) in N_Entity);
5847 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
5850 procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
5852 pragma Assert (Nkind (N) in N_Entity);
5855 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
5858 procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
5860 pragma Assert (Nkind (N) in N_Entity);
5863 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
5866 procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
5868 pragma Assert (Nkind (N) in N_Entity);
5871 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
5874 procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
5876 pragma Assert (Nkind (N) in N_Entity);
5879 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
5882 procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
5884 pragma Assert (Nkind (N) in N_Entity);
5887 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
5890 procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
5892 pragma Assert (Nkind (N) in N_Entity);
5895 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
5898 procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
5900 pragma Assert (Nkind (N) in N_Entity);
5903 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
5906 procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
5908 pragma Assert (Nkind (N) in N_Entity);
5911 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
5914 procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
5916 pragma Assert (Nkind (N) in N_Entity);
5919 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
5922 procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
5924 pragma Assert (Nkind (N) in N_Entity);
5927 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
5930 procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
5932 pragma Assert (Nkind (N) in N_Entity);
5935 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
5938 procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
5940 pragma Assert (Nkind (N) in N_Entity);
5943 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
5946 procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
5948 pragma Assert (Nkind (N) in N_Entity);
5951 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
5954 procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
5956 pragma Assert (Nkind (N) in N_Entity);
5959 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
5962 procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
5964 pragma Assert (Nkind (N) in N_Entity);
5967 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
5970 procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
5972 pragma Assert (Nkind (N) in N_Entity);
5975 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
5978 procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
5980 pragma Assert (Nkind (N) in N_Entity);
5983 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
5986 procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
5988 pragma Assert (Nkind (N) in N_Entity);
5991 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
5994 procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
5996 pragma Assert (Nkind (N) in N_Entity);
5999 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
6002 procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
6004 pragma Assert (Nkind (N) in N_Entity);
6007 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
6010 procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
6012 pragma Assert (Nkind (N) in N_Entity);
6015 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
6018 procedure Set_Flag184 (N : Node_Id; Val : Boolean) is
6020 pragma Assert (Nkind (N) in N_Entity);
6023 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag184 := Val;
6026 procedure Set_Flag185 (N : Node_Id; Val : Boolean) is
6028 pragma Assert (Nkind (N) in N_Entity);
6031 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag185 := Val;
6034 procedure Set_Flag186 (N : Node_Id; Val : Boolean) is
6036 pragma Assert (Nkind (N) in N_Entity);
6039 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag186 := Val;
6042 procedure Set_Flag187 (N : Node_Id; Val : Boolean) is
6044 pragma Assert (Nkind (N) in N_Entity);
6047 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag187 := Val;
6050 procedure Set_Flag188 (N : Node_Id; Val : Boolean) is
6052 pragma Assert (Nkind (N) in N_Entity);
6055 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag188 := Val;
6058 procedure Set_Flag189 (N : Node_Id; Val : Boolean) is
6060 pragma Assert (Nkind (N) in N_Entity);
6063 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag189 := Val;
6066 procedure Set_Flag190 (N : Node_Id; Val : Boolean) is
6068 pragma Assert (Nkind (N) in N_Entity);
6071 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag190 := Val;
6074 procedure Set_Flag191 (N : Node_Id; Val : Boolean) is
6076 pragma Assert (Nkind (N) in N_Entity);
6079 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag191 := Val;
6082 procedure Set_Flag192 (N : Node_Id; Val : Boolean) is
6084 pragma Assert (Nkind (N) in N_Entity);
6087 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag192 := Val;
6090 procedure Set_Flag193 (N : Node_Id; Val : Boolean) is
6092 pragma Assert (Nkind (N) in N_Entity);
6095 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag193 := Val;
6098 procedure Set_Flag194 (N : Node_Id; Val : Boolean) is
6100 pragma Assert (Nkind (N) in N_Entity);
6103 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag194 := Val;
6106 procedure Set_Flag195 (N : Node_Id; Val : Boolean) is
6108 pragma Assert (Nkind (N) in N_Entity);
6111 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag195 := Val;
6114 procedure Set_Flag196 (N : Node_Id; Val : Boolean) is
6116 pragma Assert (Nkind (N) in N_Entity);
6119 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag196 := Val;
6122 procedure Set_Flag197 (N : Node_Id; Val : Boolean) is
6124 pragma Assert (Nkind (N) in N_Entity);
6127 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag197 := Val;
6130 procedure Set_Flag198 (N : Node_Id; Val : Boolean) is
6132 pragma Assert (Nkind (N) in N_Entity);
6135 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag198 := Val;
6138 procedure Set_Flag199 (N : Node_Id; Val : Boolean) is
6140 pragma Assert (Nkind (N) in N_Entity);
6143 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag199 := Val;
6146 procedure Set_Flag200 (N : Node_Id; Val : Boolean) is
6148 pragma Assert (Nkind (N) in N_Entity);
6151 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag200 := Val;
6154 procedure Set_Flag201 (N : Node_Id; Val : Boolean) is
6156 pragma Assert (Nkind (N) in N_Entity);
6159 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag201 := Val;
6162 procedure Set_Flag202 (N : Node_Id; Val : Boolean) is
6164 pragma Assert (Nkind (N) in N_Entity);
6167 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag202 := Val;
6170 procedure Set_Flag203 (N : Node_Id; Val : Boolean) is
6172 pragma Assert (Nkind (N) in N_Entity);
6175 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag203 := Val;
6178 procedure Set_Flag204 (N : Node_Id; Val : Boolean) is
6180 pragma Assert (Nkind (N) in N_Entity);
6183 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag204 := Val;
6186 procedure Set_Flag205 (N : Node_Id; Val : Boolean) is
6188 pragma Assert (Nkind (N) in N_Entity);
6191 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag205 := Val;
6194 procedure Set_Flag206 (N : Node_Id; Val : Boolean) is
6196 pragma Assert (Nkind (N) in N_Entity);
6199 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag206 := Val;
6202 procedure Set_Flag207 (N : Node_Id; Val : Boolean) is
6204 pragma Assert (Nkind (N) in N_Entity);
6207 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag207 := Val;
6210 procedure Set_Flag208 (N : Node_Id; Val : Boolean) is
6212 pragma Assert (Nkind (N) in N_Entity);
6215 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag208 := Val;
6218 procedure Set_Flag209 (N : Node_Id; Val : Boolean) is
6220 pragma Assert (Nkind (N) in N_Entity);
6223 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag209 := Val;
6226 procedure Set_Flag210 (N : Node_Id; Val : Boolean) is
6228 pragma Assert (Nkind (N) in N_Entity);
6231 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag210 := Val;
6234 procedure Set_Flag211 (N : Node_Id; Val : Boolean) is
6236 pragma Assert (Nkind (N) in N_Entity);
6239 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag211 := Val;
6242 procedure Set_Flag212 (N : Node_Id; Val : Boolean) is
6244 pragma Assert (Nkind (N) in N_Entity);
6247 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag212 := Val;
6250 procedure Set_Flag213 (N : Node_Id; Val : Boolean) is
6252 pragma Assert (Nkind (N) in N_Entity);
6255 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag213 := Val;
6258 procedure Set_Flag214 (N : Node_Id; Val : Boolean) is
6260 pragma Assert (Nkind (N) in N_Entity);
6263 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag214 := Val;
6266 procedure Set_Flag215 (N : Node_Id; Val : Boolean) is
6268 pragma Assert (Nkind (N) in N_Entity);
6271 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag215 := Val;
6274 procedure Set_Flag216 (N : Node_Id; Val : Boolean) is
6276 pragma Assert (Nkind (N) in N_Entity);
6279 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag216 := Val;
6282 procedure Set_Flag217 (N : Node_Id; Val : Boolean) is
6284 pragma Assert (Nkind (N) in N_Entity);
6287 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag217 := Val;
6290 procedure Set_Flag218 (N : Node_Id; Val : Boolean) is
6292 pragma Assert (Nkind (N) in N_Entity);
6295 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag218 := Val;
6298 procedure Set_Flag219 (N : Node_Id; Val : Boolean) is
6300 pragma Assert (Nkind (N) in N_Entity);
6303 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag219 := Val;
6306 procedure Set_Flag220 (N : Node_Id; Val : Boolean) is
6308 pragma Assert (Nkind (N) in N_Entity);
6311 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag220 := Val;
6314 procedure Set_Flag221 (N : Node_Id; Val : Boolean) is
6316 pragma Assert (Nkind (N) in N_Entity);
6319 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag221 := Val;
6322 procedure Set_Flag222 (N : Node_Id; Val : Boolean) is
6324 pragma Assert (Nkind (N) in N_Entity);
6327 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag222 := Val;
6330 procedure Set_Flag223 (N : Node_Id; Val : Boolean) is
6332 pragma Assert (Nkind (N) in N_Entity);
6335 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag223 := Val;
6338 procedure Set_Flag224 (N : Node_Id; Val : Boolean) is
6340 pragma Assert (Nkind (N) in N_Entity);
6343 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag224 := Val;
6346 procedure Set_Flag225 (N : Node_Id; Val : Boolean) is
6348 pragma Assert (Nkind (N) in N_Entity);
6351 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag225 := Val;
6354 procedure Set_Flag226 (N : Node_Id; Val : Boolean) is
6356 pragma Assert (Nkind (N) in N_Entity);
6359 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag226 := Val;
6362 procedure Set_Flag227 (N : Node_Id; Val : Boolean) is
6364 pragma Assert (Nkind (N) in N_Entity);
6367 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag227 := Val;
6370 procedure Set_Flag228 (N : Node_Id; Val : Boolean) is
6372 pragma Assert (Nkind (N) in N_Entity);
6375 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag228 := Val;
6378 procedure Set_Flag229 (N : Node_Id; Val : Boolean) is
6380 pragma Assert (Nkind (N) in N_Entity);
6383 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag229 := Val;
6386 procedure Set_Flag230 (N : Node_Id; Val : Boolean) is
6388 pragma Assert (Nkind (N) in N_Entity);
6391 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag230 := Val;
6394 procedure Set_Flag231 (N : Node_Id; Val : Boolean) is
6396 pragma Assert (Nkind (N) in N_Entity);
6399 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag231 := Val;
6402 procedure Set_Flag232 (N : Node_Id; Val : Boolean) is
6404 pragma Assert (Nkind (N) in N_Entity);
6407 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag232 := Val;
6410 procedure Set_Flag233 (N : Node_Id; Val : Boolean) is
6412 pragma Assert (Nkind (N) in N_Entity);
6415 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag233 := Val;
6418 procedure Set_Flag234 (N : Node_Id; Val : Boolean) is
6420 pragma Assert (Nkind (N) in N_Entity);
6423 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag234 := Val;
6426 procedure Set_Flag235 (N : Node_Id; Val : Boolean) is
6428 pragma Assert (Nkind (N) in N_Entity);
6431 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag235 := Val;
6434 procedure Set_Flag236 (N : Node_Id; Val : Boolean) is
6436 pragma Assert (Nkind (N) in N_Entity);
6439 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag236 := Val;
6442 procedure Set_Flag237 (N : Node_Id; Val : Boolean) is
6444 pragma Assert (Nkind (N) in N_Entity);
6447 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag237 := Val;
6450 procedure Set_Flag238 (N : Node_Id; Val : Boolean) is
6452 pragma Assert (Nkind (N) in N_Entity);
6455 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag238 := Val;
6458 procedure Set_Flag239 (N : Node_Id; Val : Boolean) is
6460 pragma Assert (Nkind (N) in N_Entity);
6463 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag239 := Val;
6466 procedure Set_Flag240 (N : Node_Id; Val : Boolean) is
6468 pragma Assert (Nkind (N) in N_Entity);
6471 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag240 := Val;
6474 procedure Set_Flag241 (N : Node_Id; Val : Boolean) is
6476 pragma Assert (Nkind (N) in N_Entity);
6479 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag241 := Val;
6482 procedure Set_Flag242 (N : Node_Id; Val : Boolean) is
6484 pragma Assert (Nkind (N) in N_Entity);
6487 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag242 := Val;
6490 procedure Set_Flag243 (N : Node_Id; Val : Boolean) is
6492 pragma Assert (Nkind (N) in N_Entity);
6495 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag243 := Val;
6498 procedure Set_Flag244 (N : Node_Id; Val : Boolean) is
6500 pragma Assert (Nkind (N) in N_Entity);
6503 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag244 := Val;
6506 procedure Set_Flag245 (N : Node_Id; Val : Boolean) is
6508 pragma Assert (Nkind (N) in N_Entity);
6511 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag245 := Val;
6514 procedure Set_Flag246 (N : Node_Id; Val : Boolean) is
6516 pragma Assert (Nkind (N) in N_Entity);
6519 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag246 := Val;
6522 procedure Set_Flag247 (N : Node_Id; Val : Boolean) is
6524 pragma Assert (Nkind (N) in N_Entity);
6527 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag247 := Val;
6530 procedure Set_Node1_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_Node1_With_Parent;
6541 procedure Set_Node2_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_Node2_With_Parent;
6552 procedure Set_Node3_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_Node3_With_Parent;
6563 procedure Set_Node4_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_Node4_With_Parent;
6574 procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
6576 pragma Assert (N <= Nodes.Last);
6579 Set_Parent (N => Val, Val => N);
6583 end Set_Node5_With_Parent;
6585 procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
6587 pragma Assert (N <= Nodes.Last);
6588 if Val /= No_List and then Val /= Error_List then
6589 Set_Parent (Val, N);
6592 end Set_List1_With_Parent;
6594 procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
6596 pragma Assert (N <= Nodes.Last);
6597 if Val /= No_List and then Val /= Error_List then
6598 Set_Parent (Val, N);
6601 end Set_List2_With_Parent;
6603 procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
6605 pragma Assert (N <= Nodes.Last);
6606 if Val /= No_List and then Val /= Error_List then
6607 Set_Parent (Val, N);
6610 end Set_List3_With_Parent;
6612 procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
6614 pragma Assert (N <= Nodes.Last);
6615 if Val /= No_List and then Val /= Error_List then
6616 Set_Parent (Val, N);
6619 end Set_List4_With_Parent;
6621 procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
6623 pragma Assert (N <= Nodes.Last);
6624 if Val /= No_List and then Val /= Error_List then
6625 Set_Parent (Val, N);
6628 end Set_List5_With_Parent;
6630 end Unchecked_Access;
6638 Nodes.Locked := False;
6639 Orig_Nodes.Locked := False;