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