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