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