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