gcc/ada/atree.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                                A T R E E                                 --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2004, Free Software Foundation, Inc.         --
  10 --                                                                          --
  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.                                                      --
  21 --                                                                          --
  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.                                      --
  28 --                                                                          --
  29 -- GNAT was originally developed  by the GNAT team at  New York University. --
  30 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  31 --                                                                          --
  32 ------------------------------------------------------------------------------
  33
  34 pragma Style_Checks (All_Checks);
  35 --  Turn off subprogram ordering check for this package
  36
  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).
  40
  41 with Debug;   use Debug;
  42 with Namet;   use Namet;
  43 with Nlists;  use Nlists;
  44 with Elists;  use Elists;
  45 with Output;  use Output;
  46 with Sinput;  use Sinput;
  47 with Tree_IO; use Tree_IO;
  48
  49 with GNAT.HTable; use GNAT.HTable;
  50
  51 package body Atree is
  52
  53    Node_Count : Nat;
  54    --  Count allocated nodes for Num_Nodes function
  55
  56    use Unchecked_Access;
  57    --  We are allowed to see these from within our own body!
  58
  59    use Atree_Private_Part;
  60    --  We are also allowed to see our private data structures!
  61
  62    function E_To_N is new Unchecked_Conversion (Entity_Kind, Node_Kind);
  63    function N_To_E is new Unchecked_Conversion (Node_Kind, Entity_Kind);
  64    --  Functions used to store Entity_Kind value in Nkind field
  65
  66    --  The following declarations are used to store flags 65-72 in the
  67    --  Nkind field of the third component of an extended (entity) node.
  68
  69    type Flag_Byte is record
  70       Flag65 : Boolean;
  71       Flag66 : Boolean;
  72       Flag67 : Boolean;
  73       Flag68 : Boolean;
  74       Flag69 : Boolean;
  75       Flag70 : Boolean;
  76       Flag71 : Boolean;
  77       Flag72 : Boolean;
  78    end record;
  79
  80    pragma Pack (Flag_Byte);
  81    for Flag_Byte'Size use 8;
  82
  83    type Flag_Byte_Ptr is access all Flag_Byte;
  84    type Node_Kind_Ptr is access all Node_Kind;
  85
  86    function To_Flag_Byte is new
  87      Unchecked_Conversion (Node_Kind, Flag_Byte);
  88
  89    function To_Flag_Byte_Ptr is new
  90      Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);
  91
  92    --  The following declarations are used to store flags 73-96 in the
  93    --  Field12 field of the third component of an extended (entity) node.
  94
  95    type Flag_Word is record
  96       Flag73 : Boolean;
  97       Flag74 : Boolean;
  98       Flag75 : Boolean;
  99       Flag76 : Boolean;
 100       Flag77 : Boolean;
 101       Flag78 : Boolean;
 102       Flag79 : Boolean;
 103       Flag80 : Boolean;
 104
 105       Flag81 : Boolean;
 106       Flag82 : Boolean;
 107       Flag83 : Boolean;
 108       Flag84 : Boolean;
 109       Flag85 : Boolean;
 110       Flag86 : Boolean;
 111       Flag87 : Boolean;
 112       Flag88 : Boolean;
 113
 114       Flag89 : Boolean;
 115       Flag90 : Boolean;
 116       Flag91 : Boolean;
 117       Flag92 : Boolean;
 118       Flag93 : Boolean;
 119       Flag94 : Boolean;
 120       Flag95 : Boolean;
 121       Flag96 : Boolean;
 122
 123       Convention : Convention_Id;
 124    end record;
 125
 126    pragma Pack (Flag_Word);
 127    for Flag_Word'Size use 32;
 128    for Flag_Word'Alignment use 4;
 129
 130    type Flag_Word_Ptr is access all Flag_Word;
 131    type Union_Id_Ptr  is access all Union_Id;
 132
 133    function To_Flag_Word is new
 134      Unchecked_Conversion (Union_Id, Flag_Word);
 135
 136    function To_Flag_Word_Ptr is new
 137      Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr);
 138
 139    --  The following declarations are used to store flags 97-128 in the
 140    --  Field12 field of the fourth component of an extended (entity) node.
 141
 142    type Flag_Word2 is record
 143       Flag97  : Boolean;
 144       Flag98  : Boolean;
 145       Flag99  : Boolean;
 146       Flag100 : Boolean;
 147       Flag101 : Boolean;
 148       Flag102 : Boolean;
 149       Flag103 : Boolean;
 150       Flag104 : Boolean;
 151
 152       Flag105 : Boolean;
 153       Flag106 : Boolean;
 154       Flag107 : Boolean;
 155       Flag108 : Boolean;
 156       Flag109 : Boolean;
 157       Flag110 : Boolean;
 158       Flag111 : Boolean;
 159       Flag112 : Boolean;
 160
 161       Flag113 : Boolean;
 162       Flag114 : Boolean;
 163       Flag115 : Boolean;
 164       Flag116 : Boolean;
 165       Flag117 : Boolean;
 166       Flag118 : Boolean;
 167       Flag119 : Boolean;
 168       Flag120 : Boolean;
 169
 170       Flag121 : Boolean;
 171       Flag122 : Boolean;
 172       Flag123 : Boolean;
 173       Flag124 : Boolean;
 174       Flag125 : Boolean;
 175       Flag126 : Boolean;
 176       Flag127 : Boolean;
 177       Flag128 : Boolean;
 178    end record;
 179
 180    pragma Pack (Flag_Word2);
 181    for Flag_Word2'Size use 32;
 182    for Flag_Word2'Alignment use 4;
 183
 184    type Flag_Word2_Ptr is access all Flag_Word2;
 185
 186    function To_Flag_Word2 is new
 187      Unchecked_Conversion (Union_Id, Flag_Word2);
 188
 189    function To_Flag_Word2_Ptr is new
 190      Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr);
 191
 192    --  The following declarations are used to store flags 97-120 in the
 193    --  Field12 field of the fourth component of an extended (entity) node.
 194
 195    type Flag_Word3 is record
 196       Flag152  : Boolean;
 197       Flag153 : Boolean;
 198       Flag154 : Boolean;
 199       Flag155 : Boolean;
 200       Flag156 : Boolean;
 201       Flag157 : Boolean;
 202       Flag158 : Boolean;
 203       Flag159 : Boolean;
 204
 205       Flag160 : Boolean;
 206       Flag161 : Boolean;
 207       Flag162 : Boolean;
 208       Flag163 : Boolean;
 209       Flag164 : Boolean;
 210       Flag165 : Boolean;
 211       Flag166 : Boolean;
 212       Flag167 : Boolean;
 213
 214       Flag168 : Boolean;
 215       Flag169 : Boolean;
 216       Flag170 : Boolean;
 217       Flag171 : Boolean;
 218       Flag172 : Boolean;
 219       Flag173 : Boolean;
 220       Flag174 : Boolean;
 221       Flag175 : Boolean;
 222
 223       Flag176 : Boolean;
 224       Flag177 : Boolean;
 225       Flag178 : Boolean;
 226       Flag179 : Boolean;
 227       Flag180 : Boolean;
 228       Flag181 : Boolean;
 229       Flag182 : Boolean;
 230       Flag183 : Boolean;
 231    end record;
 232
 233    pragma Pack (Flag_Word3);
 234    for Flag_Word3'Size use 32;
 235    for Flag_Word3'Alignment use 4;
 236
 237    type Flag_Word3_Ptr is access all Flag_Word3;
 238
 239    function To_Flag_Word3 is new
 240      Unchecked_Conversion (Union_Id, Flag_Word3);
 241
 242    function To_Flag_Word3_Ptr is new
 243      Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr);
 244
 245    --  Default value used to initialize default nodes. Note that some of the
 246    --  fields get overwritten, and in particular, Nkind always gets reset.
 247
 248    Default_Node : Node_Record := (
 249       Is_Extension      => False,
 250       Pflag1            => False,
 251       Pflag2            => False,
 252       In_List           => False,
 253       Unused_1          => False,
 254       Rewrite_Ins       => False,
 255       Analyzed          => False,
 256       Comes_From_Source => False, -- modified by Set_Comes_From_Source_Default
 257       Error_Posted      => False,
 258       Flag4             => False,
 259
 260       Flag5             => False,
 261       Flag6             => False,
 262       Flag7             => False,
 263       Flag8             => False,
 264       Flag9             => False,
 265       Flag10            => False,
 266       Flag11            => False,
 267       Flag12            => False,
 268
 269       Flag13            => False,
 270       Flag14            => False,
 271       Flag15            => False,
 272       Flag16            => False,
 273       Flag17            => False,
 274       Flag18            => False,
 275
 276       Nkind             => N_Unused_At_Start,
 277
 278       Sloc              => No_Location,
 279       Link              => Empty_List_Or_Node,
 280       Field1            => Empty_List_Or_Node,
 281       Field2            => Empty_List_Or_Node,
 282       Field3            => Empty_List_Or_Node,
 283       Field4            => Empty_List_Or_Node,
 284       Field5            => Empty_List_Or_Node);
 285
 286    --  Default value used to initialize node extensions (i.e. the second
 287    --  and third and fourth components of an extended node). Note we are
 288    --  cheating a bit here when it comes to Node12, which really holds
 289    --  flags an (for the third component), the convention. But it works
 290    --  because Empty, False, Convention_Ada, all happen to be all zero bits.
 291
 292    Default_Node_Extension : constant Node_Record := (
 293       Is_Extension      => True,
 294       Pflag1            => False,
 295       Pflag2            => False,
 296       In_List           => False,
 297       Unused_1          => False,
 298       Rewrite_Ins       => False,
 299       Analyzed          => False,
 300       Comes_From_Source => False,
 301       Error_Posted      => False,
 302       Flag4             => False,
 303
 304       Flag5             => False,
 305       Flag6             => False,
 306       Flag7             => False,
 307       Flag8             => False,
 308       Flag9             => False,
 309       Flag10            => False,
 310       Flag11            => False,
 311       Flag12            => False,
 312
 313       Flag13            => False,
 314       Flag14            => False,
 315       Flag15            => False,
 316       Flag16            => False,
 317       Flag17            => False,
 318       Flag18            => False,
 319
 320       Nkind             => E_To_N (E_Void),
 321
 322       Field6            => Empty_List_Or_Node,
 323       Field7            => Empty_List_Or_Node,
 324       Field8            => Empty_List_Or_Node,
 325       Field9            => Empty_List_Or_Node,
 326       Field10           => Empty_List_Or_Node,
 327       Field11           => Empty_List_Or_Node,
 328       Field12           => Empty_List_Or_Node);
 329
 330    --------------------------------------------------
 331    -- Implementation of Tree Substitution Routines --
 332    --------------------------------------------------
 333
 334    --  A separate table keeps track of the mapping between rewritten nodes
 335    --  and their corresponding original tree nodes. Rewrite makes an entry
 336    --  in this table for use by Original_Node. By default, if no call is
 337    --  Rewrite, the entry in this table points to the original unwritten node.
 338
 339    --  Note: eventually, this should be a field in the Node directly, but
 340    --  for now we do not want to disturb the efficiency of a power of 2
 341    --  for the node size
 342
 343    package Orig_Nodes is new Table.Table (
 344       Table_Component_Type => Node_Id,
 345       Table_Index_Type     => Node_Id,
 346       Table_Low_Bound      => First_Node_Id,
 347       Table_Initial        => Alloc.Orig_Nodes_Initial,
 348       Table_Increment      => Alloc.Orig_Nodes_Increment,
 349       Table_Name           => "Orig_Nodes");
 350
 351    ----------------------------------------
 352    -- Global_Variables for New_Copy_Tree --
 353    ----------------------------------------
 354
 355    --  These global variables are used by New_Copy_Tree. See description
 356    --  of the body of this subprogram for details. Global variables can be
 357    --  safely used by New_Copy_Tree, since there is no case of a recursive
 358    --  call from the processing inside New_Copy_Tree.
 359
 360    NCT_Hash_Threshhold : constant := 20;
 361    --  If there are more than this number of pairs of entries in the
 362    --  map, then Hash_Tables_Used will be set, and the hash tables will
 363    --  be initialized and used for the searches.
 364
 365    NCT_Hash_Tables_Used : Boolean := False;
 366    --  Set to True if hash tables are in use
 367
 368    NCT_Table_Entries : Nat;
 369    --  Count entries in table to see if threshhold is reached
 370
 371    NCT_Hash_Table_Setup : Boolean := False;
 372    --  Set to True if hash table contains data. We set this True if we
 373    --  setup the hash table with data, and leave it set permanently
 374    --  from then on, this is a signal that second and subsequent users
 375    --  of the hash table must clear the old entries before reuse.
 376
 377    subtype NCT_Header_Num is Int range 0 .. 511;
 378    --  Defines range of headers in hash tables (512 headers)
 379
 380    -----------------------
 381    -- Local Subprograms --
 382    -----------------------
 383
 384    procedure Fix_Parents (Old_Node, New_Node : Node_Id);
 385    --  Fixup parent pointers for the syntactic children of New_Node after
 386    --  a copy, setting them to New_Node when they pointed to Old_Node.
 387
 388    function Allocate_Initialize_Node
 389      (Src            : Node_Id;
 390       With_Extension : Boolean) return Node_Id;
 391    --  Allocate a new node or node extension. If Src is not empty,
 392    --  the information for the newly-allocated node is copied from it.
 393
 394    ------------------------------
 395    -- Allocate_Initialize_Node --
 396    ------------------------------
 397
 398    function Allocate_Initialize_Node
 399      (Src            : Node_Id;
 400       With_Extension : Boolean) return Node_Id
 401    is
 402       New_Id : Node_Id     := Src;
 403       Nod    : Node_Record := Default_Node;
 404       Ext1   : Node_Record := Default_Node_Extension;
 405       Ext2   : Node_Record := Default_Node_Extension;
 406       Ext3   : Node_Record := Default_Node_Extension;
 407    begin
 408       if Present (Src) then
 409          Nod := Nodes.Table (Src);
 410
 411          if Has_Extension (Src) then
 412             Ext1 := Nodes.Table (Src + 1);
 413             Ext2 := Nodes.Table (Src + 2);
 414             Ext3 := Nodes.Table (Src + 3);
 415          end if;
 416       end if;
 417
 418       if not (Present (Src)
 419                and then not Has_Extension (Src)
 420                and then With_Extension
 421                and then Src = Nodes.Last)
 422       then
 423          --  We are allocating a new node, or extending a node
 424          --  other than Nodes.Last.
 425
 426          Nodes.Append (Nod);
 427          New_Id := Nodes.Last;
 428          Orig_Nodes.Append (New_Id);
 429          Node_Count := Node_Count + 1;
 430       end if;
 431
 432       if With_Extension then
 433          Nodes.Append (Ext1);
 434          Nodes.Append (Ext2);
 435          Nodes.Append (Ext3);
 436       end if;
 437
 438       Orig_Nodes.Set_Last (Nodes.Last);
 439       Allocate_List_Tables (Nodes.Last);
 440       return New_Id;
 441    end Allocate_Initialize_Node;
 442
 443    --------------
 444    -- Analyzed --
 445    --------------
 446
 447    function Analyzed (N : Node_Id) return Boolean is
 448    begin
 449       pragma Assert (N in Nodes.First .. Nodes.Last);
 450       return Nodes.Table (N).Analyzed;
 451    end Analyzed;
 452
 453    -----------------
 454    -- Change_Node --
 455    -----------------
 456
 457    procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is
 458       Save_Sloc    : constant Source_Ptr := Sloc (N);
 459       Save_In_List : constant Boolean    := Nodes.Table (N).In_List;
 460       Save_Link    : constant Union_Id   := Nodes.Table (N).Link;
 461       Save_CFS     : constant Boolean    := Nodes.Table (N).Comes_From_Source;
 462       Save_Posted  : constant Boolean    := Nodes.Table (N).Error_Posted;
 463       Par_Count    : Paren_Count_Type    := 0;
 464
 465    begin
 466       if Nkind (N) in N_Subexpr then
 467          Par_Count := Paren_Count (N);
 468       end if;
 469
 470       Nodes.Table (N)                   := Default_Node;
 471       Nodes.Table (N).Sloc              := Save_Sloc;
 472       Nodes.Table (N).In_List           := Save_In_List;
 473       Nodes.Table (N).Link              := Save_Link;
 474       Nodes.Table (N).Comes_From_Source := Save_CFS;
 475       Nodes.Table (N).Nkind             := New_Node_Kind;
 476       Nodes.Table (N).Error_Posted      := Save_Posted;
 477
 478       if New_Node_Kind in N_Subexpr then
 479          Set_Paren_Count (N, Par_Count);
 480       end if;
 481    end Change_Node;
 482
 483    -----------------------
 484    -- Comes_From_Source --
 485    -----------------------
 486
 487    function Comes_From_Source (N : Node_Id) return Boolean is
 488    begin
 489       pragma Assert (N in Nodes.First .. Nodes.Last);
 490       return Nodes.Table (N).Comes_From_Source;
 491    end Comes_From_Source;
 492
 493    ----------------
 494    -- Convention --
 495    ----------------
 496
 497    function Convention (E : Entity_Id) return Convention_Id is
 498    begin
 499       pragma Assert (Nkind (E) in N_Entity);
 500       return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention;
 501    end Convention;
 502
 503    ---------------
 504    -- Copy_Node --
 505    ---------------
 506
 507    procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is
 508       Save_In_List : constant Boolean  := Nodes.Table (Destination).In_List;
 509       Save_Link    : constant Union_Id := Nodes.Table (Destination).Link;
 510
 511    begin
 512       Nodes.Table (Destination)         := Nodes.Table (Source);
 513       Nodes.Table (Destination).In_List := Save_In_List;
 514       Nodes.Table (Destination).Link    := Save_Link;
 515
 516       if Has_Extension (Source) then
 517          pragma Assert (Has_Extension (Destination));
 518          Nodes.Table (Destination + 1) := Nodes.Table (Source + 1);
 519          Nodes.Table (Destination + 2) := Nodes.Table (Source + 2);
 520          Nodes.Table (Destination + 3) := Nodes.Table (Source + 3);
 521
 522       else
 523          pragma Assert (not Has_Extension (Source));
 524          null;
 525       end if;
 526    end Copy_Node;
 527
 528    ------------------------
 529    -- Copy_Separate_Tree --
 530    ------------------------
 531
 532    function Copy_Separate_Tree (Source : Node_Id) return Node_Id is
 533       New_Id  : Node_Id;
 534
 535       function Copy_Entity (E : Entity_Id) return Entity_Id;
 536       --  Copy Entity, copying only the Ekind and Chars fields
 537
 538       function Copy_List (List : List_Id) return List_Id;
 539       --  Copy list
 540
 541       function Possible_Copy (Field : Union_Id) return Union_Id;
 542       --  Given a field, returns a copy of the node or list if its parent
 543       --  is the current source node, and otherwise returns the input
 544
 545       -----------------
 546       -- Copy_Entity --
 547       -----------------
 548
 549       function Copy_Entity (E : Entity_Id) return Entity_Id is
 550          New_Ent : Entity_Id;
 551
 552       begin
 553          case N_Entity (Nkind (E)) is
 554             when N_Defining_Identifier =>
 555                New_Ent := New_Entity (N_Defining_Identifier, Sloc (E));
 556
 557             when N_Defining_Character_Literal =>
 558                New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E));
 559
 560             when N_Defining_Operator_Symbol =>
 561                New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E));
 562          end case;
 563
 564          Set_Chars (New_Ent, Chars (E));
 565          return New_Ent;
 566       end Copy_Entity;
 567
 568       ---------------
 569       -- Copy_List --
 570       ---------------
 571
 572       function Copy_List (List : List_Id) return List_Id is
 573          NL : List_Id;
 574          E  : Node_Id;
 575
 576       begin
 577          if List = No_List then
 578             return No_List;
 579
 580          else
 581             NL := New_List;
 582             E := First (List);
 583
 584             while Present (E) loop
 585
 586                if Has_Extension (E) then
 587                   Append (Copy_Entity (E), NL);
 588                else
 589                   Append (Copy_Separate_Tree (E), NL);
 590                end if;
 591
 592                Next (E);
 593             end loop;
 594
 595             return NL;
 596          end if;
 597       end Copy_List;
 598
 599       -------------------
 600       -- Possible_Copy --
 601       -------------------
 602
 603       function Possible_Copy (Field : Union_Id) return Union_Id is
 604          New_N : Union_Id;
 605
 606       begin
 607          if Field in Node_Range then
 608
 609             New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field)));
 610
 611             if Parent (Node_Id (Field)) = Source then
 612                Set_Parent (Node_Id (New_N), New_Id);
 613             end if;
 614
 615             return New_N;
 616
 617          elsif Field in List_Range then
 618             New_N := Union_Id (Copy_List (List_Id (Field)));
 619
 620             if Parent (List_Id (Field)) = Source then
 621                Set_Parent (List_Id (New_N), New_Id);
 622             end if;
 623
 624             return New_N;
 625
 626          else
 627             return Field;
 628          end if;
 629       end Possible_Copy;
 630
 631    --  Start of processing for Copy_Separate_Tree
 632
 633    begin
 634       if Source <= Empty_Or_Error then
 635          return Source;
 636
 637       elsif Has_Extension (Source) then
 638          return Copy_Entity (Source);
 639
 640       else
 641          New_Id := New_Copy (Source);
 642
 643          --  Recursively copy descendents
 644
 645          Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id)));
 646          Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id)));
 647          Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id)));
 648          Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id)));
 649          Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id)));
 650
 651          --  Set Entity field to Empty
 652          --  Why is this done??? and why is it always right to do it???
 653
 654          if Nkind (New_Id) in N_Has_Entity
 655            or else Nkind (New_Id) = N_Freeze_Entity
 656          then
 657             Set_Entity (New_Id, Empty);
 658          end if;
 659
 660          --  All done, return copied node
 661
 662          return New_Id;
 663       end if;
 664    end Copy_Separate_Tree;
 665
 666    -----------------
 667    -- Delete_Node --
 668    -----------------
 669
 670    procedure Delete_Node (Node : Node_Id) is
 671    begin
 672       pragma Assert (not Nodes.Table (Node).In_List);
 673
 674       if Debug_Flag_N then
 675          Write_Str ("Delete node ");
 676          Write_Int (Int (Node));
 677          Write_Eol;
 678       end if;
 679
 680       Nodes.Table (Node)       := Default_Node;
 681       Nodes.Table (Node).Nkind := N_Unused_At_Start;
 682       Node_Count := Node_Count - 1;
 683
 684       --  Note: for now, we are not bothering to reuse deleted nodes
 685
 686    end Delete_Node;
 687
 688    -----------------
 689    -- Delete_Tree --
 690    -----------------
 691
 692    procedure Delete_Tree (Node : Node_Id) is
 693
 694       procedure Delete_Field (F : Union_Id);
 695       --  Delete item pointed to by field F if it is a syntactic element
 696
 697       procedure Delete_List (L : List_Id);
 698       --  Delete all elements on the given list
 699
 700       procedure Delete_Field (F : Union_Id) is
 701       begin
 702          if F = Union_Id (Empty) then
 703             return;
 704
 705          elsif F in Node_Range
 706            and then Parent (Node_Id (F)) = Node
 707          then
 708             Delete_Tree (Node_Id (F));
 709
 710          elsif F in List_Range
 711            and then Parent (List_Id (F)) = Node
 712          then
 713             Delete_List (List_Id (F));
 714
 715          --  No need to test Elist case, there are no syntactic Elists
 716
 717          else
 718             return;
 719          end if;
 720       end Delete_Field;
 721
 722       procedure Delete_List (L : List_Id) is
 723       begin
 724          while Is_Non_Empty_List (L) loop
 725             Delete_Tree (Remove_Head (L));
 726          end loop;
 727       end Delete_List;
 728
 729    --  Start of processing for Delete_Tree
 730
 731    begin
 732       --  Delete descendents
 733
 734       Delete_Field (Field1 (Node));
 735       Delete_Field (Field2 (Node));
 736       Delete_Field (Field3 (Node));
 737       Delete_Field (Field4 (Node));
 738       Delete_Field (Field5 (Node));
 739    end Delete_Tree;
 740
 741    -----------
 742    -- Ekind --
 743    -----------
 744
 745    function Ekind (E : Entity_Id) return Entity_Kind is
 746    begin
 747       pragma Assert (Nkind (E) in N_Entity);
 748       return N_To_E (Nodes.Table (E + 1).Nkind);
 749    end Ekind;
 750
 751    ------------------
 752    -- Error_Posted --
 753    ------------------
 754
 755    function Error_Posted (N : Node_Id) return Boolean is
 756    begin
 757       pragma Assert (N in Nodes.First .. Nodes.Last);
 758       return Nodes.Table (N).Error_Posted;
 759    end Error_Posted;
 760
 761    -----------------------
 762    -- Exchange_Entities --
 763    -----------------------
 764
 765    procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is
 766       Temp_Ent : Node_Record;
 767
 768    begin
 769       pragma Assert (Has_Extension (E1)
 770         and then Has_Extension (E2)
 771         and then not Nodes.Table (E1).In_List
 772         and then not Nodes.Table (E2).In_List);
 773
 774       --  Exchange the contents of the two entities
 775
 776       Temp_Ent := Nodes.Table (E1);
 777       Nodes.Table (E1) := Nodes.Table (E2);
 778       Nodes.Table (E2) := Temp_Ent;
 779       Temp_Ent := Nodes.Table (E1 + 1);
 780       Nodes.Table (E1 + 1) := Nodes.Table (E2 + 1);
 781       Nodes.Table (E2 + 1) := Temp_Ent;
 782       Temp_Ent := Nodes.Table (E1 + 2);
 783       Nodes.Table (E1 + 2) := Nodes.Table (E2 + 2);
 784       Nodes.Table (E2 + 2) := Temp_Ent;
 785       Temp_Ent := Nodes.Table (E1 + 3);
 786       Nodes.Table (E1 + 3) := Nodes.Table (E2 + 3);
 787       Nodes.Table (E2 + 3) := Temp_Ent;
 788
 789       --  That exchange exchanged the parent pointers as well, which is what
 790       --  we want, but we need to patch up the defining identifier pointers
 791       --  in the parent nodes (the child pointers) to match this switch
 792       --  unless for Implicit types entities which have no parent, in which
 793       --  case we don't do anything otherwise we won't be able to revert back
 794       --  to the original situation.
 795
 796       --  Shouldn't this use Is_Itype instead of the Parent test
 797
 798       if Present (Parent (E1)) and then Present (Parent (E2)) then
 799          Set_Defining_Identifier (Parent (E1), E1);
 800          Set_Defining_Identifier (Parent (E2), E2);
 801       end if;
 802    end Exchange_Entities;
 803
 804    -----------------
 805    -- Extend_Node --
 806    -----------------
 807
 808    function Extend_Node (Node : Node_Id) return Entity_Id is
 809       Result : Entity_Id;
 810
 811       procedure Debug_Extend_Node;
 812       --  Debug routine for debug flag N
 813       pragma Inline (Debug_Extend_Node);
 814
 815       procedure Debug_Extend_Node is
 816       begin
 817          if Debug_Flag_N then
 818             Write_Str ("Extend node ");
 819             Write_Int (Int (Node));
 820
 821             if Result = Node then
 822                Write_Str (" in place");
 823             else
 824                Write_Str (" copied to ");
 825                Write_Int (Int (Result));
 826             end if;
 827
 828             --  Write_Eol;
 829          end if;
 830       end Debug_Extend_Node;
 831
 832    begin
 833       pragma Assert (not (Has_Extension (Node)));
 834       Result := Allocate_Initialize_Node (Node, With_Extension => True);
 835       pragma Debug (Debug_Extend_Node);
 836       return Result;
 837    end Extend_Node;
 838
 839    -----------------
 840    -- Fix_Parents --
 841    -----------------
 842
 843    procedure Fix_Parents (Old_Node, New_Node : Node_Id) is
 844
 845       procedure Fix_Parent (Field : Union_Id; Old_Node, New_Node : Node_Id);
 846       --  Fixup one parent pointer. Field is checked to see if it
 847       --  points to a node, list, or element list that has a parent that
 848       --  points to Old_Node. If so, the parent is reset to point to New_Node.
 849
 850       procedure Fix_Parent (Field : Union_Id; Old_Node, New_Node : Node_Id) is
 851       begin
 852          --  Fix parent of node that is referenced by Field. Note that we must
 853          --  exclude the case where the node is a member of a list, because in
 854          --  this case the parent is the parent of the list.
 855
 856          if Field in Node_Range
 857            and then Present (Node_Id (Field))
 858            and then not Nodes.Table (Node_Id (Field)).In_List
 859            and then Parent (Node_Id (Field)) = Old_Node
 860          then
 861             Set_Parent (Node_Id (Field), New_Node);
 862
 863          --  Fix parent of list that is referenced by Field
 864
 865          elsif Field in List_Range
 866            and then Present (List_Id (Field))
 867            and then Parent (List_Id (Field)) = Old_Node
 868          then
 869             Set_Parent (List_Id (Field), New_Node);
 870          end if;
 871       end Fix_Parent;
 872
 873    begin
 874       Fix_Parent (Field1 (New_Node), Old_Node, New_Node);
 875       Fix_Parent (Field2 (New_Node), Old_Node, New_Node);
 876       Fix_Parent (Field3 (New_Node), Old_Node, New_Node);
 877       Fix_Parent (Field4 (New_Node), Old_Node, New_Node);
 878       Fix_Parent (Field5 (New_Node), Old_Node, New_Node);
 879    end Fix_Parents;
 880
 881    -----------------------------------
 882    -- Get_Comes_From_Source_Default --
 883    -----------------------------------
 884
 885    function Get_Comes_From_Source_Default return Boolean is
 886    begin
 887       return Default_Node.Comes_From_Source;
 888    end Get_Comes_From_Source_Default;
 889
 890    -------------------
 891    -- Has_Extension --
 892    -------------------
 893
 894    function Has_Extension (N : Node_Id) return Boolean is
 895    begin
 896       return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension;
 897    end Has_Extension;
 898
 899    ----------------
 900    -- Initialize --
 901    ----------------
 902
 903    procedure Initialize is
 904       Dummy : Node_Id;
 905       pragma Warnings (Off, Dummy);
 906
 907    begin
 908       Node_Count := 0;
 909       Atree_Private_Part.Nodes.Init;
 910       Orig_Nodes.Init;
 911
 912       --  Allocate Empty node
 913
 914       Dummy := New_Node (N_Empty, No_Location);
 915       Set_Name1 (Empty, No_Name);
 916
 917       --  Allocate Error node, and set Error_Posted, since we certainly
 918       --  only generate an Error node if we do post some kind of error!
 919
 920       Dummy := New_Node (N_Error, No_Location);
 921       Set_Name1 (Error, Error_Name);
 922       Set_Error_Posted (Error, True);
 923
 924       --  Set global variables for New_Copy_Tree:
 925       NCT_Hash_Tables_Used := False;
 926       NCT_Table_Entries    := 0;
 927       NCT_Hash_Table_Setup := False;
 928    end Initialize;
 929
 930    --------------------------
 931    -- Is_Rewrite_Insertion --
 932    --------------------------
 933
 934    function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is
 935    begin
 936       return Nodes.Table (Node).Rewrite_Ins;
 937    end Is_Rewrite_Insertion;
 938
 939    -----------------------------
 940    -- Is_Rewrite_Substitution --
 941    -----------------------------
 942
 943    function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is
 944    begin
 945       return Orig_Nodes.Table (Node) /= Node;
 946    end Is_Rewrite_Substitution;
 947
 948    ------------------
 949    -- Last_Node_Id --
 950    ------------------
 951
 952    function Last_Node_Id return Node_Id is
 953    begin
 954       return Nodes.Last;
 955    end Last_Node_Id;
 956
 957    ----------
 958    -- Lock --
 959    ----------
 960
 961    procedure Lock is
 962    begin
 963       Nodes.Locked := True;
 964       Orig_Nodes.Locked := True;
 965       Nodes.Release;
 966       Orig_Nodes.Release;
 967    end Lock;
 968
 969    ----------------------------
 970    -- Mark_Rewrite_Insertion --
 971    ----------------------------
 972
 973    procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is
 974    begin
 975       Nodes.Table (New_Node).Rewrite_Ins := True;
 976    end Mark_Rewrite_Insertion;
 977
 978    --------------
 979    -- New_Copy --
 980    --------------
 981
 982    function New_Copy (Source : Node_Id) return Node_Id is
 983       New_Id : Node_Id := Source;
 984
 985    begin
 986       if Source > Empty_Or_Error then
 987
 988          New_Id := Allocate_Initialize_Node (Source, Has_Extension (Source));
 989
 990          Nodes.Table (New_Id).Link := Empty_List_Or_Node;
 991          Nodes.Table (New_Id).In_List := False;
 992
 993          --  If the original is marked as a rewrite insertion, then unmark
 994          --  the copy, since we inserted the original, not the copy.
 995
 996          Nodes.Table (New_Id).Rewrite_Ins := False;
 997       end if;
 998
 999       return New_Id;
1000    end New_Copy;
1001
1002    -------------------
1003    -- New_Copy_Tree --
1004    -------------------
1005
1006    --  Our approach here requires a two pass traversal of the tree. The
1007    --  first pass visits all nodes that eventually will be copied looking
1008    --  for defining Itypes. If any defining Itypes are found, then they are
1009    --  copied, and an entry is added to the replacement map. In the second
1010    --  phase, the tree is copied, using the replacement map to replace any
1011    --  Itype references within the copied tree.
1012
1013    --  The following hash tables are used if the Map supplied has more
1014    --  than hash threshhold entries to speed up access to the map. If
1015    --  there are fewer entries, then the map is searched sequentially
1016    --  (because setting up a hash table for only a few entries takes
1017    --  more time than it saves.
1018
1019    function New_Copy_Hash (E : Entity_Id) return NCT_Header_Num;
1020    --  Hash function used for hash operations
1021
1022    function New_Copy_Hash (E : Entity_Id) return NCT_Header_Num is
1023    begin
1024       return Nat (E) mod (NCT_Header_Num'Last + 1);
1025    end New_Copy_Hash;
1026
1027    --  The hash table NCT_Assoc associates old entities in the table
1028    --  with their corresponding new entities (i.e. the pairs of entries
1029    --  presented in the original Map argument are Key-Element pairs).
1030
1031    package NCT_Assoc is new Simple_HTable (
1032      Header_Num => NCT_Header_Num,
1033      Element    => Entity_Id,
1034      No_Element => Empty,
1035      Key        => Entity_Id,
1036      Hash       => New_Copy_Hash,
1037      Equal      => Types."=");
1038
1039    --  The hash table NCT_Itype_Assoc contains entries only for those
1040    --  old nodes which have a non-empty Associated_Node_For_Itype set.
1041    --  The key is the associated node, and the element is the new node
1042    --  itself (NOT the associated node for the new node).
1043
1044    package NCT_Itype_Assoc is new Simple_HTable (
1045      Header_Num => NCT_Header_Num,
1046      Element    => Entity_Id,
1047      No_Element => Empty,
1048      Key        => Entity_Id,
1049      Hash       => New_Copy_Hash,
1050      Equal      => Types."=");
1051
1052    --  Start of New_Copy_Tree function
1053
1054    function New_Copy_Tree
1055      (Source    : Node_Id;
1056       Map       : Elist_Id := No_Elist;
1057       New_Sloc  : Source_Ptr := No_Location;
1058       New_Scope : Entity_Id := Empty) return Node_Id
1059    is
1060       Actual_Map : Elist_Id := Map;
1061       --  This is the actual map for the copy. It is initialized with the
1062       --  given elements, and then enlarged as required for Itypes that are
1063       --  copied during the first phase of the copy operation. The visit
1064       --  procedures add elements to this map as Itypes are encountered.
1065       --  The reason we cannot use Map directly, is that it may well be
1066       --  (and normally is) initialized to No_Elist, and if we have mapped
1067       --  entities, we have to reset it to point to a real Elist.
1068
1069       function Assoc (N : Node_Or_Entity_Id) return Node_Id;
1070       --  Called during second phase to map entities into their corresponding
1071       --  copies using Actual_Map. If the argument is not an entity, or is not
1072       --  in Actual_Map, then it is returned unchanged.
1073
1074       procedure Build_NCT_Hash_Tables;
1075       --  Builds hash tables (number of elements >= threshold value)
1076
1077       function Copy_Elist_With_Replacement
1078         (Old_Elist : Elist_Id) return Elist_Id;
1079       --  Called during second phase to copy element list doing replacements.
1080
1081       procedure Copy_Itype_With_Replacement (New_Itype : Entity_Id);
1082       --  Called during the second phase to process a copied Itype. The actual
1083       --  copy happened during the first phase (so that we could make the entry
1084       --  in the mapping), but we still have to deal with the descendents of
1085       --  the copied Itype and copy them where necessary.
1086
1087       function Copy_List_With_Replacement (Old_List : List_Id) return List_Id;
1088       --  Called during second phase to copy list doing replacements.
1089
1090       function Copy_Node_With_Replacement (Old_Node : Node_Id) return Node_Id;
1091       --  Called during second phase to copy node doing replacements
1092
1093       procedure Visit_Elist (E : Elist_Id);
1094       --  Called during first phase to visit all elements of an Elist
1095
1096       procedure Visit_Field (F : Union_Id; N : Node_Id);
1097       --  Visit a single field, recursing to call Visit_Node or Visit_List
1098       --  if the field is a syntactic descendent of the current node (i.e.
1099       --  its parent is Node N).
1100
1101       procedure Visit_Itype (Old_Itype : Entity_Id);
1102       --  Called during first phase to visit subsidiary fields of a defining
1103       --  Itype, and also create a copy and make an entry in the replacement
1104       --  map for the new copy.
1105
1106       procedure Visit_List (L : List_Id);
1107       --  Called during first phase to visit all elements of a List
1108
1109       procedure Visit_Node (N : Node_Or_Entity_Id);
1110       --  Called during first phase to visit a node and all its subtrees
1111
1112       -----------
1113       -- Assoc --
1114       -----------
1115
1116       function Assoc (N : Node_Or_Entity_Id) return Node_Id is
1117          E   : Elmt_Id;
1118          Ent : Entity_Id;
1119
1120       begin
1121          if not Has_Extension (N) or else No (Actual_Map) then
1122             return N;
1123
1124          elsif NCT_Hash_Tables_Used then
1125             Ent := NCT_Assoc.Get (Entity_Id (N));
1126
1127             if Present (Ent) then
1128                return Ent;
1129             else
1130                return N;
1131             end if;
1132
1133          --  No hash table used, do serial search
1134
1135          else
1136             E := First_Elmt (Actual_Map);
1137             while Present (E) loop
1138                if Node (E) = N then
1139                   return Node (Next_Elmt (E));
1140                else
1141                   E := Next_Elmt (Next_Elmt (E));
1142                end if;
1143             end loop;
1144          end if;
1145
1146          return N;
1147       end Assoc;
1148
1149       ---------------------------
1150       -- Build_NCT_Hash_Tables --
1151       ---------------------------
1152
1153       procedure Build_NCT_Hash_Tables is
1154          Elmt : Elmt_Id;
1155          Ent  : Entity_Id;
1156       begin
1157          if NCT_Hash_Table_Setup then
1158             NCT_Assoc.Reset;
1159             NCT_Itype_Assoc.Reset;
1160          end if;
1161
1162          Elmt := First_Elmt (Actual_Map);
1163          while Present (Elmt) loop
1164             Ent := Node (Elmt);
1165             Next_Elmt (Elmt);
1166             NCT_Assoc.Set (Ent, Node (Elmt));
1167             Next_Elmt (Elmt);
1168
1169             if Is_Type (Ent) then
1170                declare
1171                   Anode : constant Entity_Id :=
1172                             Associated_Node_For_Itype (Ent);
1173
1174                begin
1175                   if Present (Anode) then
1176                      NCT_Itype_Assoc.Set (Anode, Node (Elmt));
1177                   end if;
1178                end;
1179             end if;
1180          end loop;
1181
1182          NCT_Hash_Tables_Used := True;
1183          NCT_Hash_Table_Setup := True;
1184       end Build_NCT_Hash_Tables;
1185
1186       ---------------------------------
1187       -- Copy_Elist_With_Replacement --
1188       ---------------------------------
1189
1190       function Copy_Elist_With_Replacement
1191         (Old_Elist : Elist_Id) return Elist_Id
1192       is
1193          M         : Elmt_Id;
1194          New_Elist : Elist_Id;
1195
1196       begin
1197          if No (Old_Elist) then
1198             return No_Elist;
1199
1200          else
1201             New_Elist := New_Elmt_List;
1202             M := First_Elmt (Old_Elist);
1203
1204             while Present (M) loop
1205                Append_Elmt (Copy_Node_With_Replacement (Node (M)), New_Elist);
1206                Next_Elmt (M);
1207             end loop;
1208          end if;
1209
1210          return New_Elist;
1211       end Copy_Elist_With_Replacement;
1212
1213       ---------------------------------
1214       -- Copy_Itype_With_Replacement --
1215       ---------------------------------
1216
1217       --  This routine exactly parallels its phase one analog Visit_Itype,
1218       --  and like that routine, knows far too many semantic details about
1219       --  the descendents of Itypes and whether they need copying or not.
1220
1221       procedure Copy_Itype_With_Replacement (New_Itype : Entity_Id) is
1222       begin
1223          --  Translate Next_Entity, Scope and Etype fields, in case they
1224          --  reference entities that have been mapped into copies.
1225
1226          Set_Next_Entity (New_Itype, Assoc (Next_Entity (New_Itype)));
1227          Set_Etype       (New_Itype, Assoc (Etype       (New_Itype)));
1228
1229          if Present (New_Scope) then
1230             Set_Scope    (New_Itype, New_Scope);
1231          else
1232             Set_Scope    (New_Itype, Assoc (Scope       (New_Itype)));
1233          end if;
1234
1235          --  Copy referenced fields
1236
1237          if Is_Discrete_Type (New_Itype) then
1238             Set_Scalar_Range (New_Itype,
1239               Copy_Node_With_Replacement (Scalar_Range (New_Itype)));
1240
1241          elsif Has_Discriminants (Base_Type (New_Itype)) then
1242             Set_Discriminant_Constraint (New_Itype,
1243               Copy_Elist_With_Replacement
1244                 (Discriminant_Constraint (New_Itype)));
1245
1246          elsif Is_Array_Type (New_Itype) then
1247             if Present (First_Index (New_Itype)) then
1248                Set_First_Index (New_Itype,
1249                  First (Copy_List_With_Replacement
1250                          (List_Containing (First_Index (New_Itype)))));
1251             end if;
1252
1253             if Is_Packed (New_Itype) then
1254                Set_Packed_Array_Type (New_Itype,
1255                  Copy_Node_With_Replacement
1256                    (Packed_Array_Type (New_Itype)));
1257             end if;
1258          end if;
1259       end Copy_Itype_With_Replacement;
1260
1261       --------------------------------
1262       -- Copy_List_With_Replacement --
1263       --------------------------------
1264
1265       function Copy_List_With_Replacement
1266         (Old_List : List_Id) return List_Id
1267       is
1268          New_List : List_Id;
1269          E        : Node_Id;
1270
1271       begin
1272          if Old_List = No_List then
1273             return No_List;
1274
1275          else
1276             New_List := Empty_List;
1277             E := First (Old_List);
1278             while Present (E) loop
1279                Append (Copy_Node_With_Replacement (E), New_List);
1280                Next (E);
1281             end loop;
1282
1283             return New_List;
1284          end if;
1285       end Copy_List_With_Replacement;
1286
1287       --------------------------------
1288       -- Copy_Node_With_Replacement --
1289       --------------------------------
1290
1291       function Copy_Node_With_Replacement
1292         (Old_Node : Node_Id) return Node_Id
1293       is
1294          New_Node : Node_Id;
1295
1296          function Copy_Field_With_Replacement
1297            (Field : Union_Id) return Union_Id;
1298          --  Given Field, which is a field of Old_Node, return a copy of it
1299          --  if it is a syntactic field (i.e. its parent is Node), setting
1300          --  the parent of the copy to poit to New_Node. Otherwise returns
1301          --  the field (possibly mapped if it is an entity).
1302
1303          ---------------------------------
1304          -- Copy_Field_With_Replacement --
1305          ---------------------------------
1306
1307          function Copy_Field_With_Replacement
1308            (Field : Union_Id) return Union_Id
1309          is
1310          begin
1311             if Field = Union_Id (Empty) then
1312                return Field;
1313
1314             elsif Field in Node_Range then
1315                declare
1316                   Old_N : constant Node_Id := Node_Id (Field);
1317                   New_N : Node_Id;
1318
1319                begin
1320                   --  If syntactic field, as indicated by the parent pointer
1321                   --  being set, then copy the referenced node recursively.
1322
1323                   if Parent (Old_N) = Old_Node then
1324                      New_N := Copy_Node_With_Replacement (Old_N);
1325
1326                      if New_N /= Old_N then
1327                         Set_Parent (New_N, New_Node);
1328                      end if;
1329
1330                   --  For semantic fields, update possible entity reference
1331                   --  from the replacement map.
1332
1333                   else
1334                      New_N := Assoc (Old_N);
1335                   end if;
1336
1337                   return Union_Id (New_N);
1338                end;
1339
1340             elsif Field in List_Range then
1341                declare
1342                   Old_L : constant List_Id := List_Id (Field);
1343                   New_L : List_Id;
1344
1345                begin
1346                   --  If syntactic field, as indicated by the parent pointer,
1347                   --  then recursively copy the entire referenced list.
1348
1349                   if Parent (Old_L) = Old_Node then
1350                      New_L := Copy_List_With_Replacement (Old_L);
1351                      Set_Parent (New_L, New_Node);
1352
1353                   --  For semantic list, just returned unchanged
1354
1355                   else
1356                      New_L := Old_L;
1357                   end if;
1358
1359                   return Union_Id (New_L);
1360                end;
1361
1362             --  Anything other than a list or a node is returned unchanged
1363
1364             else
1365                return Field;
1366             end if;
1367          end Copy_Field_With_Replacement;
1368
1369       --  Start of processing for Copy_Node_With_Replacement
1370
1371       begin
1372          if Old_Node <= Empty_Or_Error then
1373             return Old_Node;
1374
1375          elsif Has_Extension (Old_Node) then
1376             return Assoc (Old_Node);
1377
1378          else
1379             New_Node := New_Copy (Old_Node);
1380
1381             --  If the node we are copying is the associated node of a
1382             --  previously copied Itype, then adjust the associated node
1383             --  of the copy of that Itype accordingly.
1384
1385             if Present (Actual_Map) then
1386                declare
1387                   E   : Elmt_Id;
1388                   Ent : Entity_Id;
1389
1390                begin
1391                   --  Case of hash table used
1392
1393                   if NCT_Hash_Tables_Used then
1394                      Ent := NCT_Itype_Assoc.Get (Old_Node);
1395
1396                      if Present (Ent) then
1397                         Set_Associated_Node_For_Itype (Ent, New_Node);
1398                      end if;
1399
1400                   --  Case of no hash table used
1401
1402                   else
1403                      E := First_Elmt (Actual_Map);
1404                      while Present (E) loop
1405                         if Is_Itype (Node (E))
1406                           and then
1407                             Old_Node = Associated_Node_For_Itype (Node (E))
1408                         then
1409                            Set_Associated_Node_For_Itype
1410                              (Node (Next_Elmt (E)), New_Node);
1411                         end if;
1412
1413                         E := Next_Elmt (Next_Elmt (E));
1414                      end loop;
1415                   end if;
1416                end;
1417             end if;
1418
1419             --  Recursively copy descendents
1420
1421             Set_Field1
1422               (New_Node, Copy_Field_With_Replacement (Field1 (New_Node)));
1423             Set_Field2
1424               (New_Node, Copy_Field_With_Replacement (Field2 (New_Node)));
1425             Set_Field3
1426               (New_Node, Copy_Field_With_Replacement (Field3 (New_Node)));
1427             Set_Field4
1428               (New_Node, Copy_Field_With_Replacement (Field4 (New_Node)));
1429             Set_Field5
1430               (New_Node, Copy_Field_With_Replacement (Field5 (New_Node)));
1431
1432             --  Adjust Sloc of new node if necessary
1433
1434             if New_Sloc /= No_Location then
1435                Set_Sloc (New_Node, New_Sloc);
1436
1437                --  If we adjust the Sloc, then we are essentially making
1438                --  a completely new node, so the Comes_From_Source flag
1439                --  should be reset to the proper default value.
1440
1441                Nodes.Table (New_Node).Comes_From_Source :=
1442                  Default_Node.Comes_From_Source;
1443             end if;
1444
1445             --  Reset First_Real_Statement for Handled_Sequence_Of_Statements.
1446             --  The replacement mechanism applies to entities, and is not used
1447             --  here. Eventually we may need a more general graph-copying
1448             --  routine. For now, do a sequential search to find desired node.
1449
1450             if Nkind (Old_Node) = N_Handled_Sequence_Of_Statements
1451               and then Present (First_Real_Statement (Old_Node))
1452             then
1453                declare
1454                   Old_F  : constant Node_Id := First_Real_Statement (Old_Node);
1455                   N1, N2 : Node_Id;
1456
1457                begin
1458                   N1 := First (Statements (Old_Node));
1459                   N2 := First (Statements (New_Node));
1460
1461                   while N1 /= Old_F loop
1462                      Next (N1);
1463                      Next (N2);
1464                   end loop;
1465
1466                   Set_First_Real_Statement (New_Node, N2);
1467                end;
1468             end if;
1469          end if;
1470
1471          --  All done, return copied node
1472
1473          return New_Node;
1474       end Copy_Node_With_Replacement;
1475
1476       -----------------
1477       -- Visit_Elist --
1478       -----------------
1479
1480       procedure Visit_Elist (E : Elist_Id) is
1481          Elmt : Elmt_Id;
1482
1483       begin
1484          if Present (E) then
1485             Elmt := First_Elmt (E);
1486
1487             while Elmt /= No_Elmt loop
1488                Visit_Node (Node (Elmt));
1489                Next_Elmt (Elmt);
1490             end loop;
1491          end if;
1492       end Visit_Elist;
1493
1494       -----------------
1495       -- Visit_Field --
1496       -----------------
1497
1498       procedure Visit_Field (F : Union_Id; N : Node_Id) is
1499       begin
1500          if F = Union_Id (Empty) then
1501             return;
1502
1503          elsif F in Node_Range then
1504
1505             --  Copy node if it is syntactic, i.e. its parent pointer is
1506             --  set to point to the field that referenced it (certain
1507             --  Itypes will also meet this criterion, which is fine, since
1508             --  these are clearly Itypes that do need to be copied, since
1509             --  we are copying their parent.)
1510
1511             if Parent (Node_Id (F)) = N then
1512                Visit_Node (Node_Id (F));
1513                return;
1514
1515             --  Another case, if we are pointing to an Itype, then we want
1516             --  to copy it if its associated node is somewhere in the tree
1517             --  being copied.
1518
1519             --  Note: the exclusion of self-referential copies is just an
1520             --  optimization, since the search of the already copied list
1521             --  would catch it, but it is a common case (Etype pointing
1522             --  to itself for an Itype that is a base type).
1523
1524             elsif Has_Extension (Node_Id (F))
1525               and then Is_Itype (Entity_Id (F))
1526               and then Node_Id (F) /= N
1527             then
1528                declare
1529                   P : Node_Id;
1530
1531                begin
1532                   P := Associated_Node_For_Itype (Node_Id (F));
1533                   while Present (P) loop
1534                      if P = Source then
1535                         Visit_Node (Node_Id (F));
1536                         return;
1537                      else
1538                         P := Parent (P);
1539                      end if;
1540                   end loop;
1541
1542                   --  An Itype whose parent is not being copied definitely
1543                   --  should NOT be copied, since it does not belong in any
1544                   --  sense to the copied subtree.
1545
1546                   return;
1547                end;
1548             end if;
1549
1550          elsif F in List_Range
1551            and then Parent (List_Id (F)) = N
1552          then
1553             Visit_List (List_Id (F));
1554             return;
1555          end if;
1556       end Visit_Field;
1557
1558       -----------------
1559       -- Visit_Itype --
1560       -----------------
1561
1562       --  Note: we are relying on far too much semantic knowledge in this
1563       --  routine, it really should just do a blind replacement of all
1564       --  fields, or at least a more blind replacement. For example, we
1565       --  do not deal with corresponding record types, and that works
1566       --  because we have no Itypes of task types, but nowhere is there
1567       --  a guarantee that this will always be the case. ???
1568
1569       procedure Visit_Itype (Old_Itype : Entity_Id) is
1570          New_Itype : Entity_Id;
1571          E         : Elmt_Id;
1572          Ent       : Entity_Id;
1573
1574       begin
1575          --  Itypes that describe the designated type of access to subprograms
1576          --  have the structure of subprogram declarations, with signatures,
1577          --  etc. Either we duplicate the signatures completely, or choose to
1578          --  share such itypes, which is fine because their elaboration will
1579          --  have no side effects. In any case, this is additional semantic
1580          --  information that seems awkward to have in atree.
1581
1582          if Ekind (Old_Itype) = E_Subprogram_Type then
1583             return;
1584          end if;
1585
1586          New_Itype := New_Copy (Old_Itype);
1587
1588          --  The new Itype has all the attributes of the old one, and
1589          --  we just copy the contents of the entity. However, the back-end
1590          --  needs different names for debugging purposes, so we create a
1591          --  new internal name by appending the letter 'c' (copy) to the
1592          --  name of the original.
1593
1594          Get_Name_String (Chars (Old_Itype));
1595          Add_Char_To_Name_Buffer ('c');
1596          Set_Chars (New_Itype, Name_Enter);
1597
1598          --  If our associated node is an entity that has already been copied,
1599          --  then set the associated node of the copy to point to the right
1600          --  copy. If we have copied an Itype that is itself the associated
1601          --  node of some previously copied Itype, then we set the right
1602          --  pointer in the other direction.
1603
1604          if Present (Actual_Map) then
1605
1606             --  Case of hash tables used
1607
1608             if NCT_Hash_Tables_Used then
1609
1610                Ent := NCT_Assoc.Get (Associated_Node_For_Itype (Old_Itype));
1611                if Present (Ent) then
1612                   Set_Associated_Node_For_Itype (New_Itype, Ent);
1613                end if;
1614
1615                Ent := NCT_Itype_Assoc.Get (Old_Itype);
1616                if Present (Ent) then
1617                   Set_Associated_Node_For_Itype (Ent, New_Itype);
1618                end if;
1619
1620             --  Case of hash tables not used
1621
1622             else
1623                E := First_Elmt (Actual_Map);
1624                while Present (E) loop
1625                   if Associated_Node_For_Itype (Old_Itype) = Node (E) then
1626                      Set_Associated_Node_For_Itype
1627                        (New_Itype, Node (Next_Elmt (E)));
1628                   end if;
1629
1630                   if Is_Type (Node (E))
1631                     and then
1632                       Old_Itype = Associated_Node_For_Itype (Node (E))
1633                   then
1634                      Set_Associated_Node_For_Itype
1635                        (Node (Next_Elmt (E)), New_Itype);
1636                   end if;
1637
1638                   E := Next_Elmt (Next_Elmt (E));
1639                end loop;
1640             end if;
1641          end if;
1642
1643          if Present (Freeze_Node (New_Itype)) then
1644             Set_Is_Frozen (New_Itype, False);
1645             Set_Freeze_Node (New_Itype, Empty);
1646          end if;
1647
1648          --  Add new association to map
1649
1650          if No (Actual_Map) then
1651             Actual_Map := New_Elmt_List;
1652          end if;
1653
1654          Append_Elmt (Old_Itype, Actual_Map);
1655          Append_Elmt (New_Itype, Actual_Map);
1656
1657          if NCT_Hash_Tables_Used then
1658             NCT_Assoc.Set (Old_Itype, New_Itype);
1659
1660          else
1661             NCT_Table_Entries := NCT_Table_Entries + 1;
1662
1663             if NCT_Table_Entries > NCT_Hash_Threshhold then
1664                Build_NCT_Hash_Tables;
1665             end if;
1666          end if;
1667
1668          --  If a record subtype is simply copied, the entity list will be
1669          --  shared. Thus cloned_Subtype must be set to indicate the sharing.
1670
1671          if Ekind (Old_Itype) = E_Record_Subtype
1672            or else Ekind (Old_Itype) = E_Class_Wide_Subtype
1673          then
1674             Set_Cloned_Subtype (New_Itype, Old_Itype);
1675          end if;
1676
1677          --  Visit descendents that eventually get copied
1678
1679          Visit_Field (Union_Id (Etype (Old_Itype)), Old_Itype);
1680
1681          if Is_Discrete_Type (Old_Itype) then
1682             Visit_Field (Union_Id (Scalar_Range (Old_Itype)), Old_Itype);
1683
1684          elsif Has_Discriminants (Base_Type (Old_Itype)) then
1685             --  ??? This should involve call to Visit_Field.
1686             Visit_Elist (Discriminant_Constraint (Old_Itype));
1687
1688          elsif Is_Array_Type (Old_Itype) then
1689             if Present (First_Index (Old_Itype)) then
1690                Visit_Field (Union_Id (List_Containing
1691                                 (First_Index (Old_Itype))),
1692                             Old_Itype);
1693             end if;
1694
1695             if Is_Packed (Old_Itype) then
1696                Visit_Field (Union_Id (Packed_Array_Type (Old_Itype)),
1697                             Old_Itype);
1698             end if;
1699          end if;
1700       end Visit_Itype;
1701
1702       ----------------
1703       -- Visit_List --
1704       ----------------
1705
1706       procedure Visit_List (L : List_Id) is
1707          N : Node_Id;
1708
1709       begin
1710          if L /= No_List then
1711             N := First (L);
1712
1713             while Present (N) loop
1714                Visit_Node (N);
1715                Next (N);
1716             end loop;
1717          end if;
1718       end Visit_List;
1719
1720       ----------------
1721       -- Visit_Node --
1722       ----------------
1723
1724       procedure Visit_Node (N : Node_Or_Entity_Id) is
1725
1726       --  Start of processing for Visit_Node
1727
1728       begin
1729          --  Handle case of an Itype, which must be copied
1730
1731          if Has_Extension (N)
1732            and then Is_Itype (N)
1733          then
1734             --  Nothing to do if already in the list. This can happen with an
1735             --  Itype entity that appears more than once in the tree.
1736             --  Note that we do not want to visit descendents in this case.
1737
1738             --  Test for already in list when hash table is used
1739
1740             if NCT_Hash_Tables_Used then
1741                if Present (NCT_Assoc.Get (Entity_Id (N))) then
1742                   return;
1743                end if;
1744
1745             --  Test for already in list when hash table not used
1746
1747             else
1748                declare
1749                   E : Elmt_Id;
1750
1751                begin
1752                   if Present (Actual_Map) then
1753                      E := First_Elmt (Actual_Map);
1754                      while Present (E) loop
1755                         if Node (E) = N then
1756                            return;
1757                         else
1758                            E := Next_Elmt (Next_Elmt (E));
1759                         end if;
1760                      end loop;
1761                   end if;
1762                end;
1763             end if;
1764
1765             Visit_Itype (N);
1766          end if;
1767
1768          --  Visit descendents
1769
1770          Visit_Field (Field1 (N), N);
1771          Visit_Field (Field2 (N), N);
1772          Visit_Field (Field3 (N), N);
1773          Visit_Field (Field4 (N), N);
1774          Visit_Field (Field5 (N), N);
1775       end Visit_Node;
1776
1777    --  Start of processing for New_Copy_Tree
1778
1779    begin
1780       Actual_Map := Map;
1781
1782       --  See if we should use hash table
1783
1784       if No (Actual_Map) then
1785          NCT_Hash_Tables_Used := False;
1786
1787       else
1788          declare
1789             Elmt : Elmt_Id;
1790
1791          begin
1792             NCT_Table_Entries := 0;
1793             Elmt := First_Elmt (Actual_Map);
1794             while Present (Elmt) loop
1795                NCT_Table_Entries := NCT_Table_Entries + 1;
1796                Next_Elmt (Elmt);
1797                Next_Elmt (Elmt);
1798             end loop;
1799
1800             if NCT_Table_Entries > NCT_Hash_Threshhold then
1801                Build_NCT_Hash_Tables;
1802             else
1803                NCT_Hash_Tables_Used := False;
1804             end if;
1805          end;
1806       end if;
1807
1808       --  Hash table set up if required, now start phase one by visiting
1809       --  top node (we will recursively visit the descendents).
1810
1811       Visit_Node (Source);
1812
1813       --  Now the second phase of the copy can start. First we process
1814       --  all the mapped entities, copying their descendents.
1815
1816       if Present (Actual_Map) then
1817          declare
1818             Elmt      : Elmt_Id;
1819             New_Itype : Entity_Id;
1820
1821          begin
1822             Elmt := First_Elmt (Actual_Map);
1823             while Present (Elmt) loop
1824                Next_Elmt (Elmt);
1825                New_Itype := Node (Elmt);
1826                Copy_Itype_With_Replacement (New_Itype);
1827                Next_Elmt (Elmt);
1828             end loop;
1829          end;
1830       end if;
1831
1832       --  Now we can copy the actual tree
1833
1834       return Copy_Node_With_Replacement (Source);
1835    end New_Copy_Tree;
1836
1837    ----------------
1838    -- New_Entity --
1839    ----------------
1840
1841    function New_Entity
1842      (New_Node_Kind : Node_Kind;
1843       New_Sloc      : Source_Ptr) return Entity_Id
1844    is
1845       Ent : Entity_Id;
1846
1847       procedure New_Entity_Debugging_Output;
1848       --  Debugging routine for debug flag N
1849       pragma Inline (New_Entity_Debugging_Output);
1850
1851       ---------------------------------
1852       -- New_Entity_Debugging_Output --
1853       ---------------------------------
1854
1855       procedure New_Entity_Debugging_Output is
1856       begin
1857          if Debug_Flag_N then
1858             Write_Str ("Allocate entity, Id = ");
1859             Write_Int (Int (Ent));
1860             Write_Str ("  ");
1861             Write_Location (New_Sloc);
1862             Write_Str ("  ");
1863             Write_Str (Node_Kind'Image (New_Node_Kind));
1864             Write_Eol;
1865          end if;
1866       end New_Entity_Debugging_Output;
1867
1868    --  Start of processing for New_Entity
1869
1870    begin
1871       pragma Assert (New_Node_Kind in N_Entity);
1872
1873       Ent := Allocate_Initialize_Node (Empty, With_Extension => True);
1874
1875       --  If this is a node with a real location and we are generating
1876       --  source nodes, then reset Current_Error_Node. This is useful
1877       --  if we bomb during parsing to get a error location for the bomb.
1878
1879       if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1880          Current_Error_Node := Ent;
1881       end if;
1882
1883       Nodes.Table (Ent).Nkind  := New_Node_Kind;
1884       Nodes.Table (Ent).Sloc   := New_Sloc;
1885       pragma Debug (New_Entity_Debugging_Output);
1886
1887       return Ent;
1888    end New_Entity;
1889
1890    --------------
1891    -- New_Node --
1892    --------------
1893
1894    function New_Node
1895      (New_Node_Kind : Node_Kind;
1896       New_Sloc      : Source_Ptr) return Node_Id
1897    is
1898       Nod : Node_Id;
1899
1900       procedure New_Node_Debugging_Output;
1901       --  Debugging routine for debug flag N
1902       pragma Inline (New_Node_Debugging_Output);
1903
1904       --------------------------
1905       -- New_Debugging_Output --
1906       --------------------------
1907
1908       procedure New_Node_Debugging_Output is
1909       begin
1910          if Debug_Flag_N then
1911             Write_Str ("Allocate node, Id = ");
1912             Write_Int (Int (Nod));
1913             Write_Str ("  ");
1914             Write_Location (New_Sloc);
1915             Write_Str ("  ");
1916             Write_Str (Node_Kind'Image (New_Node_Kind));
1917             Write_Eol;
1918          end if;
1919       end New_Node_Debugging_Output;
1920
1921    --  Start of processing for New_Node
1922
1923    begin
1924       pragma Assert (New_Node_Kind not in N_Entity);
1925       Nod := Allocate_Initialize_Node (Empty, With_Extension => False);
1926       Nodes.Table (Nod).Nkind := New_Node_Kind;
1927       Nodes.Table (Nod).Sloc  := New_Sloc;
1928       pragma Debug (New_Node_Debugging_Output);
1929
1930       --  If this is a node with a real location and we are generating
1931       --  source nodes, then reset Current_Error_Node. This is useful
1932       --  if we bomb during parsing to get a error location for the bomb.
1933
1934       if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1935          Current_Error_Node := Nod;
1936       end if;
1937
1938       return Nod;
1939    end New_Node;
1940
1941    -----------
1942    -- Nkind --
1943    -----------
1944
1945    function Nkind (N : Node_Id) return Node_Kind is
1946    begin
1947       return Nodes.Table (N).Nkind;
1948    end Nkind;
1949
1950    --------
1951    -- No --
1952    --------
1953
1954    function No (N : Node_Id) return Boolean is
1955    begin
1956       return N = Empty;
1957    end No;
1958
1959    -------------------
1960    -- Nodes_Address --
1961    -------------------
1962
1963    function Nodes_Address return System.Address is
1964    begin
1965       return Nodes.Table (First_Node_Id)'Address;
1966    end Nodes_Address;
1967
1968    ---------------
1969    -- Num_Nodes --
1970    ---------------
1971
1972    function Num_Nodes return Nat is
1973    begin
1974       return Node_Count;
1975    end Num_Nodes;
1976
1977    -------------------
1978    -- Original_Node --
1979    -------------------
1980
1981    function Original_Node (Node : Node_Id) return Node_Id is
1982    begin
1983       return Orig_Nodes.Table (Node);
1984    end Original_Node;
1985
1986    -----------------
1987    -- Paren_Count --
1988    -----------------
1989
1990    function Paren_Count (N : Node_Id) return Paren_Count_Type is
1991       C : Paren_Count_Type := 0;
1992
1993    begin
1994       pragma Assert (N in Nodes.First .. Nodes.Last);
1995
1996       if Nodes.Table (N).Pflag1 then
1997          C := C + 1;
1998       end if;
1999
2000       if Nodes.Table (N).Pflag2 then
2001          C := C + 2;
2002       end if;
2003
2004       return C;
2005    end Paren_Count;
2006
2007    ------------
2008    -- Parent --
2009    ------------
2010
2011    function Parent (N : Node_Id) return Node_Id is
2012    begin
2013       if Is_List_Member (N) then
2014          return Parent (List_Containing (N));
2015       else
2016          return Node_Id (Nodes.Table (N).Link);
2017       end if;
2018    end Parent;
2019
2020    -------------
2021    -- Present --
2022    -------------
2023
2024    function Present (N : Node_Id) return Boolean is
2025    begin
2026       return N /= Empty;
2027    end Present;
2028
2029    --------------------------------
2030    -- Preserve_Comes_From_Source --
2031    --------------------------------
2032
2033    procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is
2034    begin
2035       Nodes.Table (NewN).Comes_From_Source :=
2036         Nodes.Table (OldN).Comes_From_Source;
2037    end Preserve_Comes_From_Source;
2038
2039    -------------------
2040    -- Relocate_Node --
2041    -------------------
2042
2043    function Relocate_Node (Source : Node_Id) return Node_Id is
2044       New_Node : Node_Id;
2045
2046    begin
2047       if No (Source) then
2048          return Empty;
2049       end if;
2050
2051       New_Node := New_Copy (Source);
2052       Fix_Parents (Source, New_Node);
2053
2054       --  We now set the parent of the new node to be the same as the
2055       --  parent of the source. Almost always this parent will be
2056       --  replaced by a new value when the relocated node is reattached
2057       --  to the tree, but by doing it now, we ensure that this node is
2058       --  not even temporarily disconnected from the tree. Note that this
2059       --  does not happen free, because in the list case, the parent does
2060       --  not get set.
2061
2062       Set_Parent (New_Node, Parent (Source));
2063
2064       --  If the node being relocated was a rewriting of some original
2065       --  node, then the relocated node has the same original node.
2066
2067       if Orig_Nodes.Table (Source) /= Source then
2068          Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source);
2069       end if;
2070
2071       return New_Node;
2072    end Relocate_Node;
2073
2074    -------------
2075    -- Replace --
2076    -------------
2077
2078    procedure Replace (Old_Node, New_Node : Node_Id) is
2079       Old_Post : constant Boolean  := Nodes.Table (Old_Node).Error_Posted;
2080       Old_CFS  : constant Boolean  := Nodes.Table (Old_Node).Comes_From_Source;
2081
2082    begin
2083       pragma Assert
2084         (not Has_Extension (Old_Node)
2085            and not Has_Extension (New_Node)
2086            and not Nodes.Table (New_Node).In_List);
2087
2088       --  Do copy, preserving link and in list status and comes from source
2089
2090       Copy_Node (Source => New_Node, Destination => Old_Node);
2091       Nodes.Table (Old_Node).Comes_From_Source := Old_CFS;
2092       Nodes.Table (Old_Node).Error_Posted      := Old_Post;
2093
2094       --  Fix parents of substituted node, since it has changed identity
2095
2096       Fix_Parents (New_Node, Old_Node);
2097
2098       --  Since we are doing a replace, we assume that the original node
2099       --  is intended to become the new replaced node. The call would be
2100       --  to Rewrite if there were an intention to save the original node.
2101
2102       Orig_Nodes.Table (Old_Node) := Old_Node;
2103
2104       --  Finally delete the source, since it is now copied
2105
2106       Delete_Node (New_Node);
2107    end Replace;
2108
2109    -------------
2110    -- Rewrite --
2111    -------------
2112
2113    procedure Rewrite (Old_Node, New_Node : Node_Id) is
2114
2115       Old_Error_P : constant Boolean  := Nodes.Table (Old_Node).Error_Posted;
2116       --  This fields is always preserved in the new node
2117
2118       Old_Paren_Count     : Paren_Count_Type;
2119       Old_Must_Not_Freeze : Boolean;
2120       --  These fields are preserved in the new node only if the new node
2121       --  and the old node are both subexpression nodes.
2122
2123       --  Note: it is a violation of abstraction levels for Must_Not_Freeze
2124       --  to be referenced like this. ???
2125
2126       Sav_Node : Node_Id;
2127
2128    begin
2129       pragma Assert
2130         (not Has_Extension (Old_Node)
2131            and not Has_Extension (New_Node)
2132            and not Nodes.Table (New_Node).In_List);
2133
2134       if Nkind (Old_Node) in N_Subexpr then
2135          Old_Paren_Count     := Paren_Count (Old_Node);
2136          Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node);
2137       else
2138          Old_Paren_Count := 0;
2139          Old_Must_Not_Freeze := False;
2140       end if;
2141
2142       --  Allocate a new node, to be used to preserve the original contents
2143       --  of the Old_Node, for possible later retrival by Original_Node and
2144       --  make an entry in the Orig_Nodes table. This is only done if we have
2145       --  not already rewritten the node, as indicated by an Orig_Nodes entry
2146       --  that does not reference the Old_Node.
2147
2148       if Orig_Nodes.Table (Old_Node) = Old_Node then
2149          Sav_Node := New_Copy (Old_Node);
2150          Orig_Nodes.Table (Sav_Node) := Sav_Node;
2151          Orig_Nodes.Table (Old_Node) := Sav_Node;
2152       end if;
2153
2154       --  Copy substitute node into place, preserving old fields as required
2155
2156       Copy_Node (Source => New_Node, Destination => Old_Node);
2157       Nodes.Table (Old_Node).Error_Posted := Old_Error_P;
2158
2159       if Nkind (New_Node) in N_Subexpr then
2160          Set_Paren_Count     (Old_Node, Old_Paren_Count);
2161          Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze);
2162       end if;
2163
2164       Fix_Parents (New_Node, Old_Node);
2165    end Rewrite;
2166
2167    ------------------
2168    -- Set_Analyzed --
2169    ------------------
2170
2171    procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is
2172    begin
2173       Nodes.Table (N).Analyzed := Val;
2174    end Set_Analyzed;
2175
2176    ---------------------------
2177    -- Set_Comes_From_Source --
2178    ---------------------------
2179
2180    procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is
2181    begin
2182       pragma Assert (N in Nodes.First .. Nodes.Last);
2183       Nodes.Table (N).Comes_From_Source := Val;
2184    end Set_Comes_From_Source;
2185
2186    -----------------------------------
2187    -- Set_Comes_From_Source_Default --
2188    -----------------------------------
2189
2190    procedure Set_Comes_From_Source_Default (Default : Boolean) is
2191    begin
2192       Default_Node.Comes_From_Source := Default;
2193    end Set_Comes_From_Source_Default;
2194
2195    --------------------
2196    -- Set_Convention --
2197    --------------------
2198
2199    procedure Set_Convention  (E : Entity_Id; Val : Convention_Id) is
2200    begin
2201       pragma Assert (Nkind (E) in N_Entity);
2202       To_Flag_Word_Ptr
2203         (Union_Id_Ptr'
2204           (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention :=
2205                                                                         Val;
2206    end Set_Convention;
2207
2208    ---------------
2209    -- Set_Ekind --
2210    ---------------
2211
2212    procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is
2213    begin
2214       pragma Assert (Nkind (E) in N_Entity);
2215       Nodes.Table (E + 1).Nkind := E_To_N (Val);
2216    end Set_Ekind;
2217
2218    ----------------------
2219    -- Set_Error_Posted --
2220    ----------------------
2221
2222    procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is
2223    begin
2224       Nodes.Table (N).Error_Posted := Val;
2225    end Set_Error_Posted;
2226
2227    ---------------------
2228    -- Set_Paren_Count --
2229    ---------------------
2230
2231    procedure Set_Paren_Count (N : Node_Id; Val : Paren_Count_Type) is
2232    begin
2233       pragma Assert (Nkind (N) in N_Subexpr);
2234       Nodes.Table (N).Pflag1 := (Val mod 2 /= 0);
2235       Nodes.Table (N).Pflag2 := (Val >= 2);
2236    end Set_Paren_Count;
2237
2238    ----------------
2239    -- Set_Parent --
2240    ----------------
2241
2242    procedure Set_Parent (N : Node_Id; Val : Node_Id) is
2243    begin
2244       pragma Assert (not Nodes.Table (N).In_List);
2245       Nodes.Table (N).Link := Union_Id (Val);
2246    end Set_Parent;
2247
2248    --------------
2249    -- Set_Sloc --
2250    --------------
2251
2252    procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is
2253    begin
2254       Nodes.Table (N).Sloc := Val;
2255    end Set_Sloc;
2256
2257    ----------
2258    -- Sloc --
2259    ----------
2260
2261    function Sloc (N : Node_Id) return Source_Ptr is
2262    begin
2263       return Nodes.Table (N).Sloc;
2264    end Sloc;
2265
2266    -------------------
2267    -- Traverse_Func --
2268    -------------------
2269
2270    function Traverse_Func (Node : Node_Id) return Traverse_Result is
2271
2272       function Traverse_Field (Fld : Union_Id) return Traverse_Result;
2273       --  Fld is one of the fields of Node. If the field points to a
2274       --  syntactic node or list, then this node or list is traversed,
2275       --  and the result is the result of this traversal. Otherwise
2276       --  a value of True is returned with no processing.
2277
2278       --------------------
2279       -- Traverse_Field --
2280       --------------------
2281
2282       function Traverse_Field (Fld : Union_Id) return Traverse_Result is
2283       begin
2284          if Fld = Union_Id (Empty) then
2285             return OK;
2286
2287          --  Descendent is a node
2288
2289          elsif Fld in Node_Range then
2290
2291             --  Traverse descendent that is syntactic subtree node
2292
2293             if Parent (Node_Id (Fld)) = Node
2294               or else Original_Node (Parent (Node_Id (Fld))) = Node
2295             then
2296                return Traverse_Func (Node_Id (Fld));
2297
2298             --  Node that is not a syntactic subtree
2299
2300             else
2301                return OK;
2302             end if;
2303
2304          --  Descendent is a list
2305
2306          elsif Fld in List_Range then
2307
2308             --  Traverse descendent that is a syntactic subtree list
2309
2310             if Parent (List_Id (Fld)) = Node
2311               or else Original_Node (Parent (List_Id (Fld))) = Node
2312             then
2313                declare
2314                   Elmt : Node_Id := First (List_Id (Fld));
2315                begin
2316                   while Present (Elmt) loop
2317                      if Traverse_Func (Elmt) = Abandon then
2318                         return Abandon;
2319                      else
2320                         Next (Elmt);
2321                      end if;
2322                   end loop;
2323
2324                   return OK;
2325                end;
2326
2327             --  List that is not a syntactic subtree
2328
2329             else
2330                return OK;
2331             end if;
2332
2333          --  Field was not a node or a list
2334
2335          else
2336             return OK;
2337          end if;
2338       end Traverse_Field;
2339
2340    --  Start of processing for Traverse_Func
2341
2342    begin
2343       case Process (Node) is
2344          when Abandon =>
2345             return Abandon;
2346
2347          when Skip =>
2348             return OK;
2349
2350          when OK =>
2351             if Traverse_Field (Union_Id (Field1 (Node))) = Abandon
2352                  or else
2353                Traverse_Field (Union_Id (Field2 (Node))) = Abandon
2354                  or else
2355                Traverse_Field (Union_Id (Field3 (Node))) = Abandon
2356                  or else
2357                Traverse_Field (Union_Id (Field4 (Node))) = Abandon
2358                  or else
2359                Traverse_Field (Union_Id (Field5 (Node))) = Abandon
2360             then
2361                return Abandon;
2362
2363             else
2364                return OK;
2365             end if;
2366
2367          when OK_Orig =>
2368             declare
2369                Onode : constant Node_Id := Original_Node (Node);
2370
2371             begin
2372                if Traverse_Field (Union_Id (Field1 (Onode))) = Abandon
2373                     or else
2374                   Traverse_Field (Union_Id (Field2 (Onode))) = Abandon
2375                     or else
2376                   Traverse_Field (Union_Id (Field3 (Onode))) = Abandon
2377                     or else
2378                   Traverse_Field (Union_Id (Field4 (Onode))) = Abandon
2379                     or else
2380                   Traverse_Field (Union_Id (Field5 (Onode))) = Abandon
2381                then
2382                   return Abandon;
2383
2384                else
2385                   return OK_Orig;
2386                end if;
2387             end;
2388       end case;
2389    end Traverse_Func;
2390
2391    -------------------
2392    -- Traverse_Proc --
2393    -------------------
2394
2395    procedure Traverse_Proc (Node : Node_Id) is
2396       function Traverse is new Traverse_Func (Process);
2397       Discard : Traverse_Result;
2398       pragma Warnings (Off, Discard);
2399
2400    begin
2401       Discard := Traverse (Node);
2402    end Traverse_Proc;
2403
2404    ---------------
2405    -- Tree_Read --
2406    ---------------
2407
2408    procedure Tree_Read is
2409    begin
2410       Tree_Read_Int (Node_Count);
2411       Nodes.Tree_Read;
2412       Orig_Nodes.Tree_Read;
2413    end Tree_Read;
2414
2415    ----------------
2416    -- Tree_Write --
2417    ----------------
2418
2419    procedure Tree_Write is
2420    begin
2421       Tree_Write_Int (Node_Count);
2422       Nodes.Tree_Write;
2423       Orig_Nodes.Tree_Write;
2424    end Tree_Write;
2425
2426    ------------------------------
2427    -- Unchecked Access Package --
2428    ------------------------------
2429
2430    package body Unchecked_Access is
2431
2432       function Field1 (N : Node_Id) return Union_Id is
2433       begin
2434          pragma Assert (N in Nodes.First .. Nodes.Last);
2435          return Nodes.Table (N).Field1;
2436       end Field1;
2437
2438       function Field2 (N : Node_Id) return Union_Id is
2439       begin
2440          pragma Assert (N in Nodes.First .. Nodes.Last);
2441          return Nodes.Table (N).Field2;
2442       end Field2;
2443
2444       function Field3 (N : Node_Id) return Union_Id is
2445       begin
2446          pragma Assert (N in Nodes.First .. Nodes.Last);
2447          return Nodes.Table (N).Field3;
2448       end Field3;
2449
2450       function Field4 (N : Node_Id) return Union_Id is
2451       begin
2452          pragma Assert (N in Nodes.First .. Nodes.Last);
2453          return Nodes.Table (N).Field4;
2454       end Field4;
2455
2456       function Field5 (N : Node_Id) return Union_Id is
2457       begin
2458          pragma Assert (N in Nodes.First .. Nodes.Last);
2459          return Nodes.Table (N).Field5;
2460       end Field5;
2461
2462       function Field6 (N : Node_Id) return Union_Id is
2463       begin
2464          pragma Assert (Nkind (N) in N_Entity);
2465          return Nodes.Table (N + 1).Field6;
2466       end Field6;
2467
2468       function Field7 (N : Node_Id) return Union_Id is
2469       begin
2470          pragma Assert (Nkind (N) in N_Entity);
2471          return Nodes.Table (N + 1).Field7;
2472       end Field7;
2473
2474       function Field8 (N : Node_Id) return Union_Id is
2475       begin
2476          pragma Assert (Nkind (N) in N_Entity);
2477          return Nodes.Table (N + 1).Field8;
2478       end Field8;
2479
2480       function Field9 (N : Node_Id) return Union_Id is
2481       begin
2482          pragma Assert (Nkind (N) in N_Entity);
2483          return Nodes.Table (N + 1).Field9;
2484       end Field9;
2485
2486       function Field10 (N : Node_Id) return Union_Id is
2487       begin
2488          pragma Assert (Nkind (N) in N_Entity);
2489          return Nodes.Table (N + 1).Field10;
2490       end Field10;
2491
2492       function Field11 (N : Node_Id) return Union_Id is
2493       begin
2494          pragma Assert (Nkind (N) in N_Entity);
2495          return Nodes.Table (N + 1).Field11;
2496       end Field11;
2497
2498       function Field12 (N : Node_Id) return Union_Id is
2499       begin
2500          pragma Assert (Nkind (N) in N_Entity);
2501          return Nodes.Table (N + 1).Field12;
2502       end Field12;
2503
2504       function Field13 (N : Node_Id) return Union_Id is
2505       begin
2506          pragma Assert (Nkind (N) in N_Entity);
2507          return Nodes.Table (N + 2).Field6;
2508       end Field13;
2509
2510       function Field14 (N : Node_Id) return Union_Id is
2511       begin
2512          pragma Assert (Nkind (N) in N_Entity);
2513          return Nodes.Table (N + 2).Field7;
2514       end Field14;
2515
2516       function Field15 (N : Node_Id) return Union_Id is
2517       begin
2518          pragma Assert (Nkind (N) in N_Entity);
2519          return Nodes.Table (N + 2).Field8;
2520       end Field15;
2521
2522       function Field16 (N : Node_Id) return Union_Id is
2523       begin
2524          pragma Assert (Nkind (N) in N_Entity);
2525          return Nodes.Table (N + 2).Field9;
2526       end Field16;
2527
2528       function Field17 (N : Node_Id) return Union_Id is
2529       begin
2530          pragma Assert (Nkind (N) in N_Entity);
2531          return Nodes.Table (N + 2).Field10;
2532       end Field17;
2533
2534       function Field18 (N : Node_Id) return Union_Id is
2535       begin
2536          pragma Assert (Nkind (N) in N_Entity);
2537          return Nodes.Table (N + 2).Field11;
2538       end Field18;
2539
2540       function Field19 (N : Node_Id) return Union_Id is
2541       begin
2542          pragma Assert (Nkind (N) in N_Entity);
2543          return Nodes.Table (N + 3).Field6;
2544       end Field19;
2545
2546       function Field20 (N : Node_Id) return Union_Id is
2547       begin
2548          pragma Assert (Nkind (N) in N_Entity);
2549          return Nodes.Table (N + 3).Field7;
2550       end Field20;
2551
2552       function Field21 (N : Node_Id) return Union_Id is
2553       begin
2554          pragma Assert (Nkind (N) in N_Entity);
2555          return Nodes.Table (N + 3).Field8;
2556       end Field21;
2557
2558       function Field22 (N : Node_Id) return Union_Id is
2559       begin
2560          pragma Assert (Nkind (N) in N_Entity);
2561          return Nodes.Table (N + 3).Field9;
2562       end Field22;
2563
2564       function Field23 (N : Node_Id) return Union_Id is
2565       begin
2566          pragma Assert (Nkind (N) in N_Entity);
2567          return Nodes.Table (N + 3).Field10;
2568       end Field23;
2569
2570       function Node1 (N : Node_Id) return Node_Id is
2571       begin
2572          pragma Assert (N in Nodes.First .. Nodes.Last);
2573          return Node_Id (Nodes.Table (N).Field1);
2574       end Node1;
2575
2576       function Node2 (N : Node_Id) return Node_Id is
2577       begin
2578          pragma Assert (N in Nodes.First .. Nodes.Last);
2579          return Node_Id (Nodes.Table (N).Field2);
2580       end Node2;
2581
2582       function Node3 (N : Node_Id) return Node_Id is
2583       begin
2584          pragma Assert (N in Nodes.First .. Nodes.Last);
2585          return Node_Id (Nodes.Table (N).Field3);
2586       end Node3;
2587
2588       function Node4 (N : Node_Id) return Node_Id is
2589       begin
2590          pragma Assert (N in Nodes.First .. Nodes.Last);
2591          return Node_Id (Nodes.Table (N).Field4);
2592       end Node4;
2593
2594       function Node5 (N : Node_Id) return Node_Id is
2595       begin
2596          pragma Assert (N in Nodes.First .. Nodes.Last);
2597          return Node_Id (Nodes.Table (N).Field5);
2598       end Node5;
2599
2600       function Node6 (N : Node_Id) return Node_Id is
2601       begin
2602          pragma Assert (Nkind (N) in N_Entity);
2603          return Node_Id (Nodes.Table (N + 1).Field6);
2604       end Node6;
2605
2606       function Node7 (N : Node_Id) return Node_Id is
2607       begin
2608          pragma Assert (Nkind (N) in N_Entity);
2609          return Node_Id (Nodes.Table (N + 1).Field7);
2610       end Node7;
2611
2612       function Node8 (N : Node_Id) return Node_Id is
2613       begin
2614          pragma Assert (Nkind (N) in N_Entity);
2615          return Node_Id (Nodes.Table (N + 1).Field8);
2616       end Node8;
2617
2618       function Node9 (N : Node_Id) return Node_Id is
2619       begin
2620          pragma Assert (Nkind (N) in N_Entity);
2621          return Node_Id (Nodes.Table (N + 1).Field9);
2622       end Node9;
2623
2624       function Node10 (N : Node_Id) return Node_Id is
2625       begin
2626          pragma Assert (Nkind (N) in N_Entity);
2627          return Node_Id (Nodes.Table (N + 1).Field10);
2628       end Node10;
2629
2630       function Node11 (N : Node_Id) return Node_Id is
2631       begin
2632          pragma Assert (Nkind (N) in N_Entity);
2633          return Node_Id (Nodes.Table (N + 1).Field11);
2634       end Node11;
2635
2636       function Node12 (N : Node_Id) return Node_Id is
2637       begin
2638          pragma Assert (Nkind (N) in N_Entity);
2639          return Node_Id (Nodes.Table (N + 1).Field12);
2640       end Node12;
2641
2642       function Node13 (N : Node_Id) return Node_Id is
2643       begin
2644          pragma Assert (Nkind (N) in N_Entity);
2645          return Node_Id (Nodes.Table (N + 2).Field6);
2646       end Node13;
2647
2648       function Node14 (N : Node_Id) return Node_Id is
2649       begin
2650          pragma Assert (Nkind (N) in N_Entity);
2651          return Node_Id (Nodes.Table (N + 2).Field7);
2652       end Node14;
2653
2654       function Node15 (N : Node_Id) return Node_Id is
2655       begin
2656          pragma Assert (Nkind (N) in N_Entity);
2657          return Node_Id (Nodes.Table (N + 2).Field8);
2658       end Node15;
2659
2660       function Node16 (N : Node_Id) return Node_Id is
2661       begin
2662          pragma Assert (Nkind (N) in N_Entity);
2663          return Node_Id (Nodes.Table (N + 2).Field9);
2664       end Node16;
2665
2666       function Node17 (N : Node_Id) return Node_Id is
2667       begin
2668          pragma Assert (Nkind (N) in N_Entity);
2669          return Node_Id (Nodes.Table (N + 2).Field10);
2670       end Node17;
2671
2672       function Node18 (N : Node_Id) return Node_Id is
2673       begin
2674          pragma Assert (Nkind (N) in N_Entity);
2675          return Node_Id (Nodes.Table (N + 2).Field11);
2676       end Node18;
2677
2678       function Node19 (N : Node_Id) return Node_Id is
2679       begin
2680          pragma Assert (Nkind (N) in N_Entity);
2681          return Node_Id (Nodes.Table (N + 3).Field6);
2682       end Node19;
2683
2684       function Node20 (N : Node_Id) return Node_Id is
2685       begin
2686          pragma Assert (Nkind (N) in N_Entity);
2687          return Node_Id (Nodes.Table (N + 3).Field7);
2688       end Node20;
2689
2690       function Node21 (N : Node_Id) return Node_Id is
2691       begin
2692          pragma Assert (Nkind (N) in N_Entity);
2693          return Node_Id (Nodes.Table (N + 3).Field8);
2694       end Node21;
2695
2696       function Node22 (N : Node_Id) return Node_Id is
2697       begin
2698          pragma Assert (Nkind (N) in N_Entity);
2699          return Node_Id (Nodes.Table (N + 3).Field9);
2700       end Node22;
2701
2702       function Node23 (N : Node_Id) return Node_Id is
2703       begin
2704          pragma Assert (Nkind (N) in N_Entity);
2705          return Node_Id (Nodes.Table (N + 3).Field10);
2706       end Node23;
2707
2708       function List1 (N : Node_Id) return List_Id is
2709       begin
2710          pragma Assert (N in Nodes.First .. Nodes.Last);
2711          return List_Id (Nodes.Table (N).Field1);
2712       end List1;
2713
2714       function List2 (N : Node_Id) return List_Id is
2715       begin
2716          pragma Assert (N in Nodes.First .. Nodes.Last);
2717          return List_Id (Nodes.Table (N).Field2);
2718       end List2;
2719
2720       function List3 (N : Node_Id) return List_Id is
2721       begin
2722          pragma Assert (N in Nodes.First .. Nodes.Last);
2723          return List_Id (Nodes.Table (N).Field3);
2724       end List3;
2725
2726       function List4 (N : Node_Id) return List_Id is
2727       begin
2728          pragma Assert (N in Nodes.First .. Nodes.Last);
2729          return List_Id (Nodes.Table (N).Field4);
2730       end List4;
2731
2732       function List5 (N : Node_Id) return List_Id is
2733       begin
2734          pragma Assert (N in Nodes.First .. Nodes.Last);
2735          return List_Id (Nodes.Table (N).Field5);
2736       end List5;
2737
2738       function List10 (N : Node_Id) return List_Id is
2739       begin
2740          pragma Assert (Nkind (N) in N_Entity);
2741          return List_Id (Nodes.Table (N + 1).Field10);
2742       end List10;
2743
2744       function List14 (N : Node_Id) return List_Id is
2745       begin
2746          pragma Assert (Nkind (N) in N_Entity);
2747          return List_Id (Nodes.Table (N + 2).Field7);
2748       end List14;
2749
2750       function Elist2 (N : Node_Id) return Elist_Id is
2751       begin
2752          return Elist_Id (Nodes.Table (N).Field2);
2753       end Elist2;
2754
2755       function Elist3 (N : Node_Id) return Elist_Id is
2756       begin
2757          return Elist_Id (Nodes.Table (N).Field3);
2758       end Elist3;
2759
2760       function Elist4 (N : Node_Id) return Elist_Id is
2761       begin
2762          return Elist_Id (Nodes.Table (N).Field4);
2763       end Elist4;
2764
2765       function Elist8 (N : Node_Id) return Elist_Id is
2766       begin
2767          pragma Assert (Nkind (N) in N_Entity);
2768          return Elist_Id (Nodes.Table (N + 1).Field8);
2769       end Elist8;
2770
2771       function Elist13 (N : Node_Id) return Elist_Id is
2772       begin
2773          pragma Assert (Nkind (N) in N_Entity);
2774          return Elist_Id (Nodes.Table (N + 2).Field6);
2775       end Elist13;
2776
2777       function Elist15 (N : Node_Id) return Elist_Id is
2778       begin
2779          pragma Assert (Nkind (N) in N_Entity);
2780          return Elist_Id (Nodes.Table (N + 2).Field8);
2781       end Elist15;
2782
2783       function Elist16 (N : Node_Id) return Elist_Id is
2784       begin
2785          pragma Assert (Nkind (N) in N_Entity);
2786          return Elist_Id (Nodes.Table (N + 2).Field9);
2787       end Elist16;
2788
2789       function Elist18 (N : Node_Id) return Elist_Id is
2790       begin
2791          pragma Assert (Nkind (N) in N_Entity);
2792          return Elist_Id (Nodes.Table (N + 2).Field11);
2793       end Elist18;
2794
2795       function Elist21 (N : Node_Id) return Elist_Id is
2796       begin
2797          pragma Assert (Nkind (N) in N_Entity);
2798          return Elist_Id (Nodes.Table (N + 3).Field8);
2799       end Elist21;
2800
2801       function Elist23 (N : Node_Id) return Elist_Id is
2802       begin
2803          pragma Assert (Nkind (N) in N_Entity);
2804          return Elist_Id (Nodes.Table (N + 3).Field10);
2805       end Elist23;
2806
2807       function Name1 (N : Node_Id) return Name_Id is
2808       begin
2809          pragma Assert (N in Nodes.First .. Nodes.Last);
2810          return Name_Id (Nodes.Table (N).Field1);
2811       end Name1;
2812
2813       function Name2 (N : Node_Id) return Name_Id is
2814       begin
2815          pragma Assert (N in Nodes.First .. Nodes.Last);
2816          return Name_Id (Nodes.Table (N).Field2);
2817       end Name2;
2818
2819       function Str3 (N : Node_Id) return String_Id is
2820       begin
2821          pragma Assert (N in Nodes.First .. Nodes.Last);
2822          return String_Id (Nodes.Table (N).Field3);
2823       end Str3;
2824
2825       function Char_Code2 (N : Node_Id) return Char_Code is
2826       begin
2827          pragma Assert (N in Nodes.First .. Nodes.Last);
2828          return Char_Code (Nodes.Table (N).Field2 - Char_Code_Bias);
2829       end Char_Code2;
2830
2831       function Uint3 (N : Node_Id) return Uint is
2832          pragma Assert (N in Nodes.First .. Nodes.Last);
2833          U : constant Union_Id := Nodes.Table (N).Field3;
2834
2835       begin
2836          if U = 0 then
2837             return Uint_0;
2838          else
2839             return From_Union (U);
2840          end if;
2841       end Uint3;
2842
2843       function Uint4 (N : Node_Id) return Uint is
2844          pragma Assert (N in Nodes.First .. Nodes.Last);
2845          U : constant Union_Id := Nodes.Table (N).Field4;
2846
2847       begin
2848          if U = 0 then
2849             return Uint_0;
2850          else
2851             return From_Union (U);
2852          end if;
2853       end Uint4;
2854
2855       function Uint5 (N : Node_Id) return Uint is
2856          pragma Assert (N in Nodes.First .. Nodes.Last);
2857          U : constant Union_Id := Nodes.Table (N).Field5;
2858
2859       begin
2860          if U = 0 then
2861             return Uint_0;
2862          else
2863             return From_Union (U);
2864          end if;
2865       end Uint5;
2866
2867       function Uint8 (N : Node_Id) return Uint is
2868          pragma Assert (Nkind (N) in N_Entity);
2869          U : constant Union_Id := Nodes.Table (N + 1).Field8;
2870
2871       begin
2872          if U = 0 then
2873             return Uint_0;
2874          else
2875             return From_Union (U);
2876          end if;
2877       end Uint8;
2878
2879       function Uint9 (N : Node_Id) return Uint is
2880          pragma Assert (Nkind (N) in N_Entity);
2881          U : constant Union_Id := Nodes.Table (N + 1).Field9;
2882
2883       begin
2884          if U = 0 then
2885             return Uint_0;
2886          else
2887             return From_Union (U);
2888          end if;
2889       end Uint9;
2890
2891       function Uint11 (N : Node_Id) return Uint is
2892          pragma Assert (Nkind (N) in N_Entity);
2893          U : constant Union_Id := Nodes.Table (N + 1).Field11;
2894
2895       begin
2896          if U = 0 then
2897             return Uint_0;
2898          else
2899             return From_Union (U);
2900          end if;
2901       end Uint11;
2902
2903       function Uint10 (N : Node_Id) return Uint is
2904          pragma Assert (Nkind (N) in N_Entity);
2905          U : constant Union_Id := Nodes.Table (N + 1).Field10;
2906
2907       begin
2908          if U = 0 then
2909             return Uint_0;
2910          else
2911             return From_Union (U);
2912          end if;
2913       end Uint10;
2914
2915       function Uint12 (N : Node_Id) return Uint is
2916          pragma Assert (Nkind (N) in N_Entity);
2917          U : constant Union_Id := Nodes.Table (N + 1).Field12;
2918
2919       begin
2920          if U = 0 then
2921             return Uint_0;
2922          else
2923             return From_Union (U);
2924          end if;
2925       end Uint12;
2926
2927       function Uint13 (N : Node_Id) return Uint is
2928          pragma Assert (Nkind (N) in N_Entity);
2929          U : constant Union_Id := Nodes.Table (N + 2).Field6;
2930
2931       begin
2932          if U = 0 then
2933             return Uint_0;
2934          else
2935             return From_Union (U);
2936          end if;
2937       end Uint13;
2938
2939       function Uint14 (N : Node_Id) return Uint is
2940          pragma Assert (Nkind (N) in N_Entity);
2941          U : constant Union_Id := Nodes.Table (N + 2).Field7;
2942
2943       begin
2944          if U = 0 then
2945             return Uint_0;
2946          else
2947             return From_Union (U);
2948          end if;
2949       end Uint14;
2950
2951       function Uint15 (N : Node_Id) return Uint is
2952          pragma Assert (Nkind (N) in N_Entity);
2953          U : constant Union_Id := Nodes.Table (N + 2).Field8;
2954
2955       begin
2956          if U = 0 then
2957             return Uint_0;
2958          else
2959             return From_Union (U);
2960          end if;
2961       end Uint15;
2962
2963       function Uint16 (N : Node_Id) return Uint is
2964          pragma Assert (Nkind (N) in N_Entity);
2965          U : constant Union_Id := Nodes.Table (N + 2).Field9;
2966
2967       begin
2968          if U = 0 then
2969             return Uint_0;
2970          else
2971             return From_Union (U);
2972          end if;
2973       end Uint16;
2974
2975       function Uint17 (N : Node_Id) return Uint is
2976          pragma Assert (Nkind (N) in N_Entity);
2977          U : constant Union_Id := Nodes.Table (N + 2).Field10;
2978
2979       begin
2980          if U = 0 then
2981             return Uint_0;
2982          else
2983             return From_Union (U);
2984          end if;
2985       end Uint17;
2986
2987       function Uint22 (N : Node_Id) return Uint is
2988          pragma Assert (Nkind (N) in N_Entity);
2989          U : constant Union_Id := Nodes.Table (N + 3).Field9;
2990
2991       begin
2992          if U = 0 then
2993             return Uint_0;
2994          else
2995             return From_Union (U);
2996          end if;
2997       end Uint22;
2998
2999       function Ureal3 (N : Node_Id) return Ureal is
3000       begin
3001          pragma Assert (N in Nodes.First .. Nodes.Last);
3002          return From_Union (Nodes.Table (N).Field3);
3003       end Ureal3;
3004
3005       function Ureal18 (N : Node_Id) return Ureal is
3006       begin
3007          pragma Assert (Nkind (N) in N_Entity);
3008          return From_Union (Nodes.Table (N + 2).Field11);
3009       end Ureal18;
3010
3011       function Ureal21 (N : Node_Id) return Ureal is
3012       begin
3013          pragma Assert (Nkind (N) in N_Entity);
3014          return From_Union (Nodes.Table (N + 3).Field8);
3015       end Ureal21;
3016
3017       function Flag4 (N : Node_Id) return Boolean is
3018       begin
3019          pragma Assert (N in Nodes.First .. Nodes.Last);
3020          return Nodes.Table (N).Flag4;
3021       end Flag4;
3022
3023       function Flag5 (N : Node_Id) return Boolean is
3024       begin
3025          pragma Assert (N in Nodes.First .. Nodes.Last);
3026          return Nodes.Table (N).Flag5;
3027       end Flag5;
3028
3029       function Flag6 (N : Node_Id) return Boolean is
3030       begin
3031          pragma Assert (N in Nodes.First .. Nodes.Last);
3032          return Nodes.Table (N).Flag6;
3033       end Flag6;
3034
3035       function Flag7 (N : Node_Id) return Boolean is
3036       begin
3037          pragma Assert (N in Nodes.First .. Nodes.Last);
3038          return Nodes.Table (N).Flag7;
3039       end Flag7;
3040
3041       function Flag8 (N : Node_Id) return Boolean is
3042       begin
3043          pragma Assert (N in Nodes.First .. Nodes.Last);
3044          return Nodes.Table (N).Flag8;
3045       end Flag8;
3046
3047       function Flag9 (N : Node_Id) return Boolean is
3048       begin
3049          pragma Assert (N in Nodes.First .. Nodes.Last);
3050          return Nodes.Table (N).Flag9;
3051       end Flag9;
3052
3053       function Flag10 (N : Node_Id) return Boolean is
3054       begin
3055          pragma Assert (N in Nodes.First .. Nodes.Last);
3056          return Nodes.Table (N).Flag10;
3057       end Flag10;
3058
3059       function Flag11 (N : Node_Id) return Boolean is
3060       begin
3061          pragma Assert (N in Nodes.First .. Nodes.Last);
3062          return Nodes.Table (N).Flag11;
3063       end Flag11;
3064
3065       function Flag12 (N : Node_Id) return Boolean is
3066       begin
3067          pragma Assert (N in Nodes.First .. Nodes.Last);
3068          return Nodes.Table (N).Flag12;
3069       end Flag12;
3070
3071       function Flag13 (N : Node_Id) return Boolean is
3072       begin
3073          pragma Assert (N in Nodes.First .. Nodes.Last);
3074          return Nodes.Table (N).Flag13;
3075       end Flag13;
3076
3077       function Flag14 (N : Node_Id) return Boolean is
3078       begin
3079          pragma Assert (N in Nodes.First .. Nodes.Last);
3080          return Nodes.Table (N).Flag14;
3081       end Flag14;
3082
3083       function Flag15 (N : Node_Id) return Boolean is
3084       begin
3085          pragma Assert (N in Nodes.First .. Nodes.Last);
3086          return Nodes.Table (N).Flag15;
3087       end Flag15;
3088
3089       function Flag16 (N : Node_Id) return Boolean is
3090       begin
3091          pragma Assert (N in Nodes.First .. Nodes.Last);
3092          return Nodes.Table (N).Flag16;
3093       end Flag16;
3094
3095       function Flag17 (N : Node_Id) return Boolean is
3096       begin
3097          pragma Assert (N in Nodes.First .. Nodes.Last);
3098          return Nodes.Table (N).Flag17;
3099       end Flag17;
3100
3101       function Flag18 (N : Node_Id) return Boolean is
3102       begin
3103          pragma Assert (N in Nodes.First .. Nodes.Last);
3104          return Nodes.Table (N).Flag18;
3105       end Flag18;
3106
3107       function Flag19 (N : Node_Id) return Boolean is
3108       begin
3109          pragma Assert (Nkind (N) in N_Entity);
3110          return Nodes.Table (N + 1).In_List;
3111       end Flag19;
3112
3113       function Flag20 (N : Node_Id) return Boolean is
3114       begin
3115          pragma Assert (Nkind (N) in N_Entity);
3116          return Nodes.Table (N + 1).Unused_1;
3117       end Flag20;
3118
3119       function Flag21 (N : Node_Id) return Boolean is
3120       begin
3121          pragma Assert (Nkind (N) in N_Entity);
3122          return Nodes.Table (N + 1).Rewrite_Ins;
3123       end Flag21;
3124
3125       function Flag22 (N : Node_Id) return Boolean is
3126       begin
3127          pragma Assert (Nkind (N) in N_Entity);
3128          return Nodes.Table (N + 1).Analyzed;
3129       end Flag22;
3130
3131       function Flag23 (N : Node_Id) return Boolean is
3132       begin
3133          pragma Assert (Nkind (N) in N_Entity);
3134          return Nodes.Table (N + 1).Comes_From_Source;
3135       end Flag23;
3136
3137       function Flag24 (N : Node_Id) return Boolean is
3138       begin
3139          pragma Assert (Nkind (N) in N_Entity);
3140          return Nodes.Table (N + 1).Error_Posted;
3141       end Flag24;
3142
3143       function Flag25 (N : Node_Id) return Boolean is
3144       begin
3145          pragma Assert (Nkind (N) in N_Entity);
3146          return Nodes.Table (N + 1).Flag4;
3147       end Flag25;
3148
3149       function Flag26 (N : Node_Id) return Boolean is
3150       begin
3151          pragma Assert (Nkind (N) in N_Entity);
3152          return Nodes.Table (N + 1).Flag5;
3153       end Flag26;
3154
3155       function Flag27 (N : Node_Id) return Boolean is
3156       begin
3157          pragma Assert (Nkind (N) in N_Entity);
3158          return Nodes.Table (N + 1).Flag6;
3159       end Flag27;
3160
3161       function Flag28 (N : Node_Id) return Boolean is
3162       begin
3163          pragma Assert (Nkind (N) in N_Entity);
3164          return Nodes.Table (N + 1).Flag7;
3165       end Flag28;
3166
3167       function Flag29 (N : Node_Id) return Boolean is
3168       begin
3169          pragma Assert (Nkind (N) in N_Entity);
3170          return Nodes.Table (N + 1).Flag8;
3171       end Flag29;
3172
3173       function Flag30 (N : Node_Id) return Boolean is
3174       begin
3175          pragma Assert (Nkind (N) in N_Entity);
3176          return Nodes.Table (N + 1).Flag9;
3177       end Flag30;
3178
3179       function Flag31 (N : Node_Id) return Boolean is
3180       begin
3181          pragma Assert (Nkind (N) in N_Entity);
3182          return Nodes.Table (N + 1).Flag10;
3183       end Flag31;
3184
3185       function Flag32 (N : Node_Id) return Boolean is
3186       begin
3187          pragma Assert (Nkind (N) in N_Entity);
3188          return Nodes.Table (N + 1).Flag11;
3189       end Flag32;
3190
3191       function Flag33 (N : Node_Id) return Boolean is
3192       begin
3193          pragma Assert (Nkind (N) in N_Entity);
3194          return Nodes.Table (N + 1).Flag12;
3195       end Flag33;
3196
3197       function Flag34 (N : Node_Id) return Boolean is
3198       begin
3199          pragma Assert (Nkind (N) in N_Entity);
3200          return Nodes.Table (N + 1).Flag13;
3201       end Flag34;
3202
3203       function Flag35 (N : Node_Id) return Boolean is
3204       begin
3205          pragma Assert (Nkind (N) in N_Entity);
3206          return Nodes.Table (N + 1).Flag14;
3207       end Flag35;
3208
3209       function Flag36 (N : Node_Id) return Boolean is
3210       begin
3211          pragma Assert (Nkind (N) in N_Entity);
3212          return Nodes.Table (N + 1).Flag15;
3213       end Flag36;
3214
3215       function Flag37 (N : Node_Id) return Boolean is
3216       begin
3217          pragma Assert (Nkind (N) in N_Entity);
3218          return Nodes.Table (N + 1).Flag16;
3219       end Flag37;
3220
3221       function Flag38 (N : Node_Id) return Boolean is
3222       begin
3223          pragma Assert (Nkind (N) in N_Entity);
3224          return Nodes.Table (N + 1).Flag17;
3225       end Flag38;
3226
3227       function Flag39 (N : Node_Id) return Boolean is
3228       begin
3229          pragma Assert (Nkind (N) in N_Entity);
3230          return Nodes.Table (N + 1).Flag18;
3231       end Flag39;
3232
3233       function Flag40 (N : Node_Id) return Boolean is
3234       begin
3235          pragma Assert (Nkind (N) in N_Entity);
3236          return Nodes.Table (N + 2).In_List;
3237       end Flag40;
3238
3239       function Flag41 (N : Node_Id) return Boolean is
3240       begin
3241          pragma Assert (Nkind (N) in N_Entity);
3242          return Nodes.Table (N + 2).Unused_1;
3243       end Flag41;
3244
3245       function Flag42 (N : Node_Id) return Boolean is
3246       begin
3247          pragma Assert (Nkind (N) in N_Entity);
3248          return Nodes.Table (N + 2).Rewrite_Ins;
3249       end Flag42;
3250
3251       function Flag43 (N : Node_Id) return Boolean is
3252       begin
3253          pragma Assert (Nkind (N) in N_Entity);
3254          return Nodes.Table (N + 2).Analyzed;
3255       end Flag43;
3256
3257       function Flag44 (N : Node_Id) return Boolean is
3258       begin
3259          pragma Assert (Nkind (N) in N_Entity);
3260          return Nodes.Table (N + 2).Comes_From_Source;
3261       end Flag44;
3262
3263       function Flag45 (N : Node_Id) return Boolean is
3264       begin
3265          pragma Assert (Nkind (N) in N_Entity);
3266          return Nodes.Table (N + 2).Error_Posted;
3267       end Flag45;
3268
3269       function Flag46 (N : Node_Id) return Boolean is
3270       begin
3271          pragma Assert (Nkind (N) in N_Entity);
3272          return Nodes.Table (N + 2).Flag4;
3273       end Flag46;
3274
3275       function Flag47 (N : Node_Id) return Boolean is
3276       begin
3277          pragma Assert (Nkind (N) in N_Entity);
3278          return Nodes.Table (N + 2).Flag5;
3279       end Flag47;
3280
3281       function Flag48 (N : Node_Id) return Boolean is
3282       begin
3283          pragma Assert (Nkind (N) in N_Entity);
3284          return Nodes.Table (N + 2).Flag6;
3285       end Flag48;
3286
3287       function Flag49 (N : Node_Id) return Boolean is
3288       begin
3289          pragma Assert (Nkind (N) in N_Entity);
3290          return Nodes.Table (N + 2).Flag7;
3291       end Flag49;
3292
3293       function Flag50 (N : Node_Id) return Boolean is
3294       begin
3295          pragma Assert (Nkind (N) in N_Entity);
3296          return Nodes.Table (N + 2).Flag8;
3297       end Flag50;
3298
3299       function Flag51 (N : Node_Id) return Boolean is
3300       begin
3301          pragma Assert (Nkind (N) in N_Entity);
3302          return Nodes.Table (N + 2).Flag9;
3303       end Flag51;
3304
3305       function Flag52 (N : Node_Id) return Boolean is
3306       begin
3307          pragma Assert (Nkind (N) in N_Entity);
3308          return Nodes.Table (N + 2).Flag10;
3309       end Flag52;
3310
3311       function Flag53 (N : Node_Id) return Boolean is
3312       begin
3313          pragma Assert (Nkind (N) in N_Entity);
3314          return Nodes.Table (N + 2).Flag11;
3315       end Flag53;
3316
3317       function Flag54 (N : Node_Id) return Boolean is
3318       begin
3319          pragma Assert (Nkind (N) in N_Entity);
3320          return Nodes.Table (N + 2).Flag12;
3321       end Flag54;
3322
3323       function Flag55 (N : Node_Id) return Boolean is
3324       begin
3325          pragma Assert (Nkind (N) in N_Entity);
3326          return Nodes.Table (N + 2).Flag13;
3327       end Flag55;
3328
3329       function Flag56 (N : Node_Id) return Boolean is
3330       begin
3331          pragma Assert (Nkind (N) in N_Entity);
3332          return Nodes.Table (N + 2).Flag14;
3333       end Flag56;
3334
3335       function Flag57 (N : Node_Id) return Boolean is
3336       begin
3337          pragma Assert (Nkind (N) in N_Entity);
3338          return Nodes.Table (N + 2).Flag15;
3339       end Flag57;
3340
3341       function Flag58 (N : Node_Id) return Boolean is
3342       begin
3343          pragma Assert (Nkind (N) in N_Entity);
3344          return Nodes.Table (N + 2).Flag16;
3345       end Flag58;
3346
3347       function Flag59 (N : Node_Id) return Boolean is
3348       begin
3349          pragma Assert (Nkind (N) in N_Entity);
3350          return Nodes.Table (N + 2).Flag17;
3351       end Flag59;
3352
3353       function Flag60 (N : Node_Id) return Boolean is
3354       begin
3355          pragma Assert (Nkind (N) in N_Entity);
3356          return Nodes.Table (N + 2).Flag18;
3357       end Flag60;
3358
3359       function Flag61 (N : Node_Id) return Boolean is
3360       begin
3361          pragma Assert (Nkind (N) in N_Entity);
3362          return Nodes.Table (N + 1).Pflag1;
3363       end Flag61;
3364
3365       function Flag62 (N : Node_Id) return Boolean is
3366       begin
3367          pragma Assert (Nkind (N) in N_Entity);
3368          return Nodes.Table (N + 1).Pflag2;
3369       end Flag62;
3370
3371       function Flag63 (N : Node_Id) return Boolean is
3372       begin
3373          pragma Assert (Nkind (N) in N_Entity);
3374          return Nodes.Table (N + 2).Pflag1;
3375       end Flag63;
3376
3377       function Flag64 (N : Node_Id) return Boolean is
3378       begin
3379          pragma Assert (Nkind (N) in N_Entity);
3380          return Nodes.Table (N + 2).Pflag2;
3381       end Flag64;
3382
3383       function Flag65 (N : Node_Id) return Boolean is
3384       begin
3385          pragma Assert (Nkind (N) in N_Entity);
3386          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
3387       end Flag65;
3388
3389       function Flag66 (N : Node_Id) return Boolean is
3390       begin
3391          pragma Assert (Nkind (N) in N_Entity);
3392          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
3393       end Flag66;
3394
3395       function Flag67 (N : Node_Id) return Boolean is
3396       begin
3397          pragma Assert (Nkind (N) in N_Entity);
3398          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
3399       end Flag67;
3400
3401       function Flag68 (N : Node_Id) return Boolean is
3402       begin
3403          pragma Assert (Nkind (N) in N_Entity);
3404          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
3405       end Flag68;
3406
3407       function Flag69 (N : Node_Id) return Boolean is
3408       begin
3409          pragma Assert (Nkind (N) in N_Entity);
3410          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
3411       end Flag69;
3412
3413       function Flag70 (N : Node_Id) return Boolean is
3414       begin
3415          pragma Assert (Nkind (N) in N_Entity);
3416          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
3417       end Flag70;
3418
3419       function Flag71 (N : Node_Id) return Boolean is
3420       begin
3421          pragma Assert (Nkind (N) in N_Entity);
3422          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
3423       end Flag71;
3424
3425       function Flag72 (N : Node_Id) return Boolean is
3426       begin
3427          pragma Assert (Nkind (N) in N_Entity);
3428          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
3429       end Flag72;
3430
3431       function Flag73 (N : Node_Id) return Boolean is
3432       begin
3433          pragma Assert (Nkind (N) in N_Entity);
3434          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
3435       end Flag73;
3436
3437       function Flag74 (N : Node_Id) return Boolean is
3438       begin
3439          pragma Assert (Nkind (N) in N_Entity);
3440          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
3441       end Flag74;
3442
3443       function Flag75 (N : Node_Id) return Boolean is
3444       begin
3445          pragma Assert (Nkind (N) in N_Entity);
3446          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
3447       end Flag75;
3448
3449       function Flag76 (N : Node_Id) return Boolean is
3450       begin
3451          pragma Assert (Nkind (N) in N_Entity);
3452          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
3453       end Flag76;
3454
3455       function Flag77 (N : Node_Id) return Boolean is
3456       begin
3457          pragma Assert (Nkind (N) in N_Entity);
3458          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
3459       end Flag77;
3460
3461       function Flag78 (N : Node_Id) return Boolean is
3462       begin
3463          pragma Assert (Nkind (N) in N_Entity);
3464          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
3465       end Flag78;
3466
3467       function Flag79 (N : Node_Id) return Boolean is
3468       begin
3469          pragma Assert (Nkind (N) in N_Entity);
3470          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
3471       end Flag79;
3472
3473       function Flag80 (N : Node_Id) return Boolean is
3474       begin
3475          pragma Assert (Nkind (N) in N_Entity);
3476          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
3477       end Flag80;
3478
3479       function Flag81 (N : Node_Id) return Boolean is
3480       begin
3481          pragma Assert (Nkind (N) in N_Entity);
3482          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
3483       end Flag81;
3484
3485       function Flag82 (N : Node_Id) return Boolean is
3486       begin
3487          pragma Assert (Nkind (N) in N_Entity);
3488          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
3489       end Flag82;
3490
3491       function Flag83 (N : Node_Id) return Boolean is
3492       begin
3493          pragma Assert (Nkind (N) in N_Entity);
3494          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
3495       end Flag83;
3496
3497       function Flag84 (N : Node_Id) return Boolean is
3498       begin
3499          pragma Assert (Nkind (N) in N_Entity);
3500          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
3501       end Flag84;
3502
3503       function Flag85 (N : Node_Id) return Boolean is
3504       begin
3505          pragma Assert (Nkind (N) in N_Entity);
3506          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
3507       end Flag85;
3508
3509       function Flag86 (N : Node_Id) return Boolean is
3510       begin
3511          pragma Assert (Nkind (N) in N_Entity);
3512          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
3513       end Flag86;
3514
3515       function Flag87 (N : Node_Id) return Boolean is
3516       begin
3517          pragma Assert (Nkind (N) in N_Entity);
3518          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
3519       end Flag87;
3520
3521       function Flag88 (N : Node_Id) return Boolean is
3522       begin
3523          pragma Assert (Nkind (N) in N_Entity);
3524          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
3525       end Flag88;
3526
3527       function Flag89 (N : Node_Id) return Boolean is
3528       begin
3529          pragma Assert (Nkind (N) in N_Entity);
3530          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
3531       end Flag89;
3532
3533       function Flag90 (N : Node_Id) return Boolean is
3534       begin
3535          pragma Assert (Nkind (N) in N_Entity);
3536          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
3537       end Flag90;
3538
3539       function Flag91 (N : Node_Id) return Boolean is
3540       begin
3541          pragma Assert (Nkind (N) in N_Entity);
3542          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
3543       end Flag91;
3544
3545       function Flag92 (N : Node_Id) return Boolean is
3546       begin
3547          pragma Assert (Nkind (N) in N_Entity);
3548          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
3549       end Flag92;
3550
3551       function Flag93 (N : Node_Id) return Boolean is
3552       begin
3553          pragma Assert (Nkind (N) in N_Entity);
3554          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
3555       end Flag93;
3556
3557       function Flag94 (N : Node_Id) return Boolean is
3558       begin
3559          pragma Assert (Nkind (N) in N_Entity);
3560          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
3561       end Flag94;
3562
3563       function Flag95 (N : Node_Id) return Boolean is
3564       begin
3565          pragma Assert (Nkind (N) in N_Entity);
3566          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
3567       end Flag95;
3568
3569       function Flag96 (N : Node_Id) return Boolean is
3570       begin
3571          pragma Assert (Nkind (N) in N_Entity);
3572          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
3573       end Flag96;
3574
3575       function Flag97 (N : Node_Id) return Boolean is
3576       begin
3577          pragma Assert (Nkind (N) in N_Entity);
3578          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
3579       end Flag97;
3580
3581       function Flag98 (N : Node_Id) return Boolean is
3582       begin
3583          pragma Assert (Nkind (N) in N_Entity);
3584          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
3585       end Flag98;
3586
3587       function Flag99 (N : Node_Id) return Boolean is
3588       begin
3589          pragma Assert (Nkind (N) in N_Entity);
3590          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
3591       end Flag99;
3592
3593       function Flag100 (N : Node_Id) return Boolean is
3594       begin
3595          pragma Assert (Nkind (N) in N_Entity);
3596          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
3597       end Flag100;
3598
3599       function Flag101 (N : Node_Id) return Boolean is
3600       begin
3601          pragma Assert (Nkind (N) in N_Entity);
3602          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
3603       end Flag101;
3604
3605       function Flag102 (N : Node_Id) return Boolean is
3606       begin
3607          pragma Assert (Nkind (N) in N_Entity);
3608          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
3609       end Flag102;
3610
3611       function Flag103 (N : Node_Id) return Boolean is
3612       begin
3613          pragma Assert (Nkind (N) in N_Entity);
3614          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
3615       end Flag103;
3616
3617       function Flag104 (N : Node_Id) return Boolean is
3618       begin
3619          pragma Assert (Nkind (N) in N_Entity);
3620          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
3621       end Flag104;
3622
3623       function Flag105 (N : Node_Id) return Boolean is
3624       begin
3625          pragma Assert (Nkind (N) in N_Entity);
3626          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
3627       end Flag105;
3628
3629       function Flag106 (N : Node_Id) return Boolean is
3630       begin
3631          pragma Assert (Nkind (N) in N_Entity);
3632          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
3633       end Flag106;
3634
3635       function Flag107 (N : Node_Id) return Boolean is
3636       begin
3637          pragma Assert (Nkind (N) in N_Entity);
3638          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
3639       end Flag107;
3640
3641       function Flag108 (N : Node_Id) return Boolean is
3642       begin
3643          pragma Assert (Nkind (N) in N_Entity);
3644          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
3645       end Flag108;
3646
3647       function Flag109 (N : Node_Id) return Boolean is
3648       begin
3649          pragma Assert (Nkind (N) in N_Entity);
3650          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
3651       end Flag109;
3652
3653       function Flag110 (N : Node_Id) return Boolean is
3654       begin
3655          pragma Assert (Nkind (N) in N_Entity);
3656          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
3657       end Flag110;
3658
3659       function Flag111 (N : Node_Id) return Boolean is
3660       begin
3661          pragma Assert (Nkind (N) in N_Entity);
3662          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
3663       end Flag111;
3664
3665       function Flag112 (N : Node_Id) return Boolean is
3666       begin
3667          pragma Assert (Nkind (N) in N_Entity);
3668          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
3669       end Flag112;
3670
3671       function Flag113 (N : Node_Id) return Boolean is
3672       begin
3673          pragma Assert (Nkind (N) in N_Entity);
3674          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
3675       end Flag113;
3676
3677       function Flag114 (N : Node_Id) return Boolean is
3678       begin
3679          pragma Assert (Nkind (N) in N_Entity);
3680          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
3681       end Flag114;
3682
3683       function Flag115 (N : Node_Id) return Boolean is
3684       begin
3685          pragma Assert (Nkind (N) in N_Entity);
3686          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
3687       end Flag115;
3688
3689       function Flag116 (N : Node_Id) return Boolean is
3690       begin
3691          pragma Assert (Nkind (N) in N_Entity);
3692          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
3693       end Flag116;
3694
3695       function Flag117 (N : Node_Id) return Boolean is
3696       begin
3697          pragma Assert (Nkind (N) in N_Entity);
3698          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
3699       end Flag117;
3700
3701       function Flag118 (N : Node_Id) return Boolean is
3702       begin
3703          pragma Assert (Nkind (N) in N_Entity);
3704          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
3705       end Flag118;
3706
3707       function Flag119 (N : Node_Id) return Boolean is
3708       begin
3709          pragma Assert (Nkind (N) in N_Entity);
3710          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
3711       end Flag119;
3712
3713       function Flag120 (N : Node_Id) return Boolean is
3714       begin
3715          pragma Assert (Nkind (N) in N_Entity);
3716          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
3717       end Flag120;
3718
3719       function Flag121 (N : Node_Id) return Boolean is
3720       begin
3721          pragma Assert (Nkind (N) in N_Entity);
3722          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
3723       end Flag121;
3724
3725       function Flag122 (N : Node_Id) return Boolean is
3726       begin
3727          pragma Assert (Nkind (N) in N_Entity);
3728          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
3729       end Flag122;
3730
3731       function Flag123 (N : Node_Id) return Boolean is
3732       begin
3733          pragma Assert (Nkind (N) in N_Entity);
3734          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
3735       end Flag123;
3736
3737       function Flag124 (N : Node_Id) return Boolean is
3738       begin
3739          pragma Assert (Nkind (N) in N_Entity);
3740          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
3741       end Flag124;
3742
3743       function Flag125 (N : Node_Id) return Boolean is
3744       begin
3745          pragma Assert (Nkind (N) in N_Entity);
3746          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
3747       end Flag125;
3748
3749       function Flag126 (N : Node_Id) return Boolean is
3750       begin
3751          pragma Assert (Nkind (N) in N_Entity);
3752          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
3753       end Flag126;
3754
3755       function Flag127 (N : Node_Id) return Boolean is
3756       begin
3757          pragma Assert (Nkind (N) in N_Entity);
3758          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
3759       end Flag127;
3760
3761       function Flag128 (N : Node_Id) return Boolean is
3762       begin
3763          pragma Assert (Nkind (N) in N_Entity);
3764          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
3765       end Flag128;
3766
3767       function Flag129 (N : Node_Id) return Boolean is
3768       begin
3769          pragma Assert (Nkind (N) in N_Entity);
3770          return Nodes.Table (N + 3).In_List;
3771       end Flag129;
3772
3773       function Flag130 (N : Node_Id) return Boolean is
3774       begin
3775          pragma Assert (Nkind (N) in N_Entity);
3776          return Nodes.Table (N + 3).Unused_1;
3777       end Flag130;
3778
3779       function Flag131 (N : Node_Id) return Boolean is
3780       begin
3781          pragma Assert (Nkind (N) in N_Entity);
3782          return Nodes.Table (N + 3).Rewrite_Ins;
3783       end Flag131;
3784
3785       function Flag132 (N : Node_Id) return Boolean is
3786       begin
3787          pragma Assert (Nkind (N) in N_Entity);
3788          return Nodes.Table (N + 3).Analyzed;
3789       end Flag132;
3790
3791       function Flag133 (N : Node_Id) return Boolean is
3792       begin
3793          pragma Assert (Nkind (N) in N_Entity);
3794          return Nodes.Table (N + 3).Comes_From_Source;
3795       end Flag133;
3796
3797       function Flag134 (N : Node_Id) return Boolean is
3798       begin
3799          pragma Assert (Nkind (N) in N_Entity);
3800          return Nodes.Table (N + 3).Error_Posted;
3801       end Flag134;
3802
3803       function Flag135 (N : Node_Id) return Boolean is
3804       begin
3805          pragma Assert (Nkind (N) in N_Entity);
3806          return Nodes.Table (N + 3).Flag4;
3807       end Flag135;
3808
3809       function Flag136 (N : Node_Id) return Boolean is
3810       begin
3811          pragma Assert (Nkind (N) in N_Entity);
3812          return Nodes.Table (N + 3).Flag5;
3813       end Flag136;
3814
3815       function Flag137 (N : Node_Id) return Boolean is
3816       begin
3817          pragma Assert (Nkind (N) in N_Entity);
3818          return Nodes.Table (N + 3).Flag6;
3819       end Flag137;
3820
3821       function Flag138 (N : Node_Id) return Boolean is
3822       begin
3823          pragma Assert (Nkind (N) in N_Entity);
3824          return Nodes.Table (N + 3).Flag7;
3825       end Flag138;
3826
3827       function Flag139 (N : Node_Id) return Boolean is
3828       begin
3829          pragma Assert (Nkind (N) in N_Entity);
3830          return Nodes.Table (N + 3).Flag8;
3831       end Flag139;
3832
3833       function Flag140 (N : Node_Id) return Boolean is
3834       begin
3835          pragma Assert (Nkind (N) in N_Entity);
3836          return Nodes.Table (N + 3).Flag9;
3837       end Flag140;
3838
3839       function Flag141 (N : Node_Id) return Boolean is
3840       begin
3841          pragma Assert (Nkind (N) in N_Entity);
3842          return Nodes.Table (N + 3).Flag10;
3843       end Flag141;
3844
3845       function Flag142 (N : Node_Id) return Boolean is
3846       begin
3847          pragma Assert (Nkind (N) in N_Entity);
3848          return Nodes.Table (N + 3).Flag11;
3849       end Flag142;
3850
3851       function Flag143 (N : Node_Id) return Boolean is
3852       begin
3853          pragma Assert (Nkind (N) in N_Entity);
3854          return Nodes.Table (N + 3).Flag12;
3855       end Flag143;
3856
3857       function Flag144 (N : Node_Id) return Boolean is
3858       begin
3859          pragma Assert (Nkind (N) in N_Entity);
3860          return Nodes.Table (N + 3).Flag13;
3861       end Flag144;
3862
3863       function Flag145 (N : Node_Id) return Boolean is
3864       begin
3865          pragma Assert (Nkind (N) in N_Entity);
3866          return Nodes.Table (N + 3).Flag14;
3867       end Flag145;
3868
3869       function Flag146 (N : Node_Id) return Boolean is
3870       begin
3871          pragma Assert (Nkind (N) in N_Entity);
3872          return Nodes.Table (N + 3).Flag15;
3873       end Flag146;
3874
3875       function Flag147 (N : Node_Id) return Boolean is
3876       begin
3877          pragma Assert (Nkind (N) in N_Entity);
3878          return Nodes.Table (N + 3).Flag16;
3879       end Flag147;
3880
3881       function Flag148 (N : Node_Id) return Boolean is
3882       begin
3883          pragma Assert (Nkind (N) in N_Entity);
3884          return Nodes.Table (N + 3).Flag17;
3885       end Flag148;
3886
3887       function Flag149 (N : Node_Id) return Boolean is
3888       begin
3889          pragma Assert (Nkind (N) in N_Entity);
3890          return Nodes.Table (N + 3).Flag18;
3891       end Flag149;
3892
3893       function Flag150 (N : Node_Id) return Boolean is
3894       begin
3895          pragma Assert (Nkind (N) in N_Entity);
3896          return Nodes.Table (N + 3).Pflag1;
3897       end Flag150;
3898
3899       function Flag151 (N : Node_Id) return Boolean is
3900       begin
3901          pragma Assert (Nkind (N) in N_Entity);
3902          return Nodes.Table (N + 3).Pflag2;
3903       end Flag151;
3904
3905       function Flag152 (N : Node_Id) return Boolean is
3906       begin
3907          pragma Assert (Nkind (N) in N_Entity);
3908          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
3909       end Flag152;
3910
3911       function Flag153 (N : Node_Id) return Boolean is
3912       begin
3913          pragma Assert (Nkind (N) in N_Entity);
3914          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
3915       end Flag153;
3916
3917       function Flag154 (N : Node_Id) return Boolean is
3918       begin
3919          pragma Assert (Nkind (N) in N_Entity);
3920          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
3921       end Flag154;
3922
3923       function Flag155 (N : Node_Id) return Boolean is
3924       begin
3925          pragma Assert (Nkind (N) in N_Entity);
3926          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
3927       end Flag155;
3928
3929       function Flag156 (N : Node_Id) return Boolean is
3930       begin
3931          pragma Assert (Nkind (N) in N_Entity);
3932          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
3933       end Flag156;
3934
3935       function Flag157 (N : Node_Id) return Boolean is
3936       begin
3937          pragma Assert (Nkind (N) in N_Entity);
3938          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
3939       end Flag157;
3940
3941       function Flag158 (N : Node_Id) return Boolean is
3942       begin
3943          pragma Assert (Nkind (N) in N_Entity);
3944          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
3945       end Flag158;
3946
3947       function Flag159 (N : Node_Id) return Boolean is
3948       begin
3949          pragma Assert (Nkind (N) in N_Entity);
3950          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
3951       end Flag159;
3952
3953       function Flag160 (N : Node_Id) return Boolean is
3954       begin
3955          pragma Assert (Nkind (N) in N_Entity);
3956          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
3957       end Flag160;
3958
3959       function Flag161 (N : Node_Id) return Boolean is
3960       begin
3961          pragma Assert (Nkind (N) in N_Entity);
3962          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
3963       end Flag161;
3964
3965       function Flag162 (N : Node_Id) return Boolean is
3966       begin
3967          pragma Assert (Nkind (N) in N_Entity);
3968          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
3969       end Flag162;
3970
3971       function Flag163 (N : Node_Id) return Boolean is
3972       begin
3973          pragma Assert (Nkind (N) in N_Entity);
3974          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
3975       end Flag163;
3976
3977       function Flag164 (N : Node_Id) return Boolean is
3978       begin
3979          pragma Assert (Nkind (N) in N_Entity);
3980          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
3981       end Flag164;
3982
3983       function Flag165 (N : Node_Id) return Boolean is
3984       begin
3985          pragma Assert (Nkind (N) in N_Entity);
3986          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
3987       end Flag165;
3988
3989       function Flag166 (N : Node_Id) return Boolean is
3990       begin
3991          pragma Assert (Nkind (N) in N_Entity);
3992          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
3993       end Flag166;
3994
3995       function Flag167 (N : Node_Id) return Boolean is
3996       begin
3997          pragma Assert (Nkind (N) in N_Entity);
3998          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
3999       end Flag167;
4000
4001       function Flag168 (N : Node_Id) return Boolean is
4002       begin
4003          pragma Assert (Nkind (N) in N_Entity);
4004          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
4005       end Flag168;
4006
4007       function Flag169 (N : Node_Id) return Boolean is
4008       begin
4009          pragma Assert (Nkind (N) in N_Entity);
4010          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
4011       end Flag169;
4012
4013       function Flag170 (N : Node_Id) return Boolean is
4014       begin
4015          pragma Assert (Nkind (N) in N_Entity);
4016          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
4017       end Flag170;
4018
4019       function Flag171 (N : Node_Id) return Boolean is
4020       begin
4021          pragma Assert (Nkind (N) in N_Entity);
4022          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
4023       end Flag171;
4024
4025       function Flag172 (N : Node_Id) return Boolean is
4026       begin
4027          pragma Assert (Nkind (N) in N_Entity);
4028          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
4029       end Flag172;
4030
4031       function Flag173 (N : Node_Id) return Boolean is
4032       begin
4033          pragma Assert (Nkind (N) in N_Entity);
4034          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
4035       end Flag173;
4036
4037       function Flag174 (N : Node_Id) return Boolean is
4038       begin
4039          pragma Assert (Nkind (N) in N_Entity);
4040          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
4041       end Flag174;
4042
4043       function Flag175 (N : Node_Id) return Boolean is
4044       begin
4045          pragma Assert (Nkind (N) in N_Entity);
4046          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
4047       end Flag175;
4048
4049       function Flag176 (N : Node_Id) return Boolean is
4050       begin
4051          pragma Assert (Nkind (N) in N_Entity);
4052          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
4053       end Flag176;
4054
4055       function Flag177 (N : Node_Id) return Boolean is
4056       begin
4057          pragma Assert (Nkind (N) in N_Entity);
4058          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
4059       end Flag177;
4060
4061       function Flag178 (N : Node_Id) return Boolean is
4062       begin
4063          pragma Assert (Nkind (N) in N_Entity);
4064          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
4065       end Flag178;
4066
4067       function Flag179 (N : Node_Id) return Boolean is
4068       begin
4069          pragma Assert (Nkind (N) in N_Entity);
4070          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
4071       end Flag179;
4072
4073       function Flag180 (N : Node_Id) return Boolean is
4074       begin
4075          pragma Assert (Nkind (N) in N_Entity);
4076          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
4077       end Flag180;
4078
4079       function Flag181 (N : Node_Id) return Boolean is
4080       begin
4081          pragma Assert (Nkind (N) in N_Entity);
4082          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
4083       end Flag181;
4084
4085       function Flag182 (N : Node_Id) return Boolean is
4086       begin
4087          pragma Assert (Nkind (N) in N_Entity);
4088          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
4089       end Flag182;
4090
4091       function Flag183 (N : Node_Id) return Boolean is
4092       begin
4093          pragma Assert (Nkind (N) in N_Entity);
4094          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
4095       end Flag183;
4096
4097       procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
4098       begin
4099          pragma Assert (N in Nodes.First .. Nodes.Last);
4100          Nodes.Table (N).Nkind := Val;
4101       end Set_Nkind;
4102
4103       procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
4104       begin
4105          pragma Assert (N in Nodes.First .. Nodes.Last);
4106          Nodes.Table (N).Field1 := Val;
4107       end Set_Field1;
4108
4109       procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
4110       begin
4111          pragma Assert (N in Nodes.First .. Nodes.Last);
4112          Nodes.Table (N).Field2 := Val;
4113       end Set_Field2;
4114
4115       procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
4116       begin
4117          pragma Assert (N in Nodes.First .. Nodes.Last);
4118          Nodes.Table (N).Field3 := Val;
4119       end Set_Field3;
4120
4121       procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
4122       begin
4123          pragma Assert (N in Nodes.First .. Nodes.Last);
4124          Nodes.Table (N).Field4 := Val;
4125       end Set_Field4;
4126
4127       procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
4128       begin
4129          pragma Assert (N in Nodes.First .. Nodes.Last);
4130          Nodes.Table (N).Field5 := Val;
4131       end Set_Field5;
4132
4133       procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
4134       begin
4135          pragma Assert (Nkind (N) in N_Entity);
4136          Nodes.Table (N + 1).Field6 := Val;
4137       end Set_Field6;
4138
4139       procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
4140       begin
4141          pragma Assert (Nkind (N) in N_Entity);
4142          Nodes.Table (N + 1).Field7 := Val;
4143       end Set_Field7;
4144
4145       procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
4146       begin
4147          pragma Assert (Nkind (N) in N_Entity);
4148          Nodes.Table (N + 1).Field8 := Val;
4149       end Set_Field8;
4150
4151       procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
4152       begin
4153          pragma Assert (Nkind (N) in N_Entity);
4154          Nodes.Table (N + 1).Field9 := Val;
4155       end Set_Field9;
4156
4157       procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
4158       begin
4159          pragma Assert (Nkind (N) in N_Entity);
4160          Nodes.Table (N + 1).Field10 := Val;
4161       end Set_Field10;
4162
4163       procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
4164       begin
4165          pragma Assert (Nkind (N) in N_Entity);
4166          Nodes.Table (N + 1).Field11 := Val;
4167       end Set_Field11;
4168
4169       procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
4170       begin
4171          pragma Assert (Nkind (N) in N_Entity);
4172          Nodes.Table (N + 1).Field12 := Val;
4173       end Set_Field12;
4174
4175       procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
4176       begin
4177          pragma Assert (Nkind (N) in N_Entity);
4178          Nodes.Table (N + 2).Field6 := Val;
4179       end Set_Field13;
4180
4181       procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
4182       begin
4183          pragma Assert (Nkind (N) in N_Entity);
4184          Nodes.Table (N + 2).Field7 := Val;
4185       end Set_Field14;
4186
4187       procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
4188       begin
4189          pragma Assert (Nkind (N) in N_Entity);
4190          Nodes.Table (N + 2).Field8 := Val;
4191       end Set_Field15;
4192
4193       procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
4194       begin
4195          pragma Assert (Nkind (N) in N_Entity);
4196          Nodes.Table (N + 2).Field9 := Val;
4197       end Set_Field16;
4198
4199       procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
4200       begin
4201          pragma Assert (Nkind (N) in N_Entity);
4202          Nodes.Table (N + 2).Field10 := Val;
4203       end Set_Field17;
4204
4205       procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
4206       begin
4207          pragma Assert (Nkind (N) in N_Entity);
4208          Nodes.Table (N + 2).Field11 := Val;
4209       end Set_Field18;
4210
4211       procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
4212       begin
4213          pragma Assert (Nkind (N) in N_Entity);
4214          Nodes.Table (N + 3).Field6 := Val;
4215       end Set_Field19;
4216
4217       procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
4218       begin
4219          pragma Assert (Nkind (N) in N_Entity);
4220          Nodes.Table (N + 3).Field7 := Val;
4221       end Set_Field20;
4222
4223       procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
4224       begin
4225          pragma Assert (Nkind (N) in N_Entity);
4226          Nodes.Table (N + 3).Field8 := Val;
4227       end Set_Field21;
4228
4229       procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
4230       begin
4231          pragma Assert (Nkind (N) in N_Entity);
4232          Nodes.Table (N + 3).Field9 := Val;
4233       end Set_Field22;
4234
4235       procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
4236       begin
4237          pragma Assert (Nkind (N) in N_Entity);
4238          Nodes.Table (N + 3).Field10 := Val;
4239       end Set_Field23;
4240
4241       procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
4242       begin
4243          pragma Assert (N in Nodes.First .. Nodes.Last);
4244          Nodes.Table (N).Field1 := Union_Id (Val);
4245       end Set_Node1;
4246
4247       procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
4248       begin
4249          pragma Assert (N in Nodes.First .. Nodes.Last);
4250          Nodes.Table (N).Field2 := Union_Id (Val);
4251       end Set_Node2;
4252
4253       procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
4254       begin
4255          pragma Assert (N in Nodes.First .. Nodes.Last);
4256          Nodes.Table (N).Field3 := Union_Id (Val);
4257       end Set_Node3;
4258
4259       procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
4260       begin
4261          pragma Assert (N in Nodes.First .. Nodes.Last);
4262          Nodes.Table (N).Field4 := Union_Id (Val);
4263       end Set_Node4;
4264
4265       procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
4266       begin
4267          pragma Assert (N in Nodes.First .. Nodes.Last);
4268          Nodes.Table (N).Field5 := Union_Id (Val);
4269       end Set_Node5;
4270
4271       procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
4272       begin
4273          pragma Assert (Nkind (N) in N_Entity);
4274          Nodes.Table (N + 1).Field6 := Union_Id (Val);
4275       end Set_Node6;
4276
4277       procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
4278       begin
4279          pragma Assert (Nkind (N) in N_Entity);
4280          Nodes.Table (N + 1).Field7 := Union_Id (Val);
4281       end Set_Node7;
4282
4283       procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
4284       begin
4285          pragma Assert (Nkind (N) in N_Entity);
4286          Nodes.Table (N + 1).Field8 := Union_Id (Val);
4287       end Set_Node8;
4288
4289       procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
4290       begin
4291          pragma Assert (Nkind (N) in N_Entity);
4292          Nodes.Table (N + 1).Field9 := Union_Id (Val);
4293       end Set_Node9;
4294
4295       procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
4296       begin
4297          pragma Assert (Nkind (N) in N_Entity);
4298          Nodes.Table (N + 1).Field10 := Union_Id (Val);
4299       end Set_Node10;
4300
4301       procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
4302       begin
4303          pragma Assert (Nkind (N) in N_Entity);
4304          Nodes.Table (N + 1).Field11 := Union_Id (Val);
4305       end Set_Node11;
4306
4307       procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
4308       begin
4309          pragma Assert (Nkind (N) in N_Entity);
4310          Nodes.Table (N + 1).Field12 := Union_Id (Val);
4311       end Set_Node12;
4312
4313       procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
4314       begin
4315          pragma Assert (Nkind (N) in N_Entity);
4316          Nodes.Table (N + 2).Field6 := Union_Id (Val);
4317       end Set_Node13;
4318
4319       procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
4320       begin
4321          pragma Assert (Nkind (N) in N_Entity);
4322          Nodes.Table (N + 2).Field7 := Union_Id (Val);
4323       end Set_Node14;
4324
4325       procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
4326       begin
4327          pragma Assert (Nkind (N) in N_Entity);
4328          Nodes.Table (N + 2).Field8 := Union_Id (Val);
4329       end Set_Node15;
4330
4331       procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
4332       begin
4333          pragma Assert (Nkind (N) in N_Entity);
4334          Nodes.Table (N + 2).Field9 := Union_Id (Val);
4335       end Set_Node16;
4336
4337       procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
4338       begin
4339          pragma Assert (Nkind (N) in N_Entity);
4340          Nodes.Table (N + 2).Field10 := Union_Id (Val);
4341       end Set_Node17;
4342
4343       procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
4344       begin
4345          pragma Assert (Nkind (N) in N_Entity);
4346          Nodes.Table (N + 2).Field11 := Union_Id (Val);
4347       end Set_Node18;
4348
4349       procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
4350       begin
4351          pragma Assert (Nkind (N) in N_Entity);
4352          Nodes.Table (N + 3).Field6 := Union_Id (Val);
4353       end Set_Node19;
4354
4355       procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
4356       begin
4357          pragma Assert (Nkind (N) in N_Entity);
4358          Nodes.Table (N + 3).Field7 := Union_Id (Val);
4359       end Set_Node20;
4360
4361       procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
4362       begin
4363          pragma Assert (Nkind (N) in N_Entity);
4364          Nodes.Table (N + 3).Field8 := Union_Id (Val);
4365       end Set_Node21;
4366
4367       procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
4368       begin
4369          pragma Assert (Nkind (N) in N_Entity);
4370          Nodes.Table (N + 3).Field9 := Union_Id (Val);
4371       end Set_Node22;
4372
4373       procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
4374       begin
4375          pragma Assert (Nkind (N) in N_Entity);
4376          Nodes.Table (N + 3).Field10 := Union_Id (Val);
4377       end Set_Node23;
4378
4379       procedure Set_List1 (N : Node_Id; Val : List_Id) is
4380       begin
4381          pragma Assert (N in Nodes.First .. Nodes.Last);
4382          Nodes.Table (N).Field1 := Union_Id (Val);
4383       end Set_List1;
4384
4385       procedure Set_List2 (N : Node_Id; Val : List_Id) is
4386       begin
4387          pragma Assert (N in Nodes.First .. Nodes.Last);
4388          Nodes.Table (N).Field2 := Union_Id (Val);
4389       end Set_List2;
4390
4391       procedure Set_List3 (N : Node_Id; Val : List_Id) is
4392       begin
4393          pragma Assert (N in Nodes.First .. Nodes.Last);
4394          Nodes.Table (N).Field3 := Union_Id (Val);
4395       end Set_List3;
4396
4397       procedure Set_List4 (N : Node_Id; Val : List_Id) is
4398       begin
4399          pragma Assert (N in Nodes.First .. Nodes.Last);
4400          Nodes.Table (N).Field4 := Union_Id (Val);
4401       end Set_List4;
4402
4403       procedure Set_List5 (N : Node_Id; Val : List_Id) is
4404       begin
4405          pragma Assert (N in Nodes.First .. Nodes.Last);
4406          Nodes.Table (N).Field5 := Union_Id (Val);
4407       end Set_List5;
4408
4409       procedure Set_List10 (N : Node_Id; Val : List_Id) is
4410       begin
4411          pragma Assert (Nkind (N) in N_Entity);
4412          Nodes.Table (N + 1).Field10 := Union_Id (Val);
4413       end Set_List10;
4414
4415       procedure Set_List14 (N : Node_Id; Val : List_Id) is
4416       begin
4417          pragma Assert (Nkind (N) in N_Entity);
4418          Nodes.Table (N + 2).Field7 := Union_Id (Val);
4419       end Set_List14;
4420
4421       procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
4422       begin
4423          Nodes.Table (N).Field2 := Union_Id (Val);
4424       end Set_Elist2;
4425
4426       procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
4427       begin
4428          Nodes.Table (N).Field3 := Union_Id (Val);
4429       end Set_Elist3;
4430
4431       procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
4432       begin
4433          Nodes.Table (N).Field4 := Union_Id (Val);
4434       end Set_Elist4;
4435
4436       procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
4437       begin
4438          pragma Assert (Nkind (N) in N_Entity);
4439          Nodes.Table (N + 1).Field8 := Union_Id (Val);
4440       end Set_Elist8;
4441
4442       procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
4443       begin
4444          pragma Assert (Nkind (N) in N_Entity);
4445          Nodes.Table (N + 2).Field6 := Union_Id (Val);
4446       end Set_Elist13;
4447
4448       procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
4449       begin
4450          pragma Assert (Nkind (N) in N_Entity);
4451          Nodes.Table (N + 2).Field8 := Union_Id (Val);
4452       end Set_Elist15;
4453
4454       procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
4455       begin
4456          pragma Assert (Nkind (N) in N_Entity);
4457          Nodes.Table (N + 2).Field9 := Union_Id (Val);
4458       end Set_Elist16;
4459
4460       procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
4461       begin
4462          pragma Assert (Nkind (N) in N_Entity);
4463          Nodes.Table (N + 2).Field11 := Union_Id (Val);
4464       end Set_Elist18;
4465
4466       procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
4467       begin
4468          pragma Assert (Nkind (N) in N_Entity);
4469          Nodes.Table (N + 3).Field8 := Union_Id (Val);
4470       end Set_Elist21;
4471
4472       procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
4473       begin
4474          pragma Assert (Nkind (N) in N_Entity);
4475          Nodes.Table (N + 3).Field10 := Union_Id (Val);
4476       end Set_Elist23;
4477
4478       procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
4479       begin
4480          pragma Assert (N in Nodes.First .. Nodes.Last);
4481          Nodes.Table (N).Field1 := Union_Id (Val);
4482       end Set_Name1;
4483
4484       procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
4485       begin
4486          pragma Assert (N in Nodes.First .. Nodes.Last);
4487          Nodes.Table (N).Field2 := Union_Id (Val);
4488       end Set_Name2;
4489
4490       procedure Set_Str3 (N : Node_Id; Val : String_Id) is
4491       begin
4492          pragma Assert (N in Nodes.First .. Nodes.Last);
4493          Nodes.Table (N).Field3 := Union_Id (Val);
4494       end Set_Str3;
4495
4496       procedure Set_Uint3 (N : Node_Id; Val : Uint) is
4497       begin
4498          pragma Assert (N in Nodes.First .. Nodes.Last);
4499          Nodes.Table (N).Field3 := To_Union (Val);
4500       end Set_Uint3;
4501
4502       procedure Set_Uint4 (N : Node_Id; Val : Uint) is
4503       begin
4504          pragma Assert (N in Nodes.First .. Nodes.Last);
4505          Nodes.Table (N).Field4 := To_Union (Val);
4506       end Set_Uint4;
4507
4508       procedure Set_Uint5 (N : Node_Id; Val : Uint) is
4509       begin
4510          pragma Assert (N in Nodes.First .. Nodes.Last);
4511          Nodes.Table (N).Field5 := To_Union (Val);
4512       end Set_Uint5;
4513
4514       procedure Set_Uint8 (N : Node_Id; Val : Uint) is
4515       begin
4516          pragma Assert (Nkind (N) in N_Entity);
4517          Nodes.Table (N + 1).Field8 := To_Union (Val);
4518       end Set_Uint8;
4519
4520       procedure Set_Uint9 (N : Node_Id; Val : Uint) is
4521       begin
4522          pragma Assert (Nkind (N) in N_Entity);
4523          Nodes.Table (N + 1).Field9 := To_Union (Val);
4524       end Set_Uint9;
4525
4526       procedure Set_Uint10 (N : Node_Id; Val : Uint) is
4527       begin
4528          pragma Assert (Nkind (N) in N_Entity);
4529          Nodes.Table (N + 1).Field10 := To_Union (Val);
4530       end Set_Uint10;
4531
4532       procedure Set_Uint11 (N : Node_Id; Val : Uint) is
4533       begin
4534          pragma Assert (Nkind (N) in N_Entity);
4535          Nodes.Table (N + 1).Field11 := To_Union (Val);
4536       end Set_Uint11;
4537
4538       procedure Set_Uint12 (N : Node_Id; Val : Uint) is
4539       begin
4540          pragma Assert (Nkind (N) in N_Entity);
4541          Nodes.Table (N + 1).Field12 := To_Union (Val);
4542       end Set_Uint12;
4543
4544       procedure Set_Uint13 (N : Node_Id; Val : Uint) is
4545       begin
4546          pragma Assert (Nkind (N) in N_Entity);
4547          Nodes.Table (N + 2).Field6 := To_Union (Val);
4548       end Set_Uint13;
4549
4550       procedure Set_Uint14 (N : Node_Id; Val : Uint) is
4551       begin
4552          pragma Assert (Nkind (N) in N_Entity);
4553          Nodes.Table (N + 2).Field7 := To_Union (Val);
4554       end Set_Uint14;
4555
4556       procedure Set_Uint15 (N : Node_Id; Val : Uint) is
4557       begin
4558          pragma Assert (Nkind (N) in N_Entity);
4559          Nodes.Table (N + 2).Field8 := To_Union (Val);
4560       end Set_Uint15;
4561
4562       procedure Set_Uint16 (N : Node_Id; Val : Uint) is
4563       begin
4564          pragma Assert (Nkind (N) in N_Entity);
4565          Nodes.Table (N + 2).Field9 := To_Union (Val);
4566       end Set_Uint16;
4567
4568       procedure Set_Uint17 (N : Node_Id; Val : Uint) is
4569       begin
4570          pragma Assert (Nkind (N) in N_Entity);
4571          Nodes.Table (N + 2).Field10 := To_Union (Val);
4572       end Set_Uint17;
4573
4574       procedure Set_Uint22 (N : Node_Id; Val : Uint) is
4575       begin
4576          pragma Assert (Nkind (N) in N_Entity);
4577          Nodes.Table (N + 3).Field9 := To_Union (Val);
4578       end Set_Uint22;
4579
4580       procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
4581       begin
4582          pragma Assert (N in Nodes.First .. Nodes.Last);
4583          Nodes.Table (N).Field3 := To_Union (Val);
4584       end Set_Ureal3;
4585
4586       procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
4587       begin
4588          pragma Assert (Nkind (N) in N_Entity);
4589          Nodes.Table (N + 2).Field11 := To_Union (Val);
4590       end Set_Ureal18;
4591
4592       procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
4593       begin
4594          pragma Assert (Nkind (N) in N_Entity);
4595          Nodes.Table (N + 3).Field8 := To_Union (Val);
4596       end Set_Ureal21;
4597
4598       procedure Set_Char_Code2 (N : Node_Id; Val : Char_Code) is
4599       begin
4600          pragma Assert (N in Nodes.First .. Nodes.Last);
4601          Nodes.Table (N).Field2 := Union_Id (Val) + Char_Code_Bias;
4602       end Set_Char_Code2;
4603
4604       procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
4605       begin
4606          pragma Assert (N in Nodes.First .. Nodes.Last);
4607          Nodes.Table (N).Flag4 := Val;
4608       end Set_Flag4;
4609
4610       procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
4611       begin
4612          pragma Assert (N in Nodes.First .. Nodes.Last);
4613          Nodes.Table (N).Flag5 := Val;
4614       end Set_Flag5;
4615
4616       procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
4617       begin
4618          pragma Assert (N in Nodes.First .. Nodes.Last);
4619          Nodes.Table (N).Flag6 := Val;
4620       end Set_Flag6;
4621
4622       procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
4623       begin
4624          pragma Assert (N in Nodes.First .. Nodes.Last);
4625          Nodes.Table (N).Flag7 := Val;
4626       end Set_Flag7;
4627
4628       procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
4629       begin
4630          pragma Assert (N in Nodes.First .. Nodes.Last);
4631          Nodes.Table (N).Flag8 := Val;
4632       end Set_Flag8;
4633
4634       procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
4635       begin
4636          pragma Assert (N in Nodes.First .. Nodes.Last);
4637          Nodes.Table (N).Flag9 := Val;
4638       end Set_Flag9;
4639
4640       procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
4641       begin
4642          pragma Assert (N in Nodes.First .. Nodes.Last);
4643          Nodes.Table (N).Flag10 := Val;
4644       end Set_Flag10;
4645
4646       procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
4647       begin
4648          pragma Assert (N in Nodes.First .. Nodes.Last);
4649          Nodes.Table (N).Flag11 := Val;
4650       end Set_Flag11;
4651
4652       procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
4653       begin
4654          pragma Assert (N in Nodes.First .. Nodes.Last);
4655          Nodes.Table (N).Flag12 := Val;
4656       end Set_Flag12;
4657
4658       procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
4659       begin
4660          pragma Assert (N in Nodes.First .. Nodes.Last);
4661          Nodes.Table (N).Flag13 := Val;
4662       end Set_Flag13;
4663
4664       procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
4665       begin
4666          pragma Assert (N in Nodes.First .. Nodes.Last);
4667          Nodes.Table (N).Flag14 := Val;
4668       end Set_Flag14;
4669
4670       procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
4671       begin
4672          pragma Assert (N in Nodes.First .. Nodes.Last);
4673          Nodes.Table (N).Flag15 := Val;
4674       end Set_Flag15;
4675
4676       procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
4677       begin
4678          pragma Assert (N in Nodes.First .. Nodes.Last);
4679          Nodes.Table (N).Flag16 := Val;
4680       end Set_Flag16;
4681
4682       procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
4683       begin
4684          pragma Assert (N in Nodes.First .. Nodes.Last);
4685          Nodes.Table (N).Flag17 := Val;
4686       end Set_Flag17;
4687
4688       procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
4689       begin
4690          pragma Assert (N in Nodes.First .. Nodes.Last);
4691          Nodes.Table (N).Flag18 := Val;
4692       end Set_Flag18;
4693
4694       procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
4695       begin
4696          pragma Assert (Nkind (N) in N_Entity);
4697          Nodes.Table (N + 1).In_List := Val;
4698       end Set_Flag19;
4699
4700       procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
4701       begin
4702          pragma Assert (Nkind (N) in N_Entity);
4703          Nodes.Table (N + 1).Unused_1 := Val;
4704       end Set_Flag20;
4705
4706       procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
4707       begin
4708          pragma Assert (Nkind (N) in N_Entity);
4709          Nodes.Table (N + 1).Rewrite_Ins := Val;
4710       end Set_Flag21;
4711
4712       procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
4713       begin
4714          pragma Assert (Nkind (N) in N_Entity);
4715          Nodes.Table (N + 1).Analyzed := Val;
4716       end Set_Flag22;
4717
4718       procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
4719       begin
4720          pragma Assert (Nkind (N) in N_Entity);
4721          Nodes.Table (N + 1).Comes_From_Source := Val;
4722       end Set_Flag23;
4723
4724       procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
4725       begin
4726          pragma Assert (Nkind (N) in N_Entity);
4727          Nodes.Table (N + 1).Error_Posted := Val;
4728       end Set_Flag24;
4729
4730       procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
4731       begin
4732          pragma Assert (Nkind (N) in N_Entity);
4733          Nodes.Table (N + 1).Flag4 := Val;
4734       end Set_Flag25;
4735
4736       procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
4737       begin
4738          pragma Assert (Nkind (N) in N_Entity);
4739          Nodes.Table (N + 1).Flag5 := Val;
4740       end Set_Flag26;
4741
4742       procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
4743       begin
4744          pragma Assert (Nkind (N) in N_Entity);
4745          Nodes.Table (N + 1).Flag6 := Val;
4746       end Set_Flag27;
4747
4748       procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
4749       begin
4750          pragma Assert (Nkind (N) in N_Entity);
4751          Nodes.Table (N + 1).Flag7 := Val;
4752       end Set_Flag28;
4753
4754       procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
4755       begin
4756          pragma Assert (Nkind (N) in N_Entity);
4757          Nodes.Table (N + 1).Flag8 := Val;
4758       end Set_Flag29;
4759
4760       procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
4761       begin
4762          pragma Assert (Nkind (N) in N_Entity);
4763          Nodes.Table (N + 1).Flag9 := Val;
4764       end Set_Flag30;
4765
4766       procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
4767       begin
4768          pragma Assert (Nkind (N) in N_Entity);
4769          Nodes.Table (N + 1).Flag10 := Val;
4770       end Set_Flag31;
4771
4772       procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
4773       begin
4774          pragma Assert (Nkind (N) in N_Entity);
4775          Nodes.Table (N + 1).Flag11 := Val;
4776       end Set_Flag32;
4777
4778       procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
4779       begin
4780          pragma Assert (Nkind (N) in N_Entity);
4781          Nodes.Table (N + 1).Flag12 := Val;
4782       end Set_Flag33;
4783
4784       procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
4785       begin
4786          pragma Assert (Nkind (N) in N_Entity);
4787          Nodes.Table (N + 1).Flag13 := Val;
4788       end Set_Flag34;
4789
4790       procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
4791       begin
4792          pragma Assert (Nkind (N) in N_Entity);
4793          Nodes.Table (N + 1).Flag14 := Val;
4794       end Set_Flag35;
4795
4796       procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
4797       begin
4798          pragma Assert (Nkind (N) in N_Entity);
4799          Nodes.Table (N + 1).Flag15 := Val;
4800       end Set_Flag36;
4801
4802       procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
4803       begin
4804          pragma Assert (Nkind (N) in N_Entity);
4805          Nodes.Table (N + 1).Flag16 := Val;
4806       end Set_Flag37;
4807
4808       procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
4809       begin
4810          pragma Assert (Nkind (N) in N_Entity);
4811          Nodes.Table (N + 1).Flag17 := Val;
4812       end Set_Flag38;
4813
4814       procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
4815       begin
4816          pragma Assert (Nkind (N) in N_Entity);
4817          Nodes.Table (N + 1).Flag18 := Val;
4818       end Set_Flag39;
4819
4820       procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
4821       begin
4822          pragma Assert (Nkind (N) in N_Entity);
4823          Nodes.Table (N + 2).In_List := Val;
4824       end Set_Flag40;
4825
4826       procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
4827       begin
4828          pragma Assert (Nkind (N) in N_Entity);
4829          Nodes.Table (N + 2).Unused_1 := Val;
4830       end Set_Flag41;
4831
4832       procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
4833       begin
4834          pragma Assert (Nkind (N) in N_Entity);
4835          Nodes.Table (N + 2).Rewrite_Ins := Val;
4836       end Set_Flag42;
4837
4838       procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
4839       begin
4840          pragma Assert (Nkind (N) in N_Entity);
4841          Nodes.Table (N + 2).Analyzed := Val;
4842       end Set_Flag43;
4843
4844       procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
4845       begin
4846          pragma Assert (Nkind (N) in N_Entity);
4847          Nodes.Table (N + 2).Comes_From_Source := Val;
4848       end Set_Flag44;
4849
4850       procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
4851       begin
4852          pragma Assert (Nkind (N) in N_Entity);
4853          Nodes.Table (N + 2).Error_Posted := Val;
4854       end Set_Flag45;
4855
4856       procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
4857       begin
4858          pragma Assert (Nkind (N) in N_Entity);
4859          Nodes.Table (N + 2).Flag4 := Val;
4860       end Set_Flag46;
4861
4862       procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
4863       begin
4864          pragma Assert (Nkind (N) in N_Entity);
4865          Nodes.Table (N + 2).Flag5 := Val;
4866       end Set_Flag47;
4867
4868       procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
4869       begin
4870          pragma Assert (Nkind (N) in N_Entity);
4871          Nodes.Table (N + 2).Flag6 := Val;
4872       end Set_Flag48;
4873
4874       procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
4875       begin
4876          pragma Assert (Nkind (N) in N_Entity);
4877          Nodes.Table (N + 2).Flag7 := Val;
4878       end Set_Flag49;
4879
4880       procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
4881       begin
4882          pragma Assert (Nkind (N) in N_Entity);
4883          Nodes.Table (N + 2).Flag8 := Val;
4884       end Set_Flag50;
4885
4886       procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
4887       begin
4888          pragma Assert (Nkind (N) in N_Entity);
4889          Nodes.Table (N + 2).Flag9 := Val;
4890       end Set_Flag51;
4891
4892       procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
4893       begin
4894          pragma Assert (Nkind (N) in N_Entity);
4895          Nodes.Table (N + 2).Flag10 := Val;
4896       end Set_Flag52;
4897
4898       procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
4899       begin
4900          pragma Assert (Nkind (N) in N_Entity);
4901          Nodes.Table (N + 2).Flag11 := Val;
4902       end Set_Flag53;
4903
4904       procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
4905       begin
4906          pragma Assert (Nkind (N) in N_Entity);
4907          Nodes.Table (N + 2).Flag12 := Val;
4908       end Set_Flag54;
4909
4910       procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
4911       begin
4912          pragma Assert (Nkind (N) in N_Entity);
4913          Nodes.Table (N + 2).Flag13 := Val;
4914       end Set_Flag55;
4915
4916       procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
4917       begin
4918          pragma Assert (Nkind (N) in N_Entity);
4919          Nodes.Table (N + 2).Flag14 := Val;
4920       end Set_Flag56;
4921
4922       procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
4923       begin
4924          pragma Assert (Nkind (N) in N_Entity);
4925          Nodes.Table (N + 2).Flag15 := Val;
4926       end Set_Flag57;
4927
4928       procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
4929       begin
4930          pragma Assert (Nkind (N) in N_Entity);
4931          Nodes.Table (N + 2).Flag16 := Val;
4932       end Set_Flag58;
4933
4934       procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
4935       begin
4936          pragma Assert (Nkind (N) in N_Entity);
4937          Nodes.Table (N + 2).Flag17 := Val;
4938       end Set_Flag59;
4939
4940       procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
4941       begin
4942          pragma Assert (Nkind (N) in N_Entity);
4943          Nodes.Table (N + 2).Flag18 := Val;
4944       end Set_Flag60;
4945
4946       procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
4947       begin
4948          pragma Assert (Nkind (N) in N_Entity);
4949          Nodes.Table (N + 1).Pflag1 := Val;
4950       end Set_Flag61;
4951
4952       procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
4953       begin
4954          pragma Assert (Nkind (N) in N_Entity);
4955          Nodes.Table (N + 1).Pflag2 := Val;
4956       end Set_Flag62;
4957
4958       procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
4959       begin
4960          pragma Assert (Nkind (N) in N_Entity);
4961          Nodes.Table (N + 2).Pflag1 := Val;
4962       end Set_Flag63;
4963
4964       procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
4965       begin
4966          pragma Assert (Nkind (N) in N_Entity);
4967          Nodes.Table (N + 2).Pflag2 := Val;
4968       end Set_Flag64;
4969
4970       procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
4971       begin
4972          pragma Assert (Nkind (N) in N_Entity);
4973          To_Flag_Byte_Ptr
4974            (Node_Kind_Ptr'
4975              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
4976       end Set_Flag65;
4977
4978       procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
4979       begin
4980          pragma Assert (Nkind (N) in N_Entity);
4981          To_Flag_Byte_Ptr
4982            (Node_Kind_Ptr'
4983              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
4984       end Set_Flag66;
4985
4986       procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
4987       begin
4988          pragma Assert (Nkind (N) in N_Entity);
4989          To_Flag_Byte_Ptr
4990            (Node_Kind_Ptr'
4991              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
4992       end Set_Flag67;
4993
4994       procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
4995       begin
4996          pragma Assert (Nkind (N) in N_Entity);
4997          To_Flag_Byte_Ptr
4998            (Node_Kind_Ptr'
4999              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
5000       end Set_Flag68;
5001
5002       procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
5003       begin
5004          pragma Assert (Nkind (N) in N_Entity);
5005          To_Flag_Byte_Ptr
5006            (Node_Kind_Ptr'
5007              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
5008       end Set_Flag69;
5009
5010       procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
5011       begin
5012          pragma Assert (Nkind (N) in N_Entity);
5013          To_Flag_Byte_Ptr
5014            (Node_Kind_Ptr'
5015              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
5016       end Set_Flag70;
5017
5018       procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
5019       begin
5020          pragma Assert (Nkind (N) in N_Entity);
5021          To_Flag_Byte_Ptr
5022            (Node_Kind_Ptr'
5023              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
5024       end Set_Flag71;
5025
5026       procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
5027       begin
5028          pragma Assert (Nkind (N) in N_Entity);
5029          To_Flag_Byte_Ptr
5030            (Node_Kind_Ptr'
5031              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
5032       end Set_Flag72;
5033
5034       procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
5035       begin
5036          pragma Assert (Nkind (N) in N_Entity);
5037          To_Flag_Word_Ptr
5038            (Union_Id_Ptr'
5039              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
5040       end Set_Flag73;
5041
5042       procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
5043       begin
5044          pragma Assert (Nkind (N) in N_Entity);
5045          To_Flag_Word_Ptr
5046            (Union_Id_Ptr'
5047              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
5048       end Set_Flag74;
5049
5050       procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
5051       begin
5052          pragma Assert (Nkind (N) in N_Entity);
5053          To_Flag_Word_Ptr
5054            (Union_Id_Ptr'
5055              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
5056       end Set_Flag75;
5057
5058       procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
5059       begin
5060          pragma Assert (Nkind (N) in N_Entity);
5061          To_Flag_Word_Ptr
5062            (Union_Id_Ptr'
5063              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
5064       end Set_Flag76;
5065
5066       procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
5067       begin
5068          pragma Assert (Nkind (N) in N_Entity);
5069          To_Flag_Word_Ptr
5070            (Union_Id_Ptr'
5071              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
5072       end Set_Flag77;
5073
5074       procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
5075       begin
5076          pragma Assert (Nkind (N) in N_Entity);
5077          To_Flag_Word_Ptr
5078            (Union_Id_Ptr'
5079              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
5080       end Set_Flag78;
5081
5082       procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
5083       begin
5084          pragma Assert (Nkind (N) in N_Entity);
5085          To_Flag_Word_Ptr
5086            (Union_Id_Ptr'
5087              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
5088       end Set_Flag79;
5089
5090       procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
5091       begin
5092          pragma Assert (Nkind (N) in N_Entity);
5093          To_Flag_Word_Ptr
5094            (Union_Id_Ptr'
5095              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
5096       end Set_Flag80;
5097
5098       procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
5099       begin
5100          pragma Assert (Nkind (N) in N_Entity);
5101          To_Flag_Word_Ptr
5102            (Union_Id_Ptr'
5103              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
5104       end Set_Flag81;
5105
5106       procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
5107       begin
5108          pragma Assert (Nkind (N) in N_Entity);
5109          To_Flag_Word_Ptr
5110            (Union_Id_Ptr'
5111              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
5112       end Set_Flag82;
5113
5114       procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
5115       begin
5116          pragma Assert (Nkind (N) in N_Entity);
5117          To_Flag_Word_Ptr
5118            (Union_Id_Ptr'
5119              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
5120       end Set_Flag83;
5121
5122       procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
5123       begin
5124          pragma Assert (Nkind (N) in N_Entity);
5125          To_Flag_Word_Ptr
5126            (Union_Id_Ptr'
5127              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
5128       end Set_Flag84;
5129
5130       procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
5131       begin
5132          pragma Assert (Nkind (N) in N_Entity);
5133          To_Flag_Word_Ptr
5134            (Union_Id_Ptr'
5135              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
5136       end Set_Flag85;
5137
5138       procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
5139       begin
5140          pragma Assert (Nkind (N) in N_Entity);
5141          To_Flag_Word_Ptr
5142            (Union_Id_Ptr'
5143              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
5144       end Set_Flag86;
5145
5146       procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
5147       begin
5148          pragma Assert (Nkind (N) in N_Entity);
5149          To_Flag_Word_Ptr
5150            (Union_Id_Ptr'
5151              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
5152       end Set_Flag87;
5153
5154       procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
5155       begin
5156          pragma Assert (Nkind (N) in N_Entity);
5157          To_Flag_Word_Ptr
5158            (Union_Id_Ptr'
5159              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
5160       end Set_Flag88;
5161
5162       procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
5163       begin
5164          pragma Assert (Nkind (N) in N_Entity);
5165          To_Flag_Word_Ptr
5166            (Union_Id_Ptr'
5167              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
5168       end Set_Flag89;
5169
5170       procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
5171       begin
5172          pragma Assert (Nkind (N) in N_Entity);
5173          To_Flag_Word_Ptr
5174            (Union_Id_Ptr'
5175              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
5176       end Set_Flag90;
5177
5178       procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
5179       begin
5180          pragma Assert (Nkind (N) in N_Entity);
5181          To_Flag_Word_Ptr
5182            (Union_Id_Ptr'
5183              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
5184       end Set_Flag91;
5185
5186       procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
5187       begin
5188          pragma Assert (Nkind (N) in N_Entity);
5189          To_Flag_Word_Ptr
5190            (Union_Id_Ptr'
5191              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
5192       end Set_Flag92;
5193
5194       procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
5195       begin
5196          pragma Assert (Nkind (N) in N_Entity);
5197          To_Flag_Word_Ptr
5198            (Union_Id_Ptr'
5199              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
5200       end Set_Flag93;
5201
5202       procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
5203       begin
5204          pragma Assert (Nkind (N) in N_Entity);
5205          To_Flag_Word_Ptr
5206            (Union_Id_Ptr'
5207              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
5208       end Set_Flag94;
5209
5210       procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
5211       begin
5212          pragma Assert (Nkind (N) in N_Entity);
5213          To_Flag_Word_Ptr
5214            (Union_Id_Ptr'
5215              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
5216       end Set_Flag95;
5217
5218       procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
5219       begin
5220          pragma Assert (Nkind (N) in N_Entity);
5221          To_Flag_Word_Ptr
5222            (Union_Id_Ptr'
5223              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
5224       end Set_Flag96;
5225
5226       procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
5227       begin
5228          pragma Assert (Nkind (N) in N_Entity);
5229          To_Flag_Word2_Ptr
5230            (Union_Id_Ptr'
5231              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
5232       end Set_Flag97;
5233
5234       procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
5235       begin
5236          pragma Assert (Nkind (N) in N_Entity);
5237          To_Flag_Word2_Ptr
5238            (Union_Id_Ptr'
5239              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
5240       end Set_Flag98;
5241
5242       procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
5243       begin
5244          pragma Assert (Nkind (N) in N_Entity);
5245          To_Flag_Word2_Ptr
5246            (Union_Id_Ptr'
5247              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
5248       end Set_Flag99;
5249
5250       procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
5251       begin
5252          pragma Assert (Nkind (N) in N_Entity);
5253          To_Flag_Word2_Ptr
5254            (Union_Id_Ptr'
5255              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
5256       end Set_Flag100;
5257
5258       procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
5259       begin
5260          pragma Assert (Nkind (N) in N_Entity);
5261          To_Flag_Word2_Ptr
5262            (Union_Id_Ptr'
5263              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
5264       end Set_Flag101;
5265
5266       procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
5267       begin
5268          pragma Assert (Nkind (N) in N_Entity);
5269          To_Flag_Word2_Ptr
5270            (Union_Id_Ptr'
5271              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
5272       end Set_Flag102;
5273
5274       procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
5275       begin
5276          pragma Assert (Nkind (N) in N_Entity);
5277          To_Flag_Word2_Ptr
5278            (Union_Id_Ptr'
5279              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
5280       end Set_Flag103;
5281
5282       procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
5283       begin
5284          pragma Assert (Nkind (N) in N_Entity);
5285          To_Flag_Word2_Ptr
5286            (Union_Id_Ptr'
5287              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
5288       end Set_Flag104;
5289
5290       procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
5291       begin
5292          pragma Assert (Nkind (N) in N_Entity);
5293          To_Flag_Word2_Ptr
5294            (Union_Id_Ptr'
5295              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
5296       end Set_Flag105;
5297
5298       procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
5299       begin
5300          pragma Assert (Nkind (N) in N_Entity);
5301          To_Flag_Word2_Ptr
5302            (Union_Id_Ptr'
5303              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
5304       end Set_Flag106;
5305
5306       procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
5307       begin
5308          pragma Assert (Nkind (N) in N_Entity);
5309          To_Flag_Word2_Ptr
5310            (Union_Id_Ptr'
5311              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
5312       end Set_Flag107;
5313
5314       procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
5315       begin
5316          pragma Assert (Nkind (N) in N_Entity);
5317          To_Flag_Word2_Ptr
5318            (Union_Id_Ptr'
5319              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
5320       end Set_Flag108;
5321
5322       procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
5323       begin
5324          pragma Assert (Nkind (N) in N_Entity);
5325          To_Flag_Word2_Ptr
5326            (Union_Id_Ptr'
5327              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
5328       end Set_Flag109;
5329
5330       procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
5331       begin
5332          pragma Assert (Nkind (N) in N_Entity);
5333          To_Flag_Word2_Ptr
5334            (Union_Id_Ptr'
5335              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
5336       end Set_Flag110;
5337
5338       procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
5339       begin
5340          pragma Assert (Nkind (N) in N_Entity);
5341          To_Flag_Word2_Ptr
5342            (Union_Id_Ptr'
5343              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
5344       end Set_Flag111;
5345
5346       procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
5347       begin
5348          pragma Assert (Nkind (N) in N_Entity);
5349          To_Flag_Word2_Ptr
5350            (Union_Id_Ptr'
5351              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
5352       end Set_Flag112;
5353
5354       procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
5355       begin
5356          pragma Assert (Nkind (N) in N_Entity);
5357          To_Flag_Word2_Ptr
5358            (Union_Id_Ptr'
5359              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
5360       end Set_Flag113;
5361
5362       procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
5363       begin
5364          pragma Assert (Nkind (N) in N_Entity);
5365          To_Flag_Word2_Ptr
5366            (Union_Id_Ptr'
5367              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
5368       end Set_Flag114;
5369
5370       procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
5371       begin
5372          pragma Assert (Nkind (N) in N_Entity);
5373          To_Flag_Word2_Ptr
5374            (Union_Id_Ptr'
5375              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
5376       end Set_Flag115;
5377
5378       procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
5379       begin
5380          pragma Assert (Nkind (N) in N_Entity);
5381          To_Flag_Word2_Ptr
5382            (Union_Id_Ptr'
5383              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
5384       end Set_Flag116;
5385
5386       procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
5387       begin
5388          pragma Assert (Nkind (N) in N_Entity);
5389          To_Flag_Word2_Ptr
5390            (Union_Id_Ptr'
5391              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
5392       end Set_Flag117;
5393
5394       procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
5395       begin
5396          pragma Assert (Nkind (N) in N_Entity);
5397          To_Flag_Word2_Ptr
5398            (Union_Id_Ptr'
5399              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
5400       end Set_Flag118;
5401
5402       procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
5403       begin
5404          pragma Assert (Nkind (N) in N_Entity);
5405          To_Flag_Word2_Ptr
5406            (Union_Id_Ptr'
5407              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
5408       end Set_Flag119;
5409
5410       procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
5411       begin
5412          pragma Assert (Nkind (N) in N_Entity);
5413          To_Flag_Word2_Ptr
5414            (Union_Id_Ptr'
5415              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
5416       end Set_Flag120;
5417
5418       procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
5419       begin
5420          pragma Assert (Nkind (N) in N_Entity);
5421          To_Flag_Word2_Ptr
5422            (Union_Id_Ptr'
5423              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
5424       end Set_Flag121;
5425
5426       procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
5427       begin
5428          pragma Assert (Nkind (N) in N_Entity);
5429          To_Flag_Word2_Ptr
5430            (Union_Id_Ptr'
5431              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
5432       end Set_Flag122;
5433
5434       procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
5435       begin
5436          pragma Assert (Nkind (N) in N_Entity);
5437          To_Flag_Word2_Ptr
5438            (Union_Id_Ptr'
5439              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
5440       end Set_Flag123;
5441
5442       procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
5443       begin
5444          pragma Assert (Nkind (N) in N_Entity);
5445          To_Flag_Word2_Ptr
5446            (Union_Id_Ptr'
5447              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
5448       end Set_Flag124;
5449
5450       procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
5451       begin
5452          pragma Assert (Nkind (N) in N_Entity);
5453          To_Flag_Word2_Ptr
5454            (Union_Id_Ptr'
5455              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
5456       end Set_Flag125;
5457
5458       procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
5459       begin
5460          pragma Assert (Nkind (N) in N_Entity);
5461          To_Flag_Word2_Ptr
5462            (Union_Id_Ptr'
5463              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
5464       end Set_Flag126;
5465
5466       procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
5467       begin
5468          pragma Assert (Nkind (N) in N_Entity);
5469          To_Flag_Word2_Ptr
5470            (Union_Id_Ptr'
5471              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
5472       end Set_Flag127;
5473
5474       procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
5475       begin
5476          pragma Assert (Nkind (N) in N_Entity);
5477          To_Flag_Word2_Ptr
5478            (Union_Id_Ptr'
5479              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
5480       end Set_Flag128;
5481
5482       procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
5483       begin
5484          pragma Assert (Nkind (N) in N_Entity);
5485          Nodes.Table (N + 3).In_List := Val;
5486       end Set_Flag129;
5487
5488       procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
5489       begin
5490          pragma Assert (Nkind (N) in N_Entity);
5491          Nodes.Table (N + 3).Unused_1 := Val;
5492       end Set_Flag130;
5493
5494       procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
5495       begin
5496          pragma Assert (Nkind (N) in N_Entity);
5497          Nodes.Table (N + 3).Rewrite_Ins := Val;
5498       end Set_Flag131;
5499
5500       procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
5501       begin
5502          pragma Assert (Nkind (N) in N_Entity);
5503          Nodes.Table (N + 3).Analyzed := Val;
5504       end Set_Flag132;
5505
5506       procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
5507       begin
5508          pragma Assert (Nkind (N) in N_Entity);
5509          Nodes.Table (N + 3).Comes_From_Source := Val;
5510       end Set_Flag133;
5511
5512       procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
5513       begin
5514          pragma Assert (Nkind (N) in N_Entity);
5515          Nodes.Table (N + 3).Error_Posted := Val;
5516       end Set_Flag134;
5517
5518       procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
5519       begin
5520          pragma Assert (Nkind (N) in N_Entity);
5521          Nodes.Table (N + 3).Flag4 := Val;
5522       end Set_Flag135;
5523
5524       procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
5525       begin
5526          pragma Assert (Nkind (N) in N_Entity);
5527          Nodes.Table (N + 3).Flag5 := Val;
5528       end Set_Flag136;
5529
5530       procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
5531       begin
5532          pragma Assert (Nkind (N) in N_Entity);
5533          Nodes.Table (N + 3).Flag6 := Val;
5534       end Set_Flag137;
5535
5536       procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
5537       begin
5538          pragma Assert (Nkind (N) in N_Entity);
5539          Nodes.Table (N + 3).Flag7 := Val;
5540       end Set_Flag138;
5541
5542       procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
5543       begin
5544          pragma Assert (Nkind (N) in N_Entity);
5545          Nodes.Table (N + 3).Flag8 := Val;
5546       end Set_Flag139;
5547
5548       procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
5549       begin
5550          pragma Assert (Nkind (N) in N_Entity);
5551          Nodes.Table (N + 3).Flag9 := Val;
5552       end Set_Flag140;
5553
5554       procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
5555       begin
5556          pragma Assert (Nkind (N) in N_Entity);
5557          Nodes.Table (N + 3).Flag10 := Val;
5558       end Set_Flag141;
5559
5560       procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
5561       begin
5562          pragma Assert (Nkind (N) in N_Entity);
5563          Nodes.Table (N + 3).Flag11 := Val;
5564       end Set_Flag142;
5565
5566       procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
5567       begin
5568          pragma Assert (Nkind (N) in N_Entity);
5569          Nodes.Table (N + 3).Flag12 := Val;
5570       end Set_Flag143;
5571
5572       procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
5573       begin
5574          pragma Assert (Nkind (N) in N_Entity);
5575          Nodes.Table (N + 3).Flag13 := Val;
5576       end Set_Flag144;
5577
5578       procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
5579       begin
5580          pragma Assert (Nkind (N) in N_Entity);
5581          Nodes.Table (N + 3).Flag14 := Val;
5582       end Set_Flag145;
5583
5584       procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
5585       begin
5586          pragma Assert (Nkind (N) in N_Entity);
5587          Nodes.Table (N + 3).Flag15 := Val;
5588       end Set_Flag146;
5589
5590       procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
5591       begin
5592          pragma Assert (Nkind (N) in N_Entity);
5593          Nodes.Table (N + 3).Flag16 := Val;
5594       end Set_Flag147;
5595
5596       procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
5597       begin
5598          pragma Assert (Nkind (N) in N_Entity);
5599          Nodes.Table (N + 3).Flag17 := Val;
5600       end Set_Flag148;
5601
5602       procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
5603       begin
5604          pragma Assert (Nkind (N) in N_Entity);
5605          Nodes.Table (N + 3).Flag18 := Val;
5606       end Set_Flag149;
5607
5608       procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
5609       begin
5610          pragma Assert (Nkind (N) in N_Entity);
5611          Nodes.Table (N + 3).Pflag1 := Val;
5612       end Set_Flag150;
5613
5614       procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
5615       begin
5616          pragma Assert (Nkind (N) in N_Entity);
5617          Nodes.Table (N + 3).Pflag2 := Val;
5618       end Set_Flag151;
5619
5620       procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
5621       begin
5622          pragma Assert (Nkind (N) in N_Entity);
5623          To_Flag_Word3_Ptr
5624            (Union_Id_Ptr'
5625              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
5626       end Set_Flag152;
5627
5628       procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
5629       begin
5630          pragma Assert (Nkind (N) in N_Entity);
5631          To_Flag_Word3_Ptr
5632            (Union_Id_Ptr'
5633              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
5634       end Set_Flag153;
5635
5636       procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
5637       begin
5638          pragma Assert (Nkind (N) in N_Entity);
5639          To_Flag_Word3_Ptr
5640            (Union_Id_Ptr'
5641              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
5642       end Set_Flag154;
5643
5644       procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
5645       begin
5646          pragma Assert (Nkind (N) in N_Entity);
5647          To_Flag_Word3_Ptr
5648            (Union_Id_Ptr'
5649              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
5650       end Set_Flag155;
5651
5652       procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
5653       begin
5654          pragma Assert (Nkind (N) in N_Entity);
5655          To_Flag_Word3_Ptr
5656            (Union_Id_Ptr'
5657              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
5658       end Set_Flag156;
5659
5660       procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
5661       begin
5662          pragma Assert (Nkind (N) in N_Entity);
5663          To_Flag_Word3_Ptr
5664            (Union_Id_Ptr'
5665              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
5666       end Set_Flag157;
5667
5668       procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
5669       begin
5670          pragma Assert (Nkind (N) in N_Entity);
5671          To_Flag_Word3_Ptr
5672            (Union_Id_Ptr'
5673              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
5674       end Set_Flag158;
5675
5676       procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
5677       begin
5678          pragma Assert (Nkind (N) in N_Entity);
5679          To_Flag_Word3_Ptr
5680            (Union_Id_Ptr'
5681              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
5682       end Set_Flag159;
5683
5684       procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
5685       begin
5686          pragma Assert (Nkind (N) in N_Entity);
5687          To_Flag_Word3_Ptr
5688            (Union_Id_Ptr'
5689              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
5690       end Set_Flag160;
5691
5692       procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
5693       begin
5694          pragma Assert (Nkind (N) in N_Entity);
5695          To_Flag_Word3_Ptr
5696            (Union_Id_Ptr'
5697              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
5698       end Set_Flag161;
5699
5700       procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
5701       begin
5702          pragma Assert (Nkind (N) in N_Entity);
5703          To_Flag_Word3_Ptr
5704            (Union_Id_Ptr'
5705              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
5706       end Set_Flag162;
5707
5708       procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
5709       begin
5710          pragma Assert (Nkind (N) in N_Entity);
5711          To_Flag_Word3_Ptr
5712            (Union_Id_Ptr'
5713              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
5714       end Set_Flag163;
5715
5716       procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
5717       begin
5718          pragma Assert (Nkind (N) in N_Entity);
5719          To_Flag_Word3_Ptr
5720            (Union_Id_Ptr'
5721              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
5722       end Set_Flag164;
5723
5724       procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
5725       begin
5726          pragma Assert (Nkind (N) in N_Entity);
5727          To_Flag_Word3_Ptr
5728            (Union_Id_Ptr'
5729              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
5730       end Set_Flag165;
5731
5732       procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
5733       begin
5734          pragma Assert (Nkind (N) in N_Entity);
5735          To_Flag_Word3_Ptr
5736            (Union_Id_Ptr'
5737              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
5738       end Set_Flag166;
5739
5740       procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
5741       begin
5742          pragma Assert (Nkind (N) in N_Entity);
5743          To_Flag_Word3_Ptr
5744            (Union_Id_Ptr'
5745              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
5746       end Set_Flag167;
5747
5748       procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
5749       begin
5750          pragma Assert (Nkind (N) in N_Entity);
5751          To_Flag_Word3_Ptr
5752            (Union_Id_Ptr'
5753              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
5754       end Set_Flag168;
5755
5756       procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
5757       begin
5758          pragma Assert (Nkind (N) in N_Entity);
5759          To_Flag_Word3_Ptr
5760            (Union_Id_Ptr'
5761              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
5762       end Set_Flag169;
5763
5764       procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
5765       begin
5766          pragma Assert (Nkind (N) in N_Entity);
5767          To_Flag_Word3_Ptr
5768            (Union_Id_Ptr'
5769              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
5770       end Set_Flag170;
5771
5772       procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
5773       begin
5774          pragma Assert (Nkind (N) in N_Entity);
5775          To_Flag_Word3_Ptr
5776            (Union_Id_Ptr'
5777              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
5778       end Set_Flag171;
5779
5780       procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
5781       begin
5782          pragma Assert (Nkind (N) in N_Entity);
5783          To_Flag_Word3_Ptr
5784            (Union_Id_Ptr'
5785              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
5786       end Set_Flag172;
5787
5788       procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
5789       begin
5790          pragma Assert (Nkind (N) in N_Entity);
5791          To_Flag_Word3_Ptr
5792            (Union_Id_Ptr'
5793              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
5794       end Set_Flag173;
5795
5796       procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
5797       begin
5798          pragma Assert (Nkind (N) in N_Entity);
5799          To_Flag_Word3_Ptr
5800            (Union_Id_Ptr'
5801              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
5802       end Set_Flag174;
5803
5804       procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
5805       begin
5806          pragma Assert (Nkind (N) in N_Entity);
5807          To_Flag_Word3_Ptr
5808            (Union_Id_Ptr'
5809              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
5810       end Set_Flag175;
5811
5812       procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
5813       begin
5814          pragma Assert (Nkind (N) in N_Entity);
5815          To_Flag_Word3_Ptr
5816            (Union_Id_Ptr'
5817              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
5818       end Set_Flag176;
5819
5820       procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
5821       begin
5822          pragma Assert (Nkind (N) in N_Entity);
5823          To_Flag_Word3_Ptr
5824            (Union_Id_Ptr'
5825              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
5826       end Set_Flag177;
5827
5828       procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
5829       begin
5830          pragma Assert (Nkind (N) in N_Entity);
5831          To_Flag_Word3_Ptr
5832            (Union_Id_Ptr'
5833              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
5834       end Set_Flag178;
5835
5836       procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
5837       begin
5838          pragma Assert (Nkind (N) in N_Entity);
5839          To_Flag_Word3_Ptr
5840            (Union_Id_Ptr'
5841              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
5842       end Set_Flag179;
5843
5844       procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
5845       begin
5846          pragma Assert (Nkind (N) in N_Entity);
5847          To_Flag_Word3_Ptr
5848            (Union_Id_Ptr'
5849              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
5850       end Set_Flag180;
5851
5852       procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
5853       begin
5854          pragma Assert (Nkind (N) in N_Entity);
5855          To_Flag_Word3_Ptr
5856            (Union_Id_Ptr'
5857              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
5858       end Set_Flag181;
5859
5860       procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
5861       begin
5862          pragma Assert (Nkind (N) in N_Entity);
5863          To_Flag_Word3_Ptr
5864            (Union_Id_Ptr'
5865              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
5866       end Set_Flag182;
5867
5868       procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
5869       begin
5870          pragma Assert (Nkind (N) in N_Entity);
5871          To_Flag_Word3_Ptr
5872            (Union_Id_Ptr'
5873              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
5874       end Set_Flag183;
5875
5876       procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is
5877       begin
5878          pragma Assert (N in Nodes.First .. Nodes.Last);
5879          if Val > Error then Set_Parent (Val, N); end if;
5880          Set_Node1 (N, Val);
5881       end Set_Node1_With_Parent;
5882
5883       procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is
5884       begin
5885          pragma Assert (N in Nodes.First .. Nodes.Last);
5886          if Val > Error then Set_Parent (Val, N); end if;
5887          Set_Node2 (N, Val);
5888       end Set_Node2_With_Parent;
5889
5890       procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is
5891       begin
5892          pragma Assert (N in Nodes.First .. Nodes.Last);
5893          if Val > Error then Set_Parent (Val, N); end if;
5894          Set_Node3 (N, Val);
5895       end Set_Node3_With_Parent;
5896
5897       procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is
5898       begin
5899          pragma Assert (N in Nodes.First .. Nodes.Last);
5900          if Val > Error then Set_Parent (Val, N); end if;
5901          Set_Node4 (N, Val);
5902       end Set_Node4_With_Parent;
5903
5904       procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
5905       begin
5906          pragma Assert (N in Nodes.First .. Nodes.Last);
5907          if Val > Error then Set_Parent (Val, N); end if;
5908          Set_Node5 (N, Val);
5909       end Set_Node5_With_Parent;
5910
5911       procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
5912       begin
5913          pragma Assert (N in Nodes.First .. Nodes.Last);
5914          if Val /= No_List and then Val /= Error_List then
5915             Set_Parent (Val, N);
5916          end if;
5917          Set_List1 (N, Val);
5918       end Set_List1_With_Parent;
5919
5920       procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
5921       begin
5922          pragma Assert (N in Nodes.First .. Nodes.Last);
5923          if Val /= No_List and then Val /= Error_List then
5924             Set_Parent (Val, N);
5925          end if;
5926          Set_List2 (N, Val);
5927       end Set_List2_With_Parent;
5928
5929       procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
5930       begin
5931          pragma Assert (N in Nodes.First .. Nodes.Last);
5932          if Val /= No_List and then Val /= Error_List then
5933             Set_Parent (Val, N);
5934          end if;
5935          Set_List3 (N, Val);
5936       end Set_List3_With_Parent;
5937
5938       procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
5939       begin
5940          pragma Assert (N in Nodes.First .. Nodes.Last);
5941          if Val /= No_List and then Val /= Error_List then
5942             Set_Parent (Val, N);
5943          end if;
5944          Set_List4 (N, Val);
5945       end Set_List4_With_Parent;
5946
5947       procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
5948       begin
5949          pragma Assert (N in Nodes.First .. Nodes.Last);
5950          if Val /= No_List and then Val /= Error_List then
5951             Set_Parent (Val, N);
5952          end if;
5953          Set_List5 (N, Val);
5954       end Set_List5_With_Parent;
5955
5956    end Unchecked_Access;
5957
5958 end Atree;