1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2009, 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;
51 -- Suppose you find that node 12345 is messed up. You might want to find
52 -- the code that created that node. There are two ways to do this:
54 -- One way is to set a conditional breakpoint on New_Node_Debugging_Output
56 -- break nnd if n = 12345
57 -- and run gnat1 again from the beginning.
59 -- The other way is to set a breakpoint near the beginning (e.g. on
60 -- gnat1drv), and run. Then set Watch_Node (nickname "ww") to 12345 in gdb:
62 -- and set a breakpoint on New_Node_Breakpoint (nickname "nn"). Continue.
64 -- Either way, gnat1 will stop when node 12345 is created
66 -- The second method is faster
68 ww : Node_Id'Base := Node_Id'First - 1;
69 pragma Export (Ada, ww); -- trick the optimizer
70 Watch_Node : Node_Id'Base renames ww;
71 -- Node to "watch"; that is, whenever a node is created, we check if it is
72 -- equal to Watch_Node, and if so, call New_Node_Breakpoint. You have
73 -- presumably set a breakpoint on New_Node_Breakpoint. Note that the
74 -- initial value of Node_Id'First - 1 ensures that by default, no node
75 -- will be equal to Watch_Node.
78 pragma Export (Ada, nn);
79 procedure New_Node_Breakpoint renames nn;
80 -- This doesn't do anything interesting; it's just for setting breakpoint
81 -- on as explained above.
83 procedure nnd (N : Node_Id);
84 pragma Export (Ada, nnd);
85 procedure New_Node_Debugging_Output (N : Node_Id) renames nnd;
86 -- For debugging. If debugging is turned on, New_Node and New_Entity call
87 -- this. If debug flag N is turned on, this prints out the new node.
89 -- If Node = Watch_Node, this prints out the new node and calls
90 -- New_Node_Breakpoint. Otherwise, does nothing.
92 -----------------------------
93 -- Local Objects and Types --
94 -----------------------------
97 -- Count allocated nodes for Num_Nodes function
100 -- We are allowed to see these from within our own body!
102 use Atree_Private_Part;
103 -- We are also allowed to see our private data structures!
105 -- Functions used to store Entity_Kind value in Nkind field
107 -- The following declarations are used to store flags 65-72 in the
108 -- Nkind field of the third component of an extended (entity) node.
110 type Flag_Byte is record
121 pragma Pack (Flag_Byte);
122 for Flag_Byte'Size use 8;
124 type Flag_Byte_Ptr is access all Flag_Byte;
125 type Node_Kind_Ptr is access all Node_Kind;
127 function To_Flag_Byte is new
128 Unchecked_Conversion (Node_Kind, Flag_Byte);
130 function To_Flag_Byte_Ptr is new
131 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);
133 -- The following declarations are used to store flags 73-96 and the
134 -- Convention field in the Field12 field of the third component of an
135 -- extended (Entity) node.
137 type Flag_Word is record
165 Convention : Convention_Id;
168 pragma Pack (Flag_Word);
169 for Flag_Word'Size use 32;
170 for Flag_Word'Alignment use 4;
172 type Flag_Word_Ptr is access all Flag_Word;
173 type Union_Id_Ptr is access all Union_Id;
175 function To_Flag_Word is new
176 Unchecked_Conversion (Union_Id, Flag_Word);
178 function To_Flag_Word_Ptr is new
179 Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr);
181 -- The following declarations are used to store flags 97-128 in the
182 -- Field12 field of the fourth component of an extended (entity) node.
184 type Flag_Word2 is record
222 pragma Pack (Flag_Word2);
223 for Flag_Word2'Size use 32;
224 for Flag_Word2'Alignment use 4;
226 type Flag_Word2_Ptr is access all Flag_Word2;
228 function To_Flag_Word2 is new
229 Unchecked_Conversion (Union_Id, Flag_Word2);
231 function To_Flag_Word2_Ptr is new
232 Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr);
234 -- The following declarations are used to store flags 152-183 in the
235 -- Field11 field of the fourth component of an extended (entity) node.
237 type Flag_Word3 is record
275 pragma Pack (Flag_Word3);
276 for Flag_Word3'Size use 32;
277 for Flag_Word3'Alignment use 4;
279 type Flag_Word3_Ptr is access all Flag_Word3;
281 function To_Flag_Word3 is new
282 Unchecked_Conversion (Union_Id, Flag_Word3);
284 function To_Flag_Word3_Ptr is new
285 Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr);
287 -- The following declarations are used to store flags 184-215 in the
288 -- Field11 field of the fifth component of an extended (entity) node.
290 type Flag_Word4 is record
328 pragma Pack (Flag_Word4);
329 for Flag_Word4'Size use 32;
330 for Flag_Word4'Alignment use 4;
332 type Flag_Word4_Ptr is access all Flag_Word4;
334 function To_Flag_Word4 is new
335 Unchecked_Conversion (Union_Id, Flag_Word4);
337 function To_Flag_Word4_Ptr is new
338 Unchecked_Conversion (Union_Id_Ptr, Flag_Word4_Ptr);
340 -- The following declarations are used to store flags 216-247 in the
341 -- Field12 field of the fifth component of an extended (entity) node.
343 type Flag_Word5 is record
381 pragma Pack (Flag_Word5);
382 for Flag_Word5'Size use 32;
383 for Flag_Word5'Alignment use 4;
385 type Flag_Word5_Ptr is access all Flag_Word5;
387 function To_Flag_Word5 is new
388 Unchecked_Conversion (Union_Id, Flag_Word5);
390 function To_Flag_Word5_Ptr is new
391 Unchecked_Conversion (Union_Id_Ptr, Flag_Word5_Ptr);
393 --------------------------------------------------
394 -- Implementation of Tree Substitution Routines --
395 --------------------------------------------------
397 -- A separate table keeps track of the mapping between rewritten nodes
398 -- and their corresponding original tree nodes. Rewrite makes an entry
399 -- in this table for use by Original_Node. By default, if no call is
400 -- Rewrite, the entry in this table points to the original unwritten node.
402 -- Note: eventually, this should be a field in the Node directly, but
403 -- for now we do not want to disturb the efficiency of a power of 2
406 package Orig_Nodes is new Table.Table (
407 Table_Component_Type => Node_Id,
408 Table_Index_Type => Node_Id'Base,
409 Table_Low_Bound => First_Node_Id,
410 Table_Initial => Alloc.Orig_Nodes_Initial,
411 Table_Increment => Alloc.Orig_Nodes_Increment,
412 Table_Name => "Orig_Nodes");
414 --------------------------
415 -- Paren_Count Handling --
416 --------------------------
418 -- As noted in the spec, the paren count in a sub-expression node has
419 -- four possible values 0,1,2, and 3. The value 3 really means 3 or more,
420 -- and we use an auxiliary serially scanned table to record the actual
421 -- count. A serial search is fine, only pathological programs will use
422 -- entries in this table. Normal programs won't use it at all.
424 type Paren_Count_Entry is record
426 -- The node to which this count applies
428 Count : Nat range 3 .. Nat'Last;
429 -- The count of parentheses, which will be in the indicated range
432 package Paren_Counts is new Table.Table (
433 Table_Component_Type => Paren_Count_Entry,
434 Table_Index_Type => Int,
435 Table_Low_Bound => 0,
437 Table_Increment => 200,
438 Table_Name => "Paren_Counts");
440 -----------------------
441 -- Local Subprograms --
442 -----------------------
444 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id);
445 -- Fixup parent pointers for the syntactic children of Fix_Node after
446 -- a copy, setting them to Fix_Node when they pointed to Ref_Node.
448 function Allocate_Initialize_Node
450 With_Extension : Boolean) return Node_Id;
451 -- Allocate a new node or node extension. If Src is not empty,
452 -- the information for the newly-allocated node is copied from it.
454 ------------------------------
455 -- Allocate_Initialize_Node --
456 ------------------------------
458 function Allocate_Initialize_Node
460 With_Extension : Boolean) return Node_Id
462 New_Id : Node_Id := Src;
463 Nod : Node_Record := Default_Node;
464 Ext1 : Node_Record := Default_Node_Extension;
465 Ext2 : Node_Record := Default_Node_Extension;
466 Ext3 : Node_Record := Default_Node_Extension;
467 Ext4 : Node_Record := Default_Node_Extension;
470 if Present (Src) then
471 Nod := Nodes.Table (Src);
473 if Has_Extension (Src) then
474 Ext1 := Nodes.Table (Src + 1);
475 Ext2 := Nodes.Table (Src + 2);
476 Ext3 := Nodes.Table (Src + 3);
477 Ext4 := Nodes.Table (Src + 4);
481 if not (Present (Src)
482 and then not Has_Extension (Src)
483 and then With_Extension
484 and then Src = Nodes.Last)
486 -- We are allocating a new node, or extending a node
487 -- other than Nodes.Last.
490 New_Id := Nodes.Last;
491 Orig_Nodes.Append (New_Id);
492 Node_Count := Node_Count + 1;
495 -- Specifically copy Paren_Count to deal with creating new table entry
496 -- if the parentheses count is at the maximum possible value already.
498 if Present (Src) and then Nkind (Src) in N_Subexpr then
499 Set_Paren_Count (New_Id, Paren_Count (Src));
502 -- Set extension nodes if required
504 if With_Extension then
511 Orig_Nodes.Set_Last (Nodes.Last);
512 Allocate_List_Tables (Nodes.Last);
514 end Allocate_Initialize_Node;
520 function Analyzed (N : Node_Id) return Boolean is
522 pragma Assert (N <= Nodes.Last);
523 return Nodes.Table (N).Analyzed;
526 --------------------------
527 -- Basic_Set_Convention --
528 --------------------------
530 procedure Basic_Set_Convention (E : Entity_Id; Val : Convention_Id) is
532 pragma Assert (Nkind (E) in N_Entity);
535 (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention := Val;
536 end Basic_Set_Convention;
542 procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is
543 Save_Sloc : constant Source_Ptr := Sloc (N);
544 Save_In_List : constant Boolean := Nodes.Table (N).In_List;
545 Save_Link : constant Union_Id := Nodes.Table (N).Link;
546 Save_CFS : constant Boolean := Nodes.Table (N).Comes_From_Source;
547 Save_Posted : constant Boolean := Nodes.Table (N).Error_Posted;
548 Par_Count : Nat := 0;
551 if Nkind (N) in N_Subexpr then
552 Par_Count := Paren_Count (N);
555 Nodes.Table (N) := Default_Node;
556 Nodes.Table (N).Sloc := Save_Sloc;
557 Nodes.Table (N).In_List := Save_In_List;
558 Nodes.Table (N).Link := Save_Link;
559 Nodes.Table (N).Comes_From_Source := Save_CFS;
560 Nodes.Table (N).Nkind := New_Node_Kind;
561 Nodes.Table (N).Error_Posted := Save_Posted;
563 if New_Node_Kind in N_Subexpr then
564 Set_Paren_Count (N, Par_Count);
568 -----------------------
569 -- Comes_From_Source --
570 -----------------------
572 function Comes_From_Source (N : Node_Id) return Boolean is
574 pragma Assert (N <= Nodes.Last);
575 return Nodes.Table (N).Comes_From_Source;
576 end Comes_From_Source;
582 function Convention (E : Entity_Id) return Convention_Id is
584 pragma Assert (Nkind (E) in N_Entity);
585 return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention;
592 procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is
593 Save_In_List : constant Boolean := Nodes.Table (Destination).In_List;
594 Save_Link : constant Union_Id := Nodes.Table (Destination).Link;
597 Nodes.Table (Destination) := Nodes.Table (Source);
598 Nodes.Table (Destination).In_List := Save_In_List;
599 Nodes.Table (Destination).Link := Save_Link;
601 -- Specifically set Paren_Count to make sure auxiliary table entry
602 -- gets correctly made if the parentheses count is at the max value.
604 if Nkind (Destination) in N_Subexpr then
605 Set_Paren_Count (Destination, Paren_Count (Source));
608 -- Deal with copying extension nodes if present
610 if Has_Extension (Source) then
611 pragma Assert (Has_Extension (Destination));
612 Nodes.Table (Destination + 1) := Nodes.Table (Source + 1);
613 Nodes.Table (Destination + 2) := Nodes.Table (Source + 2);
614 Nodes.Table (Destination + 3) := Nodes.Table (Source + 3);
615 Nodes.Table (Destination + 4) := Nodes.Table (Source + 4);
618 pragma Assert (not Has_Extension (Source));
623 ------------------------
624 -- Copy_Separate_Tree --
625 ------------------------
627 function Copy_Separate_Tree (Source : Node_Id) return Node_Id is
630 function Copy_Entity (E : Entity_Id) return Entity_Id;
631 -- Copy Entity, copying only the Ekind and Chars fields
633 function Copy_List (List : List_Id) return List_Id;
636 function Possible_Copy (Field : Union_Id) return Union_Id;
637 -- Given a field, returns a copy of the node or list if its parent
638 -- is the current source node, and otherwise returns the input
644 function Copy_Entity (E : Entity_Id) return Entity_Id is
648 case N_Entity (Nkind (E)) is
649 when N_Defining_Identifier =>
650 New_Ent := New_Entity (N_Defining_Identifier, Sloc (E));
652 when N_Defining_Character_Literal =>
653 New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E));
655 when N_Defining_Operator_Symbol =>
656 New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E));
659 Set_Chars (New_Ent, Chars (E));
667 function Copy_List (List : List_Id) return List_Id is
672 if List = No_List then
679 while Present (E) loop
680 if Has_Extension (E) then
681 Append (Copy_Entity (E), NL);
683 Append (Copy_Separate_Tree (E), NL);
697 function Possible_Copy (Field : Union_Id) return Union_Id is
701 if Field in Node_Range then
702 New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field)));
704 if Parent (Node_Id (Field)) = Source then
705 Set_Parent (Node_Id (New_N), New_Id);
710 elsif Field in List_Range then
711 New_N := Union_Id (Copy_List (List_Id (Field)));
713 if Parent (List_Id (Field)) = Source then
714 Set_Parent (List_Id (New_N), New_Id);
724 -- Start of processing for Copy_Separate_Tree
727 if Source <= Empty_Or_Error then
730 elsif Has_Extension (Source) then
731 return Copy_Entity (Source);
734 New_Id := New_Copy (Source);
736 -- Recursively copy descendents
738 Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id)));
739 Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id)));
740 Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id)));
741 Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id)));
742 Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id)));
744 -- Set Entity field to Empty
745 -- Why is this done??? and why is it always right to do it???
747 if Nkind (New_Id) in N_Has_Entity
748 or else Nkind (New_Id) = N_Freeze_Entity
750 Set_Entity (New_Id, Empty);
753 -- All done, return copied node
757 end Copy_Separate_Tree;
763 function Ekind (E : Entity_Id) return Entity_Kind is
765 pragma Assert (Nkind (E) in N_Entity);
766 return N_To_E (Nodes.Table (E + 1).Nkind);
773 function Error_Posted (N : Node_Id) return Boolean is
775 pragma Assert (N <= Nodes.Last);
776 return Nodes.Table (N).Error_Posted;
779 -----------------------
780 -- Exchange_Entities --
781 -----------------------
783 procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is
784 Temp_Ent : Node_Record;
787 pragma Assert (Has_Extension (E1)
788 and then Has_Extension (E2)
789 and then not Nodes.Table (E1).In_List
790 and then not Nodes.Table (E2).In_List);
792 -- Exchange the contents of the two entities
794 Temp_Ent := Nodes.Table (E1);
795 Nodes.Table (E1) := Nodes.Table (E2);
796 Nodes.Table (E2) := Temp_Ent;
797 Temp_Ent := Nodes.Table (E1 + 1);
798 Nodes.Table (E1 + 1) := Nodes.Table (E2 + 1);
799 Nodes.Table (E2 + 1) := Temp_Ent;
800 Temp_Ent := Nodes.Table (E1 + 2);
801 Nodes.Table (E1 + 2) := Nodes.Table (E2 + 2);
802 Nodes.Table (E2 + 2) := Temp_Ent;
803 Temp_Ent := Nodes.Table (E1 + 3);
804 Nodes.Table (E1 + 3) := Nodes.Table (E2 + 3);
805 Nodes.Table (E2 + 3) := Temp_Ent;
806 Temp_Ent := Nodes.Table (E1 + 4);
807 Nodes.Table (E1 + 4) := Nodes.Table (E2 + 4);
808 Nodes.Table (E2 + 4) := Temp_Ent;
810 -- That exchange exchanged the parent pointers as well, which is what
811 -- we want, but we need to patch up the defining identifier pointers
812 -- in the parent nodes (the child pointers) to match this switch
813 -- unless for Implicit types entities which have no parent, in which
814 -- case we don't do anything otherwise we won't be able to revert back
815 -- to the original situation.
817 -- Shouldn't this use Is_Itype instead of the Parent test
819 if Present (Parent (E1)) and then Present (Parent (E2)) then
820 Set_Defining_Identifier (Parent (E1), E1);
821 Set_Defining_Identifier (Parent (E2), E2);
823 end Exchange_Entities;
829 function Extend_Node (Node : Node_Id) return Entity_Id is
832 procedure Debug_Extend_Node;
833 pragma Inline (Debug_Extend_Node);
834 -- Debug routine for debug flag N
836 -----------------------
837 -- Debug_Extend_Node --
838 -----------------------
840 procedure Debug_Extend_Node is
843 Write_Str ("Extend node ");
844 Write_Int (Int (Node));
846 if Result = Node then
847 Write_Str (" in place");
849 Write_Str (" copied to ");
850 Write_Int (Int (Result));
855 end Debug_Extend_Node;
857 -- Start of processing for Extend_Node
860 pragma Assert (not (Has_Extension (Node)));
861 Result := Allocate_Initialize_Node (Node, With_Extension => True);
862 pragma Debug (Debug_Extend_Node);
870 procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id) is
872 procedure Fix_Parent (Field : Union_Id);
873 -- Fixup one parent pointer. Field is checked to see if it points to
874 -- a node, list, or element list that has a parent that points to
875 -- Ref_Node. If so, the parent is reset to point to Fix_Node.
881 procedure Fix_Parent (Field : Union_Id) is
883 -- Fix parent of node that is referenced by Field. Note that we must
884 -- exclude the case where the node is a member of a list, because in
885 -- this case the parent is the parent of the list.
887 if Field in Node_Range
888 and then Present (Node_Id (Field))
889 and then not Nodes.Table (Node_Id (Field)).In_List
890 and then Parent (Node_Id (Field)) = Ref_Node
892 Set_Parent (Node_Id (Field), Fix_Node);
894 -- Fix parent of list that is referenced by Field
896 elsif Field in List_Range
897 and then Present (List_Id (Field))
898 and then Parent (List_Id (Field)) = Ref_Node
900 Set_Parent (List_Id (Field), Fix_Node);
904 -- Start of processing for Fix_Parents
907 Fix_Parent (Field1 (Fix_Node));
908 Fix_Parent (Field2 (Fix_Node));
909 Fix_Parent (Field3 (Fix_Node));
910 Fix_Parent (Field4 (Fix_Node));
911 Fix_Parent (Field5 (Fix_Node));
914 -----------------------------------
915 -- Get_Comes_From_Source_Default --
916 -----------------------------------
918 function Get_Comes_From_Source_Default return Boolean is
920 return Default_Node.Comes_From_Source;
921 end Get_Comes_From_Source_Default;
927 function Has_Extension (N : Node_Id) return Boolean is
929 return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension;
936 procedure Initialize is
938 pragma Warnings (Off, Dummy);
942 Atree_Private_Part.Nodes.Init;
946 -- Allocate Empty node
948 Dummy := New_Node (N_Empty, No_Location);
949 Set_Name1 (Empty, No_Name);
951 -- Allocate Error node, and set Error_Posted, since we certainly
952 -- only generate an Error node if we do post some kind of error!
954 Dummy := New_Node (N_Error, No_Location);
955 Set_Name1 (Error, Error_Name);
956 Set_Error_Posted (Error, True);
959 --------------------------
960 -- Is_Rewrite_Insertion --
961 --------------------------
963 function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is
965 return Nodes.Table (Node).Rewrite_Ins;
966 end Is_Rewrite_Insertion;
968 -----------------------------
969 -- Is_Rewrite_Substitution --
970 -----------------------------
972 function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is
974 return Orig_Nodes.Table (Node) /= Node;
975 end Is_Rewrite_Substitution;
981 function Last_Node_Id return Node_Id is
992 Nodes.Locked := True;
993 Orig_Nodes.Locked := True;
998 ----------------------------
999 -- Mark_Rewrite_Insertion --
1000 ----------------------------
1002 procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is
1004 Nodes.Table (New_Node).Rewrite_Ins := True;
1005 end Mark_Rewrite_Insertion;
1011 function New_Copy (Source : Node_Id) return Node_Id is
1012 New_Id : Node_Id := Source;
1015 if Source > Empty_Or_Error then
1017 New_Id := Allocate_Initialize_Node (Source, Has_Extension (Source));
1019 Nodes.Table (New_Id).Link := Empty_List_Or_Node;
1020 Nodes.Table (New_Id).In_List := False;
1022 -- If the original is marked as a rewrite insertion, then unmark
1023 -- the copy, since we inserted the original, not the copy.
1025 Nodes.Table (New_Id).Rewrite_Ins := False;
1026 pragma Debug (New_Node_Debugging_Output (New_Id));
1037 (New_Node_Kind : Node_Kind;
1038 New_Sloc : Source_Ptr) return Entity_Id
1043 pragma Assert (New_Node_Kind in N_Entity);
1045 Ent := Allocate_Initialize_Node (Empty, With_Extension => True);
1047 -- If this is a node with a real location and we are generating
1048 -- source nodes, then reset Current_Error_Node. This is useful
1049 -- if we bomb during parsing to get a error location for the bomb.
1051 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1052 Current_Error_Node := Ent;
1055 Nodes.Table (Ent).Nkind := New_Node_Kind;
1056 Nodes.Table (Ent).Sloc := New_Sloc;
1057 pragma Debug (New_Node_Debugging_Output (Ent));
1067 (New_Node_Kind : Node_Kind;
1068 New_Sloc : Source_Ptr) return Node_Id
1073 pragma Assert (New_Node_Kind not in N_Entity);
1074 Nod := Allocate_Initialize_Node (Empty, With_Extension => False);
1075 Nodes.Table (Nod).Nkind := New_Node_Kind;
1076 Nodes.Table (Nod).Sloc := New_Sloc;
1077 pragma Debug (New_Node_Debugging_Output (Nod));
1079 -- If this is a node with a real location and we are generating source
1080 -- nodes, then reset Current_Error_Node. This is useful if we bomb
1081 -- during parsing to get an error location for the bomb.
1083 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1084 Current_Error_Node := Nod;
1090 -------------------------
1091 -- New_Node_Breakpoint --
1092 -------------------------
1094 procedure nn is -- New_Node_Breakpoint
1096 Write_Str ("Watched node ");
1097 Write_Int (Int (Watch_Node));
1098 Write_Str (" created");
1102 -------------------------------
1103 -- New_Node_Debugging_Output --
1104 -------------------------------
1106 procedure nnd (N : Node_Id) is -- New_Node_Debugging_Output
1107 Node_Is_Watched : constant Boolean := N = Watch_Node;
1110 if Debug_Flag_N or else Node_Is_Watched then
1111 Write_Str ("Allocate ");
1113 if Nkind (N) in N_Entity then
1114 Write_Str ("entity");
1119 Write_Str (", Id = ");
1120 Write_Int (Int (N));
1122 Write_Location (Sloc (N));
1124 Write_Str (Node_Kind'Image (Nkind (N)));
1127 if Node_Is_Watched then
1128 New_Node_Breakpoint;
1137 function Nkind (N : Node_Id) return Node_Kind is
1139 return Nodes.Table (N).Nkind;
1149 V2 : Node_Kind) return Boolean
1152 return Nkind_In (Nkind (N), V1, V2);
1159 V3 : Node_Kind) return Boolean
1162 return Nkind_In (Nkind (N), V1, V2, V3);
1170 V4 : Node_Kind) return Boolean
1173 return Nkind_In (Nkind (N), V1, V2, V3, V4);
1182 V5 : Node_Kind) return Boolean
1185 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5);
1195 V6 : Node_Kind) return Boolean
1198 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6);
1209 V7 : Node_Kind) return Boolean
1212 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7);
1224 V8 : Node_Kind) return Boolean
1227 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8);
1240 V9 : Node_Kind) return Boolean
1243 return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8, V9);
1249 function No (N : Node_Id) return Boolean is
1258 function Nodes_Address return System.Address is
1260 return Nodes.Table (First_Node_Id)'Address;
1267 function Num_Nodes return Nat is
1276 function Original_Node (Node : Node_Id) return Node_Id is
1278 return Orig_Nodes.Table (Node);
1285 function Paren_Count (N : Node_Id) return Nat is
1289 pragma Assert (N <= Nodes.Last);
1291 if Nodes.Table (N).Pflag1 then
1295 if Nodes.Table (N).Pflag2 then
1299 -- Value of 0,1,2 returned as is
1304 -- Value of 3 means we search the table, and we must find an entry
1307 for J in Paren_Counts.First .. Paren_Counts.Last loop
1308 if N = Paren_Counts.Table (J).Nod then
1309 return Paren_Counts.Table (J).Count;
1313 raise Program_Error;
1321 function Parent (N : Node_Id) return Node_Id is
1323 if Is_List_Member (N) then
1324 return Parent (List_Containing (N));
1326 return Node_Id (Nodes.Table (N).Link);
1334 function Present (N : Node_Id) return Boolean is
1339 --------------------------------
1340 -- Preserve_Comes_From_Source --
1341 --------------------------------
1343 procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is
1345 Nodes.Table (NewN).Comes_From_Source :=
1346 Nodes.Table (OldN).Comes_From_Source;
1347 end Preserve_Comes_From_Source;
1353 function Relocate_Node (Source : Node_Id) return Node_Id is
1361 New_Node := New_Copy (Source);
1362 Fix_Parents (Ref_Node => Source, Fix_Node => New_Node);
1364 -- We now set the parent of the new node to be the same as the
1365 -- parent of the source. Almost always this parent will be
1366 -- replaced by a new value when the relocated node is reattached
1367 -- to the tree, but by doing it now, we ensure that this node is
1368 -- not even temporarily disconnected from the tree. Note that this
1369 -- does not happen free, because in the list case, the parent does
1372 Set_Parent (New_Node, Parent (Source));
1374 -- If the node being relocated was a rewriting of some original
1375 -- node, then the relocated node has the same original node.
1377 if Orig_Nodes.Table (Source) /= Source then
1378 Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source);
1388 procedure Replace (Old_Node, New_Node : Node_Id) is
1389 Old_Post : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
1390 Old_CFS : constant Boolean := Nodes.Table (Old_Node).Comes_From_Source;
1394 (not Has_Extension (Old_Node)
1395 and not Has_Extension (New_Node)
1396 and not Nodes.Table (New_Node).In_List);
1398 -- Do copy, preserving link and in list status and comes from source
1400 Copy_Node (Source => New_Node, Destination => Old_Node);
1401 Nodes.Table (Old_Node).Comes_From_Source := Old_CFS;
1402 Nodes.Table (Old_Node).Error_Posted := Old_Post;
1404 -- Fix parents of substituted node, since it has changed identity
1406 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1408 -- Since we are doing a replace, we assume that the original node
1409 -- is intended to become the new replaced node. The call would be
1410 -- to Rewrite if there were an intention to save the original node.
1412 Orig_Nodes.Table (Old_Node) := Old_Node;
1419 procedure Rewrite (Old_Node, New_Node : Node_Id) is
1420 Old_Error_P : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
1421 -- This fields is always preserved in the new node
1423 Old_Paren_Count : Nat;
1424 Old_Must_Not_Freeze : Boolean;
1425 -- These fields are preserved in the new node only if the new node
1426 -- and the old node are both subexpression nodes.
1428 -- Note: it is a violation of abstraction levels for Must_Not_Freeze
1429 -- to be referenced like this. ???
1435 (not Has_Extension (Old_Node)
1436 and not Has_Extension (New_Node)
1437 and not Nodes.Table (New_Node).In_List);
1439 if Nkind (Old_Node) in N_Subexpr then
1440 Old_Paren_Count := Paren_Count (Old_Node);
1441 Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node);
1443 Old_Paren_Count := 0;
1444 Old_Must_Not_Freeze := False;
1447 -- Allocate a new node, to be used to preserve the original contents
1448 -- of the Old_Node, for possible later retrival by Original_Node and
1449 -- make an entry in the Orig_Nodes table. This is only done if we have
1450 -- not already rewritten the node, as indicated by an Orig_Nodes entry
1451 -- that does not reference the Old_Node.
1453 if Orig_Nodes.Table (Old_Node) = Old_Node then
1454 Sav_Node := New_Copy (Old_Node);
1455 Orig_Nodes.Table (Sav_Node) := Sav_Node;
1456 Orig_Nodes.Table (Old_Node) := Sav_Node;
1459 -- Copy substitute node into place, preserving old fields as required
1461 Copy_Node (Source => New_Node, Destination => Old_Node);
1462 Nodes.Table (Old_Node).Error_Posted := Old_Error_P;
1464 if Nkind (New_Node) in N_Subexpr then
1465 Set_Paren_Count (Old_Node, Old_Paren_Count);
1466 Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze);
1469 Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1476 procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is
1478 Nodes.Table (N).Analyzed := Val;
1481 ---------------------------
1482 -- Set_Comes_From_Source --
1483 ---------------------------
1485 procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is
1487 pragma Assert (N <= Nodes.Last);
1488 Nodes.Table (N).Comes_From_Source := Val;
1489 end Set_Comes_From_Source;
1491 -----------------------------------
1492 -- Set_Comes_From_Source_Default --
1493 -----------------------------------
1495 procedure Set_Comes_From_Source_Default (Default : Boolean) is
1497 Default_Node.Comes_From_Source := Default;
1498 end Set_Comes_From_Source_Default;
1504 procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is
1506 pragma Assert (Nkind (E) in N_Entity);
1507 Nodes.Table (E + 1).Nkind := E_To_N (Val);
1510 ----------------------
1511 -- Set_Error_Posted --
1512 ----------------------
1514 procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is
1516 Nodes.Table (N).Error_Posted := Val;
1517 end Set_Error_Posted;
1519 ---------------------
1520 -- Set_Paren_Count --
1521 ---------------------
1523 procedure Set_Paren_Count (N : Node_Id; Val : Nat) is
1525 pragma Assert (Nkind (N) in N_Subexpr);
1527 -- Value of 0,1,2 stored as is
1530 Nodes.Table (N).Pflag1 := (Val mod 2 /= 0);
1531 Nodes.Table (N).Pflag2 := (Val = 2);
1533 -- Value of 3 or greater stores 3 in node and makes table entry
1536 Nodes.Table (N).Pflag1 := True;
1537 Nodes.Table (N).Pflag2 := True;
1539 for J in Paren_Counts.First .. Paren_Counts.Last loop
1540 if N = Paren_Counts.Table (J).Nod then
1541 Paren_Counts.Table (J).Count := Val;
1546 Paren_Counts.Append ((Nod => N, Count => Val));
1548 end Set_Paren_Count;
1554 procedure Set_Parent (N : Node_Id; Val : Node_Id) is
1556 pragma Assert (not Nodes.Table (N).In_List);
1557 Nodes.Table (N).Link := Union_Id (Val);
1564 procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is
1566 Nodes.Table (N).Sloc := Val;
1573 function Sloc (N : Node_Id) return Source_Ptr is
1575 return Nodes.Table (N).Sloc;
1582 function Traverse_Func (Node : Node_Id) return Traverse_Final_Result is
1584 function Traverse_Field
1587 FN : Field_Num) return Traverse_Final_Result;
1588 -- Fld is one of the fields of Nod. If the field points to syntactic
1589 -- node or list, then this node or list is traversed, and the result is
1590 -- the result of this traversal. Otherwise a value of True is returned
1591 -- with no processing. FN is the number of the field (1 .. 5).
1593 --------------------
1594 -- Traverse_Field --
1595 --------------------
1597 function Traverse_Field
1600 FN : Field_Num) return Traverse_Final_Result
1603 if Fld = Union_Id (Empty) then
1606 -- Descendent is a node
1608 elsif Fld in Node_Range then
1610 -- Traverse descendent that is syntactic subtree node
1612 if Is_Syntactic_Field (Nkind (Nod), FN) then
1613 return Traverse_Func (Node_Id (Fld));
1615 -- Node that is not a syntactic subtree
1621 -- Descendent is a list
1623 elsif Fld in List_Range then
1625 -- Traverse descendent that is a syntactic subtree list
1627 if Is_Syntactic_Field (Nkind (Nod), FN) then
1629 Elmt : Node_Id := First (List_Id (Fld));
1631 while Present (Elmt) loop
1632 if Traverse_Func (Elmt) = Abandon then
1642 -- List that is not a syntactic subtree
1648 -- Field was not a node or a list
1655 Cur_Node : Node_Id := Node;
1657 -- Start of processing for Traverse_Func
1660 -- We walk Field2 last, and if it is a node, we eliminate the tail
1661 -- recursion by jumping back to this label. This is because Field2 is
1662 -- where the Left_Opnd field of N_Op_Concat is stored, and in practice
1663 -- concatenations are sometimes deeply nested, as in X1&X2&...&XN. This
1664 -- trick prevents us from running out of memory in that case. We don't
1665 -- bother eliminating the tail recursion if Field2 is a list.
1669 case Process (Cur_Node) is
1680 Cur_Node := Original_Node (Cur_Node);
1683 if Traverse_Field (Cur_Node, Field1 (Cur_Node), 1) = Abandon
1684 or else -- skip Field2 here
1685 Traverse_Field (Cur_Node, Field3 (Cur_Node), 3) = Abandon
1687 Traverse_Field (Cur_Node, Field4 (Cur_Node), 4) = Abandon
1689 Traverse_Field (Cur_Node, Field5 (Cur_Node), 5) = Abandon
1694 if Field2 (Cur_Node) not in Node_Range then
1695 return Traverse_Field (Cur_Node, Field2 (Cur_Node), 2);
1697 elsif Is_Syntactic_Field (Nkind (Cur_Node), 2)
1698 and then Field2 (Cur_Node) /= Empty_List_Or_Node
1700 -- Here is the tail recursion step, we reset Cur_Node and jump back
1701 -- to the start of the procedure, which has the same semantic effect
1704 Cur_Node := Node_Id (Field2 (Cur_Node));
1715 procedure Traverse_Proc (Node : Node_Id) is
1716 function Traverse is new Traverse_Func (Process);
1717 Discard : Traverse_Final_Result;
1718 pragma Warnings (Off, Discard);
1720 Discard := Traverse (Node);
1727 procedure Tree_Read is
1729 Tree_Read_Int (Node_Count);
1731 Orig_Nodes.Tree_Read;
1732 Paren_Counts.Tree_Read;
1739 procedure Tree_Write is
1741 Tree_Write_Int (Node_Count);
1743 Orig_Nodes.Tree_Write;
1744 Paren_Counts.Tree_Write;
1747 ------------------------------
1748 -- Unchecked Access Package --
1749 ------------------------------
1751 package body Unchecked_Access is
1753 function Field1 (N : Node_Id) return Union_Id is
1755 pragma Assert (N <= Nodes.Last);
1756 return Nodes.Table (N).Field1;
1759 function Field2 (N : Node_Id) return Union_Id is
1761 pragma Assert (N <= Nodes.Last);
1762 return Nodes.Table (N).Field2;
1765 function Field3 (N : Node_Id) return Union_Id is
1767 pragma Assert (N <= Nodes.Last);
1768 return Nodes.Table (N).Field3;
1771 function Field4 (N : Node_Id) return Union_Id is
1773 pragma Assert (N <= Nodes.Last);
1774 return Nodes.Table (N).Field4;
1777 function Field5 (N : Node_Id) return Union_Id is
1779 pragma Assert (N <= Nodes.Last);
1780 return Nodes.Table (N).Field5;
1783 function Field6 (N : Node_Id) return Union_Id is
1785 pragma Assert (Nkind (N) in N_Entity);
1786 return Nodes.Table (N + 1).Field6;
1789 function Field7 (N : Node_Id) return Union_Id is
1791 pragma Assert (Nkind (N) in N_Entity);
1792 return Nodes.Table (N + 1).Field7;
1795 function Field8 (N : Node_Id) return Union_Id is
1797 pragma Assert (Nkind (N) in N_Entity);
1798 return Nodes.Table (N + 1).Field8;
1801 function Field9 (N : Node_Id) return Union_Id is
1803 pragma Assert (Nkind (N) in N_Entity);
1804 return Nodes.Table (N + 1).Field9;
1807 function Field10 (N : Node_Id) return Union_Id is
1809 pragma Assert (Nkind (N) in N_Entity);
1810 return Nodes.Table (N + 1).Field10;
1813 function Field11 (N : Node_Id) return Union_Id is
1815 pragma Assert (Nkind (N) in N_Entity);
1816 return Nodes.Table (N + 1).Field11;
1819 function Field12 (N : Node_Id) return Union_Id is
1821 pragma Assert (Nkind (N) in N_Entity);
1822 return Nodes.Table (N + 1).Field12;
1825 function Field13 (N : Node_Id) return Union_Id is
1827 pragma Assert (Nkind (N) in N_Entity);
1828 return Nodes.Table (N + 2).Field6;
1831 function Field14 (N : Node_Id) return Union_Id is
1833 pragma Assert (Nkind (N) in N_Entity);
1834 return Nodes.Table (N + 2).Field7;
1837 function Field15 (N : Node_Id) return Union_Id is
1839 pragma Assert (Nkind (N) in N_Entity);
1840 return Nodes.Table (N + 2).Field8;
1843 function Field16 (N : Node_Id) return Union_Id is
1845 pragma Assert (Nkind (N) in N_Entity);
1846 return Nodes.Table (N + 2).Field9;
1849 function Field17 (N : Node_Id) return Union_Id is
1851 pragma Assert (Nkind (N) in N_Entity);
1852 return Nodes.Table (N + 2).Field10;
1855 function Field18 (N : Node_Id) return Union_Id is
1857 pragma Assert (Nkind (N) in N_Entity);
1858 return Nodes.Table (N + 2).Field11;
1861 function Field19 (N : Node_Id) return Union_Id is
1863 pragma Assert (Nkind (N) in N_Entity);
1864 return Nodes.Table (N + 3).Field6;
1867 function Field20 (N : Node_Id) return Union_Id is
1869 pragma Assert (Nkind (N) in N_Entity);
1870 return Nodes.Table (N + 3).Field7;
1873 function Field21 (N : Node_Id) return Union_Id is
1875 pragma Assert (Nkind (N) in N_Entity);
1876 return Nodes.Table (N + 3).Field8;
1879 function Field22 (N : Node_Id) return Union_Id is
1881 pragma Assert (Nkind (N) in N_Entity);
1882 return Nodes.Table (N + 3).Field9;
1885 function Field23 (N : Node_Id) return Union_Id is
1887 pragma Assert (Nkind (N) in N_Entity);
1888 return Nodes.Table (N + 3).Field10;
1891 function Field24 (N : Node_Id) return Union_Id is
1893 pragma Assert (Nkind (N) in N_Entity);
1894 return Nodes.Table (N + 4).Field6;
1897 function Field25 (N : Node_Id) return Union_Id is
1899 pragma Assert (Nkind (N) in N_Entity);
1900 return Nodes.Table (N + 4).Field7;
1903 function Field26 (N : Node_Id) return Union_Id is
1905 pragma Assert (Nkind (N) in N_Entity);
1906 return Nodes.Table (N + 4).Field8;
1909 function Field27 (N : Node_Id) return Union_Id is
1911 pragma Assert (Nkind (N) in N_Entity);
1912 return Nodes.Table (N + 4).Field9;
1915 function Field28 (N : Node_Id) return Union_Id is
1917 pragma Assert (Nkind (N) in N_Entity);
1918 return Nodes.Table (N + 4).Field10;
1921 function Node1 (N : Node_Id) return Node_Id is
1923 pragma Assert (N <= Nodes.Last);
1924 return Node_Id (Nodes.Table (N).Field1);
1927 function Node2 (N : Node_Id) return Node_Id is
1929 pragma Assert (N <= Nodes.Last);
1930 return Node_Id (Nodes.Table (N).Field2);
1933 function Node3 (N : Node_Id) return Node_Id is
1935 pragma Assert (N <= Nodes.Last);
1936 return Node_Id (Nodes.Table (N).Field3);
1939 function Node4 (N : Node_Id) return Node_Id is
1941 pragma Assert (N <= Nodes.Last);
1942 return Node_Id (Nodes.Table (N).Field4);
1945 function Node5 (N : Node_Id) return Node_Id is
1947 pragma Assert (N <= Nodes.Last);
1948 return Node_Id (Nodes.Table (N).Field5);
1951 function Node6 (N : Node_Id) return Node_Id is
1953 pragma Assert (Nkind (N) in N_Entity);
1954 return Node_Id (Nodes.Table (N + 1).Field6);
1957 function Node7 (N : Node_Id) return Node_Id is
1959 pragma Assert (Nkind (N) in N_Entity);
1960 return Node_Id (Nodes.Table (N + 1).Field7);
1963 function Node8 (N : Node_Id) return Node_Id is
1965 pragma Assert (Nkind (N) in N_Entity);
1966 return Node_Id (Nodes.Table (N + 1).Field8);
1969 function Node9 (N : Node_Id) return Node_Id is
1971 pragma Assert (Nkind (N) in N_Entity);
1972 return Node_Id (Nodes.Table (N + 1).Field9);
1975 function Node10 (N : Node_Id) return Node_Id is
1977 pragma Assert (Nkind (N) in N_Entity);
1978 return Node_Id (Nodes.Table (N + 1).Field10);
1981 function Node11 (N : Node_Id) return Node_Id is
1983 pragma Assert (Nkind (N) in N_Entity);
1984 return Node_Id (Nodes.Table (N + 1).Field11);
1987 function Node12 (N : Node_Id) return Node_Id is
1989 pragma Assert (Nkind (N) in N_Entity);
1990 return Node_Id (Nodes.Table (N + 1).Field12);
1993 function Node13 (N : Node_Id) return Node_Id is
1995 pragma Assert (Nkind (N) in N_Entity);
1996 return Node_Id (Nodes.Table (N + 2).Field6);
1999 function Node14 (N : Node_Id) return Node_Id is
2001 pragma Assert (Nkind (N) in N_Entity);
2002 return Node_Id (Nodes.Table (N + 2).Field7);
2005 function Node15 (N : Node_Id) return Node_Id is
2007 pragma Assert (Nkind (N) in N_Entity);
2008 return Node_Id (Nodes.Table (N + 2).Field8);
2011 function Node16 (N : Node_Id) return Node_Id is
2013 pragma Assert (Nkind (N) in N_Entity);
2014 return Node_Id (Nodes.Table (N + 2).Field9);
2017 function Node17 (N : Node_Id) return Node_Id is
2019 pragma Assert (Nkind (N) in N_Entity);
2020 return Node_Id (Nodes.Table (N + 2).Field10);
2023 function Node18 (N : Node_Id) return Node_Id is
2025 pragma Assert (Nkind (N) in N_Entity);
2026 return Node_Id (Nodes.Table (N + 2).Field11);
2029 function Node19 (N : Node_Id) return Node_Id is
2031 pragma Assert (Nkind (N) in N_Entity);
2032 return Node_Id (Nodes.Table (N + 3).Field6);
2035 function Node20 (N : Node_Id) return Node_Id is
2037 pragma Assert (Nkind (N) in N_Entity);
2038 return Node_Id (Nodes.Table (N + 3).Field7);
2041 function Node21 (N : Node_Id) return Node_Id is
2043 pragma Assert (Nkind (N) in N_Entity);
2044 return Node_Id (Nodes.Table (N + 3).Field8);
2047 function Node22 (N : Node_Id) return Node_Id is
2049 pragma Assert (Nkind (N) in N_Entity);
2050 return Node_Id (Nodes.Table (N + 3).Field9);
2053 function Node23 (N : Node_Id) return Node_Id is
2055 pragma Assert (Nkind (N) in N_Entity);
2056 return Node_Id (Nodes.Table (N + 3).Field10);
2059 function Node24 (N : Node_Id) return Node_Id is
2061 pragma Assert (Nkind (N) in N_Entity);
2062 return Node_Id (Nodes.Table (N + 4).Field6);
2065 function Node25 (N : Node_Id) return Node_Id is
2067 pragma Assert (Nkind (N) in N_Entity);
2068 return Node_Id (Nodes.Table (N + 4).Field7);
2071 function Node26 (N : Node_Id) return Node_Id is
2073 pragma Assert (Nkind (N) in N_Entity);
2074 return Node_Id (Nodes.Table (N + 4).Field8);
2077 function Node27 (N : Node_Id) return Node_Id is
2079 pragma Assert (Nkind (N) in N_Entity);
2080 return Node_Id (Nodes.Table (N + 4).Field9);
2083 function Node28 (N : Node_Id) return Node_Id is
2085 pragma Assert (Nkind (N) in N_Entity);
2086 return Node_Id (Nodes.Table (N + 4).Field10);
2089 function List1 (N : Node_Id) return List_Id is
2091 pragma Assert (N <= Nodes.Last);
2092 return List_Id (Nodes.Table (N).Field1);
2095 function List2 (N : Node_Id) return List_Id is
2097 pragma Assert (N <= Nodes.Last);
2098 return List_Id (Nodes.Table (N).Field2);
2101 function List3 (N : Node_Id) return List_Id is
2103 pragma Assert (N <= Nodes.Last);
2104 return List_Id (Nodes.Table (N).Field3);
2107 function List4 (N : Node_Id) return List_Id is
2109 pragma Assert (N <= Nodes.Last);
2110 return List_Id (Nodes.Table (N).Field4);
2113 function List5 (N : Node_Id) return List_Id is
2115 pragma Assert (N <= Nodes.Last);
2116 return List_Id (Nodes.Table (N).Field5);
2119 function List10 (N : Node_Id) return List_Id is
2121 pragma Assert (Nkind (N) in N_Entity);
2122 return List_Id (Nodes.Table (N + 1).Field10);
2125 function List14 (N : Node_Id) return List_Id is
2127 pragma Assert (Nkind (N) in N_Entity);
2128 return List_Id (Nodes.Table (N + 2).Field7);
2131 function Elist1 (N : Node_Id) return Elist_Id is
2132 pragma Assert (N <= Nodes.Last);
2133 Value : constant Union_Id := Nodes.Table (N).Field1;
2138 return Elist_Id (Value);
2142 function Elist2 (N : Node_Id) return Elist_Id is
2143 pragma Assert (N <= Nodes.Last);
2144 Value : constant Union_Id := Nodes.Table (N).Field2;
2149 return Elist_Id (Value);
2153 function Elist3 (N : Node_Id) return Elist_Id is
2154 pragma Assert (N <= Nodes.Last);
2155 Value : constant Union_Id := Nodes.Table (N).Field3;
2160 return Elist_Id (Value);
2164 function Elist4 (N : Node_Id) return Elist_Id is
2165 pragma Assert (N <= Nodes.Last);
2166 Value : constant Union_Id := Nodes.Table (N).Field4;
2171 return Elist_Id (Value);
2175 function Elist8 (N : Node_Id) return Elist_Id is
2176 pragma Assert (Nkind (N) in N_Entity);
2177 Value : constant Union_Id := Nodes.Table (N + 1).Field8;
2182 return Elist_Id (Value);
2186 function Elist13 (N : Node_Id) return Elist_Id is
2187 pragma Assert (Nkind (N) in N_Entity);
2188 Value : constant Union_Id := Nodes.Table (N + 2).Field6;
2193 return Elist_Id (Value);
2197 function Elist15 (N : Node_Id) return Elist_Id is
2198 pragma Assert (Nkind (N) in N_Entity);
2199 Value : constant Union_Id := Nodes.Table (N + 2).Field8;
2204 return Elist_Id (Value);
2208 function Elist16 (N : Node_Id) return Elist_Id is
2209 pragma Assert (Nkind (N) in N_Entity);
2210 Value : constant Union_Id := Nodes.Table (N + 2).Field9;
2215 return Elist_Id (Value);
2219 function Elist18 (N : Node_Id) return Elist_Id is
2220 pragma Assert (Nkind (N) in N_Entity);
2221 Value : constant Union_Id := Nodes.Table (N + 2).Field11;
2226 return Elist_Id (Value);
2230 function Elist21 (N : Node_Id) return Elist_Id is
2231 pragma Assert (Nkind (N) in N_Entity);
2232 Value : constant Union_Id := Nodes.Table (N + 3).Field8;
2237 return Elist_Id (Value);
2241 function Elist23 (N : Node_Id) return Elist_Id is
2242 pragma Assert (Nkind (N) in N_Entity);
2243 Value : constant Union_Id := Nodes.Table (N + 3).Field10;
2248 return Elist_Id (Value);
2252 function Elist25 (N : Node_Id) return Elist_Id is
2253 pragma Assert (Nkind (N) in N_Entity);
2254 Value : constant Union_Id := Nodes.Table (N + 4).Field7;
2259 return Elist_Id (Value);
2263 function Elist26 (N : Node_Id) return Elist_Id is
2264 pragma Assert (Nkind (N) in N_Entity);
2265 Value : constant Union_Id := Nodes.Table (N + 4).Field8;
2270 return Elist_Id (Value);
2274 function Name1 (N : Node_Id) return Name_Id is
2276 pragma Assert (N <= Nodes.Last);
2277 return Name_Id (Nodes.Table (N).Field1);
2280 function Name2 (N : Node_Id) return Name_Id is
2282 pragma Assert (N <= Nodes.Last);
2283 return Name_Id (Nodes.Table (N).Field2);
2286 function Str3 (N : Node_Id) return String_Id is
2288 pragma Assert (N <= Nodes.Last);
2289 return String_Id (Nodes.Table (N).Field3);
2292 function Uint2 (N : Node_Id) return Uint is
2293 pragma Assert (N <= Nodes.Last);
2294 U : constant Union_Id := Nodes.Table (N).Field2;
2299 return From_Union (U);
2303 function Uint3 (N : Node_Id) return Uint is
2304 pragma Assert (N <= Nodes.Last);
2305 U : constant Union_Id := Nodes.Table (N).Field3;
2310 return From_Union (U);
2314 function Uint4 (N : Node_Id) return Uint is
2315 pragma Assert (N <= Nodes.Last);
2316 U : constant Union_Id := Nodes.Table (N).Field4;
2321 return From_Union (U);
2325 function Uint5 (N : Node_Id) return Uint is
2326 pragma Assert (N <= Nodes.Last);
2327 U : constant Union_Id := Nodes.Table (N).Field5;
2332 return From_Union (U);
2336 function Uint8 (N : Node_Id) return Uint is
2337 pragma Assert (Nkind (N) in N_Entity);
2338 U : constant Union_Id := Nodes.Table (N + 1).Field8;
2343 return From_Union (U);
2347 function Uint9 (N : Node_Id) return Uint is
2348 pragma Assert (Nkind (N) in N_Entity);
2349 U : constant Union_Id := Nodes.Table (N + 1).Field9;
2354 return From_Union (U);
2358 function Uint10 (N : Node_Id) return Uint is
2359 pragma Assert (Nkind (N) in N_Entity);
2360 U : constant Union_Id := Nodes.Table (N + 1).Field10;
2365 return From_Union (U);
2369 function Uint11 (N : Node_Id) return Uint is
2370 pragma Assert (Nkind (N) in N_Entity);
2371 U : constant Union_Id := Nodes.Table (N + 1).Field11;
2376 return From_Union (U);
2380 function Uint12 (N : Node_Id) return Uint is
2381 pragma Assert (Nkind (N) in N_Entity);
2382 U : constant Union_Id := Nodes.Table (N + 1).Field12;
2387 return From_Union (U);
2391 function Uint13 (N : Node_Id) return Uint is
2392 pragma Assert (Nkind (N) in N_Entity);
2393 U : constant Union_Id := Nodes.Table (N + 2).Field6;
2398 return From_Union (U);
2402 function Uint14 (N : Node_Id) return Uint is
2403 pragma Assert (Nkind (N) in N_Entity);
2404 U : constant Union_Id := Nodes.Table (N + 2).Field7;
2409 return From_Union (U);
2413 function Uint15 (N : Node_Id) return Uint is
2414 pragma Assert (Nkind (N) in N_Entity);
2415 U : constant Union_Id := Nodes.Table (N + 2).Field8;
2420 return From_Union (U);
2424 function Uint16 (N : Node_Id) return Uint is
2425 pragma Assert (Nkind (N) in N_Entity);
2426 U : constant Union_Id := Nodes.Table (N + 2).Field9;
2431 return From_Union (U);
2435 function Uint17 (N : Node_Id) return Uint is
2436 pragma Assert (Nkind (N) in N_Entity);
2437 U : constant Union_Id := Nodes.Table (N + 2).Field10;
2442 return From_Union (U);
2446 function Uint22 (N : Node_Id) return Uint is
2447 pragma Assert (Nkind (N) in N_Entity);
2448 U : constant Union_Id := Nodes.Table (N + 3).Field9;
2453 return From_Union (U);
2457 function Ureal3 (N : Node_Id) return Ureal is
2459 pragma Assert (N <= Nodes.Last);
2460 return From_Union (Nodes.Table (N).Field3);
2463 function Ureal18 (N : Node_Id) return Ureal is
2465 pragma Assert (Nkind (N) in N_Entity);
2466 return From_Union (Nodes.Table (N + 2).Field11);
2469 function Ureal21 (N : Node_Id) return Ureal is
2471 pragma Assert (Nkind (N) in N_Entity);
2472 return From_Union (Nodes.Table (N + 3).Field8);
2475 function Flag4 (N : Node_Id) return Boolean is
2477 pragma Assert (N <= Nodes.Last);
2478 return Nodes.Table (N).Flag4;
2481 function Flag5 (N : Node_Id) return Boolean is
2483 pragma Assert (N <= Nodes.Last);
2484 return Nodes.Table (N).Flag5;
2487 function Flag6 (N : Node_Id) return Boolean is
2489 pragma Assert (N <= Nodes.Last);
2490 return Nodes.Table (N).Flag6;
2493 function Flag7 (N : Node_Id) return Boolean is
2495 pragma Assert (N <= Nodes.Last);
2496 return Nodes.Table (N).Flag7;
2499 function Flag8 (N : Node_Id) return Boolean is
2501 pragma Assert (N <= Nodes.Last);
2502 return Nodes.Table (N).Flag8;
2505 function Flag9 (N : Node_Id) return Boolean is
2507 pragma Assert (N <= Nodes.Last);
2508 return Nodes.Table (N).Flag9;
2511 function Flag10 (N : Node_Id) return Boolean is
2513 pragma Assert (N <= Nodes.Last);
2514 return Nodes.Table (N).Flag10;
2517 function Flag11 (N : Node_Id) return Boolean is
2519 pragma Assert (N <= Nodes.Last);
2520 return Nodes.Table (N).Flag11;
2523 function Flag12 (N : Node_Id) return Boolean is
2525 pragma Assert (N <= Nodes.Last);
2526 return Nodes.Table (N).Flag12;
2529 function Flag13 (N : Node_Id) return Boolean is
2531 pragma Assert (N <= Nodes.Last);
2532 return Nodes.Table (N).Flag13;
2535 function Flag14 (N : Node_Id) return Boolean is
2537 pragma Assert (N <= Nodes.Last);
2538 return Nodes.Table (N).Flag14;
2541 function Flag15 (N : Node_Id) return Boolean is
2543 pragma Assert (N <= Nodes.Last);
2544 return Nodes.Table (N).Flag15;
2547 function Flag16 (N : Node_Id) return Boolean is
2549 pragma Assert (N <= Nodes.Last);
2550 return Nodes.Table (N).Flag16;
2553 function Flag17 (N : Node_Id) return Boolean is
2555 pragma Assert (N <= Nodes.Last);
2556 return Nodes.Table (N).Flag17;
2559 function Flag18 (N : Node_Id) return Boolean is
2561 pragma Assert (N <= Nodes.Last);
2562 return Nodes.Table (N).Flag18;
2565 function Flag19 (N : Node_Id) return Boolean is
2567 pragma Assert (Nkind (N) in N_Entity);
2568 return Nodes.Table (N + 1).In_List;
2571 function Flag20 (N : Node_Id) return Boolean is
2573 pragma Assert (Nkind (N) in N_Entity);
2574 return Nodes.Table (N + 1).Unused_1;
2577 function Flag21 (N : Node_Id) return Boolean is
2579 pragma Assert (Nkind (N) in N_Entity);
2580 return Nodes.Table (N + 1).Rewrite_Ins;
2583 function Flag22 (N : Node_Id) return Boolean is
2585 pragma Assert (Nkind (N) in N_Entity);
2586 return Nodes.Table (N + 1).Analyzed;
2589 function Flag23 (N : Node_Id) return Boolean is
2591 pragma Assert (Nkind (N) in N_Entity);
2592 return Nodes.Table (N + 1).Comes_From_Source;
2595 function Flag24 (N : Node_Id) return Boolean is
2597 pragma Assert (Nkind (N) in N_Entity);
2598 return Nodes.Table (N + 1).Error_Posted;
2601 function Flag25 (N : Node_Id) return Boolean is
2603 pragma Assert (Nkind (N) in N_Entity);
2604 return Nodes.Table (N + 1).Flag4;
2607 function Flag26 (N : Node_Id) return Boolean is
2609 pragma Assert (Nkind (N) in N_Entity);
2610 return Nodes.Table (N + 1).Flag5;
2613 function Flag27 (N : Node_Id) return Boolean is
2615 pragma Assert (Nkind (N) in N_Entity);
2616 return Nodes.Table (N + 1).Flag6;
2619 function Flag28 (N : Node_Id) return Boolean is
2621 pragma Assert (Nkind (N) in N_Entity);
2622 return Nodes.Table (N + 1).Flag7;
2625 function Flag29 (N : Node_Id) return Boolean is
2627 pragma Assert (Nkind (N) in N_Entity);
2628 return Nodes.Table (N + 1).Flag8;
2631 function Flag30 (N : Node_Id) return Boolean is
2633 pragma Assert (Nkind (N) in N_Entity);
2634 return Nodes.Table (N + 1).Flag9;
2637 function Flag31 (N : Node_Id) return Boolean is
2639 pragma Assert (Nkind (N) in N_Entity);
2640 return Nodes.Table (N + 1).Flag10;
2643 function Flag32 (N : Node_Id) return Boolean is
2645 pragma Assert (Nkind (N) in N_Entity);
2646 return Nodes.Table (N + 1).Flag11;
2649 function Flag33 (N : Node_Id) return Boolean is
2651 pragma Assert (Nkind (N) in N_Entity);
2652 return Nodes.Table (N + 1).Flag12;
2655 function Flag34 (N : Node_Id) return Boolean is
2657 pragma Assert (Nkind (N) in N_Entity);
2658 return Nodes.Table (N + 1).Flag13;
2661 function Flag35 (N : Node_Id) return Boolean is
2663 pragma Assert (Nkind (N) in N_Entity);
2664 return Nodes.Table (N + 1).Flag14;
2667 function Flag36 (N : Node_Id) return Boolean is
2669 pragma Assert (Nkind (N) in N_Entity);
2670 return Nodes.Table (N + 1).Flag15;
2673 function Flag37 (N : Node_Id) return Boolean is
2675 pragma Assert (Nkind (N) in N_Entity);
2676 return Nodes.Table (N + 1).Flag16;
2679 function Flag38 (N : Node_Id) return Boolean is
2681 pragma Assert (Nkind (N) in N_Entity);
2682 return Nodes.Table (N + 1).Flag17;
2685 function Flag39 (N : Node_Id) return Boolean is
2687 pragma Assert (Nkind (N) in N_Entity);
2688 return Nodes.Table (N + 1).Flag18;
2691 function Flag40 (N : Node_Id) return Boolean is
2693 pragma Assert (Nkind (N) in N_Entity);
2694 return Nodes.Table (N + 2).In_List;
2697 function Flag41 (N : Node_Id) return Boolean is
2699 pragma Assert (Nkind (N) in N_Entity);
2700 return Nodes.Table (N + 2).Unused_1;
2703 function Flag42 (N : Node_Id) return Boolean is
2705 pragma Assert (Nkind (N) in N_Entity);
2706 return Nodes.Table (N + 2).Rewrite_Ins;
2709 function Flag43 (N : Node_Id) return Boolean is
2711 pragma Assert (Nkind (N) in N_Entity);
2712 return Nodes.Table (N + 2).Analyzed;
2715 function Flag44 (N : Node_Id) return Boolean is
2717 pragma Assert (Nkind (N) in N_Entity);
2718 return Nodes.Table (N + 2).Comes_From_Source;
2721 function Flag45 (N : Node_Id) return Boolean is
2723 pragma Assert (Nkind (N) in N_Entity);
2724 return Nodes.Table (N + 2).Error_Posted;
2727 function Flag46 (N : Node_Id) return Boolean is
2729 pragma Assert (Nkind (N) in N_Entity);
2730 return Nodes.Table (N + 2).Flag4;
2733 function Flag47 (N : Node_Id) return Boolean is
2735 pragma Assert (Nkind (N) in N_Entity);
2736 return Nodes.Table (N + 2).Flag5;
2739 function Flag48 (N : Node_Id) return Boolean is
2741 pragma Assert (Nkind (N) in N_Entity);
2742 return Nodes.Table (N + 2).Flag6;
2745 function Flag49 (N : Node_Id) return Boolean is
2747 pragma Assert (Nkind (N) in N_Entity);
2748 return Nodes.Table (N + 2).Flag7;
2751 function Flag50 (N : Node_Id) return Boolean is
2753 pragma Assert (Nkind (N) in N_Entity);
2754 return Nodes.Table (N + 2).Flag8;
2757 function Flag51 (N : Node_Id) return Boolean is
2759 pragma Assert (Nkind (N) in N_Entity);
2760 return Nodes.Table (N + 2).Flag9;
2763 function Flag52 (N : Node_Id) return Boolean is
2765 pragma Assert (Nkind (N) in N_Entity);
2766 return Nodes.Table (N + 2).Flag10;
2769 function Flag53 (N : Node_Id) return Boolean is
2771 pragma Assert (Nkind (N) in N_Entity);
2772 return Nodes.Table (N + 2).Flag11;
2775 function Flag54 (N : Node_Id) return Boolean is
2777 pragma Assert (Nkind (N) in N_Entity);
2778 return Nodes.Table (N + 2).Flag12;
2781 function Flag55 (N : Node_Id) return Boolean is
2783 pragma Assert (Nkind (N) in N_Entity);
2784 return Nodes.Table (N + 2).Flag13;
2787 function Flag56 (N : Node_Id) return Boolean is
2789 pragma Assert (Nkind (N) in N_Entity);
2790 return Nodes.Table (N + 2).Flag14;
2793 function Flag57 (N : Node_Id) return Boolean is
2795 pragma Assert (Nkind (N) in N_Entity);
2796 return Nodes.Table (N + 2).Flag15;
2799 function Flag58 (N : Node_Id) return Boolean is
2801 pragma Assert (Nkind (N) in N_Entity);
2802 return Nodes.Table (N + 2).Flag16;
2805 function Flag59 (N : Node_Id) return Boolean is
2807 pragma Assert (Nkind (N) in N_Entity);
2808 return Nodes.Table (N + 2).Flag17;
2811 function Flag60 (N : Node_Id) return Boolean is
2813 pragma Assert (Nkind (N) in N_Entity);
2814 return Nodes.Table (N + 2).Flag18;
2817 function Flag61 (N : Node_Id) return Boolean is
2819 pragma Assert (Nkind (N) in N_Entity);
2820 return Nodes.Table (N + 1).Pflag1;
2823 function Flag62 (N : Node_Id) return Boolean is
2825 pragma Assert (Nkind (N) in N_Entity);
2826 return Nodes.Table (N + 1).Pflag2;
2829 function Flag63 (N : Node_Id) return Boolean is
2831 pragma Assert (Nkind (N) in N_Entity);
2832 return Nodes.Table (N + 2).Pflag1;
2835 function Flag64 (N : Node_Id) return Boolean is
2837 pragma Assert (Nkind (N) in N_Entity);
2838 return Nodes.Table (N + 2).Pflag2;
2841 function Flag65 (N : Node_Id) return Boolean is
2843 pragma Assert (Nkind (N) in N_Entity);
2844 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
2847 function Flag66 (N : Node_Id) return Boolean is
2849 pragma Assert (Nkind (N) in N_Entity);
2850 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
2853 function Flag67 (N : Node_Id) return Boolean is
2855 pragma Assert (Nkind (N) in N_Entity);
2856 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
2859 function Flag68 (N : Node_Id) return Boolean is
2861 pragma Assert (Nkind (N) in N_Entity);
2862 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
2865 function Flag69 (N : Node_Id) return Boolean is
2867 pragma Assert (Nkind (N) in N_Entity);
2868 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
2871 function Flag70 (N : Node_Id) return Boolean is
2873 pragma Assert (Nkind (N) in N_Entity);
2874 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
2877 function Flag71 (N : Node_Id) return Boolean is
2879 pragma Assert (Nkind (N) in N_Entity);
2880 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
2883 function Flag72 (N : Node_Id) return Boolean is
2885 pragma Assert (Nkind (N) in N_Entity);
2886 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
2889 function Flag73 (N : Node_Id) return Boolean is
2891 pragma Assert (Nkind (N) in N_Entity);
2892 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
2895 function Flag74 (N : Node_Id) return Boolean is
2897 pragma Assert (Nkind (N) in N_Entity);
2898 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
2901 function Flag75 (N : Node_Id) return Boolean is
2903 pragma Assert (Nkind (N) in N_Entity);
2904 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
2907 function Flag76 (N : Node_Id) return Boolean is
2909 pragma Assert (Nkind (N) in N_Entity);
2910 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
2913 function Flag77 (N : Node_Id) return Boolean is
2915 pragma Assert (Nkind (N) in N_Entity);
2916 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
2919 function Flag78 (N : Node_Id) return Boolean is
2921 pragma Assert (Nkind (N) in N_Entity);
2922 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
2925 function Flag79 (N : Node_Id) return Boolean is
2927 pragma Assert (Nkind (N) in N_Entity);
2928 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
2931 function Flag80 (N : Node_Id) return Boolean is
2933 pragma Assert (Nkind (N) in N_Entity);
2934 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
2937 function Flag81 (N : Node_Id) return Boolean is
2939 pragma Assert (Nkind (N) in N_Entity);
2940 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
2943 function Flag82 (N : Node_Id) return Boolean is
2945 pragma Assert (Nkind (N) in N_Entity);
2946 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
2949 function Flag83 (N : Node_Id) return Boolean is
2951 pragma Assert (Nkind (N) in N_Entity);
2952 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
2955 function Flag84 (N : Node_Id) return Boolean is
2957 pragma Assert (Nkind (N) in N_Entity);
2958 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
2961 function Flag85 (N : Node_Id) return Boolean is
2963 pragma Assert (Nkind (N) in N_Entity);
2964 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
2967 function Flag86 (N : Node_Id) return Boolean is
2969 pragma Assert (Nkind (N) in N_Entity);
2970 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
2973 function Flag87 (N : Node_Id) return Boolean is
2975 pragma Assert (Nkind (N) in N_Entity);
2976 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
2979 function Flag88 (N : Node_Id) return Boolean is
2981 pragma Assert (Nkind (N) in N_Entity);
2982 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
2985 function Flag89 (N : Node_Id) return Boolean is
2987 pragma Assert (Nkind (N) in N_Entity);
2988 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
2991 function Flag90 (N : Node_Id) return Boolean is
2993 pragma Assert (Nkind (N) in N_Entity);
2994 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
2997 function Flag91 (N : Node_Id) return Boolean is
2999 pragma Assert (Nkind (N) in N_Entity);
3000 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
3003 function Flag92 (N : Node_Id) return Boolean is
3005 pragma Assert (Nkind (N) in N_Entity);
3006 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
3009 function Flag93 (N : Node_Id) return Boolean is
3011 pragma Assert (Nkind (N) in N_Entity);
3012 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
3015 function Flag94 (N : Node_Id) return Boolean is
3017 pragma Assert (Nkind (N) in N_Entity);
3018 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
3021 function Flag95 (N : Node_Id) return Boolean is
3023 pragma Assert (Nkind (N) in N_Entity);
3024 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
3027 function Flag96 (N : Node_Id) return Boolean is
3029 pragma Assert (Nkind (N) in N_Entity);
3030 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
3033 function Flag97 (N : Node_Id) return Boolean is
3035 pragma Assert (Nkind (N) in N_Entity);
3036 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
3039 function Flag98 (N : Node_Id) return Boolean is
3041 pragma Assert (Nkind (N) in N_Entity);
3042 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
3045 function Flag99 (N : Node_Id) return Boolean is
3047 pragma Assert (Nkind (N) in N_Entity);
3048 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
3051 function Flag100 (N : Node_Id) return Boolean is
3053 pragma Assert (Nkind (N) in N_Entity);
3054 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
3057 function Flag101 (N : Node_Id) return Boolean is
3059 pragma Assert (Nkind (N) in N_Entity);
3060 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
3063 function Flag102 (N : Node_Id) return Boolean is
3065 pragma Assert (Nkind (N) in N_Entity);
3066 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
3069 function Flag103 (N : Node_Id) return Boolean is
3071 pragma Assert (Nkind (N) in N_Entity);
3072 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
3075 function Flag104 (N : Node_Id) return Boolean is
3077 pragma Assert (Nkind (N) in N_Entity);
3078 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
3081 function Flag105 (N : Node_Id) return Boolean is
3083 pragma Assert (Nkind (N) in N_Entity);
3084 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
3087 function Flag106 (N : Node_Id) return Boolean is
3089 pragma Assert (Nkind (N) in N_Entity);
3090 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
3093 function Flag107 (N : Node_Id) return Boolean is
3095 pragma Assert (Nkind (N) in N_Entity);
3096 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
3099 function Flag108 (N : Node_Id) return Boolean is
3101 pragma Assert (Nkind (N) in N_Entity);
3102 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
3105 function Flag109 (N : Node_Id) return Boolean is
3107 pragma Assert (Nkind (N) in N_Entity);
3108 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
3111 function Flag110 (N : Node_Id) return Boolean is
3113 pragma Assert (Nkind (N) in N_Entity);
3114 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
3117 function Flag111 (N : Node_Id) return Boolean is
3119 pragma Assert (Nkind (N) in N_Entity);
3120 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
3123 function Flag112 (N : Node_Id) return Boolean is
3125 pragma Assert (Nkind (N) in N_Entity);
3126 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
3129 function Flag113 (N : Node_Id) return Boolean is
3131 pragma Assert (Nkind (N) in N_Entity);
3132 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
3135 function Flag114 (N : Node_Id) return Boolean is
3137 pragma Assert (Nkind (N) in N_Entity);
3138 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
3141 function Flag115 (N : Node_Id) return Boolean is
3143 pragma Assert (Nkind (N) in N_Entity);
3144 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
3147 function Flag116 (N : Node_Id) return Boolean is
3149 pragma Assert (Nkind (N) in N_Entity);
3150 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
3153 function Flag117 (N : Node_Id) return Boolean is
3155 pragma Assert (Nkind (N) in N_Entity);
3156 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
3159 function Flag118 (N : Node_Id) return Boolean is
3161 pragma Assert (Nkind (N) in N_Entity);
3162 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
3165 function Flag119 (N : Node_Id) return Boolean is
3167 pragma Assert (Nkind (N) in N_Entity);
3168 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
3171 function Flag120 (N : Node_Id) return Boolean is
3173 pragma Assert (Nkind (N) in N_Entity);
3174 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
3177 function Flag121 (N : Node_Id) return Boolean is
3179 pragma Assert (Nkind (N) in N_Entity);
3180 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
3183 function Flag122 (N : Node_Id) return Boolean is
3185 pragma Assert (Nkind (N) in N_Entity);
3186 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
3189 function Flag123 (N : Node_Id) return Boolean is
3191 pragma Assert (Nkind (N) in N_Entity);
3192 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
3195 function Flag124 (N : Node_Id) return Boolean is
3197 pragma Assert (Nkind (N) in N_Entity);
3198 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
3201 function Flag125 (N : Node_Id) return Boolean is
3203 pragma Assert (Nkind (N) in N_Entity);
3204 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
3207 function Flag126 (N : Node_Id) return Boolean is
3209 pragma Assert (Nkind (N) in N_Entity);
3210 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
3213 function Flag127 (N : Node_Id) return Boolean is
3215 pragma Assert (Nkind (N) in N_Entity);
3216 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
3219 function Flag128 (N : Node_Id) return Boolean is
3221 pragma Assert (Nkind (N) in N_Entity);
3222 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
3225 function Flag129 (N : Node_Id) return Boolean is
3227 pragma Assert (Nkind (N) in N_Entity);
3228 return Nodes.Table (N + 3).In_List;
3231 function Flag130 (N : Node_Id) return Boolean is
3233 pragma Assert (Nkind (N) in N_Entity);
3234 return Nodes.Table (N + 3).Unused_1;
3237 function Flag131 (N : Node_Id) return Boolean is
3239 pragma Assert (Nkind (N) in N_Entity);
3240 return Nodes.Table (N + 3).Rewrite_Ins;
3243 function Flag132 (N : Node_Id) return Boolean is
3245 pragma Assert (Nkind (N) in N_Entity);
3246 return Nodes.Table (N + 3).Analyzed;
3249 function Flag133 (N : Node_Id) return Boolean is
3251 pragma Assert (Nkind (N) in N_Entity);
3252 return Nodes.Table (N + 3).Comes_From_Source;
3255 function Flag134 (N : Node_Id) return Boolean is
3257 pragma Assert (Nkind (N) in N_Entity);
3258 return Nodes.Table (N + 3).Error_Posted;
3261 function Flag135 (N : Node_Id) return Boolean is
3263 pragma Assert (Nkind (N) in N_Entity);
3264 return Nodes.Table (N + 3).Flag4;
3267 function Flag136 (N : Node_Id) return Boolean is
3269 pragma Assert (Nkind (N) in N_Entity);
3270 return Nodes.Table (N + 3).Flag5;
3273 function Flag137 (N : Node_Id) return Boolean is
3275 pragma Assert (Nkind (N) in N_Entity);
3276 return Nodes.Table (N + 3).Flag6;
3279 function Flag138 (N : Node_Id) return Boolean is
3281 pragma Assert (Nkind (N) in N_Entity);
3282 return Nodes.Table (N + 3).Flag7;
3285 function Flag139 (N : Node_Id) return Boolean is
3287 pragma Assert (Nkind (N) in N_Entity);
3288 return Nodes.Table (N + 3).Flag8;
3291 function Flag140 (N : Node_Id) return Boolean is
3293 pragma Assert (Nkind (N) in N_Entity);
3294 return Nodes.Table (N + 3).Flag9;
3297 function Flag141 (N : Node_Id) return Boolean is
3299 pragma Assert (Nkind (N) in N_Entity);
3300 return Nodes.Table (N + 3).Flag10;
3303 function Flag142 (N : Node_Id) return Boolean is
3305 pragma Assert (Nkind (N) in N_Entity);
3306 return Nodes.Table (N + 3).Flag11;
3309 function Flag143 (N : Node_Id) return Boolean is
3311 pragma Assert (Nkind (N) in N_Entity);
3312 return Nodes.Table (N + 3).Flag12;
3315 function Flag144 (N : Node_Id) return Boolean is
3317 pragma Assert (Nkind (N) in N_Entity);
3318 return Nodes.Table (N + 3).Flag13;
3321 function Flag145 (N : Node_Id) return Boolean is
3323 pragma Assert (Nkind (N) in N_Entity);
3324 return Nodes.Table (N + 3).Flag14;
3327 function Flag146 (N : Node_Id) return Boolean is
3329 pragma Assert (Nkind (N) in N_Entity);
3330 return Nodes.Table (N + 3).Flag15;
3333 function Flag147 (N : Node_Id) return Boolean is
3335 pragma Assert (Nkind (N) in N_Entity);
3336 return Nodes.Table (N + 3).Flag16;
3339 function Flag148 (N : Node_Id) return Boolean is
3341 pragma Assert (Nkind (N) in N_Entity);
3342 return Nodes.Table (N + 3).Flag17;
3345 function Flag149 (N : Node_Id) return Boolean is
3347 pragma Assert (Nkind (N) in N_Entity);
3348 return Nodes.Table (N + 3).Flag18;
3351 function Flag150 (N : Node_Id) return Boolean is
3353 pragma Assert (Nkind (N) in N_Entity);
3354 return Nodes.Table (N + 3).Pflag1;
3357 function Flag151 (N : Node_Id) return Boolean is
3359 pragma Assert (Nkind (N) in N_Entity);
3360 return Nodes.Table (N + 3).Pflag2;
3363 function Flag152 (N : Node_Id) return Boolean is
3365 pragma Assert (Nkind (N) in N_Entity);
3366 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
3369 function Flag153 (N : Node_Id) return Boolean is
3371 pragma Assert (Nkind (N) in N_Entity);
3372 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
3375 function Flag154 (N : Node_Id) return Boolean is
3377 pragma Assert (Nkind (N) in N_Entity);
3378 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
3381 function Flag155 (N : Node_Id) return Boolean is
3383 pragma Assert (Nkind (N) in N_Entity);
3384 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
3387 function Flag156 (N : Node_Id) return Boolean is
3389 pragma Assert (Nkind (N) in N_Entity);
3390 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
3393 function Flag157 (N : Node_Id) return Boolean is
3395 pragma Assert (Nkind (N) in N_Entity);
3396 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
3399 function Flag158 (N : Node_Id) return Boolean is
3401 pragma Assert (Nkind (N) in N_Entity);
3402 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
3405 function Flag159 (N : Node_Id) return Boolean is
3407 pragma Assert (Nkind (N) in N_Entity);
3408 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
3411 function Flag160 (N : Node_Id) return Boolean is
3413 pragma Assert (Nkind (N) in N_Entity);
3414 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
3417 function Flag161 (N : Node_Id) return Boolean is
3419 pragma Assert (Nkind (N) in N_Entity);
3420 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
3423 function Flag162 (N : Node_Id) return Boolean is
3425 pragma Assert (Nkind (N) in N_Entity);
3426 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
3429 function Flag163 (N : Node_Id) return Boolean is
3431 pragma Assert (Nkind (N) in N_Entity);
3432 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
3435 function Flag164 (N : Node_Id) return Boolean is
3437 pragma Assert (Nkind (N) in N_Entity);
3438 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
3441 function Flag165 (N : Node_Id) return Boolean is
3443 pragma Assert (Nkind (N) in N_Entity);
3444 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
3447 function Flag166 (N : Node_Id) return Boolean is
3449 pragma Assert (Nkind (N) in N_Entity);
3450 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
3453 function Flag167 (N : Node_Id) return Boolean is
3455 pragma Assert (Nkind (N) in N_Entity);
3456 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
3459 function Flag168 (N : Node_Id) return Boolean is
3461 pragma Assert (Nkind (N) in N_Entity);
3462 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
3465 function Flag169 (N : Node_Id) return Boolean is
3467 pragma Assert (Nkind (N) in N_Entity);
3468 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
3471 function Flag170 (N : Node_Id) return Boolean is
3473 pragma Assert (Nkind (N) in N_Entity);
3474 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
3477 function Flag171 (N : Node_Id) return Boolean is
3479 pragma Assert (Nkind (N) in N_Entity);
3480 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
3483 function Flag172 (N : Node_Id) return Boolean is
3485 pragma Assert (Nkind (N) in N_Entity);
3486 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
3489 function Flag173 (N : Node_Id) return Boolean is
3491 pragma Assert (Nkind (N) in N_Entity);
3492 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
3495 function Flag174 (N : Node_Id) return Boolean is
3497 pragma Assert (Nkind (N) in N_Entity);
3498 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
3501 function Flag175 (N : Node_Id) return Boolean is
3503 pragma Assert (Nkind (N) in N_Entity);
3504 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
3507 function Flag176 (N : Node_Id) return Boolean is
3509 pragma Assert (Nkind (N) in N_Entity);
3510 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
3513 function Flag177 (N : Node_Id) return Boolean is
3515 pragma Assert (Nkind (N) in N_Entity);
3516 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
3519 function Flag178 (N : Node_Id) return Boolean is
3521 pragma Assert (Nkind (N) in N_Entity);
3522 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
3525 function Flag179 (N : Node_Id) return Boolean is
3527 pragma Assert (Nkind (N) in N_Entity);
3528 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
3531 function Flag180 (N : Node_Id) return Boolean is
3533 pragma Assert (Nkind (N) in N_Entity);
3534 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
3537 function Flag181 (N : Node_Id) return Boolean is
3539 pragma Assert (Nkind (N) in N_Entity);
3540 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
3543 function Flag182 (N : Node_Id) return Boolean is
3545 pragma Assert (Nkind (N) in N_Entity);
3546 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
3549 function Flag183 (N : Node_Id) return Boolean is
3551 pragma Assert (Nkind (N) in N_Entity);
3552 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
3555 function Flag184 (N : Node_Id) return Boolean is
3557 pragma Assert (Nkind (N) in N_Entity);
3558 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag184;
3561 function Flag185 (N : Node_Id) return Boolean is
3563 pragma Assert (Nkind (N) in N_Entity);
3564 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag185;
3567 function Flag186 (N : Node_Id) return Boolean is
3569 pragma Assert (Nkind (N) in N_Entity);
3570 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag186;
3573 function Flag187 (N : Node_Id) return Boolean is
3575 pragma Assert (Nkind (N) in N_Entity);
3576 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag187;
3579 function Flag188 (N : Node_Id) return Boolean is
3581 pragma Assert (Nkind (N) in N_Entity);
3582 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag188;
3585 function Flag189 (N : Node_Id) return Boolean is
3587 pragma Assert (Nkind (N) in N_Entity);
3588 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag189;
3591 function Flag190 (N : Node_Id) return Boolean is
3593 pragma Assert (Nkind (N) in N_Entity);
3594 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag190;
3597 function Flag191 (N : Node_Id) return Boolean is
3599 pragma Assert (Nkind (N) in N_Entity);
3600 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag191;
3603 function Flag192 (N : Node_Id) return Boolean is
3605 pragma Assert (Nkind (N) in N_Entity);
3606 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag192;
3609 function Flag193 (N : Node_Id) return Boolean is
3611 pragma Assert (Nkind (N) in N_Entity);
3612 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag193;
3615 function Flag194 (N : Node_Id) return Boolean is
3617 pragma Assert (Nkind (N) in N_Entity);
3618 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag194;
3621 function Flag195 (N : Node_Id) return Boolean is
3623 pragma Assert (Nkind (N) in N_Entity);
3624 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag195;
3627 function Flag196 (N : Node_Id) return Boolean is
3629 pragma Assert (Nkind (N) in N_Entity);
3630 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag196;
3633 function Flag197 (N : Node_Id) return Boolean is
3635 pragma Assert (Nkind (N) in N_Entity);
3636 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag197;
3639 function Flag198 (N : Node_Id) return Boolean is
3641 pragma Assert (Nkind (N) in N_Entity);
3642 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag198;
3645 function Flag199 (N : Node_Id) return Boolean is
3647 pragma Assert (Nkind (N) in N_Entity);
3648 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag199;
3651 function Flag200 (N : Node_Id) return Boolean is
3653 pragma Assert (Nkind (N) in N_Entity);
3654 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag200;
3657 function Flag201 (N : Node_Id) return Boolean is
3659 pragma Assert (Nkind (N) in N_Entity);
3660 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag201;
3663 function Flag202 (N : Node_Id) return Boolean is
3665 pragma Assert (Nkind (N) in N_Entity);
3666 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag202;
3669 function Flag203 (N : Node_Id) return Boolean is
3671 pragma Assert (Nkind (N) in N_Entity);
3672 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag203;
3675 function Flag204 (N : Node_Id) return Boolean is
3677 pragma Assert (Nkind (N) in N_Entity);
3678 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag204;
3681 function Flag205 (N : Node_Id) return Boolean is
3683 pragma Assert (Nkind (N) in N_Entity);
3684 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag205;
3687 function Flag206 (N : Node_Id) return Boolean is
3689 pragma Assert (Nkind (N) in N_Entity);
3690 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag206;
3693 function Flag207 (N : Node_Id) return Boolean is
3695 pragma Assert (Nkind (N) in N_Entity);
3696 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag207;
3699 function Flag208 (N : Node_Id) return Boolean is
3701 pragma Assert (Nkind (N) in N_Entity);
3702 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag208;
3705 function Flag209 (N : Node_Id) return Boolean is
3707 pragma Assert (Nkind (N) in N_Entity);
3708 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag209;
3711 function Flag210 (N : Node_Id) return Boolean is
3713 pragma Assert (Nkind (N) in N_Entity);
3714 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag210;
3717 function Flag211 (N : Node_Id) return Boolean is
3719 pragma Assert (Nkind (N) in N_Entity);
3720 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag211;
3723 function Flag212 (N : Node_Id) return Boolean is
3725 pragma Assert (Nkind (N) in N_Entity);
3726 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag212;
3729 function Flag213 (N : Node_Id) return Boolean is
3731 pragma Assert (Nkind (N) in N_Entity);
3732 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag213;
3735 function Flag214 (N : Node_Id) return Boolean is
3737 pragma Assert (Nkind (N) in N_Entity);
3738 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag214;
3741 function Flag215 (N : Node_Id) return Boolean is
3743 pragma Assert (Nkind (N) in N_Entity);
3744 return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag215;
3747 function Flag216 (N : Node_Id) return Boolean is
3749 pragma Assert (Nkind (N) in N_Entity);
3750 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag216;
3753 function Flag217 (N : Node_Id) return Boolean is
3755 pragma Assert (Nkind (N) in N_Entity);
3756 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag217;
3759 function Flag218 (N : Node_Id) return Boolean is
3761 pragma Assert (Nkind (N) in N_Entity);
3762 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag218;
3765 function Flag219 (N : Node_Id) return Boolean is
3767 pragma Assert (Nkind (N) in N_Entity);
3768 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag219;
3771 function Flag220 (N : Node_Id) return Boolean is
3773 pragma Assert (Nkind (N) in N_Entity);
3774 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag220;
3777 function Flag221 (N : Node_Id) return Boolean is
3779 pragma Assert (Nkind (N) in N_Entity);
3780 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag221;
3783 function Flag222 (N : Node_Id) return Boolean is
3785 pragma Assert (Nkind (N) in N_Entity);
3786 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag222;
3789 function Flag223 (N : Node_Id) return Boolean is
3791 pragma Assert (Nkind (N) in N_Entity);
3792 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag223;
3795 function Flag224 (N : Node_Id) return Boolean is
3797 pragma Assert (Nkind (N) in N_Entity);
3798 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag224;
3801 function Flag225 (N : Node_Id) return Boolean is
3803 pragma Assert (Nkind (N) in N_Entity);
3804 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag225;
3807 function Flag226 (N : Node_Id) return Boolean is
3809 pragma Assert (Nkind (N) in N_Entity);
3810 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag226;
3813 function Flag227 (N : Node_Id) return Boolean is
3815 pragma Assert (Nkind (N) in N_Entity);
3816 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag227;
3819 function Flag228 (N : Node_Id) return Boolean is
3821 pragma Assert (Nkind (N) in N_Entity);
3822 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag228;
3825 function Flag229 (N : Node_Id) return Boolean is
3827 pragma Assert (Nkind (N) in N_Entity);
3828 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag229;
3831 function Flag230 (N : Node_Id) return Boolean is
3833 pragma Assert (Nkind (N) in N_Entity);
3834 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag230;
3837 function Flag231 (N : Node_Id) return Boolean is
3839 pragma Assert (Nkind (N) in N_Entity);
3840 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag231;
3843 function Flag232 (N : Node_Id) return Boolean is
3845 pragma Assert (Nkind (N) in N_Entity);
3846 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag232;
3849 function Flag233 (N : Node_Id) return Boolean is
3851 pragma Assert (Nkind (N) in N_Entity);
3852 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag233;
3855 function Flag234 (N : Node_Id) return Boolean is
3857 pragma Assert (Nkind (N) in N_Entity);
3858 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag234;
3861 function Flag235 (N : Node_Id) return Boolean is
3863 pragma Assert (Nkind (N) in N_Entity);
3864 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag235;
3867 function Flag236 (N : Node_Id) return Boolean is
3869 pragma Assert (Nkind (N) in N_Entity);
3870 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag236;
3873 function Flag237 (N : Node_Id) return Boolean is
3875 pragma Assert (Nkind (N) in N_Entity);
3876 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag237;
3879 function Flag238 (N : Node_Id) return Boolean is
3881 pragma Assert (Nkind (N) in N_Entity);
3882 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag238;
3885 function Flag239 (N : Node_Id) return Boolean is
3887 pragma Assert (Nkind (N) in N_Entity);
3888 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag239;
3891 function Flag240 (N : Node_Id) return Boolean is
3893 pragma Assert (Nkind (N) in N_Entity);
3894 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag240;
3897 function Flag241 (N : Node_Id) return Boolean is
3899 pragma Assert (Nkind (N) in N_Entity);
3900 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag241;
3903 function Flag242 (N : Node_Id) return Boolean is
3905 pragma Assert (Nkind (N) in N_Entity);
3906 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag242;
3909 function Flag243 (N : Node_Id) return Boolean is
3911 pragma Assert (Nkind (N) in N_Entity);
3912 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag243;
3915 function Flag244 (N : Node_Id) return Boolean is
3917 pragma Assert (Nkind (N) in N_Entity);
3918 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag244;
3921 function Flag245 (N : Node_Id) return Boolean is
3923 pragma Assert (Nkind (N) in N_Entity);
3924 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag245;
3927 function Flag246 (N : Node_Id) return Boolean is
3929 pragma Assert (Nkind (N) in N_Entity);
3930 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag246;
3933 function Flag247 (N : Node_Id) return Boolean is
3935 pragma Assert (Nkind (N) in N_Entity);
3936 return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag247;
3939 procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
3941 pragma Assert (N <= Nodes.Last);
3942 Nodes.Table (N).Nkind := Val;
3945 procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
3947 pragma Assert (N <= Nodes.Last);
3948 Nodes.Table (N).Field1 := Val;
3951 procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
3953 pragma Assert (N <= Nodes.Last);
3954 Nodes.Table (N).Field2 := Val;
3957 procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
3959 pragma Assert (N <= Nodes.Last);
3960 Nodes.Table (N).Field3 := Val;
3963 procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
3965 pragma Assert (N <= Nodes.Last);
3966 Nodes.Table (N).Field4 := Val;
3969 procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
3971 pragma Assert (N <= Nodes.Last);
3972 Nodes.Table (N).Field5 := Val;
3975 procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
3977 pragma Assert (Nkind (N) in N_Entity);
3978 Nodes.Table (N + 1).Field6 := Val;
3981 procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
3983 pragma Assert (Nkind (N) in N_Entity);
3984 Nodes.Table (N + 1).Field7 := Val;
3987 procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
3989 pragma Assert (Nkind (N) in N_Entity);
3990 Nodes.Table (N + 1).Field8 := Val;
3993 procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
3995 pragma Assert (Nkind (N) in N_Entity);
3996 Nodes.Table (N + 1).Field9 := Val;
3999 procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
4001 pragma Assert (Nkind (N) in N_Entity);
4002 Nodes.Table (N + 1).Field10 := Val;
4005 procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
4007 pragma Assert (Nkind (N) in N_Entity);
4008 Nodes.Table (N + 1).Field11 := Val;
4011 procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
4013 pragma Assert (Nkind (N) in N_Entity);
4014 Nodes.Table (N + 1).Field12 := Val;
4017 procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
4019 pragma Assert (Nkind (N) in N_Entity);
4020 Nodes.Table (N + 2).Field6 := Val;
4023 procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
4025 pragma Assert (Nkind (N) in N_Entity);
4026 Nodes.Table (N + 2).Field7 := Val;
4029 procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
4031 pragma Assert (Nkind (N) in N_Entity);
4032 Nodes.Table (N + 2).Field8 := Val;
4035 procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
4037 pragma Assert (Nkind (N) in N_Entity);
4038 Nodes.Table (N + 2).Field9 := Val;
4041 procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
4043 pragma Assert (Nkind (N) in N_Entity);
4044 Nodes.Table (N + 2).Field10 := Val;
4047 procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
4049 pragma Assert (Nkind (N) in N_Entity);
4050 Nodes.Table (N + 2).Field11 := Val;
4053 procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
4055 pragma Assert (Nkind (N) in N_Entity);
4056 Nodes.Table (N + 3).Field6 := Val;
4059 procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
4061 pragma Assert (Nkind (N) in N_Entity);
4062 Nodes.Table (N + 3).Field7 := Val;
4065 procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
4067 pragma Assert (Nkind (N) in N_Entity);
4068 Nodes.Table (N + 3).Field8 := Val;
4071 procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
4073 pragma Assert (Nkind (N) in N_Entity);
4074 Nodes.Table (N + 3).Field9 := Val;
4077 procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
4079 pragma Assert (Nkind (N) in N_Entity);
4080 Nodes.Table (N + 3).Field10 := Val;
4083 procedure Set_Field24 (N : Node_Id; Val : Union_Id) is
4085 pragma Assert (Nkind (N) in N_Entity);
4086 Nodes.Table (N + 4).Field6 := Val;
4089 procedure Set_Field25 (N : Node_Id; Val : Union_Id) is
4091 pragma Assert (Nkind (N) in N_Entity);
4092 Nodes.Table (N + 4).Field7 := Val;
4095 procedure Set_Field26 (N : Node_Id; Val : Union_Id) is
4097 pragma Assert (Nkind (N) in N_Entity);
4098 Nodes.Table (N + 4).Field8 := Val;
4101 procedure Set_Field27 (N : Node_Id; Val : Union_Id) is
4103 pragma Assert (Nkind (N) in N_Entity);
4104 Nodes.Table (N + 4).Field9 := Val;
4107 procedure Set_Field28 (N : Node_Id; Val : Union_Id) is
4109 pragma Assert (Nkind (N) in N_Entity);
4110 Nodes.Table (N + 4).Field10 := Val;
4113 procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
4115 pragma Assert (N <= Nodes.Last);
4116 Nodes.Table (N).Field1 := Union_Id (Val);
4119 procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
4121 pragma Assert (N <= Nodes.Last);
4122 Nodes.Table (N).Field2 := Union_Id (Val);
4125 procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
4127 pragma Assert (N <= Nodes.Last);
4128 Nodes.Table (N).Field3 := Union_Id (Val);
4131 procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
4133 pragma Assert (N <= Nodes.Last);
4134 Nodes.Table (N).Field4 := Union_Id (Val);
4137 procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
4139 pragma Assert (N <= Nodes.Last);
4140 Nodes.Table (N).Field5 := Union_Id (Val);
4143 procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
4145 pragma Assert (Nkind (N) in N_Entity);
4146 Nodes.Table (N + 1).Field6 := Union_Id (Val);
4149 procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
4151 pragma Assert (Nkind (N) in N_Entity);
4152 Nodes.Table (N + 1).Field7 := Union_Id (Val);
4155 procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
4157 pragma Assert (Nkind (N) in N_Entity);
4158 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4161 procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
4163 pragma Assert (Nkind (N) in N_Entity);
4164 Nodes.Table (N + 1).Field9 := Union_Id (Val);
4167 procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
4169 pragma Assert (Nkind (N) in N_Entity);
4170 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4173 procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
4175 pragma Assert (Nkind (N) in N_Entity);
4176 Nodes.Table (N + 1).Field11 := Union_Id (Val);
4179 procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
4181 pragma Assert (Nkind (N) in N_Entity);
4182 Nodes.Table (N + 1).Field12 := Union_Id (Val);
4185 procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
4187 pragma Assert (Nkind (N) in N_Entity);
4188 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4191 procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
4193 pragma Assert (Nkind (N) in N_Entity);
4194 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4197 procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
4199 pragma Assert (Nkind (N) in N_Entity);
4200 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4203 procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
4205 pragma Assert (Nkind (N) in N_Entity);
4206 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4209 procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
4211 pragma Assert (Nkind (N) in N_Entity);
4212 Nodes.Table (N + 2).Field10 := Union_Id (Val);
4215 procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
4217 pragma Assert (Nkind (N) in N_Entity);
4218 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4221 procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
4223 pragma Assert (Nkind (N) in N_Entity);
4224 Nodes.Table (N + 3).Field6 := Union_Id (Val);
4227 procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
4229 pragma Assert (Nkind (N) in N_Entity);
4230 Nodes.Table (N + 3).Field7 := Union_Id (Val);
4233 procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
4235 pragma Assert (Nkind (N) in N_Entity);
4236 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4239 procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
4241 pragma Assert (Nkind (N) in N_Entity);
4242 Nodes.Table (N + 3).Field9 := Union_Id (Val);
4245 procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
4247 pragma Assert (Nkind (N) in N_Entity);
4248 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4251 procedure Set_Node24 (N : Node_Id; Val : Node_Id) is
4253 pragma Assert (Nkind (N) in N_Entity);
4254 Nodes.Table (N + 4).Field6 := Union_Id (Val);
4257 procedure Set_Node25 (N : Node_Id; Val : Node_Id) is
4259 pragma Assert (Nkind (N) in N_Entity);
4260 Nodes.Table (N + 4).Field7 := Union_Id (Val);
4263 procedure Set_Node26 (N : Node_Id; Val : Node_Id) is
4265 pragma Assert (Nkind (N) in N_Entity);
4266 Nodes.Table (N + 4).Field8 := Union_Id (Val);
4269 procedure Set_Node27 (N : Node_Id; Val : Node_Id) is
4271 pragma Assert (Nkind (N) in N_Entity);
4272 Nodes.Table (N + 4).Field9 := Union_Id (Val);
4275 procedure Set_Node28 (N : Node_Id; Val : Node_Id) is
4277 pragma Assert (Nkind (N) in N_Entity);
4278 Nodes.Table (N + 4).Field10 := Union_Id (Val);
4281 procedure Set_List1 (N : Node_Id; Val : List_Id) is
4283 pragma Assert (N <= Nodes.Last);
4284 Nodes.Table (N).Field1 := Union_Id (Val);
4287 procedure Set_List2 (N : Node_Id; Val : List_Id) is
4289 pragma Assert (N <= Nodes.Last);
4290 Nodes.Table (N).Field2 := Union_Id (Val);
4293 procedure Set_List3 (N : Node_Id; Val : List_Id) is
4295 pragma Assert (N <= Nodes.Last);
4296 Nodes.Table (N).Field3 := Union_Id (Val);
4299 procedure Set_List4 (N : Node_Id; Val : List_Id) is
4301 pragma Assert (N <= Nodes.Last);
4302 Nodes.Table (N).Field4 := Union_Id (Val);
4305 procedure Set_List5 (N : Node_Id; Val : List_Id) is
4307 pragma Assert (N <= Nodes.Last);
4308 Nodes.Table (N).Field5 := Union_Id (Val);
4311 procedure Set_List10 (N : Node_Id; Val : List_Id) is
4313 pragma Assert (Nkind (N) in N_Entity);
4314 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4317 procedure Set_List14 (N : Node_Id; Val : List_Id) is
4319 pragma Assert (Nkind (N) in N_Entity);
4320 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4323 procedure Set_Elist1 (N : Node_Id; Val : Elist_Id) is
4325 Nodes.Table (N).Field1 := Union_Id (Val);
4328 procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
4330 Nodes.Table (N).Field2 := Union_Id (Val);
4333 procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
4335 Nodes.Table (N).Field3 := Union_Id (Val);
4338 procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
4340 Nodes.Table (N).Field4 := Union_Id (Val);
4343 procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
4345 pragma Assert (Nkind (N) in N_Entity);
4346 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4349 procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
4351 pragma Assert (Nkind (N) in N_Entity);
4352 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4355 procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
4357 pragma Assert (Nkind (N) in N_Entity);
4358 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4361 procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
4363 pragma Assert (Nkind (N) in N_Entity);
4364 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4367 procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
4369 pragma Assert (Nkind (N) in N_Entity);
4370 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4373 procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
4375 pragma Assert (Nkind (N) in N_Entity);
4376 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4379 procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
4381 pragma Assert (Nkind (N) in N_Entity);
4382 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4385 procedure Set_Elist25 (N : Node_Id; Val : Elist_Id) is
4387 pragma Assert (Nkind (N) in N_Entity);
4388 Nodes.Table (N + 4).Field7 := Union_Id (Val);
4391 procedure Set_Elist26 (N : Node_Id; Val : Elist_Id) is
4393 pragma Assert (Nkind (N) in N_Entity);
4394 Nodes.Table (N + 4).Field8 := Union_Id (Val);
4397 procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
4399 pragma Assert (N <= Nodes.Last);
4400 Nodes.Table (N).Field1 := Union_Id (Val);
4403 procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
4405 pragma Assert (N <= Nodes.Last);
4406 Nodes.Table (N).Field2 := Union_Id (Val);
4409 procedure Set_Str3 (N : Node_Id; Val : String_Id) is
4411 pragma Assert (N <= Nodes.Last);
4412 Nodes.Table (N).Field3 := Union_Id (Val);
4415 procedure Set_Uint2 (N : Node_Id; Val : Uint) is
4417 pragma Assert (N <= Nodes.Last);
4418 Nodes.Table (N).Field2 := To_Union (Val);
4421 procedure Set_Uint3 (N : Node_Id; Val : Uint) is
4423 pragma Assert (N <= Nodes.Last);
4424 Nodes.Table (N).Field3 := To_Union (Val);
4427 procedure Set_Uint4 (N : Node_Id; Val : Uint) is
4429 pragma Assert (N <= Nodes.Last);
4430 Nodes.Table (N).Field4 := To_Union (Val);
4433 procedure Set_Uint5 (N : Node_Id; Val : Uint) is
4435 pragma Assert (N <= Nodes.Last);
4436 Nodes.Table (N).Field5 := To_Union (Val);
4439 procedure Set_Uint8 (N : Node_Id; Val : Uint) is
4441 pragma Assert (Nkind (N) in N_Entity);
4442 Nodes.Table (N + 1).Field8 := To_Union (Val);
4445 procedure Set_Uint9 (N : Node_Id; Val : Uint) is
4447 pragma Assert (Nkind (N) in N_Entity);
4448 Nodes.Table (N + 1).Field9 := To_Union (Val);
4451 procedure Set_Uint10 (N : Node_Id; Val : Uint) is
4453 pragma Assert (Nkind (N) in N_Entity);
4454 Nodes.Table (N + 1).Field10 := To_Union (Val);
4457 procedure Set_Uint11 (N : Node_Id; Val : Uint) is
4459 pragma Assert (Nkind (N) in N_Entity);
4460 Nodes.Table (N + 1).Field11 := To_Union (Val);
4463 procedure Set_Uint12 (N : Node_Id; Val : Uint) is
4465 pragma Assert (Nkind (N) in N_Entity);
4466 Nodes.Table (N + 1).Field12 := To_Union (Val);
4469 procedure Set_Uint13 (N : Node_Id; Val : Uint) is
4471 pragma Assert (Nkind (N) in N_Entity);
4472 Nodes.Table (N + 2).Field6 := To_Union (Val);
4475 procedure Set_Uint14 (N : Node_Id; Val : Uint) is
4477 pragma Assert (Nkind (N) in N_Entity);
4478 Nodes.Table (N + 2).Field7 := To_Union (Val);
4481 procedure Set_Uint15 (N : Node_Id; Val : Uint) is
4483 pragma Assert (Nkind (N) in N_Entity);
4484 Nodes.Table (N + 2).Field8 := To_Union (Val);
4487 procedure Set_Uint16 (N : Node_Id; Val : Uint) is
4489 pragma Assert (Nkind (N) in N_Entity);
4490 Nodes.Table (N + 2).Field9 := To_Union (Val);
4493 procedure Set_Uint17 (N : Node_Id; Val : Uint) is
4495 pragma Assert (Nkind (N) in N_Entity);
4496 Nodes.Table (N + 2).Field10 := To_Union (Val);
4499 procedure Set_Uint22 (N : Node_Id; Val : Uint) is
4501 pragma Assert (Nkind (N) in N_Entity);
4502 Nodes.Table (N + 3).Field9 := To_Union (Val);
4505 procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
4507 pragma Assert (N <= Nodes.Last);
4508 Nodes.Table (N).Field3 := To_Union (Val);
4511 procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
4513 pragma Assert (Nkind (N) in N_Entity);
4514 Nodes.Table (N + 2).Field11 := To_Union (Val);
4517 procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
4519 pragma Assert (Nkind (N) in N_Entity);
4520 Nodes.Table (N + 3).Field8 := To_Union (Val);
4523 procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
4525 pragma Assert (N <= Nodes.Last);
4526 Nodes.Table (N).Flag4 := Val;
4529 procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
4531 pragma Assert (N <= Nodes.Last);
4532 Nodes.Table (N).Flag5 := Val;
4535 procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
4537 pragma Assert (N <= Nodes.Last);
4538 Nodes.Table (N).Flag6 := Val;
4541 procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
4543 pragma Assert (N <= Nodes.Last);
4544 Nodes.Table (N).Flag7 := Val;
4547 procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
4549 pragma Assert (N <= Nodes.Last);
4550 Nodes.Table (N).Flag8 := Val;
4553 procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
4555 pragma Assert (N <= Nodes.Last);
4556 Nodes.Table (N).Flag9 := Val;
4559 procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
4561 pragma Assert (N <= Nodes.Last);
4562 Nodes.Table (N).Flag10 := Val;
4565 procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
4567 pragma Assert (N <= Nodes.Last);
4568 Nodes.Table (N).Flag11 := Val;
4571 procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
4573 pragma Assert (N <= Nodes.Last);
4574 Nodes.Table (N).Flag12 := Val;
4577 procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
4579 pragma Assert (N <= Nodes.Last);
4580 Nodes.Table (N).Flag13 := Val;
4583 procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
4585 pragma Assert (N <= Nodes.Last);
4586 Nodes.Table (N).Flag14 := Val;
4589 procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
4591 pragma Assert (N <= Nodes.Last);
4592 Nodes.Table (N).Flag15 := Val;
4595 procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
4597 pragma Assert (N <= Nodes.Last);
4598 Nodes.Table (N).Flag16 := Val;
4601 procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
4603 pragma Assert (N <= Nodes.Last);
4604 Nodes.Table (N).Flag17 := Val;
4607 procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
4609 pragma Assert (N <= Nodes.Last);
4610 Nodes.Table (N).Flag18 := Val;
4613 procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
4615 pragma Assert (Nkind (N) in N_Entity);
4616 Nodes.Table (N + 1).In_List := Val;
4619 procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
4621 pragma Assert (Nkind (N) in N_Entity);
4622 Nodes.Table (N + 1).Unused_1 := Val;
4625 procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
4627 pragma Assert (Nkind (N) in N_Entity);
4628 Nodes.Table (N + 1).Rewrite_Ins := Val;
4631 procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
4633 pragma Assert (Nkind (N) in N_Entity);
4634 Nodes.Table (N + 1).Analyzed := Val;
4637 procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
4639 pragma Assert (Nkind (N) in N_Entity);
4640 Nodes.Table (N + 1).Comes_From_Source := Val;
4643 procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
4645 pragma Assert (Nkind (N) in N_Entity);
4646 Nodes.Table (N + 1).Error_Posted := Val;
4649 procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
4651 pragma Assert (Nkind (N) in N_Entity);
4652 Nodes.Table (N + 1).Flag4 := Val;
4655 procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
4657 pragma Assert (Nkind (N) in N_Entity);
4658 Nodes.Table (N + 1).Flag5 := Val;
4661 procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
4663 pragma Assert (Nkind (N) in N_Entity);
4664 Nodes.Table (N + 1).Flag6 := Val;
4667 procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
4669 pragma Assert (Nkind (N) in N_Entity);
4670 Nodes.Table (N + 1).Flag7 := Val;
4673 procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
4675 pragma Assert (Nkind (N) in N_Entity);
4676 Nodes.Table (N + 1).Flag8 := Val;
4679 procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
4681 pragma Assert (Nkind (N) in N_Entity);
4682 Nodes.Table (N + 1).Flag9 := Val;
4685 procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
4687 pragma Assert (Nkind (N) in N_Entity);
4688 Nodes.Table (N + 1).Flag10 := Val;
4691 procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
4693 pragma Assert (Nkind (N) in N_Entity);
4694 Nodes.Table (N + 1).Flag11 := Val;
4697 procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
4699 pragma Assert (Nkind (N) in N_Entity);
4700 Nodes.Table (N + 1).Flag12 := Val;
4703 procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
4705 pragma Assert (Nkind (N) in N_Entity);
4706 Nodes.Table (N + 1).Flag13 := Val;
4709 procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
4711 pragma Assert (Nkind (N) in N_Entity);
4712 Nodes.Table (N + 1).Flag14 := Val;
4715 procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
4717 pragma Assert (Nkind (N) in N_Entity);
4718 Nodes.Table (N + 1).Flag15 := Val;
4721 procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
4723 pragma Assert (Nkind (N) in N_Entity);
4724 Nodes.Table (N + 1).Flag16 := Val;
4727 procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
4729 pragma Assert (Nkind (N) in N_Entity);
4730 Nodes.Table (N + 1).Flag17 := Val;
4733 procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
4735 pragma Assert (Nkind (N) in N_Entity);
4736 Nodes.Table (N + 1).Flag18 := Val;
4739 procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
4741 pragma Assert (Nkind (N) in N_Entity);
4742 Nodes.Table (N + 2).In_List := Val;
4745 procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
4747 pragma Assert (Nkind (N) in N_Entity);
4748 Nodes.Table (N + 2).Unused_1 := Val;
4751 procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
4753 pragma Assert (Nkind (N) in N_Entity);
4754 Nodes.Table (N + 2).Rewrite_Ins := Val;
4757 procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
4759 pragma Assert (Nkind (N) in N_Entity);
4760 Nodes.Table (N + 2).Analyzed := Val;
4763 procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
4765 pragma Assert (Nkind (N) in N_Entity);
4766 Nodes.Table (N + 2).Comes_From_Source := Val;
4769 procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
4771 pragma Assert (Nkind (N) in N_Entity);
4772 Nodes.Table (N + 2).Error_Posted := Val;
4775 procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
4777 pragma Assert (Nkind (N) in N_Entity);
4778 Nodes.Table (N + 2).Flag4 := Val;
4781 procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
4783 pragma Assert (Nkind (N) in N_Entity);
4784 Nodes.Table (N + 2).Flag5 := Val;
4787 procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
4789 pragma Assert (Nkind (N) in N_Entity);
4790 Nodes.Table (N + 2).Flag6 := Val;
4793 procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
4795 pragma Assert (Nkind (N) in N_Entity);
4796 Nodes.Table (N + 2).Flag7 := Val;
4799 procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
4801 pragma Assert (Nkind (N) in N_Entity);
4802 Nodes.Table (N + 2).Flag8 := Val;
4805 procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
4807 pragma Assert (Nkind (N) in N_Entity);
4808 Nodes.Table (N + 2).Flag9 := Val;
4811 procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
4813 pragma Assert (Nkind (N) in N_Entity);
4814 Nodes.Table (N + 2).Flag10 := Val;
4817 procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
4819 pragma Assert (Nkind (N) in N_Entity);
4820 Nodes.Table (N + 2).Flag11 := Val;
4823 procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
4825 pragma Assert (Nkind (N) in N_Entity);
4826 Nodes.Table (N + 2).Flag12 := Val;
4829 procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
4831 pragma Assert (Nkind (N) in N_Entity);
4832 Nodes.Table (N + 2).Flag13 := Val;
4835 procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
4837 pragma Assert (Nkind (N) in N_Entity);
4838 Nodes.Table (N + 2).Flag14 := Val;
4841 procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
4843 pragma Assert (Nkind (N) in N_Entity);
4844 Nodes.Table (N + 2).Flag15 := Val;
4847 procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
4849 pragma Assert (Nkind (N) in N_Entity);
4850 Nodes.Table (N + 2).Flag16 := Val;
4853 procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
4855 pragma Assert (Nkind (N) in N_Entity);
4856 Nodes.Table (N + 2).Flag17 := Val;
4859 procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
4861 pragma Assert (Nkind (N) in N_Entity);
4862 Nodes.Table (N + 2).Flag18 := Val;
4865 procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
4867 pragma Assert (Nkind (N) in N_Entity);
4868 Nodes.Table (N + 1).Pflag1 := Val;
4871 procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
4873 pragma Assert (Nkind (N) in N_Entity);
4874 Nodes.Table (N + 1).Pflag2 := Val;
4877 procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
4879 pragma Assert (Nkind (N) in N_Entity);
4880 Nodes.Table (N + 2).Pflag1 := Val;
4883 procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
4885 pragma Assert (Nkind (N) in N_Entity);
4886 Nodes.Table (N + 2).Pflag2 := Val;
4889 procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
4891 pragma Assert (Nkind (N) in N_Entity);
4894 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
4897 procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
4899 pragma Assert (Nkind (N) in N_Entity);
4902 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
4905 procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
4907 pragma Assert (Nkind (N) in N_Entity);
4910 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
4913 procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
4915 pragma Assert (Nkind (N) in N_Entity);
4918 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
4921 procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
4923 pragma Assert (Nkind (N) in N_Entity);
4926 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
4929 procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
4931 pragma Assert (Nkind (N) in N_Entity);
4934 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
4937 procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
4939 pragma Assert (Nkind (N) in N_Entity);
4942 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
4945 procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
4947 pragma Assert (Nkind (N) in N_Entity);
4950 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
4953 procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
4955 pragma Assert (Nkind (N) in N_Entity);
4958 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
4961 procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
4963 pragma Assert (Nkind (N) in N_Entity);
4966 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
4969 procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
4971 pragma Assert (Nkind (N) in N_Entity);
4974 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
4977 procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
4979 pragma Assert (Nkind (N) in N_Entity);
4982 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
4985 procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
4987 pragma Assert (Nkind (N) in N_Entity);
4990 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
4993 procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
4995 pragma Assert (Nkind (N) in N_Entity);
4998 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
5001 procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
5003 pragma Assert (Nkind (N) in N_Entity);
5006 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
5009 procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
5011 pragma Assert (Nkind (N) in N_Entity);
5014 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
5017 procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
5019 pragma Assert (Nkind (N) in N_Entity);
5022 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
5025 procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
5027 pragma Assert (Nkind (N) in N_Entity);
5030 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
5033 procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
5035 pragma Assert (Nkind (N) in N_Entity);
5038 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
5041 procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
5043 pragma Assert (Nkind (N) in N_Entity);
5046 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
5049 procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
5051 pragma Assert (Nkind (N) in N_Entity);
5054 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
5057 procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
5059 pragma Assert (Nkind (N) in N_Entity);
5062 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
5065 procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
5067 pragma Assert (Nkind (N) in N_Entity);
5070 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
5073 procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
5075 pragma Assert (Nkind (N) in N_Entity);
5078 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
5081 procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
5083 pragma Assert (Nkind (N) in N_Entity);
5086 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
5089 procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
5091 pragma Assert (Nkind (N) in N_Entity);
5094 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
5097 procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
5099 pragma Assert (Nkind (N) in N_Entity);
5102 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
5105 procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
5107 pragma Assert (Nkind (N) in N_Entity);
5110 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
5113 procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
5115 pragma Assert (Nkind (N) in N_Entity);
5118 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
5121 procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
5123 pragma Assert (Nkind (N) in N_Entity);
5126 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
5129 procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
5131 pragma Assert (Nkind (N) in N_Entity);
5134 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
5137 procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
5139 pragma Assert (Nkind (N) in N_Entity);
5142 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
5145 procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
5147 pragma Assert (Nkind (N) in N_Entity);
5150 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
5153 procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
5155 pragma Assert (Nkind (N) in N_Entity);
5158 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
5161 procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
5163 pragma Assert (Nkind (N) in N_Entity);
5166 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
5169 procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
5171 pragma Assert (Nkind (N) in N_Entity);
5174 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
5177 procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
5179 pragma Assert (Nkind (N) in N_Entity);
5182 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
5185 procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
5187 pragma Assert (Nkind (N) in N_Entity);
5190 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
5193 procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
5195 pragma Assert (Nkind (N) in N_Entity);
5198 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
5201 procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
5203 pragma Assert (Nkind (N) in N_Entity);
5206 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
5209 procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
5211 pragma Assert (Nkind (N) in N_Entity);
5214 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
5217 procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
5219 pragma Assert (Nkind (N) in N_Entity);
5222 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
5225 procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
5227 pragma Assert (Nkind (N) in N_Entity);
5230 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
5233 procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
5235 pragma Assert (Nkind (N) in N_Entity);
5238 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
5241 procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
5243 pragma Assert (Nkind (N) in N_Entity);
5246 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
5249 procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
5251 pragma Assert (Nkind (N) in N_Entity);
5254 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
5257 procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
5259 pragma Assert (Nkind (N) in N_Entity);
5262 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
5265 procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
5267 pragma Assert (Nkind (N) in N_Entity);
5270 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
5273 procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
5275 pragma Assert (Nkind (N) in N_Entity);
5278 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
5281 procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
5283 pragma Assert (Nkind (N) in N_Entity);
5286 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
5289 procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
5291 pragma Assert (Nkind (N) in N_Entity);
5294 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
5297 procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
5299 pragma Assert (Nkind (N) in N_Entity);
5302 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
5305 procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
5307 pragma Assert (Nkind (N) in N_Entity);
5310 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
5313 procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
5315 pragma Assert (Nkind (N) in N_Entity);
5318 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
5321 procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
5323 pragma Assert (Nkind (N) in N_Entity);
5326 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
5329 procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
5331 pragma Assert (Nkind (N) in N_Entity);
5334 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
5337 procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
5339 pragma Assert (Nkind (N) in N_Entity);
5342 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
5345 procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
5347 pragma Assert (Nkind (N) in N_Entity);
5350 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
5353 procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
5355 pragma Assert (Nkind (N) in N_Entity);
5358 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
5361 procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
5363 pragma Assert (Nkind (N) in N_Entity);
5366 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
5369 procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
5371 pragma Assert (Nkind (N) in N_Entity);
5374 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
5377 procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
5379 pragma Assert (Nkind (N) in N_Entity);
5382 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
5385 procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
5387 pragma Assert (Nkind (N) in N_Entity);
5390 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
5393 procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
5395 pragma Assert (Nkind (N) in N_Entity);
5398 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
5401 procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
5403 pragma Assert (Nkind (N) in N_Entity);
5404 Nodes.Table (N + 3).In_List := Val;
5407 procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
5409 pragma Assert (Nkind (N) in N_Entity);
5410 Nodes.Table (N + 3).Unused_1 := Val;
5413 procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
5415 pragma Assert (Nkind (N) in N_Entity);
5416 Nodes.Table (N + 3).Rewrite_Ins := Val;
5419 procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
5421 pragma Assert (Nkind (N) in N_Entity);
5422 Nodes.Table (N + 3).Analyzed := Val;
5425 procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
5427 pragma Assert (Nkind (N) in N_Entity);
5428 Nodes.Table (N + 3).Comes_From_Source := Val;
5431 procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
5433 pragma Assert (Nkind (N) in N_Entity);
5434 Nodes.Table (N + 3).Error_Posted := Val;
5437 procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
5439 pragma Assert (Nkind (N) in N_Entity);
5440 Nodes.Table (N + 3).Flag4 := Val;
5443 procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
5445 pragma Assert (Nkind (N) in N_Entity);
5446 Nodes.Table (N + 3).Flag5 := Val;
5449 procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
5451 pragma Assert (Nkind (N) in N_Entity);
5452 Nodes.Table (N + 3).Flag6 := Val;
5455 procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
5457 pragma Assert (Nkind (N) in N_Entity);
5458 Nodes.Table (N + 3).Flag7 := Val;
5461 procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
5463 pragma Assert (Nkind (N) in N_Entity);
5464 Nodes.Table (N + 3).Flag8 := Val;
5467 procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
5469 pragma Assert (Nkind (N) in N_Entity);
5470 Nodes.Table (N + 3).Flag9 := Val;
5473 procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
5475 pragma Assert (Nkind (N) in N_Entity);
5476 Nodes.Table (N + 3).Flag10 := Val;
5479 procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
5481 pragma Assert (Nkind (N) in N_Entity);
5482 Nodes.Table (N + 3).Flag11 := Val;
5485 procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
5487 pragma Assert (Nkind (N) in N_Entity);
5488 Nodes.Table (N + 3).Flag12 := Val;
5491 procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
5493 pragma Assert (Nkind (N) in N_Entity);
5494 Nodes.Table (N + 3).Flag13 := Val;
5497 procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
5499 pragma Assert (Nkind (N) in N_Entity);
5500 Nodes.Table (N + 3).Flag14 := Val;
5503 procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
5505 pragma Assert (Nkind (N) in N_Entity);
5506 Nodes.Table (N + 3).Flag15 := Val;
5509 procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
5511 pragma Assert (Nkind (N) in N_Entity);
5512 Nodes.Table (N + 3).Flag16 := Val;
5515 procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
5517 pragma Assert (Nkind (N) in N_Entity);
5518 Nodes.Table (N + 3).Flag17 := Val;
5521 procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
5523 pragma Assert (Nkind (N) in N_Entity);
5524 Nodes.Table (N + 3).Flag18 := Val;
5527 procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
5529 pragma Assert (Nkind (N) in N_Entity);
5530 Nodes.Table (N + 3).Pflag1 := Val;
5533 procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
5535 pragma Assert (Nkind (N) in N_Entity);
5536 Nodes.Table (N + 3).Pflag2 := Val;
5539 procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
5541 pragma Assert (Nkind (N) in N_Entity);
5544 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
5547 procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
5549 pragma Assert (Nkind (N) in N_Entity);
5552 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
5555 procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
5557 pragma Assert (Nkind (N) in N_Entity);
5560 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
5563 procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
5565 pragma Assert (Nkind (N) in N_Entity);
5568 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
5571 procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
5573 pragma Assert (Nkind (N) in N_Entity);
5576 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
5579 procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
5581 pragma Assert (Nkind (N) in N_Entity);
5584 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
5587 procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
5589 pragma Assert (Nkind (N) in N_Entity);
5592 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
5595 procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
5597 pragma Assert (Nkind (N) in N_Entity);
5600 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
5603 procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
5605 pragma Assert (Nkind (N) in N_Entity);
5608 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
5611 procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
5613 pragma Assert (Nkind (N) in N_Entity);
5616 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
5619 procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
5621 pragma Assert (Nkind (N) in N_Entity);
5624 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
5627 procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
5629 pragma Assert (Nkind (N) in N_Entity);
5632 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
5635 procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
5637 pragma Assert (Nkind (N) in N_Entity);
5640 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
5643 procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
5645 pragma Assert (Nkind (N) in N_Entity);
5648 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
5651 procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
5653 pragma Assert (Nkind (N) in N_Entity);
5656 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
5659 procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
5661 pragma Assert (Nkind (N) in N_Entity);
5664 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
5667 procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
5669 pragma Assert (Nkind (N) in N_Entity);
5672 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
5675 procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
5677 pragma Assert (Nkind (N) in N_Entity);
5680 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
5683 procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
5685 pragma Assert (Nkind (N) in N_Entity);
5688 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
5691 procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
5693 pragma Assert (Nkind (N) in N_Entity);
5696 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
5699 procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
5701 pragma Assert (Nkind (N) in N_Entity);
5704 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
5707 procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
5709 pragma Assert (Nkind (N) in N_Entity);
5712 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
5715 procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
5717 pragma Assert (Nkind (N) in N_Entity);
5720 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
5723 procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
5725 pragma Assert (Nkind (N) in N_Entity);
5728 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
5731 procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
5733 pragma Assert (Nkind (N) in N_Entity);
5736 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
5739 procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
5741 pragma Assert (Nkind (N) in N_Entity);
5744 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
5747 procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
5749 pragma Assert (Nkind (N) in N_Entity);
5752 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
5755 procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
5757 pragma Assert (Nkind (N) in N_Entity);
5760 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
5763 procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
5765 pragma Assert (Nkind (N) in N_Entity);
5768 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
5771 procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
5773 pragma Assert (Nkind (N) in N_Entity);
5776 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
5779 procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
5781 pragma Assert (Nkind (N) in N_Entity);
5784 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
5787 procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
5789 pragma Assert (Nkind (N) in N_Entity);
5792 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
5795 procedure Set_Flag184 (N : Node_Id; Val : Boolean) is
5797 pragma Assert (Nkind (N) in N_Entity);
5800 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag184 := Val;
5803 procedure Set_Flag185 (N : Node_Id; Val : Boolean) is
5805 pragma Assert (Nkind (N) in N_Entity);
5808 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag185 := Val;
5811 procedure Set_Flag186 (N : Node_Id; Val : Boolean) is
5813 pragma Assert (Nkind (N) in N_Entity);
5816 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag186 := Val;
5819 procedure Set_Flag187 (N : Node_Id; Val : Boolean) is
5821 pragma Assert (Nkind (N) in N_Entity);
5824 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag187 := Val;
5827 procedure Set_Flag188 (N : Node_Id; Val : Boolean) is
5829 pragma Assert (Nkind (N) in N_Entity);
5832 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag188 := Val;
5835 procedure Set_Flag189 (N : Node_Id; Val : Boolean) is
5837 pragma Assert (Nkind (N) in N_Entity);
5840 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag189 := Val;
5843 procedure Set_Flag190 (N : Node_Id; Val : Boolean) is
5845 pragma Assert (Nkind (N) in N_Entity);
5848 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag190 := Val;
5851 procedure Set_Flag191 (N : Node_Id; Val : Boolean) is
5853 pragma Assert (Nkind (N) in N_Entity);
5856 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag191 := Val;
5859 procedure Set_Flag192 (N : Node_Id; Val : Boolean) is
5861 pragma Assert (Nkind (N) in N_Entity);
5864 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag192 := Val;
5867 procedure Set_Flag193 (N : Node_Id; Val : Boolean) is
5869 pragma Assert (Nkind (N) in N_Entity);
5872 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag193 := Val;
5875 procedure Set_Flag194 (N : Node_Id; Val : Boolean) is
5877 pragma Assert (Nkind (N) in N_Entity);
5880 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag194 := Val;
5883 procedure Set_Flag195 (N : Node_Id; Val : Boolean) is
5885 pragma Assert (Nkind (N) in N_Entity);
5888 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag195 := Val;
5891 procedure Set_Flag196 (N : Node_Id; Val : Boolean) is
5893 pragma Assert (Nkind (N) in N_Entity);
5896 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag196 := Val;
5899 procedure Set_Flag197 (N : Node_Id; Val : Boolean) is
5901 pragma Assert (Nkind (N) in N_Entity);
5904 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag197 := Val;
5907 procedure Set_Flag198 (N : Node_Id; Val : Boolean) is
5909 pragma Assert (Nkind (N) in N_Entity);
5912 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag198 := Val;
5915 procedure Set_Flag199 (N : Node_Id; Val : Boolean) is
5917 pragma Assert (Nkind (N) in N_Entity);
5920 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag199 := Val;
5923 procedure Set_Flag200 (N : Node_Id; Val : Boolean) is
5925 pragma Assert (Nkind (N) in N_Entity);
5928 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag200 := Val;
5931 procedure Set_Flag201 (N : Node_Id; Val : Boolean) is
5933 pragma Assert (Nkind (N) in N_Entity);
5936 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag201 := Val;
5939 procedure Set_Flag202 (N : Node_Id; Val : Boolean) is
5941 pragma Assert (Nkind (N) in N_Entity);
5944 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag202 := Val;
5947 procedure Set_Flag203 (N : Node_Id; Val : Boolean) is
5949 pragma Assert (Nkind (N) in N_Entity);
5952 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag203 := Val;
5955 procedure Set_Flag204 (N : Node_Id; Val : Boolean) is
5957 pragma Assert (Nkind (N) in N_Entity);
5960 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag204 := Val;
5963 procedure Set_Flag205 (N : Node_Id; Val : Boolean) is
5965 pragma Assert (Nkind (N) in N_Entity);
5968 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag205 := Val;
5971 procedure Set_Flag206 (N : Node_Id; Val : Boolean) is
5973 pragma Assert (Nkind (N) in N_Entity);
5976 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag206 := Val;
5979 procedure Set_Flag207 (N : Node_Id; Val : Boolean) is
5981 pragma Assert (Nkind (N) in N_Entity);
5984 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag207 := Val;
5987 procedure Set_Flag208 (N : Node_Id; Val : Boolean) is
5989 pragma Assert (Nkind (N) in N_Entity);
5992 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag208 := Val;
5995 procedure Set_Flag209 (N : Node_Id; Val : Boolean) is
5997 pragma Assert (Nkind (N) in N_Entity);
6000 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag209 := Val;
6003 procedure Set_Flag210 (N : Node_Id; Val : Boolean) is
6005 pragma Assert (Nkind (N) in N_Entity);
6008 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag210 := Val;
6011 procedure Set_Flag211 (N : Node_Id; Val : Boolean) is
6013 pragma Assert (Nkind (N) in N_Entity);
6016 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag211 := Val;
6019 procedure Set_Flag212 (N : Node_Id; Val : Boolean) is
6021 pragma Assert (Nkind (N) in N_Entity);
6024 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag212 := Val;
6027 procedure Set_Flag213 (N : Node_Id; Val : Boolean) is
6029 pragma Assert (Nkind (N) in N_Entity);
6032 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag213 := Val;
6035 procedure Set_Flag214 (N : Node_Id; Val : Boolean) is
6037 pragma Assert (Nkind (N) in N_Entity);
6040 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag214 := Val;
6043 procedure Set_Flag215 (N : Node_Id; Val : Boolean) is
6045 pragma Assert (Nkind (N) in N_Entity);
6048 (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag215 := Val;
6051 procedure Set_Flag216 (N : Node_Id; Val : Boolean) is
6053 pragma Assert (Nkind (N) in N_Entity);
6056 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag216 := Val;
6059 procedure Set_Flag217 (N : Node_Id; Val : Boolean) is
6061 pragma Assert (Nkind (N) in N_Entity);
6064 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag217 := Val;
6067 procedure Set_Flag218 (N : Node_Id; Val : Boolean) is
6069 pragma Assert (Nkind (N) in N_Entity);
6072 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag218 := Val;
6075 procedure Set_Flag219 (N : Node_Id; Val : Boolean) is
6077 pragma Assert (Nkind (N) in N_Entity);
6080 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag219 := Val;
6083 procedure Set_Flag220 (N : Node_Id; Val : Boolean) is
6085 pragma Assert (Nkind (N) in N_Entity);
6088 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag220 := Val;
6091 procedure Set_Flag221 (N : Node_Id; Val : Boolean) is
6093 pragma Assert (Nkind (N) in N_Entity);
6096 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag221 := Val;
6099 procedure Set_Flag222 (N : Node_Id; Val : Boolean) is
6101 pragma Assert (Nkind (N) in N_Entity);
6104 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag222 := Val;
6107 procedure Set_Flag223 (N : Node_Id; Val : Boolean) is
6109 pragma Assert (Nkind (N) in N_Entity);
6112 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag223 := Val;
6115 procedure Set_Flag224 (N : Node_Id; Val : Boolean) is
6117 pragma Assert (Nkind (N) in N_Entity);
6120 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag224 := Val;
6123 procedure Set_Flag225 (N : Node_Id; Val : Boolean) is
6125 pragma Assert (Nkind (N) in N_Entity);
6128 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag225 := Val;
6131 procedure Set_Flag226 (N : Node_Id; Val : Boolean) is
6133 pragma Assert (Nkind (N) in N_Entity);
6136 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag226 := Val;
6139 procedure Set_Flag227 (N : Node_Id; Val : Boolean) is
6141 pragma Assert (Nkind (N) in N_Entity);
6144 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag227 := Val;
6147 procedure Set_Flag228 (N : Node_Id; Val : Boolean) is
6149 pragma Assert (Nkind (N) in N_Entity);
6152 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag228 := Val;
6155 procedure Set_Flag229 (N : Node_Id; Val : Boolean) is
6157 pragma Assert (Nkind (N) in N_Entity);
6160 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag229 := Val;
6163 procedure Set_Flag230 (N : Node_Id; Val : Boolean) is
6165 pragma Assert (Nkind (N) in N_Entity);
6168 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag230 := Val;
6171 procedure Set_Flag231 (N : Node_Id; Val : Boolean) is
6173 pragma Assert (Nkind (N) in N_Entity);
6176 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag231 := Val;
6179 procedure Set_Flag232 (N : Node_Id; Val : Boolean) is
6181 pragma Assert (Nkind (N) in N_Entity);
6184 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag232 := Val;
6187 procedure Set_Flag233 (N : Node_Id; Val : Boolean) is
6189 pragma Assert (Nkind (N) in N_Entity);
6192 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag233 := Val;
6195 procedure Set_Flag234 (N : Node_Id; Val : Boolean) is
6197 pragma Assert (Nkind (N) in N_Entity);
6200 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag234 := Val;
6203 procedure Set_Flag235 (N : Node_Id; Val : Boolean) is
6205 pragma Assert (Nkind (N) in N_Entity);
6208 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag235 := Val;
6211 procedure Set_Flag236 (N : Node_Id; Val : Boolean) is
6213 pragma Assert (Nkind (N) in N_Entity);
6216 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag236 := Val;
6219 procedure Set_Flag237 (N : Node_Id; Val : Boolean) is
6221 pragma Assert (Nkind (N) in N_Entity);
6224 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag237 := Val;
6227 procedure Set_Flag238 (N : Node_Id; Val : Boolean) is
6229 pragma Assert (Nkind (N) in N_Entity);
6232 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag238 := Val;
6235 procedure Set_Flag239 (N : Node_Id; Val : Boolean) is
6237 pragma Assert (Nkind (N) in N_Entity);
6240 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag239 := Val;
6243 procedure Set_Flag240 (N : Node_Id; Val : Boolean) is
6245 pragma Assert (Nkind (N) in N_Entity);
6248 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag240 := Val;
6251 procedure Set_Flag241 (N : Node_Id; Val : Boolean) is
6253 pragma Assert (Nkind (N) in N_Entity);
6256 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag241 := Val;
6259 procedure Set_Flag242 (N : Node_Id; Val : Boolean) is
6261 pragma Assert (Nkind (N) in N_Entity);
6264 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag242 := Val;
6267 procedure Set_Flag243 (N : Node_Id; Val : Boolean) is
6269 pragma Assert (Nkind (N) in N_Entity);
6272 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag243 := Val;
6275 procedure Set_Flag244 (N : Node_Id; Val : Boolean) is
6277 pragma Assert (Nkind (N) in N_Entity);
6280 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag244 := Val;
6283 procedure Set_Flag245 (N : Node_Id; Val : Boolean) is
6285 pragma Assert (Nkind (N) in N_Entity);
6288 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag245 := Val;
6291 procedure Set_Flag246 (N : Node_Id; Val : Boolean) is
6293 pragma Assert (Nkind (N) in N_Entity);
6296 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag246 := Val;
6299 procedure Set_Flag247 (N : Node_Id; Val : Boolean) is
6301 pragma Assert (Nkind (N) in N_Entity);
6304 (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag247 := Val;
6307 procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is
6309 pragma Assert (N <= Nodes.Last);
6312 Set_Parent (N => Val, Val => N);
6316 end Set_Node1_With_Parent;
6318 procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is
6320 pragma Assert (N <= Nodes.Last);
6323 Set_Parent (N => Val, Val => N);
6327 end Set_Node2_With_Parent;
6329 procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is
6331 pragma Assert (N <= Nodes.Last);
6334 Set_Parent (N => Val, Val => N);
6338 end Set_Node3_With_Parent;
6340 procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is
6342 pragma Assert (N <= Nodes.Last);
6345 Set_Parent (N => Val, Val => N);
6349 end Set_Node4_With_Parent;
6351 procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
6353 pragma Assert (N <= Nodes.Last);
6356 Set_Parent (N => Val, Val => N);
6360 end Set_Node5_With_Parent;
6362 procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
6364 pragma Assert (N <= Nodes.Last);
6365 if Val /= No_List and then Val /= Error_List then
6366 Set_Parent (Val, N);
6369 end Set_List1_With_Parent;
6371 procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
6373 pragma Assert (N <= Nodes.Last);
6374 if Val /= No_List and then Val /= Error_List then
6375 Set_Parent (Val, N);
6378 end Set_List2_With_Parent;
6380 procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
6382 pragma Assert (N <= Nodes.Last);
6383 if Val /= No_List and then Val /= Error_List then
6384 Set_Parent (Val, N);
6387 end Set_List3_With_Parent;
6389 procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
6391 pragma Assert (N <= Nodes.Last);
6392 if Val /= No_List and then Val /= Error_List then
6393 Set_Parent (Val, N);
6396 end Set_List4_With_Parent;
6398 procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
6400 pragma Assert (N <= Nodes.Last);
6401 if Val /= No_List and then Val /= Error_List then
6402 Set_Parent (Val, N);
6405 end Set_List5_With_Parent;
6407 end Unchecked_Access;
6415 Nodes.Locked := False;
6416 Orig_Nodes.Locked := False;