gcc/ada/atree.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                                A T R E E                                 --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2004, Free Software Foundation, Inc.         --
  10 --                                                                          --
  11 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  12 -- terms of the  GNU General Public License as published  by the Free Soft- --
  13 -- ware  Foundation;  either version 2,  or (at your option) any later ver- --
  14 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  15 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  16 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT;  see file COPYING.  If not, write --
  19 -- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
  20 -- MA 02111-1307, USA.                                                      --
  21 --                                                                          --
  22 -- As a special exception,  if other files  instantiate  generics from this --
  23 -- unit, or you link  this unit with other files  to produce an executable, --
  24 -- this  unit  does not  by itself cause  the resulting  executable  to  be --
  25 -- covered  by the  GNU  General  Public  License.  This exception does not --
  26 -- however invalidate  any other reasons why  the executable file  might be --
  27 -- covered by the  GNU Public License.                                      --
  28 --                                                                          --
  29 -- GNAT was originally developed  by the GNAT team at  New York University. --
  30 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  31 --                                                                          --
  32 ------------------------------------------------------------------------------
  33
  34 pragma Style_Checks (All_Checks);
  35 --  Turn off subprogram ordering check for this package
  36
  37 --  WARNING: There is a C version of this package. Any changes to this source
  38 --  file must be properly reflected in the C header a-atree.h (for inlined
  39 --  bodies) and the C file a-atree.c (for remaining non-inlined bodies).
  40
  41 with Debug;   use Debug;
  42 with Namet;   use Namet;
  43 with Nlists;  use Nlists;
  44 with Elists;  use Elists;
  45 with Output;  use Output;
  46 with Sinput;  use Sinput;
  47 with Tree_IO; use Tree_IO;
  48
  49 with GNAT.HTable; use GNAT.HTable;
  50
  51 package body Atree is
  52
  53    Node_Count : Nat;
  54    --  Count allocated nodes for Num_Nodes function
  55
  56    use Unchecked_Access;
  57    --  We are allowed to see these from within our own body!
  58
  59    use Atree_Private_Part;
  60    --  We are also allowed to see our private data structures!
  61
  62    function E_To_N is new Unchecked_Conversion (Entity_Kind, Node_Kind);
  63    function N_To_E is new Unchecked_Conversion (Node_Kind, Entity_Kind);
  64    --  Functions used to store Entity_Kind value in Nkind field
  65
  66    --  The following declarations are used to store flags 65-72 in the
  67    --  Nkind field of the third component of an extended (entity) node.
  68
  69    type Flag_Byte is record
  70       Flag65 : Boolean;
  71       Flag66 : Boolean;
  72       Flag67 : Boolean;
  73       Flag68 : Boolean;
  74       Flag69 : Boolean;
  75       Flag70 : Boolean;
  76       Flag71 : Boolean;
  77       Flag72 : Boolean;
  78    end record;
  79
  80    pragma Pack (Flag_Byte);
  81    for Flag_Byte'Size use 8;
  82
  83    type Flag_Byte_Ptr is access all Flag_Byte;
  84    type Node_Kind_Ptr is access all Node_Kind;
  85
  86    function To_Flag_Byte is new
  87      Unchecked_Conversion (Node_Kind, Flag_Byte);
  88
  89    function To_Flag_Byte_Ptr is new
  90      Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);
  91
  92    --  The following declarations are used to store flags 73-96 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    --  Field12 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       begin
2890          return Elist_Id (Nodes.Table (N).Field2);
2891       end Elist2;
2892
2893       function Elist3 (N : Node_Id) return Elist_Id is
2894       begin
2895          return Elist_Id (Nodes.Table (N).Field3);
2896       end Elist3;
2897
2898       function Elist4 (N : Node_Id) return Elist_Id is
2899       begin
2900          return Elist_Id (Nodes.Table (N).Field4);
2901       end Elist4;
2902
2903       function Elist8 (N : Node_Id) return Elist_Id is
2904       begin
2905          pragma Assert (Nkind (N) in N_Entity);
2906          return Elist_Id (Nodes.Table (N + 1).Field8);
2907       end Elist8;
2908
2909       function Elist13 (N : Node_Id) return Elist_Id is
2910       begin
2911          pragma Assert (Nkind (N) in N_Entity);
2912          return Elist_Id (Nodes.Table (N + 2).Field6);
2913       end Elist13;
2914
2915       function Elist15 (N : Node_Id) return Elist_Id is
2916       begin
2917          pragma Assert (Nkind (N) in N_Entity);
2918          return Elist_Id (Nodes.Table (N + 2).Field8);
2919       end Elist15;
2920
2921       function Elist16 (N : Node_Id) return Elist_Id is
2922       begin
2923          pragma Assert (Nkind (N) in N_Entity);
2924          return Elist_Id (Nodes.Table (N + 2).Field9);
2925       end Elist16;
2926
2927       function Elist18 (N : Node_Id) return Elist_Id is
2928       begin
2929          pragma Assert (Nkind (N) in N_Entity);
2930          return Elist_Id (Nodes.Table (N + 2).Field11);
2931       end Elist18;
2932
2933       function Elist21 (N : Node_Id) return Elist_Id is
2934       begin
2935          pragma Assert (Nkind (N) in N_Entity);
2936          return Elist_Id (Nodes.Table (N + 3).Field8);
2937       end Elist21;
2938
2939       function Elist23 (N : Node_Id) return Elist_Id is
2940       begin
2941          pragma Assert (Nkind (N) in N_Entity);
2942          return Elist_Id (Nodes.Table (N + 3).Field10);
2943       end Elist23;
2944
2945       function Name1 (N : Node_Id) return Name_Id is
2946       begin
2947          pragma Assert (N in Nodes.First .. Nodes.Last);
2948          return Name_Id (Nodes.Table (N).Field1);
2949       end Name1;
2950
2951       function Name2 (N : Node_Id) return Name_Id is
2952       begin
2953          pragma Assert (N in Nodes.First .. Nodes.Last);
2954          return Name_Id (Nodes.Table (N).Field2);
2955       end Name2;
2956
2957       function Str3 (N : Node_Id) return String_Id is
2958       begin
2959          pragma Assert (N in Nodes.First .. Nodes.Last);
2960          return String_Id (Nodes.Table (N).Field3);
2961       end Str3;
2962
2963       function Char_Code2 (N : Node_Id) return Char_Code is
2964       begin
2965          pragma Assert (N in Nodes.First .. Nodes.Last);
2966          return Char_Code (Nodes.Table (N).Field2 - Char_Code_Bias);
2967       end Char_Code2;
2968
2969       function Uint3 (N : Node_Id) return Uint is
2970          pragma Assert (N in Nodes.First .. Nodes.Last);
2971          U : constant Union_Id := Nodes.Table (N).Field3;
2972       begin
2973          if U = 0 then
2974             return Uint_0;
2975          else
2976             return From_Union (U);
2977          end if;
2978       end Uint3;
2979
2980       function Uint4 (N : Node_Id) return Uint is
2981          pragma Assert (N in Nodes.First .. Nodes.Last);
2982          U : constant Union_Id := Nodes.Table (N).Field4;
2983       begin
2984          if U = 0 then
2985             return Uint_0;
2986          else
2987             return From_Union (U);
2988          end if;
2989       end Uint4;
2990
2991       function Uint5 (N : Node_Id) return Uint is
2992          pragma Assert (N in Nodes.First .. Nodes.Last);
2993          U : constant Union_Id := Nodes.Table (N).Field5;
2994       begin
2995          if U = 0 then
2996             return Uint_0;
2997          else
2998             return From_Union (U);
2999          end if;
3000       end Uint5;
3001
3002       function Uint8 (N : Node_Id) return Uint is
3003          pragma Assert (Nkind (N) in N_Entity);
3004          U : constant Union_Id := Nodes.Table (N + 1).Field8;
3005
3006       begin
3007          if U = 0 then
3008             return Uint_0;
3009          else
3010             return From_Union (U);
3011          end if;
3012       end Uint8;
3013
3014       function Uint9 (N : Node_Id) return Uint is
3015          pragma Assert (Nkind (N) in N_Entity);
3016          U : constant Union_Id := Nodes.Table (N + 1).Field9;
3017       begin
3018          if U = 0 then
3019             return Uint_0;
3020          else
3021             return From_Union (U);
3022          end if;
3023       end Uint9;
3024
3025       function Uint10 (N : Node_Id) return Uint is
3026          pragma Assert (Nkind (N) in N_Entity);
3027          U : constant Union_Id := Nodes.Table (N + 1).Field10;
3028       begin
3029          if U = 0 then
3030             return Uint_0;
3031          else
3032             return From_Union (U);
3033          end if;
3034       end Uint10;
3035
3036       function Uint11 (N : Node_Id) return Uint is
3037          pragma Assert (Nkind (N) in N_Entity);
3038          U : constant Union_Id := Nodes.Table (N + 1).Field11;
3039       begin
3040          if U = 0 then
3041             return Uint_0;
3042          else
3043             return From_Union (U);
3044          end if;
3045       end Uint11;
3046
3047       function Uint12 (N : Node_Id) return Uint is
3048          pragma Assert (Nkind (N) in N_Entity);
3049          U : constant Union_Id := Nodes.Table (N + 1).Field12;
3050       begin
3051          if U = 0 then
3052             return Uint_0;
3053          else
3054             return From_Union (U);
3055          end if;
3056       end Uint12;
3057
3058       function Uint13 (N : Node_Id) return Uint is
3059          pragma Assert (Nkind (N) in N_Entity);
3060          U : constant Union_Id := Nodes.Table (N + 2).Field6;
3061       begin
3062          if U = 0 then
3063             return Uint_0;
3064          else
3065             return From_Union (U);
3066          end if;
3067       end Uint13;
3068
3069       function Uint14 (N : Node_Id) return Uint is
3070          pragma Assert (Nkind (N) in N_Entity);
3071          U : constant Union_Id := Nodes.Table (N + 2).Field7;
3072       begin
3073          if U = 0 then
3074             return Uint_0;
3075          else
3076             return From_Union (U);
3077          end if;
3078       end Uint14;
3079
3080       function Uint15 (N : Node_Id) return Uint is
3081          pragma Assert (Nkind (N) in N_Entity);
3082          U : constant Union_Id := Nodes.Table (N + 2).Field8;
3083       begin
3084          if U = 0 then
3085             return Uint_0;
3086          else
3087             return From_Union (U);
3088          end if;
3089       end Uint15;
3090
3091       function Uint16 (N : Node_Id) return Uint is
3092          pragma Assert (Nkind (N) in N_Entity);
3093          U : constant Union_Id := Nodes.Table (N + 2).Field9;
3094       begin
3095          if U = 0 then
3096             return Uint_0;
3097          else
3098             return From_Union (U);
3099          end if;
3100       end Uint16;
3101
3102       function Uint17 (N : Node_Id) return Uint is
3103          pragma Assert (Nkind (N) in N_Entity);
3104          U : constant Union_Id := Nodes.Table (N + 2).Field10;
3105       begin
3106          if U = 0 then
3107             return Uint_0;
3108          else
3109             return From_Union (U);
3110          end if;
3111       end Uint17;
3112
3113       function Uint22 (N : Node_Id) return Uint is
3114          pragma Assert (Nkind (N) in N_Entity);
3115          U : constant Union_Id := Nodes.Table (N + 3).Field9;
3116       begin
3117          if U = 0 then
3118             return Uint_0;
3119          else
3120             return From_Union (U);
3121          end if;
3122       end Uint22;
3123
3124       function Ureal3 (N : Node_Id) return Ureal is
3125       begin
3126          pragma Assert (N in Nodes.First .. Nodes.Last);
3127          return From_Union (Nodes.Table (N).Field3);
3128       end Ureal3;
3129
3130       function Ureal18 (N : Node_Id) return Ureal is
3131       begin
3132          pragma Assert (Nkind (N) in N_Entity);
3133          return From_Union (Nodes.Table (N + 2).Field11);
3134       end Ureal18;
3135
3136       function Ureal21 (N : Node_Id) return Ureal is
3137       begin
3138          pragma Assert (Nkind (N) in N_Entity);
3139          return From_Union (Nodes.Table (N + 3).Field8);
3140       end Ureal21;
3141
3142       function Flag4 (N : Node_Id) return Boolean is
3143       begin
3144          pragma Assert (N in Nodes.First .. Nodes.Last);
3145          return Nodes.Table (N).Flag4;
3146       end Flag4;
3147
3148       function Flag5 (N : Node_Id) return Boolean is
3149       begin
3150          pragma Assert (N in Nodes.First .. Nodes.Last);
3151          return Nodes.Table (N).Flag5;
3152       end Flag5;
3153
3154       function Flag6 (N : Node_Id) return Boolean is
3155       begin
3156          pragma Assert (N in Nodes.First .. Nodes.Last);
3157          return Nodes.Table (N).Flag6;
3158       end Flag6;
3159
3160       function Flag7 (N : Node_Id) return Boolean is
3161       begin
3162          pragma Assert (N in Nodes.First .. Nodes.Last);
3163          return Nodes.Table (N).Flag7;
3164       end Flag7;
3165
3166       function Flag8 (N : Node_Id) return Boolean is
3167       begin
3168          pragma Assert (N in Nodes.First .. Nodes.Last);
3169          return Nodes.Table (N).Flag8;
3170       end Flag8;
3171
3172       function Flag9 (N : Node_Id) return Boolean is
3173       begin
3174          pragma Assert (N in Nodes.First .. Nodes.Last);
3175          return Nodes.Table (N).Flag9;
3176       end Flag9;
3177
3178       function Flag10 (N : Node_Id) return Boolean is
3179       begin
3180          pragma Assert (N in Nodes.First .. Nodes.Last);
3181          return Nodes.Table (N).Flag10;
3182       end Flag10;
3183
3184       function Flag11 (N : Node_Id) return Boolean is
3185       begin
3186          pragma Assert (N in Nodes.First .. Nodes.Last);
3187          return Nodes.Table (N).Flag11;
3188       end Flag11;
3189
3190       function Flag12 (N : Node_Id) return Boolean is
3191       begin
3192          pragma Assert (N in Nodes.First .. Nodes.Last);
3193          return Nodes.Table (N).Flag12;
3194       end Flag12;
3195
3196       function Flag13 (N : Node_Id) return Boolean is
3197       begin
3198          pragma Assert (N in Nodes.First .. Nodes.Last);
3199          return Nodes.Table (N).Flag13;
3200       end Flag13;
3201
3202       function Flag14 (N : Node_Id) return Boolean is
3203       begin
3204          pragma Assert (N in Nodes.First .. Nodes.Last);
3205          return Nodes.Table (N).Flag14;
3206       end Flag14;
3207
3208       function Flag15 (N : Node_Id) return Boolean is
3209       begin
3210          pragma Assert (N in Nodes.First .. Nodes.Last);
3211          return Nodes.Table (N).Flag15;
3212       end Flag15;
3213
3214       function Flag16 (N : Node_Id) return Boolean is
3215       begin
3216          pragma Assert (N in Nodes.First .. Nodes.Last);
3217          return Nodes.Table (N).Flag16;
3218       end Flag16;
3219
3220       function Flag17 (N : Node_Id) return Boolean is
3221       begin
3222          pragma Assert (N in Nodes.First .. Nodes.Last);
3223          return Nodes.Table (N).Flag17;
3224       end Flag17;
3225
3226       function Flag18 (N : Node_Id) return Boolean is
3227       begin
3228          pragma Assert (N in Nodes.First .. Nodes.Last);
3229          return Nodes.Table (N).Flag18;
3230       end Flag18;
3231
3232       function Flag19 (N : Node_Id) return Boolean is
3233       begin
3234          pragma Assert (Nkind (N) in N_Entity);
3235          return Nodes.Table (N + 1).In_List;
3236       end Flag19;
3237
3238       function Flag20 (N : Node_Id) return Boolean is
3239       begin
3240          pragma Assert (Nkind (N) in N_Entity);
3241          return Nodes.Table (N + 1).Unused_1;
3242       end Flag20;
3243
3244       function Flag21 (N : Node_Id) return Boolean is
3245       begin
3246          pragma Assert (Nkind (N) in N_Entity);
3247          return Nodes.Table (N + 1).Rewrite_Ins;
3248       end Flag21;
3249
3250       function Flag22 (N : Node_Id) return Boolean is
3251       begin
3252          pragma Assert (Nkind (N) in N_Entity);
3253          return Nodes.Table (N + 1).Analyzed;
3254       end Flag22;
3255
3256       function Flag23 (N : Node_Id) return Boolean is
3257       begin
3258          pragma Assert (Nkind (N) in N_Entity);
3259          return Nodes.Table (N + 1).Comes_From_Source;
3260       end Flag23;
3261
3262       function Flag24 (N : Node_Id) return Boolean is
3263       begin
3264          pragma Assert (Nkind (N) in N_Entity);
3265          return Nodes.Table (N + 1).Error_Posted;
3266       end Flag24;
3267
3268       function Flag25 (N : Node_Id) return Boolean is
3269       begin
3270          pragma Assert (Nkind (N) in N_Entity);
3271          return Nodes.Table (N + 1).Flag4;
3272       end Flag25;
3273
3274       function Flag26 (N : Node_Id) return Boolean is
3275       begin
3276          pragma Assert (Nkind (N) in N_Entity);
3277          return Nodes.Table (N + 1).Flag5;
3278       end Flag26;
3279
3280       function Flag27 (N : Node_Id) return Boolean is
3281       begin
3282          pragma Assert (Nkind (N) in N_Entity);
3283          return Nodes.Table (N + 1).Flag6;
3284       end Flag27;
3285
3286       function Flag28 (N : Node_Id) return Boolean is
3287       begin
3288          pragma Assert (Nkind (N) in N_Entity);
3289          return Nodes.Table (N + 1).Flag7;
3290       end Flag28;
3291
3292       function Flag29 (N : Node_Id) return Boolean is
3293       begin
3294          pragma Assert (Nkind (N) in N_Entity);
3295          return Nodes.Table (N + 1).Flag8;
3296       end Flag29;
3297
3298       function Flag30 (N : Node_Id) return Boolean is
3299       begin
3300          pragma Assert (Nkind (N) in N_Entity);
3301          return Nodes.Table (N + 1).Flag9;
3302       end Flag30;
3303
3304       function Flag31 (N : Node_Id) return Boolean is
3305       begin
3306          pragma Assert (Nkind (N) in N_Entity);
3307          return Nodes.Table (N + 1).Flag10;
3308       end Flag31;
3309
3310       function Flag32 (N : Node_Id) return Boolean is
3311       begin
3312          pragma Assert (Nkind (N) in N_Entity);
3313          return Nodes.Table (N + 1).Flag11;
3314       end Flag32;
3315
3316       function Flag33 (N : Node_Id) return Boolean is
3317       begin
3318          pragma Assert (Nkind (N) in N_Entity);
3319          return Nodes.Table (N + 1).Flag12;
3320       end Flag33;
3321
3322       function Flag34 (N : Node_Id) return Boolean is
3323       begin
3324          pragma Assert (Nkind (N) in N_Entity);
3325          return Nodes.Table (N + 1).Flag13;
3326       end Flag34;
3327
3328       function Flag35 (N : Node_Id) return Boolean is
3329       begin
3330          pragma Assert (Nkind (N) in N_Entity);
3331          return Nodes.Table (N + 1).Flag14;
3332       end Flag35;
3333
3334       function Flag36 (N : Node_Id) return Boolean is
3335       begin
3336          pragma Assert (Nkind (N) in N_Entity);
3337          return Nodes.Table (N + 1).Flag15;
3338       end Flag36;
3339
3340       function Flag37 (N : Node_Id) return Boolean is
3341       begin
3342          pragma Assert (Nkind (N) in N_Entity);
3343          return Nodes.Table (N + 1).Flag16;
3344       end Flag37;
3345
3346       function Flag38 (N : Node_Id) return Boolean is
3347       begin
3348          pragma Assert (Nkind (N) in N_Entity);
3349          return Nodes.Table (N + 1).Flag17;
3350       end Flag38;
3351
3352       function Flag39 (N : Node_Id) return Boolean is
3353       begin
3354          pragma Assert (Nkind (N) in N_Entity);
3355          return Nodes.Table (N + 1).Flag18;
3356       end Flag39;
3357
3358       function Flag40 (N : Node_Id) return Boolean is
3359       begin
3360          pragma Assert (Nkind (N) in N_Entity);
3361          return Nodes.Table (N + 2).In_List;
3362       end Flag40;
3363
3364       function Flag41 (N : Node_Id) return Boolean is
3365       begin
3366          pragma Assert (Nkind (N) in N_Entity);
3367          return Nodes.Table (N + 2).Unused_1;
3368       end Flag41;
3369
3370       function Flag42 (N : Node_Id) return Boolean is
3371       begin
3372          pragma Assert (Nkind (N) in N_Entity);
3373          return Nodes.Table (N + 2).Rewrite_Ins;
3374       end Flag42;
3375
3376       function Flag43 (N : Node_Id) return Boolean is
3377       begin
3378          pragma Assert (Nkind (N) in N_Entity);
3379          return Nodes.Table (N + 2).Analyzed;
3380       end Flag43;
3381
3382       function Flag44 (N : Node_Id) return Boolean is
3383       begin
3384          pragma Assert (Nkind (N) in N_Entity);
3385          return Nodes.Table (N + 2).Comes_From_Source;
3386       end Flag44;
3387
3388       function Flag45 (N : Node_Id) return Boolean is
3389       begin
3390          pragma Assert (Nkind (N) in N_Entity);
3391          return Nodes.Table (N + 2).Error_Posted;
3392       end Flag45;
3393
3394       function Flag46 (N : Node_Id) return Boolean is
3395       begin
3396          pragma Assert (Nkind (N) in N_Entity);
3397          return Nodes.Table (N + 2).Flag4;
3398       end Flag46;
3399
3400       function Flag47 (N : Node_Id) return Boolean is
3401       begin
3402          pragma Assert (Nkind (N) in N_Entity);
3403          return Nodes.Table (N + 2).Flag5;
3404       end Flag47;
3405
3406       function Flag48 (N : Node_Id) return Boolean is
3407       begin
3408          pragma Assert (Nkind (N) in N_Entity);
3409          return Nodes.Table (N + 2).Flag6;
3410       end Flag48;
3411
3412       function Flag49 (N : Node_Id) return Boolean is
3413       begin
3414          pragma Assert (Nkind (N) in N_Entity);
3415          return Nodes.Table (N + 2).Flag7;
3416       end Flag49;
3417
3418       function Flag50 (N : Node_Id) return Boolean is
3419       begin
3420          pragma Assert (Nkind (N) in N_Entity);
3421          return Nodes.Table (N + 2).Flag8;
3422       end Flag50;
3423
3424       function Flag51 (N : Node_Id) return Boolean is
3425       begin
3426          pragma Assert (Nkind (N) in N_Entity);
3427          return Nodes.Table (N + 2).Flag9;
3428       end Flag51;
3429
3430       function Flag52 (N : Node_Id) return Boolean is
3431       begin
3432          pragma Assert (Nkind (N) in N_Entity);
3433          return Nodes.Table (N + 2).Flag10;
3434       end Flag52;
3435
3436       function Flag53 (N : Node_Id) return Boolean is
3437       begin
3438          pragma Assert (Nkind (N) in N_Entity);
3439          return Nodes.Table (N + 2).Flag11;
3440       end Flag53;
3441
3442       function Flag54 (N : Node_Id) return Boolean is
3443       begin
3444          pragma Assert (Nkind (N) in N_Entity);
3445          return Nodes.Table (N + 2).Flag12;
3446       end Flag54;
3447
3448       function Flag55 (N : Node_Id) return Boolean is
3449       begin
3450          pragma Assert (Nkind (N) in N_Entity);
3451          return Nodes.Table (N + 2).Flag13;
3452       end Flag55;
3453
3454       function Flag56 (N : Node_Id) return Boolean is
3455       begin
3456          pragma Assert (Nkind (N) in N_Entity);
3457          return Nodes.Table (N + 2).Flag14;
3458       end Flag56;
3459
3460       function Flag57 (N : Node_Id) return Boolean is
3461       begin
3462          pragma Assert (Nkind (N) in N_Entity);
3463          return Nodes.Table (N + 2).Flag15;
3464       end Flag57;
3465
3466       function Flag58 (N : Node_Id) return Boolean is
3467       begin
3468          pragma Assert (Nkind (N) in N_Entity);
3469          return Nodes.Table (N + 2).Flag16;
3470       end Flag58;
3471
3472       function Flag59 (N : Node_Id) return Boolean is
3473       begin
3474          pragma Assert (Nkind (N) in N_Entity);
3475          return Nodes.Table (N + 2).Flag17;
3476       end Flag59;
3477
3478       function Flag60 (N : Node_Id) return Boolean is
3479       begin
3480          pragma Assert (Nkind (N) in N_Entity);
3481          return Nodes.Table (N + 2).Flag18;
3482       end Flag60;
3483
3484       function Flag61 (N : Node_Id) return Boolean is
3485       begin
3486          pragma Assert (Nkind (N) in N_Entity);
3487          return Nodes.Table (N + 1).Pflag1;
3488       end Flag61;
3489
3490       function Flag62 (N : Node_Id) return Boolean is
3491       begin
3492          pragma Assert (Nkind (N) in N_Entity);
3493          return Nodes.Table (N + 1).Pflag2;
3494       end Flag62;
3495
3496       function Flag63 (N : Node_Id) return Boolean is
3497       begin
3498          pragma Assert (Nkind (N) in N_Entity);
3499          return Nodes.Table (N + 2).Pflag1;
3500       end Flag63;
3501
3502       function Flag64 (N : Node_Id) return Boolean is
3503       begin
3504          pragma Assert (Nkind (N) in N_Entity);
3505          return Nodes.Table (N + 2).Pflag2;
3506       end Flag64;
3507
3508       function Flag65 (N : Node_Id) return Boolean is
3509       begin
3510          pragma Assert (Nkind (N) in N_Entity);
3511          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
3512       end Flag65;
3513
3514       function Flag66 (N : Node_Id) return Boolean is
3515       begin
3516          pragma Assert (Nkind (N) in N_Entity);
3517          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
3518       end Flag66;
3519
3520       function Flag67 (N : Node_Id) return Boolean is
3521       begin
3522          pragma Assert (Nkind (N) in N_Entity);
3523          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
3524       end Flag67;
3525
3526       function Flag68 (N : Node_Id) return Boolean is
3527       begin
3528          pragma Assert (Nkind (N) in N_Entity);
3529          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
3530       end Flag68;
3531
3532       function Flag69 (N : Node_Id) return Boolean is
3533       begin
3534          pragma Assert (Nkind (N) in N_Entity);
3535          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
3536       end Flag69;
3537
3538       function Flag70 (N : Node_Id) return Boolean is
3539       begin
3540          pragma Assert (Nkind (N) in N_Entity);
3541          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
3542       end Flag70;
3543
3544       function Flag71 (N : Node_Id) return Boolean is
3545       begin
3546          pragma Assert (Nkind (N) in N_Entity);
3547          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
3548       end Flag71;
3549
3550       function Flag72 (N : Node_Id) return Boolean is
3551       begin
3552          pragma Assert (Nkind (N) in N_Entity);
3553          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
3554       end Flag72;
3555
3556       function Flag73 (N : Node_Id) return Boolean is
3557       begin
3558          pragma Assert (Nkind (N) in N_Entity);
3559          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
3560       end Flag73;
3561
3562       function Flag74 (N : Node_Id) return Boolean is
3563       begin
3564          pragma Assert (Nkind (N) in N_Entity);
3565          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
3566       end Flag74;
3567
3568       function Flag75 (N : Node_Id) return Boolean is
3569       begin
3570          pragma Assert (Nkind (N) in N_Entity);
3571          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
3572       end Flag75;
3573
3574       function Flag76 (N : Node_Id) return Boolean is
3575       begin
3576          pragma Assert (Nkind (N) in N_Entity);
3577          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
3578       end Flag76;
3579
3580       function Flag77 (N : Node_Id) return Boolean is
3581       begin
3582          pragma Assert (Nkind (N) in N_Entity);
3583          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
3584       end Flag77;
3585
3586       function Flag78 (N : Node_Id) return Boolean is
3587       begin
3588          pragma Assert (Nkind (N) in N_Entity);
3589          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
3590       end Flag78;
3591
3592       function Flag79 (N : Node_Id) return Boolean is
3593       begin
3594          pragma Assert (Nkind (N) in N_Entity);
3595          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
3596       end Flag79;
3597
3598       function Flag80 (N : Node_Id) return Boolean is
3599       begin
3600          pragma Assert (Nkind (N) in N_Entity);
3601          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
3602       end Flag80;
3603
3604       function Flag81 (N : Node_Id) return Boolean is
3605       begin
3606          pragma Assert (Nkind (N) in N_Entity);
3607          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
3608       end Flag81;
3609
3610       function Flag82 (N : Node_Id) return Boolean is
3611       begin
3612          pragma Assert (Nkind (N) in N_Entity);
3613          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
3614       end Flag82;
3615
3616       function Flag83 (N : Node_Id) return Boolean is
3617       begin
3618          pragma Assert (Nkind (N) in N_Entity);
3619          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
3620       end Flag83;
3621
3622       function Flag84 (N : Node_Id) return Boolean is
3623       begin
3624          pragma Assert (Nkind (N) in N_Entity);
3625          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
3626       end Flag84;
3627
3628       function Flag85 (N : Node_Id) return Boolean is
3629       begin
3630          pragma Assert (Nkind (N) in N_Entity);
3631          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
3632       end Flag85;
3633
3634       function Flag86 (N : Node_Id) return Boolean is
3635       begin
3636          pragma Assert (Nkind (N) in N_Entity);
3637          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
3638       end Flag86;
3639
3640       function Flag87 (N : Node_Id) return Boolean is
3641       begin
3642          pragma Assert (Nkind (N) in N_Entity);
3643          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
3644       end Flag87;
3645
3646       function Flag88 (N : Node_Id) return Boolean is
3647       begin
3648          pragma Assert (Nkind (N) in N_Entity);
3649          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
3650       end Flag88;
3651
3652       function Flag89 (N : Node_Id) return Boolean is
3653       begin
3654          pragma Assert (Nkind (N) in N_Entity);
3655          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
3656       end Flag89;
3657
3658       function Flag90 (N : Node_Id) return Boolean is
3659       begin
3660          pragma Assert (Nkind (N) in N_Entity);
3661          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
3662       end Flag90;
3663
3664       function Flag91 (N : Node_Id) return Boolean is
3665       begin
3666          pragma Assert (Nkind (N) in N_Entity);
3667          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
3668       end Flag91;
3669
3670       function Flag92 (N : Node_Id) return Boolean is
3671       begin
3672          pragma Assert (Nkind (N) in N_Entity);
3673          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
3674       end Flag92;
3675
3676       function Flag93 (N : Node_Id) return Boolean is
3677       begin
3678          pragma Assert (Nkind (N) in N_Entity);
3679          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
3680       end Flag93;
3681
3682       function Flag94 (N : Node_Id) return Boolean is
3683       begin
3684          pragma Assert (Nkind (N) in N_Entity);
3685          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
3686       end Flag94;
3687
3688       function Flag95 (N : Node_Id) return Boolean is
3689       begin
3690          pragma Assert (Nkind (N) in N_Entity);
3691          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
3692       end Flag95;
3693
3694       function Flag96 (N : Node_Id) return Boolean is
3695       begin
3696          pragma Assert (Nkind (N) in N_Entity);
3697          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
3698       end Flag96;
3699
3700       function Flag97 (N : Node_Id) return Boolean is
3701       begin
3702          pragma Assert (Nkind (N) in N_Entity);
3703          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
3704       end Flag97;
3705
3706       function Flag98 (N : Node_Id) return Boolean is
3707       begin
3708          pragma Assert (Nkind (N) in N_Entity);
3709          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
3710       end Flag98;
3711
3712       function Flag99 (N : Node_Id) return Boolean is
3713       begin
3714          pragma Assert (Nkind (N) in N_Entity);
3715          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
3716       end Flag99;
3717
3718       function Flag100 (N : Node_Id) return Boolean is
3719       begin
3720          pragma Assert (Nkind (N) in N_Entity);
3721          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
3722       end Flag100;
3723
3724       function Flag101 (N : Node_Id) return Boolean is
3725       begin
3726          pragma Assert (Nkind (N) in N_Entity);
3727          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
3728       end Flag101;
3729
3730       function Flag102 (N : Node_Id) return Boolean is
3731       begin
3732          pragma Assert (Nkind (N) in N_Entity);
3733          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
3734       end Flag102;
3735
3736       function Flag103 (N : Node_Id) return Boolean is
3737       begin
3738          pragma Assert (Nkind (N) in N_Entity);
3739          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
3740       end Flag103;
3741
3742       function Flag104 (N : Node_Id) return Boolean is
3743       begin
3744          pragma Assert (Nkind (N) in N_Entity);
3745          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
3746       end Flag104;
3747
3748       function Flag105 (N : Node_Id) return Boolean is
3749       begin
3750          pragma Assert (Nkind (N) in N_Entity);
3751          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
3752       end Flag105;
3753
3754       function Flag106 (N : Node_Id) return Boolean is
3755       begin
3756          pragma Assert (Nkind (N) in N_Entity);
3757          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
3758       end Flag106;
3759
3760       function Flag107 (N : Node_Id) return Boolean is
3761       begin
3762          pragma Assert (Nkind (N) in N_Entity);
3763          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
3764       end Flag107;
3765
3766       function Flag108 (N : Node_Id) return Boolean is
3767       begin
3768          pragma Assert (Nkind (N) in N_Entity);
3769          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
3770       end Flag108;
3771
3772       function Flag109 (N : Node_Id) return Boolean is
3773       begin
3774          pragma Assert (Nkind (N) in N_Entity);
3775          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
3776       end Flag109;
3777
3778       function Flag110 (N : Node_Id) return Boolean is
3779       begin
3780          pragma Assert (Nkind (N) in N_Entity);
3781          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
3782       end Flag110;
3783
3784       function Flag111 (N : Node_Id) return Boolean is
3785       begin
3786          pragma Assert (Nkind (N) in N_Entity);
3787          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
3788       end Flag111;
3789
3790       function Flag112 (N : Node_Id) return Boolean is
3791       begin
3792          pragma Assert (Nkind (N) in N_Entity);
3793          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
3794       end Flag112;
3795
3796       function Flag113 (N : Node_Id) return Boolean is
3797       begin
3798          pragma Assert (Nkind (N) in N_Entity);
3799          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
3800       end Flag113;
3801
3802       function Flag114 (N : Node_Id) return Boolean is
3803       begin
3804          pragma Assert (Nkind (N) in N_Entity);
3805          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
3806       end Flag114;
3807
3808       function Flag115 (N : Node_Id) return Boolean is
3809       begin
3810          pragma Assert (Nkind (N) in N_Entity);
3811          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
3812       end Flag115;
3813
3814       function Flag116 (N : Node_Id) return Boolean is
3815       begin
3816          pragma Assert (Nkind (N) in N_Entity);
3817          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
3818       end Flag116;
3819
3820       function Flag117 (N : Node_Id) return Boolean is
3821       begin
3822          pragma Assert (Nkind (N) in N_Entity);
3823          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
3824       end Flag117;
3825
3826       function Flag118 (N : Node_Id) return Boolean is
3827       begin
3828          pragma Assert (Nkind (N) in N_Entity);
3829          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
3830       end Flag118;
3831
3832       function Flag119 (N : Node_Id) return Boolean is
3833       begin
3834          pragma Assert (Nkind (N) in N_Entity);
3835          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
3836       end Flag119;
3837
3838       function Flag120 (N : Node_Id) return Boolean is
3839       begin
3840          pragma Assert (Nkind (N) in N_Entity);
3841          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
3842       end Flag120;
3843
3844       function Flag121 (N : Node_Id) return Boolean is
3845       begin
3846          pragma Assert (Nkind (N) in N_Entity);
3847          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
3848       end Flag121;
3849
3850       function Flag122 (N : Node_Id) return Boolean is
3851       begin
3852          pragma Assert (Nkind (N) in N_Entity);
3853          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
3854       end Flag122;
3855
3856       function Flag123 (N : Node_Id) return Boolean is
3857       begin
3858          pragma Assert (Nkind (N) in N_Entity);
3859          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
3860       end Flag123;
3861
3862       function Flag124 (N : Node_Id) return Boolean is
3863       begin
3864          pragma Assert (Nkind (N) in N_Entity);
3865          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
3866       end Flag124;
3867
3868       function Flag125 (N : Node_Id) return Boolean is
3869       begin
3870          pragma Assert (Nkind (N) in N_Entity);
3871          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
3872       end Flag125;
3873
3874       function Flag126 (N : Node_Id) return Boolean is
3875       begin
3876          pragma Assert (Nkind (N) in N_Entity);
3877          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
3878       end Flag126;
3879
3880       function Flag127 (N : Node_Id) return Boolean is
3881       begin
3882          pragma Assert (Nkind (N) in N_Entity);
3883          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
3884       end Flag127;
3885
3886       function Flag128 (N : Node_Id) return Boolean is
3887       begin
3888          pragma Assert (Nkind (N) in N_Entity);
3889          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
3890       end Flag128;
3891
3892       function Flag129 (N : Node_Id) return Boolean is
3893       begin
3894          pragma Assert (Nkind (N) in N_Entity);
3895          return Nodes.Table (N + 3).In_List;
3896       end Flag129;
3897
3898       function Flag130 (N : Node_Id) return Boolean is
3899       begin
3900          pragma Assert (Nkind (N) in N_Entity);
3901          return Nodes.Table (N + 3).Unused_1;
3902       end Flag130;
3903
3904       function Flag131 (N : Node_Id) return Boolean is
3905       begin
3906          pragma Assert (Nkind (N) in N_Entity);
3907          return Nodes.Table (N + 3).Rewrite_Ins;
3908       end Flag131;
3909
3910       function Flag132 (N : Node_Id) return Boolean is
3911       begin
3912          pragma Assert (Nkind (N) in N_Entity);
3913          return Nodes.Table (N + 3).Analyzed;
3914       end Flag132;
3915
3916       function Flag133 (N : Node_Id) return Boolean is
3917       begin
3918          pragma Assert (Nkind (N) in N_Entity);
3919          return Nodes.Table (N + 3).Comes_From_Source;
3920       end Flag133;
3921
3922       function Flag134 (N : Node_Id) return Boolean is
3923       begin
3924          pragma Assert (Nkind (N) in N_Entity);
3925          return Nodes.Table (N + 3).Error_Posted;
3926       end Flag134;
3927
3928       function Flag135 (N : Node_Id) return Boolean is
3929       begin
3930          pragma Assert (Nkind (N) in N_Entity);
3931          return Nodes.Table (N + 3).Flag4;
3932       end Flag135;
3933
3934       function Flag136 (N : Node_Id) return Boolean is
3935       begin
3936          pragma Assert (Nkind (N) in N_Entity);
3937          return Nodes.Table (N + 3).Flag5;
3938       end Flag136;
3939
3940       function Flag137 (N : Node_Id) return Boolean is
3941       begin
3942          pragma Assert (Nkind (N) in N_Entity);
3943          return Nodes.Table (N + 3).Flag6;
3944       end Flag137;
3945
3946       function Flag138 (N : Node_Id) return Boolean is
3947       begin
3948          pragma Assert (Nkind (N) in N_Entity);
3949          return Nodes.Table (N + 3).Flag7;
3950       end Flag138;
3951
3952       function Flag139 (N : Node_Id) return Boolean is
3953       begin
3954          pragma Assert (Nkind (N) in N_Entity);
3955          return Nodes.Table (N + 3).Flag8;
3956       end Flag139;
3957
3958       function Flag140 (N : Node_Id) return Boolean is
3959       begin
3960          pragma Assert (Nkind (N) in N_Entity);
3961          return Nodes.Table (N + 3).Flag9;
3962       end Flag140;
3963
3964       function Flag141 (N : Node_Id) return Boolean is
3965       begin
3966          pragma Assert (Nkind (N) in N_Entity);
3967          return Nodes.Table (N + 3).Flag10;
3968       end Flag141;
3969
3970       function Flag142 (N : Node_Id) return Boolean is
3971       begin
3972          pragma Assert (Nkind (N) in N_Entity);
3973          return Nodes.Table (N + 3).Flag11;
3974       end Flag142;
3975
3976       function Flag143 (N : Node_Id) return Boolean is
3977       begin
3978          pragma Assert (Nkind (N) in N_Entity);
3979          return Nodes.Table (N + 3).Flag12;
3980       end Flag143;
3981
3982       function Flag144 (N : Node_Id) return Boolean is
3983       begin
3984          pragma Assert (Nkind (N) in N_Entity);
3985          return Nodes.Table (N + 3).Flag13;
3986       end Flag144;
3987
3988       function Flag145 (N : Node_Id) return Boolean is
3989       begin
3990          pragma Assert (Nkind (N) in N_Entity);
3991          return Nodes.Table (N + 3).Flag14;
3992       end Flag145;
3993
3994       function Flag146 (N : Node_Id) return Boolean is
3995       begin
3996          pragma Assert (Nkind (N) in N_Entity);
3997          return Nodes.Table (N + 3).Flag15;
3998       end Flag146;
3999
4000       function Flag147 (N : Node_Id) return Boolean is
4001       begin
4002          pragma Assert (Nkind (N) in N_Entity);
4003          return Nodes.Table (N + 3).Flag16;
4004       end Flag147;
4005
4006       function Flag148 (N : Node_Id) return Boolean is
4007       begin
4008          pragma Assert (Nkind (N) in N_Entity);
4009          return Nodes.Table (N + 3).Flag17;
4010       end Flag148;
4011
4012       function Flag149 (N : Node_Id) return Boolean is
4013       begin
4014          pragma Assert (Nkind (N) in N_Entity);
4015          return Nodes.Table (N + 3).Flag18;
4016       end Flag149;
4017
4018       function Flag150 (N : Node_Id) return Boolean is
4019       begin
4020          pragma Assert (Nkind (N) in N_Entity);
4021          return Nodes.Table (N + 3).Pflag1;
4022       end Flag150;
4023
4024       function Flag151 (N : Node_Id) return Boolean is
4025       begin
4026          pragma Assert (Nkind (N) in N_Entity);
4027          return Nodes.Table (N + 3).Pflag2;
4028       end Flag151;
4029
4030       function Flag152 (N : Node_Id) return Boolean is
4031       begin
4032          pragma Assert (Nkind (N) in N_Entity);
4033          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
4034       end Flag152;
4035
4036       function Flag153 (N : Node_Id) return Boolean is
4037       begin
4038          pragma Assert (Nkind (N) in N_Entity);
4039          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
4040       end Flag153;
4041
4042       function Flag154 (N : Node_Id) return Boolean is
4043       begin
4044          pragma Assert (Nkind (N) in N_Entity);
4045          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
4046       end Flag154;
4047
4048       function Flag155 (N : Node_Id) return Boolean is
4049       begin
4050          pragma Assert (Nkind (N) in N_Entity);
4051          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
4052       end Flag155;
4053
4054       function Flag156 (N : Node_Id) return Boolean is
4055       begin
4056          pragma Assert (Nkind (N) in N_Entity);
4057          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
4058       end Flag156;
4059
4060       function Flag157 (N : Node_Id) return Boolean is
4061       begin
4062          pragma Assert (Nkind (N) in N_Entity);
4063          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
4064       end Flag157;
4065
4066       function Flag158 (N : Node_Id) return Boolean is
4067       begin
4068          pragma Assert (Nkind (N) in N_Entity);
4069          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
4070       end Flag158;
4071
4072       function Flag159 (N : Node_Id) return Boolean is
4073       begin
4074          pragma Assert (Nkind (N) in N_Entity);
4075          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
4076       end Flag159;
4077
4078       function Flag160 (N : Node_Id) return Boolean is
4079       begin
4080          pragma Assert (Nkind (N) in N_Entity);
4081          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
4082       end Flag160;
4083
4084       function Flag161 (N : Node_Id) return Boolean is
4085       begin
4086          pragma Assert (Nkind (N) in N_Entity);
4087          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
4088       end Flag161;
4089
4090       function Flag162 (N : Node_Id) return Boolean is
4091       begin
4092          pragma Assert (Nkind (N) in N_Entity);
4093          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
4094       end Flag162;
4095
4096       function Flag163 (N : Node_Id) return Boolean is
4097       begin
4098          pragma Assert (Nkind (N) in N_Entity);
4099          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
4100       end Flag163;
4101
4102       function Flag164 (N : Node_Id) return Boolean is
4103       begin
4104          pragma Assert (Nkind (N) in N_Entity);
4105          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
4106       end Flag164;
4107
4108       function Flag165 (N : Node_Id) return Boolean is
4109       begin
4110          pragma Assert (Nkind (N) in N_Entity);
4111          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
4112       end Flag165;
4113
4114       function Flag166 (N : Node_Id) return Boolean is
4115       begin
4116          pragma Assert (Nkind (N) in N_Entity);
4117          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
4118       end Flag166;
4119
4120       function Flag167 (N : Node_Id) return Boolean is
4121       begin
4122          pragma Assert (Nkind (N) in N_Entity);
4123          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
4124       end Flag167;
4125
4126       function Flag168 (N : Node_Id) return Boolean is
4127       begin
4128          pragma Assert (Nkind (N) in N_Entity);
4129          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
4130       end Flag168;
4131
4132       function Flag169 (N : Node_Id) return Boolean is
4133       begin
4134          pragma Assert (Nkind (N) in N_Entity);
4135          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
4136       end Flag169;
4137
4138       function Flag170 (N : Node_Id) return Boolean is
4139       begin
4140          pragma Assert (Nkind (N) in N_Entity);
4141          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
4142       end Flag170;
4143
4144       function Flag171 (N : Node_Id) return Boolean is
4145       begin
4146          pragma Assert (Nkind (N) in N_Entity);
4147          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
4148       end Flag171;
4149
4150       function Flag172 (N : Node_Id) return Boolean is
4151       begin
4152          pragma Assert (Nkind (N) in N_Entity);
4153          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
4154       end Flag172;
4155
4156       function Flag173 (N : Node_Id) return Boolean is
4157       begin
4158          pragma Assert (Nkind (N) in N_Entity);
4159          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
4160       end Flag173;
4161
4162       function Flag174 (N : Node_Id) return Boolean is
4163       begin
4164          pragma Assert (Nkind (N) in N_Entity);
4165          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
4166       end Flag174;
4167
4168       function Flag175 (N : Node_Id) return Boolean is
4169       begin
4170          pragma Assert (Nkind (N) in N_Entity);
4171          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
4172       end Flag175;
4173
4174       function Flag176 (N : Node_Id) return Boolean is
4175       begin
4176          pragma Assert (Nkind (N) in N_Entity);
4177          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
4178       end Flag176;
4179
4180       function Flag177 (N : Node_Id) return Boolean is
4181       begin
4182          pragma Assert (Nkind (N) in N_Entity);
4183          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
4184       end Flag177;
4185
4186       function Flag178 (N : Node_Id) return Boolean is
4187       begin
4188          pragma Assert (Nkind (N) in N_Entity);
4189          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
4190       end Flag178;
4191
4192       function Flag179 (N : Node_Id) return Boolean is
4193       begin
4194          pragma Assert (Nkind (N) in N_Entity);
4195          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
4196       end Flag179;
4197
4198       function Flag180 (N : Node_Id) return Boolean is
4199       begin
4200          pragma Assert (Nkind (N) in N_Entity);
4201          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
4202       end Flag180;
4203
4204       function Flag181 (N : Node_Id) return Boolean is
4205       begin
4206          pragma Assert (Nkind (N) in N_Entity);
4207          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
4208       end Flag181;
4209
4210       function Flag182 (N : Node_Id) return Boolean is
4211       begin
4212          pragma Assert (Nkind (N) in N_Entity);
4213          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
4214       end Flag182;
4215
4216       function Flag183 (N : Node_Id) return Boolean is
4217       begin
4218          pragma Assert (Nkind (N) in N_Entity);
4219          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
4220       end Flag183;
4221
4222       function Flag184 (N : Node_Id) return Boolean is
4223       begin
4224          pragma Assert (Nkind (N) in N_Entity);
4225          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag184;
4226       end Flag184;
4227
4228       function Flag185 (N : Node_Id) return Boolean is
4229       begin
4230          pragma Assert (Nkind (N) in N_Entity);
4231          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag185;
4232       end Flag185;
4233
4234       function Flag186 (N : Node_Id) return Boolean is
4235       begin
4236          pragma Assert (Nkind (N) in N_Entity);
4237          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag186;
4238       end Flag186;
4239
4240       function Flag187 (N : Node_Id) return Boolean is
4241       begin
4242          pragma Assert (Nkind (N) in N_Entity);
4243          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag187;
4244       end Flag187;
4245
4246       function Flag188 (N : Node_Id) return Boolean is
4247       begin
4248          pragma Assert (Nkind (N) in N_Entity);
4249          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag188;
4250       end Flag188;
4251
4252       function Flag189 (N : Node_Id) return Boolean is
4253       begin
4254          pragma Assert (Nkind (N) in N_Entity);
4255          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag189;
4256       end Flag189;
4257
4258       function Flag190 (N : Node_Id) return Boolean is
4259       begin
4260          pragma Assert (Nkind (N) in N_Entity);
4261          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag190;
4262       end Flag190;
4263
4264       function Flag191 (N : Node_Id) return Boolean is
4265       begin
4266          pragma Assert (Nkind (N) in N_Entity);
4267          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag191;
4268       end Flag191;
4269
4270       function Flag192 (N : Node_Id) return Boolean is
4271       begin
4272          pragma Assert (Nkind (N) in N_Entity);
4273          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag192;
4274       end Flag192;
4275
4276       function Flag193 (N : Node_Id) return Boolean is
4277       begin
4278          pragma Assert (Nkind (N) in N_Entity);
4279          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag193;
4280       end Flag193;
4281
4282       function Flag194 (N : Node_Id) return Boolean is
4283       begin
4284          pragma Assert (Nkind (N) in N_Entity);
4285          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag194;
4286       end Flag194;
4287
4288       function Flag195 (N : Node_Id) return Boolean is
4289       begin
4290          pragma Assert (Nkind (N) in N_Entity);
4291          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag195;
4292       end Flag195;
4293
4294       function Flag196 (N : Node_Id) return Boolean is
4295       begin
4296          pragma Assert (Nkind (N) in N_Entity);
4297          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag196;
4298       end Flag196;
4299
4300       function Flag197 (N : Node_Id) return Boolean is
4301       begin
4302          pragma Assert (Nkind (N) in N_Entity);
4303          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag197;
4304       end Flag197;
4305
4306       function Flag198 (N : Node_Id) return Boolean is
4307       begin
4308          pragma Assert (Nkind (N) in N_Entity);
4309          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag198;
4310       end Flag198;
4311
4312       function Flag199 (N : Node_Id) return Boolean is
4313       begin
4314          pragma Assert (Nkind (N) in N_Entity);
4315          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag199;
4316       end Flag199;
4317
4318       function Flag200 (N : Node_Id) return Boolean is
4319       begin
4320          pragma Assert (Nkind (N) in N_Entity);
4321          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag200;
4322       end Flag200;
4323
4324       function Flag201 (N : Node_Id) return Boolean is
4325       begin
4326          pragma Assert (Nkind (N) in N_Entity);
4327          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag201;
4328       end Flag201;
4329
4330       function Flag202 (N : Node_Id) return Boolean is
4331       begin
4332          pragma Assert (Nkind (N) in N_Entity);
4333          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag202;
4334       end Flag202;
4335
4336       function Flag203 (N : Node_Id) return Boolean is
4337       begin
4338          pragma Assert (Nkind (N) in N_Entity);
4339          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag203;
4340       end Flag203;
4341
4342       function Flag204 (N : Node_Id) return Boolean is
4343       begin
4344          pragma Assert (Nkind (N) in N_Entity);
4345          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag204;
4346       end Flag204;
4347
4348       function Flag205 (N : Node_Id) return Boolean is
4349       begin
4350          pragma Assert (Nkind (N) in N_Entity);
4351          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag205;
4352       end Flag205;
4353
4354       function Flag206 (N : Node_Id) return Boolean is
4355       begin
4356          pragma Assert (Nkind (N) in N_Entity);
4357          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag206;
4358       end Flag206;
4359
4360       function Flag207 (N : Node_Id) return Boolean is
4361       begin
4362          pragma Assert (Nkind (N) in N_Entity);
4363          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag207;
4364       end Flag207;
4365
4366       function Flag208 (N : Node_Id) return Boolean is
4367       begin
4368          pragma Assert (Nkind (N) in N_Entity);
4369          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag208;
4370       end Flag208;
4371
4372       function Flag209 (N : Node_Id) return Boolean is
4373       begin
4374          pragma Assert (Nkind (N) in N_Entity);
4375          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag209;
4376       end Flag209;
4377
4378       function Flag210 (N : Node_Id) return Boolean is
4379       begin
4380          pragma Assert (Nkind (N) in N_Entity);
4381          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag210;
4382       end Flag210;
4383
4384       function Flag211 (N : Node_Id) return Boolean is
4385       begin
4386          pragma Assert (Nkind (N) in N_Entity);
4387          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag211;
4388       end Flag211;
4389
4390       function Flag212 (N : Node_Id) return Boolean is
4391       begin
4392          pragma Assert (Nkind (N) in N_Entity);
4393          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag212;
4394       end Flag212;
4395
4396       function Flag213 (N : Node_Id) return Boolean is
4397       begin
4398          pragma Assert (Nkind (N) in N_Entity);
4399          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag213;
4400       end Flag213;
4401
4402       function Flag214 (N : Node_Id) return Boolean is
4403       begin
4404          pragma Assert (Nkind (N) in N_Entity);
4405          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag214;
4406       end Flag214;
4407
4408       function Flag215 (N : Node_Id) return Boolean is
4409       begin
4410          pragma Assert (Nkind (N) in N_Entity);
4411          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag215;
4412       end Flag215;
4413
4414       procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
4415       begin
4416          pragma Assert (N in Nodes.First .. Nodes.Last);
4417          Nodes.Table (N).Nkind := Val;
4418       end Set_Nkind;
4419
4420       procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
4421       begin
4422          pragma Assert (N in Nodes.First .. Nodes.Last);
4423          Nodes.Table (N).Field1 := Val;
4424       end Set_Field1;
4425
4426       procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
4427       begin
4428          pragma Assert (N in Nodes.First .. Nodes.Last);
4429          Nodes.Table (N).Field2 := Val;
4430       end Set_Field2;
4431
4432       procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
4433       begin
4434          pragma Assert (N in Nodes.First .. Nodes.Last);
4435          Nodes.Table (N).Field3 := Val;
4436       end Set_Field3;
4437
4438       procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
4439       begin
4440          pragma Assert (N in Nodes.First .. Nodes.Last);
4441          Nodes.Table (N).Field4 := Val;
4442       end Set_Field4;
4443
4444       procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
4445       begin
4446          pragma Assert (N in Nodes.First .. Nodes.Last);
4447          Nodes.Table (N).Field5 := Val;
4448       end Set_Field5;
4449
4450       procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
4451       begin
4452          pragma Assert (Nkind (N) in N_Entity);
4453          Nodes.Table (N + 1).Field6 := Val;
4454       end Set_Field6;
4455
4456       procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
4457       begin
4458          pragma Assert (Nkind (N) in N_Entity);
4459          Nodes.Table (N + 1).Field7 := Val;
4460       end Set_Field7;
4461
4462       procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
4463       begin
4464          pragma Assert (Nkind (N) in N_Entity);
4465          Nodes.Table (N + 1).Field8 := Val;
4466       end Set_Field8;
4467
4468       procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
4469       begin
4470          pragma Assert (Nkind (N) in N_Entity);
4471          Nodes.Table (N + 1).Field9 := Val;
4472       end Set_Field9;
4473
4474       procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
4475       begin
4476          pragma Assert (Nkind (N) in N_Entity);
4477          Nodes.Table (N + 1).Field10 := Val;
4478       end Set_Field10;
4479
4480       procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
4481       begin
4482          pragma Assert (Nkind (N) in N_Entity);
4483          Nodes.Table (N + 1).Field11 := Val;
4484       end Set_Field11;
4485
4486       procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
4487       begin
4488          pragma Assert (Nkind (N) in N_Entity);
4489          Nodes.Table (N + 1).Field12 := Val;
4490       end Set_Field12;
4491
4492       procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
4493       begin
4494          pragma Assert (Nkind (N) in N_Entity);
4495          Nodes.Table (N + 2).Field6 := Val;
4496       end Set_Field13;
4497
4498       procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
4499       begin
4500          pragma Assert (Nkind (N) in N_Entity);
4501          Nodes.Table (N + 2).Field7 := Val;
4502       end Set_Field14;
4503
4504       procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
4505       begin
4506          pragma Assert (Nkind (N) in N_Entity);
4507          Nodes.Table (N + 2).Field8 := Val;
4508       end Set_Field15;
4509
4510       procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
4511       begin
4512          pragma Assert (Nkind (N) in N_Entity);
4513          Nodes.Table (N + 2).Field9 := Val;
4514       end Set_Field16;
4515
4516       procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
4517       begin
4518          pragma Assert (Nkind (N) in N_Entity);
4519          Nodes.Table (N + 2).Field10 := Val;
4520       end Set_Field17;
4521
4522       procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
4523       begin
4524          pragma Assert (Nkind (N) in N_Entity);
4525          Nodes.Table (N + 2).Field11 := Val;
4526       end Set_Field18;
4527
4528       procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
4529       begin
4530          pragma Assert (Nkind (N) in N_Entity);
4531          Nodes.Table (N + 3).Field6 := Val;
4532       end Set_Field19;
4533
4534       procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
4535       begin
4536          pragma Assert (Nkind (N) in N_Entity);
4537          Nodes.Table (N + 3).Field7 := Val;
4538       end Set_Field20;
4539
4540       procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
4541       begin
4542          pragma Assert (Nkind (N) in N_Entity);
4543          Nodes.Table (N + 3).Field8 := Val;
4544       end Set_Field21;
4545
4546       procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
4547       begin
4548          pragma Assert (Nkind (N) in N_Entity);
4549          Nodes.Table (N + 3).Field9 := Val;
4550       end Set_Field22;
4551
4552       procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
4553       begin
4554          pragma Assert (Nkind (N) in N_Entity);
4555          Nodes.Table (N + 3).Field10 := Val;
4556       end Set_Field23;
4557
4558       procedure Set_Field24 (N : Node_Id; Val : Union_Id) is
4559       begin
4560          pragma Assert (Nkind (N) in N_Entity);
4561          Nodes.Table (N + 4).Field6 := Val;
4562       end Set_Field24;
4563
4564       procedure Set_Field25 (N : Node_Id; Val : Union_Id) is
4565       begin
4566          pragma Assert (Nkind (N) in N_Entity);
4567          Nodes.Table (N + 4).Field7 := Val;
4568       end Set_Field25;
4569
4570       procedure Set_Field26 (N : Node_Id; Val : Union_Id) is
4571       begin
4572          pragma Assert (Nkind (N) in N_Entity);
4573          Nodes.Table (N + 4).Field8 := Val;
4574       end Set_Field26;
4575
4576       procedure Set_Field27 (N : Node_Id; Val : Union_Id) is
4577       begin
4578          pragma Assert (Nkind (N) in N_Entity);
4579          Nodes.Table (N + 4).Field9 := Val;
4580       end Set_Field27;
4581
4582       procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
4583       begin
4584          pragma Assert (N in Nodes.First .. Nodes.Last);
4585          Nodes.Table (N).Field1 := Union_Id (Val);
4586       end Set_Node1;
4587
4588       procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
4589       begin
4590          pragma Assert (N in Nodes.First .. Nodes.Last);
4591          Nodes.Table (N).Field2 := Union_Id (Val);
4592       end Set_Node2;
4593
4594       procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
4595       begin
4596          pragma Assert (N in Nodes.First .. Nodes.Last);
4597          Nodes.Table (N).Field3 := Union_Id (Val);
4598       end Set_Node3;
4599
4600       procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
4601       begin
4602          pragma Assert (N in Nodes.First .. Nodes.Last);
4603          Nodes.Table (N).Field4 := Union_Id (Val);
4604       end Set_Node4;
4605
4606       procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
4607       begin
4608          pragma Assert (N in Nodes.First .. Nodes.Last);
4609          Nodes.Table (N).Field5 := Union_Id (Val);
4610       end Set_Node5;
4611
4612       procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
4613       begin
4614          pragma Assert (Nkind (N) in N_Entity);
4615          Nodes.Table (N + 1).Field6 := Union_Id (Val);
4616       end Set_Node6;
4617
4618       procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
4619       begin
4620          pragma Assert (Nkind (N) in N_Entity);
4621          Nodes.Table (N + 1).Field7 := Union_Id (Val);
4622       end Set_Node7;
4623
4624       procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
4625       begin
4626          pragma Assert (Nkind (N) in N_Entity);
4627          Nodes.Table (N + 1).Field8 := Union_Id (Val);
4628       end Set_Node8;
4629
4630       procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
4631       begin
4632          pragma Assert (Nkind (N) in N_Entity);
4633          Nodes.Table (N + 1).Field9 := Union_Id (Val);
4634       end Set_Node9;
4635
4636       procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
4637       begin
4638          pragma Assert (Nkind (N) in N_Entity);
4639          Nodes.Table (N + 1).Field10 := Union_Id (Val);
4640       end Set_Node10;
4641
4642       procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
4643       begin
4644          pragma Assert (Nkind (N) in N_Entity);
4645          Nodes.Table (N + 1).Field11 := Union_Id (Val);
4646       end Set_Node11;
4647
4648       procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
4649       begin
4650          pragma Assert (Nkind (N) in N_Entity);
4651          Nodes.Table (N + 1).Field12 := Union_Id (Val);
4652       end Set_Node12;
4653
4654       procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
4655       begin
4656          pragma Assert (Nkind (N) in N_Entity);
4657          Nodes.Table (N + 2).Field6 := Union_Id (Val);
4658       end Set_Node13;
4659
4660       procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
4661       begin
4662          pragma Assert (Nkind (N) in N_Entity);
4663          Nodes.Table (N + 2).Field7 := Union_Id (Val);
4664       end Set_Node14;
4665
4666       procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
4667       begin
4668          pragma Assert (Nkind (N) in N_Entity);
4669          Nodes.Table (N + 2).Field8 := Union_Id (Val);
4670       end Set_Node15;
4671
4672       procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
4673       begin
4674          pragma Assert (Nkind (N) in N_Entity);
4675          Nodes.Table (N + 2).Field9 := Union_Id (Val);
4676       end Set_Node16;
4677
4678       procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
4679       begin
4680          pragma Assert (Nkind (N) in N_Entity);
4681          Nodes.Table (N + 2).Field10 := Union_Id (Val);
4682       end Set_Node17;
4683
4684       procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
4685       begin
4686          pragma Assert (Nkind (N) in N_Entity);
4687          Nodes.Table (N + 2).Field11 := Union_Id (Val);
4688       end Set_Node18;
4689
4690       procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
4691       begin
4692          pragma Assert (Nkind (N) in N_Entity);
4693          Nodes.Table (N + 3).Field6 := Union_Id (Val);
4694       end Set_Node19;
4695
4696       procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
4697       begin
4698          pragma Assert (Nkind (N) in N_Entity);
4699          Nodes.Table (N + 3).Field7 := Union_Id (Val);
4700       end Set_Node20;
4701
4702       procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
4703       begin
4704          pragma Assert (Nkind (N) in N_Entity);
4705          Nodes.Table (N + 3).Field8 := Union_Id (Val);
4706       end Set_Node21;
4707
4708       procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
4709       begin
4710          pragma Assert (Nkind (N) in N_Entity);
4711          Nodes.Table (N + 3).Field9 := Union_Id (Val);
4712       end Set_Node22;
4713
4714       procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
4715       begin
4716          pragma Assert (Nkind (N) in N_Entity);
4717          Nodes.Table (N + 3).Field10 := Union_Id (Val);
4718       end Set_Node23;
4719
4720       procedure Set_Node24 (N : Node_Id; Val : Node_Id) is
4721       begin
4722          pragma Assert (Nkind (N) in N_Entity);
4723          Nodes.Table (N + 4).Field6 := Union_Id (Val);
4724       end Set_Node24;
4725
4726       procedure Set_Node25 (N : Node_Id; Val : Node_Id) is
4727       begin
4728          pragma Assert (Nkind (N) in N_Entity);
4729          Nodes.Table (N + 4).Field7 := Union_Id (Val);
4730       end Set_Node25;
4731
4732       procedure Set_Node26 (N : Node_Id; Val : Node_Id) is
4733       begin
4734          pragma Assert (Nkind (N) in N_Entity);
4735          Nodes.Table (N + 4).Field8 := Union_Id (Val);
4736       end Set_Node26;
4737
4738       procedure Set_Node27 (N : Node_Id; Val : Node_Id) is
4739       begin
4740          pragma Assert (Nkind (N) in N_Entity);
4741          Nodes.Table (N + 4).Field9 := Union_Id (Val);
4742       end Set_Node27;
4743
4744       procedure Set_List1 (N : Node_Id; Val : List_Id) is
4745       begin
4746          pragma Assert (N in Nodes.First .. Nodes.Last);
4747          Nodes.Table (N).Field1 := Union_Id (Val);
4748       end Set_List1;
4749
4750       procedure Set_List2 (N : Node_Id; Val : List_Id) is
4751       begin
4752          pragma Assert (N in Nodes.First .. Nodes.Last);
4753          Nodes.Table (N).Field2 := Union_Id (Val);
4754       end Set_List2;
4755
4756       procedure Set_List3 (N : Node_Id; Val : List_Id) is
4757       begin
4758          pragma Assert (N in Nodes.First .. Nodes.Last);
4759          Nodes.Table (N).Field3 := Union_Id (Val);
4760       end Set_List3;
4761
4762       procedure Set_List4 (N : Node_Id; Val : List_Id) is
4763       begin
4764          pragma Assert (N in Nodes.First .. Nodes.Last);
4765          Nodes.Table (N).Field4 := Union_Id (Val);
4766       end Set_List4;
4767
4768       procedure Set_List5 (N : Node_Id; Val : List_Id) is
4769       begin
4770          pragma Assert (N in Nodes.First .. Nodes.Last);
4771          Nodes.Table (N).Field5 := Union_Id (Val);
4772       end Set_List5;
4773
4774       procedure Set_List10 (N : Node_Id; Val : List_Id) is
4775       begin
4776          pragma Assert (Nkind (N) in N_Entity);
4777          Nodes.Table (N + 1).Field10 := Union_Id (Val);
4778       end Set_List10;
4779
4780       procedure Set_List14 (N : Node_Id; Val : List_Id) is
4781       begin
4782          pragma Assert (Nkind (N) in N_Entity);
4783          Nodes.Table (N + 2).Field7 := Union_Id (Val);
4784       end Set_List14;
4785
4786       procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
4787       begin
4788          Nodes.Table (N).Field2 := Union_Id (Val);
4789       end Set_Elist2;
4790
4791       procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
4792       begin
4793          Nodes.Table (N).Field3 := Union_Id (Val);
4794       end Set_Elist3;
4795
4796       procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
4797       begin
4798          Nodes.Table (N).Field4 := Union_Id (Val);
4799       end Set_Elist4;
4800
4801       procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
4802       begin
4803          pragma Assert (Nkind (N) in N_Entity);
4804          Nodes.Table (N + 1).Field8 := Union_Id (Val);
4805       end Set_Elist8;
4806
4807       procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
4808       begin
4809          pragma Assert (Nkind (N) in N_Entity);
4810          Nodes.Table (N + 2).Field6 := Union_Id (Val);
4811       end Set_Elist13;
4812
4813       procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
4814       begin
4815          pragma Assert (Nkind (N) in N_Entity);
4816          Nodes.Table (N + 2).Field8 := Union_Id (Val);
4817       end Set_Elist15;
4818
4819       procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
4820       begin
4821          pragma Assert (Nkind (N) in N_Entity);
4822          Nodes.Table (N + 2).Field9 := Union_Id (Val);
4823       end Set_Elist16;
4824
4825       procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
4826       begin
4827          pragma Assert (Nkind (N) in N_Entity);
4828          Nodes.Table (N + 2).Field11 := Union_Id (Val);
4829       end Set_Elist18;
4830
4831       procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
4832       begin
4833          pragma Assert (Nkind (N) in N_Entity);
4834          Nodes.Table (N + 3).Field8 := Union_Id (Val);
4835       end Set_Elist21;
4836
4837       procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
4838       begin
4839          pragma Assert (Nkind (N) in N_Entity);
4840          Nodes.Table (N + 3).Field10 := Union_Id (Val);
4841       end Set_Elist23;
4842
4843       procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
4844       begin
4845          pragma Assert (N in Nodes.First .. Nodes.Last);
4846          Nodes.Table (N).Field1 := Union_Id (Val);
4847       end Set_Name1;
4848
4849       procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
4850       begin
4851          pragma Assert (N in Nodes.First .. Nodes.Last);
4852          Nodes.Table (N).Field2 := Union_Id (Val);
4853       end Set_Name2;
4854
4855       procedure Set_Str3 (N : Node_Id; Val : String_Id) is
4856       begin
4857          pragma Assert (N in Nodes.First .. Nodes.Last);
4858          Nodes.Table (N).Field3 := Union_Id (Val);
4859       end Set_Str3;
4860
4861       procedure Set_Uint3 (N : Node_Id; Val : Uint) is
4862       begin
4863          pragma Assert (N in Nodes.First .. Nodes.Last);
4864          Nodes.Table (N).Field3 := To_Union (Val);
4865       end Set_Uint3;
4866
4867       procedure Set_Uint4 (N : Node_Id; Val : Uint) is
4868       begin
4869          pragma Assert (N in Nodes.First .. Nodes.Last);
4870          Nodes.Table (N).Field4 := To_Union (Val);
4871       end Set_Uint4;
4872
4873       procedure Set_Uint5 (N : Node_Id; Val : Uint) is
4874       begin
4875          pragma Assert (N in Nodes.First .. Nodes.Last);
4876          Nodes.Table (N).Field5 := To_Union (Val);
4877       end Set_Uint5;
4878
4879       procedure Set_Uint8 (N : Node_Id; Val : Uint) is
4880       begin
4881          pragma Assert (Nkind (N) in N_Entity);
4882          Nodes.Table (N + 1).Field8 := To_Union (Val);
4883       end Set_Uint8;
4884
4885       procedure Set_Uint9 (N : Node_Id; Val : Uint) is
4886       begin
4887          pragma Assert (Nkind (N) in N_Entity);
4888          Nodes.Table (N + 1).Field9 := To_Union (Val);
4889       end Set_Uint9;
4890
4891       procedure Set_Uint10 (N : Node_Id; Val : Uint) is
4892       begin
4893          pragma Assert (Nkind (N) in N_Entity);
4894          Nodes.Table (N + 1).Field10 := To_Union (Val);
4895       end Set_Uint10;
4896
4897       procedure Set_Uint11 (N : Node_Id; Val : Uint) is
4898       begin
4899          pragma Assert (Nkind (N) in N_Entity);
4900          Nodes.Table (N + 1).Field11 := To_Union (Val);
4901       end Set_Uint11;
4902
4903       procedure Set_Uint12 (N : Node_Id; Val : Uint) is
4904       begin
4905          pragma Assert (Nkind (N) in N_Entity);
4906          Nodes.Table (N + 1).Field12 := To_Union (Val);
4907       end Set_Uint12;
4908
4909       procedure Set_Uint13 (N : Node_Id; Val : Uint) is
4910       begin
4911          pragma Assert (Nkind (N) in N_Entity);
4912          Nodes.Table (N + 2).Field6 := To_Union (Val);
4913       end Set_Uint13;
4914
4915       procedure Set_Uint14 (N : Node_Id; Val : Uint) is
4916       begin
4917          pragma Assert (Nkind (N) in N_Entity);
4918          Nodes.Table (N + 2).Field7 := To_Union (Val);
4919       end Set_Uint14;
4920
4921       procedure Set_Uint15 (N : Node_Id; Val : Uint) is
4922       begin
4923          pragma Assert (Nkind (N) in N_Entity);
4924          Nodes.Table (N + 2).Field8 := To_Union (Val);
4925       end Set_Uint15;
4926
4927       procedure Set_Uint16 (N : Node_Id; Val : Uint) is
4928       begin
4929          pragma Assert (Nkind (N) in N_Entity);
4930          Nodes.Table (N + 2).Field9 := To_Union (Val);
4931       end Set_Uint16;
4932
4933       procedure Set_Uint17 (N : Node_Id; Val : Uint) is
4934       begin
4935          pragma Assert (Nkind (N) in N_Entity);
4936          Nodes.Table (N + 2).Field10 := To_Union (Val);
4937       end Set_Uint17;
4938
4939       procedure Set_Uint22 (N : Node_Id; Val : Uint) is
4940       begin
4941          pragma Assert (Nkind (N) in N_Entity);
4942          Nodes.Table (N + 3).Field9 := To_Union (Val);
4943       end Set_Uint22;
4944
4945       procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
4946       begin
4947          pragma Assert (N in Nodes.First .. Nodes.Last);
4948          Nodes.Table (N).Field3 := To_Union (Val);
4949       end Set_Ureal3;
4950
4951       procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
4952       begin
4953          pragma Assert (Nkind (N) in N_Entity);
4954          Nodes.Table (N + 2).Field11 := To_Union (Val);
4955       end Set_Ureal18;
4956
4957       procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
4958       begin
4959          pragma Assert (Nkind (N) in N_Entity);
4960          Nodes.Table (N + 3).Field8 := To_Union (Val);
4961       end Set_Ureal21;
4962
4963       procedure Set_Char_Code2 (N : Node_Id; Val : Char_Code) is
4964       begin
4965          pragma Assert (N in Nodes.First .. Nodes.Last);
4966          Nodes.Table (N).Field2 := Union_Id (Val) + Char_Code_Bias;
4967       end Set_Char_Code2;
4968
4969       procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
4970       begin
4971          pragma Assert (N in Nodes.First .. Nodes.Last);
4972          Nodes.Table (N).Flag4 := Val;
4973       end Set_Flag4;
4974
4975       procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
4976       begin
4977          pragma Assert (N in Nodes.First .. Nodes.Last);
4978          Nodes.Table (N).Flag5 := Val;
4979       end Set_Flag5;
4980
4981       procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
4982       begin
4983          pragma Assert (N in Nodes.First .. Nodes.Last);
4984          Nodes.Table (N).Flag6 := Val;
4985       end Set_Flag6;
4986
4987       procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
4988       begin
4989          pragma Assert (N in Nodes.First .. Nodes.Last);
4990          Nodes.Table (N).Flag7 := Val;
4991       end Set_Flag7;
4992
4993       procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
4994       begin
4995          pragma Assert (N in Nodes.First .. Nodes.Last);
4996          Nodes.Table (N).Flag8 := Val;
4997       end Set_Flag8;
4998
4999       procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
5000       begin
5001          pragma Assert (N in Nodes.First .. Nodes.Last);
5002          Nodes.Table (N).Flag9 := Val;
5003       end Set_Flag9;
5004
5005       procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
5006       begin
5007          pragma Assert (N in Nodes.First .. Nodes.Last);
5008          Nodes.Table (N).Flag10 := Val;
5009       end Set_Flag10;
5010
5011       procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
5012       begin
5013          pragma Assert (N in Nodes.First .. Nodes.Last);
5014          Nodes.Table (N).Flag11 := Val;
5015       end Set_Flag11;
5016
5017       procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
5018       begin
5019          pragma Assert (N in Nodes.First .. Nodes.Last);
5020          Nodes.Table (N).Flag12 := Val;
5021       end Set_Flag12;
5022
5023       procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
5024       begin
5025          pragma Assert (N in Nodes.First .. Nodes.Last);
5026          Nodes.Table (N).Flag13 := Val;
5027       end Set_Flag13;
5028
5029       procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
5030       begin
5031          pragma Assert (N in Nodes.First .. Nodes.Last);
5032          Nodes.Table (N).Flag14 := Val;
5033       end Set_Flag14;
5034
5035       procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
5036       begin
5037          pragma Assert (N in Nodes.First .. Nodes.Last);
5038          Nodes.Table (N).Flag15 := Val;
5039       end Set_Flag15;
5040
5041       procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
5042       begin
5043          pragma Assert (N in Nodes.First .. Nodes.Last);
5044          Nodes.Table (N).Flag16 := Val;
5045       end Set_Flag16;
5046
5047       procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
5048       begin
5049          pragma Assert (N in Nodes.First .. Nodes.Last);
5050          Nodes.Table (N).Flag17 := Val;
5051       end Set_Flag17;
5052
5053       procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
5054       begin
5055          pragma Assert (N in Nodes.First .. Nodes.Last);
5056          Nodes.Table (N).Flag18 := Val;
5057       end Set_Flag18;
5058
5059       procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
5060       begin
5061          pragma Assert (Nkind (N) in N_Entity);
5062          Nodes.Table (N + 1).In_List := Val;
5063       end Set_Flag19;
5064
5065       procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
5066       begin
5067          pragma Assert (Nkind (N) in N_Entity);
5068          Nodes.Table (N + 1).Unused_1 := Val;
5069       end Set_Flag20;
5070
5071       procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
5072       begin
5073          pragma Assert (Nkind (N) in N_Entity);
5074          Nodes.Table (N + 1).Rewrite_Ins := Val;
5075       end Set_Flag21;
5076
5077       procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
5078       begin
5079          pragma Assert (Nkind (N) in N_Entity);
5080          Nodes.Table (N + 1).Analyzed := Val;
5081       end Set_Flag22;
5082
5083       procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
5084       begin
5085          pragma Assert (Nkind (N) in N_Entity);
5086          Nodes.Table (N + 1).Comes_From_Source := Val;
5087       end Set_Flag23;
5088
5089       procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
5090       begin
5091          pragma Assert (Nkind (N) in N_Entity);
5092          Nodes.Table (N + 1).Error_Posted := Val;
5093       end Set_Flag24;
5094
5095       procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
5096       begin
5097          pragma Assert (Nkind (N) in N_Entity);
5098          Nodes.Table (N + 1).Flag4 := Val;
5099       end Set_Flag25;
5100
5101       procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
5102       begin
5103          pragma Assert (Nkind (N) in N_Entity);
5104          Nodes.Table (N + 1).Flag5 := Val;
5105       end Set_Flag26;
5106
5107       procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
5108       begin
5109          pragma Assert (Nkind (N) in N_Entity);
5110          Nodes.Table (N + 1).Flag6 := Val;
5111       end Set_Flag27;
5112
5113       procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
5114       begin
5115          pragma Assert (Nkind (N) in N_Entity);
5116          Nodes.Table (N + 1).Flag7 := Val;
5117       end Set_Flag28;
5118
5119       procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
5120       begin
5121          pragma Assert (Nkind (N) in N_Entity);
5122          Nodes.Table (N + 1).Flag8 := Val;
5123       end Set_Flag29;
5124
5125       procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
5126       begin
5127          pragma Assert (Nkind (N) in N_Entity);
5128          Nodes.Table (N + 1).Flag9 := Val;
5129       end Set_Flag30;
5130
5131       procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
5132       begin
5133          pragma Assert (Nkind (N) in N_Entity);
5134          Nodes.Table (N + 1).Flag10 := Val;
5135       end Set_Flag31;
5136
5137       procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
5138       begin
5139          pragma Assert (Nkind (N) in N_Entity);
5140          Nodes.Table (N + 1).Flag11 := Val;
5141       end Set_Flag32;
5142
5143       procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
5144       begin
5145          pragma Assert (Nkind (N) in N_Entity);
5146          Nodes.Table (N + 1).Flag12 := Val;
5147       end Set_Flag33;
5148
5149       procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
5150       begin
5151          pragma Assert (Nkind (N) in N_Entity);
5152          Nodes.Table (N + 1).Flag13 := Val;
5153       end Set_Flag34;
5154
5155       procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
5156       begin
5157          pragma Assert (Nkind (N) in N_Entity);
5158          Nodes.Table (N + 1).Flag14 := Val;
5159       end Set_Flag35;
5160
5161       procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
5162       begin
5163          pragma Assert (Nkind (N) in N_Entity);
5164          Nodes.Table (N + 1).Flag15 := Val;
5165       end Set_Flag36;
5166
5167       procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
5168       begin
5169          pragma Assert (Nkind (N) in N_Entity);
5170          Nodes.Table (N + 1).Flag16 := Val;
5171       end Set_Flag37;
5172
5173       procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
5174       begin
5175          pragma Assert (Nkind (N) in N_Entity);
5176          Nodes.Table (N + 1).Flag17 := Val;
5177       end Set_Flag38;
5178
5179       procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
5180       begin
5181          pragma Assert (Nkind (N) in N_Entity);
5182          Nodes.Table (N + 1).Flag18 := Val;
5183       end Set_Flag39;
5184
5185       procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
5186       begin
5187          pragma Assert (Nkind (N) in N_Entity);
5188          Nodes.Table (N + 2).In_List := Val;
5189       end Set_Flag40;
5190
5191       procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
5192       begin
5193          pragma Assert (Nkind (N) in N_Entity);
5194          Nodes.Table (N + 2).Unused_1 := Val;
5195       end Set_Flag41;
5196
5197       procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
5198       begin
5199          pragma Assert (Nkind (N) in N_Entity);
5200          Nodes.Table (N + 2).Rewrite_Ins := Val;
5201       end Set_Flag42;
5202
5203       procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
5204       begin
5205          pragma Assert (Nkind (N) in N_Entity);
5206          Nodes.Table (N + 2).Analyzed := Val;
5207       end Set_Flag43;
5208
5209       procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
5210       begin
5211          pragma Assert (Nkind (N) in N_Entity);
5212          Nodes.Table (N + 2).Comes_From_Source := Val;
5213       end Set_Flag44;
5214
5215       procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
5216       begin
5217          pragma Assert (Nkind (N) in N_Entity);
5218          Nodes.Table (N + 2).Error_Posted := Val;
5219       end Set_Flag45;
5220
5221       procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
5222       begin
5223          pragma Assert (Nkind (N) in N_Entity);
5224          Nodes.Table (N + 2).Flag4 := Val;
5225       end Set_Flag46;
5226
5227       procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
5228       begin
5229          pragma Assert (Nkind (N) in N_Entity);
5230          Nodes.Table (N + 2).Flag5 := Val;
5231       end Set_Flag47;
5232
5233       procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
5234       begin
5235          pragma Assert (Nkind (N) in N_Entity);
5236          Nodes.Table (N + 2).Flag6 := Val;
5237       end Set_Flag48;
5238
5239       procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
5240       begin
5241          pragma Assert (Nkind (N) in N_Entity);
5242          Nodes.Table (N + 2).Flag7 := Val;
5243       end Set_Flag49;
5244
5245       procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
5246       begin
5247          pragma Assert (Nkind (N) in N_Entity);
5248          Nodes.Table (N + 2).Flag8 := Val;
5249       end Set_Flag50;
5250
5251       procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
5252       begin
5253          pragma Assert (Nkind (N) in N_Entity);
5254          Nodes.Table (N + 2).Flag9 := Val;
5255       end Set_Flag51;
5256
5257       procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
5258       begin
5259          pragma Assert (Nkind (N) in N_Entity);
5260          Nodes.Table (N + 2).Flag10 := Val;
5261       end Set_Flag52;
5262
5263       procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
5264       begin
5265          pragma Assert (Nkind (N) in N_Entity);
5266          Nodes.Table (N + 2).Flag11 := Val;
5267       end Set_Flag53;
5268
5269       procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
5270       begin
5271          pragma Assert (Nkind (N) in N_Entity);
5272          Nodes.Table (N + 2).Flag12 := Val;
5273       end Set_Flag54;
5274
5275       procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
5276       begin
5277          pragma Assert (Nkind (N) in N_Entity);
5278          Nodes.Table (N + 2).Flag13 := Val;
5279       end Set_Flag55;
5280
5281       procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
5282       begin
5283          pragma Assert (Nkind (N) in N_Entity);
5284          Nodes.Table (N + 2).Flag14 := Val;
5285       end Set_Flag56;
5286
5287       procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
5288       begin
5289          pragma Assert (Nkind (N) in N_Entity);
5290          Nodes.Table (N + 2).Flag15 := Val;
5291       end Set_Flag57;
5292
5293       procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
5294       begin
5295          pragma Assert (Nkind (N) in N_Entity);
5296          Nodes.Table (N + 2).Flag16 := Val;
5297       end Set_Flag58;
5298
5299       procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
5300       begin
5301          pragma Assert (Nkind (N) in N_Entity);
5302          Nodes.Table (N + 2).Flag17 := Val;
5303       end Set_Flag59;
5304
5305       procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
5306       begin
5307          pragma Assert (Nkind (N) in N_Entity);
5308          Nodes.Table (N + 2).Flag18 := Val;
5309       end Set_Flag60;
5310
5311       procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
5312       begin
5313          pragma Assert (Nkind (N) in N_Entity);
5314          Nodes.Table (N + 1).Pflag1 := Val;
5315       end Set_Flag61;
5316
5317       procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
5318       begin
5319          pragma Assert (Nkind (N) in N_Entity);
5320          Nodes.Table (N + 1).Pflag2 := Val;
5321       end Set_Flag62;
5322
5323       procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
5324       begin
5325          pragma Assert (Nkind (N) in N_Entity);
5326          Nodes.Table (N + 2).Pflag1 := Val;
5327       end Set_Flag63;
5328
5329       procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
5330       begin
5331          pragma Assert (Nkind (N) in N_Entity);
5332          Nodes.Table (N + 2).Pflag2 := Val;
5333       end Set_Flag64;
5334
5335       procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
5336       begin
5337          pragma Assert (Nkind (N) in N_Entity);
5338          To_Flag_Byte_Ptr
5339            (Node_Kind_Ptr'
5340              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
5341       end Set_Flag65;
5342
5343       procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
5344       begin
5345          pragma Assert (Nkind (N) in N_Entity);
5346          To_Flag_Byte_Ptr
5347            (Node_Kind_Ptr'
5348              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
5349       end Set_Flag66;
5350
5351       procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
5352       begin
5353          pragma Assert (Nkind (N) in N_Entity);
5354          To_Flag_Byte_Ptr
5355            (Node_Kind_Ptr'
5356              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
5357       end Set_Flag67;
5358
5359       procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
5360       begin
5361          pragma Assert (Nkind (N) in N_Entity);
5362          To_Flag_Byte_Ptr
5363            (Node_Kind_Ptr'
5364              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
5365       end Set_Flag68;
5366
5367       procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
5368       begin
5369          pragma Assert (Nkind (N) in N_Entity);
5370          To_Flag_Byte_Ptr
5371            (Node_Kind_Ptr'
5372              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
5373       end Set_Flag69;
5374
5375       procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
5376       begin
5377          pragma Assert (Nkind (N) in N_Entity);
5378          To_Flag_Byte_Ptr
5379            (Node_Kind_Ptr'
5380              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
5381       end Set_Flag70;
5382
5383       procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
5384       begin
5385          pragma Assert (Nkind (N) in N_Entity);
5386          To_Flag_Byte_Ptr
5387            (Node_Kind_Ptr'
5388              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
5389       end Set_Flag71;
5390
5391       procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
5392       begin
5393          pragma Assert (Nkind (N) in N_Entity);
5394          To_Flag_Byte_Ptr
5395            (Node_Kind_Ptr'
5396              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
5397       end Set_Flag72;
5398
5399       procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
5400       begin
5401          pragma Assert (Nkind (N) in N_Entity);
5402          To_Flag_Word_Ptr
5403            (Union_Id_Ptr'
5404              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
5405       end Set_Flag73;
5406
5407       procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
5408       begin
5409          pragma Assert (Nkind (N) in N_Entity);
5410          To_Flag_Word_Ptr
5411            (Union_Id_Ptr'
5412              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
5413       end Set_Flag74;
5414
5415       procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
5416       begin
5417          pragma Assert (Nkind (N) in N_Entity);
5418          To_Flag_Word_Ptr
5419            (Union_Id_Ptr'
5420              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
5421       end Set_Flag75;
5422
5423       procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
5424       begin
5425          pragma Assert (Nkind (N) in N_Entity);
5426          To_Flag_Word_Ptr
5427            (Union_Id_Ptr'
5428              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
5429       end Set_Flag76;
5430
5431       procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
5432       begin
5433          pragma Assert (Nkind (N) in N_Entity);
5434          To_Flag_Word_Ptr
5435            (Union_Id_Ptr'
5436              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
5437       end Set_Flag77;
5438
5439       procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
5440       begin
5441          pragma Assert (Nkind (N) in N_Entity);
5442          To_Flag_Word_Ptr
5443            (Union_Id_Ptr'
5444              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
5445       end Set_Flag78;
5446
5447       procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
5448       begin
5449          pragma Assert (Nkind (N) in N_Entity);
5450          To_Flag_Word_Ptr
5451            (Union_Id_Ptr'
5452              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
5453       end Set_Flag79;
5454
5455       procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
5456       begin
5457          pragma Assert (Nkind (N) in N_Entity);
5458          To_Flag_Word_Ptr
5459            (Union_Id_Ptr'
5460              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
5461       end Set_Flag80;
5462
5463       procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
5464       begin
5465          pragma Assert (Nkind (N) in N_Entity);
5466          To_Flag_Word_Ptr
5467            (Union_Id_Ptr'
5468              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
5469       end Set_Flag81;
5470
5471       procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
5472       begin
5473          pragma Assert (Nkind (N) in N_Entity);
5474          To_Flag_Word_Ptr
5475            (Union_Id_Ptr'
5476              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
5477       end Set_Flag82;
5478
5479       procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
5480       begin
5481          pragma Assert (Nkind (N) in N_Entity);
5482          To_Flag_Word_Ptr
5483            (Union_Id_Ptr'
5484              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
5485       end Set_Flag83;
5486
5487       procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
5488       begin
5489          pragma Assert (Nkind (N) in N_Entity);
5490          To_Flag_Word_Ptr
5491            (Union_Id_Ptr'
5492              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
5493       end Set_Flag84;
5494
5495       procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
5496       begin
5497          pragma Assert (Nkind (N) in N_Entity);
5498          To_Flag_Word_Ptr
5499            (Union_Id_Ptr'
5500              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
5501       end Set_Flag85;
5502
5503       procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
5504       begin
5505          pragma Assert (Nkind (N) in N_Entity);
5506          To_Flag_Word_Ptr
5507            (Union_Id_Ptr'
5508              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
5509       end Set_Flag86;
5510
5511       procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
5512       begin
5513          pragma Assert (Nkind (N) in N_Entity);
5514          To_Flag_Word_Ptr
5515            (Union_Id_Ptr'
5516              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
5517       end Set_Flag87;
5518
5519       procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
5520       begin
5521          pragma Assert (Nkind (N) in N_Entity);
5522          To_Flag_Word_Ptr
5523            (Union_Id_Ptr'
5524              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
5525       end Set_Flag88;
5526
5527       procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
5528       begin
5529          pragma Assert (Nkind (N) in N_Entity);
5530          To_Flag_Word_Ptr
5531            (Union_Id_Ptr'
5532              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
5533       end Set_Flag89;
5534
5535       procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
5536       begin
5537          pragma Assert (Nkind (N) in N_Entity);
5538          To_Flag_Word_Ptr
5539            (Union_Id_Ptr'
5540              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
5541       end Set_Flag90;
5542
5543       procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
5544       begin
5545          pragma Assert (Nkind (N) in N_Entity);
5546          To_Flag_Word_Ptr
5547            (Union_Id_Ptr'
5548              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
5549       end Set_Flag91;
5550
5551       procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
5552       begin
5553          pragma Assert (Nkind (N) in N_Entity);
5554          To_Flag_Word_Ptr
5555            (Union_Id_Ptr'
5556              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
5557       end Set_Flag92;
5558
5559       procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
5560       begin
5561          pragma Assert (Nkind (N) in N_Entity);
5562          To_Flag_Word_Ptr
5563            (Union_Id_Ptr'
5564              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
5565       end Set_Flag93;
5566
5567       procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
5568       begin
5569          pragma Assert (Nkind (N) in N_Entity);
5570          To_Flag_Word_Ptr
5571            (Union_Id_Ptr'
5572              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
5573       end Set_Flag94;
5574
5575       procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
5576       begin
5577          pragma Assert (Nkind (N) in N_Entity);
5578          To_Flag_Word_Ptr
5579            (Union_Id_Ptr'
5580              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
5581       end Set_Flag95;
5582
5583       procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
5584       begin
5585          pragma Assert (Nkind (N) in N_Entity);
5586          To_Flag_Word_Ptr
5587            (Union_Id_Ptr'
5588              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
5589       end Set_Flag96;
5590
5591       procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
5592       begin
5593          pragma Assert (Nkind (N) in N_Entity);
5594          To_Flag_Word2_Ptr
5595            (Union_Id_Ptr'
5596              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
5597       end Set_Flag97;
5598
5599       procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
5600       begin
5601          pragma Assert (Nkind (N) in N_Entity);
5602          To_Flag_Word2_Ptr
5603            (Union_Id_Ptr'
5604              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
5605       end Set_Flag98;
5606
5607       procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
5608       begin
5609          pragma Assert (Nkind (N) in N_Entity);
5610          To_Flag_Word2_Ptr
5611            (Union_Id_Ptr'
5612              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
5613       end Set_Flag99;
5614
5615       procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
5616       begin
5617          pragma Assert (Nkind (N) in N_Entity);
5618          To_Flag_Word2_Ptr
5619            (Union_Id_Ptr'
5620              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
5621       end Set_Flag100;
5622
5623       procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
5624       begin
5625          pragma Assert (Nkind (N) in N_Entity);
5626          To_Flag_Word2_Ptr
5627            (Union_Id_Ptr'
5628              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
5629       end Set_Flag101;
5630
5631       procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
5632       begin
5633          pragma Assert (Nkind (N) in N_Entity);
5634          To_Flag_Word2_Ptr
5635            (Union_Id_Ptr'
5636              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
5637       end Set_Flag102;
5638
5639       procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
5640       begin
5641          pragma Assert (Nkind (N) in N_Entity);
5642          To_Flag_Word2_Ptr
5643            (Union_Id_Ptr'
5644              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
5645       end Set_Flag103;
5646
5647       procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
5648       begin
5649          pragma Assert (Nkind (N) in N_Entity);
5650          To_Flag_Word2_Ptr
5651            (Union_Id_Ptr'
5652              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
5653       end Set_Flag104;
5654
5655       procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
5656       begin
5657          pragma Assert (Nkind (N) in N_Entity);
5658          To_Flag_Word2_Ptr
5659            (Union_Id_Ptr'
5660              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
5661       end Set_Flag105;
5662
5663       procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
5664       begin
5665          pragma Assert (Nkind (N) in N_Entity);
5666          To_Flag_Word2_Ptr
5667            (Union_Id_Ptr'
5668              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
5669       end Set_Flag106;
5670
5671       procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
5672       begin
5673          pragma Assert (Nkind (N) in N_Entity);
5674          To_Flag_Word2_Ptr
5675            (Union_Id_Ptr'
5676              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
5677       end Set_Flag107;
5678
5679       procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
5680       begin
5681          pragma Assert (Nkind (N) in N_Entity);
5682          To_Flag_Word2_Ptr
5683            (Union_Id_Ptr'
5684              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
5685       end Set_Flag108;
5686
5687       procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
5688       begin
5689          pragma Assert (Nkind (N) in N_Entity);
5690          To_Flag_Word2_Ptr
5691            (Union_Id_Ptr'
5692              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
5693       end Set_Flag109;
5694
5695       procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
5696       begin
5697          pragma Assert (Nkind (N) in N_Entity);
5698          To_Flag_Word2_Ptr
5699            (Union_Id_Ptr'
5700              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
5701       end Set_Flag110;
5702
5703       procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
5704       begin
5705          pragma Assert (Nkind (N) in N_Entity);
5706          To_Flag_Word2_Ptr
5707            (Union_Id_Ptr'
5708              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
5709       end Set_Flag111;
5710
5711       procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
5712       begin
5713          pragma Assert (Nkind (N) in N_Entity);
5714          To_Flag_Word2_Ptr
5715            (Union_Id_Ptr'
5716              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
5717       end Set_Flag112;
5718
5719       procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
5720       begin
5721          pragma Assert (Nkind (N) in N_Entity);
5722          To_Flag_Word2_Ptr
5723            (Union_Id_Ptr'
5724              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
5725       end Set_Flag113;
5726
5727       procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
5728       begin
5729          pragma Assert (Nkind (N) in N_Entity);
5730          To_Flag_Word2_Ptr
5731            (Union_Id_Ptr'
5732              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
5733       end Set_Flag114;
5734
5735       procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
5736       begin
5737          pragma Assert (Nkind (N) in N_Entity);
5738          To_Flag_Word2_Ptr
5739            (Union_Id_Ptr'
5740              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
5741       end Set_Flag115;
5742
5743       procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
5744       begin
5745          pragma Assert (Nkind (N) in N_Entity);
5746          To_Flag_Word2_Ptr
5747            (Union_Id_Ptr'
5748              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
5749       end Set_Flag116;
5750
5751       procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
5752       begin
5753          pragma Assert (Nkind (N) in N_Entity);
5754          To_Flag_Word2_Ptr
5755            (Union_Id_Ptr'
5756              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
5757       end Set_Flag117;
5758
5759       procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
5760       begin
5761          pragma Assert (Nkind (N) in N_Entity);
5762          To_Flag_Word2_Ptr
5763            (Union_Id_Ptr'
5764              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
5765       end Set_Flag118;
5766
5767       procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
5768       begin
5769          pragma Assert (Nkind (N) in N_Entity);
5770          To_Flag_Word2_Ptr
5771            (Union_Id_Ptr'
5772              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
5773       end Set_Flag119;
5774
5775       procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
5776       begin
5777          pragma Assert (Nkind (N) in N_Entity);
5778          To_Flag_Word2_Ptr
5779            (Union_Id_Ptr'
5780              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
5781       end Set_Flag120;
5782
5783       procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
5784       begin
5785          pragma Assert (Nkind (N) in N_Entity);
5786          To_Flag_Word2_Ptr
5787            (Union_Id_Ptr'
5788              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
5789       end Set_Flag121;
5790
5791       procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
5792       begin
5793          pragma Assert (Nkind (N) in N_Entity);
5794          To_Flag_Word2_Ptr
5795            (Union_Id_Ptr'
5796              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
5797       end Set_Flag122;
5798
5799       procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
5800       begin
5801          pragma Assert (Nkind (N) in N_Entity);
5802          To_Flag_Word2_Ptr
5803            (Union_Id_Ptr'
5804              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
5805       end Set_Flag123;
5806
5807       procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
5808       begin
5809          pragma Assert (Nkind (N) in N_Entity);
5810          To_Flag_Word2_Ptr
5811            (Union_Id_Ptr'
5812              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
5813       end Set_Flag124;
5814
5815       procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
5816       begin
5817          pragma Assert (Nkind (N) in N_Entity);
5818          To_Flag_Word2_Ptr
5819            (Union_Id_Ptr'
5820              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
5821       end Set_Flag125;
5822
5823       procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
5824       begin
5825          pragma Assert (Nkind (N) in N_Entity);
5826          To_Flag_Word2_Ptr
5827            (Union_Id_Ptr'
5828              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
5829       end Set_Flag126;
5830
5831       procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
5832       begin
5833          pragma Assert (Nkind (N) in N_Entity);
5834          To_Flag_Word2_Ptr
5835            (Union_Id_Ptr'
5836              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
5837       end Set_Flag127;
5838
5839       procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
5840       begin
5841          pragma Assert (Nkind (N) in N_Entity);
5842          To_Flag_Word2_Ptr
5843            (Union_Id_Ptr'
5844              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
5845       end Set_Flag128;
5846
5847       procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
5848       begin
5849          pragma Assert (Nkind (N) in N_Entity);
5850          Nodes.Table (N + 3).In_List := Val;
5851       end Set_Flag129;
5852
5853       procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
5854       begin
5855          pragma Assert (Nkind (N) in N_Entity);
5856          Nodes.Table (N + 3).Unused_1 := Val;
5857       end Set_Flag130;
5858
5859       procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
5860       begin
5861          pragma Assert (Nkind (N) in N_Entity);
5862          Nodes.Table (N + 3).Rewrite_Ins := Val;
5863       end Set_Flag131;
5864
5865       procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
5866       begin
5867          pragma Assert (Nkind (N) in N_Entity);
5868          Nodes.Table (N + 3).Analyzed := Val;
5869       end Set_Flag132;
5870
5871       procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
5872       begin
5873          pragma Assert (Nkind (N) in N_Entity);
5874          Nodes.Table (N + 3).Comes_From_Source := Val;
5875       end Set_Flag133;
5876
5877       procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
5878       begin
5879          pragma Assert (Nkind (N) in N_Entity);
5880          Nodes.Table (N + 3).Error_Posted := Val;
5881       end Set_Flag134;
5882
5883       procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
5884       begin
5885          pragma Assert (Nkind (N) in N_Entity);
5886          Nodes.Table (N + 3).Flag4 := Val;
5887       end Set_Flag135;
5888
5889       procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
5890       begin
5891          pragma Assert (Nkind (N) in N_Entity);
5892          Nodes.Table (N + 3).Flag5 := Val;
5893       end Set_Flag136;
5894
5895       procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
5896       begin
5897          pragma Assert (Nkind (N) in N_Entity);
5898          Nodes.Table (N + 3).Flag6 := Val;
5899       end Set_Flag137;
5900
5901       procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
5902       begin
5903          pragma Assert (Nkind (N) in N_Entity);
5904          Nodes.Table (N + 3).Flag7 := Val;
5905       end Set_Flag138;
5906
5907       procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
5908       begin
5909          pragma Assert (Nkind (N) in N_Entity);
5910          Nodes.Table (N + 3).Flag8 := Val;
5911       end Set_Flag139;
5912
5913       procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
5914       begin
5915          pragma Assert (Nkind (N) in N_Entity);
5916          Nodes.Table (N + 3).Flag9 := Val;
5917       end Set_Flag140;
5918
5919       procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
5920       begin
5921          pragma Assert (Nkind (N) in N_Entity);
5922          Nodes.Table (N + 3).Flag10 := Val;
5923       end Set_Flag141;
5924
5925       procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
5926       begin
5927          pragma Assert (Nkind (N) in N_Entity);
5928          Nodes.Table (N + 3).Flag11 := Val;
5929       end Set_Flag142;
5930
5931       procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
5932       begin
5933          pragma Assert (Nkind (N) in N_Entity);
5934          Nodes.Table (N + 3).Flag12 := Val;
5935       end Set_Flag143;
5936
5937       procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
5938       begin
5939          pragma Assert (Nkind (N) in N_Entity);
5940          Nodes.Table (N + 3).Flag13 := Val;
5941       end Set_Flag144;
5942
5943       procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
5944       begin
5945          pragma Assert (Nkind (N) in N_Entity);
5946          Nodes.Table (N + 3).Flag14 := Val;
5947       end Set_Flag145;
5948
5949       procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
5950       begin
5951          pragma Assert (Nkind (N) in N_Entity);
5952          Nodes.Table (N + 3).Flag15 := Val;
5953       end Set_Flag146;
5954
5955       procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
5956       begin
5957          pragma Assert (Nkind (N) in N_Entity);
5958          Nodes.Table (N + 3).Flag16 := Val;
5959       end Set_Flag147;
5960
5961       procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
5962       begin
5963          pragma Assert (Nkind (N) in N_Entity);
5964          Nodes.Table (N + 3).Flag17 := Val;
5965       end Set_Flag148;
5966
5967       procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
5968       begin
5969          pragma Assert (Nkind (N) in N_Entity);
5970          Nodes.Table (N + 3).Flag18 := Val;
5971       end Set_Flag149;
5972
5973       procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
5974       begin
5975          pragma Assert (Nkind (N) in N_Entity);
5976          Nodes.Table (N + 3).Pflag1 := Val;
5977       end Set_Flag150;
5978
5979       procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
5980       begin
5981          pragma Assert (Nkind (N) in N_Entity);
5982          Nodes.Table (N + 3).Pflag2 := Val;
5983       end Set_Flag151;
5984
5985       procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
5986       begin
5987          pragma Assert (Nkind (N) in N_Entity);
5988          To_Flag_Word3_Ptr
5989            (Union_Id_Ptr'
5990              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
5991       end Set_Flag152;
5992
5993       procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
5994       begin
5995          pragma Assert (Nkind (N) in N_Entity);
5996          To_Flag_Word3_Ptr
5997            (Union_Id_Ptr'
5998              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
5999       end Set_Flag153;
6000
6001       procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
6002       begin
6003          pragma Assert (Nkind (N) in N_Entity);
6004          To_Flag_Word3_Ptr
6005            (Union_Id_Ptr'
6006              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
6007       end Set_Flag154;
6008
6009       procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
6010       begin
6011          pragma Assert (Nkind (N) in N_Entity);
6012          To_Flag_Word3_Ptr
6013            (Union_Id_Ptr'
6014              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
6015       end Set_Flag155;
6016
6017       procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
6018       begin
6019          pragma Assert (Nkind (N) in N_Entity);
6020          To_Flag_Word3_Ptr
6021            (Union_Id_Ptr'
6022              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
6023       end Set_Flag156;
6024
6025       procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
6026       begin
6027          pragma Assert (Nkind (N) in N_Entity);
6028          To_Flag_Word3_Ptr
6029            (Union_Id_Ptr'
6030              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
6031       end Set_Flag157;
6032
6033       procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
6034       begin
6035          pragma Assert (Nkind (N) in N_Entity);
6036          To_Flag_Word3_Ptr
6037            (Union_Id_Ptr'
6038              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
6039       end Set_Flag158;
6040
6041       procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
6042       begin
6043          pragma Assert (Nkind (N) in N_Entity);
6044          To_Flag_Word3_Ptr
6045            (Union_Id_Ptr'
6046              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
6047       end Set_Flag159;
6048
6049       procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
6050       begin
6051          pragma Assert (Nkind (N) in N_Entity);
6052          To_Flag_Word3_Ptr
6053            (Union_Id_Ptr'
6054              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
6055       end Set_Flag160;
6056
6057       procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
6058       begin
6059          pragma Assert (Nkind (N) in N_Entity);
6060          To_Flag_Word3_Ptr
6061            (Union_Id_Ptr'
6062              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
6063       end Set_Flag161;
6064
6065       procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
6066       begin
6067          pragma Assert (Nkind (N) in N_Entity);
6068          To_Flag_Word3_Ptr
6069            (Union_Id_Ptr'
6070              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
6071       end Set_Flag162;
6072
6073       procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
6074       begin
6075          pragma Assert (Nkind (N) in N_Entity);
6076          To_Flag_Word3_Ptr
6077            (Union_Id_Ptr'
6078              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
6079       end Set_Flag163;
6080
6081       procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
6082       begin
6083          pragma Assert (Nkind (N) in N_Entity);
6084          To_Flag_Word3_Ptr
6085            (Union_Id_Ptr'
6086              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
6087       end Set_Flag164;
6088
6089       procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
6090       begin
6091          pragma Assert (Nkind (N) in N_Entity);
6092          To_Flag_Word3_Ptr
6093            (Union_Id_Ptr'
6094              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
6095       end Set_Flag165;
6096
6097       procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
6098       begin
6099          pragma Assert (Nkind (N) in N_Entity);
6100          To_Flag_Word3_Ptr
6101            (Union_Id_Ptr'
6102              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
6103       end Set_Flag166;
6104
6105       procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
6106       begin
6107          pragma Assert (Nkind (N) in N_Entity);
6108          To_Flag_Word3_Ptr
6109            (Union_Id_Ptr'
6110              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
6111       end Set_Flag167;
6112
6113       procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
6114       begin
6115          pragma Assert (Nkind (N) in N_Entity);
6116          To_Flag_Word3_Ptr
6117            (Union_Id_Ptr'
6118              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
6119       end Set_Flag168;
6120
6121       procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
6122       begin
6123          pragma Assert (Nkind (N) in N_Entity);
6124          To_Flag_Word3_Ptr
6125            (Union_Id_Ptr'
6126              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
6127       end Set_Flag169;
6128
6129       procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
6130       begin
6131          pragma Assert (Nkind (N) in N_Entity);
6132          To_Flag_Word3_Ptr
6133            (Union_Id_Ptr'
6134              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
6135       end Set_Flag170;
6136
6137       procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
6138       begin
6139          pragma Assert (Nkind (N) in N_Entity);
6140          To_Flag_Word3_Ptr
6141            (Union_Id_Ptr'
6142              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
6143       end Set_Flag171;
6144
6145       procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
6146       begin
6147          pragma Assert (Nkind (N) in N_Entity);
6148          To_Flag_Word3_Ptr
6149            (Union_Id_Ptr'
6150              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
6151       end Set_Flag172;
6152
6153       procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
6154       begin
6155          pragma Assert (Nkind (N) in N_Entity);
6156          To_Flag_Word3_Ptr
6157            (Union_Id_Ptr'
6158              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
6159       end Set_Flag173;
6160
6161       procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
6162       begin
6163          pragma Assert (Nkind (N) in N_Entity);
6164          To_Flag_Word3_Ptr
6165            (Union_Id_Ptr'
6166              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
6167       end Set_Flag174;
6168
6169       procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
6170       begin
6171          pragma Assert (Nkind (N) in N_Entity);
6172          To_Flag_Word3_Ptr
6173            (Union_Id_Ptr'
6174              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
6175       end Set_Flag175;
6176
6177       procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
6178       begin
6179          pragma Assert (Nkind (N) in N_Entity);
6180          To_Flag_Word3_Ptr
6181            (Union_Id_Ptr'
6182              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
6183       end Set_Flag176;
6184
6185       procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
6186       begin
6187          pragma Assert (Nkind (N) in N_Entity);
6188          To_Flag_Word3_Ptr
6189            (Union_Id_Ptr'
6190              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
6191       end Set_Flag177;
6192
6193       procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
6194       begin
6195          pragma Assert (Nkind (N) in N_Entity);
6196          To_Flag_Word3_Ptr
6197            (Union_Id_Ptr'
6198              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
6199       end Set_Flag178;
6200
6201       procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
6202       begin
6203          pragma Assert (Nkind (N) in N_Entity);
6204          To_Flag_Word3_Ptr
6205            (Union_Id_Ptr'
6206              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
6207       end Set_Flag179;
6208
6209       procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
6210       begin
6211          pragma Assert (Nkind (N) in N_Entity);
6212          To_Flag_Word3_Ptr
6213            (Union_Id_Ptr'
6214              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
6215       end Set_Flag180;
6216
6217       procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
6218       begin
6219          pragma Assert (Nkind (N) in N_Entity);
6220          To_Flag_Word3_Ptr
6221            (Union_Id_Ptr'
6222              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
6223       end Set_Flag181;
6224
6225       procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
6226       begin
6227          pragma Assert (Nkind (N) in N_Entity);
6228          To_Flag_Word3_Ptr
6229            (Union_Id_Ptr'
6230              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
6231       end Set_Flag182;
6232
6233       procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
6234       begin
6235          pragma Assert (Nkind (N) in N_Entity);
6236          To_Flag_Word3_Ptr
6237            (Union_Id_Ptr'
6238              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
6239       end Set_Flag183;
6240
6241       procedure Set_Flag184 (N : Node_Id; Val : Boolean) is
6242       begin
6243          pragma Assert (Nkind (N) in N_Entity);
6244          To_Flag_Word4_Ptr
6245            (Union_Id_Ptr'
6246              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag184 := Val;
6247       end Set_Flag184;
6248
6249       procedure Set_Flag185 (N : Node_Id; Val : Boolean) is
6250       begin
6251          pragma Assert (Nkind (N) in N_Entity);
6252          To_Flag_Word4_Ptr
6253            (Union_Id_Ptr'
6254              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag185 := Val;
6255       end Set_Flag185;
6256
6257       procedure Set_Flag186 (N : Node_Id; Val : Boolean) is
6258       begin
6259          pragma Assert (Nkind (N) in N_Entity);
6260          To_Flag_Word4_Ptr
6261            (Union_Id_Ptr'
6262              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag186 := Val;
6263       end Set_Flag186;
6264
6265       procedure Set_Flag187 (N : Node_Id; Val : Boolean) is
6266       begin
6267          pragma Assert (Nkind (N) in N_Entity);
6268          To_Flag_Word4_Ptr
6269            (Union_Id_Ptr'
6270              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag187 := Val;
6271       end Set_Flag187;
6272
6273       procedure Set_Flag188 (N : Node_Id; Val : Boolean) is
6274       begin
6275          pragma Assert (Nkind (N) in N_Entity);
6276          To_Flag_Word4_Ptr
6277            (Union_Id_Ptr'
6278              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag188 := Val;
6279       end Set_Flag188;
6280
6281       procedure Set_Flag189 (N : Node_Id; Val : Boolean) is
6282       begin
6283          pragma Assert (Nkind (N) in N_Entity);
6284          To_Flag_Word4_Ptr
6285            (Union_Id_Ptr'
6286              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag189 := Val;
6287       end Set_Flag189;
6288
6289       procedure Set_Flag190 (N : Node_Id; Val : Boolean) is
6290       begin
6291          pragma Assert (Nkind (N) in N_Entity);
6292          To_Flag_Word4_Ptr
6293            (Union_Id_Ptr'
6294              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag190 := Val;
6295       end Set_Flag190;
6296
6297       procedure Set_Flag191 (N : Node_Id; Val : Boolean) is
6298       begin
6299          pragma Assert (Nkind (N) in N_Entity);
6300          To_Flag_Word4_Ptr
6301            (Union_Id_Ptr'
6302              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag191 := Val;
6303       end Set_Flag191;
6304
6305       procedure Set_Flag192 (N : Node_Id; Val : Boolean) is
6306       begin
6307          pragma Assert (Nkind (N) in N_Entity);
6308          To_Flag_Word4_Ptr
6309            (Union_Id_Ptr'
6310              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag192 := Val;
6311       end Set_Flag192;
6312
6313       procedure Set_Flag193 (N : Node_Id; Val : Boolean) is
6314       begin
6315          pragma Assert (Nkind (N) in N_Entity);
6316          To_Flag_Word4_Ptr
6317            (Union_Id_Ptr'
6318              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag193 := Val;
6319       end Set_Flag193;
6320
6321       procedure Set_Flag194 (N : Node_Id; Val : Boolean) is
6322       begin
6323          pragma Assert (Nkind (N) in N_Entity);
6324          To_Flag_Word4_Ptr
6325            (Union_Id_Ptr'
6326              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag194 := Val;
6327       end Set_Flag194;
6328
6329       procedure Set_Flag195 (N : Node_Id; Val : Boolean) is
6330       begin
6331          pragma Assert (Nkind (N) in N_Entity);
6332          To_Flag_Word4_Ptr
6333            (Union_Id_Ptr'
6334              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag195 := Val;
6335       end Set_Flag195;
6336
6337       procedure Set_Flag196 (N : Node_Id; Val : Boolean) is
6338       begin
6339          pragma Assert (Nkind (N) in N_Entity);
6340          To_Flag_Word4_Ptr
6341            (Union_Id_Ptr'
6342              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag196 := Val;
6343       end Set_Flag196;
6344
6345       procedure Set_Flag197 (N : Node_Id; Val : Boolean) is
6346       begin
6347          pragma Assert (Nkind (N) in N_Entity);
6348          To_Flag_Word4_Ptr
6349            (Union_Id_Ptr'
6350              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag197 := Val;
6351       end Set_Flag197;
6352
6353       procedure Set_Flag198 (N : Node_Id; Val : Boolean) is
6354       begin
6355          pragma Assert (Nkind (N) in N_Entity);
6356          To_Flag_Word4_Ptr
6357            (Union_Id_Ptr'
6358              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag198 := Val;
6359       end Set_Flag198;
6360
6361       procedure Set_Flag199 (N : Node_Id; Val : Boolean) is
6362       begin
6363          pragma Assert (Nkind (N) in N_Entity);
6364          To_Flag_Word4_Ptr
6365            (Union_Id_Ptr'
6366              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag199 := Val;
6367       end Set_Flag199;
6368
6369       procedure Set_Flag200 (N : Node_Id; Val : Boolean) is
6370       begin
6371          pragma Assert (Nkind (N) in N_Entity);
6372          To_Flag_Word4_Ptr
6373            (Union_Id_Ptr'
6374              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag200 := Val;
6375       end Set_Flag200;
6376
6377       procedure Set_Flag201 (N : Node_Id; Val : Boolean) is
6378       begin
6379          pragma Assert (Nkind (N) in N_Entity);
6380          To_Flag_Word4_Ptr
6381            (Union_Id_Ptr'
6382              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag201 := Val;
6383       end Set_Flag201;
6384
6385       procedure Set_Flag202 (N : Node_Id; Val : Boolean) is
6386       begin
6387          pragma Assert (Nkind (N) in N_Entity);
6388          To_Flag_Word4_Ptr
6389            (Union_Id_Ptr'
6390              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag202 := Val;
6391       end Set_Flag202;
6392
6393       procedure Set_Flag203 (N : Node_Id; Val : Boolean) is
6394       begin
6395          pragma Assert (Nkind (N) in N_Entity);
6396          To_Flag_Word4_Ptr
6397            (Union_Id_Ptr'
6398              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag203 := Val;
6399       end Set_Flag203;
6400
6401       procedure Set_Flag204 (N : Node_Id; Val : Boolean) is
6402       begin
6403          pragma Assert (Nkind (N) in N_Entity);
6404          To_Flag_Word4_Ptr
6405            (Union_Id_Ptr'
6406              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag204 := Val;
6407       end Set_Flag204;
6408
6409       procedure Set_Flag205 (N : Node_Id; Val : Boolean) is
6410       begin
6411          pragma Assert (Nkind (N) in N_Entity);
6412          To_Flag_Word4_Ptr
6413            (Union_Id_Ptr'
6414              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag205 := Val;
6415       end Set_Flag205;
6416
6417       procedure Set_Flag206 (N : Node_Id; Val : Boolean) is
6418       begin
6419          pragma Assert (Nkind (N) in N_Entity);
6420          To_Flag_Word4_Ptr
6421            (Union_Id_Ptr'
6422              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag206 := Val;
6423       end Set_Flag206;
6424
6425       procedure Set_Flag207 (N : Node_Id; Val : Boolean) is
6426       begin
6427          pragma Assert (Nkind (N) in N_Entity);
6428          To_Flag_Word4_Ptr
6429            (Union_Id_Ptr'
6430              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag207 := Val;
6431       end Set_Flag207;
6432
6433       procedure Set_Flag208 (N : Node_Id; Val : Boolean) is
6434       begin
6435          pragma Assert (Nkind (N) in N_Entity);
6436          To_Flag_Word4_Ptr
6437            (Union_Id_Ptr'
6438              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag208 := Val;
6439       end Set_Flag208;
6440
6441       procedure Set_Flag209 (N : Node_Id; Val : Boolean) is
6442       begin
6443          pragma Assert (Nkind (N) in N_Entity);
6444          To_Flag_Word4_Ptr
6445            (Union_Id_Ptr'
6446              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag209 := Val;
6447       end Set_Flag209;
6448
6449       procedure Set_Flag210 (N : Node_Id; Val : Boolean) is
6450       begin
6451          pragma Assert (Nkind (N) in N_Entity);
6452          To_Flag_Word4_Ptr
6453            (Union_Id_Ptr'
6454              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag210 := Val;
6455       end Set_Flag210;
6456
6457       procedure Set_Flag211 (N : Node_Id; Val : Boolean) is
6458       begin
6459          pragma Assert (Nkind (N) in N_Entity);
6460          To_Flag_Word4_Ptr
6461            (Union_Id_Ptr'
6462              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag211 := Val;
6463       end Set_Flag211;
6464
6465       procedure Set_Flag212 (N : Node_Id; Val : Boolean) is
6466       begin
6467          pragma Assert (Nkind (N) in N_Entity);
6468          To_Flag_Word4_Ptr
6469            (Union_Id_Ptr'
6470              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag212 := Val;
6471       end Set_Flag212;
6472
6473       procedure Set_Flag213 (N : Node_Id; Val : Boolean) is
6474       begin
6475          pragma Assert (Nkind (N) in N_Entity);
6476          To_Flag_Word4_Ptr
6477            (Union_Id_Ptr'
6478              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag213 := Val;
6479       end Set_Flag213;
6480
6481       procedure Set_Flag214 (N : Node_Id; Val : Boolean) is
6482       begin
6483          pragma Assert (Nkind (N) in N_Entity);
6484          To_Flag_Word4_Ptr
6485            (Union_Id_Ptr'
6486              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag214 := Val;
6487       end Set_Flag214;
6488
6489       procedure Set_Flag215 (N : Node_Id; Val : Boolean) is
6490       begin
6491          pragma Assert (Nkind (N) in N_Entity);
6492          To_Flag_Word4_Ptr
6493            (Union_Id_Ptr'
6494              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag215 := Val;
6495       end Set_Flag215;
6496
6497       procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is
6498       begin
6499          pragma Assert (N in Nodes.First .. Nodes.Last);
6500          if Val > Error then Set_Parent (Val, N); end if;
6501          Set_Node1 (N, Val);
6502       end Set_Node1_With_Parent;
6503
6504       procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is
6505       begin
6506          pragma Assert (N in Nodes.First .. Nodes.Last);
6507          if Val > Error then Set_Parent (Val, N); end if;
6508          Set_Node2 (N, Val);
6509       end Set_Node2_With_Parent;
6510
6511       procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is
6512       begin
6513          pragma Assert (N in Nodes.First .. Nodes.Last);
6514          if Val > Error then Set_Parent (Val, N); end if;
6515          Set_Node3 (N, Val);
6516       end Set_Node3_With_Parent;
6517
6518       procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is
6519       begin
6520          pragma Assert (N in Nodes.First .. Nodes.Last);
6521          if Val > Error then Set_Parent (Val, N); end if;
6522          Set_Node4 (N, Val);
6523       end Set_Node4_With_Parent;
6524
6525       procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
6526       begin
6527          pragma Assert (N in Nodes.First .. Nodes.Last);
6528          if Val > Error then Set_Parent (Val, N); end if;
6529          Set_Node5 (N, Val);
6530       end Set_Node5_With_Parent;
6531
6532       procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
6533       begin
6534          pragma Assert (N in Nodes.First .. Nodes.Last);
6535          if Val /= No_List and then Val /= Error_List then
6536             Set_Parent (Val, N);
6537          end if;
6538          Set_List1 (N, Val);
6539       end Set_List1_With_Parent;
6540
6541       procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
6542       begin
6543          pragma Assert (N in Nodes.First .. Nodes.Last);
6544          if Val /= No_List and then Val /= Error_List then
6545             Set_Parent (Val, N);
6546          end if;
6547          Set_List2 (N, Val);
6548       end Set_List2_With_Parent;
6549
6550       procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
6551       begin
6552          pragma Assert (N in Nodes.First .. Nodes.Last);
6553          if Val /= No_List and then Val /= Error_List then
6554             Set_Parent (Val, N);
6555          end if;
6556          Set_List3 (N, Val);
6557       end Set_List3_With_Parent;
6558
6559       procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
6560       begin
6561          pragma Assert (N in Nodes.First .. Nodes.Last);
6562          if Val /= No_List and then Val /= Error_List then
6563             Set_Parent (Val, N);
6564          end if;
6565          Set_List4 (N, Val);
6566       end Set_List4_With_Parent;
6567
6568       procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
6569       begin
6570          pragma Assert (N in Nodes.First .. Nodes.Last);
6571          if Val /= No_List and then Val /= Error_List then
6572             Set_Parent (Val, N);
6573          end if;
6574          Set_List5 (N, Val);
6575       end Set_List5_With_Parent;
6576
6577    end Unchecked_Access;
6578
6579 end Atree;