gcc/ada/atree.adb

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