gcc/ada/atree.adb

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