1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
9 -- Copyright (C) 1992-2003, 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 2, 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. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING. If not, write --
19 -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
20 -- MA 02111-1307, USA. --
22 -- As a special exception, if other files instantiate generics from this --
23 -- unit, or you link this unit with other files to produce an executable, --
24 -- this unit does not by itself cause the resulting executable to be --
25 -- covered by the GNU General Public License. This exception does not --
26 -- however invalidate any other reasons why the executable file might be --
27 -- covered by the GNU Public License. --
29 -- GNAT was originally developed by the GNAT team at New York University. --
30 -- Extensive contributions were provided by Ada Core Technologies Inc. --
32 ------------------------------------------------------------------------------
34 pragma Style_Checks (All_Checks);
35 -- Turn off subprogram ordering check for this package
37 -- WARNING: There is a C version of this package. Any changes to this source
38 -- file must be properly reflected in the C header a-atree.h (for inlined
39 -- bodies) and the C file a-atree.c (for remaining non-inlined bodies).
41 with Debug; use Debug;
42 with Nlists; use Nlists;
43 with Elists; use Elists;
44 with Output; use Output;
45 with Sinput; use Sinput;
46 with Tree_IO; use Tree_IO;
48 with GNAT.HTable; use GNAT.HTable;
53 -- Count allocated nodes for Num_Nodes function
56 -- We are allowed to see these from within our own body!
58 use Atree_Private_Part;
59 -- We are also allowed to see our private data structures!
61 function E_To_N is new Unchecked_Conversion (Entity_Kind, Node_Kind);
62 function N_To_E is new Unchecked_Conversion (Node_Kind, Entity_Kind);
63 -- Functions used to store Entity_Kind value in Nkind field
65 -- The following declarations are used to store flags 65-72 in the
66 -- Nkind field of the third component of an extended (entity) node.
68 type Flag_Byte is record
79 pragma Pack (Flag_Byte);
80 for Flag_Byte'Size use 8;
82 type Flag_Byte_Ptr is access all Flag_Byte;
83 type Node_Kind_Ptr is access all Node_Kind;
85 function To_Flag_Byte is new
86 Unchecked_Conversion (Node_Kind, Flag_Byte);
88 function To_Flag_Byte_Ptr is new
89 Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);
91 -- The following declarations are used to store flags 73-96 in the
92 -- Field12 field of the third component of an extended (entity) node.
94 type Flag_Word is record
122 Convention : Convention_Id;
125 pragma Pack (Flag_Word);
126 for Flag_Word'Size use 32;
127 for Flag_Word'Alignment use 4;
129 type Flag_Word_Ptr is access all Flag_Word;
130 type Union_Id_Ptr is access all Union_Id;
132 function To_Flag_Word is new
133 Unchecked_Conversion (Union_Id, Flag_Word);
135 function To_Flag_Word_Ptr is new
136 Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr);
138 -- The following declarations are used to store flags 97-128 in the
139 -- Field12 field of the fourth component of an extended (entity) node.
141 type Flag_Word2 is record
179 pragma Pack (Flag_Word2);
180 for Flag_Word2'Size use 32;
181 for Flag_Word2'Alignment use 4;
183 type Flag_Word2_Ptr is access all Flag_Word2;
185 function To_Flag_Word2 is new
186 Unchecked_Conversion (Union_Id, Flag_Word2);
188 function To_Flag_Word2_Ptr is new
189 Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr);
191 -- The following declarations are used to store flags 97-120 in the
192 -- Field12 field of the fourth component of an extended (entity) node.
194 type Flag_Word3 is record
232 pragma Pack (Flag_Word3);
233 for Flag_Word3'Size use 32;
234 for Flag_Word3'Alignment use 4;
236 type Flag_Word3_Ptr is access all Flag_Word3;
238 function To_Flag_Word3 is new
239 Unchecked_Conversion (Union_Id, Flag_Word3);
241 function To_Flag_Word3_Ptr is new
242 Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr);
244 -- Default value used to initialize default nodes. Note that some of the
245 -- fields get overwritten, and in particular, Nkind always gets reset.
247 Default_Node : Node_Record := (
248 Is_Extension => False,
253 Rewrite_Ins => False,
255 Comes_From_Source => False, -- modified by Set_Comes_From_Source_Default
256 Error_Posted => False,
275 Nkind => N_Unused_At_Start,
278 Link => Empty_List_Or_Node,
279 Field1 => Empty_List_Or_Node,
280 Field2 => Empty_List_Or_Node,
281 Field3 => Empty_List_Or_Node,
282 Field4 => Empty_List_Or_Node,
283 Field5 => Empty_List_Or_Node);
285 -- Default value used to initialize node extensions (i.e. the second
286 -- and third and fourth components of an extended node). Note we are
287 -- cheating a bit here when it comes to Node12, which really holds
288 -- flags an (for the third component), the convention. But it works
289 -- because Empty, False, Convention_Ada, all happen to be all zero bits.
291 Default_Node_Extension : constant Node_Record := (
292 Is_Extension => True,
297 Rewrite_Ins => False,
299 Comes_From_Source => False,
300 Error_Posted => False,
319 Nkind => E_To_N (E_Void),
321 Field6 => Empty_List_Or_Node,
322 Field7 => Empty_List_Or_Node,
323 Field8 => Empty_List_Or_Node,
324 Field9 => Empty_List_Or_Node,
325 Field10 => Empty_List_Or_Node,
326 Field11 => Empty_List_Or_Node,
327 Field12 => Empty_List_Or_Node);
329 --------------------------------------------------
330 -- Implementation of Tree Substitution Routines --
331 --------------------------------------------------
333 -- A separate table keeps track of the mapping between rewritten nodes
334 -- and their corresponding original tree nodes. Rewrite makes an entry
335 -- in this table for use by Original_Node. By default, if no call is
336 -- Rewrite, the entry in this table points to the original unwritten node.
338 -- Note: eventually, this should be a field in the Node directly, but
339 -- for now we do not want to disturb the efficiency of a power of 2
342 package Orig_Nodes is new Table.Table (
343 Table_Component_Type => Node_Id,
344 Table_Index_Type => Node_Id,
345 Table_Low_Bound => First_Node_Id,
346 Table_Initial => Alloc.Orig_Nodes_Initial,
347 Table_Increment => Alloc.Orig_Nodes_Increment,
348 Table_Name => "Orig_Nodes");
350 ----------------------------------------
351 -- Global_Variables for New_Copy_Tree --
352 ----------------------------------------
354 -- These global variables are used by New_Copy_Tree. See description
355 -- of the body of this subprogram for details. Global variables can be
356 -- safely used by New_Copy_Tree, since there is no case of a recursive
357 -- call from the processing inside New_Copy_Tree.
359 NCT_Hash_Threshhold : constant := 20;
360 -- If there are more than this number of pairs of entries in the
361 -- map, then Hash_Tables_Used will be set, and the hash tables will
362 -- be initialized and used for the searches.
364 NCT_Hash_Tables_Used : Boolean := False;
365 -- Set to True if hash tables are in use
367 NCT_Table_Entries : Nat;
368 -- Count entries in table to see if threshhold is reached
370 NCT_Hash_Table_Setup : Boolean := False;
371 -- Set to True if hash table contains data. We set this True if we
372 -- setup the hash table with data, and leave it set permanently
373 -- from then on, this is a signal that second and subsequent users
374 -- of the hash table must clear the old entries before reuse.
376 subtype NCT_Header_Num is Int range 0 .. 511;
377 -- Defines range of headers in hash tables (512 headers)
379 -----------------------
380 -- Local Subprograms --
381 -----------------------
383 procedure Fix_Parent (Field : Union_Id; Old_Node, New_Node : Node_Id);
384 -- This subprogram is used to fixup parent pointers that are rendered
385 -- incorrect because of a node copy. Field is checked to see if it
386 -- points to a node, list, or element list that has a parent that
387 -- points to Old_Node. If so, the parent is reset to point to New_Node.
393 function Analyzed (N : Node_Id) return Boolean is
395 pragma Assert (N in Nodes.First .. Nodes.Last);
396 return Nodes.Table (N).Analyzed;
403 procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is
404 Save_Sloc : constant Source_Ptr := Sloc (N);
405 Save_In_List : constant Boolean := Nodes.Table (N).In_List;
406 Save_Link : constant Union_Id := Nodes.Table (N).Link;
407 Save_CFS : constant Boolean := Nodes.Table (N).Comes_From_Source;
408 Save_Posted : constant Boolean := Nodes.Table (N).Error_Posted;
409 Par_Count : Paren_Count_Type := 0;
412 if Nkind (N) in N_Subexpr then
413 Par_Count := Paren_Count (N);
416 Nodes.Table (N) := Default_Node;
417 Nodes.Table (N).Sloc := Save_Sloc;
418 Nodes.Table (N).In_List := Save_In_List;
419 Nodes.Table (N).Link := Save_Link;
420 Nodes.Table (N).Comes_From_Source := Save_CFS;
421 Nodes.Table (N).Nkind := New_Node_Kind;
422 Nodes.Table (N).Error_Posted := Save_Posted;
424 if New_Node_Kind in N_Subexpr then
425 Set_Paren_Count (N, Par_Count);
429 -----------------------
430 -- Comes_From_Source --
431 -----------------------
433 function Comes_From_Source (N : Node_Id) return Boolean is
435 pragma Assert (N in Nodes.First .. Nodes.Last);
436 return Nodes.Table (N).Comes_From_Source;
437 end Comes_From_Source;
443 function Convention (E : Entity_Id) return Convention_Id is
445 pragma Assert (Nkind (E) in N_Entity);
446 return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention;
453 procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is
454 Save_In_List : constant Boolean := Nodes.Table (Destination).In_List;
455 Save_Link : constant Union_Id := Nodes.Table (Destination).Link;
458 Nodes.Table (Destination) := Nodes.Table (Source);
459 Nodes.Table (Destination).In_List := Save_In_List;
460 Nodes.Table (Destination).Link := Save_Link;
462 if Has_Extension (Source) then
463 pragma Assert (Has_Extension (Destination));
464 Nodes.Table (Destination + 1) := Nodes.Table (Source + 1);
465 Nodes.Table (Destination + 2) := Nodes.Table (Source + 2);
466 Nodes.Table (Destination + 3) := Nodes.Table (Source + 3);
469 pragma Assert (not Has_Extension (Source));
474 ------------------------
475 -- Copy_Separate_Tree --
476 ------------------------
478 function Copy_Separate_Tree (Source : Node_Id) return Node_Id is
481 function Copy_Entity (E : Entity_Id) return Entity_Id;
482 -- Copy Entity, copying only the Ekind and Chars fields
484 function Copy_List (List : List_Id) return List_Id;
487 function Possible_Copy (Field : Union_Id) return Union_Id;
488 -- Given a field, returns a copy of the node or list if its parent
489 -- is the current source node, and otherwise returns the input
495 function Copy_Entity (E : Entity_Id) return Entity_Id is
499 case N_Entity (Nkind (E)) is
500 when N_Defining_Identifier =>
501 New_Ent := New_Entity (N_Defining_Identifier, Sloc (E));
503 when N_Defining_Character_Literal =>
504 New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E));
506 when N_Defining_Operator_Symbol =>
507 New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E));
510 Set_Chars (New_Ent, Chars (E));
518 function Copy_List (List : List_Id) return List_Id is
523 if List = No_List then
530 while Present (E) loop
532 if Has_Extension (E) then
533 Append (Copy_Entity (E), NL);
535 Append (Copy_Separate_Tree (E), NL);
549 function Possible_Copy (Field : Union_Id) return Union_Id is
553 if Field in Node_Range then
555 New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field)));
557 if Parent (Node_Id (Field)) = Source then
558 Set_Parent (Node_Id (New_N), New_Id);
563 elsif Field in List_Range then
564 New_N := Union_Id (Copy_List (List_Id (Field)));
566 if Parent (List_Id (Field)) = Source then
567 Set_Parent (List_Id (New_N), New_Id);
577 -- Start of processing for Copy_Separate_Tree
580 if Source <= Empty_Or_Error then
583 elsif Has_Extension (Source) then
584 return Copy_Entity (Source);
587 Nodes.Increment_Last;
588 New_Id := Nodes.Last;
589 Nodes.Table (New_Id) := Nodes.Table (Source);
590 Nodes.Table (New_Id).Link := Empty_List_Or_Node;
591 Nodes.Table (New_Id).In_List := False;
592 Nodes.Table (New_Id).Rewrite_Ins := False;
593 Node_Count := Node_Count + 1;
595 Orig_Nodes.Increment_Last;
596 Allocate_List_Tables (Nodes.Last);
597 Orig_Nodes.Table (New_Id) := New_Id;
599 -- Recursively copy descendents
601 Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id)));
602 Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id)));
603 Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id)));
604 Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id)));
605 Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id)));
607 -- Set Entity field to Empty
608 -- Why is this done??? and why is it always right to do it???
610 if Nkind (New_Id) in N_Has_Entity
611 or else Nkind (New_Id) = N_Freeze_Entity
613 Set_Entity (New_Id, Empty);
616 -- All done, return copied node
620 end Copy_Separate_Tree;
626 procedure Delete_Node (Node : Node_Id) is
628 pragma Assert (not Nodes.Table (Node).In_List);
631 Write_Str ("Delete node ");
632 Write_Int (Int (Node));
636 Nodes.Table (Node) := Default_Node;
637 Nodes.Table (Node).Nkind := N_Unused_At_Start;
638 Node_Count := Node_Count - 1;
640 -- Note: for now, we are not bothering to reuse deleted nodes
648 procedure Delete_Tree (Node : Node_Id) is
650 procedure Delete_Field (F : Union_Id);
651 -- Delete item pointed to by field F if it is a syntactic element
653 procedure Delete_List (L : List_Id);
654 -- Delete all elements on the given list
656 procedure Delete_Field (F : Union_Id) is
658 if F = Union_Id (Empty) then
661 elsif F in Node_Range
662 and then Parent (Node_Id (F)) = Node
664 Delete_Tree (Node_Id (F));
666 elsif F in List_Range
667 and then Parent (List_Id (F)) = Node
669 Delete_List (List_Id (F));
671 -- No need to test Elist case, there are no syntactic Elists
678 procedure Delete_List (L : List_Id) is
680 while Is_Non_Empty_List (L) loop
681 Delete_Tree (Remove_Head (L));
685 -- Start of processing for Delete_Tree
688 -- Delete descendents
690 Delete_Field (Field1 (Node));
691 Delete_Field (Field2 (Node));
692 Delete_Field (Field3 (Node));
693 Delete_Field (Field4 (Node));
694 Delete_Field (Field5 (Node));
701 function Ekind (E : Entity_Id) return Entity_Kind is
703 pragma Assert (Nkind (E) in N_Entity);
704 return N_To_E (Nodes.Table (E + 1).Nkind);
711 function Error_Posted (N : Node_Id) return Boolean is
713 pragma Assert (N in Nodes.First .. Nodes.Last);
714 return Nodes.Table (N).Error_Posted;
717 -----------------------
718 -- Exchange_Entities --
719 -----------------------
721 procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is
722 Temp_Ent : Node_Record;
725 pragma Assert (Has_Extension (E1)
726 and then Has_Extension (E2)
727 and then not Nodes.Table (E1).In_List
728 and then not Nodes.Table (E2).In_List);
730 -- Exchange the contents of the two entities
732 Temp_Ent := Nodes.Table (E1);
733 Nodes.Table (E1) := Nodes.Table (E2);
734 Nodes.Table (E2) := Temp_Ent;
735 Temp_Ent := Nodes.Table (E1 + 1);
736 Nodes.Table (E1 + 1) := Nodes.Table (E2 + 1);
737 Nodes.Table (E2 + 1) := Temp_Ent;
738 Temp_Ent := Nodes.Table (E1 + 2);
739 Nodes.Table (E1 + 2) := Nodes.Table (E2 + 2);
740 Nodes.Table (E2 + 2) := Temp_Ent;
741 Temp_Ent := Nodes.Table (E1 + 3);
742 Nodes.Table (E1 + 3) := Nodes.Table (E2 + 3);
743 Nodes.Table (E2 + 3) := Temp_Ent;
745 -- That exchange exchanged the parent pointers as well, which is what
746 -- we want, but we need to patch up the defining identifier pointers
747 -- in the parent nodes (the child pointers) to match this switch
748 -- unless for Implicit types entities which have no parent, in which
749 -- case we don't do anything otherwise we won't be able to revert back
750 -- to the original situation.
752 -- Shouldn't this use Is_Itype instead of the Parent test
754 if Present (Parent (E1)) and then Present (Parent (E2)) then
755 Set_Defining_Identifier (Parent (E1), E1);
756 Set_Defining_Identifier (Parent (E2), E2);
758 end Exchange_Entities;
764 function Extend_Node (Node : Node_Id) return Entity_Id is
767 procedure Debug_Extend_Node;
768 -- Debug routine for debug flag N
770 procedure Debug_Extend_Node is
773 Write_Str ("Extend node ");
774 Write_Int (Int (Node));
776 if Result = Node then
777 Write_Str (" in place");
779 Write_Str (" copied to ");
780 Write_Int (Int (Result));
785 end Debug_Extend_Node;
787 pragma Inline (Debug_Extend_Node);
790 if Node /= Nodes.Last then
791 Nodes.Increment_Last;
792 Nodes.Table (Nodes.Last) := Nodes.Table (Node);
793 Result := Nodes.Last;
795 Orig_Nodes.Increment_Last;
796 Orig_Nodes.Table (Nodes.Last) := Nodes.Last;
802 Nodes.Increment_Last;
803 Nodes.Table (Nodes.Last) := Default_Node_Extension;
804 Nodes.Increment_Last;
805 Nodes.Table (Nodes.Last) := Default_Node_Extension;
806 Nodes.Increment_Last;
807 Nodes.Table (Nodes.Last) := Default_Node_Extension;
809 Orig_Nodes.Set_Last (Nodes.Last);
810 Allocate_List_Tables (Nodes.Last);
812 pragma Debug (Debug_Extend_Node);
820 procedure Fix_Parent (Field : Union_Id; Old_Node, New_Node : Node_Id) is
822 -- Fix parent of node that is referenced by Field. Note that we must
823 -- exclude the case where the node is a member of a list, because in
824 -- this case the parent is the parent of the list.
826 if Field in Node_Range
827 and then Present (Node_Id (Field))
828 and then not Nodes.Table (Node_Id (Field)).In_List
829 and then Parent (Node_Id (Field)) = Old_Node
831 Set_Parent (Node_Id (Field), New_Node);
833 -- Fix parent of list that is referenced by Field
835 elsif Field in List_Range
836 and then Present (List_Id (Field))
837 and then Parent (List_Id (Field)) = Old_Node
839 Set_Parent (List_Id (Field), New_Node);
843 -----------------------------------
844 -- Get_Comes_From_Source_Default --
845 -----------------------------------
847 function Get_Comes_From_Source_Default return Boolean is
849 return Default_Node.Comes_From_Source;
850 end Get_Comes_From_Source_Default;
856 function Has_Extension (N : Node_Id) return Boolean is
858 return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension;
865 procedure Initialize is
867 pragma Warnings (Off, Dummy);
871 Atree_Private_Part.Nodes.Init;
874 -- Allocate Empty node
876 Dummy := New_Node (N_Empty, No_Location);
877 Set_Name1 (Empty, No_Name);
879 -- Allocate Error node, and set Error_Posted, since we certainly
880 -- only generate an Error node if we do post some kind of error!
882 Dummy := New_Node (N_Error, No_Location);
883 Set_Name1 (Error, Error_Name);
884 Set_Error_Posted (Error, True);
886 -- Set global variables for New_Copy_Tree:
887 NCT_Hash_Tables_Used := False;
888 NCT_Table_Entries := 0;
889 NCT_Hash_Table_Setup := False;
892 --------------------------
893 -- Is_Rewrite_Insertion --
894 --------------------------
896 function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is
898 return Nodes.Table (Node).Rewrite_Ins;
899 end Is_Rewrite_Insertion;
901 -----------------------------
902 -- Is_Rewrite_Substitution --
903 -----------------------------
905 function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is
907 return Orig_Nodes.Table (Node) /= Node;
908 end Is_Rewrite_Substitution;
914 function Last_Node_Id return Node_Id is
925 Nodes.Locked := True;
926 Orig_Nodes.Locked := True;
931 ----------------------------
932 -- Mark_Rewrite_Insertion --
933 ----------------------------
935 procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is
937 Nodes.Table (New_Node).Rewrite_Ins := True;
938 end Mark_Rewrite_Insertion;
944 function New_Copy (Source : Node_Id) return Node_Id is
948 if Source <= Empty_Or_Error then
952 Nodes.Increment_Last;
953 New_Id := Nodes.Last;
954 Nodes.Table (New_Id) := Nodes.Table (Source);
955 Nodes.Table (New_Id).Link := Empty_List_Or_Node;
956 Nodes.Table (New_Id).In_List := False;
957 Nodes.Table (New_Id).Rewrite_Ins := False;
959 Orig_Nodes.Increment_Last;
960 Orig_Nodes.Table (New_Id) := New_Id;
962 if Has_Extension (Source) then
963 Nodes.Increment_Last;
964 Nodes.Table (New_Id + 1) := Nodes.Table (Source + 1);
965 Nodes.Increment_Last;
966 Nodes.Table (New_Id + 2) := Nodes.Table (Source + 2);
967 Nodes.Increment_Last;
968 Nodes.Table (New_Id + 3) := Nodes.Table (Source + 3);
970 Orig_Nodes.Set_Last (Nodes.Last);
973 Allocate_List_Tables (Nodes.Last);
974 Node_Count := Node_Count + 1;
983 -- Our approach here requires a two pass traversal of the tree. The
984 -- first pass visits all nodes that eventually will be copied looking
985 -- for defining Itypes. If any defining Itypes are found, then they are
986 -- copied, and an entry is added to the replacement map. In the second
987 -- phase, the tree is copied, using the replacement map to replace any
988 -- Itype references within the copied tree.
990 -- The following hash tables are used if the Map supplied has more
991 -- than hash threshhold entries to speed up access to the map. If
992 -- there are fewer entries, then the map is searched sequentially
993 -- (because setting up a hash table for only a few entries takes
994 -- more time than it saves.
996 function New_Copy_Hash (E : Entity_Id) return NCT_Header_Num;
997 -- Hash function used for hash operations
999 function New_Copy_Hash (E : Entity_Id) return NCT_Header_Num is
1001 return Nat (E) mod (NCT_Header_Num'Last + 1);
1004 -- The hash table NCT_Assoc associates old entities in the table
1005 -- with their corresponding new entities (i.e. the pairs of entries
1006 -- presented in the original Map argument are Key-Element pairs).
1008 package NCT_Assoc is new Simple_HTable (
1009 Header_Num => NCT_Header_Num,
1010 Element => Entity_Id,
1011 No_Element => Empty,
1013 Hash => New_Copy_Hash,
1014 Equal => Types."=");
1016 -- The hash table NCT_Itype_Assoc contains entries only for those
1017 -- old nodes which have a non-empty Associated_Node_For_Itype set.
1018 -- The key is the associated node, and the element is the new node
1019 -- itself (NOT the associated node for the new node).
1021 package NCT_Itype_Assoc is new Simple_HTable (
1022 Header_Num => NCT_Header_Num,
1023 Element => Entity_Id,
1024 No_Element => Empty,
1026 Hash => New_Copy_Hash,
1027 Equal => Types."=");
1029 -- Start of New_Copy_Tree function
1031 function New_Copy_Tree
1033 Map : Elist_Id := No_Elist;
1034 New_Sloc : Source_Ptr := No_Location;
1035 New_Scope : Entity_Id := Empty)
1038 Actual_Map : Elist_Id := Map;
1039 -- This is the actual map for the copy. It is initialized with the
1040 -- given elements, and then enlarged as required for Itypes that are
1041 -- copied during the first phase of the copy operation. The visit
1042 -- procedures add elements to this map as Itypes are encountered.
1043 -- The reason we cannot use Map directly, is that it may well be
1044 -- (and normally is) initialized to No_Elist, and if we have mapped
1045 -- entities, we have to reset it to point to a real Elist.
1047 function Assoc (N : Node_Or_Entity_Id) return Node_Id;
1048 -- Called during second phase to map entities into their corresponding
1049 -- copies using Actual_Map. If the argument is not an entity, or is not
1050 -- in Actual_Map, then it is returned unchanged.
1052 procedure Build_NCT_Hash_Tables;
1053 -- Builds hash tables (number of elements >= threshold value)
1055 function Copy_Elist_With_Replacement
1056 (Old_Elist : Elist_Id)
1058 -- Called during second phase to copy element list doing replacements.
1060 procedure Copy_Itype_With_Replacement (New_Itype : Entity_Id);
1061 -- Called during the second phase to process a copied Itype. The actual
1062 -- copy happened during the first phase (so that we could make the entry
1063 -- in the mapping), but we still have to deal with the descendents of
1064 -- the copied Itype and copy them where necessary.
1066 function Copy_List_With_Replacement (Old_List : List_Id) return List_Id;
1067 -- Called during second phase to copy list doing replacements.
1069 function Copy_Node_With_Replacement (Old_Node : Node_Id) return Node_Id;
1070 -- Called during second phase to copy node doing replacements
1072 procedure Visit_Elist (E : Elist_Id);
1073 -- Called during first phase to visit all elements of an Elist
1075 procedure Visit_Field (F : Union_Id; N : Node_Id);
1076 -- Visit a single field, recursing to call Visit_Node or Visit_List
1077 -- if the field is a syntactic descendent of the current node (i.e.
1078 -- its parent is Node N).
1080 procedure Visit_Itype (Old_Itype : Entity_Id);
1081 -- Called during first phase to visit subsidiary fields of a defining
1082 -- Itype, and also create a copy and make an entry in the replacement
1083 -- map for the new copy.
1085 procedure Visit_List (L : List_Id);
1086 -- Called during first phase to visit all elements of a List
1088 procedure Visit_Node (N : Node_Or_Entity_Id);
1089 -- Called during first phase to visit a node and all its subtrees
1095 function Assoc (N : Node_Or_Entity_Id) return Node_Id is
1100 if not Has_Extension (N) or else No (Actual_Map) then
1103 elsif NCT_Hash_Tables_Used then
1104 Ent := NCT_Assoc.Get (Entity_Id (N));
1106 if Present (Ent) then
1112 -- No hash table used, do serial search
1115 E := First_Elmt (Actual_Map);
1116 while Present (E) loop
1117 if Node (E) = N then
1118 return Node (Next_Elmt (E));
1120 E := Next_Elmt (Next_Elmt (E));
1128 ---------------------------
1129 -- Build_NCT_Hash_Tables --
1130 ---------------------------
1132 procedure Build_NCT_Hash_Tables is
1136 if NCT_Hash_Table_Setup then
1138 NCT_Itype_Assoc.Reset;
1141 Elmt := First_Elmt (Actual_Map);
1142 while Present (Elmt) loop
1145 NCT_Assoc.Set (Ent, Node (Elmt));
1148 if Is_Type (Ent) then
1150 Anode : constant Entity_Id :=
1151 Associated_Node_For_Itype (Ent);
1154 if Present (Anode) then
1155 NCT_Itype_Assoc.Set (Anode, Node (Elmt));
1161 NCT_Hash_Tables_Used := True;
1162 NCT_Hash_Table_Setup := True;
1163 end Build_NCT_Hash_Tables;
1165 ---------------------------------
1166 -- Copy_Elist_With_Replacement --
1167 ---------------------------------
1169 function Copy_Elist_With_Replacement
1170 (Old_Elist : Elist_Id)
1174 New_Elist : Elist_Id;
1177 if No (Old_Elist) then
1181 New_Elist := New_Elmt_List;
1182 M := First_Elmt (Old_Elist);
1184 while Present (M) loop
1185 Append_Elmt (Copy_Node_With_Replacement (Node (M)), New_Elist);
1191 end Copy_Elist_With_Replacement;
1193 ---------------------------------
1194 -- Copy_Itype_With_Replacement --
1195 ---------------------------------
1197 -- This routine exactly parallels its phase one analog Visit_Itype,
1198 -- and like that routine, knows far too many semantic details about
1199 -- the descendents of Itypes and whether they need copying or not.
1201 procedure Copy_Itype_With_Replacement (New_Itype : Entity_Id) is
1203 -- Translate Next_Entity, Scope and Etype fields, in case they
1204 -- reference entities that have been mapped into copies.
1206 Set_Next_Entity (New_Itype, Assoc (Next_Entity (New_Itype)));
1207 Set_Etype (New_Itype, Assoc (Etype (New_Itype)));
1209 if Present (New_Scope) then
1210 Set_Scope (New_Itype, New_Scope);
1212 Set_Scope (New_Itype, Assoc (Scope (New_Itype)));
1215 -- Copy referenced fields
1217 if Is_Discrete_Type (New_Itype) then
1218 Set_Scalar_Range (New_Itype,
1219 Copy_Node_With_Replacement (Scalar_Range (New_Itype)));
1221 elsif Has_Discriminants (Base_Type (New_Itype)) then
1222 Set_Discriminant_Constraint (New_Itype,
1223 Copy_Elist_With_Replacement
1224 (Discriminant_Constraint (New_Itype)));
1226 elsif Is_Array_Type (New_Itype) then
1227 if Present (First_Index (New_Itype)) then
1228 Set_First_Index (New_Itype,
1229 First (Copy_List_With_Replacement
1230 (List_Containing (First_Index (New_Itype)))));
1233 if Is_Packed (New_Itype) then
1234 Set_Packed_Array_Type (New_Itype,
1235 Copy_Node_With_Replacement
1236 (Packed_Array_Type (New_Itype)));
1239 end Copy_Itype_With_Replacement;
1241 --------------------------------
1242 -- Copy_List_With_Replacement --
1243 --------------------------------
1245 function Copy_List_With_Replacement
1246 (Old_List : List_Id)
1253 if Old_List = No_List then
1257 New_List := Empty_List;
1258 E := First (Old_List);
1259 while Present (E) loop
1260 Append (Copy_Node_With_Replacement (E), New_List);
1266 end Copy_List_With_Replacement;
1268 --------------------------------
1269 -- Copy_Node_With_Replacement --
1270 --------------------------------
1272 function Copy_Node_With_Replacement
1273 (Old_Node : Node_Id)
1278 function Copy_Field_With_Replacement
1281 -- Given Field, which is a field of Old_Node, return a copy of it
1282 -- if it is a syntactic field (i.e. its parent is Node), setting
1283 -- the parent of the copy to poit to New_Node. Otherwise returns
1284 -- the field (possibly mapped if it is an entity).
1286 ---------------------------------
1287 -- Copy_Field_With_Replacement --
1288 ---------------------------------
1290 function Copy_Field_With_Replacement
1295 if Field = Union_Id (Empty) then
1298 elsif Field in Node_Range then
1300 Old_N : constant Node_Id := Node_Id (Field);
1304 -- If syntactic field, as indicated by the parent pointer
1305 -- being set, then copy the referenced node recursively.
1307 if Parent (Old_N) = Old_Node then
1308 New_N := Copy_Node_With_Replacement (Old_N);
1310 if New_N /= Old_N then
1311 Set_Parent (New_N, New_Node);
1314 -- For semantic fields, update possible entity reference
1315 -- from the replacement map.
1318 New_N := Assoc (Old_N);
1321 return Union_Id (New_N);
1324 elsif Field in List_Range then
1326 Old_L : constant List_Id := List_Id (Field);
1330 -- If syntactic field, as indicated by the parent pointer,
1331 -- then recursively copy the entire referenced list.
1333 if Parent (Old_L) = Old_Node then
1334 New_L := Copy_List_With_Replacement (Old_L);
1335 Set_Parent (New_L, New_Node);
1337 -- For semantic list, just returned unchanged
1343 return Union_Id (New_L);
1346 -- Anything other than a list or a node is returned unchanged
1351 end Copy_Field_With_Replacement;
1353 -- Start of processing for Copy_Node_With_Replacement
1356 if Old_Node <= Empty_Or_Error then
1359 elsif Has_Extension (Old_Node) then
1360 return Assoc (Old_Node);
1363 Nodes.Increment_Last;
1364 New_Node := Nodes.Last;
1365 Nodes.Table (New_Node) := Nodes.Table (Old_Node);
1366 Nodes.Table (New_Node).Link := Empty_List_Or_Node;
1367 Nodes.Table (New_Node).In_List := False;
1368 Node_Count := Node_Count + 1;
1370 Orig_Nodes.Increment_Last;
1371 Allocate_List_Tables (Nodes.Last);
1373 Orig_Nodes.Table (Nodes.Last) := Nodes.Last;
1375 -- If the node we are copying is the associated node of a
1376 -- previously copied Itype, then adjust the associated node
1377 -- of the copy of that Itype accordingly.
1379 if Present (Actual_Map) then
1385 -- Case of hash table used
1387 if NCT_Hash_Tables_Used then
1388 Ent := NCT_Itype_Assoc.Get (Old_Node);
1390 if Present (Ent) then
1391 Set_Associated_Node_For_Itype (Ent, New_Node);
1394 -- Case of no hash table used
1397 E := First_Elmt (Actual_Map);
1398 while Present (E) loop
1399 if Is_Itype (Node (E))
1401 Old_Node = Associated_Node_For_Itype (Node (E))
1403 Set_Associated_Node_For_Itype
1404 (Node (Next_Elmt (E)), New_Node);
1407 E := Next_Elmt (Next_Elmt (E));
1413 -- Recursively copy descendents
1416 (New_Node, Copy_Field_With_Replacement (Field1 (New_Node)));
1418 (New_Node, Copy_Field_With_Replacement (Field2 (New_Node)));
1420 (New_Node, Copy_Field_With_Replacement (Field3 (New_Node)));
1422 (New_Node, Copy_Field_With_Replacement (Field4 (New_Node)));
1424 (New_Node, Copy_Field_With_Replacement (Field5 (New_Node)));
1426 -- If the original is marked as a rewrite insertion, then unmark
1427 -- the copy, since we inserted the original, not the copy.
1429 Nodes.Table (New_Node).Rewrite_Ins := False;
1431 -- Adjust Sloc of new node if necessary
1433 if New_Sloc /= No_Location then
1434 Set_Sloc (New_Node, New_Sloc);
1436 -- If we adjust the Sloc, then we are essentially making
1437 -- a completely new node, so the Comes_From_Source flag
1438 -- should be reset to the proper default value.
1440 Nodes.Table (New_Node).Comes_From_Source :=
1441 Default_Node.Comes_From_Source;
1444 -- Reset First_Real_Statement for Handled_Sequence_Of_Statements.
1445 -- The replacement mechanism applies to entities, and is not used
1446 -- here. Eventually we may need a more general graph-copying
1447 -- routine. For now, do a sequential search to find desired node.
1449 if Nkind (Old_Node) = N_Handled_Sequence_Of_Statements
1450 and then Present (First_Real_Statement (Old_Node))
1453 Old_F : constant Node_Id := First_Real_Statement (Old_Node);
1457 N1 := First (Statements (Old_Node));
1458 N2 := First (Statements (New_Node));
1460 while N1 /= Old_F loop
1465 Set_First_Real_Statement (New_Node, N2);
1470 -- All done, return copied node
1473 end Copy_Node_With_Replacement;
1479 procedure Visit_Elist (E : Elist_Id) is
1484 Elmt := First_Elmt (E);
1486 while Elmt /= No_Elmt loop
1487 Visit_Node (Node (Elmt));
1497 procedure Visit_Field (F : Union_Id; N : Node_Id) is
1499 if F = Union_Id (Empty) then
1502 elsif F in Node_Range then
1504 -- Copy node if it is syntactic, i.e. its parent pointer is
1505 -- set to point to the field that referenced it (certain
1506 -- Itypes will also meet this criterion, which is fine, since
1507 -- these are clearly Itypes that do need to be copied, since
1508 -- we are copying their parent.)
1510 if Parent (Node_Id (F)) = N then
1511 Visit_Node (Node_Id (F));
1514 -- Another case, if we are pointing to an Itype, then we want
1515 -- to copy it if its associated node is somewhere in the tree
1518 -- Note: the exclusion of self-referential copies is just an
1519 -- optimization, since the search of the already copied list
1520 -- would catch it, but it is a common case (Etype pointing
1521 -- to itself for an Itype that is a base type).
1523 elsif Has_Extension (Node_Id (F))
1524 and then Is_Itype (Entity_Id (F))
1525 and then Node_Id (F) /= N
1531 P := Associated_Node_For_Itype (Node_Id (F));
1532 while Present (P) loop
1534 Visit_Node (Node_Id (F));
1541 -- An Itype whose parent is not being copied definitely
1542 -- should NOT be copied, since it does not belong in any
1543 -- sense to the copied subtree.
1549 elsif F in List_Range
1550 and then Parent (List_Id (F)) = N
1552 Visit_List (List_Id (F));
1561 -- Note: we are relying on far too much semantic knowledge in this
1562 -- routine, it really should just do a blind replacement of all
1563 -- fields, or at least a more blind replacement. For example, we
1564 -- do not deal with corresponding record types, and that works
1565 -- because we have no Itypes of task types, but nowhere is there
1566 -- a guarantee that this will always be the case. ???
1568 procedure Visit_Itype (Old_Itype : Entity_Id) is
1569 New_Itype : Entity_Id;
1574 -- Itypes that describe the designated type of access to subprograms
1575 -- have the structure of subprogram declarations, with signatures,
1576 -- etc. Either we duplicate the signatures completely, or choose to
1577 -- share such itypes, which is fine because their elaboration will
1578 -- have no side effects. In any case, this is additional semantic
1579 -- information that seems awkward to have in atree.
1581 if Ekind (Old_Itype) = E_Subprogram_Type then
1585 New_Itype := New_Copy (Old_Itype);
1587 -- If our associated node is an entity that has already been copied,
1588 -- then set the associated node of the copy to point to the right
1589 -- copy. If we have copied an Itype that is itself the associated
1590 -- node of some previously copied Itype, then we set the right
1591 -- pointer in the other direction.
1593 if Present (Actual_Map) then
1595 -- Case of hash tables used
1597 if NCT_Hash_Tables_Used then
1599 Ent := NCT_Assoc.Get (Associated_Node_For_Itype (Old_Itype));
1600 if Present (Ent) then
1601 Set_Associated_Node_For_Itype (New_Itype, Ent);
1604 Ent := NCT_Itype_Assoc.Get (Old_Itype);
1605 if Present (Ent) then
1606 Set_Associated_Node_For_Itype (Ent, New_Itype);
1609 -- Case of hash tables not used
1612 E := First_Elmt (Actual_Map);
1613 while Present (E) loop
1614 if Associated_Node_For_Itype (Old_Itype) = Node (E) then
1615 Set_Associated_Node_For_Itype
1616 (New_Itype, Node (Next_Elmt (E)));
1619 if Is_Type (Node (E))
1621 Old_Itype = Associated_Node_For_Itype (Node (E))
1623 Set_Associated_Node_For_Itype
1624 (Node (Next_Elmt (E)), New_Itype);
1627 E := Next_Elmt (Next_Elmt (E));
1632 if Present (Freeze_Node (New_Itype)) then
1633 Set_Is_Frozen (New_Itype, False);
1634 Set_Freeze_Node (New_Itype, Empty);
1637 -- Add new association to map
1639 if No (Actual_Map) then
1640 Actual_Map := New_Elmt_List;
1643 Append_Elmt (Old_Itype, Actual_Map);
1644 Append_Elmt (New_Itype, Actual_Map);
1646 if NCT_Hash_Tables_Used then
1647 NCT_Assoc.Set (Old_Itype, New_Itype);
1650 NCT_Table_Entries := NCT_Table_Entries + 1;
1652 if NCT_Table_Entries > NCT_Hash_Threshhold then
1653 Build_NCT_Hash_Tables;
1657 -- If a record subtype is simply copied, the entity list will be
1658 -- shared. Thus cloned_Subtype must be set to indicate the sharing.
1660 if Ekind (Old_Itype) = E_Record_Subtype
1661 or else Ekind (Old_Itype) = E_Class_Wide_Subtype
1663 Set_Cloned_Subtype (New_Itype, Old_Itype);
1666 -- Visit descendents that eventually get copied
1668 Visit_Field (Union_Id (Etype (Old_Itype)), Old_Itype);
1670 if Is_Discrete_Type (Old_Itype) then
1671 Visit_Field (Union_Id (Scalar_Range (Old_Itype)), Old_Itype);
1673 elsif Has_Discriminants (Base_Type (Old_Itype)) then
1674 -- ??? This should involve call to Visit_Field.
1675 Visit_Elist (Discriminant_Constraint (Old_Itype));
1677 elsif Is_Array_Type (Old_Itype) then
1678 if Present (First_Index (Old_Itype)) then
1679 Visit_Field (Union_Id (List_Containing
1680 (First_Index (Old_Itype))),
1684 if Is_Packed (Old_Itype) then
1685 Visit_Field (Union_Id (Packed_Array_Type (Old_Itype)),
1695 procedure Visit_List (L : List_Id) is
1699 if L /= No_List then
1702 while Present (N) loop
1713 procedure Visit_Node (N : Node_Or_Entity_Id) is
1715 -- Start of processing for Visit_Node
1718 -- Handle case of an Itype, which must be copied
1720 if Has_Extension (N)
1721 and then Is_Itype (N)
1723 -- Nothing to do if already in the list. This can happen with an
1724 -- Itype entity that appears more than once in the tree.
1725 -- Note that we do not want to visit descendents in this case.
1727 -- Test for already in list when hash table is used
1729 if NCT_Hash_Tables_Used then
1730 if Present (NCT_Assoc.Get (Entity_Id (N))) then
1734 -- Test for already in list when hash table not used
1741 if Present (Actual_Map) then
1742 E := First_Elmt (Actual_Map);
1743 while Present (E) loop
1744 if Node (E) = N then
1747 E := Next_Elmt (Next_Elmt (E));
1757 -- Visit descendents
1759 Visit_Field (Field1 (N), N);
1760 Visit_Field (Field2 (N), N);
1761 Visit_Field (Field3 (N), N);
1762 Visit_Field (Field4 (N), N);
1763 Visit_Field (Field5 (N), N);
1766 -- Start of processing for New_Copy_Tree
1771 -- See if we should use hash table
1773 if No (Actual_Map) then
1774 NCT_Hash_Tables_Used := False;
1781 NCT_Table_Entries := 0;
1782 Elmt := First_Elmt (Actual_Map);
1783 while Present (Elmt) loop
1784 NCT_Table_Entries := NCT_Table_Entries + 1;
1789 if NCT_Table_Entries > NCT_Hash_Threshhold then
1790 Build_NCT_Hash_Tables;
1792 NCT_Hash_Tables_Used := False;
1797 -- Hash table set up if required, now start phase one by visiting
1798 -- top node (we will recursively visit the descendents).
1800 Visit_Node (Source);
1802 -- Now the second phase of the copy can start. First we process
1803 -- all the mapped entities, copying their descendents.
1805 if Present (Actual_Map) then
1808 New_Itype : Entity_Id;
1811 Elmt := First_Elmt (Actual_Map);
1812 while Present (Elmt) loop
1814 New_Itype := Node (Elmt);
1815 Copy_Itype_With_Replacement (New_Itype);
1821 -- Now we can copy the actual tree
1823 return Copy_Node_With_Replacement (Source);
1831 (New_Node_Kind : Node_Kind;
1832 New_Sloc : Source_Ptr)
1837 procedure New_Entity_Debugging_Output;
1838 -- Debugging routine for debug flag N
1840 ---------------------------------
1841 -- New_Entity_Debugging_Output --
1842 ---------------------------------
1844 procedure New_Entity_Debugging_Output is
1846 if Debug_Flag_N then
1847 Write_Str ("Allocate entity, Id = ");
1848 Write_Int (Int (Nodes.Last));
1850 Write_Location (New_Sloc);
1852 Write_Str (Node_Kind'Image (New_Node_Kind));
1855 end New_Entity_Debugging_Output;
1857 pragma Inline (New_Entity_Debugging_Output);
1859 -- Start of processing for New_Entity
1862 pragma Assert (New_Node_Kind in N_Entity);
1864 Nodes.Increment_Last;
1867 -- If this is a node with a real location and we are generating
1868 -- source nodes, then reset Current_Error_Node. This is useful
1869 -- if we bomb during parsing to get a error location for the bomb.
1871 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1872 Current_Error_Node := Ent;
1875 Nodes.Table (Nodes.Last) := Default_Node;
1876 Nodes.Table (Nodes.Last).Nkind := New_Node_Kind;
1877 Nodes.Table (Nodes.Last).Sloc := New_Sloc;
1878 pragma Debug (New_Entity_Debugging_Output);
1880 Orig_Nodes.Increment_Last;
1881 Orig_Nodes.Table (Nodes.Last) := Nodes.Last;
1883 Nodes.Increment_Last;
1884 Nodes.Table (Nodes.Last) := Default_Node_Extension;
1886 Nodes.Increment_Last;
1887 Nodes.Table (Nodes.Last) := Default_Node_Extension;
1889 Nodes.Increment_Last;
1890 Nodes.Table (Nodes.Last) := Default_Node_Extension;
1892 Orig_Nodes.Set_Last (Nodes.Last);
1893 Allocate_List_Tables (Nodes.Last);
1894 Node_Count := Node_Count + 1;
1903 (New_Node_Kind : Node_Kind;
1904 New_Sloc : Source_Ptr)
1909 procedure New_Node_Debugging_Output;
1910 -- Debugging routine for debug flag N
1912 --------------------------
1913 -- New_Debugging_Output --
1914 --------------------------
1916 procedure New_Node_Debugging_Output is
1918 if Debug_Flag_N then
1919 Write_Str ("Allocate node, Id = ");
1920 Write_Int (Int (Nodes.Last));
1922 Write_Location (New_Sloc);
1924 Write_Str (Node_Kind'Image (New_Node_Kind));
1927 end New_Node_Debugging_Output;
1929 pragma Inline (New_Node_Debugging_Output);
1931 -- Start of processing for New_Node
1934 pragma Assert (New_Node_Kind not in N_Entity);
1935 Nodes.Increment_Last;
1936 Nodes.Table (Nodes.Last) := Default_Node;
1937 Nodes.Table (Nodes.Last).Nkind := New_Node_Kind;
1938 Nodes.Table (Nodes.Last).Sloc := New_Sloc;
1939 pragma Debug (New_Node_Debugging_Output);
1942 -- If this is a node with a real location and we are generating
1943 -- source nodes, then reset Current_Error_Node. This is useful
1944 -- if we bomb during parsing to get a error location for the bomb.
1946 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1947 Current_Error_Node := Nod;
1950 Node_Count := Node_Count + 1;
1951 Orig_Nodes.Increment_Last;
1952 Allocate_List_Tables (Nodes.Last);
1953 Orig_Nodes.Table (Nodes.Last) := Nodes.Last;
1961 function Nkind (N : Node_Id) return Node_Kind is
1963 return Nodes.Table (N).Nkind;
1970 function No (N : Node_Id) return Boolean is
1979 function Nodes_Address return System.Address is
1981 return Nodes.Table (First_Node_Id)'Address;
1988 function Num_Nodes return Nat is
1997 function Original_Node (Node : Node_Id) return Node_Id is
1999 return Orig_Nodes.Table (Node);
2006 function Paren_Count (N : Node_Id) return Paren_Count_Type is
2007 C : Paren_Count_Type := 0;
2010 pragma Assert (N in Nodes.First .. Nodes.Last);
2012 if Nodes.Table (N).Pflag1 then
2016 if Nodes.Table (N).Pflag2 then
2027 function Parent (N : Node_Id) return Node_Id is
2029 if Is_List_Member (N) then
2030 return Parent (List_Containing (N));
2032 return Node_Id (Nodes.Table (N).Link);
2040 function Present (N : Node_Id) return Boolean is
2045 --------------------------------
2046 -- Preserve_Comes_From_Source --
2047 --------------------------------
2049 procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is
2051 Nodes.Table (NewN).Comes_From_Source :=
2052 Nodes.Table (OldN).Comes_From_Source;
2053 end Preserve_Comes_From_Source;
2059 function Relocate_Node (Source : Node_Id) return Node_Id is
2067 New_Node := New_Copy (Source);
2068 Fix_Parent (Field1 (Source), Source, New_Node);
2069 Fix_Parent (Field2 (Source), Source, New_Node);
2070 Fix_Parent (Field3 (Source), Source, New_Node);
2071 Fix_Parent (Field4 (Source), Source, New_Node);
2072 Fix_Parent (Field5 (Source), Source, New_Node);
2074 -- We now set the parent of the new node to be the same as the
2075 -- parent of the source. Almost always this parent will be
2076 -- replaced by a new value when the relocated node is reattached
2077 -- to the tree, but by doing it now, we ensure that this node is
2078 -- not even temporarily disconnected from the tree. Note that this
2079 -- does not happen free, because in the list case, the parent does
2082 Set_Parent (New_Node, Parent (Source));
2084 -- If the node being relocated was a rewriting of some original
2085 -- node, then the relocated node has the same original node.
2087 if Orig_Nodes.Table (Source) /= Source then
2088 Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source);
2098 procedure Replace (Old_Node, New_Node : Node_Id) is
2099 Old_Link : constant Union_Id := Nodes.Table (Old_Node).Link;
2100 Old_InL : constant Boolean := Nodes.Table (Old_Node).In_List;
2101 Old_Post : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
2102 Old_CFS : constant Boolean := Nodes.Table (Old_Node).Comes_From_Source;
2106 (not Has_Extension (Old_Node)
2107 and not Has_Extension (New_Node)
2108 and not Nodes.Table (New_Node).In_List);
2110 -- Do copy, preserving link and in list status and comes from source
2112 Nodes.Table (Old_Node) := Nodes.Table (New_Node);
2113 Nodes.Table (Old_Node).Link := Old_Link;
2114 Nodes.Table (Old_Node).In_List := Old_InL;
2115 Nodes.Table (Old_Node).Comes_From_Source := Old_CFS;
2116 Nodes.Table (Old_Node).Error_Posted := Old_Post;
2118 -- Fix parents of substituted node, since it has changed identity
2120 Fix_Parent (Field1 (Old_Node), New_Node, Old_Node);
2121 Fix_Parent (Field2 (Old_Node), New_Node, Old_Node);
2122 Fix_Parent (Field3 (Old_Node), New_Node, Old_Node);
2123 Fix_Parent (Field4 (Old_Node), New_Node, Old_Node);
2124 Fix_Parent (Field5 (Old_Node), New_Node, Old_Node);
2126 -- Since we are doing a replace, we assume that the original node
2127 -- is intended to become the new replaced node. The call would be
2128 -- to Rewrite_Substitute_Node if there were an intention to save
2129 -- the original node.
2131 Orig_Nodes.Table (Old_Node) := Old_Node;
2133 -- Finally delete the source, since it is now copied
2135 Delete_Node (New_Node);
2142 procedure Rewrite (Old_Node, New_Node : Node_Id) is
2144 Old_Link : constant Union_Id := Nodes.Table (Old_Node).Link;
2145 Old_In_List : constant Boolean := Nodes.Table (Old_Node).In_List;
2146 Old_Error_P : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
2147 -- These three fields are always preserved in the new node
2149 Old_Paren_Count : Paren_Count_Type;
2150 Old_Must_Not_Freeze : Boolean;
2151 -- These fields are preserved in the new node only if the new node
2152 -- and the old node are both subexpression nodes.
2154 -- Note: it is a violation of abstraction levels for Must_Not_Freeze
2155 -- to be referenced like this. ???
2161 (not Has_Extension (Old_Node)
2162 and not Has_Extension (New_Node)
2163 and not Nodes.Table (New_Node).In_List);
2165 if Nkind (Old_Node) in N_Subexpr then
2166 Old_Paren_Count := Paren_Count (Old_Node);
2167 Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node);
2169 Old_Paren_Count := 0;
2170 Old_Must_Not_Freeze := False;
2173 -- Allocate a new node, to be used to preserve the original contents
2174 -- of the Old_Node, for possible later retrival by Original_Node and
2175 -- make an entry in the Orig_Nodes table. This is only done if we have
2176 -- not already rewritten the node, as indicated by an Orig_Nodes entry
2177 -- that does not reference the Old_Node.
2179 if Orig_Nodes.Table (Old_Node) = Old_Node then
2180 Nodes.Increment_Last;
2181 Sav_Node := Nodes.Last;
2182 Nodes.Table (Sav_Node) := Nodes.Table (Old_Node);
2183 Nodes.Table (Sav_Node).In_List := False;
2184 Nodes.Table (Sav_Node).Link := Union_Id (Parent (Old_Node));
2186 Orig_Nodes.Increment_Last;
2187 Allocate_List_Tables (Nodes.Last);
2189 Orig_Nodes.Table (Sav_Node) := Sav_Node;
2190 Orig_Nodes.Table (Old_Node) := Sav_Node;
2193 -- Copy substitute node into place, preserving old fields as required
2195 Nodes.Table (Old_Node) := Nodes.Table (New_Node);
2196 Nodes.Table (Old_Node).Link := Old_Link;
2197 Nodes.Table (Old_Node).In_List := Old_In_List;
2198 Nodes.Table (Old_Node).Error_Posted := Old_Error_P;
2200 if Nkind (New_Node) in N_Subexpr then
2201 Set_Paren_Count (Old_Node, Old_Paren_Count);
2202 Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze);
2205 Fix_Parent (Field1 (Old_Node), New_Node, Old_Node);
2206 Fix_Parent (Field2 (Old_Node), New_Node, Old_Node);
2207 Fix_Parent (Field3 (Old_Node), New_Node, Old_Node);
2208 Fix_Parent (Field4 (Old_Node), New_Node, Old_Node);
2209 Fix_Parent (Field5 (Old_Node), New_Node, Old_Node);
2216 procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is
2218 Nodes.Table (N).Analyzed := Val;
2221 ---------------------------
2222 -- Set_Comes_From_Source --
2223 ---------------------------
2225 procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is
2227 pragma Assert (N in Nodes.First .. Nodes.Last);
2228 Nodes.Table (N).Comes_From_Source := Val;
2229 end Set_Comes_From_Source;
2231 -----------------------------------
2232 -- Set_Comes_From_Source_Default --
2233 -----------------------------------
2235 procedure Set_Comes_From_Source_Default (Default : Boolean) is
2237 Default_Node.Comes_From_Source := Default;
2238 end Set_Comes_From_Source_Default;
2240 --------------------
2241 -- Set_Convention --
2242 --------------------
2244 procedure Set_Convention (E : Entity_Id; Val : Convention_Id) is
2246 pragma Assert (Nkind (E) in N_Entity);
2249 (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention :=
2257 procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is
2259 pragma Assert (Nkind (E) in N_Entity);
2260 Nodes.Table (E + 1).Nkind := E_To_N (Val);
2263 ----------------------
2264 -- Set_Error_Posted --
2265 ----------------------
2267 procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is
2269 Nodes.Table (N).Error_Posted := Val;
2270 end Set_Error_Posted;
2272 ---------------------
2273 -- Set_Paren_Count --
2274 ---------------------
2276 procedure Set_Paren_Count (N : Node_Id; Val : Paren_Count_Type) is
2278 pragma Assert (Nkind (N) in N_Subexpr);
2279 Nodes.Table (N).Pflag1 := (Val mod 2 /= 0);
2280 Nodes.Table (N).Pflag2 := (Val >= 2);
2281 end Set_Paren_Count;
2287 procedure Set_Parent (N : Node_Id; Val : Node_Id) is
2289 pragma Assert (not Nodes.Table (N).In_List);
2290 Nodes.Table (N).Link := Union_Id (Val);
2297 procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is
2299 Nodes.Table (N).Sloc := Val;
2306 function Sloc (N : Node_Id) return Source_Ptr is
2308 return Nodes.Table (N).Sloc;
2315 function Traverse_Func (Node : Node_Id) return Traverse_Result is
2317 function Traverse_Field (Fld : Union_Id) return Traverse_Result;
2318 -- Fld is one of the fields of Node. If the field points to a
2319 -- syntactic node or list, then this node or list is traversed,
2320 -- and the result is the result of this traversal. Otherwise
2321 -- a value of True is returned with no processing.
2323 --------------------
2324 -- Traverse_Field --
2325 --------------------
2327 function Traverse_Field (Fld : Union_Id) return Traverse_Result is
2329 if Fld = Union_Id (Empty) then
2332 -- Descendent is a node
2334 elsif Fld in Node_Range then
2336 -- Traverse descendent that is syntactic subtree node
2338 if Parent (Node_Id (Fld)) = Node
2339 or else Original_Node (Parent (Node_Id (Fld))) = Node
2341 return Traverse_Func (Node_Id (Fld));
2343 -- Node that is not a syntactic subtree
2349 -- Descendent is a list
2351 elsif Fld in List_Range then
2353 -- Traverse descendent that is a syntactic subtree list
2355 if Parent (List_Id (Fld)) = Node
2356 or else Original_Node (Parent (List_Id (Fld))) = Node
2359 Elmt : Node_Id := First (List_Id (Fld));
2361 while Present (Elmt) loop
2362 if Traverse_Func (Elmt) = Abandon then
2372 -- List that is not a syntactic subtree
2378 -- Field was not a node or a list
2385 -- Start of processing for Traverse_Func
2388 case Process (Node) is
2396 if Traverse_Field (Union_Id (Field1 (Node))) = Abandon
2398 Traverse_Field (Union_Id (Field2 (Node))) = Abandon
2400 Traverse_Field (Union_Id (Field3 (Node))) = Abandon
2402 Traverse_Field (Union_Id (Field4 (Node))) = Abandon
2404 Traverse_Field (Union_Id (Field5 (Node))) = Abandon
2414 Onode : constant Node_Id := Original_Node (Node);
2417 if Traverse_Field (Union_Id (Field1 (Onode))) = Abandon
2419 Traverse_Field (Union_Id (Field2 (Onode))) = Abandon
2421 Traverse_Field (Union_Id (Field3 (Onode))) = Abandon
2423 Traverse_Field (Union_Id (Field4 (Onode))) = Abandon
2425 Traverse_Field (Union_Id (Field5 (Onode))) = Abandon
2440 procedure Traverse_Proc (Node : Node_Id) is
2441 function Traverse is new Traverse_Func (Process);
2442 Discard : Traverse_Result;
2443 pragma Warnings (Off, Discard);
2446 Discard := Traverse (Node);
2453 procedure Tree_Read is
2455 Tree_Read_Int (Node_Count);
2457 Orig_Nodes.Tree_Read;
2464 procedure Tree_Write is
2466 Tree_Write_Int (Node_Count);
2468 Orig_Nodes.Tree_Write;
2471 ------------------------------
2472 -- Unchecked Access Package --
2473 ------------------------------
2475 package body Unchecked_Access is
2477 function Field1 (N : Node_Id) return Union_Id is
2479 pragma Assert (N in Nodes.First .. Nodes.Last);
2480 return Nodes.Table (N).Field1;
2483 function Field2 (N : Node_Id) return Union_Id is
2485 pragma Assert (N in Nodes.First .. Nodes.Last);
2486 return Nodes.Table (N).Field2;
2489 function Field3 (N : Node_Id) return Union_Id is
2491 pragma Assert (N in Nodes.First .. Nodes.Last);
2492 return Nodes.Table (N).Field3;
2495 function Field4 (N : Node_Id) return Union_Id is
2497 pragma Assert (N in Nodes.First .. Nodes.Last);
2498 return Nodes.Table (N).Field4;
2501 function Field5 (N : Node_Id) return Union_Id is
2503 pragma Assert (N in Nodes.First .. Nodes.Last);
2504 return Nodes.Table (N).Field5;
2507 function Field6 (N : Node_Id) return Union_Id is
2509 pragma Assert (Nkind (N) in N_Entity);
2510 return Nodes.Table (N + 1).Field6;
2513 function Field7 (N : Node_Id) return Union_Id is
2515 pragma Assert (Nkind (N) in N_Entity);
2516 return Nodes.Table (N + 1).Field7;
2519 function Field8 (N : Node_Id) return Union_Id is
2521 pragma Assert (Nkind (N) in N_Entity);
2522 return Nodes.Table (N + 1).Field8;
2525 function Field9 (N : Node_Id) return Union_Id is
2527 pragma Assert (Nkind (N) in N_Entity);
2528 return Nodes.Table (N + 1).Field9;
2531 function Field10 (N : Node_Id) return Union_Id is
2533 pragma Assert (Nkind (N) in N_Entity);
2534 return Nodes.Table (N + 1).Field10;
2537 function Field11 (N : Node_Id) return Union_Id is
2539 pragma Assert (Nkind (N) in N_Entity);
2540 return Nodes.Table (N + 1).Field11;
2543 function Field12 (N : Node_Id) return Union_Id is
2545 pragma Assert (Nkind (N) in N_Entity);
2546 return Nodes.Table (N + 1).Field12;
2549 function Field13 (N : Node_Id) return Union_Id is
2551 pragma Assert (Nkind (N) in N_Entity);
2552 return Nodes.Table (N + 2).Field6;
2555 function Field14 (N : Node_Id) return Union_Id is
2557 pragma Assert (Nkind (N) in N_Entity);
2558 return Nodes.Table (N + 2).Field7;
2561 function Field15 (N : Node_Id) return Union_Id is
2563 pragma Assert (Nkind (N) in N_Entity);
2564 return Nodes.Table (N + 2).Field8;
2567 function Field16 (N : Node_Id) return Union_Id is
2569 pragma Assert (Nkind (N) in N_Entity);
2570 return Nodes.Table (N + 2).Field9;
2573 function Field17 (N : Node_Id) return Union_Id is
2575 pragma Assert (Nkind (N) in N_Entity);
2576 return Nodes.Table (N + 2).Field10;
2579 function Field18 (N : Node_Id) return Union_Id is
2581 pragma Assert (Nkind (N) in N_Entity);
2582 return Nodes.Table (N + 2).Field11;
2585 function Field19 (N : Node_Id) return Union_Id is
2587 pragma Assert (Nkind (N) in N_Entity);
2588 return Nodes.Table (N + 3).Field6;
2591 function Field20 (N : Node_Id) return Union_Id is
2593 pragma Assert (Nkind (N) in N_Entity);
2594 return Nodes.Table (N + 3).Field7;
2597 function Field21 (N : Node_Id) return Union_Id is
2599 pragma Assert (Nkind (N) in N_Entity);
2600 return Nodes.Table (N + 3).Field8;
2603 function Field22 (N : Node_Id) return Union_Id is
2605 pragma Assert (Nkind (N) in N_Entity);
2606 return Nodes.Table (N + 3).Field9;
2609 function Field23 (N : Node_Id) return Union_Id is
2611 pragma Assert (Nkind (N) in N_Entity);
2612 return Nodes.Table (N + 3).Field10;
2615 function Node1 (N : Node_Id) return Node_Id is
2617 pragma Assert (N in Nodes.First .. Nodes.Last);
2618 return Node_Id (Nodes.Table (N).Field1);
2621 function Node2 (N : Node_Id) return Node_Id is
2623 pragma Assert (N in Nodes.First .. Nodes.Last);
2624 return Node_Id (Nodes.Table (N).Field2);
2627 function Node3 (N : Node_Id) return Node_Id is
2629 pragma Assert (N in Nodes.First .. Nodes.Last);
2630 return Node_Id (Nodes.Table (N).Field3);
2633 function Node4 (N : Node_Id) return Node_Id is
2635 pragma Assert (N in Nodes.First .. Nodes.Last);
2636 return Node_Id (Nodes.Table (N).Field4);
2639 function Node5 (N : Node_Id) return Node_Id is
2641 pragma Assert (N in Nodes.First .. Nodes.Last);
2642 return Node_Id (Nodes.Table (N).Field5);
2645 function Node6 (N : Node_Id) return Node_Id is
2647 pragma Assert (Nkind (N) in N_Entity);
2648 return Node_Id (Nodes.Table (N + 1).Field6);
2651 function Node7 (N : Node_Id) return Node_Id is
2653 pragma Assert (Nkind (N) in N_Entity);
2654 return Node_Id (Nodes.Table (N + 1).Field7);
2657 function Node8 (N : Node_Id) return Node_Id is
2659 pragma Assert (Nkind (N) in N_Entity);
2660 return Node_Id (Nodes.Table (N + 1).Field8);
2663 function Node9 (N : Node_Id) return Node_Id is
2665 pragma Assert (Nkind (N) in N_Entity);
2666 return Node_Id (Nodes.Table (N + 1).Field9);
2669 function Node10 (N : Node_Id) return Node_Id is
2671 pragma Assert (Nkind (N) in N_Entity);
2672 return Node_Id (Nodes.Table (N + 1).Field10);
2675 function Node11 (N : Node_Id) return Node_Id is
2677 pragma Assert (Nkind (N) in N_Entity);
2678 return Node_Id (Nodes.Table (N + 1).Field11);
2681 function Node12 (N : Node_Id) return Node_Id is
2683 pragma Assert (Nkind (N) in N_Entity);
2684 return Node_Id (Nodes.Table (N + 1).Field12);
2687 function Node13 (N : Node_Id) return Node_Id is
2689 pragma Assert (Nkind (N) in N_Entity);
2690 return Node_Id (Nodes.Table (N + 2).Field6);
2693 function Node14 (N : Node_Id) return Node_Id is
2695 pragma Assert (Nkind (N) in N_Entity);
2696 return Node_Id (Nodes.Table (N + 2).Field7);
2699 function Node15 (N : Node_Id) return Node_Id is
2701 pragma Assert (Nkind (N) in N_Entity);
2702 return Node_Id (Nodes.Table (N + 2).Field8);
2705 function Node16 (N : Node_Id) return Node_Id is
2707 pragma Assert (Nkind (N) in N_Entity);
2708 return Node_Id (Nodes.Table (N + 2).Field9);
2711 function Node17 (N : Node_Id) return Node_Id is
2713 pragma Assert (Nkind (N) in N_Entity);
2714 return Node_Id (Nodes.Table (N + 2).Field10);
2717 function Node18 (N : Node_Id) return Node_Id is
2719 pragma Assert (Nkind (N) in N_Entity);
2720 return Node_Id (Nodes.Table (N + 2).Field11);
2723 function Node19 (N : Node_Id) return Node_Id is
2725 pragma Assert (Nkind (N) in N_Entity);
2726 return Node_Id (Nodes.Table (N + 3).Field6);
2729 function Node20 (N : Node_Id) return Node_Id is
2731 pragma Assert (Nkind (N) in N_Entity);
2732 return Node_Id (Nodes.Table (N + 3).Field7);
2735 function Node21 (N : Node_Id) return Node_Id is
2737 pragma Assert (Nkind (N) in N_Entity);
2738 return Node_Id (Nodes.Table (N + 3).Field8);
2741 function Node22 (N : Node_Id) return Node_Id is
2743 pragma Assert (Nkind (N) in N_Entity);
2744 return Node_Id (Nodes.Table (N + 3).Field9);
2747 function Node23 (N : Node_Id) return Node_Id is
2749 pragma Assert (Nkind (N) in N_Entity);
2750 return Node_Id (Nodes.Table (N + 3).Field10);
2753 function List1 (N : Node_Id) return List_Id is
2755 pragma Assert (N in Nodes.First .. Nodes.Last);
2756 return List_Id (Nodes.Table (N).Field1);
2759 function List2 (N : Node_Id) return List_Id is
2761 pragma Assert (N in Nodes.First .. Nodes.Last);
2762 return List_Id (Nodes.Table (N).Field2);
2765 function List3 (N : Node_Id) return List_Id is
2767 pragma Assert (N in Nodes.First .. Nodes.Last);
2768 return List_Id (Nodes.Table (N).Field3);
2771 function List4 (N : Node_Id) return List_Id is
2773 pragma Assert (N in Nodes.First .. Nodes.Last);
2774 return List_Id (Nodes.Table (N).Field4);
2777 function List5 (N : Node_Id) return List_Id is
2779 pragma Assert (N in Nodes.First .. Nodes.Last);
2780 return List_Id (Nodes.Table (N).Field5);
2783 function List10 (N : Node_Id) return List_Id is
2785 pragma Assert (Nkind (N) in N_Entity);
2786 return List_Id (Nodes.Table (N + 1).Field10);
2789 function List14 (N : Node_Id) return List_Id is
2791 pragma Assert (Nkind (N) in N_Entity);
2792 return List_Id (Nodes.Table (N + 2).Field7);
2795 function Elist2 (N : Node_Id) return Elist_Id is
2797 return Elist_Id (Nodes.Table (N).Field2);
2800 function Elist3 (N : Node_Id) return Elist_Id is
2802 return Elist_Id (Nodes.Table (N).Field3);
2805 function Elist4 (N : Node_Id) return Elist_Id is
2807 return Elist_Id (Nodes.Table (N).Field4);
2810 function Elist8 (N : Node_Id) return Elist_Id is
2812 pragma Assert (Nkind (N) in N_Entity);
2813 return Elist_Id (Nodes.Table (N + 1).Field8);
2816 function Elist13 (N : Node_Id) return Elist_Id is
2818 pragma Assert (Nkind (N) in N_Entity);
2819 return Elist_Id (Nodes.Table (N + 2).Field6);
2822 function Elist15 (N : Node_Id) return Elist_Id is
2824 pragma Assert (Nkind (N) in N_Entity);
2825 return Elist_Id (Nodes.Table (N + 2).Field8);
2828 function Elist16 (N : Node_Id) return Elist_Id is
2830 pragma Assert (Nkind (N) in N_Entity);
2831 return Elist_Id (Nodes.Table (N + 2).Field9);
2834 function Elist18 (N : Node_Id) return Elist_Id is
2836 pragma Assert (Nkind (N) in N_Entity);
2837 return Elist_Id (Nodes.Table (N + 2).Field11);
2840 function Elist21 (N : Node_Id) return Elist_Id is
2842 pragma Assert (Nkind (N) in N_Entity);
2843 return Elist_Id (Nodes.Table (N + 3).Field8);
2846 function Elist23 (N : Node_Id) return Elist_Id is
2848 pragma Assert (Nkind (N) in N_Entity);
2849 return Elist_Id (Nodes.Table (N + 3).Field10);
2852 function Name1 (N : Node_Id) return Name_Id is
2854 pragma Assert (N in Nodes.First .. Nodes.Last);
2855 return Name_Id (Nodes.Table (N).Field1);
2858 function Name2 (N : Node_Id) return Name_Id is
2860 pragma Assert (N in Nodes.First .. Nodes.Last);
2861 return Name_Id (Nodes.Table (N).Field2);
2864 function Str3 (N : Node_Id) return String_Id is
2866 pragma Assert (N in Nodes.First .. Nodes.Last);
2867 return String_Id (Nodes.Table (N).Field3);
2870 function Char_Code2 (N : Node_Id) return Char_Code is
2872 pragma Assert (N in Nodes.First .. Nodes.Last);
2873 return Char_Code (Nodes.Table (N).Field2 - Char_Code_Bias);
2876 function Uint3 (N : Node_Id) return Uint is
2877 pragma Assert (N in Nodes.First .. Nodes.Last);
2878 U : constant Union_Id := Nodes.Table (N).Field3;
2884 return From_Union (U);
2888 function Uint4 (N : Node_Id) return Uint is
2889 pragma Assert (N in Nodes.First .. Nodes.Last);
2890 U : constant Union_Id := Nodes.Table (N).Field4;
2896 return From_Union (U);
2900 function Uint5 (N : Node_Id) return Uint is
2901 pragma Assert (N in Nodes.First .. Nodes.Last);
2902 U : constant Union_Id := Nodes.Table (N).Field5;
2908 return From_Union (U);
2912 function Uint8 (N : Node_Id) return Uint is
2913 pragma Assert (Nkind (N) in N_Entity);
2914 U : constant Union_Id := Nodes.Table (N + 1).Field8;
2920 return From_Union (U);
2924 function Uint9 (N : Node_Id) return Uint is
2925 pragma Assert (Nkind (N) in N_Entity);
2926 U : constant Union_Id := Nodes.Table (N + 1).Field9;
2932 return From_Union (U);
2936 function Uint11 (N : Node_Id) return Uint is
2937 pragma Assert (Nkind (N) in N_Entity);
2938 U : constant Union_Id := Nodes.Table (N + 1).Field11;
2944 return From_Union (U);
2948 function Uint10 (N : Node_Id) return Uint is
2949 pragma Assert (Nkind (N) in N_Entity);
2950 U : constant Union_Id := Nodes.Table (N + 1).Field10;
2956 return From_Union (U);
2960 function Uint12 (N : Node_Id) return Uint is
2961 pragma Assert (Nkind (N) in N_Entity);
2962 U : constant Union_Id := Nodes.Table (N + 1).Field12;
2968 return From_Union (U);
2972 function Uint13 (N : Node_Id) return Uint is
2973 pragma Assert (Nkind (N) in N_Entity);
2974 U : constant Union_Id := Nodes.Table (N + 2).Field6;
2980 return From_Union (U);
2984 function Uint14 (N : Node_Id) return Uint is
2985 pragma Assert (Nkind (N) in N_Entity);
2986 U : constant Union_Id := Nodes.Table (N + 2).Field7;
2992 return From_Union (U);
2996 function Uint15 (N : Node_Id) return Uint is
2997 pragma Assert (Nkind (N) in N_Entity);
2998 U : constant Union_Id := Nodes.Table (N + 2).Field8;
3004 return From_Union (U);
3008 function Uint16 (N : Node_Id) return Uint is
3009 pragma Assert (Nkind (N) in N_Entity);
3010 U : constant Union_Id := Nodes.Table (N + 2).Field9;
3016 return From_Union (U);
3020 function Uint17 (N : Node_Id) return Uint is
3021 pragma Assert (Nkind (N) in N_Entity);
3022 U : constant Union_Id := Nodes.Table (N + 2).Field10;
3028 return From_Union (U);
3032 function Uint22 (N : Node_Id) return Uint is
3033 pragma Assert (Nkind (N) in N_Entity);
3034 U : constant Union_Id := Nodes.Table (N + 3).Field9;
3040 return From_Union (U);
3044 function Ureal3 (N : Node_Id) return Ureal is
3046 pragma Assert (N in Nodes.First .. Nodes.Last);
3047 return From_Union (Nodes.Table (N).Field3);
3050 function Ureal18 (N : Node_Id) return Ureal is
3052 pragma Assert (Nkind (N) in N_Entity);
3053 return From_Union (Nodes.Table (N + 2).Field11);
3056 function Ureal21 (N : Node_Id) return Ureal is
3058 pragma Assert (Nkind (N) in N_Entity);
3059 return From_Union (Nodes.Table (N + 3).Field8);
3062 function Flag4 (N : Node_Id) return Boolean is
3064 pragma Assert (N in Nodes.First .. Nodes.Last);
3065 return Nodes.Table (N).Flag4;
3068 function Flag5 (N : Node_Id) return Boolean is
3070 pragma Assert (N in Nodes.First .. Nodes.Last);
3071 return Nodes.Table (N).Flag5;
3074 function Flag6 (N : Node_Id) return Boolean is
3076 pragma Assert (N in Nodes.First .. Nodes.Last);
3077 return Nodes.Table (N).Flag6;
3080 function Flag7 (N : Node_Id) return Boolean is
3082 pragma Assert (N in Nodes.First .. Nodes.Last);
3083 return Nodes.Table (N).Flag7;
3086 function Flag8 (N : Node_Id) return Boolean is
3088 pragma Assert (N in Nodes.First .. Nodes.Last);
3089 return Nodes.Table (N).Flag8;
3092 function Flag9 (N : Node_Id) return Boolean is
3094 pragma Assert (N in Nodes.First .. Nodes.Last);
3095 return Nodes.Table (N).Flag9;
3098 function Flag10 (N : Node_Id) return Boolean is
3100 pragma Assert (N in Nodes.First .. Nodes.Last);
3101 return Nodes.Table (N).Flag10;
3104 function Flag11 (N : Node_Id) return Boolean is
3106 pragma Assert (N in Nodes.First .. Nodes.Last);
3107 return Nodes.Table (N).Flag11;
3110 function Flag12 (N : Node_Id) return Boolean is
3112 pragma Assert (N in Nodes.First .. Nodes.Last);
3113 return Nodes.Table (N).Flag12;
3116 function Flag13 (N : Node_Id) return Boolean is
3118 pragma Assert (N in Nodes.First .. Nodes.Last);
3119 return Nodes.Table (N).Flag13;
3122 function Flag14 (N : Node_Id) return Boolean is
3124 pragma Assert (N in Nodes.First .. Nodes.Last);
3125 return Nodes.Table (N).Flag14;
3128 function Flag15 (N : Node_Id) return Boolean is
3130 pragma Assert (N in Nodes.First .. Nodes.Last);
3131 return Nodes.Table (N).Flag15;
3134 function Flag16 (N : Node_Id) return Boolean is
3136 pragma Assert (N in Nodes.First .. Nodes.Last);
3137 return Nodes.Table (N).Flag16;
3140 function Flag17 (N : Node_Id) return Boolean is
3142 pragma Assert (N in Nodes.First .. Nodes.Last);
3143 return Nodes.Table (N).Flag17;
3146 function Flag18 (N : Node_Id) return Boolean is
3148 pragma Assert (N in Nodes.First .. Nodes.Last);
3149 return Nodes.Table (N).Flag18;
3152 function Flag19 (N : Node_Id) return Boolean is
3154 pragma Assert (Nkind (N) in N_Entity);
3155 return Nodes.Table (N + 1).In_List;
3158 function Flag20 (N : Node_Id) return Boolean is
3160 pragma Assert (Nkind (N) in N_Entity);
3161 return Nodes.Table (N + 1).Unused_1;
3164 function Flag21 (N : Node_Id) return Boolean is
3166 pragma Assert (Nkind (N) in N_Entity);
3167 return Nodes.Table (N + 1).Rewrite_Ins;
3170 function Flag22 (N : Node_Id) return Boolean is
3172 pragma Assert (Nkind (N) in N_Entity);
3173 return Nodes.Table (N + 1).Analyzed;
3176 function Flag23 (N : Node_Id) return Boolean is
3178 pragma Assert (Nkind (N) in N_Entity);
3179 return Nodes.Table (N + 1).Comes_From_Source;
3182 function Flag24 (N : Node_Id) return Boolean is
3184 pragma Assert (Nkind (N) in N_Entity);
3185 return Nodes.Table (N + 1).Error_Posted;
3188 function Flag25 (N : Node_Id) return Boolean is
3190 pragma Assert (Nkind (N) in N_Entity);
3191 return Nodes.Table (N + 1).Flag4;
3194 function Flag26 (N : Node_Id) return Boolean is
3196 pragma Assert (Nkind (N) in N_Entity);
3197 return Nodes.Table (N + 1).Flag5;
3200 function Flag27 (N : Node_Id) return Boolean is
3202 pragma Assert (Nkind (N) in N_Entity);
3203 return Nodes.Table (N + 1).Flag6;
3206 function Flag28 (N : Node_Id) return Boolean is
3208 pragma Assert (Nkind (N) in N_Entity);
3209 return Nodes.Table (N + 1).Flag7;
3212 function Flag29 (N : Node_Id) return Boolean is
3214 pragma Assert (Nkind (N) in N_Entity);
3215 return Nodes.Table (N + 1).Flag8;
3218 function Flag30 (N : Node_Id) return Boolean is
3220 pragma Assert (Nkind (N) in N_Entity);
3221 return Nodes.Table (N + 1).Flag9;
3224 function Flag31 (N : Node_Id) return Boolean is
3226 pragma Assert (Nkind (N) in N_Entity);
3227 return Nodes.Table (N + 1).Flag10;
3230 function Flag32 (N : Node_Id) return Boolean is
3232 pragma Assert (Nkind (N) in N_Entity);
3233 return Nodes.Table (N + 1).Flag11;
3236 function Flag33 (N : Node_Id) return Boolean is
3238 pragma Assert (Nkind (N) in N_Entity);
3239 return Nodes.Table (N + 1).Flag12;
3242 function Flag34 (N : Node_Id) return Boolean is
3244 pragma Assert (Nkind (N) in N_Entity);
3245 return Nodes.Table (N + 1).Flag13;
3248 function Flag35 (N : Node_Id) return Boolean is
3250 pragma Assert (Nkind (N) in N_Entity);
3251 return Nodes.Table (N + 1).Flag14;
3254 function Flag36 (N : Node_Id) return Boolean is
3256 pragma Assert (Nkind (N) in N_Entity);
3257 return Nodes.Table (N + 1).Flag15;
3260 function Flag37 (N : Node_Id) return Boolean is
3262 pragma Assert (Nkind (N) in N_Entity);
3263 return Nodes.Table (N + 1).Flag16;
3266 function Flag38 (N : Node_Id) return Boolean is
3268 pragma Assert (Nkind (N) in N_Entity);
3269 return Nodes.Table (N + 1).Flag17;
3272 function Flag39 (N : Node_Id) return Boolean is
3274 pragma Assert (Nkind (N) in N_Entity);
3275 return Nodes.Table (N + 1).Flag18;
3278 function Flag40 (N : Node_Id) return Boolean is
3280 pragma Assert (Nkind (N) in N_Entity);
3281 return Nodes.Table (N + 2).In_List;
3284 function Flag41 (N : Node_Id) return Boolean is
3286 pragma Assert (Nkind (N) in N_Entity);
3287 return Nodes.Table (N + 2).Unused_1;
3290 function Flag42 (N : Node_Id) return Boolean is
3292 pragma Assert (Nkind (N) in N_Entity);
3293 return Nodes.Table (N + 2).Rewrite_Ins;
3296 function Flag43 (N : Node_Id) return Boolean is
3298 pragma Assert (Nkind (N) in N_Entity);
3299 return Nodes.Table (N + 2).Analyzed;
3302 function Flag44 (N : Node_Id) return Boolean is
3304 pragma Assert (Nkind (N) in N_Entity);
3305 return Nodes.Table (N + 2).Comes_From_Source;
3308 function Flag45 (N : Node_Id) return Boolean is
3310 pragma Assert (Nkind (N) in N_Entity);
3311 return Nodes.Table (N + 2).Error_Posted;
3314 function Flag46 (N : Node_Id) return Boolean is
3316 pragma Assert (Nkind (N) in N_Entity);
3317 return Nodes.Table (N + 2).Flag4;
3320 function Flag47 (N : Node_Id) return Boolean is
3322 pragma Assert (Nkind (N) in N_Entity);
3323 return Nodes.Table (N + 2).Flag5;
3326 function Flag48 (N : Node_Id) return Boolean is
3328 pragma Assert (Nkind (N) in N_Entity);
3329 return Nodes.Table (N + 2).Flag6;
3332 function Flag49 (N : Node_Id) return Boolean is
3334 pragma Assert (Nkind (N) in N_Entity);
3335 return Nodes.Table (N + 2).Flag7;
3338 function Flag50 (N : Node_Id) return Boolean is
3340 pragma Assert (Nkind (N) in N_Entity);
3341 return Nodes.Table (N + 2).Flag8;
3344 function Flag51 (N : Node_Id) return Boolean is
3346 pragma Assert (Nkind (N) in N_Entity);
3347 return Nodes.Table (N + 2).Flag9;
3350 function Flag52 (N : Node_Id) return Boolean is
3352 pragma Assert (Nkind (N) in N_Entity);
3353 return Nodes.Table (N + 2).Flag10;
3356 function Flag53 (N : Node_Id) return Boolean is
3358 pragma Assert (Nkind (N) in N_Entity);
3359 return Nodes.Table (N + 2).Flag11;
3362 function Flag54 (N : Node_Id) return Boolean is
3364 pragma Assert (Nkind (N) in N_Entity);
3365 return Nodes.Table (N + 2).Flag12;
3368 function Flag55 (N : Node_Id) return Boolean is
3370 pragma Assert (Nkind (N) in N_Entity);
3371 return Nodes.Table (N + 2).Flag13;
3374 function Flag56 (N : Node_Id) return Boolean is
3376 pragma Assert (Nkind (N) in N_Entity);
3377 return Nodes.Table (N + 2).Flag14;
3380 function Flag57 (N : Node_Id) return Boolean is
3382 pragma Assert (Nkind (N) in N_Entity);
3383 return Nodes.Table (N + 2).Flag15;
3386 function Flag58 (N : Node_Id) return Boolean is
3388 pragma Assert (Nkind (N) in N_Entity);
3389 return Nodes.Table (N + 2).Flag16;
3392 function Flag59 (N : Node_Id) return Boolean is
3394 pragma Assert (Nkind (N) in N_Entity);
3395 return Nodes.Table (N + 2).Flag17;
3398 function Flag60 (N : Node_Id) return Boolean is
3400 pragma Assert (Nkind (N) in N_Entity);
3401 return Nodes.Table (N + 2).Flag18;
3404 function Flag61 (N : Node_Id) return Boolean is
3406 pragma Assert (Nkind (N) in N_Entity);
3407 return Nodes.Table (N + 1).Pflag1;
3410 function Flag62 (N : Node_Id) return Boolean is
3412 pragma Assert (Nkind (N) in N_Entity);
3413 return Nodes.Table (N + 1).Pflag2;
3416 function Flag63 (N : Node_Id) return Boolean is
3418 pragma Assert (Nkind (N) in N_Entity);
3419 return Nodes.Table (N + 2).Pflag1;
3422 function Flag64 (N : Node_Id) return Boolean is
3424 pragma Assert (Nkind (N) in N_Entity);
3425 return Nodes.Table (N + 2).Pflag2;
3428 function Flag65 (N : Node_Id) return Boolean is
3430 pragma Assert (Nkind (N) in N_Entity);
3431 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
3434 function Flag66 (N : Node_Id) return Boolean is
3436 pragma Assert (Nkind (N) in N_Entity);
3437 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
3440 function Flag67 (N : Node_Id) return Boolean is
3442 pragma Assert (Nkind (N) in N_Entity);
3443 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
3446 function Flag68 (N : Node_Id) return Boolean is
3448 pragma Assert (Nkind (N) in N_Entity);
3449 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
3452 function Flag69 (N : Node_Id) return Boolean is
3454 pragma Assert (Nkind (N) in N_Entity);
3455 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
3458 function Flag70 (N : Node_Id) return Boolean is
3460 pragma Assert (Nkind (N) in N_Entity);
3461 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
3464 function Flag71 (N : Node_Id) return Boolean is
3466 pragma Assert (Nkind (N) in N_Entity);
3467 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
3470 function Flag72 (N : Node_Id) return Boolean is
3472 pragma Assert (Nkind (N) in N_Entity);
3473 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
3476 function Flag73 (N : Node_Id) return Boolean is
3478 pragma Assert (Nkind (N) in N_Entity);
3479 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
3482 function Flag74 (N : Node_Id) return Boolean is
3484 pragma Assert (Nkind (N) in N_Entity);
3485 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
3488 function Flag75 (N : Node_Id) return Boolean is
3490 pragma Assert (Nkind (N) in N_Entity);
3491 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
3494 function Flag76 (N : Node_Id) return Boolean is
3496 pragma Assert (Nkind (N) in N_Entity);
3497 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
3500 function Flag77 (N : Node_Id) return Boolean is
3502 pragma Assert (Nkind (N) in N_Entity);
3503 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
3506 function Flag78 (N : Node_Id) return Boolean is
3508 pragma Assert (Nkind (N) in N_Entity);
3509 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
3512 function Flag79 (N : Node_Id) return Boolean is
3514 pragma Assert (Nkind (N) in N_Entity);
3515 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
3518 function Flag80 (N : Node_Id) return Boolean is
3520 pragma Assert (Nkind (N) in N_Entity);
3521 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
3524 function Flag81 (N : Node_Id) return Boolean is
3526 pragma Assert (Nkind (N) in N_Entity);
3527 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
3530 function Flag82 (N : Node_Id) return Boolean is
3532 pragma Assert (Nkind (N) in N_Entity);
3533 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
3536 function Flag83 (N : Node_Id) return Boolean is
3538 pragma Assert (Nkind (N) in N_Entity);
3539 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
3542 function Flag84 (N : Node_Id) return Boolean is
3544 pragma Assert (Nkind (N) in N_Entity);
3545 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
3548 function Flag85 (N : Node_Id) return Boolean is
3550 pragma Assert (Nkind (N) in N_Entity);
3551 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
3554 function Flag86 (N : Node_Id) return Boolean is
3556 pragma Assert (Nkind (N) in N_Entity);
3557 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
3560 function Flag87 (N : Node_Id) return Boolean is
3562 pragma Assert (Nkind (N) in N_Entity);
3563 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
3566 function Flag88 (N : Node_Id) return Boolean is
3568 pragma Assert (Nkind (N) in N_Entity);
3569 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
3572 function Flag89 (N : Node_Id) return Boolean is
3574 pragma Assert (Nkind (N) in N_Entity);
3575 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
3578 function Flag90 (N : Node_Id) return Boolean is
3580 pragma Assert (Nkind (N) in N_Entity);
3581 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
3584 function Flag91 (N : Node_Id) return Boolean is
3586 pragma Assert (Nkind (N) in N_Entity);
3587 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
3590 function Flag92 (N : Node_Id) return Boolean is
3592 pragma Assert (Nkind (N) in N_Entity);
3593 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
3596 function Flag93 (N : Node_Id) return Boolean is
3598 pragma Assert (Nkind (N) in N_Entity);
3599 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
3602 function Flag94 (N : Node_Id) return Boolean is
3604 pragma Assert (Nkind (N) in N_Entity);
3605 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
3608 function Flag95 (N : Node_Id) return Boolean is
3610 pragma Assert (Nkind (N) in N_Entity);
3611 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
3614 function Flag96 (N : Node_Id) return Boolean is
3616 pragma Assert (Nkind (N) in N_Entity);
3617 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
3620 function Flag97 (N : Node_Id) return Boolean is
3622 pragma Assert (Nkind (N) in N_Entity);
3623 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
3626 function Flag98 (N : Node_Id) return Boolean is
3628 pragma Assert (Nkind (N) in N_Entity);
3629 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
3632 function Flag99 (N : Node_Id) return Boolean is
3634 pragma Assert (Nkind (N) in N_Entity);
3635 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
3638 function Flag100 (N : Node_Id) return Boolean is
3640 pragma Assert (Nkind (N) in N_Entity);
3641 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
3644 function Flag101 (N : Node_Id) return Boolean is
3646 pragma Assert (Nkind (N) in N_Entity);
3647 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
3650 function Flag102 (N : Node_Id) return Boolean is
3652 pragma Assert (Nkind (N) in N_Entity);
3653 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
3656 function Flag103 (N : Node_Id) return Boolean is
3658 pragma Assert (Nkind (N) in N_Entity);
3659 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
3662 function Flag104 (N : Node_Id) return Boolean is
3664 pragma Assert (Nkind (N) in N_Entity);
3665 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
3668 function Flag105 (N : Node_Id) return Boolean is
3670 pragma Assert (Nkind (N) in N_Entity);
3671 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
3674 function Flag106 (N : Node_Id) return Boolean is
3676 pragma Assert (Nkind (N) in N_Entity);
3677 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
3680 function Flag107 (N : Node_Id) return Boolean is
3682 pragma Assert (Nkind (N) in N_Entity);
3683 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
3686 function Flag108 (N : Node_Id) return Boolean is
3688 pragma Assert (Nkind (N) in N_Entity);
3689 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
3692 function Flag109 (N : Node_Id) return Boolean is
3694 pragma Assert (Nkind (N) in N_Entity);
3695 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
3698 function Flag110 (N : Node_Id) return Boolean is
3700 pragma Assert (Nkind (N) in N_Entity);
3701 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
3704 function Flag111 (N : Node_Id) return Boolean is
3706 pragma Assert (Nkind (N) in N_Entity);
3707 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
3710 function Flag112 (N : Node_Id) return Boolean is
3712 pragma Assert (Nkind (N) in N_Entity);
3713 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
3716 function Flag113 (N : Node_Id) return Boolean is
3718 pragma Assert (Nkind (N) in N_Entity);
3719 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
3722 function Flag114 (N : Node_Id) return Boolean is
3724 pragma Assert (Nkind (N) in N_Entity);
3725 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
3728 function Flag115 (N : Node_Id) return Boolean is
3730 pragma Assert (Nkind (N) in N_Entity);
3731 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
3734 function Flag116 (N : Node_Id) return Boolean is
3736 pragma Assert (Nkind (N) in N_Entity);
3737 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
3740 function Flag117 (N : Node_Id) return Boolean is
3742 pragma Assert (Nkind (N) in N_Entity);
3743 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
3746 function Flag118 (N : Node_Id) return Boolean is
3748 pragma Assert (Nkind (N) in N_Entity);
3749 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
3752 function Flag119 (N : Node_Id) return Boolean is
3754 pragma Assert (Nkind (N) in N_Entity);
3755 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
3758 function Flag120 (N : Node_Id) return Boolean is
3760 pragma Assert (Nkind (N) in N_Entity);
3761 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
3764 function Flag121 (N : Node_Id) return Boolean is
3766 pragma Assert (Nkind (N) in N_Entity);
3767 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
3770 function Flag122 (N : Node_Id) return Boolean is
3772 pragma Assert (Nkind (N) in N_Entity);
3773 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
3776 function Flag123 (N : Node_Id) return Boolean is
3778 pragma Assert (Nkind (N) in N_Entity);
3779 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
3782 function Flag124 (N : Node_Id) return Boolean is
3784 pragma Assert (Nkind (N) in N_Entity);
3785 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
3788 function Flag125 (N : Node_Id) return Boolean is
3790 pragma Assert (Nkind (N) in N_Entity);
3791 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
3794 function Flag126 (N : Node_Id) return Boolean is
3796 pragma Assert (Nkind (N) in N_Entity);
3797 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
3800 function Flag127 (N : Node_Id) return Boolean is
3802 pragma Assert (Nkind (N) in N_Entity);
3803 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
3806 function Flag128 (N : Node_Id) return Boolean is
3808 pragma Assert (Nkind (N) in N_Entity);
3809 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
3812 function Flag129 (N : Node_Id) return Boolean is
3814 pragma Assert (Nkind (N) in N_Entity);
3815 return Nodes.Table (N + 3).In_List;
3818 function Flag130 (N : Node_Id) return Boolean is
3820 pragma Assert (Nkind (N) in N_Entity);
3821 return Nodes.Table (N + 3).Unused_1;
3824 function Flag131 (N : Node_Id) return Boolean is
3826 pragma Assert (Nkind (N) in N_Entity);
3827 return Nodes.Table (N + 3).Rewrite_Ins;
3830 function Flag132 (N : Node_Id) return Boolean is
3832 pragma Assert (Nkind (N) in N_Entity);
3833 return Nodes.Table (N + 3).Analyzed;
3836 function Flag133 (N : Node_Id) return Boolean is
3838 pragma Assert (Nkind (N) in N_Entity);
3839 return Nodes.Table (N + 3).Comes_From_Source;
3842 function Flag134 (N : Node_Id) return Boolean is
3844 pragma Assert (Nkind (N) in N_Entity);
3845 return Nodes.Table (N + 3).Error_Posted;
3848 function Flag135 (N : Node_Id) return Boolean is
3850 pragma Assert (Nkind (N) in N_Entity);
3851 return Nodes.Table (N + 3).Flag4;
3854 function Flag136 (N : Node_Id) return Boolean is
3856 pragma Assert (Nkind (N) in N_Entity);
3857 return Nodes.Table (N + 3).Flag5;
3860 function Flag137 (N : Node_Id) return Boolean is
3862 pragma Assert (Nkind (N) in N_Entity);
3863 return Nodes.Table (N + 3).Flag6;
3866 function Flag138 (N : Node_Id) return Boolean is
3868 pragma Assert (Nkind (N) in N_Entity);
3869 return Nodes.Table (N + 3).Flag7;
3872 function Flag139 (N : Node_Id) return Boolean is
3874 pragma Assert (Nkind (N) in N_Entity);
3875 return Nodes.Table (N + 3).Flag8;
3878 function Flag140 (N : Node_Id) return Boolean is
3880 pragma Assert (Nkind (N) in N_Entity);
3881 return Nodes.Table (N + 3).Flag9;
3884 function Flag141 (N : Node_Id) return Boolean is
3886 pragma Assert (Nkind (N) in N_Entity);
3887 return Nodes.Table (N + 3).Flag10;
3890 function Flag142 (N : Node_Id) return Boolean is
3892 pragma Assert (Nkind (N) in N_Entity);
3893 return Nodes.Table (N + 3).Flag11;
3896 function Flag143 (N : Node_Id) return Boolean is
3898 pragma Assert (Nkind (N) in N_Entity);
3899 return Nodes.Table (N + 3).Flag12;
3902 function Flag144 (N : Node_Id) return Boolean is
3904 pragma Assert (Nkind (N) in N_Entity);
3905 return Nodes.Table (N + 3).Flag13;
3908 function Flag145 (N : Node_Id) return Boolean is
3910 pragma Assert (Nkind (N) in N_Entity);
3911 return Nodes.Table (N + 3).Flag14;
3914 function Flag146 (N : Node_Id) return Boolean is
3916 pragma Assert (Nkind (N) in N_Entity);
3917 return Nodes.Table (N + 3).Flag15;
3920 function Flag147 (N : Node_Id) return Boolean is
3922 pragma Assert (Nkind (N) in N_Entity);
3923 return Nodes.Table (N + 3).Flag16;
3926 function Flag148 (N : Node_Id) return Boolean is
3928 pragma Assert (Nkind (N) in N_Entity);
3929 return Nodes.Table (N + 3).Flag17;
3932 function Flag149 (N : Node_Id) return Boolean is
3934 pragma Assert (Nkind (N) in N_Entity);
3935 return Nodes.Table (N + 3).Flag18;
3938 function Flag150 (N : Node_Id) return Boolean is
3940 pragma Assert (Nkind (N) in N_Entity);
3941 return Nodes.Table (N + 3).Pflag1;
3944 function Flag151 (N : Node_Id) return Boolean is
3946 pragma Assert (Nkind (N) in N_Entity);
3947 return Nodes.Table (N + 3).Pflag2;
3950 function Flag152 (N : Node_Id) return Boolean is
3952 pragma Assert (Nkind (N) in N_Entity);
3953 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
3956 function Flag153 (N : Node_Id) return Boolean is
3958 pragma Assert (Nkind (N) in N_Entity);
3959 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
3962 function Flag154 (N : Node_Id) return Boolean is
3964 pragma Assert (Nkind (N) in N_Entity);
3965 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
3968 function Flag155 (N : Node_Id) return Boolean is
3970 pragma Assert (Nkind (N) in N_Entity);
3971 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
3974 function Flag156 (N : Node_Id) return Boolean is
3976 pragma Assert (Nkind (N) in N_Entity);
3977 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
3980 function Flag157 (N : Node_Id) return Boolean is
3982 pragma Assert (Nkind (N) in N_Entity);
3983 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
3986 function Flag158 (N : Node_Id) return Boolean is
3988 pragma Assert (Nkind (N) in N_Entity);
3989 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
3992 function Flag159 (N : Node_Id) return Boolean is
3994 pragma Assert (Nkind (N) in N_Entity);
3995 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
3998 function Flag160 (N : Node_Id) return Boolean is
4000 pragma Assert (Nkind (N) in N_Entity);
4001 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
4004 function Flag161 (N : Node_Id) return Boolean is
4006 pragma Assert (Nkind (N) in N_Entity);
4007 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
4010 function Flag162 (N : Node_Id) return Boolean is
4012 pragma Assert (Nkind (N) in N_Entity);
4013 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
4016 function Flag163 (N : Node_Id) return Boolean is
4018 pragma Assert (Nkind (N) in N_Entity);
4019 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
4022 function Flag164 (N : Node_Id) return Boolean is
4024 pragma Assert (Nkind (N) in N_Entity);
4025 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
4028 function Flag165 (N : Node_Id) return Boolean is
4030 pragma Assert (Nkind (N) in N_Entity);
4031 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
4034 function Flag166 (N : Node_Id) return Boolean is
4036 pragma Assert (Nkind (N) in N_Entity);
4037 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
4040 function Flag167 (N : Node_Id) return Boolean is
4042 pragma Assert (Nkind (N) in N_Entity);
4043 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
4046 function Flag168 (N : Node_Id) return Boolean is
4048 pragma Assert (Nkind (N) in N_Entity);
4049 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
4052 function Flag169 (N : Node_Id) return Boolean is
4054 pragma Assert (Nkind (N) in N_Entity);
4055 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
4058 function Flag170 (N : Node_Id) return Boolean is
4060 pragma Assert (Nkind (N) in N_Entity);
4061 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
4064 function Flag171 (N : Node_Id) return Boolean is
4066 pragma Assert (Nkind (N) in N_Entity);
4067 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
4070 function Flag172 (N : Node_Id) return Boolean is
4072 pragma Assert (Nkind (N) in N_Entity);
4073 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
4076 function Flag173 (N : Node_Id) return Boolean is
4078 pragma Assert (Nkind (N) in N_Entity);
4079 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
4082 function Flag174 (N : Node_Id) return Boolean is
4084 pragma Assert (Nkind (N) in N_Entity);
4085 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
4088 function Flag175 (N : Node_Id) return Boolean is
4090 pragma Assert (Nkind (N) in N_Entity);
4091 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
4094 function Flag176 (N : Node_Id) return Boolean is
4096 pragma Assert (Nkind (N) in N_Entity);
4097 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
4100 function Flag177 (N : Node_Id) return Boolean is
4102 pragma Assert (Nkind (N) in N_Entity);
4103 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
4106 function Flag178 (N : Node_Id) return Boolean is
4108 pragma Assert (Nkind (N) in N_Entity);
4109 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
4112 function Flag179 (N : Node_Id) return Boolean is
4114 pragma Assert (Nkind (N) in N_Entity);
4115 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
4118 function Flag180 (N : Node_Id) return Boolean is
4120 pragma Assert (Nkind (N) in N_Entity);
4121 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
4124 function Flag181 (N : Node_Id) return Boolean is
4126 pragma Assert (Nkind (N) in N_Entity);
4127 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
4130 function Flag182 (N : Node_Id) return Boolean is
4132 pragma Assert (Nkind (N) in N_Entity);
4133 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
4136 function Flag183 (N : Node_Id) return Boolean is
4138 pragma Assert (Nkind (N) in N_Entity);
4139 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
4142 procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
4144 pragma Assert (N in Nodes.First .. Nodes.Last);
4145 Nodes.Table (N).Nkind := Val;
4148 procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
4150 pragma Assert (N in Nodes.First .. Nodes.Last);
4151 Nodes.Table (N).Field1 := Val;
4154 procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
4156 pragma Assert (N in Nodes.First .. Nodes.Last);
4157 Nodes.Table (N).Field2 := Val;
4160 procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
4162 pragma Assert (N in Nodes.First .. Nodes.Last);
4163 Nodes.Table (N).Field3 := Val;
4166 procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
4168 pragma Assert (N in Nodes.First .. Nodes.Last);
4169 Nodes.Table (N).Field4 := Val;
4172 procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
4174 pragma Assert (N in Nodes.First .. Nodes.Last);
4175 Nodes.Table (N).Field5 := Val;
4178 procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
4180 pragma Assert (Nkind (N) in N_Entity);
4181 Nodes.Table (N + 1).Field6 := Val;
4184 procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
4186 pragma Assert (Nkind (N) in N_Entity);
4187 Nodes.Table (N + 1).Field7 := Val;
4190 procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
4192 pragma Assert (Nkind (N) in N_Entity);
4193 Nodes.Table (N + 1).Field8 := Val;
4196 procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
4198 pragma Assert (Nkind (N) in N_Entity);
4199 Nodes.Table (N + 1).Field9 := Val;
4202 procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
4204 pragma Assert (Nkind (N) in N_Entity);
4205 Nodes.Table (N + 1).Field10 := Val;
4208 procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
4210 pragma Assert (Nkind (N) in N_Entity);
4211 Nodes.Table (N + 1).Field11 := Val;
4214 procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
4216 pragma Assert (Nkind (N) in N_Entity);
4217 Nodes.Table (N + 1).Field12 := Val;
4220 procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
4222 pragma Assert (Nkind (N) in N_Entity);
4223 Nodes.Table (N + 2).Field6 := Val;
4226 procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
4228 pragma Assert (Nkind (N) in N_Entity);
4229 Nodes.Table (N + 2).Field7 := Val;
4232 procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
4234 pragma Assert (Nkind (N) in N_Entity);
4235 Nodes.Table (N + 2).Field8 := Val;
4238 procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
4240 pragma Assert (Nkind (N) in N_Entity);
4241 Nodes.Table (N + 2).Field9 := Val;
4244 procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
4246 pragma Assert (Nkind (N) in N_Entity);
4247 Nodes.Table (N + 2).Field10 := Val;
4250 procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
4252 pragma Assert (Nkind (N) in N_Entity);
4253 Nodes.Table (N + 2).Field11 := Val;
4256 procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
4258 pragma Assert (Nkind (N) in N_Entity);
4259 Nodes.Table (N + 3).Field6 := Val;
4262 procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
4264 pragma Assert (Nkind (N) in N_Entity);
4265 Nodes.Table (N + 3).Field7 := Val;
4268 procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
4270 pragma Assert (Nkind (N) in N_Entity);
4271 Nodes.Table (N + 3).Field8 := Val;
4274 procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
4276 pragma Assert (Nkind (N) in N_Entity);
4277 Nodes.Table (N + 3).Field9 := Val;
4280 procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
4282 pragma Assert (Nkind (N) in N_Entity);
4283 Nodes.Table (N + 3).Field10 := Val;
4286 procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
4288 pragma Assert (N in Nodes.First .. Nodes.Last);
4289 Nodes.Table (N).Field1 := Union_Id (Val);
4292 procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
4294 pragma Assert (N in Nodes.First .. Nodes.Last);
4295 Nodes.Table (N).Field2 := Union_Id (Val);
4298 procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
4300 pragma Assert (N in Nodes.First .. Nodes.Last);
4301 Nodes.Table (N).Field3 := Union_Id (Val);
4304 procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
4306 pragma Assert (N in Nodes.First .. Nodes.Last);
4307 Nodes.Table (N).Field4 := Union_Id (Val);
4310 procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
4312 pragma Assert (N in Nodes.First .. Nodes.Last);
4313 Nodes.Table (N).Field5 := Union_Id (Val);
4316 procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
4318 pragma Assert (Nkind (N) in N_Entity);
4319 Nodes.Table (N + 1).Field6 := Union_Id (Val);
4322 procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
4324 pragma Assert (Nkind (N) in N_Entity);
4325 Nodes.Table (N + 1).Field7 := Union_Id (Val);
4328 procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
4330 pragma Assert (Nkind (N) in N_Entity);
4331 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4334 procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
4336 pragma Assert (Nkind (N) in N_Entity);
4337 Nodes.Table (N + 1).Field9 := Union_Id (Val);
4340 procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
4342 pragma Assert (Nkind (N) in N_Entity);
4343 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4346 procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
4348 pragma Assert (Nkind (N) in N_Entity);
4349 Nodes.Table (N + 1).Field11 := Union_Id (Val);
4352 procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
4354 pragma Assert (Nkind (N) in N_Entity);
4355 Nodes.Table (N + 1).Field12 := Union_Id (Val);
4358 procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
4360 pragma Assert (Nkind (N) in N_Entity);
4361 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4364 procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
4366 pragma Assert (Nkind (N) in N_Entity);
4367 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4370 procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
4372 pragma Assert (Nkind (N) in N_Entity);
4373 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4376 procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
4378 pragma Assert (Nkind (N) in N_Entity);
4379 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4382 procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
4384 pragma Assert (Nkind (N) in N_Entity);
4385 Nodes.Table (N + 2).Field10 := Union_Id (Val);
4388 procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
4390 pragma Assert (Nkind (N) in N_Entity);
4391 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4394 procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
4396 pragma Assert (Nkind (N) in N_Entity);
4397 Nodes.Table (N + 3).Field6 := Union_Id (Val);
4400 procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
4402 pragma Assert (Nkind (N) in N_Entity);
4403 Nodes.Table (N + 3).Field7 := Union_Id (Val);
4406 procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
4408 pragma Assert (Nkind (N) in N_Entity);
4409 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4412 procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
4414 pragma Assert (Nkind (N) in N_Entity);
4415 Nodes.Table (N + 3).Field9 := Union_Id (Val);
4418 procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
4420 pragma Assert (Nkind (N) in N_Entity);
4421 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4424 procedure Set_List1 (N : Node_Id; Val : List_Id) is
4426 pragma Assert (N in Nodes.First .. Nodes.Last);
4427 Nodes.Table (N).Field1 := Union_Id (Val);
4430 procedure Set_List2 (N : Node_Id; Val : List_Id) is
4432 pragma Assert (N in Nodes.First .. Nodes.Last);
4433 Nodes.Table (N).Field2 := Union_Id (Val);
4436 procedure Set_List3 (N : Node_Id; Val : List_Id) is
4438 pragma Assert (N in Nodes.First .. Nodes.Last);
4439 Nodes.Table (N).Field3 := Union_Id (Val);
4442 procedure Set_List4 (N : Node_Id; Val : List_Id) is
4444 pragma Assert (N in Nodes.First .. Nodes.Last);
4445 Nodes.Table (N).Field4 := Union_Id (Val);
4448 procedure Set_List5 (N : Node_Id; Val : List_Id) is
4450 pragma Assert (N in Nodes.First .. Nodes.Last);
4451 Nodes.Table (N).Field5 := Union_Id (Val);
4454 procedure Set_List10 (N : Node_Id; Val : List_Id) is
4456 pragma Assert (Nkind (N) in N_Entity);
4457 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4460 procedure Set_List14 (N : Node_Id; Val : List_Id) is
4462 pragma Assert (Nkind (N) in N_Entity);
4463 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4466 procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
4468 Nodes.Table (N).Field2 := Union_Id (Val);
4471 procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
4473 Nodes.Table (N).Field3 := Union_Id (Val);
4476 procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
4478 Nodes.Table (N).Field4 := Union_Id (Val);
4481 procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
4483 pragma Assert (Nkind (N) in N_Entity);
4484 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4487 procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
4489 pragma Assert (Nkind (N) in N_Entity);
4490 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4493 procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
4495 pragma Assert (Nkind (N) in N_Entity);
4496 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4499 procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
4501 pragma Assert (Nkind (N) in N_Entity);
4502 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4505 procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
4507 pragma Assert (Nkind (N) in N_Entity);
4508 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4511 procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
4513 pragma Assert (Nkind (N) in N_Entity);
4514 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4517 procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
4519 pragma Assert (Nkind (N) in N_Entity);
4520 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4523 procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
4525 pragma Assert (N in Nodes.First .. Nodes.Last);
4526 Nodes.Table (N).Field1 := Union_Id (Val);
4529 procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
4531 pragma Assert (N in Nodes.First .. Nodes.Last);
4532 Nodes.Table (N).Field2 := Union_Id (Val);
4535 procedure Set_Str3 (N : Node_Id; Val : String_Id) is
4537 pragma Assert (N in Nodes.First .. Nodes.Last);
4538 Nodes.Table (N).Field3 := Union_Id (Val);
4541 procedure Set_Uint3 (N : Node_Id; Val : Uint) is
4543 pragma Assert (N in Nodes.First .. Nodes.Last);
4544 Nodes.Table (N).Field3 := To_Union (Val);
4547 procedure Set_Uint4 (N : Node_Id; Val : Uint) is
4549 pragma Assert (N in Nodes.First .. Nodes.Last);
4550 Nodes.Table (N).Field4 := To_Union (Val);
4553 procedure Set_Uint5 (N : Node_Id; Val : Uint) is
4555 pragma Assert (N in Nodes.First .. Nodes.Last);
4556 Nodes.Table (N).Field5 := To_Union (Val);
4559 procedure Set_Uint8 (N : Node_Id; Val : Uint) is
4561 pragma Assert (Nkind (N) in N_Entity);
4562 Nodes.Table (N + 1).Field8 := To_Union (Val);
4565 procedure Set_Uint9 (N : Node_Id; Val : Uint) is
4567 pragma Assert (Nkind (N) in N_Entity);
4568 Nodes.Table (N + 1).Field9 := To_Union (Val);
4571 procedure Set_Uint10 (N : Node_Id; Val : Uint) is
4573 pragma Assert (Nkind (N) in N_Entity);
4574 Nodes.Table (N + 1).Field10 := To_Union (Val);
4577 procedure Set_Uint11 (N : Node_Id; Val : Uint) is
4579 pragma Assert (Nkind (N) in N_Entity);
4580 Nodes.Table (N + 1).Field11 := To_Union (Val);
4583 procedure Set_Uint12 (N : Node_Id; Val : Uint) is
4585 pragma Assert (Nkind (N) in N_Entity);
4586 Nodes.Table (N + 1).Field12 := To_Union (Val);
4589 procedure Set_Uint13 (N : Node_Id; Val : Uint) is
4591 pragma Assert (Nkind (N) in N_Entity);
4592 Nodes.Table (N + 2).Field6 := To_Union (Val);
4595 procedure Set_Uint14 (N : Node_Id; Val : Uint) is
4597 pragma Assert (Nkind (N) in N_Entity);
4598 Nodes.Table (N + 2).Field7 := To_Union (Val);
4601 procedure Set_Uint15 (N : Node_Id; Val : Uint) is
4603 pragma Assert (Nkind (N) in N_Entity);
4604 Nodes.Table (N + 2).Field8 := To_Union (Val);
4607 procedure Set_Uint16 (N : Node_Id; Val : Uint) is
4609 pragma Assert (Nkind (N) in N_Entity);
4610 Nodes.Table (N + 2).Field9 := To_Union (Val);
4613 procedure Set_Uint17 (N : Node_Id; Val : Uint) is
4615 pragma Assert (Nkind (N) in N_Entity);
4616 Nodes.Table (N + 2).Field10 := To_Union (Val);
4619 procedure Set_Uint22 (N : Node_Id; Val : Uint) is
4621 pragma Assert (Nkind (N) in N_Entity);
4622 Nodes.Table (N + 3).Field9 := To_Union (Val);
4625 procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
4627 pragma Assert (N in Nodes.First .. Nodes.Last);
4628 Nodes.Table (N).Field3 := To_Union (Val);
4631 procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
4633 pragma Assert (Nkind (N) in N_Entity);
4634 Nodes.Table (N + 2).Field11 := To_Union (Val);
4637 procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
4639 pragma Assert (Nkind (N) in N_Entity);
4640 Nodes.Table (N + 3).Field8 := To_Union (Val);
4643 procedure Set_Char_Code2 (N : Node_Id; Val : Char_Code) is
4645 pragma Assert (N in Nodes.First .. Nodes.Last);
4646 Nodes.Table (N).Field2 := Union_Id (Val) + Char_Code_Bias;
4649 procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
4651 pragma Assert (N in Nodes.First .. Nodes.Last);
4652 Nodes.Table (N).Flag4 := Val;
4655 procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
4657 pragma Assert (N in Nodes.First .. Nodes.Last);
4658 Nodes.Table (N).Flag5 := Val;
4661 procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
4663 pragma Assert (N in Nodes.First .. Nodes.Last);
4664 Nodes.Table (N).Flag6 := Val;
4667 procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
4669 pragma Assert (N in Nodes.First .. Nodes.Last);
4670 Nodes.Table (N).Flag7 := Val;
4673 procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
4675 pragma Assert (N in Nodes.First .. Nodes.Last);
4676 Nodes.Table (N).Flag8 := Val;
4679 procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
4681 pragma Assert (N in Nodes.First .. Nodes.Last);
4682 Nodes.Table (N).Flag9 := Val;
4685 procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
4687 pragma Assert (N in Nodes.First .. Nodes.Last);
4688 Nodes.Table (N).Flag10 := Val;
4691 procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
4693 pragma Assert (N in Nodes.First .. Nodes.Last);
4694 Nodes.Table (N).Flag11 := Val;
4697 procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
4699 pragma Assert (N in Nodes.First .. Nodes.Last);
4700 Nodes.Table (N).Flag12 := Val;
4703 procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
4705 pragma Assert (N in Nodes.First .. Nodes.Last);
4706 Nodes.Table (N).Flag13 := Val;
4709 procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
4711 pragma Assert (N in Nodes.First .. Nodes.Last);
4712 Nodes.Table (N).Flag14 := Val;
4715 procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
4717 pragma Assert (N in Nodes.First .. Nodes.Last);
4718 Nodes.Table (N).Flag15 := Val;
4721 procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
4723 pragma Assert (N in Nodes.First .. Nodes.Last);
4724 Nodes.Table (N).Flag16 := Val;
4727 procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
4729 pragma Assert (N in Nodes.First .. Nodes.Last);
4730 Nodes.Table (N).Flag17 := Val;
4733 procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
4735 pragma Assert (N in Nodes.First .. Nodes.Last);
4736 Nodes.Table (N).Flag18 := Val;
4739 procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
4741 pragma Assert (Nkind (N) in N_Entity);
4742 Nodes.Table (N + 1).In_List := Val;
4745 procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
4747 pragma Assert (Nkind (N) in N_Entity);
4748 Nodes.Table (N + 1).Unused_1 := Val;
4751 procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
4753 pragma Assert (Nkind (N) in N_Entity);
4754 Nodes.Table (N + 1).Rewrite_Ins := Val;
4757 procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
4759 pragma Assert (Nkind (N) in N_Entity);
4760 Nodes.Table (N + 1).Analyzed := Val;
4763 procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
4765 pragma Assert (Nkind (N) in N_Entity);
4766 Nodes.Table (N + 1).Comes_From_Source := Val;
4769 procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
4771 pragma Assert (Nkind (N) in N_Entity);
4772 Nodes.Table (N + 1).Error_Posted := Val;
4775 procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
4777 pragma Assert (Nkind (N) in N_Entity);
4778 Nodes.Table (N + 1).Flag4 := Val;
4781 procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
4783 pragma Assert (Nkind (N) in N_Entity);
4784 Nodes.Table (N + 1).Flag5 := Val;
4787 procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
4789 pragma Assert (Nkind (N) in N_Entity);
4790 Nodes.Table (N + 1).Flag6 := Val;
4793 procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
4795 pragma Assert (Nkind (N) in N_Entity);
4796 Nodes.Table (N + 1).Flag7 := Val;
4799 procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
4801 pragma Assert (Nkind (N) in N_Entity);
4802 Nodes.Table (N + 1).Flag8 := Val;
4805 procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
4807 pragma Assert (Nkind (N) in N_Entity);
4808 Nodes.Table (N + 1).Flag9 := Val;
4811 procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
4813 pragma Assert (Nkind (N) in N_Entity);
4814 Nodes.Table (N + 1).Flag10 := Val;
4817 procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
4819 pragma Assert (Nkind (N) in N_Entity);
4820 Nodes.Table (N + 1).Flag11 := Val;
4823 procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
4825 pragma Assert (Nkind (N) in N_Entity);
4826 Nodes.Table (N + 1).Flag12 := Val;
4829 procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
4831 pragma Assert (Nkind (N) in N_Entity);
4832 Nodes.Table (N + 1).Flag13 := Val;
4835 procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
4837 pragma Assert (Nkind (N) in N_Entity);
4838 Nodes.Table (N + 1).Flag14 := Val;
4841 procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
4843 pragma Assert (Nkind (N) in N_Entity);
4844 Nodes.Table (N + 1).Flag15 := Val;
4847 procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
4849 pragma Assert (Nkind (N) in N_Entity);
4850 Nodes.Table (N + 1).Flag16 := Val;
4853 procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
4855 pragma Assert (Nkind (N) in N_Entity);
4856 Nodes.Table (N + 1).Flag17 := Val;
4859 procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
4861 pragma Assert (Nkind (N) in N_Entity);
4862 Nodes.Table (N + 1).Flag18 := Val;
4865 procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
4867 pragma Assert (Nkind (N) in N_Entity);
4868 Nodes.Table (N + 2).In_List := Val;
4871 procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
4873 pragma Assert (Nkind (N) in N_Entity);
4874 Nodes.Table (N + 2).Unused_1 := Val;
4877 procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
4879 pragma Assert (Nkind (N) in N_Entity);
4880 Nodes.Table (N + 2).Rewrite_Ins := Val;
4883 procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
4885 pragma Assert (Nkind (N) in N_Entity);
4886 Nodes.Table (N + 2).Analyzed := Val;
4889 procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
4891 pragma Assert (Nkind (N) in N_Entity);
4892 Nodes.Table (N + 2).Comes_From_Source := Val;
4895 procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
4897 pragma Assert (Nkind (N) in N_Entity);
4898 Nodes.Table (N + 2).Error_Posted := Val;
4901 procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
4903 pragma Assert (Nkind (N) in N_Entity);
4904 Nodes.Table (N + 2).Flag4 := Val;
4907 procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
4909 pragma Assert (Nkind (N) in N_Entity);
4910 Nodes.Table (N + 2).Flag5 := Val;
4913 procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
4915 pragma Assert (Nkind (N) in N_Entity);
4916 Nodes.Table (N + 2).Flag6 := Val;
4919 procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
4921 pragma Assert (Nkind (N) in N_Entity);
4922 Nodes.Table (N + 2).Flag7 := Val;
4925 procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
4927 pragma Assert (Nkind (N) in N_Entity);
4928 Nodes.Table (N + 2).Flag8 := Val;
4931 procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
4933 pragma Assert (Nkind (N) in N_Entity);
4934 Nodes.Table (N + 2).Flag9 := Val;
4937 procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
4939 pragma Assert (Nkind (N) in N_Entity);
4940 Nodes.Table (N + 2).Flag10 := Val;
4943 procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
4945 pragma Assert (Nkind (N) in N_Entity);
4946 Nodes.Table (N + 2).Flag11 := Val;
4949 procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
4951 pragma Assert (Nkind (N) in N_Entity);
4952 Nodes.Table (N + 2).Flag12 := Val;
4955 procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
4957 pragma Assert (Nkind (N) in N_Entity);
4958 Nodes.Table (N + 2).Flag13 := Val;
4961 procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
4963 pragma Assert (Nkind (N) in N_Entity);
4964 Nodes.Table (N + 2).Flag14 := Val;
4967 procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
4969 pragma Assert (Nkind (N) in N_Entity);
4970 Nodes.Table (N + 2).Flag15 := Val;
4973 procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
4975 pragma Assert (Nkind (N) in N_Entity);
4976 Nodes.Table (N + 2).Flag16 := Val;
4979 procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
4981 pragma Assert (Nkind (N) in N_Entity);
4982 Nodes.Table (N + 2).Flag17 := Val;
4985 procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
4987 pragma Assert (Nkind (N) in N_Entity);
4988 Nodes.Table (N + 2).Flag18 := Val;
4991 procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
4993 pragma Assert (Nkind (N) in N_Entity);
4994 Nodes.Table (N + 1).Pflag1 := Val;
4997 procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
4999 pragma Assert (Nkind (N) in N_Entity);
5000 Nodes.Table (N + 1).Pflag2 := Val;
5003 procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
5005 pragma Assert (Nkind (N) in N_Entity);
5006 Nodes.Table (N + 2).Pflag1 := Val;
5009 procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
5011 pragma Assert (Nkind (N) in N_Entity);
5012 Nodes.Table (N + 2).Pflag2 := Val;
5015 procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
5017 pragma Assert (Nkind (N) in N_Entity);
5020 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
5023 procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
5025 pragma Assert (Nkind (N) in N_Entity);
5028 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
5031 procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
5033 pragma Assert (Nkind (N) in N_Entity);
5036 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
5039 procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
5041 pragma Assert (Nkind (N) in N_Entity);
5044 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
5047 procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
5049 pragma Assert (Nkind (N) in N_Entity);
5052 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
5055 procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
5057 pragma Assert (Nkind (N) in N_Entity);
5060 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
5063 procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
5065 pragma Assert (Nkind (N) in N_Entity);
5068 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
5071 procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
5073 pragma Assert (Nkind (N) in N_Entity);
5076 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
5079 procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
5081 pragma Assert (Nkind (N) in N_Entity);
5084 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
5087 procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
5089 pragma Assert (Nkind (N) in N_Entity);
5092 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
5095 procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
5097 pragma Assert (Nkind (N) in N_Entity);
5100 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
5103 procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
5105 pragma Assert (Nkind (N) in N_Entity);
5108 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
5111 procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
5113 pragma Assert (Nkind (N) in N_Entity);
5116 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
5119 procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
5121 pragma Assert (Nkind (N) in N_Entity);
5124 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
5127 procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
5129 pragma Assert (Nkind (N) in N_Entity);
5132 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
5135 procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
5137 pragma Assert (Nkind (N) in N_Entity);
5140 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
5143 procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
5145 pragma Assert (Nkind (N) in N_Entity);
5148 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
5151 procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
5153 pragma Assert (Nkind (N) in N_Entity);
5156 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
5159 procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
5161 pragma Assert (Nkind (N) in N_Entity);
5164 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
5167 procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
5169 pragma Assert (Nkind (N) in N_Entity);
5172 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
5175 procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
5177 pragma Assert (Nkind (N) in N_Entity);
5180 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
5183 procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
5185 pragma Assert (Nkind (N) in N_Entity);
5188 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
5191 procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
5193 pragma Assert (Nkind (N) in N_Entity);
5196 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
5199 procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
5201 pragma Assert (Nkind (N) in N_Entity);
5204 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
5207 procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
5209 pragma Assert (Nkind (N) in N_Entity);
5212 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
5215 procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
5217 pragma Assert (Nkind (N) in N_Entity);
5220 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
5223 procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
5225 pragma Assert (Nkind (N) in N_Entity);
5228 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
5231 procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
5233 pragma Assert (Nkind (N) in N_Entity);
5236 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
5239 procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
5241 pragma Assert (Nkind (N) in N_Entity);
5244 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
5247 procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
5249 pragma Assert (Nkind (N) in N_Entity);
5252 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
5255 procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
5257 pragma Assert (Nkind (N) in N_Entity);
5260 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
5263 procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
5265 pragma Assert (Nkind (N) in N_Entity);
5268 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
5271 procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
5273 pragma Assert (Nkind (N) in N_Entity);
5276 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
5279 procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
5281 pragma Assert (Nkind (N) in N_Entity);
5284 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
5287 procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
5289 pragma Assert (Nkind (N) in N_Entity);
5292 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
5295 procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
5297 pragma Assert (Nkind (N) in N_Entity);
5300 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
5303 procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
5305 pragma Assert (Nkind (N) in N_Entity);
5308 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
5311 procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
5313 pragma Assert (Nkind (N) in N_Entity);
5316 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
5319 procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
5321 pragma Assert (Nkind (N) in N_Entity);
5324 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
5327 procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
5329 pragma Assert (Nkind (N) in N_Entity);
5332 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
5335 procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
5337 pragma Assert (Nkind (N) in N_Entity);
5340 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
5343 procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
5345 pragma Assert (Nkind (N) in N_Entity);
5348 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
5351 procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
5353 pragma Assert (Nkind (N) in N_Entity);
5356 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
5359 procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
5361 pragma Assert (Nkind (N) in N_Entity);
5364 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
5367 procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
5369 pragma Assert (Nkind (N) in N_Entity);
5372 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
5375 procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
5377 pragma Assert (Nkind (N) in N_Entity);
5380 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
5383 procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
5385 pragma Assert (Nkind (N) in N_Entity);
5388 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
5391 procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
5393 pragma Assert (Nkind (N) in N_Entity);
5396 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
5399 procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
5401 pragma Assert (Nkind (N) in N_Entity);
5404 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
5407 procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
5409 pragma Assert (Nkind (N) in N_Entity);
5412 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
5415 procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
5417 pragma Assert (Nkind (N) in N_Entity);
5420 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
5423 procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
5425 pragma Assert (Nkind (N) in N_Entity);
5428 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
5431 procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
5433 pragma Assert (Nkind (N) in N_Entity);
5436 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
5439 procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
5441 pragma Assert (Nkind (N) in N_Entity);
5444 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
5447 procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
5449 pragma Assert (Nkind (N) in N_Entity);
5452 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
5455 procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
5457 pragma Assert (Nkind (N) in N_Entity);
5460 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
5463 procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
5465 pragma Assert (Nkind (N) in N_Entity);
5468 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
5471 procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
5473 pragma Assert (Nkind (N) in N_Entity);
5476 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
5479 procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
5481 pragma Assert (Nkind (N) in N_Entity);
5484 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
5487 procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
5489 pragma Assert (Nkind (N) in N_Entity);
5492 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
5495 procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
5497 pragma Assert (Nkind (N) in N_Entity);
5500 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
5503 procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
5505 pragma Assert (Nkind (N) in N_Entity);
5508 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
5511 procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
5513 pragma Assert (Nkind (N) in N_Entity);
5516 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
5519 procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
5521 pragma Assert (Nkind (N) in N_Entity);
5524 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
5527 procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
5529 pragma Assert (Nkind (N) in N_Entity);
5530 Nodes.Table (N + 3).In_List := Val;
5533 procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
5535 pragma Assert (Nkind (N) in N_Entity);
5536 Nodes.Table (N + 3).Unused_1 := Val;
5539 procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
5541 pragma Assert (Nkind (N) in N_Entity);
5542 Nodes.Table (N + 3).Rewrite_Ins := Val;
5545 procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
5547 pragma Assert (Nkind (N) in N_Entity);
5548 Nodes.Table (N + 3).Analyzed := Val;
5551 procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
5553 pragma Assert (Nkind (N) in N_Entity);
5554 Nodes.Table (N + 3).Comes_From_Source := Val;
5557 procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
5559 pragma Assert (Nkind (N) in N_Entity);
5560 Nodes.Table (N + 3).Error_Posted := Val;
5563 procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
5565 pragma Assert (Nkind (N) in N_Entity);
5566 Nodes.Table (N + 3).Flag4 := Val;
5569 procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
5571 pragma Assert (Nkind (N) in N_Entity);
5572 Nodes.Table (N + 3).Flag5 := Val;
5575 procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
5577 pragma Assert (Nkind (N) in N_Entity);
5578 Nodes.Table (N + 3).Flag6 := Val;
5581 procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
5583 pragma Assert (Nkind (N) in N_Entity);
5584 Nodes.Table (N + 3).Flag7 := Val;
5587 procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
5589 pragma Assert (Nkind (N) in N_Entity);
5590 Nodes.Table (N + 3).Flag8 := Val;
5593 procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
5595 pragma Assert (Nkind (N) in N_Entity);
5596 Nodes.Table (N + 3).Flag9 := Val;
5599 procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
5601 pragma Assert (Nkind (N) in N_Entity);
5602 Nodes.Table (N + 3).Flag10 := Val;
5605 procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
5607 pragma Assert (Nkind (N) in N_Entity);
5608 Nodes.Table (N + 3).Flag11 := Val;
5611 procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
5613 pragma Assert (Nkind (N) in N_Entity);
5614 Nodes.Table (N + 3).Flag12 := Val;
5617 procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
5619 pragma Assert (Nkind (N) in N_Entity);
5620 Nodes.Table (N + 3).Flag13 := Val;
5623 procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
5625 pragma Assert (Nkind (N) in N_Entity);
5626 Nodes.Table (N + 3).Flag14 := Val;
5629 procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
5631 pragma Assert (Nkind (N) in N_Entity);
5632 Nodes.Table (N + 3).Flag15 := Val;
5635 procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
5637 pragma Assert (Nkind (N) in N_Entity);
5638 Nodes.Table (N + 3).Flag16 := Val;
5641 procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
5643 pragma Assert (Nkind (N) in N_Entity);
5644 Nodes.Table (N + 3).Flag17 := Val;
5647 procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
5649 pragma Assert (Nkind (N) in N_Entity);
5650 Nodes.Table (N + 3).Flag18 := Val;
5653 procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
5655 pragma Assert (Nkind (N) in N_Entity);
5656 Nodes.Table (N + 3).Pflag1 := Val;
5659 procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
5661 pragma Assert (Nkind (N) in N_Entity);
5662 Nodes.Table (N + 3).Pflag2 := Val;
5665 procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
5667 pragma Assert (Nkind (N) in N_Entity);
5670 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
5673 procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
5675 pragma Assert (Nkind (N) in N_Entity);
5678 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
5681 procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
5683 pragma Assert (Nkind (N) in N_Entity);
5686 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
5689 procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
5691 pragma Assert (Nkind (N) in N_Entity);
5694 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
5697 procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
5699 pragma Assert (Nkind (N) in N_Entity);
5702 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
5705 procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
5707 pragma Assert (Nkind (N) in N_Entity);
5710 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
5713 procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
5715 pragma Assert (Nkind (N) in N_Entity);
5718 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
5721 procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
5723 pragma Assert (Nkind (N) in N_Entity);
5726 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
5729 procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
5731 pragma Assert (Nkind (N) in N_Entity);
5734 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
5737 procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
5739 pragma Assert (Nkind (N) in N_Entity);
5742 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
5745 procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
5747 pragma Assert (Nkind (N) in N_Entity);
5750 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
5753 procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
5755 pragma Assert (Nkind (N) in N_Entity);
5758 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
5761 procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
5763 pragma Assert (Nkind (N) in N_Entity);
5766 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
5769 procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
5771 pragma Assert (Nkind (N) in N_Entity);
5774 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
5777 procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
5779 pragma Assert (Nkind (N) in N_Entity);
5782 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
5785 procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
5787 pragma Assert (Nkind (N) in N_Entity);
5790 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
5793 procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
5795 pragma Assert (Nkind (N) in N_Entity);
5798 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
5801 procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
5803 pragma Assert (Nkind (N) in N_Entity);
5806 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
5809 procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
5811 pragma Assert (Nkind (N) in N_Entity);
5814 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
5817 procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
5819 pragma Assert (Nkind (N) in N_Entity);
5822 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
5825 procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
5827 pragma Assert (Nkind (N) in N_Entity);
5830 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
5833 procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
5835 pragma Assert (Nkind (N) in N_Entity);
5838 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
5841 procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
5843 pragma Assert (Nkind (N) in N_Entity);
5846 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
5849 procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
5851 pragma Assert (Nkind (N) in N_Entity);
5854 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
5857 procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
5859 pragma Assert (Nkind (N) in N_Entity);
5862 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
5865 procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
5867 pragma Assert (Nkind (N) in N_Entity);
5870 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
5873 procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
5875 pragma Assert (Nkind (N) in N_Entity);
5878 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
5881 procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
5883 pragma Assert (Nkind (N) in N_Entity);
5886 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
5889 procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
5891 pragma Assert (Nkind (N) in N_Entity);
5894 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
5897 procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
5899 pragma Assert (Nkind (N) in N_Entity);
5902 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
5905 procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
5907 pragma Assert (Nkind (N) in N_Entity);
5910 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
5913 procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
5915 pragma Assert (Nkind (N) in N_Entity);
5918 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
5921 procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is
5923 pragma Assert (N in Nodes.First .. Nodes.Last);
5924 if Val > Error then Set_Parent (Val, N); end if;
5926 end Set_Node1_With_Parent;
5928 procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is
5930 pragma Assert (N in Nodes.First .. Nodes.Last);
5931 if Val > Error then Set_Parent (Val, N); end if;
5933 end Set_Node2_With_Parent;
5935 procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is
5937 pragma Assert (N in Nodes.First .. Nodes.Last);
5938 if Val > Error then Set_Parent (Val, N); end if;
5940 end Set_Node3_With_Parent;
5942 procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is
5944 pragma Assert (N in Nodes.First .. Nodes.Last);
5945 if Val > Error then Set_Parent (Val, N); end if;
5947 end Set_Node4_With_Parent;
5949 procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
5951 pragma Assert (N in Nodes.First .. Nodes.Last);
5952 if Val > Error then Set_Parent (Val, N); end if;
5954 end Set_Node5_With_Parent;
5956 procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
5958 pragma Assert (N in Nodes.First .. Nodes.Last);
5959 if Val /= No_List and then Val /= Error_List then
5960 Set_Parent (Val, N);
5963 end Set_List1_With_Parent;
5965 procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
5967 pragma Assert (N in Nodes.First .. Nodes.Last);
5968 if Val /= No_List and then Val /= Error_List then
5969 Set_Parent (Val, N);
5972 end Set_List2_With_Parent;
5974 procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
5976 pragma Assert (N in Nodes.First .. Nodes.Last);
5977 if Val /= No_List and then Val /= Error_List then
5978 Set_Parent (Val, N);
5981 end Set_List3_With_Parent;
5983 procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
5985 pragma Assert (N in Nodes.First .. Nodes.Last);
5986 if Val /= No_List and then Val /= Error_List then
5987 Set_Parent (Val, N);
5990 end Set_List4_With_Parent;
5992 procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
5994 pragma Assert (N in Nodes.First .. Nodes.Last);
5995 if Val /= No_List and then Val /= Error_List then
5996 Set_Parent (Val, N);
5999 end Set_List5_With_Parent;
6001 end Unchecked_Access;