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