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