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