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);
887 --------------------------
888 -- Is_Rewrite_Insertion --
889 --------------------------
891 function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is
893 return Nodes.Table (Node).Rewrite_Ins;
894 end Is_Rewrite_Insertion;
896 -----------------------------
897 -- Is_Rewrite_Substitution --
898 -----------------------------
900 function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is
902 return Orig_Nodes.Table (Node) /= Node;
903 end Is_Rewrite_Substitution;
909 function Last_Node_Id return Node_Id is
920 Nodes.Locked := True;
921 Orig_Nodes.Locked := True;
926 ----------------------------
927 -- Mark_Rewrite_Insertion --
928 ----------------------------
930 procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is
932 Nodes.Table (New_Node).Rewrite_Ins := True;
933 end Mark_Rewrite_Insertion;
939 function New_Copy (Source : Node_Id) return Node_Id is
943 if Source <= Empty_Or_Error then
947 Nodes.Increment_Last;
948 New_Id := Nodes.Last;
949 Nodes.Table (New_Id) := Nodes.Table (Source);
950 Nodes.Table (New_Id).Link := Empty_List_Or_Node;
951 Nodes.Table (New_Id).In_List := False;
952 Nodes.Table (New_Id).Rewrite_Ins := False;
954 Orig_Nodes.Increment_Last;
955 Orig_Nodes.Table (New_Id) := New_Id;
957 if Has_Extension (Source) then
958 Nodes.Increment_Last;
959 Nodes.Table (New_Id + 1) := Nodes.Table (Source + 1);
960 Nodes.Increment_Last;
961 Nodes.Table (New_Id + 2) := Nodes.Table (Source + 2);
962 Nodes.Increment_Last;
963 Nodes.Table (New_Id + 3) := Nodes.Table (Source + 3);
965 Orig_Nodes.Set_Last (Nodes.Last);
968 Allocate_List_Tables (Nodes.Last);
969 Node_Count := Node_Count + 1;
978 -- Our approach here requires a two pass traversal of the tree. The
979 -- first pass visits all nodes that eventually will be copied looking
980 -- for defining Itypes. If any defining Itypes are found, then they are
981 -- copied, and an entry is added to the replacement map. In the second
982 -- phase, the tree is copied, using the replacement map to replace any
983 -- Itype references within the copied tree.
985 -- The following hash tables are used if the Map supplied has more
986 -- than hash threshhold entries to speed up access to the map. If
987 -- there are fewer entries, then the map is searched sequentially
988 -- (because setting up a hash table for only a few entries takes
989 -- more time than it saves.
991 function New_Copy_Hash (E : Entity_Id) return NCT_Header_Num;
992 -- Hash function used for hash operations
994 function New_Copy_Hash (E : Entity_Id) return NCT_Header_Num is
996 return Nat (E) mod (NCT_Header_Num'Last + 1);
999 -- The hash table NCT_Assoc associates old entities in the table
1000 -- with their corresponding new entities (i.e. the pairs of entries
1001 -- presented in the original Map argument are Key-Element pairs).
1003 package NCT_Assoc is new Simple_HTable (
1004 Header_Num => NCT_Header_Num,
1005 Element => Entity_Id,
1006 No_Element => Empty,
1008 Hash => New_Copy_Hash,
1009 Equal => Types."=");
1011 -- The hash table NCT_Itype_Assoc contains entries only for those
1012 -- old nodes which have a non-empty Associated_Node_For_Itype set.
1013 -- The key is the associated node, and the element is the new node
1014 -- itself (NOT the associated node for the new node).
1016 package NCT_Itype_Assoc is new Simple_HTable (
1017 Header_Num => NCT_Header_Num,
1018 Element => Entity_Id,
1019 No_Element => Empty,
1021 Hash => New_Copy_Hash,
1022 Equal => Types."=");
1024 -- Start of New_Copy_Tree function
1026 function New_Copy_Tree
1028 Map : Elist_Id := No_Elist;
1029 New_Sloc : Source_Ptr := No_Location;
1030 New_Scope : Entity_Id := Empty)
1033 Actual_Map : Elist_Id := Map;
1034 -- This is the actual map for the copy. It is initialized with the
1035 -- given elements, and then enlarged as required for Itypes that are
1036 -- copied during the first phase of the copy operation. The visit
1037 -- procedures add elements to this map as Itypes are encountered.
1038 -- The reason we cannot use Map directly, is that it may well be
1039 -- (and normally is) initialized to No_Elist, and if we have mapped
1040 -- entities, we have to reset it to point to a real Elist.
1042 function Assoc (N : Node_Or_Entity_Id) return Node_Id;
1043 -- Called during second phase to map entities into their corresponding
1044 -- copies using Actual_Map. If the argument is not an entity, or is not
1045 -- in Actual_Map, then it is returned unchanged.
1047 procedure Build_NCT_Hash_Tables;
1048 -- Builds hash tables (number of elements >= threshold value)
1050 function Copy_Elist_With_Replacement
1051 (Old_Elist : Elist_Id)
1053 -- Called during second phase to copy element list doing replacements.
1055 procedure Copy_Itype_With_Replacement (New_Itype : Entity_Id);
1056 -- Called during the second phase to process a copied Itype. The actual
1057 -- copy happened during the first phase (so that we could make the entry
1058 -- in the mapping), but we still have to deal with the descendents of
1059 -- the copied Itype and copy them where necessary.
1061 function Copy_List_With_Replacement (Old_List : List_Id) return List_Id;
1062 -- Called during second phase to copy list doing replacements.
1064 function Copy_Node_With_Replacement (Old_Node : Node_Id) return Node_Id;
1065 -- Called during second phase to copy node doing replacements
1067 procedure Visit_Elist (E : Elist_Id);
1068 -- Called during first phase to visit all elements of an Elist
1070 procedure Visit_Field (F : Union_Id; N : Node_Id);
1071 -- Visit a single field, recursing to call Visit_Node or Visit_List
1072 -- if the field is a syntactic descendent of the current node (i.e.
1073 -- its parent is Node N).
1075 procedure Visit_Itype (Old_Itype : Entity_Id);
1076 -- Called during first phase to visit subsidiary fields of a defining
1077 -- Itype, and also create a copy and make an entry in the replacement
1078 -- map for the new copy.
1080 procedure Visit_List (L : List_Id);
1081 -- Called during first phase to visit all elements of a List
1083 procedure Visit_Node (N : Node_Or_Entity_Id);
1084 -- Called during first phase to visit a node and all its subtrees
1090 function Assoc (N : Node_Or_Entity_Id) return Node_Id is
1095 if not Has_Extension (N) or else No (Actual_Map) then
1098 elsif NCT_Hash_Tables_Used then
1099 Ent := NCT_Assoc.Get (Entity_Id (N));
1101 if Present (Ent) then
1107 -- No hash table used, do serial search
1110 E := First_Elmt (Actual_Map);
1111 while Present (E) loop
1112 if Node (E) = N then
1113 return Node (Next_Elmt (E));
1115 E := Next_Elmt (Next_Elmt (E));
1123 ---------------------------
1124 -- Build_NCT_Hash_Tables --
1125 ---------------------------
1127 procedure Build_NCT_Hash_Tables is
1131 if NCT_Hash_Table_Setup then
1133 NCT_Itype_Assoc.Reset;
1136 Elmt := First_Elmt (Actual_Map);
1137 while Present (Elmt) loop
1140 NCT_Assoc.Set (Ent, Node (Elmt));
1143 if Is_Type (Ent) then
1145 Anode : constant Entity_Id :=
1146 Associated_Node_For_Itype (Ent);
1149 if Present (Anode) then
1150 NCT_Itype_Assoc.Set (Anode, Node (Elmt));
1156 NCT_Hash_Tables_Used := True;
1157 NCT_Hash_Table_Setup := True;
1158 end Build_NCT_Hash_Tables;
1160 ---------------------------------
1161 -- Copy_Elist_With_Replacement --
1162 ---------------------------------
1164 function Copy_Elist_With_Replacement
1165 (Old_Elist : Elist_Id)
1169 New_Elist : Elist_Id;
1172 if No (Old_Elist) then
1176 New_Elist := New_Elmt_List;
1177 M := First_Elmt (Old_Elist);
1179 while Present (M) loop
1180 Append_Elmt (Copy_Node_With_Replacement (Node (M)), New_Elist);
1186 end Copy_Elist_With_Replacement;
1188 ---------------------------------
1189 -- Copy_Itype_With_Replacement --
1190 ---------------------------------
1192 -- This routine exactly parallels its phase one analog Visit_Itype,
1193 -- and like that routine, knows far too many semantic details about
1194 -- the descendents of Itypes and whether they need copying or not.
1196 procedure Copy_Itype_With_Replacement (New_Itype : Entity_Id) is
1198 -- Translate Next_Entity, Scope and Etype fields, in case they
1199 -- reference entities that have been mapped into copies.
1201 Set_Next_Entity (New_Itype, Assoc (Next_Entity (New_Itype)));
1202 Set_Etype (New_Itype, Assoc (Etype (New_Itype)));
1204 if Present (New_Scope) then
1205 Set_Scope (New_Itype, New_Scope);
1207 Set_Scope (New_Itype, Assoc (Scope (New_Itype)));
1210 -- Copy referenced fields
1212 if Is_Discrete_Type (New_Itype) then
1213 Set_Scalar_Range (New_Itype,
1214 Copy_Node_With_Replacement (Scalar_Range (New_Itype)));
1216 elsif Has_Discriminants (Base_Type (New_Itype)) then
1217 Set_Discriminant_Constraint (New_Itype,
1218 Copy_Elist_With_Replacement
1219 (Discriminant_Constraint (New_Itype)));
1221 elsif Is_Array_Type (New_Itype) then
1222 if Present (First_Index (New_Itype)) then
1223 Set_First_Index (New_Itype,
1224 First (Copy_List_With_Replacement
1225 (List_Containing (First_Index (New_Itype)))));
1228 if Is_Packed (New_Itype) then
1229 Set_Packed_Array_Type (New_Itype,
1230 Copy_Node_With_Replacement
1231 (Packed_Array_Type (New_Itype)));
1234 end Copy_Itype_With_Replacement;
1236 --------------------------------
1237 -- Copy_List_With_Replacement --
1238 --------------------------------
1240 function Copy_List_With_Replacement
1241 (Old_List : List_Id)
1248 if Old_List = No_List then
1252 New_List := Empty_List;
1253 E := First (Old_List);
1254 while Present (E) loop
1255 Append (Copy_Node_With_Replacement (E), New_List);
1261 end Copy_List_With_Replacement;
1263 --------------------------------
1264 -- Copy_Node_With_Replacement --
1265 --------------------------------
1267 function Copy_Node_With_Replacement
1268 (Old_Node : Node_Id)
1273 function Copy_Field_With_Replacement
1276 -- Given Field, which is a field of Old_Node, return a copy of it
1277 -- if it is a syntactic field (i.e. its parent is Node), setting
1278 -- the parent of the copy to poit to New_Node. Otherwise returns
1279 -- the field (possibly mapped if it is an entity).
1281 ---------------------------------
1282 -- Copy_Field_With_Replacement --
1283 ---------------------------------
1285 function Copy_Field_With_Replacement
1290 if Field = Union_Id (Empty) then
1293 elsif Field in Node_Range then
1295 Old_N : constant Node_Id := Node_Id (Field);
1299 -- If syntactic field, as indicated by the parent pointer
1300 -- being set, then copy the referenced node recursively.
1302 if Parent (Old_N) = Old_Node then
1303 New_N := Copy_Node_With_Replacement (Old_N);
1305 if New_N /= Old_N then
1306 Set_Parent (New_N, New_Node);
1309 -- For semantic fields, update possible entity reference
1310 -- from the replacement map.
1313 New_N := Assoc (Old_N);
1316 return Union_Id (New_N);
1319 elsif Field in List_Range then
1321 Old_L : constant List_Id := List_Id (Field);
1325 -- If syntactic field, as indicated by the parent pointer,
1326 -- then recursively copy the entire referenced list.
1328 if Parent (Old_L) = Old_Node then
1329 New_L := Copy_List_With_Replacement (Old_L);
1330 Set_Parent (New_L, New_Node);
1332 -- For semantic list, just returned unchanged
1338 return Union_Id (New_L);
1341 -- Anything other than a list or a node is returned unchanged
1346 end Copy_Field_With_Replacement;
1348 -- Start of processing for Copy_Node_With_Replacement
1351 if Old_Node <= Empty_Or_Error then
1354 elsif Has_Extension (Old_Node) then
1355 return Assoc (Old_Node);
1358 Nodes.Increment_Last;
1359 New_Node := Nodes.Last;
1360 Nodes.Table (New_Node) := Nodes.Table (Old_Node);
1361 Nodes.Table (New_Node).Link := Empty_List_Or_Node;
1362 Nodes.Table (New_Node).In_List := False;
1363 Node_Count := Node_Count + 1;
1365 Orig_Nodes.Increment_Last;
1366 Allocate_List_Tables (Nodes.Last);
1368 Orig_Nodes.Table (Nodes.Last) := Nodes.Last;
1370 -- If the node we are copying is the associated node of a
1371 -- previously copied Itype, then adjust the associated node
1372 -- of the copy of that Itype accordingly.
1374 if Present (Actual_Map) then
1380 -- Case of hash table used
1382 if NCT_Hash_Tables_Used then
1383 Ent := NCT_Itype_Assoc.Get (Old_Node);
1385 if Present (Ent) then
1386 Set_Associated_Node_For_Itype (Ent, New_Node);
1389 -- Case of no hash table used
1392 E := First_Elmt (Actual_Map);
1393 while Present (E) loop
1394 if Is_Itype (Node (E))
1396 Old_Node = Associated_Node_For_Itype (Node (E))
1398 Set_Associated_Node_For_Itype
1399 (Node (Next_Elmt (E)), New_Node);
1402 E := Next_Elmt (Next_Elmt (E));
1408 -- Recursively copy descendents
1411 (New_Node, Copy_Field_With_Replacement (Field1 (New_Node)));
1413 (New_Node, Copy_Field_With_Replacement (Field2 (New_Node)));
1415 (New_Node, Copy_Field_With_Replacement (Field3 (New_Node)));
1417 (New_Node, Copy_Field_With_Replacement (Field4 (New_Node)));
1419 (New_Node, Copy_Field_With_Replacement (Field5 (New_Node)));
1421 -- If the original is marked as a rewrite insertion, then unmark
1422 -- the copy, since we inserted the original, not the copy.
1424 Nodes.Table (New_Node).Rewrite_Ins := False;
1426 -- Adjust Sloc of new node if necessary
1428 if New_Sloc /= No_Location then
1429 Set_Sloc (New_Node, New_Sloc);
1431 -- If we adjust the Sloc, then we are essentially making
1432 -- a completely new node, so the Comes_From_Source flag
1433 -- should be reset to the proper default value.
1435 Nodes.Table (New_Node).Comes_From_Source :=
1436 Default_Node.Comes_From_Source;
1439 -- Reset First_Real_Statement for Handled_Sequence_Of_Statements.
1440 -- The replacement mechanism applies to entities, and is not used
1441 -- here. Eventually we may need a more general graph-copying
1442 -- routine. For now, do a sequential search to find desired node.
1444 if Nkind (Old_Node) = N_Handled_Sequence_Of_Statements
1445 and then Present (First_Real_Statement (Old_Node))
1448 Old_F : constant Node_Id := First_Real_Statement (Old_Node);
1452 N1 := First (Statements (Old_Node));
1453 N2 := First (Statements (New_Node));
1455 while N1 /= Old_F loop
1460 Set_First_Real_Statement (New_Node, N2);
1465 -- All done, return copied node
1468 end Copy_Node_With_Replacement;
1474 procedure Visit_Elist (E : Elist_Id) is
1479 Elmt := First_Elmt (E);
1481 while Elmt /= No_Elmt loop
1482 Visit_Node (Node (Elmt));
1492 procedure Visit_Field (F : Union_Id; N : Node_Id) is
1494 if F = Union_Id (Empty) then
1497 elsif F in Node_Range then
1499 -- Copy node if it is syntactic, i.e. its parent pointer is
1500 -- set to point to the field that referenced it (certain
1501 -- Itypes will also meet this criterion, which is fine, since
1502 -- these are clearly Itypes that do need to be copied, since
1503 -- we are copying their parent.)
1505 if Parent (Node_Id (F)) = N then
1506 Visit_Node (Node_Id (F));
1509 -- Another case, if we are pointing to an Itype, then we want
1510 -- to copy it if its associated node is somewhere in the tree
1513 -- Note: the exclusion of self-referential copies is just an
1514 -- optimization, since the search of the already copied list
1515 -- would catch it, but it is a common case (Etype pointing
1516 -- to itself for an Itype that is a base type).
1518 elsif Has_Extension (Node_Id (F))
1519 and then Is_Itype (Entity_Id (F))
1520 and then Node_Id (F) /= N
1526 P := Associated_Node_For_Itype (Node_Id (F));
1527 while Present (P) loop
1529 Visit_Node (Node_Id (F));
1536 -- An Itype whose parent is not being copied definitely
1537 -- should NOT be copied, since it does not belong in any
1538 -- sense to the copied subtree.
1544 elsif F in List_Range
1545 and then Parent (List_Id (F)) = N
1547 Visit_List (List_Id (F));
1556 -- Note: we are relying on far too much semantic knowledge in this
1557 -- routine, it really should just do a blind replacement of all
1558 -- fields, or at least a more blind replacement. For example, we
1559 -- do not deal with corresponding record types, and that works
1560 -- because we have no Itypes of task types, but nowhere is there
1561 -- a guarantee that this will always be the case. ???
1563 procedure Visit_Itype (Old_Itype : Entity_Id) is
1564 New_Itype : Entity_Id;
1569 -- Itypes that describe the designated type of access to subprograms
1570 -- have the structure of subprogram declarations, with signatures,
1571 -- etc. Either we duplicate the signatures completely, or choose to
1572 -- share such itypes, which is fine because their elaboration will
1573 -- have no side effects. In any case, this is additional semantic
1574 -- information that seems awkward to have in atree.
1576 if Ekind (Old_Itype) = E_Subprogram_Type then
1580 New_Itype := New_Copy (Old_Itype);
1582 -- If our associated node is an entity that has already been copied,
1583 -- then set the associated node of the copy to point to the right
1584 -- copy. If we have copied an Itype that is itself the associated
1585 -- node of some previously copied Itype, then we set the right
1586 -- pointer in the other direction.
1588 if Present (Actual_Map) then
1590 -- Case of hash tables used
1592 if NCT_Hash_Tables_Used then
1594 Ent := NCT_Assoc.Get (Associated_Node_For_Itype (Old_Itype));
1595 if Present (Ent) then
1596 Set_Associated_Node_For_Itype (New_Itype, Ent);
1599 Ent := NCT_Itype_Assoc.Get (Old_Itype);
1600 if Present (Ent) then
1601 Set_Associated_Node_For_Itype (Ent, New_Itype);
1604 -- Case of hash tables not used
1607 E := First_Elmt (Actual_Map);
1608 while Present (E) loop
1609 if Associated_Node_For_Itype (Old_Itype) = Node (E) then
1610 Set_Associated_Node_For_Itype
1611 (New_Itype, Node (Next_Elmt (E)));
1614 if Is_Type (Node (E))
1616 Old_Itype = Associated_Node_For_Itype (Node (E))
1618 Set_Associated_Node_For_Itype
1619 (Node (Next_Elmt (E)), New_Itype);
1622 E := Next_Elmt (Next_Elmt (E));
1627 if Present (Freeze_Node (New_Itype)) then
1628 Set_Is_Frozen (New_Itype, False);
1629 Set_Freeze_Node (New_Itype, Empty);
1632 -- Add new association to map
1634 if No (Actual_Map) then
1635 Actual_Map := New_Elmt_List;
1638 Append_Elmt (Old_Itype, Actual_Map);
1639 Append_Elmt (New_Itype, Actual_Map);
1641 if NCT_Hash_Tables_Used then
1642 NCT_Assoc.Set (Old_Itype, New_Itype);
1645 NCT_Table_Entries := NCT_Table_Entries + 1;
1647 if NCT_Table_Entries > NCT_Hash_Threshhold then
1648 Build_NCT_Hash_Tables;
1652 -- If a record subtype is simply copied, the entity list will be
1653 -- shared. Thus cloned_Subtype must be set to indicate the sharing.
1655 if Ekind (Old_Itype) = E_Record_Subtype
1656 or else Ekind (Old_Itype) = E_Class_Wide_Subtype
1658 Set_Cloned_Subtype (New_Itype, Old_Itype);
1661 -- Visit descendents that eventually get copied
1663 Visit_Field (Union_Id (Etype (Old_Itype)), Old_Itype);
1665 if Is_Discrete_Type (Old_Itype) then
1666 Visit_Field (Union_Id (Scalar_Range (Old_Itype)), Old_Itype);
1668 elsif Has_Discriminants (Base_Type (Old_Itype)) then
1669 -- ??? This should involve call to Visit_Field.
1670 Visit_Elist (Discriminant_Constraint (Old_Itype));
1672 elsif Is_Array_Type (Old_Itype) then
1673 if Present (First_Index (Old_Itype)) then
1674 Visit_Field (Union_Id (List_Containing
1675 (First_Index (Old_Itype))),
1679 if Is_Packed (Old_Itype) then
1680 Visit_Field (Union_Id (Packed_Array_Type (Old_Itype)),
1690 procedure Visit_List (L : List_Id) is
1694 if L /= No_List then
1697 while Present (N) loop
1708 procedure Visit_Node (N : Node_Or_Entity_Id) is
1710 -- Start of processing for Visit_Node
1713 -- Handle case of an Itype, which must be copied
1715 if Has_Extension (N)
1716 and then Is_Itype (N)
1718 -- Nothing to do if already in the list. This can happen with an
1719 -- Itype entity that appears more than once in the tree.
1720 -- Note that we do not want to visit descendents in this case.
1722 -- Test for already in list when hash table is used
1724 if NCT_Hash_Tables_Used then
1725 if Present (NCT_Assoc.Get (Entity_Id (N))) then
1729 -- Test for already in list when hash table not used
1736 if Present (Actual_Map) then
1737 E := First_Elmt (Actual_Map);
1738 while Present (E) loop
1739 if Node (E) = N then
1742 E := Next_Elmt (Next_Elmt (E));
1752 -- Visit descendents
1754 Visit_Field (Field1 (N), N);
1755 Visit_Field (Field2 (N), N);
1756 Visit_Field (Field3 (N), N);
1757 Visit_Field (Field4 (N), N);
1758 Visit_Field (Field5 (N), N);
1761 -- Start of processing for New_Copy_Tree
1766 -- See if we should use hash table
1768 if No (Actual_Map) then
1769 NCT_Hash_Tables_Used := False;
1776 NCT_Table_Entries := 0;
1777 Elmt := First_Elmt (Actual_Map);
1778 while Present (Elmt) loop
1779 NCT_Table_Entries := NCT_Table_Entries + 1;
1784 if NCT_Table_Entries > NCT_Hash_Threshhold then
1785 Build_NCT_Hash_Tables;
1787 NCT_Hash_Tables_Used := False;
1792 -- Hash table set up if required, now start phase one by visiting
1793 -- top node (we will recursively visit the descendents).
1795 Visit_Node (Source);
1797 -- Now the second phase of the copy can start. First we process
1798 -- all the mapped entities, copying their descendents.
1800 if Present (Actual_Map) then
1803 New_Itype : Entity_Id;
1806 Elmt := First_Elmt (Actual_Map);
1807 while Present (Elmt) loop
1809 New_Itype := Node (Elmt);
1810 Copy_Itype_With_Replacement (New_Itype);
1816 -- Now we can copy the actual tree
1818 return Copy_Node_With_Replacement (Source);
1826 (New_Node_Kind : Node_Kind;
1827 New_Sloc : Source_Ptr)
1832 procedure New_Entity_Debugging_Output;
1833 -- Debugging routine for debug flag N
1835 ---------------------------------
1836 -- New_Entity_Debugging_Output --
1837 ---------------------------------
1839 procedure New_Entity_Debugging_Output is
1841 if Debug_Flag_N then
1842 Write_Str ("Allocate entity, Id = ");
1843 Write_Int (Int (Nodes.Last));
1845 Write_Location (New_Sloc);
1847 Write_Str (Node_Kind'Image (New_Node_Kind));
1850 end New_Entity_Debugging_Output;
1852 pragma Inline (New_Entity_Debugging_Output);
1854 -- Start of processing for New_Entity
1857 pragma Assert (New_Node_Kind in N_Entity);
1859 Nodes.Increment_Last;
1862 -- If this is a node with a real location and we are generating
1863 -- source nodes, then reset Current_Error_Node. This is useful
1864 -- if we bomb during parsing to get a error location for the bomb.
1866 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1867 Current_Error_Node := Ent;
1870 Nodes.Table (Nodes.Last) := Default_Node;
1871 Nodes.Table (Nodes.Last).Nkind := New_Node_Kind;
1872 Nodes.Table (Nodes.Last).Sloc := New_Sloc;
1873 pragma Debug (New_Entity_Debugging_Output);
1875 Orig_Nodes.Increment_Last;
1876 Orig_Nodes.Table (Nodes.Last) := Nodes.Last;
1878 Nodes.Increment_Last;
1879 Nodes.Table (Nodes.Last) := Default_Node_Extension;
1881 Nodes.Increment_Last;
1882 Nodes.Table (Nodes.Last) := Default_Node_Extension;
1884 Nodes.Increment_Last;
1885 Nodes.Table (Nodes.Last) := Default_Node_Extension;
1887 Orig_Nodes.Set_Last (Nodes.Last);
1888 Allocate_List_Tables (Nodes.Last);
1889 Node_Count := Node_Count + 1;
1898 (New_Node_Kind : Node_Kind;
1899 New_Sloc : Source_Ptr)
1904 procedure New_Node_Debugging_Output;
1905 -- Debugging routine for debug flag N
1907 --------------------------
1908 -- New_Debugging_Output --
1909 --------------------------
1911 procedure New_Node_Debugging_Output is
1913 if Debug_Flag_N then
1914 Write_Str ("Allocate node, Id = ");
1915 Write_Int (Int (Nodes.Last));
1917 Write_Location (New_Sloc);
1919 Write_Str (Node_Kind'Image (New_Node_Kind));
1922 end New_Node_Debugging_Output;
1924 pragma Inline (New_Node_Debugging_Output);
1926 -- Start of processing for New_Node
1929 pragma Assert (New_Node_Kind not in N_Entity);
1930 Nodes.Increment_Last;
1931 Nodes.Table (Nodes.Last) := Default_Node;
1932 Nodes.Table (Nodes.Last).Nkind := New_Node_Kind;
1933 Nodes.Table (Nodes.Last).Sloc := New_Sloc;
1934 pragma Debug (New_Node_Debugging_Output);
1937 -- If this is a node with a real location and we are generating
1938 -- source nodes, then reset Current_Error_Node. This is useful
1939 -- if we bomb during parsing to get a error location for the bomb.
1941 if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1942 Current_Error_Node := Nod;
1945 Node_Count := Node_Count + 1;
1946 Orig_Nodes.Increment_Last;
1947 Allocate_List_Tables (Nodes.Last);
1948 Orig_Nodes.Table (Nodes.Last) := Nodes.Last;
1956 function Nkind (N : Node_Id) return Node_Kind is
1958 return Nodes.Table (N).Nkind;
1965 function No (N : Node_Id) return Boolean is
1974 function Nodes_Address return System.Address is
1976 return Nodes.Table (First_Node_Id)'Address;
1983 function Num_Nodes return Nat is
1992 function Original_Node (Node : Node_Id) return Node_Id is
1994 return Orig_Nodes.Table (Node);
2001 function Paren_Count (N : Node_Id) return Paren_Count_Type is
2002 C : Paren_Count_Type := 0;
2005 pragma Assert (N in Nodes.First .. Nodes.Last);
2007 if Nodes.Table (N).Pflag1 then
2011 if Nodes.Table (N).Pflag2 then
2022 function Parent (N : Node_Id) return Node_Id is
2024 if Is_List_Member (N) then
2025 return Parent (List_Containing (N));
2027 return Node_Id (Nodes.Table (N).Link);
2035 function Present (N : Node_Id) return Boolean is
2040 --------------------------------
2041 -- Preserve_Comes_From_Source --
2042 --------------------------------
2044 procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is
2046 Nodes.Table (NewN).Comes_From_Source :=
2047 Nodes.Table (OldN).Comes_From_Source;
2048 end Preserve_Comes_From_Source;
2054 function Relocate_Node (Source : Node_Id) return Node_Id is
2062 New_Node := New_Copy (Source);
2063 Fix_Parent (Field1 (Source), Source, New_Node);
2064 Fix_Parent (Field2 (Source), Source, New_Node);
2065 Fix_Parent (Field3 (Source), Source, New_Node);
2066 Fix_Parent (Field4 (Source), Source, New_Node);
2067 Fix_Parent (Field5 (Source), Source, New_Node);
2069 -- We now set the parent of the new node to be the same as the
2070 -- parent of the source. Almost always this parent will be
2071 -- replaced by a new value when the relocated node is reattached
2072 -- to the tree, but by doing it now, we ensure that this node is
2073 -- not even temporarily disconnected from the tree. Note that this
2074 -- does not happen free, because in the list case, the parent does
2077 Set_Parent (New_Node, Parent (Source));
2079 -- If the node being relocated was a rewriting of some original
2080 -- node, then the relocated node has the same original node.
2082 if Orig_Nodes.Table (Source) /= Source then
2083 Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source);
2093 procedure Replace (Old_Node, New_Node : Node_Id) is
2094 Old_Link : constant Union_Id := Nodes.Table (Old_Node).Link;
2095 Old_InL : constant Boolean := Nodes.Table (Old_Node).In_List;
2096 Old_Post : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
2097 Old_CFS : constant Boolean := Nodes.Table (Old_Node).Comes_From_Source;
2101 (not Has_Extension (Old_Node)
2102 and not Has_Extension (New_Node)
2103 and not Nodes.Table (New_Node).In_List);
2105 -- Do copy, preserving link and in list status and comes from source
2107 Nodes.Table (Old_Node) := Nodes.Table (New_Node);
2108 Nodes.Table (Old_Node).Link := Old_Link;
2109 Nodes.Table (Old_Node).In_List := Old_InL;
2110 Nodes.Table (Old_Node).Comes_From_Source := Old_CFS;
2111 Nodes.Table (Old_Node).Error_Posted := Old_Post;
2113 -- Fix parents of substituted node, since it has changed identity
2115 Fix_Parent (Field1 (Old_Node), New_Node, Old_Node);
2116 Fix_Parent (Field2 (Old_Node), New_Node, Old_Node);
2117 Fix_Parent (Field3 (Old_Node), New_Node, Old_Node);
2118 Fix_Parent (Field4 (Old_Node), New_Node, Old_Node);
2119 Fix_Parent (Field5 (Old_Node), New_Node, Old_Node);
2121 -- Since we are doing a replace, we assume that the original node
2122 -- is intended to become the new replaced node. The call would be
2123 -- to Rewrite_Substitute_Node if there were an intention to save
2124 -- the original node.
2126 Orig_Nodes.Table (Old_Node) := Old_Node;
2128 -- Finally delete the source, since it is now copied
2130 Delete_Node (New_Node);
2137 procedure Rewrite (Old_Node, New_Node : Node_Id) is
2139 Old_Link : constant Union_Id := Nodes.Table (Old_Node).Link;
2140 Old_In_List : constant Boolean := Nodes.Table (Old_Node).In_List;
2141 Old_Error_P : constant Boolean := Nodes.Table (Old_Node).Error_Posted;
2142 -- These three fields are always preserved in the new node
2144 Old_Paren_Count : Paren_Count_Type;
2145 Old_Must_Not_Freeze : Boolean;
2146 -- These fields are preserved in the new node only if the new node
2147 -- and the old node are both subexpression nodes.
2149 -- Note: it is a violation of abstraction levels for Must_Not_Freeze
2150 -- to be referenced like this. ???
2156 (not Has_Extension (Old_Node)
2157 and not Has_Extension (New_Node)
2158 and not Nodes.Table (New_Node).In_List);
2160 if Nkind (Old_Node) in N_Subexpr then
2161 Old_Paren_Count := Paren_Count (Old_Node);
2162 Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node);
2164 Old_Paren_Count := 0;
2165 Old_Must_Not_Freeze := False;
2168 -- Allocate a new node, to be used to preserve the original contents
2169 -- of the Old_Node, for possible later retrival by Original_Node and
2170 -- make an entry in the Orig_Nodes table. This is only done if we have
2171 -- not already rewritten the node, as indicated by an Orig_Nodes entry
2172 -- that does not reference the Old_Node.
2174 if Orig_Nodes.Table (Old_Node) = Old_Node then
2175 Nodes.Increment_Last;
2176 Sav_Node := Nodes.Last;
2177 Nodes.Table (Sav_Node) := Nodes.Table (Old_Node);
2178 Nodes.Table (Sav_Node).In_List := False;
2179 Nodes.Table (Sav_Node).Link := Union_Id (Parent (Old_Node));
2181 Orig_Nodes.Increment_Last;
2182 Allocate_List_Tables (Nodes.Last);
2184 Orig_Nodes.Table (Sav_Node) := Sav_Node;
2185 Orig_Nodes.Table (Old_Node) := Sav_Node;
2188 -- Copy substitute node into place, preserving old fields as required
2190 Nodes.Table (Old_Node) := Nodes.Table (New_Node);
2191 Nodes.Table (Old_Node).Link := Old_Link;
2192 Nodes.Table (Old_Node).In_List := Old_In_List;
2193 Nodes.Table (Old_Node).Error_Posted := Old_Error_P;
2195 if Nkind (New_Node) in N_Subexpr then
2196 Set_Paren_Count (Old_Node, Old_Paren_Count);
2197 Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze);
2200 Fix_Parent (Field1 (Old_Node), New_Node, Old_Node);
2201 Fix_Parent (Field2 (Old_Node), New_Node, Old_Node);
2202 Fix_Parent (Field3 (Old_Node), New_Node, Old_Node);
2203 Fix_Parent (Field4 (Old_Node), New_Node, Old_Node);
2204 Fix_Parent (Field5 (Old_Node), New_Node, Old_Node);
2211 procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is
2213 Nodes.Table (N).Analyzed := Val;
2216 ---------------------------
2217 -- Set_Comes_From_Source --
2218 ---------------------------
2220 procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is
2222 pragma Assert (N in Nodes.First .. Nodes.Last);
2223 Nodes.Table (N).Comes_From_Source := Val;
2224 end Set_Comes_From_Source;
2226 -----------------------------------
2227 -- Set_Comes_From_Source_Default --
2228 -----------------------------------
2230 procedure Set_Comes_From_Source_Default (Default : Boolean) is
2232 Default_Node.Comes_From_Source := Default;
2233 end Set_Comes_From_Source_Default;
2235 --------------------
2236 -- Set_Convention --
2237 --------------------
2239 procedure Set_Convention (E : Entity_Id; Val : Convention_Id) is
2241 pragma Assert (Nkind (E) in N_Entity);
2244 (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention :=
2252 procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is
2254 pragma Assert (Nkind (E) in N_Entity);
2255 Nodes.Table (E + 1).Nkind := E_To_N (Val);
2258 ----------------------
2259 -- Set_Error_Posted --
2260 ----------------------
2262 procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is
2264 Nodes.Table (N).Error_Posted := Val;
2265 end Set_Error_Posted;
2267 ---------------------
2268 -- Set_Paren_Count --
2269 ---------------------
2271 procedure Set_Paren_Count (N : Node_Id; Val : Paren_Count_Type) is
2273 pragma Assert (Nkind (N) in N_Subexpr);
2274 Nodes.Table (N).Pflag1 := (Val mod 2 /= 0);
2275 Nodes.Table (N).Pflag2 := (Val >= 2);
2276 end Set_Paren_Count;
2282 procedure Set_Parent (N : Node_Id; Val : Node_Id) is
2284 pragma Assert (not Nodes.Table (N).In_List);
2285 Nodes.Table (N).Link := Union_Id (Val);
2292 procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is
2294 Nodes.Table (N).Sloc := Val;
2301 function Sloc (N : Node_Id) return Source_Ptr is
2303 return Nodes.Table (N).Sloc;
2310 function Traverse_Func (Node : Node_Id) return Traverse_Result is
2312 function Traverse_Field (Fld : Union_Id) return Traverse_Result;
2313 -- Fld is one of the fields of Node. If the field points to a
2314 -- syntactic node or list, then this node or list is traversed,
2315 -- and the result is the result of this traversal. Otherwise
2316 -- a value of True is returned with no processing.
2318 --------------------
2319 -- Traverse_Field --
2320 --------------------
2322 function Traverse_Field (Fld : Union_Id) return Traverse_Result is
2324 if Fld = Union_Id (Empty) then
2327 -- Descendent is a node
2329 elsif Fld in Node_Range then
2331 -- Traverse descendent that is syntactic subtree node
2333 if Parent (Node_Id (Fld)) = Node
2334 or else Original_Node (Parent (Node_Id (Fld))) = Node
2336 return Traverse_Func (Node_Id (Fld));
2338 -- Node that is not a syntactic subtree
2344 -- Descendent is a list
2346 elsif Fld in List_Range then
2348 -- Traverse descendent that is a syntactic subtree list
2350 if Parent (List_Id (Fld)) = Node
2351 or else Original_Node (Parent (List_Id (Fld))) = Node
2354 Elmt : Node_Id := First (List_Id (Fld));
2356 while Present (Elmt) loop
2357 if Traverse_Func (Elmt) = Abandon then
2367 -- List that is not a syntactic subtree
2373 -- Field was not a node or a list
2380 -- Start of processing for Traverse_Func
2383 case Process (Node) is
2391 if Traverse_Field (Union_Id (Field1 (Node))) = Abandon
2393 Traverse_Field (Union_Id (Field2 (Node))) = Abandon
2395 Traverse_Field (Union_Id (Field3 (Node))) = Abandon
2397 Traverse_Field (Union_Id (Field4 (Node))) = Abandon
2399 Traverse_Field (Union_Id (Field5 (Node))) = Abandon
2409 Onode : constant Node_Id := Original_Node (Node);
2412 if Traverse_Field (Union_Id (Field1 (Onode))) = Abandon
2414 Traverse_Field (Union_Id (Field2 (Onode))) = Abandon
2416 Traverse_Field (Union_Id (Field3 (Onode))) = Abandon
2418 Traverse_Field (Union_Id (Field4 (Onode))) = Abandon
2420 Traverse_Field (Union_Id (Field5 (Onode))) = Abandon
2435 procedure Traverse_Proc (Node : Node_Id) is
2436 function Traverse is new Traverse_Func (Process);
2437 Discard : Traverse_Result;
2438 pragma Warnings (Off, Discard);
2441 Discard := Traverse (Node);
2448 procedure Tree_Read is
2450 Tree_Read_Int (Node_Count);
2452 Orig_Nodes.Tree_Read;
2459 procedure Tree_Write is
2461 Tree_Write_Int (Node_Count);
2463 Orig_Nodes.Tree_Write;
2466 ------------------------------
2467 -- Unchecked Access Package --
2468 ------------------------------
2470 package body Unchecked_Access is
2472 function Field1 (N : Node_Id) return Union_Id is
2474 pragma Assert (N in Nodes.First .. Nodes.Last);
2475 return Nodes.Table (N).Field1;
2478 function Field2 (N : Node_Id) return Union_Id is
2480 pragma Assert (N in Nodes.First .. Nodes.Last);
2481 return Nodes.Table (N).Field2;
2484 function Field3 (N : Node_Id) return Union_Id is
2486 pragma Assert (N in Nodes.First .. Nodes.Last);
2487 return Nodes.Table (N).Field3;
2490 function Field4 (N : Node_Id) return Union_Id is
2492 pragma Assert (N in Nodes.First .. Nodes.Last);
2493 return Nodes.Table (N).Field4;
2496 function Field5 (N : Node_Id) return Union_Id is
2498 pragma Assert (N in Nodes.First .. Nodes.Last);
2499 return Nodes.Table (N).Field5;
2502 function Field6 (N : Node_Id) return Union_Id is
2504 pragma Assert (Nkind (N) in N_Entity);
2505 return Nodes.Table (N + 1).Field6;
2508 function Field7 (N : Node_Id) return Union_Id is
2510 pragma Assert (Nkind (N) in N_Entity);
2511 return Nodes.Table (N + 1).Field7;
2514 function Field8 (N : Node_Id) return Union_Id is
2516 pragma Assert (Nkind (N) in N_Entity);
2517 return Nodes.Table (N + 1).Field8;
2520 function Field9 (N : Node_Id) return Union_Id is
2522 pragma Assert (Nkind (N) in N_Entity);
2523 return Nodes.Table (N + 1).Field9;
2526 function Field10 (N : Node_Id) return Union_Id is
2528 pragma Assert (Nkind (N) in N_Entity);
2529 return Nodes.Table (N + 1).Field10;
2532 function Field11 (N : Node_Id) return Union_Id is
2534 pragma Assert (Nkind (N) in N_Entity);
2535 return Nodes.Table (N + 1).Field11;
2538 function Field12 (N : Node_Id) return Union_Id is
2540 pragma Assert (Nkind (N) in N_Entity);
2541 return Nodes.Table (N + 1).Field12;
2544 function Field13 (N : Node_Id) return Union_Id is
2546 pragma Assert (Nkind (N) in N_Entity);
2547 return Nodes.Table (N + 2).Field6;
2550 function Field14 (N : Node_Id) return Union_Id is
2552 pragma Assert (Nkind (N) in N_Entity);
2553 return Nodes.Table (N + 2).Field7;
2556 function Field15 (N : Node_Id) return Union_Id is
2558 pragma Assert (Nkind (N) in N_Entity);
2559 return Nodes.Table (N + 2).Field8;
2562 function Field16 (N : Node_Id) return Union_Id is
2564 pragma Assert (Nkind (N) in N_Entity);
2565 return Nodes.Table (N + 2).Field9;
2568 function Field17 (N : Node_Id) return Union_Id is
2570 pragma Assert (Nkind (N) in N_Entity);
2571 return Nodes.Table (N + 2).Field10;
2574 function Field18 (N : Node_Id) return Union_Id is
2576 pragma Assert (Nkind (N) in N_Entity);
2577 return Nodes.Table (N + 2).Field11;
2580 function Field19 (N : Node_Id) return Union_Id is
2582 pragma Assert (Nkind (N) in N_Entity);
2583 return Nodes.Table (N + 3).Field6;
2586 function Field20 (N : Node_Id) return Union_Id is
2588 pragma Assert (Nkind (N) in N_Entity);
2589 return Nodes.Table (N + 3).Field7;
2592 function Field21 (N : Node_Id) return Union_Id is
2594 pragma Assert (Nkind (N) in N_Entity);
2595 return Nodes.Table (N + 3).Field8;
2598 function Field22 (N : Node_Id) return Union_Id is
2600 pragma Assert (Nkind (N) in N_Entity);
2601 return Nodes.Table (N + 3).Field9;
2604 function Field23 (N : Node_Id) return Union_Id is
2606 pragma Assert (Nkind (N) in N_Entity);
2607 return Nodes.Table (N + 3).Field10;
2610 function Node1 (N : Node_Id) return Node_Id is
2612 pragma Assert (N in Nodes.First .. Nodes.Last);
2613 return Node_Id (Nodes.Table (N).Field1);
2616 function Node2 (N : Node_Id) return Node_Id is
2618 pragma Assert (N in Nodes.First .. Nodes.Last);
2619 return Node_Id (Nodes.Table (N).Field2);
2622 function Node3 (N : Node_Id) return Node_Id is
2624 pragma Assert (N in Nodes.First .. Nodes.Last);
2625 return Node_Id (Nodes.Table (N).Field3);
2628 function Node4 (N : Node_Id) return Node_Id is
2630 pragma Assert (N in Nodes.First .. Nodes.Last);
2631 return Node_Id (Nodes.Table (N).Field4);
2634 function Node5 (N : Node_Id) return Node_Id is
2636 pragma Assert (N in Nodes.First .. Nodes.Last);
2637 return Node_Id (Nodes.Table (N).Field5);
2640 function Node6 (N : Node_Id) return Node_Id is
2642 pragma Assert (Nkind (N) in N_Entity);
2643 return Node_Id (Nodes.Table (N + 1).Field6);
2646 function Node7 (N : Node_Id) return Node_Id is
2648 pragma Assert (Nkind (N) in N_Entity);
2649 return Node_Id (Nodes.Table (N + 1).Field7);
2652 function Node8 (N : Node_Id) return Node_Id is
2654 pragma Assert (Nkind (N) in N_Entity);
2655 return Node_Id (Nodes.Table (N + 1).Field8);
2658 function Node9 (N : Node_Id) return Node_Id is
2660 pragma Assert (Nkind (N) in N_Entity);
2661 return Node_Id (Nodes.Table (N + 1).Field9);
2664 function Node10 (N : Node_Id) return Node_Id is
2666 pragma Assert (Nkind (N) in N_Entity);
2667 return Node_Id (Nodes.Table (N + 1).Field10);
2670 function Node11 (N : Node_Id) return Node_Id is
2672 pragma Assert (Nkind (N) in N_Entity);
2673 return Node_Id (Nodes.Table (N + 1).Field11);
2676 function Node12 (N : Node_Id) return Node_Id is
2678 pragma Assert (Nkind (N) in N_Entity);
2679 return Node_Id (Nodes.Table (N + 1).Field12);
2682 function Node13 (N : Node_Id) return Node_Id is
2684 pragma Assert (Nkind (N) in N_Entity);
2685 return Node_Id (Nodes.Table (N + 2).Field6);
2688 function Node14 (N : Node_Id) return Node_Id is
2690 pragma Assert (Nkind (N) in N_Entity);
2691 return Node_Id (Nodes.Table (N + 2).Field7);
2694 function Node15 (N : Node_Id) return Node_Id is
2696 pragma Assert (Nkind (N) in N_Entity);
2697 return Node_Id (Nodes.Table (N + 2).Field8);
2700 function Node16 (N : Node_Id) return Node_Id is
2702 pragma Assert (Nkind (N) in N_Entity);
2703 return Node_Id (Nodes.Table (N + 2).Field9);
2706 function Node17 (N : Node_Id) return Node_Id is
2708 pragma Assert (Nkind (N) in N_Entity);
2709 return Node_Id (Nodes.Table (N + 2).Field10);
2712 function Node18 (N : Node_Id) return Node_Id is
2714 pragma Assert (Nkind (N) in N_Entity);
2715 return Node_Id (Nodes.Table (N + 2).Field11);
2718 function Node19 (N : Node_Id) return Node_Id is
2720 pragma Assert (Nkind (N) in N_Entity);
2721 return Node_Id (Nodes.Table (N + 3).Field6);
2724 function Node20 (N : Node_Id) return Node_Id is
2726 pragma Assert (Nkind (N) in N_Entity);
2727 return Node_Id (Nodes.Table (N + 3).Field7);
2730 function Node21 (N : Node_Id) return Node_Id is
2732 pragma Assert (Nkind (N) in N_Entity);
2733 return Node_Id (Nodes.Table (N + 3).Field8);
2736 function Node22 (N : Node_Id) return Node_Id is
2738 pragma Assert (Nkind (N) in N_Entity);
2739 return Node_Id (Nodes.Table (N + 3).Field9);
2742 function Node23 (N : Node_Id) return Node_Id is
2744 pragma Assert (Nkind (N) in N_Entity);
2745 return Node_Id (Nodes.Table (N + 3).Field10);
2748 function List1 (N : Node_Id) return List_Id is
2750 pragma Assert (N in Nodes.First .. Nodes.Last);
2751 return List_Id (Nodes.Table (N).Field1);
2754 function List2 (N : Node_Id) return List_Id is
2756 pragma Assert (N in Nodes.First .. Nodes.Last);
2757 return List_Id (Nodes.Table (N).Field2);
2760 function List3 (N : Node_Id) return List_Id is
2762 pragma Assert (N in Nodes.First .. Nodes.Last);
2763 return List_Id (Nodes.Table (N).Field3);
2766 function List4 (N : Node_Id) return List_Id is
2768 pragma Assert (N in Nodes.First .. Nodes.Last);
2769 return List_Id (Nodes.Table (N).Field4);
2772 function List5 (N : Node_Id) return List_Id is
2774 pragma Assert (N in Nodes.First .. Nodes.Last);
2775 return List_Id (Nodes.Table (N).Field5);
2778 function List10 (N : Node_Id) return List_Id is
2780 pragma Assert (Nkind (N) in N_Entity);
2781 return List_Id (Nodes.Table (N + 1).Field10);
2784 function List14 (N : Node_Id) return List_Id is
2786 pragma Assert (Nkind (N) in N_Entity);
2787 return List_Id (Nodes.Table (N + 2).Field7);
2790 function Elist2 (N : Node_Id) return Elist_Id is
2792 return Elist_Id (Nodes.Table (N).Field2);
2795 function Elist3 (N : Node_Id) return Elist_Id is
2797 return Elist_Id (Nodes.Table (N).Field3);
2800 function Elist4 (N : Node_Id) return Elist_Id is
2802 return Elist_Id (Nodes.Table (N).Field4);
2805 function Elist8 (N : Node_Id) return Elist_Id is
2807 pragma Assert (Nkind (N) in N_Entity);
2808 return Elist_Id (Nodes.Table (N + 1).Field8);
2811 function Elist13 (N : Node_Id) return Elist_Id is
2813 pragma Assert (Nkind (N) in N_Entity);
2814 return Elist_Id (Nodes.Table (N + 2).Field6);
2817 function Elist15 (N : Node_Id) return Elist_Id is
2819 pragma Assert (Nkind (N) in N_Entity);
2820 return Elist_Id (Nodes.Table (N + 2).Field8);
2823 function Elist16 (N : Node_Id) return Elist_Id is
2825 pragma Assert (Nkind (N) in N_Entity);
2826 return Elist_Id (Nodes.Table (N + 2).Field9);
2829 function Elist18 (N : Node_Id) return Elist_Id is
2831 pragma Assert (Nkind (N) in N_Entity);
2832 return Elist_Id (Nodes.Table (N + 2).Field11);
2835 function Elist21 (N : Node_Id) return Elist_Id is
2837 pragma Assert (Nkind (N) in N_Entity);
2838 return Elist_Id (Nodes.Table (N + 3).Field8);
2841 function Elist23 (N : Node_Id) return Elist_Id is
2843 pragma Assert (Nkind (N) in N_Entity);
2844 return Elist_Id (Nodes.Table (N + 3).Field10);
2847 function Name1 (N : Node_Id) return Name_Id is
2849 pragma Assert (N in Nodes.First .. Nodes.Last);
2850 return Name_Id (Nodes.Table (N).Field1);
2853 function Name2 (N : Node_Id) return Name_Id is
2855 pragma Assert (N in Nodes.First .. Nodes.Last);
2856 return Name_Id (Nodes.Table (N).Field2);
2859 function Str3 (N : Node_Id) return String_Id is
2861 pragma Assert (N in Nodes.First .. Nodes.Last);
2862 return String_Id (Nodes.Table (N).Field3);
2865 function Char_Code2 (N : Node_Id) return Char_Code is
2867 pragma Assert (N in Nodes.First .. Nodes.Last);
2868 return Char_Code (Nodes.Table (N).Field2 - Char_Code_Bias);
2871 function Uint3 (N : Node_Id) return Uint is
2872 pragma Assert (N in Nodes.First .. Nodes.Last);
2873 U : constant Union_Id := Nodes.Table (N).Field3;
2879 return From_Union (U);
2883 function Uint4 (N : Node_Id) return Uint is
2884 pragma Assert (N in Nodes.First .. Nodes.Last);
2885 U : constant Union_Id := Nodes.Table (N).Field4;
2891 return From_Union (U);
2895 function Uint5 (N : Node_Id) return Uint is
2896 pragma Assert (N in Nodes.First .. Nodes.Last);
2897 U : constant Union_Id := Nodes.Table (N).Field5;
2903 return From_Union (U);
2907 function Uint8 (N : Node_Id) return Uint is
2908 pragma Assert (Nkind (N) in N_Entity);
2909 U : constant Union_Id := Nodes.Table (N + 1).Field8;
2915 return From_Union (U);
2919 function Uint9 (N : Node_Id) return Uint is
2920 pragma Assert (Nkind (N) in N_Entity);
2921 U : constant Union_Id := Nodes.Table (N + 1).Field9;
2927 return From_Union (U);
2931 function Uint11 (N : Node_Id) return Uint is
2932 pragma Assert (Nkind (N) in N_Entity);
2933 U : constant Union_Id := Nodes.Table (N + 1).Field11;
2939 return From_Union (U);
2943 function Uint10 (N : Node_Id) return Uint is
2944 pragma Assert (Nkind (N) in N_Entity);
2945 U : constant Union_Id := Nodes.Table (N + 1).Field10;
2951 return From_Union (U);
2955 function Uint12 (N : Node_Id) return Uint is
2956 pragma Assert (Nkind (N) in N_Entity);
2957 U : constant Union_Id := Nodes.Table (N + 1).Field12;
2963 return From_Union (U);
2967 function Uint13 (N : Node_Id) return Uint is
2968 pragma Assert (Nkind (N) in N_Entity);
2969 U : constant Union_Id := Nodes.Table (N + 2).Field6;
2975 return From_Union (U);
2979 function Uint14 (N : Node_Id) return Uint is
2980 pragma Assert (Nkind (N) in N_Entity);
2981 U : constant Union_Id := Nodes.Table (N + 2).Field7;
2987 return From_Union (U);
2991 function Uint15 (N : Node_Id) return Uint is
2992 pragma Assert (Nkind (N) in N_Entity);
2993 U : constant Union_Id := Nodes.Table (N + 2).Field8;
2999 return From_Union (U);
3003 function Uint16 (N : Node_Id) return Uint is
3004 pragma Assert (Nkind (N) in N_Entity);
3005 U : constant Union_Id := Nodes.Table (N + 2).Field9;
3011 return From_Union (U);
3015 function Uint17 (N : Node_Id) return Uint is
3016 pragma Assert (Nkind (N) in N_Entity);
3017 U : constant Union_Id := Nodes.Table (N + 2).Field10;
3023 return From_Union (U);
3027 function Uint22 (N : Node_Id) return Uint is
3028 pragma Assert (Nkind (N) in N_Entity);
3029 U : constant Union_Id := Nodes.Table (N + 3).Field9;
3035 return From_Union (U);
3039 function Ureal3 (N : Node_Id) return Ureal is
3041 pragma Assert (N in Nodes.First .. Nodes.Last);
3042 return From_Union (Nodes.Table (N).Field3);
3045 function Ureal18 (N : Node_Id) return Ureal is
3047 pragma Assert (Nkind (N) in N_Entity);
3048 return From_Union (Nodes.Table (N + 2).Field11);
3051 function Ureal21 (N : Node_Id) return Ureal is
3053 pragma Assert (Nkind (N) in N_Entity);
3054 return From_Union (Nodes.Table (N + 3).Field8);
3057 function Flag4 (N : Node_Id) return Boolean is
3059 pragma Assert (N in Nodes.First .. Nodes.Last);
3060 return Nodes.Table (N).Flag4;
3063 function Flag5 (N : Node_Id) return Boolean is
3065 pragma Assert (N in Nodes.First .. Nodes.Last);
3066 return Nodes.Table (N).Flag5;
3069 function Flag6 (N : Node_Id) return Boolean is
3071 pragma Assert (N in Nodes.First .. Nodes.Last);
3072 return Nodes.Table (N).Flag6;
3075 function Flag7 (N : Node_Id) return Boolean is
3077 pragma Assert (N in Nodes.First .. Nodes.Last);
3078 return Nodes.Table (N).Flag7;
3081 function Flag8 (N : Node_Id) return Boolean is
3083 pragma Assert (N in Nodes.First .. Nodes.Last);
3084 return Nodes.Table (N).Flag8;
3087 function Flag9 (N : Node_Id) return Boolean is
3089 pragma Assert (N in Nodes.First .. Nodes.Last);
3090 return Nodes.Table (N).Flag9;
3093 function Flag10 (N : Node_Id) return Boolean is
3095 pragma Assert (N in Nodes.First .. Nodes.Last);
3096 return Nodes.Table (N).Flag10;
3099 function Flag11 (N : Node_Id) return Boolean is
3101 pragma Assert (N in Nodes.First .. Nodes.Last);
3102 return Nodes.Table (N).Flag11;
3105 function Flag12 (N : Node_Id) return Boolean is
3107 pragma Assert (N in Nodes.First .. Nodes.Last);
3108 return Nodes.Table (N).Flag12;
3111 function Flag13 (N : Node_Id) return Boolean is
3113 pragma Assert (N in Nodes.First .. Nodes.Last);
3114 return Nodes.Table (N).Flag13;
3117 function Flag14 (N : Node_Id) return Boolean is
3119 pragma Assert (N in Nodes.First .. Nodes.Last);
3120 return Nodes.Table (N).Flag14;
3123 function Flag15 (N : Node_Id) return Boolean is
3125 pragma Assert (N in Nodes.First .. Nodes.Last);
3126 return Nodes.Table (N).Flag15;
3129 function Flag16 (N : Node_Id) return Boolean is
3131 pragma Assert (N in Nodes.First .. Nodes.Last);
3132 return Nodes.Table (N).Flag16;
3135 function Flag17 (N : Node_Id) return Boolean is
3137 pragma Assert (N in Nodes.First .. Nodes.Last);
3138 return Nodes.Table (N).Flag17;
3141 function Flag18 (N : Node_Id) return Boolean is
3143 pragma Assert (N in Nodes.First .. Nodes.Last);
3144 return Nodes.Table (N).Flag18;
3147 function Flag19 (N : Node_Id) return Boolean is
3149 pragma Assert (Nkind (N) in N_Entity);
3150 return Nodes.Table (N + 1).In_List;
3153 function Flag20 (N : Node_Id) return Boolean is
3155 pragma Assert (Nkind (N) in N_Entity);
3156 return Nodes.Table (N + 1).Unused_1;
3159 function Flag21 (N : Node_Id) return Boolean is
3161 pragma Assert (Nkind (N) in N_Entity);
3162 return Nodes.Table (N + 1).Rewrite_Ins;
3165 function Flag22 (N : Node_Id) return Boolean is
3167 pragma Assert (Nkind (N) in N_Entity);
3168 return Nodes.Table (N + 1).Analyzed;
3171 function Flag23 (N : Node_Id) return Boolean is
3173 pragma Assert (Nkind (N) in N_Entity);
3174 return Nodes.Table (N + 1).Comes_From_Source;
3177 function Flag24 (N : Node_Id) return Boolean is
3179 pragma Assert (Nkind (N) in N_Entity);
3180 return Nodes.Table (N + 1).Error_Posted;
3183 function Flag25 (N : Node_Id) return Boolean is
3185 pragma Assert (Nkind (N) in N_Entity);
3186 return Nodes.Table (N + 1).Flag4;
3189 function Flag26 (N : Node_Id) return Boolean is
3191 pragma Assert (Nkind (N) in N_Entity);
3192 return Nodes.Table (N + 1).Flag5;
3195 function Flag27 (N : Node_Id) return Boolean is
3197 pragma Assert (Nkind (N) in N_Entity);
3198 return Nodes.Table (N + 1).Flag6;
3201 function Flag28 (N : Node_Id) return Boolean is
3203 pragma Assert (Nkind (N) in N_Entity);
3204 return Nodes.Table (N + 1).Flag7;
3207 function Flag29 (N : Node_Id) return Boolean is
3209 pragma Assert (Nkind (N) in N_Entity);
3210 return Nodes.Table (N + 1).Flag8;
3213 function Flag30 (N : Node_Id) return Boolean is
3215 pragma Assert (Nkind (N) in N_Entity);
3216 return Nodes.Table (N + 1).Flag9;
3219 function Flag31 (N : Node_Id) return Boolean is
3221 pragma Assert (Nkind (N) in N_Entity);
3222 return Nodes.Table (N + 1).Flag10;
3225 function Flag32 (N : Node_Id) return Boolean is
3227 pragma Assert (Nkind (N) in N_Entity);
3228 return Nodes.Table (N + 1).Flag11;
3231 function Flag33 (N : Node_Id) return Boolean is
3233 pragma Assert (Nkind (N) in N_Entity);
3234 return Nodes.Table (N + 1).Flag12;
3237 function Flag34 (N : Node_Id) return Boolean is
3239 pragma Assert (Nkind (N) in N_Entity);
3240 return Nodes.Table (N + 1).Flag13;
3243 function Flag35 (N : Node_Id) return Boolean is
3245 pragma Assert (Nkind (N) in N_Entity);
3246 return Nodes.Table (N + 1).Flag14;
3249 function Flag36 (N : Node_Id) return Boolean is
3251 pragma Assert (Nkind (N) in N_Entity);
3252 return Nodes.Table (N + 1).Flag15;
3255 function Flag37 (N : Node_Id) return Boolean is
3257 pragma Assert (Nkind (N) in N_Entity);
3258 return Nodes.Table (N + 1).Flag16;
3261 function Flag38 (N : Node_Id) return Boolean is
3263 pragma Assert (Nkind (N) in N_Entity);
3264 return Nodes.Table (N + 1).Flag17;
3267 function Flag39 (N : Node_Id) return Boolean is
3269 pragma Assert (Nkind (N) in N_Entity);
3270 return Nodes.Table (N + 1).Flag18;
3273 function Flag40 (N : Node_Id) return Boolean is
3275 pragma Assert (Nkind (N) in N_Entity);
3276 return Nodes.Table (N + 2).In_List;
3279 function Flag41 (N : Node_Id) return Boolean is
3281 pragma Assert (Nkind (N) in N_Entity);
3282 return Nodes.Table (N + 2).Unused_1;
3285 function Flag42 (N : Node_Id) return Boolean is
3287 pragma Assert (Nkind (N) in N_Entity);
3288 return Nodes.Table (N + 2).Rewrite_Ins;
3291 function Flag43 (N : Node_Id) return Boolean is
3293 pragma Assert (Nkind (N) in N_Entity);
3294 return Nodes.Table (N + 2).Analyzed;
3297 function Flag44 (N : Node_Id) return Boolean is
3299 pragma Assert (Nkind (N) in N_Entity);
3300 return Nodes.Table (N + 2).Comes_From_Source;
3303 function Flag45 (N : Node_Id) return Boolean is
3305 pragma Assert (Nkind (N) in N_Entity);
3306 return Nodes.Table (N + 2).Error_Posted;
3309 function Flag46 (N : Node_Id) return Boolean is
3311 pragma Assert (Nkind (N) in N_Entity);
3312 return Nodes.Table (N + 2).Flag4;
3315 function Flag47 (N : Node_Id) return Boolean is
3317 pragma Assert (Nkind (N) in N_Entity);
3318 return Nodes.Table (N + 2).Flag5;
3321 function Flag48 (N : Node_Id) return Boolean is
3323 pragma Assert (Nkind (N) in N_Entity);
3324 return Nodes.Table (N + 2).Flag6;
3327 function Flag49 (N : Node_Id) return Boolean is
3329 pragma Assert (Nkind (N) in N_Entity);
3330 return Nodes.Table (N + 2).Flag7;
3333 function Flag50 (N : Node_Id) return Boolean is
3335 pragma Assert (Nkind (N) in N_Entity);
3336 return Nodes.Table (N + 2).Flag8;
3339 function Flag51 (N : Node_Id) return Boolean is
3341 pragma Assert (Nkind (N) in N_Entity);
3342 return Nodes.Table (N + 2).Flag9;
3345 function Flag52 (N : Node_Id) return Boolean is
3347 pragma Assert (Nkind (N) in N_Entity);
3348 return Nodes.Table (N + 2).Flag10;
3351 function Flag53 (N : Node_Id) return Boolean is
3353 pragma Assert (Nkind (N) in N_Entity);
3354 return Nodes.Table (N + 2).Flag11;
3357 function Flag54 (N : Node_Id) return Boolean is
3359 pragma Assert (Nkind (N) in N_Entity);
3360 return Nodes.Table (N + 2).Flag12;
3363 function Flag55 (N : Node_Id) return Boolean is
3365 pragma Assert (Nkind (N) in N_Entity);
3366 return Nodes.Table (N + 2).Flag13;
3369 function Flag56 (N : Node_Id) return Boolean is
3371 pragma Assert (Nkind (N) in N_Entity);
3372 return Nodes.Table (N + 2).Flag14;
3375 function Flag57 (N : Node_Id) return Boolean is
3377 pragma Assert (Nkind (N) in N_Entity);
3378 return Nodes.Table (N + 2).Flag15;
3381 function Flag58 (N : Node_Id) return Boolean is
3383 pragma Assert (Nkind (N) in N_Entity);
3384 return Nodes.Table (N + 2).Flag16;
3387 function Flag59 (N : Node_Id) return Boolean is
3389 pragma Assert (Nkind (N) in N_Entity);
3390 return Nodes.Table (N + 2).Flag17;
3393 function Flag60 (N : Node_Id) return Boolean is
3395 pragma Assert (Nkind (N) in N_Entity);
3396 return Nodes.Table (N + 2).Flag18;
3399 function Flag61 (N : Node_Id) return Boolean is
3401 pragma Assert (Nkind (N) in N_Entity);
3402 return Nodes.Table (N + 1).Pflag1;
3405 function Flag62 (N : Node_Id) return Boolean is
3407 pragma Assert (Nkind (N) in N_Entity);
3408 return Nodes.Table (N + 1).Pflag2;
3411 function Flag63 (N : Node_Id) return Boolean is
3413 pragma Assert (Nkind (N) in N_Entity);
3414 return Nodes.Table (N + 2).Pflag1;
3417 function Flag64 (N : Node_Id) return Boolean is
3419 pragma Assert (Nkind (N) in N_Entity);
3420 return Nodes.Table (N + 2).Pflag2;
3423 function Flag65 (N : Node_Id) return Boolean is
3425 pragma Assert (Nkind (N) in N_Entity);
3426 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
3429 function Flag66 (N : Node_Id) return Boolean is
3431 pragma Assert (Nkind (N) in N_Entity);
3432 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
3435 function Flag67 (N : Node_Id) return Boolean is
3437 pragma Assert (Nkind (N) in N_Entity);
3438 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
3441 function Flag68 (N : Node_Id) return Boolean is
3443 pragma Assert (Nkind (N) in N_Entity);
3444 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
3447 function Flag69 (N : Node_Id) return Boolean is
3449 pragma Assert (Nkind (N) in N_Entity);
3450 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
3453 function Flag70 (N : Node_Id) return Boolean is
3455 pragma Assert (Nkind (N) in N_Entity);
3456 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
3459 function Flag71 (N : Node_Id) return Boolean is
3461 pragma Assert (Nkind (N) in N_Entity);
3462 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
3465 function Flag72 (N : Node_Id) return Boolean is
3467 pragma Assert (Nkind (N) in N_Entity);
3468 return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
3471 function Flag73 (N : Node_Id) return Boolean is
3473 pragma Assert (Nkind (N) in N_Entity);
3474 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
3477 function Flag74 (N : Node_Id) return Boolean is
3479 pragma Assert (Nkind (N) in N_Entity);
3480 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
3483 function Flag75 (N : Node_Id) return Boolean is
3485 pragma Assert (Nkind (N) in N_Entity);
3486 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
3489 function Flag76 (N : Node_Id) return Boolean is
3491 pragma Assert (Nkind (N) in N_Entity);
3492 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
3495 function Flag77 (N : Node_Id) return Boolean is
3497 pragma Assert (Nkind (N) in N_Entity);
3498 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
3501 function Flag78 (N : Node_Id) return Boolean is
3503 pragma Assert (Nkind (N) in N_Entity);
3504 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
3507 function Flag79 (N : Node_Id) return Boolean is
3509 pragma Assert (Nkind (N) in N_Entity);
3510 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
3513 function Flag80 (N : Node_Id) return Boolean is
3515 pragma Assert (Nkind (N) in N_Entity);
3516 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
3519 function Flag81 (N : Node_Id) return Boolean is
3521 pragma Assert (Nkind (N) in N_Entity);
3522 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
3525 function Flag82 (N : Node_Id) return Boolean is
3527 pragma Assert (Nkind (N) in N_Entity);
3528 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
3531 function Flag83 (N : Node_Id) return Boolean is
3533 pragma Assert (Nkind (N) in N_Entity);
3534 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
3537 function Flag84 (N : Node_Id) return Boolean is
3539 pragma Assert (Nkind (N) in N_Entity);
3540 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
3543 function Flag85 (N : Node_Id) return Boolean is
3545 pragma Assert (Nkind (N) in N_Entity);
3546 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
3549 function Flag86 (N : Node_Id) return Boolean is
3551 pragma Assert (Nkind (N) in N_Entity);
3552 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
3555 function Flag87 (N : Node_Id) return Boolean is
3557 pragma Assert (Nkind (N) in N_Entity);
3558 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
3561 function Flag88 (N : Node_Id) return Boolean is
3563 pragma Assert (Nkind (N) in N_Entity);
3564 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
3567 function Flag89 (N : Node_Id) return Boolean is
3569 pragma Assert (Nkind (N) in N_Entity);
3570 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
3573 function Flag90 (N : Node_Id) return Boolean is
3575 pragma Assert (Nkind (N) in N_Entity);
3576 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
3579 function Flag91 (N : Node_Id) return Boolean is
3581 pragma Assert (Nkind (N) in N_Entity);
3582 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
3585 function Flag92 (N : Node_Id) return Boolean is
3587 pragma Assert (Nkind (N) in N_Entity);
3588 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
3591 function Flag93 (N : Node_Id) return Boolean is
3593 pragma Assert (Nkind (N) in N_Entity);
3594 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
3597 function Flag94 (N : Node_Id) return Boolean is
3599 pragma Assert (Nkind (N) in N_Entity);
3600 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
3603 function Flag95 (N : Node_Id) return Boolean is
3605 pragma Assert (Nkind (N) in N_Entity);
3606 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
3609 function Flag96 (N : Node_Id) return Boolean is
3611 pragma Assert (Nkind (N) in N_Entity);
3612 return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
3615 function Flag97 (N : Node_Id) return Boolean is
3617 pragma Assert (Nkind (N) in N_Entity);
3618 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
3621 function Flag98 (N : Node_Id) return Boolean is
3623 pragma Assert (Nkind (N) in N_Entity);
3624 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
3627 function Flag99 (N : Node_Id) return Boolean is
3629 pragma Assert (Nkind (N) in N_Entity);
3630 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
3633 function Flag100 (N : Node_Id) return Boolean is
3635 pragma Assert (Nkind (N) in N_Entity);
3636 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
3639 function Flag101 (N : Node_Id) return Boolean is
3641 pragma Assert (Nkind (N) in N_Entity);
3642 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
3645 function Flag102 (N : Node_Id) return Boolean is
3647 pragma Assert (Nkind (N) in N_Entity);
3648 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
3651 function Flag103 (N : Node_Id) return Boolean is
3653 pragma Assert (Nkind (N) in N_Entity);
3654 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
3657 function Flag104 (N : Node_Id) return Boolean is
3659 pragma Assert (Nkind (N) in N_Entity);
3660 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
3663 function Flag105 (N : Node_Id) return Boolean is
3665 pragma Assert (Nkind (N) in N_Entity);
3666 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
3669 function Flag106 (N : Node_Id) return Boolean is
3671 pragma Assert (Nkind (N) in N_Entity);
3672 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
3675 function Flag107 (N : Node_Id) return Boolean is
3677 pragma Assert (Nkind (N) in N_Entity);
3678 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
3681 function Flag108 (N : Node_Id) return Boolean is
3683 pragma Assert (Nkind (N) in N_Entity);
3684 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
3687 function Flag109 (N : Node_Id) return Boolean is
3689 pragma Assert (Nkind (N) in N_Entity);
3690 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
3693 function Flag110 (N : Node_Id) return Boolean is
3695 pragma Assert (Nkind (N) in N_Entity);
3696 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
3699 function Flag111 (N : Node_Id) return Boolean is
3701 pragma Assert (Nkind (N) in N_Entity);
3702 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
3705 function Flag112 (N : Node_Id) return Boolean is
3707 pragma Assert (Nkind (N) in N_Entity);
3708 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
3711 function Flag113 (N : Node_Id) return Boolean is
3713 pragma Assert (Nkind (N) in N_Entity);
3714 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
3717 function Flag114 (N : Node_Id) return Boolean is
3719 pragma Assert (Nkind (N) in N_Entity);
3720 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
3723 function Flag115 (N : Node_Id) return Boolean is
3725 pragma Assert (Nkind (N) in N_Entity);
3726 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
3729 function Flag116 (N : Node_Id) return Boolean is
3731 pragma Assert (Nkind (N) in N_Entity);
3732 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
3735 function Flag117 (N : Node_Id) return Boolean is
3737 pragma Assert (Nkind (N) in N_Entity);
3738 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
3741 function Flag118 (N : Node_Id) return Boolean is
3743 pragma Assert (Nkind (N) in N_Entity);
3744 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
3747 function Flag119 (N : Node_Id) return Boolean is
3749 pragma Assert (Nkind (N) in N_Entity);
3750 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
3753 function Flag120 (N : Node_Id) return Boolean is
3755 pragma Assert (Nkind (N) in N_Entity);
3756 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
3759 function Flag121 (N : Node_Id) return Boolean is
3761 pragma Assert (Nkind (N) in N_Entity);
3762 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
3765 function Flag122 (N : Node_Id) return Boolean is
3767 pragma Assert (Nkind (N) in N_Entity);
3768 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
3771 function Flag123 (N : Node_Id) return Boolean is
3773 pragma Assert (Nkind (N) in N_Entity);
3774 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
3777 function Flag124 (N : Node_Id) return Boolean is
3779 pragma Assert (Nkind (N) in N_Entity);
3780 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
3783 function Flag125 (N : Node_Id) return Boolean is
3785 pragma Assert (Nkind (N) in N_Entity);
3786 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
3789 function Flag126 (N : Node_Id) return Boolean is
3791 pragma Assert (Nkind (N) in N_Entity);
3792 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
3795 function Flag127 (N : Node_Id) return Boolean is
3797 pragma Assert (Nkind (N) in N_Entity);
3798 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
3801 function Flag128 (N : Node_Id) return Boolean is
3803 pragma Assert (Nkind (N) in N_Entity);
3804 return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
3807 function Flag129 (N : Node_Id) return Boolean is
3809 pragma Assert (Nkind (N) in N_Entity);
3810 return Nodes.Table (N + 3).In_List;
3813 function Flag130 (N : Node_Id) return Boolean is
3815 pragma Assert (Nkind (N) in N_Entity);
3816 return Nodes.Table (N + 3).Unused_1;
3819 function Flag131 (N : Node_Id) return Boolean is
3821 pragma Assert (Nkind (N) in N_Entity);
3822 return Nodes.Table (N + 3).Rewrite_Ins;
3825 function Flag132 (N : Node_Id) return Boolean is
3827 pragma Assert (Nkind (N) in N_Entity);
3828 return Nodes.Table (N + 3).Analyzed;
3831 function Flag133 (N : Node_Id) return Boolean is
3833 pragma Assert (Nkind (N) in N_Entity);
3834 return Nodes.Table (N + 3).Comes_From_Source;
3837 function Flag134 (N : Node_Id) return Boolean is
3839 pragma Assert (Nkind (N) in N_Entity);
3840 return Nodes.Table (N + 3).Error_Posted;
3843 function Flag135 (N : Node_Id) return Boolean is
3845 pragma Assert (Nkind (N) in N_Entity);
3846 return Nodes.Table (N + 3).Flag4;
3849 function Flag136 (N : Node_Id) return Boolean is
3851 pragma Assert (Nkind (N) in N_Entity);
3852 return Nodes.Table (N + 3).Flag5;
3855 function Flag137 (N : Node_Id) return Boolean is
3857 pragma Assert (Nkind (N) in N_Entity);
3858 return Nodes.Table (N + 3).Flag6;
3861 function Flag138 (N : Node_Id) return Boolean is
3863 pragma Assert (Nkind (N) in N_Entity);
3864 return Nodes.Table (N + 3).Flag7;
3867 function Flag139 (N : Node_Id) return Boolean is
3869 pragma Assert (Nkind (N) in N_Entity);
3870 return Nodes.Table (N + 3).Flag8;
3873 function Flag140 (N : Node_Id) return Boolean is
3875 pragma Assert (Nkind (N) in N_Entity);
3876 return Nodes.Table (N + 3).Flag9;
3879 function Flag141 (N : Node_Id) return Boolean is
3881 pragma Assert (Nkind (N) in N_Entity);
3882 return Nodes.Table (N + 3).Flag10;
3885 function Flag142 (N : Node_Id) return Boolean is
3887 pragma Assert (Nkind (N) in N_Entity);
3888 return Nodes.Table (N + 3).Flag11;
3891 function Flag143 (N : Node_Id) return Boolean is
3893 pragma Assert (Nkind (N) in N_Entity);
3894 return Nodes.Table (N + 3).Flag12;
3897 function Flag144 (N : Node_Id) return Boolean is
3899 pragma Assert (Nkind (N) in N_Entity);
3900 return Nodes.Table (N + 3).Flag13;
3903 function Flag145 (N : Node_Id) return Boolean is
3905 pragma Assert (Nkind (N) in N_Entity);
3906 return Nodes.Table (N + 3).Flag14;
3909 function Flag146 (N : Node_Id) return Boolean is
3911 pragma Assert (Nkind (N) in N_Entity);
3912 return Nodes.Table (N + 3).Flag15;
3915 function Flag147 (N : Node_Id) return Boolean is
3917 pragma Assert (Nkind (N) in N_Entity);
3918 return Nodes.Table (N + 3).Flag16;
3921 function Flag148 (N : Node_Id) return Boolean is
3923 pragma Assert (Nkind (N) in N_Entity);
3924 return Nodes.Table (N + 3).Flag17;
3927 function Flag149 (N : Node_Id) return Boolean is
3929 pragma Assert (Nkind (N) in N_Entity);
3930 return Nodes.Table (N + 3).Flag18;
3933 function Flag150 (N : Node_Id) return Boolean is
3935 pragma Assert (Nkind (N) in N_Entity);
3936 return Nodes.Table (N + 3).Pflag1;
3939 function Flag151 (N : Node_Id) return Boolean is
3941 pragma Assert (Nkind (N) in N_Entity);
3942 return Nodes.Table (N + 3).Pflag2;
3945 function Flag152 (N : Node_Id) return Boolean is
3947 pragma Assert (Nkind (N) in N_Entity);
3948 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
3951 function Flag153 (N : Node_Id) return Boolean is
3953 pragma Assert (Nkind (N) in N_Entity);
3954 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
3957 function Flag154 (N : Node_Id) return Boolean is
3959 pragma Assert (Nkind (N) in N_Entity);
3960 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
3963 function Flag155 (N : Node_Id) return Boolean is
3965 pragma Assert (Nkind (N) in N_Entity);
3966 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
3969 function Flag156 (N : Node_Id) return Boolean is
3971 pragma Assert (Nkind (N) in N_Entity);
3972 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
3975 function Flag157 (N : Node_Id) return Boolean is
3977 pragma Assert (Nkind (N) in N_Entity);
3978 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
3981 function Flag158 (N : Node_Id) return Boolean is
3983 pragma Assert (Nkind (N) in N_Entity);
3984 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
3987 function Flag159 (N : Node_Id) return Boolean is
3989 pragma Assert (Nkind (N) in N_Entity);
3990 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
3993 function Flag160 (N : Node_Id) return Boolean is
3995 pragma Assert (Nkind (N) in N_Entity);
3996 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
3999 function Flag161 (N : Node_Id) return Boolean is
4001 pragma Assert (Nkind (N) in N_Entity);
4002 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
4005 function Flag162 (N : Node_Id) return Boolean is
4007 pragma Assert (Nkind (N) in N_Entity);
4008 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
4011 function Flag163 (N : Node_Id) return Boolean is
4013 pragma Assert (Nkind (N) in N_Entity);
4014 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
4017 function Flag164 (N : Node_Id) return Boolean is
4019 pragma Assert (Nkind (N) in N_Entity);
4020 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
4023 function Flag165 (N : Node_Id) return Boolean is
4025 pragma Assert (Nkind (N) in N_Entity);
4026 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
4029 function Flag166 (N : Node_Id) return Boolean is
4031 pragma Assert (Nkind (N) in N_Entity);
4032 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
4035 function Flag167 (N : Node_Id) return Boolean is
4037 pragma Assert (Nkind (N) in N_Entity);
4038 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
4041 function Flag168 (N : Node_Id) return Boolean is
4043 pragma Assert (Nkind (N) in N_Entity);
4044 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
4047 function Flag169 (N : Node_Id) return Boolean is
4049 pragma Assert (Nkind (N) in N_Entity);
4050 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
4053 function Flag170 (N : Node_Id) return Boolean is
4055 pragma Assert (Nkind (N) in N_Entity);
4056 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
4059 function Flag171 (N : Node_Id) return Boolean is
4061 pragma Assert (Nkind (N) in N_Entity);
4062 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
4065 function Flag172 (N : Node_Id) return Boolean is
4067 pragma Assert (Nkind (N) in N_Entity);
4068 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
4071 function Flag173 (N : Node_Id) return Boolean is
4073 pragma Assert (Nkind (N) in N_Entity);
4074 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
4077 function Flag174 (N : Node_Id) return Boolean is
4079 pragma Assert (Nkind (N) in N_Entity);
4080 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
4083 function Flag175 (N : Node_Id) return Boolean is
4085 pragma Assert (Nkind (N) in N_Entity);
4086 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
4089 function Flag176 (N : Node_Id) return Boolean is
4091 pragma Assert (Nkind (N) in N_Entity);
4092 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
4095 function Flag177 (N : Node_Id) return Boolean is
4097 pragma Assert (Nkind (N) in N_Entity);
4098 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
4101 function Flag178 (N : Node_Id) return Boolean is
4103 pragma Assert (Nkind (N) in N_Entity);
4104 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
4107 function Flag179 (N : Node_Id) return Boolean is
4109 pragma Assert (Nkind (N) in N_Entity);
4110 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
4113 function Flag180 (N : Node_Id) return Boolean is
4115 pragma Assert (Nkind (N) in N_Entity);
4116 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
4119 function Flag181 (N : Node_Id) return Boolean is
4121 pragma Assert (Nkind (N) in N_Entity);
4122 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
4125 function Flag182 (N : Node_Id) return Boolean is
4127 pragma Assert (Nkind (N) in N_Entity);
4128 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
4131 function Flag183 (N : Node_Id) return Boolean is
4133 pragma Assert (Nkind (N) in N_Entity);
4134 return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
4137 procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
4139 pragma Assert (N in Nodes.First .. Nodes.Last);
4140 Nodes.Table (N).Nkind := Val;
4143 procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
4145 pragma Assert (N in Nodes.First .. Nodes.Last);
4146 Nodes.Table (N).Field1 := Val;
4149 procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
4151 pragma Assert (N in Nodes.First .. Nodes.Last);
4152 Nodes.Table (N).Field2 := Val;
4155 procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
4157 pragma Assert (N in Nodes.First .. Nodes.Last);
4158 Nodes.Table (N).Field3 := Val;
4161 procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
4163 pragma Assert (N in Nodes.First .. Nodes.Last);
4164 Nodes.Table (N).Field4 := Val;
4167 procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
4169 pragma Assert (N in Nodes.First .. Nodes.Last);
4170 Nodes.Table (N).Field5 := Val;
4173 procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
4175 pragma Assert (Nkind (N) in N_Entity);
4176 Nodes.Table (N + 1).Field6 := Val;
4179 procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
4181 pragma Assert (Nkind (N) in N_Entity);
4182 Nodes.Table (N + 1).Field7 := Val;
4185 procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
4187 pragma Assert (Nkind (N) in N_Entity);
4188 Nodes.Table (N + 1).Field8 := Val;
4191 procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
4193 pragma Assert (Nkind (N) in N_Entity);
4194 Nodes.Table (N + 1).Field9 := Val;
4197 procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
4199 pragma Assert (Nkind (N) in N_Entity);
4200 Nodes.Table (N + 1).Field10 := Val;
4203 procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
4205 pragma Assert (Nkind (N) in N_Entity);
4206 Nodes.Table (N + 1).Field11 := Val;
4209 procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
4211 pragma Assert (Nkind (N) in N_Entity);
4212 Nodes.Table (N + 1).Field12 := Val;
4215 procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
4217 pragma Assert (Nkind (N) in N_Entity);
4218 Nodes.Table (N + 2).Field6 := Val;
4221 procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
4223 pragma Assert (Nkind (N) in N_Entity);
4224 Nodes.Table (N + 2).Field7 := Val;
4227 procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
4229 pragma Assert (Nkind (N) in N_Entity);
4230 Nodes.Table (N + 2).Field8 := Val;
4233 procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
4235 pragma Assert (Nkind (N) in N_Entity);
4236 Nodes.Table (N + 2).Field9 := Val;
4239 procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
4241 pragma Assert (Nkind (N) in N_Entity);
4242 Nodes.Table (N + 2).Field10 := Val;
4245 procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
4247 pragma Assert (Nkind (N) in N_Entity);
4248 Nodes.Table (N + 2).Field11 := Val;
4251 procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
4253 pragma Assert (Nkind (N) in N_Entity);
4254 Nodes.Table (N + 3).Field6 := Val;
4257 procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
4259 pragma Assert (Nkind (N) in N_Entity);
4260 Nodes.Table (N + 3).Field7 := Val;
4263 procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
4265 pragma Assert (Nkind (N) in N_Entity);
4266 Nodes.Table (N + 3).Field8 := Val;
4269 procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
4271 pragma Assert (Nkind (N) in N_Entity);
4272 Nodes.Table (N + 3).Field9 := Val;
4275 procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
4277 pragma Assert (Nkind (N) in N_Entity);
4278 Nodes.Table (N + 3).Field10 := Val;
4281 procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
4283 pragma Assert (N in Nodes.First .. Nodes.Last);
4284 Nodes.Table (N).Field1 := Union_Id (Val);
4287 procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
4289 pragma Assert (N in Nodes.First .. Nodes.Last);
4290 Nodes.Table (N).Field2 := Union_Id (Val);
4293 procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
4295 pragma Assert (N in Nodes.First .. Nodes.Last);
4296 Nodes.Table (N).Field3 := Union_Id (Val);
4299 procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
4301 pragma Assert (N in Nodes.First .. Nodes.Last);
4302 Nodes.Table (N).Field4 := Union_Id (Val);
4305 procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
4307 pragma Assert (N in Nodes.First .. Nodes.Last);
4308 Nodes.Table (N).Field5 := Union_Id (Val);
4311 procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
4313 pragma Assert (Nkind (N) in N_Entity);
4314 Nodes.Table (N + 1).Field6 := Union_Id (Val);
4317 procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
4319 pragma Assert (Nkind (N) in N_Entity);
4320 Nodes.Table (N + 1).Field7 := Union_Id (Val);
4323 procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
4325 pragma Assert (Nkind (N) in N_Entity);
4326 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4329 procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
4331 pragma Assert (Nkind (N) in N_Entity);
4332 Nodes.Table (N + 1).Field9 := Union_Id (Val);
4335 procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
4337 pragma Assert (Nkind (N) in N_Entity);
4338 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4341 procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
4343 pragma Assert (Nkind (N) in N_Entity);
4344 Nodes.Table (N + 1).Field11 := Union_Id (Val);
4347 procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
4349 pragma Assert (Nkind (N) in N_Entity);
4350 Nodes.Table (N + 1).Field12 := Union_Id (Val);
4353 procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
4355 pragma Assert (Nkind (N) in N_Entity);
4356 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4359 procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
4361 pragma Assert (Nkind (N) in N_Entity);
4362 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4365 procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
4367 pragma Assert (Nkind (N) in N_Entity);
4368 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4371 procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
4373 pragma Assert (Nkind (N) in N_Entity);
4374 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4377 procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
4379 pragma Assert (Nkind (N) in N_Entity);
4380 Nodes.Table (N + 2).Field10 := Union_Id (Val);
4383 procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
4385 pragma Assert (Nkind (N) in N_Entity);
4386 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4389 procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
4391 pragma Assert (Nkind (N) in N_Entity);
4392 Nodes.Table (N + 3).Field6 := Union_Id (Val);
4395 procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
4397 pragma Assert (Nkind (N) in N_Entity);
4398 Nodes.Table (N + 3).Field7 := Union_Id (Val);
4401 procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
4403 pragma Assert (Nkind (N) in N_Entity);
4404 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4407 procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
4409 pragma Assert (Nkind (N) in N_Entity);
4410 Nodes.Table (N + 3).Field9 := Union_Id (Val);
4413 procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
4415 pragma Assert (Nkind (N) in N_Entity);
4416 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4419 procedure Set_List1 (N : Node_Id; Val : List_Id) is
4421 pragma Assert (N in Nodes.First .. Nodes.Last);
4422 Nodes.Table (N).Field1 := Union_Id (Val);
4425 procedure Set_List2 (N : Node_Id; Val : List_Id) is
4427 pragma Assert (N in Nodes.First .. Nodes.Last);
4428 Nodes.Table (N).Field2 := Union_Id (Val);
4431 procedure Set_List3 (N : Node_Id; Val : List_Id) is
4433 pragma Assert (N in Nodes.First .. Nodes.Last);
4434 Nodes.Table (N).Field3 := Union_Id (Val);
4437 procedure Set_List4 (N : Node_Id; Val : List_Id) is
4439 pragma Assert (N in Nodes.First .. Nodes.Last);
4440 Nodes.Table (N).Field4 := Union_Id (Val);
4443 procedure Set_List5 (N : Node_Id; Val : List_Id) is
4445 pragma Assert (N in Nodes.First .. Nodes.Last);
4446 Nodes.Table (N).Field5 := Union_Id (Val);
4449 procedure Set_List10 (N : Node_Id; Val : List_Id) is
4451 pragma Assert (Nkind (N) in N_Entity);
4452 Nodes.Table (N + 1).Field10 := Union_Id (Val);
4455 procedure Set_List14 (N : Node_Id; Val : List_Id) is
4457 pragma Assert (Nkind (N) in N_Entity);
4458 Nodes.Table (N + 2).Field7 := Union_Id (Val);
4461 procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
4463 Nodes.Table (N).Field2 := Union_Id (Val);
4466 procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
4468 Nodes.Table (N).Field3 := Union_Id (Val);
4471 procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
4473 Nodes.Table (N).Field4 := Union_Id (Val);
4476 procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
4478 pragma Assert (Nkind (N) in N_Entity);
4479 Nodes.Table (N + 1).Field8 := Union_Id (Val);
4482 procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
4484 pragma Assert (Nkind (N) in N_Entity);
4485 Nodes.Table (N + 2).Field6 := Union_Id (Val);
4488 procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
4490 pragma Assert (Nkind (N) in N_Entity);
4491 Nodes.Table (N + 2).Field8 := Union_Id (Val);
4494 procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
4496 pragma Assert (Nkind (N) in N_Entity);
4497 Nodes.Table (N + 2).Field9 := Union_Id (Val);
4500 procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
4502 pragma Assert (Nkind (N) in N_Entity);
4503 Nodes.Table (N + 2).Field11 := Union_Id (Val);
4506 procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
4508 pragma Assert (Nkind (N) in N_Entity);
4509 Nodes.Table (N + 3).Field8 := Union_Id (Val);
4512 procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
4514 pragma Assert (Nkind (N) in N_Entity);
4515 Nodes.Table (N + 3).Field10 := Union_Id (Val);
4518 procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
4520 pragma Assert (N in Nodes.First .. Nodes.Last);
4521 Nodes.Table (N).Field1 := Union_Id (Val);
4524 procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
4526 pragma Assert (N in Nodes.First .. Nodes.Last);
4527 Nodes.Table (N).Field2 := Union_Id (Val);
4530 procedure Set_Str3 (N : Node_Id; Val : String_Id) is
4532 pragma Assert (N in Nodes.First .. Nodes.Last);
4533 Nodes.Table (N).Field3 := Union_Id (Val);
4536 procedure Set_Uint3 (N : Node_Id; Val : Uint) is
4538 pragma Assert (N in Nodes.First .. Nodes.Last);
4539 Nodes.Table (N).Field3 := To_Union (Val);
4542 procedure Set_Uint4 (N : Node_Id; Val : Uint) is
4544 pragma Assert (N in Nodes.First .. Nodes.Last);
4545 Nodes.Table (N).Field4 := To_Union (Val);
4548 procedure Set_Uint5 (N : Node_Id; Val : Uint) is
4550 pragma Assert (N in Nodes.First .. Nodes.Last);
4551 Nodes.Table (N).Field5 := To_Union (Val);
4554 procedure Set_Uint8 (N : Node_Id; Val : Uint) is
4556 pragma Assert (Nkind (N) in N_Entity);
4557 Nodes.Table (N + 1).Field8 := To_Union (Val);
4560 procedure Set_Uint9 (N : Node_Id; Val : Uint) is
4562 pragma Assert (Nkind (N) in N_Entity);
4563 Nodes.Table (N + 1).Field9 := To_Union (Val);
4566 procedure Set_Uint10 (N : Node_Id; Val : Uint) is
4568 pragma Assert (Nkind (N) in N_Entity);
4569 Nodes.Table (N + 1).Field10 := To_Union (Val);
4572 procedure Set_Uint11 (N : Node_Id; Val : Uint) is
4574 pragma Assert (Nkind (N) in N_Entity);
4575 Nodes.Table (N + 1).Field11 := To_Union (Val);
4578 procedure Set_Uint12 (N : Node_Id; Val : Uint) is
4580 pragma Assert (Nkind (N) in N_Entity);
4581 Nodes.Table (N + 1).Field12 := To_Union (Val);
4584 procedure Set_Uint13 (N : Node_Id; Val : Uint) is
4586 pragma Assert (Nkind (N) in N_Entity);
4587 Nodes.Table (N + 2).Field6 := To_Union (Val);
4590 procedure Set_Uint14 (N : Node_Id; Val : Uint) is
4592 pragma Assert (Nkind (N) in N_Entity);
4593 Nodes.Table (N + 2).Field7 := To_Union (Val);
4596 procedure Set_Uint15 (N : Node_Id; Val : Uint) is
4598 pragma Assert (Nkind (N) in N_Entity);
4599 Nodes.Table (N + 2).Field8 := To_Union (Val);
4602 procedure Set_Uint16 (N : Node_Id; Val : Uint) is
4604 pragma Assert (Nkind (N) in N_Entity);
4605 Nodes.Table (N + 2).Field9 := To_Union (Val);
4608 procedure Set_Uint17 (N : Node_Id; Val : Uint) is
4610 pragma Assert (Nkind (N) in N_Entity);
4611 Nodes.Table (N + 2).Field10 := To_Union (Val);
4614 procedure Set_Uint22 (N : Node_Id; Val : Uint) is
4616 pragma Assert (Nkind (N) in N_Entity);
4617 Nodes.Table (N + 3).Field9 := To_Union (Val);
4620 procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
4622 pragma Assert (N in Nodes.First .. Nodes.Last);
4623 Nodes.Table (N).Field3 := To_Union (Val);
4626 procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
4628 pragma Assert (Nkind (N) in N_Entity);
4629 Nodes.Table (N + 2).Field11 := To_Union (Val);
4632 procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
4634 pragma Assert (Nkind (N) in N_Entity);
4635 Nodes.Table (N + 3).Field8 := To_Union (Val);
4638 procedure Set_Char_Code2 (N : Node_Id; Val : Char_Code) is
4640 pragma Assert (N in Nodes.First .. Nodes.Last);
4641 Nodes.Table (N).Field2 := Union_Id (Val) + Char_Code_Bias;
4644 procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
4646 pragma Assert (N in Nodes.First .. Nodes.Last);
4647 Nodes.Table (N).Flag4 := Val;
4650 procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
4652 pragma Assert (N in Nodes.First .. Nodes.Last);
4653 Nodes.Table (N).Flag5 := Val;
4656 procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
4658 pragma Assert (N in Nodes.First .. Nodes.Last);
4659 Nodes.Table (N).Flag6 := Val;
4662 procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
4664 pragma Assert (N in Nodes.First .. Nodes.Last);
4665 Nodes.Table (N).Flag7 := Val;
4668 procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
4670 pragma Assert (N in Nodes.First .. Nodes.Last);
4671 Nodes.Table (N).Flag8 := Val;
4674 procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
4676 pragma Assert (N in Nodes.First .. Nodes.Last);
4677 Nodes.Table (N).Flag9 := Val;
4680 procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
4682 pragma Assert (N in Nodes.First .. Nodes.Last);
4683 Nodes.Table (N).Flag10 := Val;
4686 procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
4688 pragma Assert (N in Nodes.First .. Nodes.Last);
4689 Nodes.Table (N).Flag11 := Val;
4692 procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
4694 pragma Assert (N in Nodes.First .. Nodes.Last);
4695 Nodes.Table (N).Flag12 := Val;
4698 procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
4700 pragma Assert (N in Nodes.First .. Nodes.Last);
4701 Nodes.Table (N).Flag13 := Val;
4704 procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
4706 pragma Assert (N in Nodes.First .. Nodes.Last);
4707 Nodes.Table (N).Flag14 := Val;
4710 procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
4712 pragma Assert (N in Nodes.First .. Nodes.Last);
4713 Nodes.Table (N).Flag15 := Val;
4716 procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
4718 pragma Assert (N in Nodes.First .. Nodes.Last);
4719 Nodes.Table (N).Flag16 := Val;
4722 procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
4724 pragma Assert (N in Nodes.First .. Nodes.Last);
4725 Nodes.Table (N).Flag17 := Val;
4728 procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
4730 pragma Assert (N in Nodes.First .. Nodes.Last);
4731 Nodes.Table (N).Flag18 := Val;
4734 procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
4736 pragma Assert (Nkind (N) in N_Entity);
4737 Nodes.Table (N + 1).In_List := Val;
4740 procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
4742 pragma Assert (Nkind (N) in N_Entity);
4743 Nodes.Table (N + 1).Unused_1 := Val;
4746 procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
4748 pragma Assert (Nkind (N) in N_Entity);
4749 Nodes.Table (N + 1).Rewrite_Ins := Val;
4752 procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
4754 pragma Assert (Nkind (N) in N_Entity);
4755 Nodes.Table (N + 1).Analyzed := Val;
4758 procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
4760 pragma Assert (Nkind (N) in N_Entity);
4761 Nodes.Table (N + 1).Comes_From_Source := Val;
4764 procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
4766 pragma Assert (Nkind (N) in N_Entity);
4767 Nodes.Table (N + 1).Error_Posted := Val;
4770 procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
4772 pragma Assert (Nkind (N) in N_Entity);
4773 Nodes.Table (N + 1).Flag4 := Val;
4776 procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
4778 pragma Assert (Nkind (N) in N_Entity);
4779 Nodes.Table (N + 1).Flag5 := Val;
4782 procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
4784 pragma Assert (Nkind (N) in N_Entity);
4785 Nodes.Table (N + 1).Flag6 := Val;
4788 procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
4790 pragma Assert (Nkind (N) in N_Entity);
4791 Nodes.Table (N + 1).Flag7 := Val;
4794 procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
4796 pragma Assert (Nkind (N) in N_Entity);
4797 Nodes.Table (N + 1).Flag8 := Val;
4800 procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
4802 pragma Assert (Nkind (N) in N_Entity);
4803 Nodes.Table (N + 1).Flag9 := Val;
4806 procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
4808 pragma Assert (Nkind (N) in N_Entity);
4809 Nodes.Table (N + 1).Flag10 := Val;
4812 procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
4814 pragma Assert (Nkind (N) in N_Entity);
4815 Nodes.Table (N + 1).Flag11 := Val;
4818 procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
4820 pragma Assert (Nkind (N) in N_Entity);
4821 Nodes.Table (N + 1).Flag12 := Val;
4824 procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
4826 pragma Assert (Nkind (N) in N_Entity);
4827 Nodes.Table (N + 1).Flag13 := Val;
4830 procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
4832 pragma Assert (Nkind (N) in N_Entity);
4833 Nodes.Table (N + 1).Flag14 := Val;
4836 procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
4838 pragma Assert (Nkind (N) in N_Entity);
4839 Nodes.Table (N + 1).Flag15 := Val;
4842 procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
4844 pragma Assert (Nkind (N) in N_Entity);
4845 Nodes.Table (N + 1).Flag16 := Val;
4848 procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
4850 pragma Assert (Nkind (N) in N_Entity);
4851 Nodes.Table (N + 1).Flag17 := Val;
4854 procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
4856 pragma Assert (Nkind (N) in N_Entity);
4857 Nodes.Table (N + 1).Flag18 := Val;
4860 procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
4862 pragma Assert (Nkind (N) in N_Entity);
4863 Nodes.Table (N + 2).In_List := Val;
4866 procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
4868 pragma Assert (Nkind (N) in N_Entity);
4869 Nodes.Table (N + 2).Unused_1 := Val;
4872 procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
4874 pragma Assert (Nkind (N) in N_Entity);
4875 Nodes.Table (N + 2).Rewrite_Ins := Val;
4878 procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
4880 pragma Assert (Nkind (N) in N_Entity);
4881 Nodes.Table (N + 2).Analyzed := Val;
4884 procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
4886 pragma Assert (Nkind (N) in N_Entity);
4887 Nodes.Table (N + 2).Comes_From_Source := Val;
4890 procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
4892 pragma Assert (Nkind (N) in N_Entity);
4893 Nodes.Table (N + 2).Error_Posted := Val;
4896 procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
4898 pragma Assert (Nkind (N) in N_Entity);
4899 Nodes.Table (N + 2).Flag4 := Val;
4902 procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
4904 pragma Assert (Nkind (N) in N_Entity);
4905 Nodes.Table (N + 2).Flag5 := Val;
4908 procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
4910 pragma Assert (Nkind (N) in N_Entity);
4911 Nodes.Table (N + 2).Flag6 := Val;
4914 procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
4916 pragma Assert (Nkind (N) in N_Entity);
4917 Nodes.Table (N + 2).Flag7 := Val;
4920 procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
4922 pragma Assert (Nkind (N) in N_Entity);
4923 Nodes.Table (N + 2).Flag8 := Val;
4926 procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
4928 pragma Assert (Nkind (N) in N_Entity);
4929 Nodes.Table (N + 2).Flag9 := Val;
4932 procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
4934 pragma Assert (Nkind (N) in N_Entity);
4935 Nodes.Table (N + 2).Flag10 := Val;
4938 procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
4940 pragma Assert (Nkind (N) in N_Entity);
4941 Nodes.Table (N + 2).Flag11 := Val;
4944 procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
4946 pragma Assert (Nkind (N) in N_Entity);
4947 Nodes.Table (N + 2).Flag12 := Val;
4950 procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
4952 pragma Assert (Nkind (N) in N_Entity);
4953 Nodes.Table (N + 2).Flag13 := Val;
4956 procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
4958 pragma Assert (Nkind (N) in N_Entity);
4959 Nodes.Table (N + 2).Flag14 := Val;
4962 procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
4964 pragma Assert (Nkind (N) in N_Entity);
4965 Nodes.Table (N + 2).Flag15 := Val;
4968 procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
4970 pragma Assert (Nkind (N) in N_Entity);
4971 Nodes.Table (N + 2).Flag16 := Val;
4974 procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
4976 pragma Assert (Nkind (N) in N_Entity);
4977 Nodes.Table (N + 2).Flag17 := Val;
4980 procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
4982 pragma Assert (Nkind (N) in N_Entity);
4983 Nodes.Table (N + 2).Flag18 := Val;
4986 procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
4988 pragma Assert (Nkind (N) in N_Entity);
4989 Nodes.Table (N + 1).Pflag1 := Val;
4992 procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
4994 pragma Assert (Nkind (N) in N_Entity);
4995 Nodes.Table (N + 1).Pflag2 := Val;
4998 procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
5000 pragma Assert (Nkind (N) in N_Entity);
5001 Nodes.Table (N + 2).Pflag1 := Val;
5004 procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
5006 pragma Assert (Nkind (N) in N_Entity);
5007 Nodes.Table (N + 2).Pflag2 := Val;
5010 procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
5012 pragma Assert (Nkind (N) in N_Entity);
5015 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
5018 procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
5020 pragma Assert (Nkind (N) in N_Entity);
5023 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
5026 procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
5028 pragma Assert (Nkind (N) in N_Entity);
5031 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
5034 procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
5036 pragma Assert (Nkind (N) in N_Entity);
5039 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
5042 procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
5044 pragma Assert (Nkind (N) in N_Entity);
5047 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
5050 procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
5052 pragma Assert (Nkind (N) in N_Entity);
5055 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
5058 procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
5060 pragma Assert (Nkind (N) in N_Entity);
5063 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
5066 procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
5068 pragma Assert (Nkind (N) in N_Entity);
5071 (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
5074 procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
5076 pragma Assert (Nkind (N) in N_Entity);
5079 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
5082 procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
5084 pragma Assert (Nkind (N) in N_Entity);
5087 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
5090 procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
5092 pragma Assert (Nkind (N) in N_Entity);
5095 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
5098 procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
5100 pragma Assert (Nkind (N) in N_Entity);
5103 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
5106 procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
5108 pragma Assert (Nkind (N) in N_Entity);
5111 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
5114 procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
5116 pragma Assert (Nkind (N) in N_Entity);
5119 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
5122 procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
5124 pragma Assert (Nkind (N) in N_Entity);
5127 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
5130 procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
5132 pragma Assert (Nkind (N) in N_Entity);
5135 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
5138 procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
5140 pragma Assert (Nkind (N) in N_Entity);
5143 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
5146 procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
5148 pragma Assert (Nkind (N) in N_Entity);
5151 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
5154 procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
5156 pragma Assert (Nkind (N) in N_Entity);
5159 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
5162 procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
5164 pragma Assert (Nkind (N) in N_Entity);
5167 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
5170 procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
5172 pragma Assert (Nkind (N) in N_Entity);
5175 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
5178 procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
5180 pragma Assert (Nkind (N) in N_Entity);
5183 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
5186 procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
5188 pragma Assert (Nkind (N) in N_Entity);
5191 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
5194 procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
5196 pragma Assert (Nkind (N) in N_Entity);
5199 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
5202 procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
5204 pragma Assert (Nkind (N) in N_Entity);
5207 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
5210 procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
5212 pragma Assert (Nkind (N) in N_Entity);
5215 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
5218 procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
5220 pragma Assert (Nkind (N) in N_Entity);
5223 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
5226 procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
5228 pragma Assert (Nkind (N) in N_Entity);
5231 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
5234 procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
5236 pragma Assert (Nkind (N) in N_Entity);
5239 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
5242 procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
5244 pragma Assert (Nkind (N) in N_Entity);
5247 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
5250 procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
5252 pragma Assert (Nkind (N) in N_Entity);
5255 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
5258 procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
5260 pragma Assert (Nkind (N) in N_Entity);
5263 (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
5266 procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
5268 pragma Assert (Nkind (N) in N_Entity);
5271 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
5274 procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
5276 pragma Assert (Nkind (N) in N_Entity);
5279 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
5282 procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
5284 pragma Assert (Nkind (N) in N_Entity);
5287 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
5290 procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
5292 pragma Assert (Nkind (N) in N_Entity);
5295 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
5298 procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
5300 pragma Assert (Nkind (N) in N_Entity);
5303 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
5306 procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
5308 pragma Assert (Nkind (N) in N_Entity);
5311 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
5314 procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
5316 pragma Assert (Nkind (N) in N_Entity);
5319 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
5322 procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
5324 pragma Assert (Nkind (N) in N_Entity);
5327 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
5330 procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
5332 pragma Assert (Nkind (N) in N_Entity);
5335 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
5338 procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
5340 pragma Assert (Nkind (N) in N_Entity);
5343 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
5346 procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
5348 pragma Assert (Nkind (N) in N_Entity);
5351 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
5354 procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
5356 pragma Assert (Nkind (N) in N_Entity);
5359 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
5362 procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
5364 pragma Assert (Nkind (N) in N_Entity);
5367 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
5370 procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
5372 pragma Assert (Nkind (N) in N_Entity);
5375 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
5378 procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
5380 pragma Assert (Nkind (N) in N_Entity);
5383 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
5386 procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
5388 pragma Assert (Nkind (N) in N_Entity);
5391 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
5394 procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
5396 pragma Assert (Nkind (N) in N_Entity);
5399 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
5402 procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
5404 pragma Assert (Nkind (N) in N_Entity);
5407 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
5410 procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
5412 pragma Assert (Nkind (N) in N_Entity);
5415 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
5418 procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
5420 pragma Assert (Nkind (N) in N_Entity);
5423 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
5426 procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
5428 pragma Assert (Nkind (N) in N_Entity);
5431 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
5434 procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
5436 pragma Assert (Nkind (N) in N_Entity);
5439 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
5442 procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
5444 pragma Assert (Nkind (N) in N_Entity);
5447 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
5450 procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
5452 pragma Assert (Nkind (N) in N_Entity);
5455 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
5458 procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
5460 pragma Assert (Nkind (N) in N_Entity);
5463 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
5466 procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
5468 pragma Assert (Nkind (N) in N_Entity);
5471 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
5474 procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
5476 pragma Assert (Nkind (N) in N_Entity);
5479 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
5482 procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
5484 pragma Assert (Nkind (N) in N_Entity);
5487 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
5490 procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
5492 pragma Assert (Nkind (N) in N_Entity);
5495 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
5498 procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
5500 pragma Assert (Nkind (N) in N_Entity);
5503 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
5506 procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
5508 pragma Assert (Nkind (N) in N_Entity);
5511 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
5514 procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
5516 pragma Assert (Nkind (N) in N_Entity);
5519 (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
5522 procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
5524 pragma Assert (Nkind (N) in N_Entity);
5525 Nodes.Table (N + 3).In_List := Val;
5528 procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
5530 pragma Assert (Nkind (N) in N_Entity);
5531 Nodes.Table (N + 3).Unused_1 := Val;
5534 procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
5536 pragma Assert (Nkind (N) in N_Entity);
5537 Nodes.Table (N + 3).Rewrite_Ins := Val;
5540 procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
5542 pragma Assert (Nkind (N) in N_Entity);
5543 Nodes.Table (N + 3).Analyzed := Val;
5546 procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
5548 pragma Assert (Nkind (N) in N_Entity);
5549 Nodes.Table (N + 3).Comes_From_Source := Val;
5552 procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
5554 pragma Assert (Nkind (N) in N_Entity);
5555 Nodes.Table (N + 3).Error_Posted := Val;
5558 procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
5560 pragma Assert (Nkind (N) in N_Entity);
5561 Nodes.Table (N + 3).Flag4 := Val;
5564 procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
5566 pragma Assert (Nkind (N) in N_Entity);
5567 Nodes.Table (N + 3).Flag5 := Val;
5570 procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
5572 pragma Assert (Nkind (N) in N_Entity);
5573 Nodes.Table (N + 3).Flag6 := Val;
5576 procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
5578 pragma Assert (Nkind (N) in N_Entity);
5579 Nodes.Table (N + 3).Flag7 := Val;
5582 procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
5584 pragma Assert (Nkind (N) in N_Entity);
5585 Nodes.Table (N + 3).Flag8 := Val;
5588 procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
5590 pragma Assert (Nkind (N) in N_Entity);
5591 Nodes.Table (N + 3).Flag9 := Val;
5594 procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
5596 pragma Assert (Nkind (N) in N_Entity);
5597 Nodes.Table (N + 3).Flag10 := Val;
5600 procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
5602 pragma Assert (Nkind (N) in N_Entity);
5603 Nodes.Table (N + 3).Flag11 := Val;
5606 procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
5608 pragma Assert (Nkind (N) in N_Entity);
5609 Nodes.Table (N + 3).Flag12 := Val;
5612 procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
5614 pragma Assert (Nkind (N) in N_Entity);
5615 Nodes.Table (N + 3).Flag13 := Val;
5618 procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
5620 pragma Assert (Nkind (N) in N_Entity);
5621 Nodes.Table (N + 3).Flag14 := Val;
5624 procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
5626 pragma Assert (Nkind (N) in N_Entity);
5627 Nodes.Table (N + 3).Flag15 := Val;
5630 procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
5632 pragma Assert (Nkind (N) in N_Entity);
5633 Nodes.Table (N + 3).Flag16 := Val;
5636 procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
5638 pragma Assert (Nkind (N) in N_Entity);
5639 Nodes.Table (N + 3).Flag17 := Val;
5642 procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
5644 pragma Assert (Nkind (N) in N_Entity);
5645 Nodes.Table (N + 3).Flag18 := Val;
5648 procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
5650 pragma Assert (Nkind (N) in N_Entity);
5651 Nodes.Table (N + 3).Pflag1 := Val;
5654 procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
5656 pragma Assert (Nkind (N) in N_Entity);
5657 Nodes.Table (N + 3).Pflag2 := Val;
5660 procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
5662 pragma Assert (Nkind (N) in N_Entity);
5665 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
5668 procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
5670 pragma Assert (Nkind (N) in N_Entity);
5673 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
5676 procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
5678 pragma Assert (Nkind (N) in N_Entity);
5681 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
5684 procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
5686 pragma Assert (Nkind (N) in N_Entity);
5689 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
5692 procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
5694 pragma Assert (Nkind (N) in N_Entity);
5697 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
5700 procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
5702 pragma Assert (Nkind (N) in N_Entity);
5705 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
5708 procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
5710 pragma Assert (Nkind (N) in N_Entity);
5713 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
5716 procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
5718 pragma Assert (Nkind (N) in N_Entity);
5721 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
5724 procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
5726 pragma Assert (Nkind (N) in N_Entity);
5729 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
5732 procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
5734 pragma Assert (Nkind (N) in N_Entity);
5737 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
5740 procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
5742 pragma Assert (Nkind (N) in N_Entity);
5745 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
5748 procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
5750 pragma Assert (Nkind (N) in N_Entity);
5753 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
5756 procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
5758 pragma Assert (Nkind (N) in N_Entity);
5761 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
5764 procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
5766 pragma Assert (Nkind (N) in N_Entity);
5769 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
5772 procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
5774 pragma Assert (Nkind (N) in N_Entity);
5777 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
5780 procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
5782 pragma Assert (Nkind (N) in N_Entity);
5785 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
5788 procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
5790 pragma Assert (Nkind (N) in N_Entity);
5793 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
5796 procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
5798 pragma Assert (Nkind (N) in N_Entity);
5801 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
5804 procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
5806 pragma Assert (Nkind (N) in N_Entity);
5809 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
5812 procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
5814 pragma Assert (Nkind (N) in N_Entity);
5817 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
5820 procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
5822 pragma Assert (Nkind (N) in N_Entity);
5825 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
5828 procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
5830 pragma Assert (Nkind (N) in N_Entity);
5833 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
5836 procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
5838 pragma Assert (Nkind (N) in N_Entity);
5841 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
5844 procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
5846 pragma Assert (Nkind (N) in N_Entity);
5849 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
5852 procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
5854 pragma Assert (Nkind (N) in N_Entity);
5857 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
5860 procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
5862 pragma Assert (Nkind (N) in N_Entity);
5865 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
5868 procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
5870 pragma Assert (Nkind (N) in N_Entity);
5873 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
5876 procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
5878 pragma Assert (Nkind (N) in N_Entity);
5881 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
5884 procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
5886 pragma Assert (Nkind (N) in N_Entity);
5889 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
5892 procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
5894 pragma Assert (Nkind (N) in N_Entity);
5897 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
5900 procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
5902 pragma Assert (Nkind (N) in N_Entity);
5905 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
5908 procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
5910 pragma Assert (Nkind (N) in N_Entity);
5913 (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
5916 procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is
5918 pragma Assert (N in Nodes.First .. Nodes.Last);
5919 if Val > Error then Set_Parent (Val, N); end if;
5921 end Set_Node1_With_Parent;
5923 procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is
5925 pragma Assert (N in Nodes.First .. Nodes.Last);
5926 if Val > Error then Set_Parent (Val, N); end if;
5928 end Set_Node2_With_Parent;
5930 procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is
5932 pragma Assert (N in Nodes.First .. Nodes.Last);
5933 if Val > Error then Set_Parent (Val, N); end if;
5935 end Set_Node3_With_Parent;
5937 procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is
5939 pragma Assert (N in Nodes.First .. Nodes.Last);
5940 if Val > Error then Set_Parent (Val, N); end if;
5942 end Set_Node4_With_Parent;
5944 procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
5946 pragma Assert (N in Nodes.First .. Nodes.Last);
5947 if Val > Error then Set_Parent (Val, N); end if;
5949 end Set_Node5_With_Parent;
5951 procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
5953 pragma Assert (N in Nodes.First .. Nodes.Last);
5954 if Val /= No_List and then Val /= Error_List then
5955 Set_Parent (Val, N);
5958 end Set_List1_With_Parent;
5960 procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
5962 pragma Assert (N in Nodes.First .. Nodes.Last);
5963 if Val /= No_List and then Val /= Error_List then
5964 Set_Parent (Val, N);
5967 end Set_List2_With_Parent;
5969 procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
5971 pragma Assert (N in Nodes.First .. Nodes.Last);
5972 if Val /= No_List and then Val /= Error_List then
5973 Set_Parent (Val, N);
5976 end Set_List3_With_Parent;
5978 procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
5980 pragma Assert (N in Nodes.First .. Nodes.Last);
5981 if Val /= No_List and then Val /= Error_List then
5982 Set_Parent (Val, N);
5985 end Set_List4_With_Parent;
5987 procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
5989 pragma Assert (N in Nodes.First .. Nodes.Last);
5990 if Val /= No_List and then Val /= Error_List then
5991 Set_Parent (Val, N);
5994 end Set_List5_With_Parent;
5996 end Unchecked_Access;