gcc/ada/atree.adb

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