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