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