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