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