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