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