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