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