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-2009, 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 Debug;   use Debug;
  40 with Nlists;  use Nlists;
  41 with Output;  use Output;
  42 with Sinput;  use Sinput;
  43 with Tree_IO; use Tree_IO;
  44
  45 package body Atree is
  46
  47    ---------------
  48    -- Debugging --
  49    ---------------
  50
  51    --  Suppose you find that node 12345 is messed up. You might want to find
  52    --  the code that created that node. There are two ways to do this:
  53
  54    --  One way is to set a conditional breakpoint on New_Node_Debugging_Output
  55    --  (nickname "nnd"):
  56    --     break nnd if n = 12345
  57    --  and run gnat1 again from the beginning.
  58
  59    --  The other way is to set a breakpoint near the beginning (e.g. on
  60    --  gnat1drv), and run. Then set Watch_Node (nickname "ww") to 12345 in gdb:
  61    --     ww := 12345
  62    --  and set a breakpoint on New_Node_Breakpoint (nickname "nn"). Continue.
  63
  64    --  Either way, gnat1 will stop when node 12345 is created
  65
  66    --  The second method is faster
  67
  68    ww : Node_Id'Base := Node_Id'First - 1;
  69    pragma Export (Ada, ww); --  trick the optimizer
  70    Watch_Node : Node_Id'Base renames ww;
  71    --  Node to "watch"; that is, whenever a node is created, we check if it is
  72    --  equal to Watch_Node, and if so, call New_Node_Breakpoint. You have
  73    --  presumably set a breakpoint on New_Node_Breakpoint. Note that the
  74    --  initial value of Node_Id'First - 1 ensures that by default, no node
  75    --  will be equal to Watch_Node.
  76
  77    procedure nn;
  78    pragma Export (Ada, nn);
  79    procedure New_Node_Breakpoint renames nn;
  80    --  This doesn't do anything interesting; it's just for setting breakpoint
  81    --  on as explained above.
  82
  83    procedure nnd (N : Node_Id);
  84    pragma Export (Ada, nnd);
  85    procedure New_Node_Debugging_Output (N : Node_Id) renames nnd;
  86    --  For debugging. If debugging is turned on, New_Node and New_Entity call
  87    --  this. If debug flag N is turned on, this prints out the new node.
  88    --
  89    --  If Node = Watch_Node, this prints out the new node and calls
  90    --  New_Node_Breakpoint. Otherwise, does nothing.
  91
  92    -----------------------------
  93    -- Local Objects and Types --
  94    -----------------------------
  95
  96    Node_Count : Nat;
  97    --  Count allocated nodes for Num_Nodes function
  98
  99    use Unchecked_Access;
 100    --  We are allowed to see these from within our own body!
 101
 102    use Atree_Private_Part;
 103    --  We are also allowed to see our private data structures!
 104
 105    --  Functions used to store Entity_Kind value in Nkind field
 106
 107    --  The following declarations are used to store flags 65-72 in the
 108    --  Nkind field of the third component of an extended (entity) node.
 109
 110    type Flag_Byte is record
 111       Flag65 : Boolean;
 112       Flag66 : Boolean;
 113       Flag67 : Boolean;
 114       Flag68 : Boolean;
 115       Flag69 : Boolean;
 116       Flag70 : Boolean;
 117       Flag71 : Boolean;
 118       Flag72 : Boolean;
 119    end record;
 120
 121    pragma Pack (Flag_Byte);
 122    for Flag_Byte'Size use 8;
 123
 124    type Flag_Byte_Ptr is access all Flag_Byte;
 125    type Node_Kind_Ptr is access all Node_Kind;
 126
 127    function To_Flag_Byte is new
 128      Unchecked_Conversion (Node_Kind, Flag_Byte);
 129
 130    function To_Flag_Byte_Ptr is new
 131      Unchecked_Conversion (Node_Kind_Ptr, Flag_Byte_Ptr);
 132
 133    --  The following declarations are used to store flags 73-96 and the
 134    --  Convention field in the Field12 field of the third component of an
 135    --  extended (Entity) node.
 136
 137    type Flag_Word is record
 138       Flag73 : Boolean;
 139       Flag74 : Boolean;
 140       Flag75 : Boolean;
 141       Flag76 : Boolean;
 142       Flag77 : Boolean;
 143       Flag78 : Boolean;
 144       Flag79 : Boolean;
 145       Flag80 : Boolean;
 146
 147       Flag81 : Boolean;
 148       Flag82 : Boolean;
 149       Flag83 : Boolean;
 150       Flag84 : Boolean;
 151       Flag85 : Boolean;
 152       Flag86 : Boolean;
 153       Flag87 : Boolean;
 154       Flag88 : Boolean;
 155
 156       Flag89 : Boolean;
 157       Flag90 : Boolean;
 158       Flag91 : Boolean;
 159       Flag92 : Boolean;
 160       Flag93 : Boolean;
 161       Flag94 : Boolean;
 162       Flag95 : Boolean;
 163       Flag96 : Boolean;
 164
 165       Convention : Convention_Id;
 166    end record;
 167
 168    pragma Pack (Flag_Word);
 169    for Flag_Word'Size use 32;
 170    for Flag_Word'Alignment use 4;
 171
 172    type Flag_Word_Ptr is access all Flag_Word;
 173    type Union_Id_Ptr  is access all Union_Id;
 174
 175    function To_Flag_Word is new
 176      Unchecked_Conversion (Union_Id, Flag_Word);
 177
 178    function To_Flag_Word_Ptr is new
 179      Unchecked_Conversion (Union_Id_Ptr, Flag_Word_Ptr);
 180
 181    --  The following declarations are used to store flags 97-128 in the
 182    --  Field12 field of the fourth component of an extended (entity) node.
 183
 184    type Flag_Word2 is record
 185       Flag97  : Boolean;
 186       Flag98  : Boolean;
 187       Flag99  : Boolean;
 188       Flag100 : Boolean;
 189       Flag101 : Boolean;
 190       Flag102 : Boolean;
 191       Flag103 : Boolean;
 192       Flag104 : Boolean;
 193
 194       Flag105 : Boolean;
 195       Flag106 : Boolean;
 196       Flag107 : Boolean;
 197       Flag108 : Boolean;
 198       Flag109 : Boolean;
 199       Flag110 : Boolean;
 200       Flag111 : Boolean;
 201       Flag112 : Boolean;
 202
 203       Flag113 : Boolean;
 204       Flag114 : Boolean;
 205       Flag115 : Boolean;
 206       Flag116 : Boolean;
 207       Flag117 : Boolean;
 208       Flag118 : Boolean;
 209       Flag119 : Boolean;
 210       Flag120 : Boolean;
 211
 212       Flag121 : Boolean;
 213       Flag122 : Boolean;
 214       Flag123 : Boolean;
 215       Flag124 : Boolean;
 216       Flag125 : Boolean;
 217       Flag126 : Boolean;
 218       Flag127 : Boolean;
 219       Flag128 : Boolean;
 220    end record;
 221
 222    pragma Pack (Flag_Word2);
 223    for Flag_Word2'Size use 32;
 224    for Flag_Word2'Alignment use 4;
 225
 226    type Flag_Word2_Ptr is access all Flag_Word2;
 227
 228    function To_Flag_Word2 is new
 229      Unchecked_Conversion (Union_Id, Flag_Word2);
 230
 231    function To_Flag_Word2_Ptr is new
 232      Unchecked_Conversion (Union_Id_Ptr, Flag_Word2_Ptr);
 233
 234    --  The following declarations are used to store flags 152-183 in the
 235    --  Field11 field of the fourth component of an extended (entity) node.
 236
 237    type Flag_Word3 is record
 238       Flag152 : Boolean;
 239       Flag153 : Boolean;
 240       Flag154 : Boolean;
 241       Flag155 : Boolean;
 242       Flag156 : Boolean;
 243       Flag157 : Boolean;
 244       Flag158 : Boolean;
 245       Flag159 : Boolean;
 246
 247       Flag160 : Boolean;
 248       Flag161 : Boolean;
 249       Flag162 : Boolean;
 250       Flag163 : Boolean;
 251       Flag164 : Boolean;
 252       Flag165 : Boolean;
 253       Flag166 : Boolean;
 254       Flag167 : Boolean;
 255
 256       Flag168 : Boolean;
 257       Flag169 : Boolean;
 258       Flag170 : Boolean;
 259       Flag171 : Boolean;
 260       Flag172 : Boolean;
 261       Flag173 : Boolean;
 262       Flag174 : Boolean;
 263       Flag175 : Boolean;
 264
 265       Flag176 : Boolean;
 266       Flag177 : Boolean;
 267       Flag178 : Boolean;
 268       Flag179 : Boolean;
 269       Flag180 : Boolean;
 270       Flag181 : Boolean;
 271       Flag182 : Boolean;
 272       Flag183 : Boolean;
 273    end record;
 274
 275    pragma Pack (Flag_Word3);
 276    for Flag_Word3'Size use 32;
 277    for Flag_Word3'Alignment use 4;
 278
 279    type Flag_Word3_Ptr is access all Flag_Word3;
 280
 281    function To_Flag_Word3 is new
 282      Unchecked_Conversion (Union_Id, Flag_Word3);
 283
 284    function To_Flag_Word3_Ptr is new
 285      Unchecked_Conversion (Union_Id_Ptr, Flag_Word3_Ptr);
 286
 287    --  The following declarations are used to store flags 184-215 in the
 288    --  Field11 field of the fifth component of an extended (entity) node.
 289
 290    type Flag_Word4 is record
 291       Flag184 : Boolean;
 292       Flag185 : Boolean;
 293       Flag186 : Boolean;
 294       Flag187 : Boolean;
 295       Flag188 : Boolean;
 296       Flag189 : Boolean;
 297       Flag190 : Boolean;
 298       Flag191 : Boolean;
 299
 300       Flag192 : Boolean;
 301       Flag193 : Boolean;
 302       Flag194 : Boolean;
 303       Flag195 : Boolean;
 304       Flag196 : Boolean;
 305       Flag197 : Boolean;
 306       Flag198 : Boolean;
 307       Flag199 : Boolean;
 308
 309       Flag200 : Boolean;
 310       Flag201 : Boolean;
 311       Flag202 : Boolean;
 312       Flag203 : Boolean;
 313       Flag204 : Boolean;
 314       Flag205 : Boolean;
 315       Flag206 : Boolean;
 316       Flag207 : Boolean;
 317
 318       Flag208 : Boolean;
 319       Flag209 : Boolean;
 320       Flag210 : Boolean;
 321       Flag211 : Boolean;
 322       Flag212 : Boolean;
 323       Flag213 : Boolean;
 324       Flag214 : Boolean;
 325       Flag215 : Boolean;
 326    end record;
 327
 328    pragma Pack (Flag_Word4);
 329    for Flag_Word4'Size use 32;
 330    for Flag_Word4'Alignment use 4;
 331
 332    type Flag_Word4_Ptr is access all Flag_Word4;
 333
 334    function To_Flag_Word4 is new
 335      Unchecked_Conversion (Union_Id, Flag_Word4);
 336
 337    function To_Flag_Word4_Ptr is new
 338      Unchecked_Conversion (Union_Id_Ptr, Flag_Word4_Ptr);
 339
 340    --  The following declarations are used to store flags 216-247 in the
 341    --  Field12 field of the fifth component of an extended (entity) node.
 342
 343    type Flag_Word5 is record
 344       Flag216 : Boolean;
 345       Flag217 : Boolean;
 346       Flag218 : Boolean;
 347       Flag219 : Boolean;
 348       Flag220 : Boolean;
 349       Flag221 : Boolean;
 350       Flag222 : Boolean;
 351       Flag223 : Boolean;
 352
 353       Flag224 : Boolean;
 354       Flag225 : Boolean;
 355       Flag226 : Boolean;
 356       Flag227 : Boolean;
 357       Flag228 : Boolean;
 358       Flag229 : Boolean;
 359       Flag230 : Boolean;
 360       Flag231 : Boolean;
 361
 362       Flag232 : Boolean;
 363       Flag233 : Boolean;
 364       Flag234 : Boolean;
 365       Flag235 : Boolean;
 366       Flag236 : Boolean;
 367       Flag237 : Boolean;
 368       Flag238 : Boolean;
 369       Flag239 : Boolean;
 370
 371       Flag240 : Boolean;
 372       Flag241 : Boolean;
 373       Flag242 : Boolean;
 374       Flag243 : Boolean;
 375       Flag244 : Boolean;
 376       Flag245 : Boolean;
 377       Flag246 : Boolean;
 378       Flag247 : Boolean;
 379    end record;
 380
 381    pragma Pack (Flag_Word5);
 382    for Flag_Word5'Size use 32;
 383    for Flag_Word5'Alignment use 4;
 384
 385    type Flag_Word5_Ptr is access all Flag_Word5;
 386
 387    function To_Flag_Word5 is new
 388      Unchecked_Conversion (Union_Id, Flag_Word5);
 389
 390    function To_Flag_Word5_Ptr is new
 391      Unchecked_Conversion (Union_Id_Ptr, Flag_Word5_Ptr);
 392
 393    --------------------------------------------------
 394    -- Implementation of Tree Substitution Routines --
 395    --------------------------------------------------
 396
 397    --  A separate table keeps track of the mapping between rewritten nodes
 398    --  and their corresponding original tree nodes. Rewrite makes an entry
 399    --  in this table for use by Original_Node. By default, if no call is
 400    --  Rewrite, the entry in this table points to the original unwritten node.
 401
 402    --  Note: eventually, this should be a field in the Node directly, but
 403    --  for now we do not want to disturb the efficiency of a power of 2
 404    --  for the node size
 405
 406    package Orig_Nodes is new Table.Table (
 407       Table_Component_Type => Node_Id,
 408       Table_Index_Type     => Node_Id'Base,
 409       Table_Low_Bound      => First_Node_Id,
 410       Table_Initial        => Alloc.Orig_Nodes_Initial,
 411       Table_Increment      => Alloc.Orig_Nodes_Increment,
 412       Table_Name           => "Orig_Nodes");
 413
 414    --------------------------
 415    -- Paren_Count Handling --
 416    --------------------------
 417
 418    --  As noted in the spec, the paren count in a sub-expression node has
 419    --  four possible values 0,1,2, and 3. The value 3 really means 3 or more,
 420    --  and we use an auxiliary serially scanned table to record the actual
 421    --  count. A serial search is fine, only pathological programs will use
 422    --  entries in this table. Normal programs won't use it at all.
 423
 424    type Paren_Count_Entry is record
 425       Nod   : Node_Id;
 426       --  The node to which this count applies
 427
 428       Count : Nat range 3 .. Nat'Last;
 429       --  The count of parentheses, which will be in the indicated range
 430    end record;
 431
 432    package Paren_Counts is new Table.Table (
 433      Table_Component_Type => Paren_Count_Entry,
 434      Table_Index_Type     => Int,
 435      Table_Low_Bound      => 0,
 436      Table_Initial        => 10,
 437      Table_Increment      => 200,
 438      Table_Name           => "Paren_Counts");
 439
 440    -----------------------
 441    -- Local Subprograms --
 442    -----------------------
 443
 444    procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id);
 445    --  Fixup parent pointers for the syntactic children of Fix_Node after
 446    --  a copy, setting them to Fix_Node when they pointed to Ref_Node.
 447
 448    function Allocate_Initialize_Node
 449      (Src            : Node_Id;
 450       With_Extension : Boolean) return Node_Id;
 451    --  Allocate a new node or node extension. If Src is not empty,
 452    --  the information for the newly-allocated node is copied from it.
 453
 454    ------------------------------
 455    -- Allocate_Initialize_Node --
 456    ------------------------------
 457
 458    function Allocate_Initialize_Node
 459      (Src            : Node_Id;
 460       With_Extension : Boolean) return Node_Id
 461    is
 462       New_Id : Node_Id     := Src;
 463       Nod    : Node_Record := Default_Node;
 464       Ext1   : Node_Record := Default_Node_Extension;
 465       Ext2   : Node_Record := Default_Node_Extension;
 466       Ext3   : Node_Record := Default_Node_Extension;
 467       Ext4   : Node_Record := Default_Node_Extension;
 468
 469    begin
 470       if Present (Src) then
 471          Nod := Nodes.Table (Src);
 472
 473          if Has_Extension (Src) then
 474             Ext1 := Nodes.Table (Src + 1);
 475             Ext2 := Nodes.Table (Src + 2);
 476             Ext3 := Nodes.Table (Src + 3);
 477             Ext4 := Nodes.Table (Src + 4);
 478          end if;
 479       end if;
 480
 481       if not (Present (Src)
 482                and then not Has_Extension (Src)
 483                and then With_Extension
 484                and then Src = Nodes.Last)
 485       then
 486          --  We are allocating a new node, or extending a node
 487          --  other than Nodes.Last.
 488
 489          Nodes.Append (Nod);
 490          New_Id := Nodes.Last;
 491          Orig_Nodes.Append (New_Id);
 492          Node_Count := Node_Count + 1;
 493       end if;
 494
 495       --  Specifically copy Paren_Count to deal with creating new table entry
 496       --  if the parentheses count is at the maximum possible value already.
 497
 498       if Present (Src) and then Nkind (Src) in N_Subexpr then
 499          Set_Paren_Count (New_Id, Paren_Count (Src));
 500       end if;
 501
 502       --  Set extension nodes if required
 503
 504       if With_Extension then
 505          Nodes.Append (Ext1);
 506          Nodes.Append (Ext2);
 507          Nodes.Append (Ext3);
 508          Nodes.Append (Ext4);
 509       end if;
 510
 511       Orig_Nodes.Set_Last (Nodes.Last);
 512       Allocate_List_Tables (Nodes.Last);
 513       return New_Id;
 514    end Allocate_Initialize_Node;
 515
 516    --------------
 517    -- Analyzed --
 518    --------------
 519
 520    function Analyzed (N : Node_Id) return Boolean is
 521    begin
 522       pragma Assert (N <= Nodes.Last);
 523       return Nodes.Table (N).Analyzed;
 524    end Analyzed;
 525
 526    --------------------------
 527    -- Basic_Set_Convention --
 528    --------------------------
 529
 530    procedure Basic_Set_Convention  (E : Entity_Id; Val : Convention_Id) is
 531    begin
 532       pragma Assert (Nkind (E) in N_Entity);
 533       To_Flag_Word_Ptr
 534         (Union_Id_Ptr'
 535           (Nodes.Table (E + 2).Field12'Unrestricted_Access)).Convention := Val;
 536    end Basic_Set_Convention;
 537
 538    -----------------
 539    -- Change_Node --
 540    -----------------
 541
 542    procedure Change_Node (N : Node_Id; New_Node_Kind : Node_Kind) is
 543       Save_Sloc    : constant Source_Ptr := Sloc (N);
 544       Save_In_List : constant Boolean    := Nodes.Table (N).In_List;
 545       Save_Link    : constant Union_Id   := Nodes.Table (N).Link;
 546       Save_CFS     : constant Boolean    := Nodes.Table (N).Comes_From_Source;
 547       Save_Posted  : constant Boolean    := Nodes.Table (N).Error_Posted;
 548       Par_Count    : Nat                 := 0;
 549
 550    begin
 551       if Nkind (N) in N_Subexpr then
 552          Par_Count := Paren_Count (N);
 553       end if;
 554
 555       Nodes.Table (N)                   := Default_Node;
 556       Nodes.Table (N).Sloc              := Save_Sloc;
 557       Nodes.Table (N).In_List           := Save_In_List;
 558       Nodes.Table (N).Link              := Save_Link;
 559       Nodes.Table (N).Comes_From_Source := Save_CFS;
 560       Nodes.Table (N).Nkind             := New_Node_Kind;
 561       Nodes.Table (N).Error_Posted      := Save_Posted;
 562
 563       if New_Node_Kind in N_Subexpr then
 564          Set_Paren_Count (N, Par_Count);
 565       end if;
 566    end Change_Node;
 567
 568    -----------------------
 569    -- Comes_From_Source --
 570    -----------------------
 571
 572    function Comes_From_Source (N : Node_Id) return Boolean is
 573    begin
 574       pragma Assert (N <= Nodes.Last);
 575       return Nodes.Table (N).Comes_From_Source;
 576    end Comes_From_Source;
 577
 578    ----------------
 579    -- Convention --
 580    ----------------
 581
 582    function Convention (E : Entity_Id) return Convention_Id is
 583    begin
 584       pragma Assert (Nkind (E) in N_Entity);
 585       return To_Flag_Word (Nodes.Table (E + 2).Field12).Convention;
 586    end Convention;
 587
 588    ---------------
 589    -- Copy_Node --
 590    ---------------
 591
 592    procedure Copy_Node (Source : Node_Id; Destination : Node_Id) is
 593       Save_In_List : constant Boolean  := Nodes.Table (Destination).In_List;
 594       Save_Link    : constant Union_Id := Nodes.Table (Destination).Link;
 595
 596    begin
 597       Nodes.Table (Destination)         := Nodes.Table (Source);
 598       Nodes.Table (Destination).In_List := Save_In_List;
 599       Nodes.Table (Destination).Link    := Save_Link;
 600
 601       --  Specifically set Paren_Count to make sure auxiliary table entry
 602       --  gets correctly made if the parentheses count is at the max value.
 603
 604       if Nkind (Destination) in N_Subexpr then
 605          Set_Paren_Count (Destination, Paren_Count (Source));
 606       end if;
 607
 608       --  Deal with copying extension nodes if present
 609
 610       if Has_Extension (Source) then
 611          pragma Assert (Has_Extension (Destination));
 612          Nodes.Table (Destination + 1) := Nodes.Table (Source + 1);
 613          Nodes.Table (Destination + 2) := Nodes.Table (Source + 2);
 614          Nodes.Table (Destination + 3) := Nodes.Table (Source + 3);
 615          Nodes.Table (Destination + 4) := Nodes.Table (Source + 4);
 616
 617       else
 618          pragma Assert (not Has_Extension (Source));
 619          null;
 620       end if;
 621    end Copy_Node;
 622
 623    ------------------------
 624    -- Copy_Separate_Tree --
 625    ------------------------
 626
 627    function Copy_Separate_Tree (Source : Node_Id) return Node_Id is
 628       New_Id  : Node_Id;
 629
 630       function Copy_Entity (E : Entity_Id) return Entity_Id;
 631       --  Copy Entity, copying only the Ekind and Chars fields
 632
 633       function Copy_List (List : List_Id) return List_Id;
 634       --  Copy list
 635
 636       function Possible_Copy (Field : Union_Id) return Union_Id;
 637       --  Given a field, returns a copy of the node or list if its parent
 638       --  is the current source node, and otherwise returns the input
 639
 640       -----------------
 641       -- Copy_Entity --
 642       -----------------
 643
 644       function Copy_Entity (E : Entity_Id) return Entity_Id is
 645          New_Ent : Entity_Id;
 646
 647       begin
 648          case N_Entity (Nkind (E)) is
 649             when N_Defining_Identifier =>
 650                New_Ent := New_Entity (N_Defining_Identifier, Sloc (E));
 651
 652             when N_Defining_Character_Literal =>
 653                New_Ent := New_Entity (N_Defining_Character_Literal, Sloc (E));
 654
 655             when N_Defining_Operator_Symbol =>
 656                New_Ent := New_Entity (N_Defining_Operator_Symbol, Sloc (E));
 657          end case;
 658
 659          Set_Chars (New_Ent, Chars (E));
 660          return New_Ent;
 661       end Copy_Entity;
 662
 663       ---------------
 664       -- Copy_List --
 665       ---------------
 666
 667       function Copy_List (List : List_Id) return List_Id is
 668          NL : List_Id;
 669          E  : Node_Id;
 670
 671       begin
 672          if List = No_List then
 673             return No_List;
 674
 675          else
 676             NL := New_List;
 677
 678             E := First (List);
 679             while Present (E) loop
 680                if Has_Extension (E) then
 681                   Append (Copy_Entity (E), NL);
 682                else
 683                   Append (Copy_Separate_Tree (E), NL);
 684                end if;
 685
 686                Next (E);
 687             end loop;
 688
 689             return NL;
 690          end if;
 691       end Copy_List;
 692
 693       -------------------
 694       -- Possible_Copy --
 695       -------------------
 696
 697       function Possible_Copy (Field : Union_Id) return Union_Id is
 698          New_N : Union_Id;
 699
 700       begin
 701          if Field in Node_Range then
 702             New_N := Union_Id (Copy_Separate_Tree (Node_Id (Field)));
 703
 704             if Parent (Node_Id (Field)) = Source then
 705                Set_Parent (Node_Id (New_N), New_Id);
 706             end if;
 707
 708             return New_N;
 709
 710          elsif Field in List_Range then
 711             New_N := Union_Id (Copy_List (List_Id (Field)));
 712
 713             if Parent (List_Id (Field)) = Source then
 714                Set_Parent (List_Id (New_N), New_Id);
 715             end if;
 716
 717             return New_N;
 718
 719          else
 720             return Field;
 721          end if;
 722       end Possible_Copy;
 723
 724    --  Start of processing for Copy_Separate_Tree
 725
 726    begin
 727       if Source <= Empty_Or_Error then
 728          return Source;
 729
 730       elsif Has_Extension (Source) then
 731          return Copy_Entity (Source);
 732
 733       else
 734          New_Id := New_Copy (Source);
 735
 736          --  Recursively copy descendents
 737
 738          Set_Field1 (New_Id, Possible_Copy (Field1 (New_Id)));
 739          Set_Field2 (New_Id, Possible_Copy (Field2 (New_Id)));
 740          Set_Field3 (New_Id, Possible_Copy (Field3 (New_Id)));
 741          Set_Field4 (New_Id, Possible_Copy (Field4 (New_Id)));
 742          Set_Field5 (New_Id, Possible_Copy (Field5 (New_Id)));
 743
 744          --  Set Entity field to Empty
 745          --  Why is this done??? and why is it always right to do it???
 746
 747          if Nkind (New_Id) in N_Has_Entity
 748            or else Nkind (New_Id) = N_Freeze_Entity
 749          then
 750             Set_Entity (New_Id, Empty);
 751          end if;
 752
 753          --  All done, return copied node
 754
 755          return New_Id;
 756       end if;
 757    end Copy_Separate_Tree;
 758
 759    -----------
 760    -- Ekind --
 761    -----------
 762
 763    function Ekind (E : Entity_Id) return Entity_Kind is
 764    begin
 765       pragma Assert (Nkind (E) in N_Entity);
 766       return N_To_E (Nodes.Table (E + 1).Nkind);
 767    end Ekind;
 768
 769    ------------------
 770    -- Error_Posted --
 771    ------------------
 772
 773    function Error_Posted (N : Node_Id) return Boolean is
 774    begin
 775       pragma Assert (N <= Nodes.Last);
 776       return Nodes.Table (N).Error_Posted;
 777    end Error_Posted;
 778
 779    -----------------------
 780    -- Exchange_Entities --
 781    -----------------------
 782
 783    procedure Exchange_Entities (E1 : Entity_Id; E2 : Entity_Id) is
 784       Temp_Ent : Node_Record;
 785
 786    begin
 787       pragma Assert (Has_Extension (E1)
 788         and then Has_Extension (E2)
 789         and then not Nodes.Table (E1).In_List
 790         and then not Nodes.Table (E2).In_List);
 791
 792       --  Exchange the contents of the two entities
 793
 794       Temp_Ent := Nodes.Table (E1);
 795       Nodes.Table (E1) := Nodes.Table (E2);
 796       Nodes.Table (E2) := Temp_Ent;
 797       Temp_Ent := Nodes.Table (E1 + 1);
 798       Nodes.Table (E1 + 1) := Nodes.Table (E2 + 1);
 799       Nodes.Table (E2 + 1) := Temp_Ent;
 800       Temp_Ent := Nodes.Table (E1 + 2);
 801       Nodes.Table (E1 + 2) := Nodes.Table (E2 + 2);
 802       Nodes.Table (E2 + 2) := Temp_Ent;
 803       Temp_Ent := Nodes.Table (E1 + 3);
 804       Nodes.Table (E1 + 3) := Nodes.Table (E2 + 3);
 805       Nodes.Table (E2 + 3) := Temp_Ent;
 806       Temp_Ent := Nodes.Table (E1 + 4);
 807       Nodes.Table (E1 + 4) := Nodes.Table (E2 + 4);
 808       Nodes.Table (E2 + 4) := Temp_Ent;
 809
 810       --  That exchange exchanged the parent pointers as well, which is what
 811       --  we want, but we need to patch up the defining identifier pointers
 812       --  in the parent nodes (the child pointers) to match this switch
 813       --  unless for Implicit types entities which have no parent, in which
 814       --  case we don't do anything otherwise we won't be able to revert back
 815       --  to the original situation.
 816
 817       --  Shouldn't this use Is_Itype instead of the Parent test
 818
 819       if Present (Parent (E1)) and then Present (Parent (E2)) then
 820          Set_Defining_Identifier (Parent (E1), E1);
 821          Set_Defining_Identifier (Parent (E2), E2);
 822       end if;
 823    end Exchange_Entities;
 824
 825    -----------------
 826    -- Extend_Node --
 827    -----------------
 828
 829    function Extend_Node (Node : Node_Id) return Entity_Id is
 830       Result : Entity_Id;
 831
 832       procedure Debug_Extend_Node;
 833       pragma Inline (Debug_Extend_Node);
 834       --  Debug routine for debug flag N
 835
 836       -----------------------
 837       -- Debug_Extend_Node --
 838       -----------------------
 839
 840       procedure Debug_Extend_Node is
 841       begin
 842          if Debug_Flag_N then
 843             Write_Str ("Extend node ");
 844             Write_Int (Int (Node));
 845
 846             if Result = Node then
 847                Write_Str (" in place");
 848             else
 849                Write_Str (" copied to ");
 850                Write_Int (Int (Result));
 851             end if;
 852
 853             --  Write_Eol;
 854          end if;
 855       end Debug_Extend_Node;
 856
 857    --  Start of processing for Extend_Node
 858
 859    begin
 860       pragma Assert (not (Has_Extension (Node)));
 861       Result := Allocate_Initialize_Node (Node, With_Extension => True);
 862       pragma Debug (Debug_Extend_Node);
 863       return Result;
 864    end Extend_Node;
 865
 866    -----------------
 867    -- Fix_Parents --
 868    -----------------
 869
 870    procedure Fix_Parents (Ref_Node, Fix_Node : Node_Id) is
 871
 872       procedure Fix_Parent (Field : Union_Id);
 873       --  Fixup one parent pointer. Field is checked to see if it points to
 874       --  a node, list, or element list that has a parent that points to
 875       --  Ref_Node. If so, the parent is reset to point to Fix_Node.
 876
 877       ----------------
 878       -- Fix_Parent --
 879       ----------------
 880
 881       procedure Fix_Parent (Field : Union_Id) is
 882       begin
 883          --  Fix parent of node that is referenced by Field. Note that we must
 884          --  exclude the case where the node is a member of a list, because in
 885          --  this case the parent is the parent of the list.
 886
 887          if Field in Node_Range
 888            and then Present (Node_Id (Field))
 889            and then not Nodes.Table (Node_Id (Field)).In_List
 890            and then Parent (Node_Id (Field)) = Ref_Node
 891          then
 892             Set_Parent (Node_Id (Field), Fix_Node);
 893
 894          --  Fix parent of list that is referenced by Field
 895
 896          elsif Field in List_Range
 897            and then Present (List_Id (Field))
 898            and then Parent (List_Id (Field)) = Ref_Node
 899          then
 900             Set_Parent (List_Id (Field), Fix_Node);
 901          end if;
 902       end Fix_Parent;
 903
 904    --  Start of processing for Fix_Parents
 905
 906    begin
 907       Fix_Parent (Field1 (Fix_Node));
 908       Fix_Parent (Field2 (Fix_Node));
 909       Fix_Parent (Field3 (Fix_Node));
 910       Fix_Parent (Field4 (Fix_Node));
 911       Fix_Parent (Field5 (Fix_Node));
 912    end Fix_Parents;
 913
 914    -----------------------------------
 915    -- Get_Comes_From_Source_Default --
 916    -----------------------------------
 917
 918    function Get_Comes_From_Source_Default return Boolean is
 919    begin
 920       return Default_Node.Comes_From_Source;
 921    end Get_Comes_From_Source_Default;
 922
 923    -------------------
 924    -- Has_Extension --
 925    -------------------
 926
 927    function Has_Extension (N : Node_Id) return Boolean is
 928    begin
 929       return N < Nodes.Last and then Nodes.Table (N + 1).Is_Extension;
 930    end Has_Extension;
 931
 932    ----------------
 933    -- Initialize --
 934    ----------------
 935
 936    procedure Initialize is
 937       Dummy : Node_Id;
 938       pragma Warnings (Off, Dummy);
 939
 940    begin
 941       Node_Count := 0;
 942       Atree_Private_Part.Nodes.Init;
 943       Orig_Nodes.Init;
 944       Paren_Counts.Init;
 945
 946       --  Allocate Empty node
 947
 948       Dummy := New_Node (N_Empty, No_Location);
 949       Set_Name1 (Empty, No_Name);
 950
 951       --  Allocate Error node, and set Error_Posted, since we certainly
 952       --  only generate an Error node if we do post some kind of error!
 953
 954       Dummy := New_Node (N_Error, No_Location);
 955       Set_Name1 (Error, Error_Name);
 956       Set_Error_Posted (Error, True);
 957    end Initialize;
 958
 959    --------------------------
 960    -- Is_Rewrite_Insertion --
 961    --------------------------
 962
 963    function Is_Rewrite_Insertion (Node : Node_Id) return Boolean is
 964    begin
 965       return Nodes.Table (Node).Rewrite_Ins;
 966    end Is_Rewrite_Insertion;
 967
 968    -----------------------------
 969    -- Is_Rewrite_Substitution --
 970    -----------------------------
 971
 972    function Is_Rewrite_Substitution (Node : Node_Id) return Boolean is
 973    begin
 974       return Orig_Nodes.Table (Node) /= Node;
 975    end Is_Rewrite_Substitution;
 976
 977    ------------------
 978    -- Last_Node_Id --
 979    ------------------
 980
 981    function Last_Node_Id return Node_Id is
 982    begin
 983       return Nodes.Last;
 984    end Last_Node_Id;
 985
 986    ----------
 987    -- Lock --
 988    ----------
 989
 990    procedure Lock is
 991    begin
 992       Nodes.Locked := True;
 993       Orig_Nodes.Locked := True;
 994       Nodes.Release;
 995       Orig_Nodes.Release;
 996    end Lock;
 997
 998    ----------------------------
 999    -- Mark_Rewrite_Insertion --
1000    ----------------------------
1001
1002    procedure Mark_Rewrite_Insertion (New_Node : Node_Id) is
1003    begin
1004       Nodes.Table (New_Node).Rewrite_Ins := True;
1005    end Mark_Rewrite_Insertion;
1006
1007    --------------
1008    -- New_Copy --
1009    --------------
1010
1011    function New_Copy (Source : Node_Id) return Node_Id is
1012       New_Id : Node_Id := Source;
1013
1014    begin
1015       if Source > Empty_Or_Error then
1016
1017          New_Id := Allocate_Initialize_Node (Source, Has_Extension (Source));
1018
1019          Nodes.Table (New_Id).Link := Empty_List_Or_Node;
1020          Nodes.Table (New_Id).In_List := False;
1021
1022          --  If the original is marked as a rewrite insertion, then unmark
1023          --  the copy, since we inserted the original, not the copy.
1024
1025          Nodes.Table (New_Id).Rewrite_Ins := False;
1026          pragma Debug (New_Node_Debugging_Output (New_Id));
1027       end if;
1028
1029       return New_Id;
1030    end New_Copy;
1031
1032    ----------------
1033    -- New_Entity --
1034    ----------------
1035
1036    function New_Entity
1037      (New_Node_Kind : Node_Kind;
1038       New_Sloc      : Source_Ptr) return Entity_Id
1039    is
1040       Ent : Entity_Id;
1041
1042    begin
1043       pragma Assert (New_Node_Kind in N_Entity);
1044
1045       Ent := Allocate_Initialize_Node (Empty, With_Extension => True);
1046
1047       --  If this is a node with a real location and we are generating
1048       --  source nodes, then reset Current_Error_Node. This is useful
1049       --  if we bomb during parsing to get a error location for the bomb.
1050
1051       if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1052          Current_Error_Node := Ent;
1053       end if;
1054
1055       Nodes.Table (Ent).Nkind  := New_Node_Kind;
1056       Nodes.Table (Ent).Sloc   := New_Sloc;
1057       pragma Debug (New_Node_Debugging_Output (Ent));
1058
1059       return Ent;
1060    end New_Entity;
1061
1062    --------------
1063    -- New_Node --
1064    --------------
1065
1066    function New_Node
1067      (New_Node_Kind : Node_Kind;
1068       New_Sloc      : Source_Ptr) return Node_Id
1069    is
1070       Nod : Node_Id;
1071
1072    begin
1073       pragma Assert (New_Node_Kind not in N_Entity);
1074       Nod := Allocate_Initialize_Node (Empty, With_Extension => False);
1075       Nodes.Table (Nod).Nkind := New_Node_Kind;
1076       Nodes.Table (Nod).Sloc  := New_Sloc;
1077       pragma Debug (New_Node_Debugging_Output (Nod));
1078
1079       --  If this is a node with a real location and we are generating source
1080       --  nodes, then reset Current_Error_Node. This is useful if we bomb
1081       --  during parsing to get an error location for the bomb.
1082
1083       if Default_Node.Comes_From_Source and then New_Sloc > No_Location then
1084          Current_Error_Node := Nod;
1085       end if;
1086
1087       return Nod;
1088    end New_Node;
1089
1090    -------------------------
1091    -- New_Node_Breakpoint --
1092    -------------------------
1093
1094    procedure nn is -- New_Node_Breakpoint
1095    begin
1096       Write_Str ("Watched node ");
1097       Write_Int (Int (Watch_Node));
1098       Write_Str (" created");
1099       Write_Eol;
1100    end nn;
1101
1102    -------------------------------
1103    -- New_Node_Debugging_Output --
1104    -------------------------------
1105
1106    procedure nnd (N : Node_Id) is -- New_Node_Debugging_Output
1107       Node_Is_Watched : constant Boolean := N = Watch_Node;
1108
1109    begin
1110       if Debug_Flag_N or else Node_Is_Watched then
1111          Write_Str ("Allocate ");
1112
1113          if Nkind (N) in N_Entity then
1114             Write_Str ("entity");
1115          else
1116             Write_Str ("node");
1117          end if;
1118
1119          Write_Str (", Id = ");
1120          Write_Int (Int (N));
1121          Write_Str ("  ");
1122          Write_Location (Sloc (N));
1123          Write_Str ("  ");
1124          Write_Str (Node_Kind'Image (Nkind (N)));
1125          Write_Eol;
1126
1127          if Node_Is_Watched then
1128             New_Node_Breakpoint;
1129          end if;
1130       end if;
1131    end nnd;
1132
1133    -----------
1134    -- Nkind --
1135    -----------
1136
1137    function Nkind (N : Node_Id) return Node_Kind is
1138    begin
1139       return Nodes.Table (N).Nkind;
1140    end Nkind;
1141
1142    --------------
1143    -- Nkind_In --
1144    --------------
1145
1146    function Nkind_In
1147      (N  : Node_Id;
1148       V1 : Node_Kind;
1149       V2 : Node_Kind) return Boolean
1150    is
1151    begin
1152       return Nkind_In (Nkind (N), V1, V2);
1153    end Nkind_In;
1154
1155    function Nkind_In
1156      (N  : Node_Id;
1157       V1 : Node_Kind;
1158       V2 : Node_Kind;
1159       V3 : Node_Kind) return Boolean
1160    is
1161    begin
1162       return Nkind_In (Nkind (N), V1, V2, V3);
1163    end Nkind_In;
1164
1165    function Nkind_In
1166      (N  : Node_Id;
1167       V1 : Node_Kind;
1168       V2 : Node_Kind;
1169       V3 : Node_Kind;
1170       V4 : Node_Kind) return Boolean
1171    is
1172    begin
1173       return Nkind_In (Nkind (N), V1, V2, V3, V4);
1174    end Nkind_In;
1175
1176    function Nkind_In
1177      (N  : Node_Id;
1178       V1 : Node_Kind;
1179       V2 : Node_Kind;
1180       V3 : Node_Kind;
1181       V4 : Node_Kind;
1182       V5 : Node_Kind) return Boolean
1183    is
1184    begin
1185       return Nkind_In (Nkind (N), V1, V2, V3, V4, V5);
1186    end Nkind_In;
1187
1188    function Nkind_In
1189      (N  : Node_Id;
1190       V1 : Node_Kind;
1191       V2 : Node_Kind;
1192       V3 : Node_Kind;
1193       V4 : Node_Kind;
1194       V5 : Node_Kind;
1195       V6 : Node_Kind) return Boolean
1196    is
1197    begin
1198       return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6);
1199    end Nkind_In;
1200
1201    function Nkind_In
1202      (N  : Node_Id;
1203       V1 : Node_Kind;
1204       V2 : Node_Kind;
1205       V3 : Node_Kind;
1206       V4 : Node_Kind;
1207       V5 : Node_Kind;
1208       V6 : Node_Kind;
1209       V7 : Node_Kind) return Boolean
1210    is
1211    begin
1212       return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7);
1213    end Nkind_In;
1214
1215    function Nkind_In
1216      (N  : Node_Id;
1217       V1 : Node_Kind;
1218       V2 : Node_Kind;
1219       V3 : Node_Kind;
1220       V4 : Node_Kind;
1221       V5 : Node_Kind;
1222       V6 : Node_Kind;
1223       V7 : Node_Kind;
1224       V8 : Node_Kind) return Boolean
1225    is
1226    begin
1227       return Nkind_In (Nkind (N), V1, V2, V3, V4, V5, V6, V7, V8);
1228    end Nkind_In;
1229
1230    --------
1231    -- No --
1232    --------
1233
1234    function No (N : Node_Id) return Boolean is
1235    begin
1236       return N = Empty;
1237    end No;
1238
1239    -------------------
1240    -- Nodes_Address --
1241    -------------------
1242
1243    function Nodes_Address return System.Address is
1244    begin
1245       return Nodes.Table (First_Node_Id)'Address;
1246    end Nodes_Address;
1247
1248    ---------------
1249    -- Num_Nodes --
1250    ---------------
1251
1252    function Num_Nodes return Nat is
1253    begin
1254       return Node_Count;
1255    end Num_Nodes;
1256
1257    -------------------
1258    -- Original_Node --
1259    -------------------
1260
1261    function Original_Node (Node : Node_Id) return Node_Id is
1262    begin
1263       return Orig_Nodes.Table (Node);
1264    end Original_Node;
1265
1266    -----------------
1267    -- Paren_Count --
1268    -----------------
1269
1270    function Paren_Count (N : Node_Id) return Nat is
1271       C : Nat := 0;
1272
1273    begin
1274       pragma Assert (N <= Nodes.Last);
1275
1276       if Nodes.Table (N).Pflag1 then
1277          C := C + 1;
1278       end if;
1279
1280       if Nodes.Table (N).Pflag2 then
1281          C := C + 2;
1282       end if;
1283
1284       --  Value of 0,1,2 returned as is
1285
1286       if C <= 2 then
1287          return C;
1288
1289       --  Value of 3 means we search the table, and we must find an entry
1290
1291       else
1292          for J in Paren_Counts.First .. Paren_Counts.Last loop
1293             if N = Paren_Counts.Table (J).Nod then
1294                return Paren_Counts.Table (J).Count;
1295             end if;
1296          end loop;
1297
1298          raise Program_Error;
1299       end if;
1300    end Paren_Count;
1301
1302    ------------
1303    -- Parent --
1304    ------------
1305
1306    function Parent (N : Node_Id) return Node_Id is
1307    begin
1308       if Is_List_Member (N) then
1309          return Parent (List_Containing (N));
1310       else
1311          return Node_Id (Nodes.Table (N).Link);
1312       end if;
1313    end Parent;
1314
1315    -------------
1316    -- Present --
1317    -------------
1318
1319    function Present (N : Node_Id) return Boolean is
1320    begin
1321       return N /= Empty;
1322    end Present;
1323
1324    --------------------------------
1325    -- Preserve_Comes_From_Source --
1326    --------------------------------
1327
1328    procedure Preserve_Comes_From_Source (NewN, OldN : Node_Id) is
1329    begin
1330       Nodes.Table (NewN).Comes_From_Source :=
1331         Nodes.Table (OldN).Comes_From_Source;
1332    end Preserve_Comes_From_Source;
1333
1334    -------------------
1335    -- Relocate_Node --
1336    -------------------
1337
1338    function Relocate_Node (Source : Node_Id) return Node_Id is
1339       New_Node : Node_Id;
1340
1341    begin
1342       if No (Source) then
1343          return Empty;
1344       end if;
1345
1346       New_Node := New_Copy (Source);
1347       Fix_Parents (Ref_Node => Source, Fix_Node => New_Node);
1348
1349       --  We now set the parent of the new node to be the same as the
1350       --  parent of the source. Almost always this parent will be
1351       --  replaced by a new value when the relocated node is reattached
1352       --  to the tree, but by doing it now, we ensure that this node is
1353       --  not even temporarily disconnected from the tree. Note that this
1354       --  does not happen free, because in the list case, the parent does
1355       --  not get set.
1356
1357       Set_Parent (New_Node, Parent (Source));
1358
1359       --  If the node being relocated was a rewriting of some original
1360       --  node, then the relocated node has the same original node.
1361
1362       if Orig_Nodes.Table (Source) /= Source then
1363          Orig_Nodes.Table (New_Node) := Orig_Nodes.Table (Source);
1364       end if;
1365
1366       return New_Node;
1367    end Relocate_Node;
1368
1369    -------------
1370    -- Replace --
1371    -------------
1372
1373    procedure Replace (Old_Node, New_Node : Node_Id) is
1374       Old_Post : constant Boolean  := Nodes.Table (Old_Node).Error_Posted;
1375       Old_CFS  : constant Boolean  := Nodes.Table (Old_Node).Comes_From_Source;
1376
1377    begin
1378       pragma Assert
1379         (not Has_Extension (Old_Node)
1380            and not Has_Extension (New_Node)
1381            and not Nodes.Table (New_Node).In_List);
1382
1383       --  Do copy, preserving link and in list status and comes from source
1384
1385       Copy_Node (Source => New_Node, Destination => Old_Node);
1386       Nodes.Table (Old_Node).Comes_From_Source := Old_CFS;
1387       Nodes.Table (Old_Node).Error_Posted      := Old_Post;
1388
1389       --  Fix parents of substituted node, since it has changed identity
1390
1391       Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1392
1393       --  Since we are doing a replace, we assume that the original node
1394       --  is intended to become the new replaced node. The call would be
1395       --  to Rewrite if there were an intention to save the original node.
1396
1397       Orig_Nodes.Table (Old_Node) := Old_Node;
1398    end Replace;
1399
1400    -------------
1401    -- Rewrite --
1402    -------------
1403
1404    procedure Rewrite (Old_Node, New_Node : Node_Id) is
1405       Old_Error_P : constant Boolean  := Nodes.Table (Old_Node).Error_Posted;
1406       --  This fields is always preserved in the new node
1407
1408       Old_Paren_Count     : Nat;
1409       Old_Must_Not_Freeze : Boolean;
1410       --  These fields are preserved in the new node only if the new node
1411       --  and the old node are both subexpression nodes.
1412
1413       --  Note: it is a violation of abstraction levels for Must_Not_Freeze
1414       --  to be referenced like this. ???
1415
1416       Sav_Node : Node_Id;
1417
1418    begin
1419       pragma Assert
1420         (not Has_Extension (Old_Node)
1421            and not Has_Extension (New_Node)
1422            and not Nodes.Table (New_Node).In_List);
1423
1424       if Nkind (Old_Node) in N_Subexpr then
1425          Old_Paren_Count     := Paren_Count (Old_Node);
1426          Old_Must_Not_Freeze := Must_Not_Freeze (Old_Node);
1427       else
1428          Old_Paren_Count := 0;
1429          Old_Must_Not_Freeze := False;
1430       end if;
1431
1432       --  Allocate a new node, to be used to preserve the original contents
1433       --  of the Old_Node, for possible later retrival by Original_Node and
1434       --  make an entry in the Orig_Nodes table. This is only done if we have
1435       --  not already rewritten the node, as indicated by an Orig_Nodes entry
1436       --  that does not reference the Old_Node.
1437
1438       if Orig_Nodes.Table (Old_Node) = Old_Node then
1439          Sav_Node := New_Copy (Old_Node);
1440          Orig_Nodes.Table (Sav_Node) := Sav_Node;
1441          Orig_Nodes.Table (Old_Node) := Sav_Node;
1442       end if;
1443
1444       --  Copy substitute node into place, preserving old fields as required
1445
1446       Copy_Node (Source => New_Node, Destination => Old_Node);
1447       Nodes.Table (Old_Node).Error_Posted := Old_Error_P;
1448
1449       if Nkind (New_Node) in N_Subexpr then
1450          Set_Paren_Count     (Old_Node, Old_Paren_Count);
1451          Set_Must_Not_Freeze (Old_Node, Old_Must_Not_Freeze);
1452       end if;
1453
1454       Fix_Parents (Ref_Node => New_Node, Fix_Node => Old_Node);
1455    end Rewrite;
1456
1457    ------------------
1458    -- Set_Analyzed --
1459    ------------------
1460
1461    procedure Set_Analyzed (N : Node_Id; Val : Boolean := True) is
1462    begin
1463       Nodes.Table (N).Analyzed := Val;
1464    end Set_Analyzed;
1465
1466    ---------------------------
1467    -- Set_Comes_From_Source --
1468    ---------------------------
1469
1470    procedure Set_Comes_From_Source (N : Node_Id; Val : Boolean) is
1471    begin
1472       pragma Assert (N <= Nodes.Last);
1473       Nodes.Table (N).Comes_From_Source := Val;
1474    end Set_Comes_From_Source;
1475
1476    -----------------------------------
1477    -- Set_Comes_From_Source_Default --
1478    -----------------------------------
1479
1480    procedure Set_Comes_From_Source_Default (Default : Boolean) is
1481    begin
1482       Default_Node.Comes_From_Source := Default;
1483    end Set_Comes_From_Source_Default;
1484
1485    ---------------
1486    -- Set_Ekind --
1487    ---------------
1488
1489    procedure Set_Ekind (E : Entity_Id; Val : Entity_Kind) is
1490    begin
1491       pragma Assert (Nkind (E) in N_Entity);
1492       Nodes.Table (E + 1).Nkind := E_To_N (Val);
1493    end Set_Ekind;
1494
1495    ----------------------
1496    -- Set_Error_Posted --
1497    ----------------------
1498
1499    procedure Set_Error_Posted (N : Node_Id; Val : Boolean := True) is
1500    begin
1501       Nodes.Table (N).Error_Posted := Val;
1502    end Set_Error_Posted;
1503
1504    ---------------------
1505    -- Set_Paren_Count --
1506    ---------------------
1507
1508    procedure Set_Paren_Count (N : Node_Id; Val : Nat) is
1509    begin
1510       pragma Assert (Nkind (N) in N_Subexpr);
1511
1512       --  Value of 0,1,2 stored as is
1513
1514       if Val <= 2 then
1515          Nodes.Table (N).Pflag1 := (Val mod 2 /= 0);
1516          Nodes.Table (N).Pflag2 := (Val = 2);
1517
1518       --  Value of 3 or greater stores 3 in node and makes table entry
1519
1520       else
1521          Nodes.Table (N).Pflag1 := True;
1522          Nodes.Table (N).Pflag2 := True;
1523
1524          for J in Paren_Counts.First .. Paren_Counts.Last loop
1525             if N = Paren_Counts.Table (J).Nod then
1526                Paren_Counts.Table (J).Count := Val;
1527                return;
1528             end if;
1529          end loop;
1530
1531          Paren_Counts.Append ((Nod => N, Count => Val));
1532       end if;
1533    end Set_Paren_Count;
1534
1535    ----------------
1536    -- Set_Parent --
1537    ----------------
1538
1539    procedure Set_Parent (N : Node_Id; Val : Node_Id) is
1540    begin
1541       pragma Assert (not Nodes.Table (N).In_List);
1542       Nodes.Table (N).Link := Union_Id (Val);
1543    end Set_Parent;
1544
1545    --------------
1546    -- Set_Sloc --
1547    --------------
1548
1549    procedure Set_Sloc (N : Node_Id; Val : Source_Ptr) is
1550    begin
1551       Nodes.Table (N).Sloc := Val;
1552    end Set_Sloc;
1553
1554    ----------
1555    -- Sloc --
1556    ----------
1557
1558    function Sloc (N : Node_Id) return Source_Ptr is
1559    begin
1560       return Nodes.Table (N).Sloc;
1561    end Sloc;
1562
1563    -------------------
1564    -- Traverse_Func --
1565    -------------------
1566
1567    function Traverse_Func (Node : Node_Id) return Traverse_Final_Result is
1568
1569       function Traverse_Field
1570         (Nod : Node_Id;
1571          Fld : Union_Id;
1572          FN  : Field_Num) return Traverse_Final_Result;
1573       --  Fld is one of the fields of Nod. If the field points to syntactic
1574       --  node or list, then this node or list is traversed, and the result is
1575       --  the result of this traversal. Otherwise a value of True is returned
1576       --  with no processing. FN is the number of the field (1 .. 5).
1577
1578       --------------------
1579       -- Traverse_Field --
1580       --------------------
1581
1582       function Traverse_Field
1583         (Nod : Node_Id;
1584          Fld : Union_Id;
1585          FN  : Field_Num) return Traverse_Final_Result
1586       is
1587       begin
1588          if Fld = Union_Id (Empty) then
1589             return OK;
1590
1591          --  Descendent is a node
1592
1593          elsif Fld in Node_Range then
1594
1595             --  Traverse descendent that is syntactic subtree node
1596
1597             if Is_Syntactic_Field (Nkind (Nod), FN) then
1598                return Traverse_Func (Node_Id (Fld));
1599
1600             --  Node that is not a syntactic subtree
1601
1602             else
1603                return OK;
1604             end if;
1605
1606          --  Descendent is a list
1607
1608          elsif Fld in List_Range then
1609
1610             --  Traverse descendent that is a syntactic subtree list
1611
1612             if Is_Syntactic_Field (Nkind (Nod), FN) then
1613                declare
1614                   Elmt : Node_Id := First (List_Id (Fld));
1615                begin
1616                   while Present (Elmt) loop
1617                      if Traverse_Func (Elmt) = Abandon then
1618                         return Abandon;
1619                      else
1620                         Next (Elmt);
1621                      end if;
1622                   end loop;
1623
1624                   return OK;
1625                end;
1626
1627             --  List that is not a syntactic subtree
1628
1629             else
1630                return OK;
1631             end if;
1632
1633          --  Field was not a node or a list
1634
1635          else
1636             return OK;
1637          end if;
1638       end Traverse_Field;
1639
1640       Cur_Node : Node_Id := Node;
1641
1642    --  Start of processing for Traverse_Func
1643
1644    begin
1645       --  We walk Field2 last, and if it is a node, we eliminate the tail
1646       --  recursion by jumping back to this label. This is because Field2 is
1647       --  where the Left_Opnd field of N_Op_Concat is stored, and in practice
1648       --  concatenations are sometimes deeply nested, as in X1&X2&...&XN. This
1649       --  trick prevents us from running out of memory in that case. We don't
1650       --  bother eliminating the tail recursion if Field2 is a list.
1651
1652       <<Tail_Recurse>>
1653
1654       case Process (Cur_Node) is
1655          when Abandon =>
1656             return Abandon;
1657
1658          when Skip =>
1659             return OK;
1660
1661          when OK =>
1662             null;
1663
1664          when OK_Orig =>
1665             Cur_Node := Original_Node (Cur_Node);
1666       end case;
1667
1668       if Traverse_Field (Cur_Node, Field1 (Cur_Node), 1) = Abandon
1669            or else  --  skip Field2 here
1670          Traverse_Field (Cur_Node, Field3 (Cur_Node), 3) = Abandon
1671            or else
1672          Traverse_Field (Cur_Node, Field4 (Cur_Node), 4) = Abandon
1673            or else
1674          Traverse_Field (Cur_Node, Field5 (Cur_Node), 5) = Abandon
1675       then
1676          return Abandon;
1677       end if;
1678
1679       if Field2 (Cur_Node) not in Node_Range then
1680          return Traverse_Field (Cur_Node, Field2 (Cur_Node), 2);
1681
1682       elsif Is_Syntactic_Field (Nkind (Cur_Node), 2)
1683         and then Field2 (Cur_Node) /= Empty_List_Or_Node
1684       then
1685          --  Here is the tail recursion step, we reset Cur_Node and jump back
1686          --  to the start of the procedure, which has the same semantic effect
1687          --  as a call.
1688
1689          Cur_Node := Node_Id (Field2 (Cur_Node));
1690          goto Tail_Recurse;
1691       end if;
1692
1693       return OK;
1694    end Traverse_Func;
1695
1696    -------------------
1697    -- Traverse_Proc --
1698    -------------------
1699
1700    procedure Traverse_Proc (Node : Node_Id) is
1701       function Traverse is new Traverse_Func (Process);
1702       Discard : Traverse_Final_Result;
1703       pragma Warnings (Off, Discard);
1704    begin
1705       Discard := Traverse (Node);
1706    end Traverse_Proc;
1707
1708    ---------------
1709    -- Tree_Read --
1710    ---------------
1711
1712    procedure Tree_Read is
1713    begin
1714       Tree_Read_Int (Node_Count);
1715       Nodes.Tree_Read;
1716       Orig_Nodes.Tree_Read;
1717       Paren_Counts.Tree_Read;
1718    end Tree_Read;
1719
1720    ----------------
1721    -- Tree_Write --
1722    ----------------
1723
1724    procedure Tree_Write is
1725    begin
1726       Tree_Write_Int (Node_Count);
1727       Nodes.Tree_Write;
1728       Orig_Nodes.Tree_Write;
1729       Paren_Counts.Tree_Write;
1730    end Tree_Write;
1731
1732    ------------------------------
1733    -- Unchecked Access Package --
1734    ------------------------------
1735
1736    package body Unchecked_Access is
1737
1738       function Field1 (N : Node_Id) return Union_Id is
1739       begin
1740          pragma Assert (N <= Nodes.Last);
1741          return Nodes.Table (N).Field1;
1742       end Field1;
1743
1744       function Field2 (N : Node_Id) return Union_Id is
1745       begin
1746          pragma Assert (N <= Nodes.Last);
1747          return Nodes.Table (N).Field2;
1748       end Field2;
1749
1750       function Field3 (N : Node_Id) return Union_Id is
1751       begin
1752          pragma Assert (N <= Nodes.Last);
1753          return Nodes.Table (N).Field3;
1754       end Field3;
1755
1756       function Field4 (N : Node_Id) return Union_Id is
1757       begin
1758          pragma Assert (N <= Nodes.Last);
1759          return Nodes.Table (N).Field4;
1760       end Field4;
1761
1762       function Field5 (N : Node_Id) return Union_Id is
1763       begin
1764          pragma Assert (N <= Nodes.Last);
1765          return Nodes.Table (N).Field5;
1766       end Field5;
1767
1768       function Field6 (N : Node_Id) return Union_Id is
1769       begin
1770          pragma Assert (Nkind (N) in N_Entity);
1771          return Nodes.Table (N + 1).Field6;
1772       end Field6;
1773
1774       function Field7 (N : Node_Id) return Union_Id is
1775       begin
1776          pragma Assert (Nkind (N) in N_Entity);
1777          return Nodes.Table (N + 1).Field7;
1778       end Field7;
1779
1780       function Field8 (N : Node_Id) return Union_Id is
1781       begin
1782          pragma Assert (Nkind (N) in N_Entity);
1783          return Nodes.Table (N + 1).Field8;
1784       end Field8;
1785
1786       function Field9 (N : Node_Id) return Union_Id is
1787       begin
1788          pragma Assert (Nkind (N) in N_Entity);
1789          return Nodes.Table (N + 1).Field9;
1790       end Field9;
1791
1792       function Field10 (N : Node_Id) return Union_Id is
1793       begin
1794          pragma Assert (Nkind (N) in N_Entity);
1795          return Nodes.Table (N + 1).Field10;
1796       end Field10;
1797
1798       function Field11 (N : Node_Id) return Union_Id is
1799       begin
1800          pragma Assert (Nkind (N) in N_Entity);
1801          return Nodes.Table (N + 1).Field11;
1802       end Field11;
1803
1804       function Field12 (N : Node_Id) return Union_Id is
1805       begin
1806          pragma Assert (Nkind (N) in N_Entity);
1807          return Nodes.Table (N + 1).Field12;
1808       end Field12;
1809
1810       function Field13 (N : Node_Id) return Union_Id is
1811       begin
1812          pragma Assert (Nkind (N) in N_Entity);
1813          return Nodes.Table (N + 2).Field6;
1814       end Field13;
1815
1816       function Field14 (N : Node_Id) return Union_Id is
1817       begin
1818          pragma Assert (Nkind (N) in N_Entity);
1819          return Nodes.Table (N + 2).Field7;
1820       end Field14;
1821
1822       function Field15 (N : Node_Id) return Union_Id is
1823       begin
1824          pragma Assert (Nkind (N) in N_Entity);
1825          return Nodes.Table (N + 2).Field8;
1826       end Field15;
1827
1828       function Field16 (N : Node_Id) return Union_Id is
1829       begin
1830          pragma Assert (Nkind (N) in N_Entity);
1831          return Nodes.Table (N + 2).Field9;
1832       end Field16;
1833
1834       function Field17 (N : Node_Id) return Union_Id is
1835       begin
1836          pragma Assert (Nkind (N) in N_Entity);
1837          return Nodes.Table (N + 2).Field10;
1838       end Field17;
1839
1840       function Field18 (N : Node_Id) return Union_Id is
1841       begin
1842          pragma Assert (Nkind (N) in N_Entity);
1843          return Nodes.Table (N + 2).Field11;
1844       end Field18;
1845
1846       function Field19 (N : Node_Id) return Union_Id is
1847       begin
1848          pragma Assert (Nkind (N) in N_Entity);
1849          return Nodes.Table (N + 3).Field6;
1850       end Field19;
1851
1852       function Field20 (N : Node_Id) return Union_Id is
1853       begin
1854          pragma Assert (Nkind (N) in N_Entity);
1855          return Nodes.Table (N + 3).Field7;
1856       end Field20;
1857
1858       function Field21 (N : Node_Id) return Union_Id is
1859       begin
1860          pragma Assert (Nkind (N) in N_Entity);
1861          return Nodes.Table (N + 3).Field8;
1862       end Field21;
1863
1864       function Field22 (N : Node_Id) return Union_Id is
1865       begin
1866          pragma Assert (Nkind (N) in N_Entity);
1867          return Nodes.Table (N + 3).Field9;
1868       end Field22;
1869
1870       function Field23 (N : Node_Id) return Union_Id is
1871       begin
1872          pragma Assert (Nkind (N) in N_Entity);
1873          return Nodes.Table (N + 3).Field10;
1874       end Field23;
1875
1876       function Field24 (N : Node_Id) return Union_Id is
1877       begin
1878          pragma Assert (Nkind (N) in N_Entity);
1879          return Nodes.Table (N + 4).Field6;
1880       end Field24;
1881
1882       function Field25 (N : Node_Id) return Union_Id is
1883       begin
1884          pragma Assert (Nkind (N) in N_Entity);
1885          return Nodes.Table (N + 4).Field7;
1886       end Field25;
1887
1888       function Field26 (N : Node_Id) return Union_Id is
1889       begin
1890          pragma Assert (Nkind (N) in N_Entity);
1891          return Nodes.Table (N + 4).Field8;
1892       end Field26;
1893
1894       function Field27 (N : Node_Id) return Union_Id is
1895       begin
1896          pragma Assert (Nkind (N) in N_Entity);
1897          return Nodes.Table (N + 4).Field9;
1898       end Field27;
1899
1900       function Field28 (N : Node_Id) return Union_Id is
1901       begin
1902          pragma Assert (Nkind (N) in N_Entity);
1903          return Nodes.Table (N + 4).Field10;
1904       end Field28;
1905
1906       function Node1 (N : Node_Id) return Node_Id is
1907       begin
1908          pragma Assert (N <= Nodes.Last);
1909          return Node_Id (Nodes.Table (N).Field1);
1910       end Node1;
1911
1912       function Node2 (N : Node_Id) return Node_Id is
1913       begin
1914          pragma Assert (N <= Nodes.Last);
1915          return Node_Id (Nodes.Table (N).Field2);
1916       end Node2;
1917
1918       function Node3 (N : Node_Id) return Node_Id is
1919       begin
1920          pragma Assert (N <= Nodes.Last);
1921          return Node_Id (Nodes.Table (N).Field3);
1922       end Node3;
1923
1924       function Node4 (N : Node_Id) return Node_Id is
1925       begin
1926          pragma Assert (N <= Nodes.Last);
1927          return Node_Id (Nodes.Table (N).Field4);
1928       end Node4;
1929
1930       function Node5 (N : Node_Id) return Node_Id is
1931       begin
1932          pragma Assert (N <= Nodes.Last);
1933          return Node_Id (Nodes.Table (N).Field5);
1934       end Node5;
1935
1936       function Node6 (N : Node_Id) return Node_Id is
1937       begin
1938          pragma Assert (Nkind (N) in N_Entity);
1939          return Node_Id (Nodes.Table (N + 1).Field6);
1940       end Node6;
1941
1942       function Node7 (N : Node_Id) return Node_Id is
1943       begin
1944          pragma Assert (Nkind (N) in N_Entity);
1945          return Node_Id (Nodes.Table (N + 1).Field7);
1946       end Node7;
1947
1948       function Node8 (N : Node_Id) return Node_Id is
1949       begin
1950          pragma Assert (Nkind (N) in N_Entity);
1951          return Node_Id (Nodes.Table (N + 1).Field8);
1952       end Node8;
1953
1954       function Node9 (N : Node_Id) return Node_Id is
1955       begin
1956          pragma Assert (Nkind (N) in N_Entity);
1957          return Node_Id (Nodes.Table (N + 1).Field9);
1958       end Node9;
1959
1960       function Node10 (N : Node_Id) return Node_Id is
1961       begin
1962          pragma Assert (Nkind (N) in N_Entity);
1963          return Node_Id (Nodes.Table (N + 1).Field10);
1964       end Node10;
1965
1966       function Node11 (N : Node_Id) return Node_Id is
1967       begin
1968          pragma Assert (Nkind (N) in N_Entity);
1969          return Node_Id (Nodes.Table (N + 1).Field11);
1970       end Node11;
1971
1972       function Node12 (N : Node_Id) return Node_Id is
1973       begin
1974          pragma Assert (Nkind (N) in N_Entity);
1975          return Node_Id (Nodes.Table (N + 1).Field12);
1976       end Node12;
1977
1978       function Node13 (N : Node_Id) return Node_Id is
1979       begin
1980          pragma Assert (Nkind (N) in N_Entity);
1981          return Node_Id (Nodes.Table (N + 2).Field6);
1982       end Node13;
1983
1984       function Node14 (N : Node_Id) return Node_Id is
1985       begin
1986          pragma Assert (Nkind (N) in N_Entity);
1987          return Node_Id (Nodes.Table (N + 2).Field7);
1988       end Node14;
1989
1990       function Node15 (N : Node_Id) return Node_Id is
1991       begin
1992          pragma Assert (Nkind (N) in N_Entity);
1993          return Node_Id (Nodes.Table (N + 2).Field8);
1994       end Node15;
1995
1996       function Node16 (N : Node_Id) return Node_Id is
1997       begin
1998          pragma Assert (Nkind (N) in N_Entity);
1999          return Node_Id (Nodes.Table (N + 2).Field9);
2000       end Node16;
2001
2002       function Node17 (N : Node_Id) return Node_Id is
2003       begin
2004          pragma Assert (Nkind (N) in N_Entity);
2005          return Node_Id (Nodes.Table (N + 2).Field10);
2006       end Node17;
2007
2008       function Node18 (N : Node_Id) return Node_Id is
2009       begin
2010          pragma Assert (Nkind (N) in N_Entity);
2011          return Node_Id (Nodes.Table (N + 2).Field11);
2012       end Node18;
2013
2014       function Node19 (N : Node_Id) return Node_Id is
2015       begin
2016          pragma Assert (Nkind (N) in N_Entity);
2017          return Node_Id (Nodes.Table (N + 3).Field6);
2018       end Node19;
2019
2020       function Node20 (N : Node_Id) return Node_Id is
2021       begin
2022          pragma Assert (Nkind (N) in N_Entity);
2023          return Node_Id (Nodes.Table (N + 3).Field7);
2024       end Node20;
2025
2026       function Node21 (N : Node_Id) return Node_Id is
2027       begin
2028          pragma Assert (Nkind (N) in N_Entity);
2029          return Node_Id (Nodes.Table (N + 3).Field8);
2030       end Node21;
2031
2032       function Node22 (N : Node_Id) return Node_Id is
2033       begin
2034          pragma Assert (Nkind (N) in N_Entity);
2035          return Node_Id (Nodes.Table (N + 3).Field9);
2036       end Node22;
2037
2038       function Node23 (N : Node_Id) return Node_Id is
2039       begin
2040          pragma Assert (Nkind (N) in N_Entity);
2041          return Node_Id (Nodes.Table (N + 3).Field10);
2042       end Node23;
2043
2044       function Node24 (N : Node_Id) return Node_Id is
2045       begin
2046          pragma Assert (Nkind (N) in N_Entity);
2047          return Node_Id (Nodes.Table (N + 4).Field6);
2048       end Node24;
2049
2050       function Node25 (N : Node_Id) return Node_Id is
2051       begin
2052          pragma Assert (Nkind (N) in N_Entity);
2053          return Node_Id (Nodes.Table (N + 4).Field7);
2054       end Node25;
2055
2056       function Node26 (N : Node_Id) return Node_Id is
2057       begin
2058          pragma Assert (Nkind (N) in N_Entity);
2059          return Node_Id (Nodes.Table (N + 4).Field8);
2060       end Node26;
2061
2062       function Node27 (N : Node_Id) return Node_Id is
2063       begin
2064          pragma Assert (Nkind (N) in N_Entity);
2065          return Node_Id (Nodes.Table (N + 4).Field9);
2066       end Node27;
2067
2068       function Node28 (N : Node_Id) return Node_Id is
2069       begin
2070          pragma Assert (Nkind (N) in N_Entity);
2071          return Node_Id (Nodes.Table (N + 4).Field10);
2072       end Node28;
2073
2074       function List1 (N : Node_Id) return List_Id is
2075       begin
2076          pragma Assert (N <= Nodes.Last);
2077          return List_Id (Nodes.Table (N).Field1);
2078       end List1;
2079
2080       function List2 (N : Node_Id) return List_Id is
2081       begin
2082          pragma Assert (N <= Nodes.Last);
2083          return List_Id (Nodes.Table (N).Field2);
2084       end List2;
2085
2086       function List3 (N : Node_Id) return List_Id is
2087       begin
2088          pragma Assert (N <= Nodes.Last);
2089          return List_Id (Nodes.Table (N).Field3);
2090       end List3;
2091
2092       function List4 (N : Node_Id) return List_Id is
2093       begin
2094          pragma Assert (N <= Nodes.Last);
2095          return List_Id (Nodes.Table (N).Field4);
2096       end List4;
2097
2098       function List5 (N : Node_Id) return List_Id is
2099       begin
2100          pragma Assert (N <= Nodes.Last);
2101          return List_Id (Nodes.Table (N).Field5);
2102       end List5;
2103
2104       function List10 (N : Node_Id) return List_Id is
2105       begin
2106          pragma Assert (Nkind (N) in N_Entity);
2107          return List_Id (Nodes.Table (N + 1).Field10);
2108       end List10;
2109
2110       function List14 (N : Node_Id) return List_Id is
2111       begin
2112          pragma Assert (Nkind (N) in N_Entity);
2113          return List_Id (Nodes.Table (N + 2).Field7);
2114       end List14;
2115
2116       function Elist1 (N : Node_Id) return Elist_Id is
2117          pragma Assert (N <= Nodes.Last);
2118          Value : constant Union_Id := Nodes.Table (N).Field1;
2119       begin
2120          if Value = 0 then
2121             return No_Elist;
2122          else
2123             return Elist_Id (Value);
2124          end if;
2125       end Elist1;
2126
2127       function Elist2 (N : Node_Id) return Elist_Id is
2128          pragma Assert (N <= Nodes.Last);
2129          Value : constant Union_Id := Nodes.Table (N).Field2;
2130       begin
2131          if Value = 0 then
2132             return No_Elist;
2133          else
2134             return Elist_Id (Value);
2135          end if;
2136       end Elist2;
2137
2138       function Elist3 (N : Node_Id) return Elist_Id is
2139          pragma Assert (N <= Nodes.Last);
2140          Value : constant Union_Id := Nodes.Table (N).Field3;
2141       begin
2142          if Value = 0 then
2143             return No_Elist;
2144          else
2145             return Elist_Id (Value);
2146          end if;
2147       end Elist3;
2148
2149       function Elist4 (N : Node_Id) return Elist_Id is
2150          pragma Assert (N <= Nodes.Last);
2151          Value : constant Union_Id := Nodes.Table (N).Field4;
2152       begin
2153          if Value = 0 then
2154             return No_Elist;
2155          else
2156             return Elist_Id (Value);
2157          end if;
2158       end Elist4;
2159
2160       function Elist8 (N : Node_Id) return Elist_Id is
2161          pragma Assert (Nkind (N) in N_Entity);
2162          Value : constant Union_Id := Nodes.Table (N + 1).Field8;
2163       begin
2164          if Value = 0 then
2165             return No_Elist;
2166          else
2167             return Elist_Id (Value);
2168          end if;
2169       end Elist8;
2170
2171       function Elist13 (N : Node_Id) return Elist_Id is
2172          pragma Assert (Nkind (N) in N_Entity);
2173          Value : constant Union_Id := Nodes.Table (N + 2).Field6;
2174       begin
2175          if Value = 0 then
2176             return No_Elist;
2177          else
2178             return Elist_Id (Value);
2179          end if;
2180       end Elist13;
2181
2182       function Elist15 (N : Node_Id) return Elist_Id is
2183          pragma Assert (Nkind (N) in N_Entity);
2184          Value : constant Union_Id := Nodes.Table (N + 2).Field8;
2185       begin
2186          if Value = 0 then
2187             return No_Elist;
2188          else
2189             return Elist_Id (Value);
2190          end if;
2191       end Elist15;
2192
2193       function Elist16 (N : Node_Id) return Elist_Id is
2194          pragma Assert (Nkind (N) in N_Entity);
2195          Value : constant Union_Id := Nodes.Table (N + 2).Field9;
2196       begin
2197          if Value = 0 then
2198             return No_Elist;
2199          else
2200             return Elist_Id (Value);
2201          end if;
2202       end Elist16;
2203
2204       function Elist18 (N : Node_Id) return Elist_Id is
2205          pragma Assert (Nkind (N) in N_Entity);
2206          Value : constant Union_Id := Nodes.Table (N + 2).Field11;
2207       begin
2208          if Value = 0 then
2209             return No_Elist;
2210          else
2211             return Elist_Id (Value);
2212          end if;
2213       end Elist18;
2214
2215       function Elist21 (N : Node_Id) return Elist_Id is
2216          pragma Assert (Nkind (N) in N_Entity);
2217          Value : constant Union_Id := Nodes.Table (N + 3).Field8;
2218       begin
2219          if Value = 0 then
2220             return No_Elist;
2221          else
2222             return Elist_Id (Value);
2223          end if;
2224       end Elist21;
2225
2226       function Elist23 (N : Node_Id) return Elist_Id is
2227          pragma Assert (Nkind (N) in N_Entity);
2228          Value : constant Union_Id := Nodes.Table (N + 3).Field10;
2229       begin
2230          if Value = 0 then
2231             return No_Elist;
2232          else
2233             return Elist_Id (Value);
2234          end if;
2235       end Elist23;
2236
2237       function Elist25 (N : Node_Id) return Elist_Id is
2238          pragma Assert (Nkind (N) in N_Entity);
2239          Value : constant Union_Id := Nodes.Table (N + 4).Field7;
2240       begin
2241          if Value = 0 then
2242             return No_Elist;
2243          else
2244             return Elist_Id (Value);
2245          end if;
2246       end Elist25;
2247
2248       function Elist26 (N : Node_Id) return Elist_Id is
2249          pragma Assert (Nkind (N) in N_Entity);
2250          Value : constant Union_Id := Nodes.Table (N + 4).Field8;
2251       begin
2252          if Value = 0 then
2253             return No_Elist;
2254          else
2255             return Elist_Id (Value);
2256          end if;
2257       end Elist26;
2258
2259       function Name1 (N : Node_Id) return Name_Id is
2260       begin
2261          pragma Assert (N <= Nodes.Last);
2262          return Name_Id (Nodes.Table (N).Field1);
2263       end Name1;
2264
2265       function Name2 (N : Node_Id) return Name_Id is
2266       begin
2267          pragma Assert (N <= Nodes.Last);
2268          return Name_Id (Nodes.Table (N).Field2);
2269       end Name2;
2270
2271       function Str3 (N : Node_Id) return String_Id is
2272       begin
2273          pragma Assert (N <= Nodes.Last);
2274          return String_Id (Nodes.Table (N).Field3);
2275       end Str3;
2276
2277       function Uint2 (N : Node_Id) return Uint is
2278          pragma Assert (N <= Nodes.Last);
2279          U : constant Union_Id := Nodes.Table (N).Field2;
2280       begin
2281          if U = 0 then
2282             return Uint_0;
2283          else
2284             return From_Union (U);
2285          end if;
2286       end Uint2;
2287
2288       function Uint3 (N : Node_Id) return Uint is
2289          pragma Assert (N <= Nodes.Last);
2290          U : constant Union_Id := Nodes.Table (N).Field3;
2291       begin
2292          if U = 0 then
2293             return Uint_0;
2294          else
2295             return From_Union (U);
2296          end if;
2297       end Uint3;
2298
2299       function Uint4 (N : Node_Id) return Uint is
2300          pragma Assert (N <= Nodes.Last);
2301          U : constant Union_Id := Nodes.Table (N).Field4;
2302       begin
2303          if U = 0 then
2304             return Uint_0;
2305          else
2306             return From_Union (U);
2307          end if;
2308       end Uint4;
2309
2310       function Uint5 (N : Node_Id) return Uint is
2311          pragma Assert (N <= Nodes.Last);
2312          U : constant Union_Id := Nodes.Table (N).Field5;
2313       begin
2314          if U = 0 then
2315             return Uint_0;
2316          else
2317             return From_Union (U);
2318          end if;
2319       end Uint5;
2320
2321       function Uint8 (N : Node_Id) return Uint is
2322          pragma Assert (Nkind (N) in N_Entity);
2323          U : constant Union_Id := Nodes.Table (N + 1).Field8;
2324       begin
2325          if U = 0 then
2326             return Uint_0;
2327          else
2328             return From_Union (U);
2329          end if;
2330       end Uint8;
2331
2332       function Uint9 (N : Node_Id) return Uint is
2333          pragma Assert (Nkind (N) in N_Entity);
2334          U : constant Union_Id := Nodes.Table (N + 1).Field9;
2335       begin
2336          if U = 0 then
2337             return Uint_0;
2338          else
2339             return From_Union (U);
2340          end if;
2341       end Uint9;
2342
2343       function Uint10 (N : Node_Id) return Uint is
2344          pragma Assert (Nkind (N) in N_Entity);
2345          U : constant Union_Id := Nodes.Table (N + 1).Field10;
2346       begin
2347          if U = 0 then
2348             return Uint_0;
2349          else
2350             return From_Union (U);
2351          end if;
2352       end Uint10;
2353
2354       function Uint11 (N : Node_Id) return Uint is
2355          pragma Assert (Nkind (N) in N_Entity);
2356          U : constant Union_Id := Nodes.Table (N + 1).Field11;
2357       begin
2358          if U = 0 then
2359             return Uint_0;
2360          else
2361             return From_Union (U);
2362          end if;
2363       end Uint11;
2364
2365       function Uint12 (N : Node_Id) return Uint is
2366          pragma Assert (Nkind (N) in N_Entity);
2367          U : constant Union_Id := Nodes.Table (N + 1).Field12;
2368       begin
2369          if U = 0 then
2370             return Uint_0;
2371          else
2372             return From_Union (U);
2373          end if;
2374       end Uint12;
2375
2376       function Uint13 (N : Node_Id) return Uint is
2377          pragma Assert (Nkind (N) in N_Entity);
2378          U : constant Union_Id := Nodes.Table (N + 2).Field6;
2379       begin
2380          if U = 0 then
2381             return Uint_0;
2382          else
2383             return From_Union (U);
2384          end if;
2385       end Uint13;
2386
2387       function Uint14 (N : Node_Id) return Uint is
2388          pragma Assert (Nkind (N) in N_Entity);
2389          U : constant Union_Id := Nodes.Table (N + 2).Field7;
2390       begin
2391          if U = 0 then
2392             return Uint_0;
2393          else
2394             return From_Union (U);
2395          end if;
2396       end Uint14;
2397
2398       function Uint15 (N : Node_Id) return Uint is
2399          pragma Assert (Nkind (N) in N_Entity);
2400          U : constant Union_Id := Nodes.Table (N + 2).Field8;
2401       begin
2402          if U = 0 then
2403             return Uint_0;
2404          else
2405             return From_Union (U);
2406          end if;
2407       end Uint15;
2408
2409       function Uint16 (N : Node_Id) return Uint is
2410          pragma Assert (Nkind (N) in N_Entity);
2411          U : constant Union_Id := Nodes.Table (N + 2).Field9;
2412       begin
2413          if U = 0 then
2414             return Uint_0;
2415          else
2416             return From_Union (U);
2417          end if;
2418       end Uint16;
2419
2420       function Uint17 (N : Node_Id) return Uint is
2421          pragma Assert (Nkind (N) in N_Entity);
2422          U : constant Union_Id := Nodes.Table (N + 2).Field10;
2423       begin
2424          if U = 0 then
2425             return Uint_0;
2426          else
2427             return From_Union (U);
2428          end if;
2429       end Uint17;
2430
2431       function Uint22 (N : Node_Id) return Uint is
2432          pragma Assert (Nkind (N) in N_Entity);
2433          U : constant Union_Id := Nodes.Table (N + 3).Field9;
2434       begin
2435          if U = 0 then
2436             return Uint_0;
2437          else
2438             return From_Union (U);
2439          end if;
2440       end Uint22;
2441
2442       function Ureal3 (N : Node_Id) return Ureal is
2443       begin
2444          pragma Assert (N <= Nodes.Last);
2445          return From_Union (Nodes.Table (N).Field3);
2446       end Ureal3;
2447
2448       function Ureal18 (N : Node_Id) return Ureal is
2449       begin
2450          pragma Assert (Nkind (N) in N_Entity);
2451          return From_Union (Nodes.Table (N + 2).Field11);
2452       end Ureal18;
2453
2454       function Ureal21 (N : Node_Id) return Ureal is
2455       begin
2456          pragma Assert (Nkind (N) in N_Entity);
2457          return From_Union (Nodes.Table (N + 3).Field8);
2458       end Ureal21;
2459
2460       function Flag4 (N : Node_Id) return Boolean is
2461       begin
2462          pragma Assert (N <= Nodes.Last);
2463          return Nodes.Table (N).Flag4;
2464       end Flag4;
2465
2466       function Flag5 (N : Node_Id) return Boolean is
2467       begin
2468          pragma Assert (N <= Nodes.Last);
2469          return Nodes.Table (N).Flag5;
2470       end Flag5;
2471
2472       function Flag6 (N : Node_Id) return Boolean is
2473       begin
2474          pragma Assert (N <= Nodes.Last);
2475          return Nodes.Table (N).Flag6;
2476       end Flag6;
2477
2478       function Flag7 (N : Node_Id) return Boolean is
2479       begin
2480          pragma Assert (N <= Nodes.Last);
2481          return Nodes.Table (N).Flag7;
2482       end Flag7;
2483
2484       function Flag8 (N : Node_Id) return Boolean is
2485       begin
2486          pragma Assert (N <= Nodes.Last);
2487          return Nodes.Table (N).Flag8;
2488       end Flag8;
2489
2490       function Flag9 (N : Node_Id) return Boolean is
2491       begin
2492          pragma Assert (N <= Nodes.Last);
2493          return Nodes.Table (N).Flag9;
2494       end Flag9;
2495
2496       function Flag10 (N : Node_Id) return Boolean is
2497       begin
2498          pragma Assert (N <= Nodes.Last);
2499          return Nodes.Table (N).Flag10;
2500       end Flag10;
2501
2502       function Flag11 (N : Node_Id) return Boolean is
2503       begin
2504          pragma Assert (N <= Nodes.Last);
2505          return Nodes.Table (N).Flag11;
2506       end Flag11;
2507
2508       function Flag12 (N : Node_Id) return Boolean is
2509       begin
2510          pragma Assert (N <= Nodes.Last);
2511          return Nodes.Table (N).Flag12;
2512       end Flag12;
2513
2514       function Flag13 (N : Node_Id) return Boolean is
2515       begin
2516          pragma Assert (N <= Nodes.Last);
2517          return Nodes.Table (N).Flag13;
2518       end Flag13;
2519
2520       function Flag14 (N : Node_Id) return Boolean is
2521       begin
2522          pragma Assert (N <= Nodes.Last);
2523          return Nodes.Table (N).Flag14;
2524       end Flag14;
2525
2526       function Flag15 (N : Node_Id) return Boolean is
2527       begin
2528          pragma Assert (N <= Nodes.Last);
2529          return Nodes.Table (N).Flag15;
2530       end Flag15;
2531
2532       function Flag16 (N : Node_Id) return Boolean is
2533       begin
2534          pragma Assert (N <= Nodes.Last);
2535          return Nodes.Table (N).Flag16;
2536       end Flag16;
2537
2538       function Flag17 (N : Node_Id) return Boolean is
2539       begin
2540          pragma Assert (N <= Nodes.Last);
2541          return Nodes.Table (N).Flag17;
2542       end Flag17;
2543
2544       function Flag18 (N : Node_Id) return Boolean is
2545       begin
2546          pragma Assert (N <= Nodes.Last);
2547          return Nodes.Table (N).Flag18;
2548       end Flag18;
2549
2550       function Flag19 (N : Node_Id) return Boolean is
2551       begin
2552          pragma Assert (Nkind (N) in N_Entity);
2553          return Nodes.Table (N + 1).In_List;
2554       end Flag19;
2555
2556       function Flag20 (N : Node_Id) return Boolean is
2557       begin
2558          pragma Assert (Nkind (N) in N_Entity);
2559          return Nodes.Table (N + 1).Unused_1;
2560       end Flag20;
2561
2562       function Flag21 (N : Node_Id) return Boolean is
2563       begin
2564          pragma Assert (Nkind (N) in N_Entity);
2565          return Nodes.Table (N + 1).Rewrite_Ins;
2566       end Flag21;
2567
2568       function Flag22 (N : Node_Id) return Boolean is
2569       begin
2570          pragma Assert (Nkind (N) in N_Entity);
2571          return Nodes.Table (N + 1).Analyzed;
2572       end Flag22;
2573
2574       function Flag23 (N : Node_Id) return Boolean is
2575       begin
2576          pragma Assert (Nkind (N) in N_Entity);
2577          return Nodes.Table (N + 1).Comes_From_Source;
2578       end Flag23;
2579
2580       function Flag24 (N : Node_Id) return Boolean is
2581       begin
2582          pragma Assert (Nkind (N) in N_Entity);
2583          return Nodes.Table (N + 1).Error_Posted;
2584       end Flag24;
2585
2586       function Flag25 (N : Node_Id) return Boolean is
2587       begin
2588          pragma Assert (Nkind (N) in N_Entity);
2589          return Nodes.Table (N + 1).Flag4;
2590       end Flag25;
2591
2592       function Flag26 (N : Node_Id) return Boolean is
2593       begin
2594          pragma Assert (Nkind (N) in N_Entity);
2595          return Nodes.Table (N + 1).Flag5;
2596       end Flag26;
2597
2598       function Flag27 (N : Node_Id) return Boolean is
2599       begin
2600          pragma Assert (Nkind (N) in N_Entity);
2601          return Nodes.Table (N + 1).Flag6;
2602       end Flag27;
2603
2604       function Flag28 (N : Node_Id) return Boolean is
2605       begin
2606          pragma Assert (Nkind (N) in N_Entity);
2607          return Nodes.Table (N + 1).Flag7;
2608       end Flag28;
2609
2610       function Flag29 (N : Node_Id) return Boolean is
2611       begin
2612          pragma Assert (Nkind (N) in N_Entity);
2613          return Nodes.Table (N + 1).Flag8;
2614       end Flag29;
2615
2616       function Flag30 (N : Node_Id) return Boolean is
2617       begin
2618          pragma Assert (Nkind (N) in N_Entity);
2619          return Nodes.Table (N + 1).Flag9;
2620       end Flag30;
2621
2622       function Flag31 (N : Node_Id) return Boolean is
2623       begin
2624          pragma Assert (Nkind (N) in N_Entity);
2625          return Nodes.Table (N + 1).Flag10;
2626       end Flag31;
2627
2628       function Flag32 (N : Node_Id) return Boolean is
2629       begin
2630          pragma Assert (Nkind (N) in N_Entity);
2631          return Nodes.Table (N + 1).Flag11;
2632       end Flag32;
2633
2634       function Flag33 (N : Node_Id) return Boolean is
2635       begin
2636          pragma Assert (Nkind (N) in N_Entity);
2637          return Nodes.Table (N + 1).Flag12;
2638       end Flag33;
2639
2640       function Flag34 (N : Node_Id) return Boolean is
2641       begin
2642          pragma Assert (Nkind (N) in N_Entity);
2643          return Nodes.Table (N + 1).Flag13;
2644       end Flag34;
2645
2646       function Flag35 (N : Node_Id) return Boolean is
2647       begin
2648          pragma Assert (Nkind (N) in N_Entity);
2649          return Nodes.Table (N + 1).Flag14;
2650       end Flag35;
2651
2652       function Flag36 (N : Node_Id) return Boolean is
2653       begin
2654          pragma Assert (Nkind (N) in N_Entity);
2655          return Nodes.Table (N + 1).Flag15;
2656       end Flag36;
2657
2658       function Flag37 (N : Node_Id) return Boolean is
2659       begin
2660          pragma Assert (Nkind (N) in N_Entity);
2661          return Nodes.Table (N + 1).Flag16;
2662       end Flag37;
2663
2664       function Flag38 (N : Node_Id) return Boolean is
2665       begin
2666          pragma Assert (Nkind (N) in N_Entity);
2667          return Nodes.Table (N + 1).Flag17;
2668       end Flag38;
2669
2670       function Flag39 (N : Node_Id) return Boolean is
2671       begin
2672          pragma Assert (Nkind (N) in N_Entity);
2673          return Nodes.Table (N + 1).Flag18;
2674       end Flag39;
2675
2676       function Flag40 (N : Node_Id) return Boolean is
2677       begin
2678          pragma Assert (Nkind (N) in N_Entity);
2679          return Nodes.Table (N + 2).In_List;
2680       end Flag40;
2681
2682       function Flag41 (N : Node_Id) return Boolean is
2683       begin
2684          pragma Assert (Nkind (N) in N_Entity);
2685          return Nodes.Table (N + 2).Unused_1;
2686       end Flag41;
2687
2688       function Flag42 (N : Node_Id) return Boolean is
2689       begin
2690          pragma Assert (Nkind (N) in N_Entity);
2691          return Nodes.Table (N + 2).Rewrite_Ins;
2692       end Flag42;
2693
2694       function Flag43 (N : Node_Id) return Boolean is
2695       begin
2696          pragma Assert (Nkind (N) in N_Entity);
2697          return Nodes.Table (N + 2).Analyzed;
2698       end Flag43;
2699
2700       function Flag44 (N : Node_Id) return Boolean is
2701       begin
2702          pragma Assert (Nkind (N) in N_Entity);
2703          return Nodes.Table (N + 2).Comes_From_Source;
2704       end Flag44;
2705
2706       function Flag45 (N : Node_Id) return Boolean is
2707       begin
2708          pragma Assert (Nkind (N) in N_Entity);
2709          return Nodes.Table (N + 2).Error_Posted;
2710       end Flag45;
2711
2712       function Flag46 (N : Node_Id) return Boolean is
2713       begin
2714          pragma Assert (Nkind (N) in N_Entity);
2715          return Nodes.Table (N + 2).Flag4;
2716       end Flag46;
2717
2718       function Flag47 (N : Node_Id) return Boolean is
2719       begin
2720          pragma Assert (Nkind (N) in N_Entity);
2721          return Nodes.Table (N + 2).Flag5;
2722       end Flag47;
2723
2724       function Flag48 (N : Node_Id) return Boolean is
2725       begin
2726          pragma Assert (Nkind (N) in N_Entity);
2727          return Nodes.Table (N + 2).Flag6;
2728       end Flag48;
2729
2730       function Flag49 (N : Node_Id) return Boolean is
2731       begin
2732          pragma Assert (Nkind (N) in N_Entity);
2733          return Nodes.Table (N + 2).Flag7;
2734       end Flag49;
2735
2736       function Flag50 (N : Node_Id) return Boolean is
2737       begin
2738          pragma Assert (Nkind (N) in N_Entity);
2739          return Nodes.Table (N + 2).Flag8;
2740       end Flag50;
2741
2742       function Flag51 (N : Node_Id) return Boolean is
2743       begin
2744          pragma Assert (Nkind (N) in N_Entity);
2745          return Nodes.Table (N + 2).Flag9;
2746       end Flag51;
2747
2748       function Flag52 (N : Node_Id) return Boolean is
2749       begin
2750          pragma Assert (Nkind (N) in N_Entity);
2751          return Nodes.Table (N + 2).Flag10;
2752       end Flag52;
2753
2754       function Flag53 (N : Node_Id) return Boolean is
2755       begin
2756          pragma Assert (Nkind (N) in N_Entity);
2757          return Nodes.Table (N + 2).Flag11;
2758       end Flag53;
2759
2760       function Flag54 (N : Node_Id) return Boolean is
2761       begin
2762          pragma Assert (Nkind (N) in N_Entity);
2763          return Nodes.Table (N + 2).Flag12;
2764       end Flag54;
2765
2766       function Flag55 (N : Node_Id) return Boolean is
2767       begin
2768          pragma Assert (Nkind (N) in N_Entity);
2769          return Nodes.Table (N + 2).Flag13;
2770       end Flag55;
2771
2772       function Flag56 (N : Node_Id) return Boolean is
2773       begin
2774          pragma Assert (Nkind (N) in N_Entity);
2775          return Nodes.Table (N + 2).Flag14;
2776       end Flag56;
2777
2778       function Flag57 (N : Node_Id) return Boolean is
2779       begin
2780          pragma Assert (Nkind (N) in N_Entity);
2781          return Nodes.Table (N + 2).Flag15;
2782       end Flag57;
2783
2784       function Flag58 (N : Node_Id) return Boolean is
2785       begin
2786          pragma Assert (Nkind (N) in N_Entity);
2787          return Nodes.Table (N + 2).Flag16;
2788       end Flag58;
2789
2790       function Flag59 (N : Node_Id) return Boolean is
2791       begin
2792          pragma Assert (Nkind (N) in N_Entity);
2793          return Nodes.Table (N + 2).Flag17;
2794       end Flag59;
2795
2796       function Flag60 (N : Node_Id) return Boolean is
2797       begin
2798          pragma Assert (Nkind (N) in N_Entity);
2799          return Nodes.Table (N + 2).Flag18;
2800       end Flag60;
2801
2802       function Flag61 (N : Node_Id) return Boolean is
2803       begin
2804          pragma Assert (Nkind (N) in N_Entity);
2805          return Nodes.Table (N + 1).Pflag1;
2806       end Flag61;
2807
2808       function Flag62 (N : Node_Id) return Boolean is
2809       begin
2810          pragma Assert (Nkind (N) in N_Entity);
2811          return Nodes.Table (N + 1).Pflag2;
2812       end Flag62;
2813
2814       function Flag63 (N : Node_Id) return Boolean is
2815       begin
2816          pragma Assert (Nkind (N) in N_Entity);
2817          return Nodes.Table (N + 2).Pflag1;
2818       end Flag63;
2819
2820       function Flag64 (N : Node_Id) return Boolean is
2821       begin
2822          pragma Assert (Nkind (N) in N_Entity);
2823          return Nodes.Table (N + 2).Pflag2;
2824       end Flag64;
2825
2826       function Flag65 (N : Node_Id) return Boolean is
2827       begin
2828          pragma Assert (Nkind (N) in N_Entity);
2829          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag65;
2830       end Flag65;
2831
2832       function Flag66 (N : Node_Id) return Boolean is
2833       begin
2834          pragma Assert (Nkind (N) in N_Entity);
2835          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag66;
2836       end Flag66;
2837
2838       function Flag67 (N : Node_Id) return Boolean is
2839       begin
2840          pragma Assert (Nkind (N) in N_Entity);
2841          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag67;
2842       end Flag67;
2843
2844       function Flag68 (N : Node_Id) return Boolean is
2845       begin
2846          pragma Assert (Nkind (N) in N_Entity);
2847          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag68;
2848       end Flag68;
2849
2850       function Flag69 (N : Node_Id) return Boolean is
2851       begin
2852          pragma Assert (Nkind (N) in N_Entity);
2853          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag69;
2854       end Flag69;
2855
2856       function Flag70 (N : Node_Id) return Boolean is
2857       begin
2858          pragma Assert (Nkind (N) in N_Entity);
2859          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag70;
2860       end Flag70;
2861
2862       function Flag71 (N : Node_Id) return Boolean is
2863       begin
2864          pragma Assert (Nkind (N) in N_Entity);
2865          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag71;
2866       end Flag71;
2867
2868       function Flag72 (N : Node_Id) return Boolean is
2869       begin
2870          pragma Assert (Nkind (N) in N_Entity);
2871          return To_Flag_Byte (Nodes.Table (N + 2).Nkind).Flag72;
2872       end Flag72;
2873
2874       function Flag73 (N : Node_Id) return Boolean is
2875       begin
2876          pragma Assert (Nkind (N) in N_Entity);
2877          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag73;
2878       end Flag73;
2879
2880       function Flag74 (N : Node_Id) return Boolean is
2881       begin
2882          pragma Assert (Nkind (N) in N_Entity);
2883          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag74;
2884       end Flag74;
2885
2886       function Flag75 (N : Node_Id) return Boolean is
2887       begin
2888          pragma Assert (Nkind (N) in N_Entity);
2889          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag75;
2890       end Flag75;
2891
2892       function Flag76 (N : Node_Id) return Boolean is
2893       begin
2894          pragma Assert (Nkind (N) in N_Entity);
2895          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag76;
2896       end Flag76;
2897
2898       function Flag77 (N : Node_Id) return Boolean is
2899       begin
2900          pragma Assert (Nkind (N) in N_Entity);
2901          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag77;
2902       end Flag77;
2903
2904       function Flag78 (N : Node_Id) return Boolean is
2905       begin
2906          pragma Assert (Nkind (N) in N_Entity);
2907          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag78;
2908       end Flag78;
2909
2910       function Flag79 (N : Node_Id) return Boolean is
2911       begin
2912          pragma Assert (Nkind (N) in N_Entity);
2913          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag79;
2914       end Flag79;
2915
2916       function Flag80 (N : Node_Id) return Boolean is
2917       begin
2918          pragma Assert (Nkind (N) in N_Entity);
2919          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag80;
2920       end Flag80;
2921
2922       function Flag81 (N : Node_Id) return Boolean is
2923       begin
2924          pragma Assert (Nkind (N) in N_Entity);
2925          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag81;
2926       end Flag81;
2927
2928       function Flag82 (N : Node_Id) return Boolean is
2929       begin
2930          pragma Assert (Nkind (N) in N_Entity);
2931          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag82;
2932       end Flag82;
2933
2934       function Flag83 (N : Node_Id) return Boolean is
2935       begin
2936          pragma Assert (Nkind (N) in N_Entity);
2937          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag83;
2938       end Flag83;
2939
2940       function Flag84 (N : Node_Id) return Boolean is
2941       begin
2942          pragma Assert (Nkind (N) in N_Entity);
2943          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag84;
2944       end Flag84;
2945
2946       function Flag85 (N : Node_Id) return Boolean is
2947       begin
2948          pragma Assert (Nkind (N) in N_Entity);
2949          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag85;
2950       end Flag85;
2951
2952       function Flag86 (N : Node_Id) return Boolean is
2953       begin
2954          pragma Assert (Nkind (N) in N_Entity);
2955          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag86;
2956       end Flag86;
2957
2958       function Flag87 (N : Node_Id) return Boolean is
2959       begin
2960          pragma Assert (Nkind (N) in N_Entity);
2961          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag87;
2962       end Flag87;
2963
2964       function Flag88 (N : Node_Id) return Boolean is
2965       begin
2966          pragma Assert (Nkind (N) in N_Entity);
2967          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag88;
2968       end Flag88;
2969
2970       function Flag89 (N : Node_Id) return Boolean is
2971       begin
2972          pragma Assert (Nkind (N) in N_Entity);
2973          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag89;
2974       end Flag89;
2975
2976       function Flag90 (N : Node_Id) return Boolean is
2977       begin
2978          pragma Assert (Nkind (N) in N_Entity);
2979          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag90;
2980       end Flag90;
2981
2982       function Flag91 (N : Node_Id) return Boolean is
2983       begin
2984          pragma Assert (Nkind (N) in N_Entity);
2985          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag91;
2986       end Flag91;
2987
2988       function Flag92 (N : Node_Id) return Boolean is
2989       begin
2990          pragma Assert (Nkind (N) in N_Entity);
2991          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag92;
2992       end Flag92;
2993
2994       function Flag93 (N : Node_Id) return Boolean is
2995       begin
2996          pragma Assert (Nkind (N) in N_Entity);
2997          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag93;
2998       end Flag93;
2999
3000       function Flag94 (N : Node_Id) return Boolean is
3001       begin
3002          pragma Assert (Nkind (N) in N_Entity);
3003          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag94;
3004       end Flag94;
3005
3006       function Flag95 (N : Node_Id) return Boolean is
3007       begin
3008          pragma Assert (Nkind (N) in N_Entity);
3009          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag95;
3010       end Flag95;
3011
3012       function Flag96 (N : Node_Id) return Boolean is
3013       begin
3014          pragma Assert (Nkind (N) in N_Entity);
3015          return To_Flag_Word (Nodes.Table (N + 2).Field12).Flag96;
3016       end Flag96;
3017
3018       function Flag97 (N : Node_Id) return Boolean is
3019       begin
3020          pragma Assert (Nkind (N) in N_Entity);
3021          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag97;
3022       end Flag97;
3023
3024       function Flag98 (N : Node_Id) return Boolean is
3025       begin
3026          pragma Assert (Nkind (N) in N_Entity);
3027          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag98;
3028       end Flag98;
3029
3030       function Flag99 (N : Node_Id) return Boolean is
3031       begin
3032          pragma Assert (Nkind (N) in N_Entity);
3033          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag99;
3034       end Flag99;
3035
3036       function Flag100 (N : Node_Id) return Boolean is
3037       begin
3038          pragma Assert (Nkind (N) in N_Entity);
3039          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag100;
3040       end Flag100;
3041
3042       function Flag101 (N : Node_Id) return Boolean is
3043       begin
3044          pragma Assert (Nkind (N) in N_Entity);
3045          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag101;
3046       end Flag101;
3047
3048       function Flag102 (N : Node_Id) return Boolean is
3049       begin
3050          pragma Assert (Nkind (N) in N_Entity);
3051          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag102;
3052       end Flag102;
3053
3054       function Flag103 (N : Node_Id) return Boolean is
3055       begin
3056          pragma Assert (Nkind (N) in N_Entity);
3057          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag103;
3058       end Flag103;
3059
3060       function Flag104 (N : Node_Id) return Boolean is
3061       begin
3062          pragma Assert (Nkind (N) in N_Entity);
3063          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag104;
3064       end Flag104;
3065
3066       function Flag105 (N : Node_Id) return Boolean is
3067       begin
3068          pragma Assert (Nkind (N) in N_Entity);
3069          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag105;
3070       end Flag105;
3071
3072       function Flag106 (N : Node_Id) return Boolean is
3073       begin
3074          pragma Assert (Nkind (N) in N_Entity);
3075          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag106;
3076       end Flag106;
3077
3078       function Flag107 (N : Node_Id) return Boolean is
3079       begin
3080          pragma Assert (Nkind (N) in N_Entity);
3081          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag107;
3082       end Flag107;
3083
3084       function Flag108 (N : Node_Id) return Boolean is
3085       begin
3086          pragma Assert (Nkind (N) in N_Entity);
3087          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag108;
3088       end Flag108;
3089
3090       function Flag109 (N : Node_Id) return Boolean is
3091       begin
3092          pragma Assert (Nkind (N) in N_Entity);
3093          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag109;
3094       end Flag109;
3095
3096       function Flag110 (N : Node_Id) return Boolean is
3097       begin
3098          pragma Assert (Nkind (N) in N_Entity);
3099          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag110;
3100       end Flag110;
3101
3102       function Flag111 (N : Node_Id) return Boolean is
3103       begin
3104          pragma Assert (Nkind (N) in N_Entity);
3105          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag111;
3106       end Flag111;
3107
3108       function Flag112 (N : Node_Id) return Boolean is
3109       begin
3110          pragma Assert (Nkind (N) in N_Entity);
3111          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag112;
3112       end Flag112;
3113
3114       function Flag113 (N : Node_Id) return Boolean is
3115       begin
3116          pragma Assert (Nkind (N) in N_Entity);
3117          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag113;
3118       end Flag113;
3119
3120       function Flag114 (N : Node_Id) return Boolean is
3121       begin
3122          pragma Assert (Nkind (N) in N_Entity);
3123          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag114;
3124       end Flag114;
3125
3126       function Flag115 (N : Node_Id) return Boolean is
3127       begin
3128          pragma Assert (Nkind (N) in N_Entity);
3129          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag115;
3130       end Flag115;
3131
3132       function Flag116 (N : Node_Id) return Boolean is
3133       begin
3134          pragma Assert (Nkind (N) in N_Entity);
3135          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag116;
3136       end Flag116;
3137
3138       function Flag117 (N : Node_Id) return Boolean is
3139       begin
3140          pragma Assert (Nkind (N) in N_Entity);
3141          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag117;
3142       end Flag117;
3143
3144       function Flag118 (N : Node_Id) return Boolean is
3145       begin
3146          pragma Assert (Nkind (N) in N_Entity);
3147          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag118;
3148       end Flag118;
3149
3150       function Flag119 (N : Node_Id) return Boolean is
3151       begin
3152          pragma Assert (Nkind (N) in N_Entity);
3153          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag119;
3154       end Flag119;
3155
3156       function Flag120 (N : Node_Id) return Boolean is
3157       begin
3158          pragma Assert (Nkind (N) in N_Entity);
3159          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag120;
3160       end Flag120;
3161
3162       function Flag121 (N : Node_Id) return Boolean is
3163       begin
3164          pragma Assert (Nkind (N) in N_Entity);
3165          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag121;
3166       end Flag121;
3167
3168       function Flag122 (N : Node_Id) return Boolean is
3169       begin
3170          pragma Assert (Nkind (N) in N_Entity);
3171          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag122;
3172       end Flag122;
3173
3174       function Flag123 (N : Node_Id) return Boolean is
3175       begin
3176          pragma Assert (Nkind (N) in N_Entity);
3177          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag123;
3178       end Flag123;
3179
3180       function Flag124 (N : Node_Id) return Boolean is
3181       begin
3182          pragma Assert (Nkind (N) in N_Entity);
3183          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag124;
3184       end Flag124;
3185
3186       function Flag125 (N : Node_Id) return Boolean is
3187       begin
3188          pragma Assert (Nkind (N) in N_Entity);
3189          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag125;
3190       end Flag125;
3191
3192       function Flag126 (N : Node_Id) return Boolean is
3193       begin
3194          pragma Assert (Nkind (N) in N_Entity);
3195          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag126;
3196       end Flag126;
3197
3198       function Flag127 (N : Node_Id) return Boolean is
3199       begin
3200          pragma Assert (Nkind (N) in N_Entity);
3201          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag127;
3202       end Flag127;
3203
3204       function Flag128 (N : Node_Id) return Boolean is
3205       begin
3206          pragma Assert (Nkind (N) in N_Entity);
3207          return To_Flag_Word2 (Nodes.Table (N + 3).Field12).Flag128;
3208       end Flag128;
3209
3210       function Flag129 (N : Node_Id) return Boolean is
3211       begin
3212          pragma Assert (Nkind (N) in N_Entity);
3213          return Nodes.Table (N + 3).In_List;
3214       end Flag129;
3215
3216       function Flag130 (N : Node_Id) return Boolean is
3217       begin
3218          pragma Assert (Nkind (N) in N_Entity);
3219          return Nodes.Table (N + 3).Unused_1;
3220       end Flag130;
3221
3222       function Flag131 (N : Node_Id) return Boolean is
3223       begin
3224          pragma Assert (Nkind (N) in N_Entity);
3225          return Nodes.Table (N + 3).Rewrite_Ins;
3226       end Flag131;
3227
3228       function Flag132 (N : Node_Id) return Boolean is
3229       begin
3230          pragma Assert (Nkind (N) in N_Entity);
3231          return Nodes.Table (N + 3).Analyzed;
3232       end Flag132;
3233
3234       function Flag133 (N : Node_Id) return Boolean is
3235       begin
3236          pragma Assert (Nkind (N) in N_Entity);
3237          return Nodes.Table (N + 3).Comes_From_Source;
3238       end Flag133;
3239
3240       function Flag134 (N : Node_Id) return Boolean is
3241       begin
3242          pragma Assert (Nkind (N) in N_Entity);
3243          return Nodes.Table (N + 3).Error_Posted;
3244       end Flag134;
3245
3246       function Flag135 (N : Node_Id) return Boolean is
3247       begin
3248          pragma Assert (Nkind (N) in N_Entity);
3249          return Nodes.Table (N + 3).Flag4;
3250       end Flag135;
3251
3252       function Flag136 (N : Node_Id) return Boolean is
3253       begin
3254          pragma Assert (Nkind (N) in N_Entity);
3255          return Nodes.Table (N + 3).Flag5;
3256       end Flag136;
3257
3258       function Flag137 (N : Node_Id) return Boolean is
3259       begin
3260          pragma Assert (Nkind (N) in N_Entity);
3261          return Nodes.Table (N + 3).Flag6;
3262       end Flag137;
3263
3264       function Flag138 (N : Node_Id) return Boolean is
3265       begin
3266          pragma Assert (Nkind (N) in N_Entity);
3267          return Nodes.Table (N + 3).Flag7;
3268       end Flag138;
3269
3270       function Flag139 (N : Node_Id) return Boolean is
3271       begin
3272          pragma Assert (Nkind (N) in N_Entity);
3273          return Nodes.Table (N + 3).Flag8;
3274       end Flag139;
3275
3276       function Flag140 (N : Node_Id) return Boolean is
3277       begin
3278          pragma Assert (Nkind (N) in N_Entity);
3279          return Nodes.Table (N + 3).Flag9;
3280       end Flag140;
3281
3282       function Flag141 (N : Node_Id) return Boolean is
3283       begin
3284          pragma Assert (Nkind (N) in N_Entity);
3285          return Nodes.Table (N + 3).Flag10;
3286       end Flag141;
3287
3288       function Flag142 (N : Node_Id) return Boolean is
3289       begin
3290          pragma Assert (Nkind (N) in N_Entity);
3291          return Nodes.Table (N + 3).Flag11;
3292       end Flag142;
3293
3294       function Flag143 (N : Node_Id) return Boolean is
3295       begin
3296          pragma Assert (Nkind (N) in N_Entity);
3297          return Nodes.Table (N + 3).Flag12;
3298       end Flag143;
3299
3300       function Flag144 (N : Node_Id) return Boolean is
3301       begin
3302          pragma Assert (Nkind (N) in N_Entity);
3303          return Nodes.Table (N + 3).Flag13;
3304       end Flag144;
3305
3306       function Flag145 (N : Node_Id) return Boolean is
3307       begin
3308          pragma Assert (Nkind (N) in N_Entity);
3309          return Nodes.Table (N + 3).Flag14;
3310       end Flag145;
3311
3312       function Flag146 (N : Node_Id) return Boolean is
3313       begin
3314          pragma Assert (Nkind (N) in N_Entity);
3315          return Nodes.Table (N + 3).Flag15;
3316       end Flag146;
3317
3318       function Flag147 (N : Node_Id) return Boolean is
3319       begin
3320          pragma Assert (Nkind (N) in N_Entity);
3321          return Nodes.Table (N + 3).Flag16;
3322       end Flag147;
3323
3324       function Flag148 (N : Node_Id) return Boolean is
3325       begin
3326          pragma Assert (Nkind (N) in N_Entity);
3327          return Nodes.Table (N + 3).Flag17;
3328       end Flag148;
3329
3330       function Flag149 (N : Node_Id) return Boolean is
3331       begin
3332          pragma Assert (Nkind (N) in N_Entity);
3333          return Nodes.Table (N + 3).Flag18;
3334       end Flag149;
3335
3336       function Flag150 (N : Node_Id) return Boolean is
3337       begin
3338          pragma Assert (Nkind (N) in N_Entity);
3339          return Nodes.Table (N + 3).Pflag1;
3340       end Flag150;
3341
3342       function Flag151 (N : Node_Id) return Boolean is
3343       begin
3344          pragma Assert (Nkind (N) in N_Entity);
3345          return Nodes.Table (N + 3).Pflag2;
3346       end Flag151;
3347
3348       function Flag152 (N : Node_Id) return Boolean is
3349       begin
3350          pragma Assert (Nkind (N) in N_Entity);
3351          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag152;
3352       end Flag152;
3353
3354       function Flag153 (N : Node_Id) return Boolean is
3355       begin
3356          pragma Assert (Nkind (N) in N_Entity);
3357          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag153;
3358       end Flag153;
3359
3360       function Flag154 (N : Node_Id) return Boolean is
3361       begin
3362          pragma Assert (Nkind (N) in N_Entity);
3363          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag154;
3364       end Flag154;
3365
3366       function Flag155 (N : Node_Id) return Boolean is
3367       begin
3368          pragma Assert (Nkind (N) in N_Entity);
3369          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag155;
3370       end Flag155;
3371
3372       function Flag156 (N : Node_Id) return Boolean is
3373       begin
3374          pragma Assert (Nkind (N) in N_Entity);
3375          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag156;
3376       end Flag156;
3377
3378       function Flag157 (N : Node_Id) return Boolean is
3379       begin
3380          pragma Assert (Nkind (N) in N_Entity);
3381          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag157;
3382       end Flag157;
3383
3384       function Flag158 (N : Node_Id) return Boolean is
3385       begin
3386          pragma Assert (Nkind (N) in N_Entity);
3387          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag158;
3388       end Flag158;
3389
3390       function Flag159 (N : Node_Id) return Boolean is
3391       begin
3392          pragma Assert (Nkind (N) in N_Entity);
3393          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag159;
3394       end Flag159;
3395
3396       function Flag160 (N : Node_Id) return Boolean is
3397       begin
3398          pragma Assert (Nkind (N) in N_Entity);
3399          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag160;
3400       end Flag160;
3401
3402       function Flag161 (N : Node_Id) return Boolean is
3403       begin
3404          pragma Assert (Nkind (N) in N_Entity);
3405          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag161;
3406       end Flag161;
3407
3408       function Flag162 (N : Node_Id) return Boolean is
3409       begin
3410          pragma Assert (Nkind (N) in N_Entity);
3411          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag162;
3412       end Flag162;
3413
3414       function Flag163 (N : Node_Id) return Boolean is
3415       begin
3416          pragma Assert (Nkind (N) in N_Entity);
3417          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag163;
3418       end Flag163;
3419
3420       function Flag164 (N : Node_Id) return Boolean is
3421       begin
3422          pragma Assert (Nkind (N) in N_Entity);
3423          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag164;
3424       end Flag164;
3425
3426       function Flag165 (N : Node_Id) return Boolean is
3427       begin
3428          pragma Assert (Nkind (N) in N_Entity);
3429          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag165;
3430       end Flag165;
3431
3432       function Flag166 (N : Node_Id) return Boolean is
3433       begin
3434          pragma Assert (Nkind (N) in N_Entity);
3435          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag166;
3436       end Flag166;
3437
3438       function Flag167 (N : Node_Id) return Boolean is
3439       begin
3440          pragma Assert (Nkind (N) in N_Entity);
3441          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag167;
3442       end Flag167;
3443
3444       function Flag168 (N : Node_Id) return Boolean is
3445       begin
3446          pragma Assert (Nkind (N) in N_Entity);
3447          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag168;
3448       end Flag168;
3449
3450       function Flag169 (N : Node_Id) return Boolean is
3451       begin
3452          pragma Assert (Nkind (N) in N_Entity);
3453          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag169;
3454       end Flag169;
3455
3456       function Flag170 (N : Node_Id) return Boolean is
3457       begin
3458          pragma Assert (Nkind (N) in N_Entity);
3459          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag170;
3460       end Flag170;
3461
3462       function Flag171 (N : Node_Id) return Boolean is
3463       begin
3464          pragma Assert (Nkind (N) in N_Entity);
3465          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag171;
3466       end Flag171;
3467
3468       function Flag172 (N : Node_Id) return Boolean is
3469       begin
3470          pragma Assert (Nkind (N) in N_Entity);
3471          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag172;
3472       end Flag172;
3473
3474       function Flag173 (N : Node_Id) return Boolean is
3475       begin
3476          pragma Assert (Nkind (N) in N_Entity);
3477          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag173;
3478       end Flag173;
3479
3480       function Flag174 (N : Node_Id) return Boolean is
3481       begin
3482          pragma Assert (Nkind (N) in N_Entity);
3483          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag174;
3484       end Flag174;
3485
3486       function Flag175 (N : Node_Id) return Boolean is
3487       begin
3488          pragma Assert (Nkind (N) in N_Entity);
3489          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag175;
3490       end Flag175;
3491
3492       function Flag176 (N : Node_Id) return Boolean is
3493       begin
3494          pragma Assert (Nkind (N) in N_Entity);
3495          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag176;
3496       end Flag176;
3497
3498       function Flag177 (N : Node_Id) return Boolean is
3499       begin
3500          pragma Assert (Nkind (N) in N_Entity);
3501          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag177;
3502       end Flag177;
3503
3504       function Flag178 (N : Node_Id) return Boolean is
3505       begin
3506          pragma Assert (Nkind (N) in N_Entity);
3507          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag178;
3508       end Flag178;
3509
3510       function Flag179 (N : Node_Id) return Boolean is
3511       begin
3512          pragma Assert (Nkind (N) in N_Entity);
3513          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag179;
3514       end Flag179;
3515
3516       function Flag180 (N : Node_Id) return Boolean is
3517       begin
3518          pragma Assert (Nkind (N) in N_Entity);
3519          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag180;
3520       end Flag180;
3521
3522       function Flag181 (N : Node_Id) return Boolean is
3523       begin
3524          pragma Assert (Nkind (N) in N_Entity);
3525          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag181;
3526       end Flag181;
3527
3528       function Flag182 (N : Node_Id) return Boolean is
3529       begin
3530          pragma Assert (Nkind (N) in N_Entity);
3531          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag182;
3532       end Flag182;
3533
3534       function Flag183 (N : Node_Id) return Boolean is
3535       begin
3536          pragma Assert (Nkind (N) in N_Entity);
3537          return To_Flag_Word3 (Nodes.Table (N + 3).Field11).Flag183;
3538       end Flag183;
3539
3540       function Flag184 (N : Node_Id) return Boolean is
3541       begin
3542          pragma Assert (Nkind (N) in N_Entity);
3543          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag184;
3544       end Flag184;
3545
3546       function Flag185 (N : Node_Id) return Boolean is
3547       begin
3548          pragma Assert (Nkind (N) in N_Entity);
3549          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag185;
3550       end Flag185;
3551
3552       function Flag186 (N : Node_Id) return Boolean is
3553       begin
3554          pragma Assert (Nkind (N) in N_Entity);
3555          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag186;
3556       end Flag186;
3557
3558       function Flag187 (N : Node_Id) return Boolean is
3559       begin
3560          pragma Assert (Nkind (N) in N_Entity);
3561          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag187;
3562       end Flag187;
3563
3564       function Flag188 (N : Node_Id) return Boolean is
3565       begin
3566          pragma Assert (Nkind (N) in N_Entity);
3567          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag188;
3568       end Flag188;
3569
3570       function Flag189 (N : Node_Id) return Boolean is
3571       begin
3572          pragma Assert (Nkind (N) in N_Entity);
3573          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag189;
3574       end Flag189;
3575
3576       function Flag190 (N : Node_Id) return Boolean is
3577       begin
3578          pragma Assert (Nkind (N) in N_Entity);
3579          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag190;
3580       end Flag190;
3581
3582       function Flag191 (N : Node_Id) return Boolean is
3583       begin
3584          pragma Assert (Nkind (N) in N_Entity);
3585          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag191;
3586       end Flag191;
3587
3588       function Flag192 (N : Node_Id) return Boolean is
3589       begin
3590          pragma Assert (Nkind (N) in N_Entity);
3591          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag192;
3592       end Flag192;
3593
3594       function Flag193 (N : Node_Id) return Boolean is
3595       begin
3596          pragma Assert (Nkind (N) in N_Entity);
3597          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag193;
3598       end Flag193;
3599
3600       function Flag194 (N : Node_Id) return Boolean is
3601       begin
3602          pragma Assert (Nkind (N) in N_Entity);
3603          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag194;
3604       end Flag194;
3605
3606       function Flag195 (N : Node_Id) return Boolean is
3607       begin
3608          pragma Assert (Nkind (N) in N_Entity);
3609          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag195;
3610       end Flag195;
3611
3612       function Flag196 (N : Node_Id) return Boolean is
3613       begin
3614          pragma Assert (Nkind (N) in N_Entity);
3615          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag196;
3616       end Flag196;
3617
3618       function Flag197 (N : Node_Id) return Boolean is
3619       begin
3620          pragma Assert (Nkind (N) in N_Entity);
3621          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag197;
3622       end Flag197;
3623
3624       function Flag198 (N : Node_Id) return Boolean is
3625       begin
3626          pragma Assert (Nkind (N) in N_Entity);
3627          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag198;
3628       end Flag198;
3629
3630       function Flag199 (N : Node_Id) return Boolean is
3631       begin
3632          pragma Assert (Nkind (N) in N_Entity);
3633          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag199;
3634       end Flag199;
3635
3636       function Flag200 (N : Node_Id) return Boolean is
3637       begin
3638          pragma Assert (Nkind (N) in N_Entity);
3639          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag200;
3640       end Flag200;
3641
3642       function Flag201 (N : Node_Id) return Boolean is
3643       begin
3644          pragma Assert (Nkind (N) in N_Entity);
3645          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag201;
3646       end Flag201;
3647
3648       function Flag202 (N : Node_Id) return Boolean is
3649       begin
3650          pragma Assert (Nkind (N) in N_Entity);
3651          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag202;
3652       end Flag202;
3653
3654       function Flag203 (N : Node_Id) return Boolean is
3655       begin
3656          pragma Assert (Nkind (N) in N_Entity);
3657          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag203;
3658       end Flag203;
3659
3660       function Flag204 (N : Node_Id) return Boolean is
3661       begin
3662          pragma Assert (Nkind (N) in N_Entity);
3663          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag204;
3664       end Flag204;
3665
3666       function Flag205 (N : Node_Id) return Boolean is
3667       begin
3668          pragma Assert (Nkind (N) in N_Entity);
3669          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag205;
3670       end Flag205;
3671
3672       function Flag206 (N : Node_Id) return Boolean is
3673       begin
3674          pragma Assert (Nkind (N) in N_Entity);
3675          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag206;
3676       end Flag206;
3677
3678       function Flag207 (N : Node_Id) return Boolean is
3679       begin
3680          pragma Assert (Nkind (N) in N_Entity);
3681          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag207;
3682       end Flag207;
3683
3684       function Flag208 (N : Node_Id) return Boolean is
3685       begin
3686          pragma Assert (Nkind (N) in N_Entity);
3687          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag208;
3688       end Flag208;
3689
3690       function Flag209 (N : Node_Id) return Boolean is
3691       begin
3692          pragma Assert (Nkind (N) in N_Entity);
3693          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag209;
3694       end Flag209;
3695
3696       function Flag210 (N : Node_Id) return Boolean is
3697       begin
3698          pragma Assert (Nkind (N) in N_Entity);
3699          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag210;
3700       end Flag210;
3701
3702       function Flag211 (N : Node_Id) return Boolean is
3703       begin
3704          pragma Assert (Nkind (N) in N_Entity);
3705          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag211;
3706       end Flag211;
3707
3708       function Flag212 (N : Node_Id) return Boolean is
3709       begin
3710          pragma Assert (Nkind (N) in N_Entity);
3711          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag212;
3712       end Flag212;
3713
3714       function Flag213 (N : Node_Id) return Boolean is
3715       begin
3716          pragma Assert (Nkind (N) in N_Entity);
3717          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag213;
3718       end Flag213;
3719
3720       function Flag214 (N : Node_Id) return Boolean is
3721       begin
3722          pragma Assert (Nkind (N) in N_Entity);
3723          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag214;
3724       end Flag214;
3725
3726       function Flag215 (N : Node_Id) return Boolean is
3727       begin
3728          pragma Assert (Nkind (N) in N_Entity);
3729          return To_Flag_Word4 (Nodes.Table (N + 4).Field11).Flag215;
3730       end Flag215;
3731
3732       function Flag216 (N : Node_Id) return Boolean is
3733       begin
3734          pragma Assert (Nkind (N) in N_Entity);
3735          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag216;
3736       end Flag216;
3737
3738       function Flag217 (N : Node_Id) return Boolean is
3739       begin
3740          pragma Assert (Nkind (N) in N_Entity);
3741          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag217;
3742       end Flag217;
3743
3744       function Flag218 (N : Node_Id) return Boolean is
3745       begin
3746          pragma Assert (Nkind (N) in N_Entity);
3747          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag218;
3748       end Flag218;
3749
3750       function Flag219 (N : Node_Id) return Boolean is
3751       begin
3752          pragma Assert (Nkind (N) in N_Entity);
3753          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag219;
3754       end Flag219;
3755
3756       function Flag220 (N : Node_Id) return Boolean is
3757       begin
3758          pragma Assert (Nkind (N) in N_Entity);
3759          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag220;
3760       end Flag220;
3761
3762       function Flag221 (N : Node_Id) return Boolean is
3763       begin
3764          pragma Assert (Nkind (N) in N_Entity);
3765          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag221;
3766       end Flag221;
3767
3768       function Flag222 (N : Node_Id) return Boolean is
3769       begin
3770          pragma Assert (Nkind (N) in N_Entity);
3771          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag222;
3772       end Flag222;
3773
3774       function Flag223 (N : Node_Id) return Boolean is
3775       begin
3776          pragma Assert (Nkind (N) in N_Entity);
3777          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag223;
3778       end Flag223;
3779
3780       function Flag224 (N : Node_Id) return Boolean is
3781       begin
3782          pragma Assert (Nkind (N) in N_Entity);
3783          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag224;
3784       end Flag224;
3785
3786       function Flag225 (N : Node_Id) return Boolean is
3787       begin
3788          pragma Assert (Nkind (N) in N_Entity);
3789          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag225;
3790       end Flag225;
3791
3792       function Flag226 (N : Node_Id) return Boolean is
3793       begin
3794          pragma Assert (Nkind (N) in N_Entity);
3795          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag226;
3796       end Flag226;
3797
3798       function Flag227 (N : Node_Id) return Boolean is
3799       begin
3800          pragma Assert (Nkind (N) in N_Entity);
3801          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag227;
3802       end Flag227;
3803
3804       function Flag228 (N : Node_Id) return Boolean is
3805       begin
3806          pragma Assert (Nkind (N) in N_Entity);
3807          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag228;
3808       end Flag228;
3809
3810       function Flag229 (N : Node_Id) return Boolean is
3811       begin
3812          pragma Assert (Nkind (N) in N_Entity);
3813          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag229;
3814       end Flag229;
3815
3816       function Flag230 (N : Node_Id) return Boolean is
3817       begin
3818          pragma Assert (Nkind (N) in N_Entity);
3819          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag230;
3820       end Flag230;
3821
3822       function Flag231 (N : Node_Id) return Boolean is
3823       begin
3824          pragma Assert (Nkind (N) in N_Entity);
3825          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag231;
3826       end Flag231;
3827
3828       function Flag232 (N : Node_Id) return Boolean is
3829       begin
3830          pragma Assert (Nkind (N) in N_Entity);
3831          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag232;
3832       end Flag232;
3833
3834       function Flag233 (N : Node_Id) return Boolean is
3835       begin
3836          pragma Assert (Nkind (N) in N_Entity);
3837          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag233;
3838       end Flag233;
3839
3840       function Flag234 (N : Node_Id) return Boolean is
3841       begin
3842          pragma Assert (Nkind (N) in N_Entity);
3843          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag234;
3844       end Flag234;
3845
3846       function Flag235 (N : Node_Id) return Boolean is
3847       begin
3848          pragma Assert (Nkind (N) in N_Entity);
3849          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag235;
3850       end Flag235;
3851
3852       function Flag236 (N : Node_Id) return Boolean is
3853       begin
3854          pragma Assert (Nkind (N) in N_Entity);
3855          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag236;
3856       end Flag236;
3857
3858       function Flag237 (N : Node_Id) return Boolean is
3859       begin
3860          pragma Assert (Nkind (N) in N_Entity);
3861          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag237;
3862       end Flag237;
3863
3864       function Flag238 (N : Node_Id) return Boolean is
3865       begin
3866          pragma Assert (Nkind (N) in N_Entity);
3867          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag238;
3868       end Flag238;
3869
3870       function Flag239 (N : Node_Id) return Boolean is
3871       begin
3872          pragma Assert (Nkind (N) in N_Entity);
3873          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag239;
3874       end Flag239;
3875
3876       function Flag240 (N : Node_Id) return Boolean is
3877       begin
3878          pragma Assert (Nkind (N) in N_Entity);
3879          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag240;
3880       end Flag240;
3881
3882       function Flag241 (N : Node_Id) return Boolean is
3883       begin
3884          pragma Assert (Nkind (N) in N_Entity);
3885          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag241;
3886       end Flag241;
3887
3888       function Flag242 (N : Node_Id) return Boolean is
3889       begin
3890          pragma Assert (Nkind (N) in N_Entity);
3891          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag242;
3892       end Flag242;
3893
3894       function Flag243 (N : Node_Id) return Boolean is
3895       begin
3896          pragma Assert (Nkind (N) in N_Entity);
3897          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag243;
3898       end Flag243;
3899
3900       function Flag244 (N : Node_Id) return Boolean is
3901       begin
3902          pragma Assert (Nkind (N) in N_Entity);
3903          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag244;
3904       end Flag244;
3905
3906       function Flag245 (N : Node_Id) return Boolean is
3907       begin
3908          pragma Assert (Nkind (N) in N_Entity);
3909          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag245;
3910       end Flag245;
3911
3912       function Flag246 (N : Node_Id) return Boolean is
3913       begin
3914          pragma Assert (Nkind (N) in N_Entity);
3915          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag246;
3916       end Flag246;
3917
3918       function Flag247 (N : Node_Id) return Boolean is
3919       begin
3920          pragma Assert (Nkind (N) in N_Entity);
3921          return To_Flag_Word5 (Nodes.Table (N + 4).Field12).Flag247;
3922       end Flag247;
3923
3924       procedure Set_Nkind (N : Node_Id; Val : Node_Kind) is
3925       begin
3926          pragma Assert (N <= Nodes.Last);
3927          Nodes.Table (N).Nkind := Val;
3928       end Set_Nkind;
3929
3930       procedure Set_Field1 (N : Node_Id; Val : Union_Id) is
3931       begin
3932          pragma Assert (N <= Nodes.Last);
3933          Nodes.Table (N).Field1 := Val;
3934       end Set_Field1;
3935
3936       procedure Set_Field2 (N : Node_Id; Val : Union_Id) is
3937       begin
3938          pragma Assert (N <= Nodes.Last);
3939          Nodes.Table (N).Field2 := Val;
3940       end Set_Field2;
3941
3942       procedure Set_Field3 (N : Node_Id; Val : Union_Id) is
3943       begin
3944          pragma Assert (N <= Nodes.Last);
3945          Nodes.Table (N).Field3 := Val;
3946       end Set_Field3;
3947
3948       procedure Set_Field4 (N : Node_Id; Val : Union_Id) is
3949       begin
3950          pragma Assert (N <= Nodes.Last);
3951          Nodes.Table (N).Field4 := Val;
3952       end Set_Field4;
3953
3954       procedure Set_Field5 (N : Node_Id; Val : Union_Id) is
3955       begin
3956          pragma Assert (N <= Nodes.Last);
3957          Nodes.Table (N).Field5 := Val;
3958       end Set_Field5;
3959
3960       procedure Set_Field6 (N : Node_Id; Val : Union_Id) is
3961       begin
3962          pragma Assert (Nkind (N) in N_Entity);
3963          Nodes.Table (N + 1).Field6 := Val;
3964       end Set_Field6;
3965
3966       procedure Set_Field7 (N : Node_Id; Val : Union_Id) is
3967       begin
3968          pragma Assert (Nkind (N) in N_Entity);
3969          Nodes.Table (N + 1).Field7 := Val;
3970       end Set_Field7;
3971
3972       procedure Set_Field8 (N : Node_Id; Val : Union_Id) is
3973       begin
3974          pragma Assert (Nkind (N) in N_Entity);
3975          Nodes.Table (N + 1).Field8 := Val;
3976       end Set_Field8;
3977
3978       procedure Set_Field9 (N : Node_Id; Val : Union_Id) is
3979       begin
3980          pragma Assert (Nkind (N) in N_Entity);
3981          Nodes.Table (N + 1).Field9 := Val;
3982       end Set_Field9;
3983
3984       procedure Set_Field10 (N : Node_Id; Val : Union_Id) is
3985       begin
3986          pragma Assert (Nkind (N) in N_Entity);
3987          Nodes.Table (N + 1).Field10 := Val;
3988       end Set_Field10;
3989
3990       procedure Set_Field11 (N : Node_Id; Val : Union_Id) is
3991       begin
3992          pragma Assert (Nkind (N) in N_Entity);
3993          Nodes.Table (N + 1).Field11 := Val;
3994       end Set_Field11;
3995
3996       procedure Set_Field12 (N : Node_Id; Val : Union_Id) is
3997       begin
3998          pragma Assert (Nkind (N) in N_Entity);
3999          Nodes.Table (N + 1).Field12 := Val;
4000       end Set_Field12;
4001
4002       procedure Set_Field13 (N : Node_Id; Val : Union_Id) is
4003       begin
4004          pragma Assert (Nkind (N) in N_Entity);
4005          Nodes.Table (N + 2).Field6 := Val;
4006       end Set_Field13;
4007
4008       procedure Set_Field14 (N : Node_Id; Val : Union_Id) is
4009       begin
4010          pragma Assert (Nkind (N) in N_Entity);
4011          Nodes.Table (N + 2).Field7 := Val;
4012       end Set_Field14;
4013
4014       procedure Set_Field15 (N : Node_Id; Val : Union_Id) is
4015       begin
4016          pragma Assert (Nkind (N) in N_Entity);
4017          Nodes.Table (N + 2).Field8 := Val;
4018       end Set_Field15;
4019
4020       procedure Set_Field16 (N : Node_Id; Val : Union_Id) is
4021       begin
4022          pragma Assert (Nkind (N) in N_Entity);
4023          Nodes.Table (N + 2).Field9 := Val;
4024       end Set_Field16;
4025
4026       procedure Set_Field17 (N : Node_Id; Val : Union_Id) is
4027       begin
4028          pragma Assert (Nkind (N) in N_Entity);
4029          Nodes.Table (N + 2).Field10 := Val;
4030       end Set_Field17;
4031
4032       procedure Set_Field18 (N : Node_Id; Val : Union_Id) is
4033       begin
4034          pragma Assert (Nkind (N) in N_Entity);
4035          Nodes.Table (N + 2).Field11 := Val;
4036       end Set_Field18;
4037
4038       procedure Set_Field19 (N : Node_Id; Val : Union_Id) is
4039       begin
4040          pragma Assert (Nkind (N) in N_Entity);
4041          Nodes.Table (N + 3).Field6 := Val;
4042       end Set_Field19;
4043
4044       procedure Set_Field20 (N : Node_Id; Val : Union_Id) is
4045       begin
4046          pragma Assert (Nkind (N) in N_Entity);
4047          Nodes.Table (N + 3).Field7 := Val;
4048       end Set_Field20;
4049
4050       procedure Set_Field21 (N : Node_Id; Val : Union_Id) is
4051       begin
4052          pragma Assert (Nkind (N) in N_Entity);
4053          Nodes.Table (N + 3).Field8 := Val;
4054       end Set_Field21;
4055
4056       procedure Set_Field22 (N : Node_Id; Val : Union_Id) is
4057       begin
4058          pragma Assert (Nkind (N) in N_Entity);
4059          Nodes.Table (N + 3).Field9 := Val;
4060       end Set_Field22;
4061
4062       procedure Set_Field23 (N : Node_Id; Val : Union_Id) is
4063       begin
4064          pragma Assert (Nkind (N) in N_Entity);
4065          Nodes.Table (N + 3).Field10 := Val;
4066       end Set_Field23;
4067
4068       procedure Set_Field24 (N : Node_Id; Val : Union_Id) is
4069       begin
4070          pragma Assert (Nkind (N) in N_Entity);
4071          Nodes.Table (N + 4).Field6 := Val;
4072       end Set_Field24;
4073
4074       procedure Set_Field25 (N : Node_Id; Val : Union_Id) is
4075       begin
4076          pragma Assert (Nkind (N) in N_Entity);
4077          Nodes.Table (N + 4).Field7 := Val;
4078       end Set_Field25;
4079
4080       procedure Set_Field26 (N : Node_Id; Val : Union_Id) is
4081       begin
4082          pragma Assert (Nkind (N) in N_Entity);
4083          Nodes.Table (N + 4).Field8 := Val;
4084       end Set_Field26;
4085
4086       procedure Set_Field27 (N : Node_Id; Val : Union_Id) is
4087       begin
4088          pragma Assert (Nkind (N) in N_Entity);
4089          Nodes.Table (N + 4).Field9 := Val;
4090       end Set_Field27;
4091
4092       procedure Set_Field28 (N : Node_Id; Val : Union_Id) is
4093       begin
4094          pragma Assert (Nkind (N) in N_Entity);
4095          Nodes.Table (N + 4).Field10 := Val;
4096       end Set_Field28;
4097
4098       procedure Set_Node1 (N : Node_Id; Val : Node_Id) is
4099       begin
4100          pragma Assert (N <= Nodes.Last);
4101          Nodes.Table (N).Field1 := Union_Id (Val);
4102       end Set_Node1;
4103
4104       procedure Set_Node2 (N : Node_Id; Val : Node_Id) is
4105       begin
4106          pragma Assert (N <= Nodes.Last);
4107          Nodes.Table (N).Field2 := Union_Id (Val);
4108       end Set_Node2;
4109
4110       procedure Set_Node3 (N : Node_Id; Val : Node_Id) is
4111       begin
4112          pragma Assert (N <= Nodes.Last);
4113          Nodes.Table (N).Field3 := Union_Id (Val);
4114       end Set_Node3;
4115
4116       procedure Set_Node4 (N : Node_Id; Val : Node_Id) is
4117       begin
4118          pragma Assert (N <= Nodes.Last);
4119          Nodes.Table (N).Field4 := Union_Id (Val);
4120       end Set_Node4;
4121
4122       procedure Set_Node5 (N : Node_Id; Val : Node_Id) is
4123       begin
4124          pragma Assert (N <= Nodes.Last);
4125          Nodes.Table (N).Field5 := Union_Id (Val);
4126       end Set_Node5;
4127
4128       procedure Set_Node6 (N : Node_Id; Val : Node_Id) is
4129       begin
4130          pragma Assert (Nkind (N) in N_Entity);
4131          Nodes.Table (N + 1).Field6 := Union_Id (Val);
4132       end Set_Node6;
4133
4134       procedure Set_Node7 (N : Node_Id; Val : Node_Id) is
4135       begin
4136          pragma Assert (Nkind (N) in N_Entity);
4137          Nodes.Table (N + 1).Field7 := Union_Id (Val);
4138       end Set_Node7;
4139
4140       procedure Set_Node8 (N : Node_Id; Val : Node_Id) is
4141       begin
4142          pragma Assert (Nkind (N) in N_Entity);
4143          Nodes.Table (N + 1).Field8 := Union_Id (Val);
4144       end Set_Node8;
4145
4146       procedure Set_Node9 (N : Node_Id; Val : Node_Id) is
4147       begin
4148          pragma Assert (Nkind (N) in N_Entity);
4149          Nodes.Table (N + 1).Field9 := Union_Id (Val);
4150       end Set_Node9;
4151
4152       procedure Set_Node10 (N : Node_Id; Val : Node_Id) is
4153       begin
4154          pragma Assert (Nkind (N) in N_Entity);
4155          Nodes.Table (N + 1).Field10 := Union_Id (Val);
4156       end Set_Node10;
4157
4158       procedure Set_Node11 (N : Node_Id; Val : Node_Id) is
4159       begin
4160          pragma Assert (Nkind (N) in N_Entity);
4161          Nodes.Table (N + 1).Field11 := Union_Id (Val);
4162       end Set_Node11;
4163
4164       procedure Set_Node12 (N : Node_Id; Val : Node_Id) is
4165       begin
4166          pragma Assert (Nkind (N) in N_Entity);
4167          Nodes.Table (N + 1).Field12 := Union_Id (Val);
4168       end Set_Node12;
4169
4170       procedure Set_Node13 (N : Node_Id; Val : Node_Id) is
4171       begin
4172          pragma Assert (Nkind (N) in N_Entity);
4173          Nodes.Table (N + 2).Field6 := Union_Id (Val);
4174       end Set_Node13;
4175
4176       procedure Set_Node14 (N : Node_Id; Val : Node_Id) is
4177       begin
4178          pragma Assert (Nkind (N) in N_Entity);
4179          Nodes.Table (N + 2).Field7 := Union_Id (Val);
4180       end Set_Node14;
4181
4182       procedure Set_Node15 (N : Node_Id; Val : Node_Id) is
4183       begin
4184          pragma Assert (Nkind (N) in N_Entity);
4185          Nodes.Table (N + 2).Field8 := Union_Id (Val);
4186       end Set_Node15;
4187
4188       procedure Set_Node16 (N : Node_Id; Val : Node_Id) is
4189       begin
4190          pragma Assert (Nkind (N) in N_Entity);
4191          Nodes.Table (N + 2).Field9 := Union_Id (Val);
4192       end Set_Node16;
4193
4194       procedure Set_Node17 (N : Node_Id; Val : Node_Id) is
4195       begin
4196          pragma Assert (Nkind (N) in N_Entity);
4197          Nodes.Table (N + 2).Field10 := Union_Id (Val);
4198       end Set_Node17;
4199
4200       procedure Set_Node18 (N : Node_Id; Val : Node_Id) is
4201       begin
4202          pragma Assert (Nkind (N) in N_Entity);
4203          Nodes.Table (N + 2).Field11 := Union_Id (Val);
4204       end Set_Node18;
4205
4206       procedure Set_Node19 (N : Node_Id; Val : Node_Id) is
4207       begin
4208          pragma Assert (Nkind (N) in N_Entity);
4209          Nodes.Table (N + 3).Field6 := Union_Id (Val);
4210       end Set_Node19;
4211
4212       procedure Set_Node20 (N : Node_Id; Val : Node_Id) is
4213       begin
4214          pragma Assert (Nkind (N) in N_Entity);
4215          Nodes.Table (N + 3).Field7 := Union_Id (Val);
4216       end Set_Node20;
4217
4218       procedure Set_Node21 (N : Node_Id; Val : Node_Id) is
4219       begin
4220          pragma Assert (Nkind (N) in N_Entity);
4221          Nodes.Table (N + 3).Field8 := Union_Id (Val);
4222       end Set_Node21;
4223
4224       procedure Set_Node22 (N : Node_Id; Val : Node_Id) is
4225       begin
4226          pragma Assert (Nkind (N) in N_Entity);
4227          Nodes.Table (N + 3).Field9 := Union_Id (Val);
4228       end Set_Node22;
4229
4230       procedure Set_Node23 (N : Node_Id; Val : Node_Id) is
4231       begin
4232          pragma Assert (Nkind (N) in N_Entity);
4233          Nodes.Table (N + 3).Field10 := Union_Id (Val);
4234       end Set_Node23;
4235
4236       procedure Set_Node24 (N : Node_Id; Val : Node_Id) is
4237       begin
4238          pragma Assert (Nkind (N) in N_Entity);
4239          Nodes.Table (N + 4).Field6 := Union_Id (Val);
4240       end Set_Node24;
4241
4242       procedure Set_Node25 (N : Node_Id; Val : Node_Id) is
4243       begin
4244          pragma Assert (Nkind (N) in N_Entity);
4245          Nodes.Table (N + 4).Field7 := Union_Id (Val);
4246       end Set_Node25;
4247
4248       procedure Set_Node26 (N : Node_Id; Val : Node_Id) is
4249       begin
4250          pragma Assert (Nkind (N) in N_Entity);
4251          Nodes.Table (N + 4).Field8 := Union_Id (Val);
4252       end Set_Node26;
4253
4254       procedure Set_Node27 (N : Node_Id; Val : Node_Id) is
4255       begin
4256          pragma Assert (Nkind (N) in N_Entity);
4257          Nodes.Table (N + 4).Field9 := Union_Id (Val);
4258       end Set_Node27;
4259
4260       procedure Set_Node28 (N : Node_Id; Val : Node_Id) is
4261       begin
4262          pragma Assert (Nkind (N) in N_Entity);
4263          Nodes.Table (N + 4).Field10 := Union_Id (Val);
4264       end Set_Node28;
4265
4266       procedure Set_List1 (N : Node_Id; Val : List_Id) is
4267       begin
4268          pragma Assert (N <= Nodes.Last);
4269          Nodes.Table (N).Field1 := Union_Id (Val);
4270       end Set_List1;
4271
4272       procedure Set_List2 (N : Node_Id; Val : List_Id) is
4273       begin
4274          pragma Assert (N <= Nodes.Last);
4275          Nodes.Table (N).Field2 := Union_Id (Val);
4276       end Set_List2;
4277
4278       procedure Set_List3 (N : Node_Id; Val : List_Id) is
4279       begin
4280          pragma Assert (N <= Nodes.Last);
4281          Nodes.Table (N).Field3 := Union_Id (Val);
4282       end Set_List3;
4283
4284       procedure Set_List4 (N : Node_Id; Val : List_Id) is
4285       begin
4286          pragma Assert (N <= Nodes.Last);
4287          Nodes.Table (N).Field4 := Union_Id (Val);
4288       end Set_List4;
4289
4290       procedure Set_List5 (N : Node_Id; Val : List_Id) is
4291       begin
4292          pragma Assert (N <= Nodes.Last);
4293          Nodes.Table (N).Field5 := Union_Id (Val);
4294       end Set_List5;
4295
4296       procedure Set_List10 (N : Node_Id; Val : List_Id) is
4297       begin
4298          pragma Assert (Nkind (N) in N_Entity);
4299          Nodes.Table (N + 1).Field10 := Union_Id (Val);
4300       end Set_List10;
4301
4302       procedure Set_List14 (N : Node_Id; Val : List_Id) is
4303       begin
4304          pragma Assert (Nkind (N) in N_Entity);
4305          Nodes.Table (N + 2).Field7 := Union_Id (Val);
4306       end Set_List14;
4307
4308       procedure Set_Elist1 (N : Node_Id; Val : Elist_Id) is
4309       begin
4310          Nodes.Table (N).Field1 := Union_Id (Val);
4311       end Set_Elist1;
4312
4313       procedure Set_Elist2 (N : Node_Id; Val : Elist_Id) is
4314       begin
4315          Nodes.Table (N).Field2 := Union_Id (Val);
4316       end Set_Elist2;
4317
4318       procedure Set_Elist3 (N : Node_Id; Val : Elist_Id) is
4319       begin
4320          Nodes.Table (N).Field3 := Union_Id (Val);
4321       end Set_Elist3;
4322
4323       procedure Set_Elist4 (N : Node_Id; Val : Elist_Id) is
4324       begin
4325          Nodes.Table (N).Field4 := Union_Id (Val);
4326       end Set_Elist4;
4327
4328       procedure Set_Elist8 (N : Node_Id; Val : Elist_Id) is
4329       begin
4330          pragma Assert (Nkind (N) in N_Entity);
4331          Nodes.Table (N + 1).Field8 := Union_Id (Val);
4332       end Set_Elist8;
4333
4334       procedure Set_Elist13 (N : Node_Id; Val : Elist_Id) is
4335       begin
4336          pragma Assert (Nkind (N) in N_Entity);
4337          Nodes.Table (N + 2).Field6 := Union_Id (Val);
4338       end Set_Elist13;
4339
4340       procedure Set_Elist15 (N : Node_Id; Val : Elist_Id) is
4341       begin
4342          pragma Assert (Nkind (N) in N_Entity);
4343          Nodes.Table (N + 2).Field8 := Union_Id (Val);
4344       end Set_Elist15;
4345
4346       procedure Set_Elist16 (N : Node_Id; Val : Elist_Id) is
4347       begin
4348          pragma Assert (Nkind (N) in N_Entity);
4349          Nodes.Table (N + 2).Field9 := Union_Id (Val);
4350       end Set_Elist16;
4351
4352       procedure Set_Elist18 (N : Node_Id; Val : Elist_Id) is
4353       begin
4354          pragma Assert (Nkind (N) in N_Entity);
4355          Nodes.Table (N + 2).Field11 := Union_Id (Val);
4356       end Set_Elist18;
4357
4358       procedure Set_Elist21 (N : Node_Id; Val : Elist_Id) is
4359       begin
4360          pragma Assert (Nkind (N) in N_Entity);
4361          Nodes.Table (N + 3).Field8 := Union_Id (Val);
4362       end Set_Elist21;
4363
4364       procedure Set_Elist23 (N : Node_Id; Val : Elist_Id) is
4365       begin
4366          pragma Assert (Nkind (N) in N_Entity);
4367          Nodes.Table (N + 3).Field10 := Union_Id (Val);
4368       end Set_Elist23;
4369
4370       procedure Set_Elist25 (N : Node_Id; Val : Elist_Id) is
4371       begin
4372          pragma Assert (Nkind (N) in N_Entity);
4373          Nodes.Table (N + 4).Field7 := Union_Id (Val);
4374       end Set_Elist25;
4375
4376       procedure Set_Elist26 (N : Node_Id; Val : Elist_Id) is
4377       begin
4378          pragma Assert (Nkind (N) in N_Entity);
4379          Nodes.Table (N + 4).Field8 := Union_Id (Val);
4380       end Set_Elist26;
4381
4382       procedure Set_Name1 (N : Node_Id; Val : Name_Id) is
4383       begin
4384          pragma Assert (N <= Nodes.Last);
4385          Nodes.Table (N).Field1 := Union_Id (Val);
4386       end Set_Name1;
4387
4388       procedure Set_Name2 (N : Node_Id; Val : Name_Id) is
4389       begin
4390          pragma Assert (N <= Nodes.Last);
4391          Nodes.Table (N).Field2 := Union_Id (Val);
4392       end Set_Name2;
4393
4394       procedure Set_Str3 (N : Node_Id; Val : String_Id) is
4395       begin
4396          pragma Assert (N <= Nodes.Last);
4397          Nodes.Table (N).Field3 := Union_Id (Val);
4398       end Set_Str3;
4399
4400       procedure Set_Uint2 (N : Node_Id; Val : Uint) is
4401       begin
4402          pragma Assert (N <= Nodes.Last);
4403          Nodes.Table (N).Field2 := To_Union (Val);
4404       end Set_Uint2;
4405
4406       procedure Set_Uint3 (N : Node_Id; Val : Uint) is
4407       begin
4408          pragma Assert (N <= Nodes.Last);
4409          Nodes.Table (N).Field3 := To_Union (Val);
4410       end Set_Uint3;
4411
4412       procedure Set_Uint4 (N : Node_Id; Val : Uint) is
4413       begin
4414          pragma Assert (N <= Nodes.Last);
4415          Nodes.Table (N).Field4 := To_Union (Val);
4416       end Set_Uint4;
4417
4418       procedure Set_Uint5 (N : Node_Id; Val : Uint) is
4419       begin
4420          pragma Assert (N <= Nodes.Last);
4421          Nodes.Table (N).Field5 := To_Union (Val);
4422       end Set_Uint5;
4423
4424       procedure Set_Uint8 (N : Node_Id; Val : Uint) is
4425       begin
4426          pragma Assert (Nkind (N) in N_Entity);
4427          Nodes.Table (N + 1).Field8 := To_Union (Val);
4428       end Set_Uint8;
4429
4430       procedure Set_Uint9 (N : Node_Id; Val : Uint) is
4431       begin
4432          pragma Assert (Nkind (N) in N_Entity);
4433          Nodes.Table (N + 1).Field9 := To_Union (Val);
4434       end Set_Uint9;
4435
4436       procedure Set_Uint10 (N : Node_Id; Val : Uint) is
4437       begin
4438          pragma Assert (Nkind (N) in N_Entity);
4439          Nodes.Table (N + 1).Field10 := To_Union (Val);
4440       end Set_Uint10;
4441
4442       procedure Set_Uint11 (N : Node_Id; Val : Uint) is
4443       begin
4444          pragma Assert (Nkind (N) in N_Entity);
4445          Nodes.Table (N + 1).Field11 := To_Union (Val);
4446       end Set_Uint11;
4447
4448       procedure Set_Uint12 (N : Node_Id; Val : Uint) is
4449       begin
4450          pragma Assert (Nkind (N) in N_Entity);
4451          Nodes.Table (N + 1).Field12 := To_Union (Val);
4452       end Set_Uint12;
4453
4454       procedure Set_Uint13 (N : Node_Id; Val : Uint) is
4455       begin
4456          pragma Assert (Nkind (N) in N_Entity);
4457          Nodes.Table (N + 2).Field6 := To_Union (Val);
4458       end Set_Uint13;
4459
4460       procedure Set_Uint14 (N : Node_Id; Val : Uint) is
4461       begin
4462          pragma Assert (Nkind (N) in N_Entity);
4463          Nodes.Table (N + 2).Field7 := To_Union (Val);
4464       end Set_Uint14;
4465
4466       procedure Set_Uint15 (N : Node_Id; Val : Uint) is
4467       begin
4468          pragma Assert (Nkind (N) in N_Entity);
4469          Nodes.Table (N + 2).Field8 := To_Union (Val);
4470       end Set_Uint15;
4471
4472       procedure Set_Uint16 (N : Node_Id; Val : Uint) is
4473       begin
4474          pragma Assert (Nkind (N) in N_Entity);
4475          Nodes.Table (N + 2).Field9 := To_Union (Val);
4476       end Set_Uint16;
4477
4478       procedure Set_Uint17 (N : Node_Id; Val : Uint) is
4479       begin
4480          pragma Assert (Nkind (N) in N_Entity);
4481          Nodes.Table (N + 2).Field10 := To_Union (Val);
4482       end Set_Uint17;
4483
4484       procedure Set_Uint22 (N : Node_Id; Val : Uint) is
4485       begin
4486          pragma Assert (Nkind (N) in N_Entity);
4487          Nodes.Table (N + 3).Field9 := To_Union (Val);
4488       end Set_Uint22;
4489
4490       procedure Set_Ureal3 (N : Node_Id; Val : Ureal) is
4491       begin
4492          pragma Assert (N <= Nodes.Last);
4493          Nodes.Table (N).Field3 := To_Union (Val);
4494       end Set_Ureal3;
4495
4496       procedure Set_Ureal18 (N : Node_Id; Val : Ureal) is
4497       begin
4498          pragma Assert (Nkind (N) in N_Entity);
4499          Nodes.Table (N + 2).Field11 := To_Union (Val);
4500       end Set_Ureal18;
4501
4502       procedure Set_Ureal21 (N : Node_Id; Val : Ureal) is
4503       begin
4504          pragma Assert (Nkind (N) in N_Entity);
4505          Nodes.Table (N + 3).Field8 := To_Union (Val);
4506       end Set_Ureal21;
4507
4508       procedure Set_Flag4 (N : Node_Id; Val : Boolean) is
4509       begin
4510          pragma Assert (N <= Nodes.Last);
4511          Nodes.Table (N).Flag4 := Val;
4512       end Set_Flag4;
4513
4514       procedure Set_Flag5 (N : Node_Id; Val : Boolean) is
4515       begin
4516          pragma Assert (N <= Nodes.Last);
4517          Nodes.Table (N).Flag5 := Val;
4518       end Set_Flag5;
4519
4520       procedure Set_Flag6 (N : Node_Id; Val : Boolean) is
4521       begin
4522          pragma Assert (N <= Nodes.Last);
4523          Nodes.Table (N).Flag6 := Val;
4524       end Set_Flag6;
4525
4526       procedure Set_Flag7 (N : Node_Id; Val : Boolean) is
4527       begin
4528          pragma Assert (N <= Nodes.Last);
4529          Nodes.Table (N).Flag7 := Val;
4530       end Set_Flag7;
4531
4532       procedure Set_Flag8 (N : Node_Id; Val : Boolean) is
4533       begin
4534          pragma Assert (N <= Nodes.Last);
4535          Nodes.Table (N).Flag8 := Val;
4536       end Set_Flag8;
4537
4538       procedure Set_Flag9 (N : Node_Id; Val : Boolean) is
4539       begin
4540          pragma Assert (N <= Nodes.Last);
4541          Nodes.Table (N).Flag9 := Val;
4542       end Set_Flag9;
4543
4544       procedure Set_Flag10 (N : Node_Id; Val : Boolean) is
4545       begin
4546          pragma Assert (N <= Nodes.Last);
4547          Nodes.Table (N).Flag10 := Val;
4548       end Set_Flag10;
4549
4550       procedure Set_Flag11 (N : Node_Id; Val : Boolean) is
4551       begin
4552          pragma Assert (N <= Nodes.Last);
4553          Nodes.Table (N).Flag11 := Val;
4554       end Set_Flag11;
4555
4556       procedure Set_Flag12 (N : Node_Id; Val : Boolean) is
4557       begin
4558          pragma Assert (N <= Nodes.Last);
4559          Nodes.Table (N).Flag12 := Val;
4560       end Set_Flag12;
4561
4562       procedure Set_Flag13 (N : Node_Id; Val : Boolean) is
4563       begin
4564          pragma Assert (N <= Nodes.Last);
4565          Nodes.Table (N).Flag13 := Val;
4566       end Set_Flag13;
4567
4568       procedure Set_Flag14 (N : Node_Id; Val : Boolean) is
4569       begin
4570          pragma Assert (N <= Nodes.Last);
4571          Nodes.Table (N).Flag14 := Val;
4572       end Set_Flag14;
4573
4574       procedure Set_Flag15 (N : Node_Id; Val : Boolean) is
4575       begin
4576          pragma Assert (N <= Nodes.Last);
4577          Nodes.Table (N).Flag15 := Val;
4578       end Set_Flag15;
4579
4580       procedure Set_Flag16 (N : Node_Id; Val : Boolean) is
4581       begin
4582          pragma Assert (N <= Nodes.Last);
4583          Nodes.Table (N).Flag16 := Val;
4584       end Set_Flag16;
4585
4586       procedure Set_Flag17 (N : Node_Id; Val : Boolean) is
4587       begin
4588          pragma Assert (N <= Nodes.Last);
4589          Nodes.Table (N).Flag17 := Val;
4590       end Set_Flag17;
4591
4592       procedure Set_Flag18 (N : Node_Id; Val : Boolean) is
4593       begin
4594          pragma Assert (N <= Nodes.Last);
4595          Nodes.Table (N).Flag18 := Val;
4596       end Set_Flag18;
4597
4598       procedure Set_Flag19 (N : Node_Id; Val : Boolean) is
4599       begin
4600          pragma Assert (Nkind (N) in N_Entity);
4601          Nodes.Table (N + 1).In_List := Val;
4602       end Set_Flag19;
4603
4604       procedure Set_Flag20 (N : Node_Id; Val : Boolean) is
4605       begin
4606          pragma Assert (Nkind (N) in N_Entity);
4607          Nodes.Table (N + 1).Unused_1 := Val;
4608       end Set_Flag20;
4609
4610       procedure Set_Flag21 (N : Node_Id; Val : Boolean) is
4611       begin
4612          pragma Assert (Nkind (N) in N_Entity);
4613          Nodes.Table (N + 1).Rewrite_Ins := Val;
4614       end Set_Flag21;
4615
4616       procedure Set_Flag22 (N : Node_Id; Val : Boolean) is
4617       begin
4618          pragma Assert (Nkind (N) in N_Entity);
4619          Nodes.Table (N + 1).Analyzed := Val;
4620       end Set_Flag22;
4621
4622       procedure Set_Flag23 (N : Node_Id; Val : Boolean) is
4623       begin
4624          pragma Assert (Nkind (N) in N_Entity);
4625          Nodes.Table (N + 1).Comes_From_Source := Val;
4626       end Set_Flag23;
4627
4628       procedure Set_Flag24 (N : Node_Id; Val : Boolean) is
4629       begin
4630          pragma Assert (Nkind (N) in N_Entity);
4631          Nodes.Table (N + 1).Error_Posted := Val;
4632       end Set_Flag24;
4633
4634       procedure Set_Flag25 (N : Node_Id; Val : Boolean) is
4635       begin
4636          pragma Assert (Nkind (N) in N_Entity);
4637          Nodes.Table (N + 1).Flag4 := Val;
4638       end Set_Flag25;
4639
4640       procedure Set_Flag26 (N : Node_Id; Val : Boolean) is
4641       begin
4642          pragma Assert (Nkind (N) in N_Entity);
4643          Nodes.Table (N + 1).Flag5 := Val;
4644       end Set_Flag26;
4645
4646       procedure Set_Flag27 (N : Node_Id; Val : Boolean) is
4647       begin
4648          pragma Assert (Nkind (N) in N_Entity);
4649          Nodes.Table (N + 1).Flag6 := Val;
4650       end Set_Flag27;
4651
4652       procedure Set_Flag28 (N : Node_Id; Val : Boolean) is
4653       begin
4654          pragma Assert (Nkind (N) in N_Entity);
4655          Nodes.Table (N + 1).Flag7 := Val;
4656       end Set_Flag28;
4657
4658       procedure Set_Flag29 (N : Node_Id; Val : Boolean) is
4659       begin
4660          pragma Assert (Nkind (N) in N_Entity);
4661          Nodes.Table (N + 1).Flag8 := Val;
4662       end Set_Flag29;
4663
4664       procedure Set_Flag30 (N : Node_Id; Val : Boolean) is
4665       begin
4666          pragma Assert (Nkind (N) in N_Entity);
4667          Nodes.Table (N + 1).Flag9 := Val;
4668       end Set_Flag30;
4669
4670       procedure Set_Flag31 (N : Node_Id; Val : Boolean) is
4671       begin
4672          pragma Assert (Nkind (N) in N_Entity);
4673          Nodes.Table (N + 1).Flag10 := Val;
4674       end Set_Flag31;
4675
4676       procedure Set_Flag32 (N : Node_Id; Val : Boolean) is
4677       begin
4678          pragma Assert (Nkind (N) in N_Entity);
4679          Nodes.Table (N + 1).Flag11 := Val;
4680       end Set_Flag32;
4681
4682       procedure Set_Flag33 (N : Node_Id; Val : Boolean) is
4683       begin
4684          pragma Assert (Nkind (N) in N_Entity);
4685          Nodes.Table (N + 1).Flag12 := Val;
4686       end Set_Flag33;
4687
4688       procedure Set_Flag34 (N : Node_Id; Val : Boolean) is
4689       begin
4690          pragma Assert (Nkind (N) in N_Entity);
4691          Nodes.Table (N + 1).Flag13 := Val;
4692       end Set_Flag34;
4693
4694       procedure Set_Flag35 (N : Node_Id; Val : Boolean) is
4695       begin
4696          pragma Assert (Nkind (N) in N_Entity);
4697          Nodes.Table (N + 1).Flag14 := Val;
4698       end Set_Flag35;
4699
4700       procedure Set_Flag36 (N : Node_Id; Val : Boolean) is
4701       begin
4702          pragma Assert (Nkind (N) in N_Entity);
4703          Nodes.Table (N + 1).Flag15 := Val;
4704       end Set_Flag36;
4705
4706       procedure Set_Flag37 (N : Node_Id; Val : Boolean) is
4707       begin
4708          pragma Assert (Nkind (N) in N_Entity);
4709          Nodes.Table (N + 1).Flag16 := Val;
4710       end Set_Flag37;
4711
4712       procedure Set_Flag38 (N : Node_Id; Val : Boolean) is
4713       begin
4714          pragma Assert (Nkind (N) in N_Entity);
4715          Nodes.Table (N + 1).Flag17 := Val;
4716       end Set_Flag38;
4717
4718       procedure Set_Flag39 (N : Node_Id; Val : Boolean) is
4719       begin
4720          pragma Assert (Nkind (N) in N_Entity);
4721          Nodes.Table (N + 1).Flag18 := Val;
4722       end Set_Flag39;
4723
4724       procedure Set_Flag40 (N : Node_Id; Val : Boolean) is
4725       begin
4726          pragma Assert (Nkind (N) in N_Entity);
4727          Nodes.Table (N + 2).In_List := Val;
4728       end Set_Flag40;
4729
4730       procedure Set_Flag41 (N : Node_Id; Val : Boolean) is
4731       begin
4732          pragma Assert (Nkind (N) in N_Entity);
4733          Nodes.Table (N + 2).Unused_1 := Val;
4734       end Set_Flag41;
4735
4736       procedure Set_Flag42 (N : Node_Id; Val : Boolean) is
4737       begin
4738          pragma Assert (Nkind (N) in N_Entity);
4739          Nodes.Table (N + 2).Rewrite_Ins := Val;
4740       end Set_Flag42;
4741
4742       procedure Set_Flag43 (N : Node_Id; Val : Boolean) is
4743       begin
4744          pragma Assert (Nkind (N) in N_Entity);
4745          Nodes.Table (N + 2).Analyzed := Val;
4746       end Set_Flag43;
4747
4748       procedure Set_Flag44 (N : Node_Id; Val : Boolean) is
4749       begin
4750          pragma Assert (Nkind (N) in N_Entity);
4751          Nodes.Table (N + 2).Comes_From_Source := Val;
4752       end Set_Flag44;
4753
4754       procedure Set_Flag45 (N : Node_Id; Val : Boolean) is
4755       begin
4756          pragma Assert (Nkind (N) in N_Entity);
4757          Nodes.Table (N + 2).Error_Posted := Val;
4758       end Set_Flag45;
4759
4760       procedure Set_Flag46 (N : Node_Id; Val : Boolean) is
4761       begin
4762          pragma Assert (Nkind (N) in N_Entity);
4763          Nodes.Table (N + 2).Flag4 := Val;
4764       end Set_Flag46;
4765
4766       procedure Set_Flag47 (N : Node_Id; Val : Boolean) is
4767       begin
4768          pragma Assert (Nkind (N) in N_Entity);
4769          Nodes.Table (N + 2).Flag5 := Val;
4770       end Set_Flag47;
4771
4772       procedure Set_Flag48 (N : Node_Id; Val : Boolean) is
4773       begin
4774          pragma Assert (Nkind (N) in N_Entity);
4775          Nodes.Table (N + 2).Flag6 := Val;
4776       end Set_Flag48;
4777
4778       procedure Set_Flag49 (N : Node_Id; Val : Boolean) is
4779       begin
4780          pragma Assert (Nkind (N) in N_Entity);
4781          Nodes.Table (N + 2).Flag7 := Val;
4782       end Set_Flag49;
4783
4784       procedure Set_Flag50 (N : Node_Id; Val : Boolean) is
4785       begin
4786          pragma Assert (Nkind (N) in N_Entity);
4787          Nodes.Table (N + 2).Flag8 := Val;
4788       end Set_Flag50;
4789
4790       procedure Set_Flag51 (N : Node_Id; Val : Boolean) is
4791       begin
4792          pragma Assert (Nkind (N) in N_Entity);
4793          Nodes.Table (N + 2).Flag9 := Val;
4794       end Set_Flag51;
4795
4796       procedure Set_Flag52 (N : Node_Id; Val : Boolean) is
4797       begin
4798          pragma Assert (Nkind (N) in N_Entity);
4799          Nodes.Table (N + 2).Flag10 := Val;
4800       end Set_Flag52;
4801
4802       procedure Set_Flag53 (N : Node_Id; Val : Boolean) is
4803       begin
4804          pragma Assert (Nkind (N) in N_Entity);
4805          Nodes.Table (N + 2).Flag11 := Val;
4806       end Set_Flag53;
4807
4808       procedure Set_Flag54 (N : Node_Id; Val : Boolean) is
4809       begin
4810          pragma Assert (Nkind (N) in N_Entity);
4811          Nodes.Table (N + 2).Flag12 := Val;
4812       end Set_Flag54;
4813
4814       procedure Set_Flag55 (N : Node_Id; Val : Boolean) is
4815       begin
4816          pragma Assert (Nkind (N) in N_Entity);
4817          Nodes.Table (N + 2).Flag13 := Val;
4818       end Set_Flag55;
4819
4820       procedure Set_Flag56 (N : Node_Id; Val : Boolean) is
4821       begin
4822          pragma Assert (Nkind (N) in N_Entity);
4823          Nodes.Table (N + 2).Flag14 := Val;
4824       end Set_Flag56;
4825
4826       procedure Set_Flag57 (N : Node_Id; Val : Boolean) is
4827       begin
4828          pragma Assert (Nkind (N) in N_Entity);
4829          Nodes.Table (N + 2).Flag15 := Val;
4830       end Set_Flag57;
4831
4832       procedure Set_Flag58 (N : Node_Id; Val : Boolean) is
4833       begin
4834          pragma Assert (Nkind (N) in N_Entity);
4835          Nodes.Table (N + 2).Flag16 := Val;
4836       end Set_Flag58;
4837
4838       procedure Set_Flag59 (N : Node_Id; Val : Boolean) is
4839       begin
4840          pragma Assert (Nkind (N) in N_Entity);
4841          Nodes.Table (N + 2).Flag17 := Val;
4842       end Set_Flag59;
4843
4844       procedure Set_Flag60 (N : Node_Id; Val : Boolean) is
4845       begin
4846          pragma Assert (Nkind (N) in N_Entity);
4847          Nodes.Table (N + 2).Flag18 := Val;
4848       end Set_Flag60;
4849
4850       procedure Set_Flag61 (N : Node_Id; Val : Boolean) is
4851       begin
4852          pragma Assert (Nkind (N) in N_Entity);
4853          Nodes.Table (N + 1).Pflag1 := Val;
4854       end Set_Flag61;
4855
4856       procedure Set_Flag62 (N : Node_Id; Val : Boolean) is
4857       begin
4858          pragma Assert (Nkind (N) in N_Entity);
4859          Nodes.Table (N + 1).Pflag2 := Val;
4860       end Set_Flag62;
4861
4862       procedure Set_Flag63 (N : Node_Id; Val : Boolean) is
4863       begin
4864          pragma Assert (Nkind (N) in N_Entity);
4865          Nodes.Table (N + 2).Pflag1 := Val;
4866       end Set_Flag63;
4867
4868       procedure Set_Flag64 (N : Node_Id; Val : Boolean) is
4869       begin
4870          pragma Assert (Nkind (N) in N_Entity);
4871          Nodes.Table (N + 2).Pflag2 := Val;
4872       end Set_Flag64;
4873
4874       procedure Set_Flag65 (N : Node_Id; Val : Boolean) is
4875       begin
4876          pragma Assert (Nkind (N) in N_Entity);
4877          To_Flag_Byte_Ptr
4878            (Node_Kind_Ptr'
4879              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag65 := Val;
4880       end Set_Flag65;
4881
4882       procedure Set_Flag66 (N : Node_Id; Val : Boolean) is
4883       begin
4884          pragma Assert (Nkind (N) in N_Entity);
4885          To_Flag_Byte_Ptr
4886            (Node_Kind_Ptr'
4887              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag66 := Val;
4888       end Set_Flag66;
4889
4890       procedure Set_Flag67 (N : Node_Id; Val : Boolean) is
4891       begin
4892          pragma Assert (Nkind (N) in N_Entity);
4893          To_Flag_Byte_Ptr
4894            (Node_Kind_Ptr'
4895              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag67 := Val;
4896       end Set_Flag67;
4897
4898       procedure Set_Flag68 (N : Node_Id; Val : Boolean) is
4899       begin
4900          pragma Assert (Nkind (N) in N_Entity);
4901          To_Flag_Byte_Ptr
4902            (Node_Kind_Ptr'
4903              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag68 := Val;
4904       end Set_Flag68;
4905
4906       procedure Set_Flag69 (N : Node_Id; Val : Boolean) is
4907       begin
4908          pragma Assert (Nkind (N) in N_Entity);
4909          To_Flag_Byte_Ptr
4910            (Node_Kind_Ptr'
4911              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag69 := Val;
4912       end Set_Flag69;
4913
4914       procedure Set_Flag70 (N : Node_Id; Val : Boolean) is
4915       begin
4916          pragma Assert (Nkind (N) in N_Entity);
4917          To_Flag_Byte_Ptr
4918            (Node_Kind_Ptr'
4919              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag70 := Val;
4920       end Set_Flag70;
4921
4922       procedure Set_Flag71 (N : Node_Id; Val : Boolean) is
4923       begin
4924          pragma Assert (Nkind (N) in N_Entity);
4925          To_Flag_Byte_Ptr
4926            (Node_Kind_Ptr'
4927              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag71 := Val;
4928       end Set_Flag71;
4929
4930       procedure Set_Flag72 (N : Node_Id; Val : Boolean) is
4931       begin
4932          pragma Assert (Nkind (N) in N_Entity);
4933          To_Flag_Byte_Ptr
4934            (Node_Kind_Ptr'
4935              (Nodes.Table (N + 2).Nkind'Unrestricted_Access)).Flag72 := Val;
4936       end Set_Flag72;
4937
4938       procedure Set_Flag73 (N : Node_Id; Val : Boolean) is
4939       begin
4940          pragma Assert (Nkind (N) in N_Entity);
4941          To_Flag_Word_Ptr
4942            (Union_Id_Ptr'
4943              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag73 := Val;
4944       end Set_Flag73;
4945
4946       procedure Set_Flag74 (N : Node_Id; Val : Boolean) is
4947       begin
4948          pragma Assert (Nkind (N) in N_Entity);
4949          To_Flag_Word_Ptr
4950            (Union_Id_Ptr'
4951              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag74 := Val;
4952       end Set_Flag74;
4953
4954       procedure Set_Flag75 (N : Node_Id; Val : Boolean) is
4955       begin
4956          pragma Assert (Nkind (N) in N_Entity);
4957          To_Flag_Word_Ptr
4958            (Union_Id_Ptr'
4959              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag75 := Val;
4960       end Set_Flag75;
4961
4962       procedure Set_Flag76 (N : Node_Id; Val : Boolean) is
4963       begin
4964          pragma Assert (Nkind (N) in N_Entity);
4965          To_Flag_Word_Ptr
4966            (Union_Id_Ptr'
4967              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag76 := Val;
4968       end Set_Flag76;
4969
4970       procedure Set_Flag77 (N : Node_Id; Val : Boolean) is
4971       begin
4972          pragma Assert (Nkind (N) in N_Entity);
4973          To_Flag_Word_Ptr
4974            (Union_Id_Ptr'
4975              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag77 := Val;
4976       end Set_Flag77;
4977
4978       procedure Set_Flag78 (N : Node_Id; Val : Boolean) is
4979       begin
4980          pragma Assert (Nkind (N) in N_Entity);
4981          To_Flag_Word_Ptr
4982            (Union_Id_Ptr'
4983              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag78 := Val;
4984       end Set_Flag78;
4985
4986       procedure Set_Flag79 (N : Node_Id; Val : Boolean) is
4987       begin
4988          pragma Assert (Nkind (N) in N_Entity);
4989          To_Flag_Word_Ptr
4990            (Union_Id_Ptr'
4991              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag79 := Val;
4992       end Set_Flag79;
4993
4994       procedure Set_Flag80 (N : Node_Id; Val : Boolean) is
4995       begin
4996          pragma Assert (Nkind (N) in N_Entity);
4997          To_Flag_Word_Ptr
4998            (Union_Id_Ptr'
4999              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag80 := Val;
5000       end Set_Flag80;
5001
5002       procedure Set_Flag81 (N : Node_Id; Val : Boolean) is
5003       begin
5004          pragma Assert (Nkind (N) in N_Entity);
5005          To_Flag_Word_Ptr
5006            (Union_Id_Ptr'
5007              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag81 := Val;
5008       end Set_Flag81;
5009
5010       procedure Set_Flag82 (N : Node_Id; Val : Boolean) is
5011       begin
5012          pragma Assert (Nkind (N) in N_Entity);
5013          To_Flag_Word_Ptr
5014            (Union_Id_Ptr'
5015              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag82 := Val;
5016       end Set_Flag82;
5017
5018       procedure Set_Flag83 (N : Node_Id; Val : Boolean) is
5019       begin
5020          pragma Assert (Nkind (N) in N_Entity);
5021          To_Flag_Word_Ptr
5022            (Union_Id_Ptr'
5023              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag83 := Val;
5024       end Set_Flag83;
5025
5026       procedure Set_Flag84 (N : Node_Id; Val : Boolean) is
5027       begin
5028          pragma Assert (Nkind (N) in N_Entity);
5029          To_Flag_Word_Ptr
5030            (Union_Id_Ptr'
5031              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag84 := Val;
5032       end Set_Flag84;
5033
5034       procedure Set_Flag85 (N : Node_Id; Val : Boolean) is
5035       begin
5036          pragma Assert (Nkind (N) in N_Entity);
5037          To_Flag_Word_Ptr
5038            (Union_Id_Ptr'
5039              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag85 := Val;
5040       end Set_Flag85;
5041
5042       procedure Set_Flag86 (N : Node_Id; Val : Boolean) is
5043       begin
5044          pragma Assert (Nkind (N) in N_Entity);
5045          To_Flag_Word_Ptr
5046            (Union_Id_Ptr'
5047              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag86 := Val;
5048       end Set_Flag86;
5049
5050       procedure Set_Flag87 (N : Node_Id; Val : Boolean) is
5051       begin
5052          pragma Assert (Nkind (N) in N_Entity);
5053          To_Flag_Word_Ptr
5054            (Union_Id_Ptr'
5055              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag87 := Val;
5056       end Set_Flag87;
5057
5058       procedure Set_Flag88 (N : Node_Id; Val : Boolean) is
5059       begin
5060          pragma Assert (Nkind (N) in N_Entity);
5061          To_Flag_Word_Ptr
5062            (Union_Id_Ptr'
5063              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag88 := Val;
5064       end Set_Flag88;
5065
5066       procedure Set_Flag89 (N : Node_Id; Val : Boolean) is
5067       begin
5068          pragma Assert (Nkind (N) in N_Entity);
5069          To_Flag_Word_Ptr
5070            (Union_Id_Ptr'
5071              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag89 := Val;
5072       end Set_Flag89;
5073
5074       procedure Set_Flag90 (N : Node_Id; Val : Boolean) is
5075       begin
5076          pragma Assert (Nkind (N) in N_Entity);
5077          To_Flag_Word_Ptr
5078            (Union_Id_Ptr'
5079              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag90 := Val;
5080       end Set_Flag90;
5081
5082       procedure Set_Flag91 (N : Node_Id; Val : Boolean) is
5083       begin
5084          pragma Assert (Nkind (N) in N_Entity);
5085          To_Flag_Word_Ptr
5086            (Union_Id_Ptr'
5087              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag91 := Val;
5088       end Set_Flag91;
5089
5090       procedure Set_Flag92 (N : Node_Id; Val : Boolean) is
5091       begin
5092          pragma Assert (Nkind (N) in N_Entity);
5093          To_Flag_Word_Ptr
5094            (Union_Id_Ptr'
5095              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag92 := Val;
5096       end Set_Flag92;
5097
5098       procedure Set_Flag93 (N : Node_Id; Val : Boolean) is
5099       begin
5100          pragma Assert (Nkind (N) in N_Entity);
5101          To_Flag_Word_Ptr
5102            (Union_Id_Ptr'
5103              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag93 := Val;
5104       end Set_Flag93;
5105
5106       procedure Set_Flag94 (N : Node_Id; Val : Boolean) is
5107       begin
5108          pragma Assert (Nkind (N) in N_Entity);
5109          To_Flag_Word_Ptr
5110            (Union_Id_Ptr'
5111              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag94 := Val;
5112       end Set_Flag94;
5113
5114       procedure Set_Flag95 (N : Node_Id; Val : Boolean) is
5115       begin
5116          pragma Assert (Nkind (N) in N_Entity);
5117          To_Flag_Word_Ptr
5118            (Union_Id_Ptr'
5119              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag95 := Val;
5120       end Set_Flag95;
5121
5122       procedure Set_Flag96 (N : Node_Id; Val : Boolean) is
5123       begin
5124          pragma Assert (Nkind (N) in N_Entity);
5125          To_Flag_Word_Ptr
5126            (Union_Id_Ptr'
5127              (Nodes.Table (N + 2).Field12'Unrestricted_Access)).Flag96 := Val;
5128       end Set_Flag96;
5129
5130       procedure Set_Flag97 (N : Node_Id; Val : Boolean) is
5131       begin
5132          pragma Assert (Nkind (N) in N_Entity);
5133          To_Flag_Word2_Ptr
5134            (Union_Id_Ptr'
5135              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag97 := Val;
5136       end Set_Flag97;
5137
5138       procedure Set_Flag98 (N : Node_Id; Val : Boolean) is
5139       begin
5140          pragma Assert (Nkind (N) in N_Entity);
5141          To_Flag_Word2_Ptr
5142            (Union_Id_Ptr'
5143              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag98 := Val;
5144       end Set_Flag98;
5145
5146       procedure Set_Flag99 (N : Node_Id; Val : Boolean) is
5147       begin
5148          pragma Assert (Nkind (N) in N_Entity);
5149          To_Flag_Word2_Ptr
5150            (Union_Id_Ptr'
5151              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag99 := Val;
5152       end Set_Flag99;
5153
5154       procedure Set_Flag100 (N : Node_Id; Val : Boolean) is
5155       begin
5156          pragma Assert (Nkind (N) in N_Entity);
5157          To_Flag_Word2_Ptr
5158            (Union_Id_Ptr'
5159              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag100 := Val;
5160       end Set_Flag100;
5161
5162       procedure Set_Flag101 (N : Node_Id; Val : Boolean) is
5163       begin
5164          pragma Assert (Nkind (N) in N_Entity);
5165          To_Flag_Word2_Ptr
5166            (Union_Id_Ptr'
5167              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag101 := Val;
5168       end Set_Flag101;
5169
5170       procedure Set_Flag102 (N : Node_Id; Val : Boolean) is
5171       begin
5172          pragma Assert (Nkind (N) in N_Entity);
5173          To_Flag_Word2_Ptr
5174            (Union_Id_Ptr'
5175              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag102 := Val;
5176       end Set_Flag102;
5177
5178       procedure Set_Flag103 (N : Node_Id; Val : Boolean) is
5179       begin
5180          pragma Assert (Nkind (N) in N_Entity);
5181          To_Flag_Word2_Ptr
5182            (Union_Id_Ptr'
5183              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag103 := Val;
5184       end Set_Flag103;
5185
5186       procedure Set_Flag104 (N : Node_Id; Val : Boolean) is
5187       begin
5188          pragma Assert (Nkind (N) in N_Entity);
5189          To_Flag_Word2_Ptr
5190            (Union_Id_Ptr'
5191              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag104 := Val;
5192       end Set_Flag104;
5193
5194       procedure Set_Flag105 (N : Node_Id; Val : Boolean) is
5195       begin
5196          pragma Assert (Nkind (N) in N_Entity);
5197          To_Flag_Word2_Ptr
5198            (Union_Id_Ptr'
5199              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag105 := Val;
5200       end Set_Flag105;
5201
5202       procedure Set_Flag106 (N : Node_Id; Val : Boolean) is
5203       begin
5204          pragma Assert (Nkind (N) in N_Entity);
5205          To_Flag_Word2_Ptr
5206            (Union_Id_Ptr'
5207              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag106 := Val;
5208       end Set_Flag106;
5209
5210       procedure Set_Flag107 (N : Node_Id; Val : Boolean) is
5211       begin
5212          pragma Assert (Nkind (N) in N_Entity);
5213          To_Flag_Word2_Ptr
5214            (Union_Id_Ptr'
5215              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag107 := Val;
5216       end Set_Flag107;
5217
5218       procedure Set_Flag108 (N : Node_Id; Val : Boolean) is
5219       begin
5220          pragma Assert (Nkind (N) in N_Entity);
5221          To_Flag_Word2_Ptr
5222            (Union_Id_Ptr'
5223              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag108 := Val;
5224       end Set_Flag108;
5225
5226       procedure Set_Flag109 (N : Node_Id; Val : Boolean) is
5227       begin
5228          pragma Assert (Nkind (N) in N_Entity);
5229          To_Flag_Word2_Ptr
5230            (Union_Id_Ptr'
5231              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag109 := Val;
5232       end Set_Flag109;
5233
5234       procedure Set_Flag110 (N : Node_Id; Val : Boolean) is
5235       begin
5236          pragma Assert (Nkind (N) in N_Entity);
5237          To_Flag_Word2_Ptr
5238            (Union_Id_Ptr'
5239              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag110 := Val;
5240       end Set_Flag110;
5241
5242       procedure Set_Flag111 (N : Node_Id; Val : Boolean) is
5243       begin
5244          pragma Assert (Nkind (N) in N_Entity);
5245          To_Flag_Word2_Ptr
5246            (Union_Id_Ptr'
5247              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag111 := Val;
5248       end Set_Flag111;
5249
5250       procedure Set_Flag112 (N : Node_Id; Val : Boolean) is
5251       begin
5252          pragma Assert (Nkind (N) in N_Entity);
5253          To_Flag_Word2_Ptr
5254            (Union_Id_Ptr'
5255              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag112 := Val;
5256       end Set_Flag112;
5257
5258       procedure Set_Flag113 (N : Node_Id; Val : Boolean) is
5259       begin
5260          pragma Assert (Nkind (N) in N_Entity);
5261          To_Flag_Word2_Ptr
5262            (Union_Id_Ptr'
5263              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag113 := Val;
5264       end Set_Flag113;
5265
5266       procedure Set_Flag114 (N : Node_Id; Val : Boolean) is
5267       begin
5268          pragma Assert (Nkind (N) in N_Entity);
5269          To_Flag_Word2_Ptr
5270            (Union_Id_Ptr'
5271              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag114 := Val;
5272       end Set_Flag114;
5273
5274       procedure Set_Flag115 (N : Node_Id; Val : Boolean) is
5275       begin
5276          pragma Assert (Nkind (N) in N_Entity);
5277          To_Flag_Word2_Ptr
5278            (Union_Id_Ptr'
5279              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag115 := Val;
5280       end Set_Flag115;
5281
5282       procedure Set_Flag116 (N : Node_Id; Val : Boolean) is
5283       begin
5284          pragma Assert (Nkind (N) in N_Entity);
5285          To_Flag_Word2_Ptr
5286            (Union_Id_Ptr'
5287              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag116 := Val;
5288       end Set_Flag116;
5289
5290       procedure Set_Flag117 (N : Node_Id; Val : Boolean) is
5291       begin
5292          pragma Assert (Nkind (N) in N_Entity);
5293          To_Flag_Word2_Ptr
5294            (Union_Id_Ptr'
5295              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag117 := Val;
5296       end Set_Flag117;
5297
5298       procedure Set_Flag118 (N : Node_Id; Val : Boolean) is
5299       begin
5300          pragma Assert (Nkind (N) in N_Entity);
5301          To_Flag_Word2_Ptr
5302            (Union_Id_Ptr'
5303              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag118 := Val;
5304       end Set_Flag118;
5305
5306       procedure Set_Flag119 (N : Node_Id; Val : Boolean) is
5307       begin
5308          pragma Assert (Nkind (N) in N_Entity);
5309          To_Flag_Word2_Ptr
5310            (Union_Id_Ptr'
5311              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag119 := Val;
5312       end Set_Flag119;
5313
5314       procedure Set_Flag120 (N : Node_Id; Val : Boolean) is
5315       begin
5316          pragma Assert (Nkind (N) in N_Entity);
5317          To_Flag_Word2_Ptr
5318            (Union_Id_Ptr'
5319              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag120 := Val;
5320       end Set_Flag120;
5321
5322       procedure Set_Flag121 (N : Node_Id; Val : Boolean) is
5323       begin
5324          pragma Assert (Nkind (N) in N_Entity);
5325          To_Flag_Word2_Ptr
5326            (Union_Id_Ptr'
5327              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag121 := Val;
5328       end Set_Flag121;
5329
5330       procedure Set_Flag122 (N : Node_Id; Val : Boolean) is
5331       begin
5332          pragma Assert (Nkind (N) in N_Entity);
5333          To_Flag_Word2_Ptr
5334            (Union_Id_Ptr'
5335              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag122 := Val;
5336       end Set_Flag122;
5337
5338       procedure Set_Flag123 (N : Node_Id; Val : Boolean) is
5339       begin
5340          pragma Assert (Nkind (N) in N_Entity);
5341          To_Flag_Word2_Ptr
5342            (Union_Id_Ptr'
5343              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag123 := Val;
5344       end Set_Flag123;
5345
5346       procedure Set_Flag124 (N : Node_Id; Val : Boolean) is
5347       begin
5348          pragma Assert (Nkind (N) in N_Entity);
5349          To_Flag_Word2_Ptr
5350            (Union_Id_Ptr'
5351              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag124 := Val;
5352       end Set_Flag124;
5353
5354       procedure Set_Flag125 (N : Node_Id; Val : Boolean) is
5355       begin
5356          pragma Assert (Nkind (N) in N_Entity);
5357          To_Flag_Word2_Ptr
5358            (Union_Id_Ptr'
5359              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag125 := Val;
5360       end Set_Flag125;
5361
5362       procedure Set_Flag126 (N : Node_Id; Val : Boolean) is
5363       begin
5364          pragma Assert (Nkind (N) in N_Entity);
5365          To_Flag_Word2_Ptr
5366            (Union_Id_Ptr'
5367              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag126 := Val;
5368       end Set_Flag126;
5369
5370       procedure Set_Flag127 (N : Node_Id; Val : Boolean) is
5371       begin
5372          pragma Assert (Nkind (N) in N_Entity);
5373          To_Flag_Word2_Ptr
5374            (Union_Id_Ptr'
5375              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag127 := Val;
5376       end Set_Flag127;
5377
5378       procedure Set_Flag128 (N : Node_Id; Val : Boolean) is
5379       begin
5380          pragma Assert (Nkind (N) in N_Entity);
5381          To_Flag_Word2_Ptr
5382            (Union_Id_Ptr'
5383              (Nodes.Table (N + 3).Field12'Unrestricted_Access)).Flag128 := Val;
5384       end Set_Flag128;
5385
5386       procedure Set_Flag129 (N : Node_Id; Val : Boolean) is
5387       begin
5388          pragma Assert (Nkind (N) in N_Entity);
5389          Nodes.Table (N + 3).In_List := Val;
5390       end Set_Flag129;
5391
5392       procedure Set_Flag130 (N : Node_Id; Val : Boolean) is
5393       begin
5394          pragma Assert (Nkind (N) in N_Entity);
5395          Nodes.Table (N + 3).Unused_1 := Val;
5396       end Set_Flag130;
5397
5398       procedure Set_Flag131 (N : Node_Id; Val : Boolean) is
5399       begin
5400          pragma Assert (Nkind (N) in N_Entity);
5401          Nodes.Table (N + 3).Rewrite_Ins := Val;
5402       end Set_Flag131;
5403
5404       procedure Set_Flag132 (N : Node_Id; Val : Boolean) is
5405       begin
5406          pragma Assert (Nkind (N) in N_Entity);
5407          Nodes.Table (N + 3).Analyzed := Val;
5408       end Set_Flag132;
5409
5410       procedure Set_Flag133 (N : Node_Id; Val : Boolean) is
5411       begin
5412          pragma Assert (Nkind (N) in N_Entity);
5413          Nodes.Table (N + 3).Comes_From_Source := Val;
5414       end Set_Flag133;
5415
5416       procedure Set_Flag134 (N : Node_Id; Val : Boolean) is
5417       begin
5418          pragma Assert (Nkind (N) in N_Entity);
5419          Nodes.Table (N + 3).Error_Posted := Val;
5420       end Set_Flag134;
5421
5422       procedure Set_Flag135 (N : Node_Id; Val : Boolean) is
5423       begin
5424          pragma Assert (Nkind (N) in N_Entity);
5425          Nodes.Table (N + 3).Flag4 := Val;
5426       end Set_Flag135;
5427
5428       procedure Set_Flag136 (N : Node_Id; Val : Boolean) is
5429       begin
5430          pragma Assert (Nkind (N) in N_Entity);
5431          Nodes.Table (N + 3).Flag5 := Val;
5432       end Set_Flag136;
5433
5434       procedure Set_Flag137 (N : Node_Id; Val : Boolean) is
5435       begin
5436          pragma Assert (Nkind (N) in N_Entity);
5437          Nodes.Table (N + 3).Flag6 := Val;
5438       end Set_Flag137;
5439
5440       procedure Set_Flag138 (N : Node_Id; Val : Boolean) is
5441       begin
5442          pragma Assert (Nkind (N) in N_Entity);
5443          Nodes.Table (N + 3).Flag7 := Val;
5444       end Set_Flag138;
5445
5446       procedure Set_Flag139 (N : Node_Id; Val : Boolean) is
5447       begin
5448          pragma Assert (Nkind (N) in N_Entity);
5449          Nodes.Table (N + 3).Flag8 := Val;
5450       end Set_Flag139;
5451
5452       procedure Set_Flag140 (N : Node_Id; Val : Boolean) is
5453       begin
5454          pragma Assert (Nkind (N) in N_Entity);
5455          Nodes.Table (N + 3).Flag9 := Val;
5456       end Set_Flag140;
5457
5458       procedure Set_Flag141 (N : Node_Id; Val : Boolean) is
5459       begin
5460          pragma Assert (Nkind (N) in N_Entity);
5461          Nodes.Table (N + 3).Flag10 := Val;
5462       end Set_Flag141;
5463
5464       procedure Set_Flag142 (N : Node_Id; Val : Boolean) is
5465       begin
5466          pragma Assert (Nkind (N) in N_Entity);
5467          Nodes.Table (N + 3).Flag11 := Val;
5468       end Set_Flag142;
5469
5470       procedure Set_Flag143 (N : Node_Id; Val : Boolean) is
5471       begin
5472          pragma Assert (Nkind (N) in N_Entity);
5473          Nodes.Table (N + 3).Flag12 := Val;
5474       end Set_Flag143;
5475
5476       procedure Set_Flag144 (N : Node_Id; Val : Boolean) is
5477       begin
5478          pragma Assert (Nkind (N) in N_Entity);
5479          Nodes.Table (N + 3).Flag13 := Val;
5480       end Set_Flag144;
5481
5482       procedure Set_Flag145 (N : Node_Id; Val : Boolean) is
5483       begin
5484          pragma Assert (Nkind (N) in N_Entity);
5485          Nodes.Table (N + 3).Flag14 := Val;
5486       end Set_Flag145;
5487
5488       procedure Set_Flag146 (N : Node_Id; Val : Boolean) is
5489       begin
5490          pragma Assert (Nkind (N) in N_Entity);
5491          Nodes.Table (N + 3).Flag15 := Val;
5492       end Set_Flag146;
5493
5494       procedure Set_Flag147 (N : Node_Id; Val : Boolean) is
5495       begin
5496          pragma Assert (Nkind (N) in N_Entity);
5497          Nodes.Table (N + 3).Flag16 := Val;
5498       end Set_Flag147;
5499
5500       procedure Set_Flag148 (N : Node_Id; Val : Boolean) is
5501       begin
5502          pragma Assert (Nkind (N) in N_Entity);
5503          Nodes.Table (N + 3).Flag17 := Val;
5504       end Set_Flag148;
5505
5506       procedure Set_Flag149 (N : Node_Id; Val : Boolean) is
5507       begin
5508          pragma Assert (Nkind (N) in N_Entity);
5509          Nodes.Table (N + 3).Flag18 := Val;
5510       end Set_Flag149;
5511
5512       procedure Set_Flag150 (N : Node_Id; Val : Boolean) is
5513       begin
5514          pragma Assert (Nkind (N) in N_Entity);
5515          Nodes.Table (N + 3).Pflag1 := Val;
5516       end Set_Flag150;
5517
5518       procedure Set_Flag151 (N : Node_Id; Val : Boolean) is
5519       begin
5520          pragma Assert (Nkind (N) in N_Entity);
5521          Nodes.Table (N + 3).Pflag2 := Val;
5522       end Set_Flag151;
5523
5524       procedure Set_Flag152 (N : Node_Id; Val : Boolean) is
5525       begin
5526          pragma Assert (Nkind (N) in N_Entity);
5527          To_Flag_Word3_Ptr
5528            (Union_Id_Ptr'
5529              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag152 := Val;
5530       end Set_Flag152;
5531
5532       procedure Set_Flag153 (N : Node_Id; Val : Boolean) is
5533       begin
5534          pragma Assert (Nkind (N) in N_Entity);
5535          To_Flag_Word3_Ptr
5536            (Union_Id_Ptr'
5537              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag153 := Val;
5538       end Set_Flag153;
5539
5540       procedure Set_Flag154 (N : Node_Id; Val : Boolean) is
5541       begin
5542          pragma Assert (Nkind (N) in N_Entity);
5543          To_Flag_Word3_Ptr
5544            (Union_Id_Ptr'
5545              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag154 := Val;
5546       end Set_Flag154;
5547
5548       procedure Set_Flag155 (N : Node_Id; Val : Boolean) is
5549       begin
5550          pragma Assert (Nkind (N) in N_Entity);
5551          To_Flag_Word3_Ptr
5552            (Union_Id_Ptr'
5553              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag155 := Val;
5554       end Set_Flag155;
5555
5556       procedure Set_Flag156 (N : Node_Id; Val : Boolean) is
5557       begin
5558          pragma Assert (Nkind (N) in N_Entity);
5559          To_Flag_Word3_Ptr
5560            (Union_Id_Ptr'
5561              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag156 := Val;
5562       end Set_Flag156;
5563
5564       procedure Set_Flag157 (N : Node_Id; Val : Boolean) is
5565       begin
5566          pragma Assert (Nkind (N) in N_Entity);
5567          To_Flag_Word3_Ptr
5568            (Union_Id_Ptr'
5569              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag157 := Val;
5570       end Set_Flag157;
5571
5572       procedure Set_Flag158 (N : Node_Id; Val : Boolean) is
5573       begin
5574          pragma Assert (Nkind (N) in N_Entity);
5575          To_Flag_Word3_Ptr
5576            (Union_Id_Ptr'
5577              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag158 := Val;
5578       end Set_Flag158;
5579
5580       procedure Set_Flag159 (N : Node_Id; Val : Boolean) is
5581       begin
5582          pragma Assert (Nkind (N) in N_Entity);
5583          To_Flag_Word3_Ptr
5584            (Union_Id_Ptr'
5585              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag159 := Val;
5586       end Set_Flag159;
5587
5588       procedure Set_Flag160 (N : Node_Id; Val : Boolean) is
5589       begin
5590          pragma Assert (Nkind (N) in N_Entity);
5591          To_Flag_Word3_Ptr
5592            (Union_Id_Ptr'
5593              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag160 := Val;
5594       end Set_Flag160;
5595
5596       procedure Set_Flag161 (N : Node_Id; Val : Boolean) is
5597       begin
5598          pragma Assert (Nkind (N) in N_Entity);
5599          To_Flag_Word3_Ptr
5600            (Union_Id_Ptr'
5601              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag161 := Val;
5602       end Set_Flag161;
5603
5604       procedure Set_Flag162 (N : Node_Id; Val : Boolean) is
5605       begin
5606          pragma Assert (Nkind (N) in N_Entity);
5607          To_Flag_Word3_Ptr
5608            (Union_Id_Ptr'
5609              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag162 := Val;
5610       end Set_Flag162;
5611
5612       procedure Set_Flag163 (N : Node_Id; Val : Boolean) is
5613       begin
5614          pragma Assert (Nkind (N) in N_Entity);
5615          To_Flag_Word3_Ptr
5616            (Union_Id_Ptr'
5617              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag163 := Val;
5618       end Set_Flag163;
5619
5620       procedure Set_Flag164 (N : Node_Id; Val : Boolean) is
5621       begin
5622          pragma Assert (Nkind (N) in N_Entity);
5623          To_Flag_Word3_Ptr
5624            (Union_Id_Ptr'
5625              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag164 := Val;
5626       end Set_Flag164;
5627
5628       procedure Set_Flag165 (N : Node_Id; Val : Boolean) is
5629       begin
5630          pragma Assert (Nkind (N) in N_Entity);
5631          To_Flag_Word3_Ptr
5632            (Union_Id_Ptr'
5633              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag165 := Val;
5634       end Set_Flag165;
5635
5636       procedure Set_Flag166 (N : Node_Id; Val : Boolean) is
5637       begin
5638          pragma Assert (Nkind (N) in N_Entity);
5639          To_Flag_Word3_Ptr
5640            (Union_Id_Ptr'
5641              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag166 := Val;
5642       end Set_Flag166;
5643
5644       procedure Set_Flag167 (N : Node_Id; Val : Boolean) is
5645       begin
5646          pragma Assert (Nkind (N) in N_Entity);
5647          To_Flag_Word3_Ptr
5648            (Union_Id_Ptr'
5649              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag167 := Val;
5650       end Set_Flag167;
5651
5652       procedure Set_Flag168 (N : Node_Id; Val : Boolean) is
5653       begin
5654          pragma Assert (Nkind (N) in N_Entity);
5655          To_Flag_Word3_Ptr
5656            (Union_Id_Ptr'
5657              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag168 := Val;
5658       end Set_Flag168;
5659
5660       procedure Set_Flag169 (N : Node_Id; Val : Boolean) is
5661       begin
5662          pragma Assert (Nkind (N) in N_Entity);
5663          To_Flag_Word3_Ptr
5664            (Union_Id_Ptr'
5665              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag169 := Val;
5666       end Set_Flag169;
5667
5668       procedure Set_Flag170 (N : Node_Id; Val : Boolean) is
5669       begin
5670          pragma Assert (Nkind (N) in N_Entity);
5671          To_Flag_Word3_Ptr
5672            (Union_Id_Ptr'
5673              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag170 := Val;
5674       end Set_Flag170;
5675
5676       procedure Set_Flag171 (N : Node_Id; Val : Boolean) is
5677       begin
5678          pragma Assert (Nkind (N) in N_Entity);
5679          To_Flag_Word3_Ptr
5680            (Union_Id_Ptr'
5681              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag171 := Val;
5682       end Set_Flag171;
5683
5684       procedure Set_Flag172 (N : Node_Id; Val : Boolean) is
5685       begin
5686          pragma Assert (Nkind (N) in N_Entity);
5687          To_Flag_Word3_Ptr
5688            (Union_Id_Ptr'
5689              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag172 := Val;
5690       end Set_Flag172;
5691
5692       procedure Set_Flag173 (N : Node_Id; Val : Boolean) is
5693       begin
5694          pragma Assert (Nkind (N) in N_Entity);
5695          To_Flag_Word3_Ptr
5696            (Union_Id_Ptr'
5697              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag173 := Val;
5698       end Set_Flag173;
5699
5700       procedure Set_Flag174 (N : Node_Id; Val : Boolean) is
5701       begin
5702          pragma Assert (Nkind (N) in N_Entity);
5703          To_Flag_Word3_Ptr
5704            (Union_Id_Ptr'
5705              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag174 := Val;
5706       end Set_Flag174;
5707
5708       procedure Set_Flag175 (N : Node_Id; Val : Boolean) is
5709       begin
5710          pragma Assert (Nkind (N) in N_Entity);
5711          To_Flag_Word3_Ptr
5712            (Union_Id_Ptr'
5713              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag175 := Val;
5714       end Set_Flag175;
5715
5716       procedure Set_Flag176 (N : Node_Id; Val : Boolean) is
5717       begin
5718          pragma Assert (Nkind (N) in N_Entity);
5719          To_Flag_Word3_Ptr
5720            (Union_Id_Ptr'
5721              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag176 := Val;
5722       end Set_Flag176;
5723
5724       procedure Set_Flag177 (N : Node_Id; Val : Boolean) is
5725       begin
5726          pragma Assert (Nkind (N) in N_Entity);
5727          To_Flag_Word3_Ptr
5728            (Union_Id_Ptr'
5729              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag177 := Val;
5730       end Set_Flag177;
5731
5732       procedure Set_Flag178 (N : Node_Id; Val : Boolean) is
5733       begin
5734          pragma Assert (Nkind (N) in N_Entity);
5735          To_Flag_Word3_Ptr
5736            (Union_Id_Ptr'
5737              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag178 := Val;
5738       end Set_Flag178;
5739
5740       procedure Set_Flag179 (N : Node_Id; Val : Boolean) is
5741       begin
5742          pragma Assert (Nkind (N) in N_Entity);
5743          To_Flag_Word3_Ptr
5744            (Union_Id_Ptr'
5745              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag179 := Val;
5746       end Set_Flag179;
5747
5748       procedure Set_Flag180 (N : Node_Id; Val : Boolean) is
5749       begin
5750          pragma Assert (Nkind (N) in N_Entity);
5751          To_Flag_Word3_Ptr
5752            (Union_Id_Ptr'
5753              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag180 := Val;
5754       end Set_Flag180;
5755
5756       procedure Set_Flag181 (N : Node_Id; Val : Boolean) is
5757       begin
5758          pragma Assert (Nkind (N) in N_Entity);
5759          To_Flag_Word3_Ptr
5760            (Union_Id_Ptr'
5761              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag181 := Val;
5762       end Set_Flag181;
5763
5764       procedure Set_Flag182 (N : Node_Id; Val : Boolean) is
5765       begin
5766          pragma Assert (Nkind (N) in N_Entity);
5767          To_Flag_Word3_Ptr
5768            (Union_Id_Ptr'
5769              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag182 := Val;
5770       end Set_Flag182;
5771
5772       procedure Set_Flag183 (N : Node_Id; Val : Boolean) is
5773       begin
5774          pragma Assert (Nkind (N) in N_Entity);
5775          To_Flag_Word3_Ptr
5776            (Union_Id_Ptr'
5777              (Nodes.Table (N + 3).Field11'Unrestricted_Access)).Flag183 := Val;
5778       end Set_Flag183;
5779
5780       procedure Set_Flag184 (N : Node_Id; Val : Boolean) is
5781       begin
5782          pragma Assert (Nkind (N) in N_Entity);
5783          To_Flag_Word4_Ptr
5784            (Union_Id_Ptr'
5785              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag184 := Val;
5786       end Set_Flag184;
5787
5788       procedure Set_Flag185 (N : Node_Id; Val : Boolean) is
5789       begin
5790          pragma Assert (Nkind (N) in N_Entity);
5791          To_Flag_Word4_Ptr
5792            (Union_Id_Ptr'
5793              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag185 := Val;
5794       end Set_Flag185;
5795
5796       procedure Set_Flag186 (N : Node_Id; Val : Boolean) is
5797       begin
5798          pragma Assert (Nkind (N) in N_Entity);
5799          To_Flag_Word4_Ptr
5800            (Union_Id_Ptr'
5801              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag186 := Val;
5802       end Set_Flag186;
5803
5804       procedure Set_Flag187 (N : Node_Id; Val : Boolean) is
5805       begin
5806          pragma Assert (Nkind (N) in N_Entity);
5807          To_Flag_Word4_Ptr
5808            (Union_Id_Ptr'
5809              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag187 := Val;
5810       end Set_Flag187;
5811
5812       procedure Set_Flag188 (N : Node_Id; Val : Boolean) is
5813       begin
5814          pragma Assert (Nkind (N) in N_Entity);
5815          To_Flag_Word4_Ptr
5816            (Union_Id_Ptr'
5817              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag188 := Val;
5818       end Set_Flag188;
5819
5820       procedure Set_Flag189 (N : Node_Id; Val : Boolean) is
5821       begin
5822          pragma Assert (Nkind (N) in N_Entity);
5823          To_Flag_Word4_Ptr
5824            (Union_Id_Ptr'
5825              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag189 := Val;
5826       end Set_Flag189;
5827
5828       procedure Set_Flag190 (N : Node_Id; Val : Boolean) is
5829       begin
5830          pragma Assert (Nkind (N) in N_Entity);
5831          To_Flag_Word4_Ptr
5832            (Union_Id_Ptr'
5833              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag190 := Val;
5834       end Set_Flag190;
5835
5836       procedure Set_Flag191 (N : Node_Id; Val : Boolean) is
5837       begin
5838          pragma Assert (Nkind (N) in N_Entity);
5839          To_Flag_Word4_Ptr
5840            (Union_Id_Ptr'
5841              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag191 := Val;
5842       end Set_Flag191;
5843
5844       procedure Set_Flag192 (N : Node_Id; Val : Boolean) is
5845       begin
5846          pragma Assert (Nkind (N) in N_Entity);
5847          To_Flag_Word4_Ptr
5848            (Union_Id_Ptr'
5849              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag192 := Val;
5850       end Set_Flag192;
5851
5852       procedure Set_Flag193 (N : Node_Id; Val : Boolean) is
5853       begin
5854          pragma Assert (Nkind (N) in N_Entity);
5855          To_Flag_Word4_Ptr
5856            (Union_Id_Ptr'
5857              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag193 := Val;
5858       end Set_Flag193;
5859
5860       procedure Set_Flag194 (N : Node_Id; Val : Boolean) is
5861       begin
5862          pragma Assert (Nkind (N) in N_Entity);
5863          To_Flag_Word4_Ptr
5864            (Union_Id_Ptr'
5865              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag194 := Val;
5866       end Set_Flag194;
5867
5868       procedure Set_Flag195 (N : Node_Id; Val : Boolean) is
5869       begin
5870          pragma Assert (Nkind (N) in N_Entity);
5871          To_Flag_Word4_Ptr
5872            (Union_Id_Ptr'
5873              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag195 := Val;
5874       end Set_Flag195;
5875
5876       procedure Set_Flag196 (N : Node_Id; Val : Boolean) is
5877       begin
5878          pragma Assert (Nkind (N) in N_Entity);
5879          To_Flag_Word4_Ptr
5880            (Union_Id_Ptr'
5881              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag196 := Val;
5882       end Set_Flag196;
5883
5884       procedure Set_Flag197 (N : Node_Id; Val : Boolean) is
5885       begin
5886          pragma Assert (Nkind (N) in N_Entity);
5887          To_Flag_Word4_Ptr
5888            (Union_Id_Ptr'
5889              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag197 := Val;
5890       end Set_Flag197;
5891
5892       procedure Set_Flag198 (N : Node_Id; Val : Boolean) is
5893       begin
5894          pragma Assert (Nkind (N) in N_Entity);
5895          To_Flag_Word4_Ptr
5896            (Union_Id_Ptr'
5897              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag198 := Val;
5898       end Set_Flag198;
5899
5900       procedure Set_Flag199 (N : Node_Id; Val : Boolean) is
5901       begin
5902          pragma Assert (Nkind (N) in N_Entity);
5903          To_Flag_Word4_Ptr
5904            (Union_Id_Ptr'
5905              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag199 := Val;
5906       end Set_Flag199;
5907
5908       procedure Set_Flag200 (N : Node_Id; Val : Boolean) is
5909       begin
5910          pragma Assert (Nkind (N) in N_Entity);
5911          To_Flag_Word4_Ptr
5912            (Union_Id_Ptr'
5913              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag200 := Val;
5914       end Set_Flag200;
5915
5916       procedure Set_Flag201 (N : Node_Id; Val : Boolean) is
5917       begin
5918          pragma Assert (Nkind (N) in N_Entity);
5919          To_Flag_Word4_Ptr
5920            (Union_Id_Ptr'
5921              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag201 := Val;
5922       end Set_Flag201;
5923
5924       procedure Set_Flag202 (N : Node_Id; Val : Boolean) is
5925       begin
5926          pragma Assert (Nkind (N) in N_Entity);
5927          To_Flag_Word4_Ptr
5928            (Union_Id_Ptr'
5929              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag202 := Val;
5930       end Set_Flag202;
5931
5932       procedure Set_Flag203 (N : Node_Id; Val : Boolean) is
5933       begin
5934          pragma Assert (Nkind (N) in N_Entity);
5935          To_Flag_Word4_Ptr
5936            (Union_Id_Ptr'
5937              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag203 := Val;
5938       end Set_Flag203;
5939
5940       procedure Set_Flag204 (N : Node_Id; Val : Boolean) is
5941       begin
5942          pragma Assert (Nkind (N) in N_Entity);
5943          To_Flag_Word4_Ptr
5944            (Union_Id_Ptr'
5945              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag204 := Val;
5946       end Set_Flag204;
5947
5948       procedure Set_Flag205 (N : Node_Id; Val : Boolean) is
5949       begin
5950          pragma Assert (Nkind (N) in N_Entity);
5951          To_Flag_Word4_Ptr
5952            (Union_Id_Ptr'
5953              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag205 := Val;
5954       end Set_Flag205;
5955
5956       procedure Set_Flag206 (N : Node_Id; Val : Boolean) is
5957       begin
5958          pragma Assert (Nkind (N) in N_Entity);
5959          To_Flag_Word4_Ptr
5960            (Union_Id_Ptr'
5961              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag206 := Val;
5962       end Set_Flag206;
5963
5964       procedure Set_Flag207 (N : Node_Id; Val : Boolean) is
5965       begin
5966          pragma Assert (Nkind (N) in N_Entity);
5967          To_Flag_Word4_Ptr
5968            (Union_Id_Ptr'
5969              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag207 := Val;
5970       end Set_Flag207;
5971
5972       procedure Set_Flag208 (N : Node_Id; Val : Boolean) is
5973       begin
5974          pragma Assert (Nkind (N) in N_Entity);
5975          To_Flag_Word4_Ptr
5976            (Union_Id_Ptr'
5977              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag208 := Val;
5978       end Set_Flag208;
5979
5980       procedure Set_Flag209 (N : Node_Id; Val : Boolean) is
5981       begin
5982          pragma Assert (Nkind (N) in N_Entity);
5983          To_Flag_Word4_Ptr
5984            (Union_Id_Ptr'
5985              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag209 := Val;
5986       end Set_Flag209;
5987
5988       procedure Set_Flag210 (N : Node_Id; Val : Boolean) is
5989       begin
5990          pragma Assert (Nkind (N) in N_Entity);
5991          To_Flag_Word4_Ptr
5992            (Union_Id_Ptr'
5993              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag210 := Val;
5994       end Set_Flag210;
5995
5996       procedure Set_Flag211 (N : Node_Id; Val : Boolean) is
5997       begin
5998          pragma Assert (Nkind (N) in N_Entity);
5999          To_Flag_Word4_Ptr
6000            (Union_Id_Ptr'
6001              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag211 := Val;
6002       end Set_Flag211;
6003
6004       procedure Set_Flag212 (N : Node_Id; Val : Boolean) is
6005       begin
6006          pragma Assert (Nkind (N) in N_Entity);
6007          To_Flag_Word4_Ptr
6008            (Union_Id_Ptr'
6009              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag212 := Val;
6010       end Set_Flag212;
6011
6012       procedure Set_Flag213 (N : Node_Id; Val : Boolean) is
6013       begin
6014          pragma Assert (Nkind (N) in N_Entity);
6015          To_Flag_Word4_Ptr
6016            (Union_Id_Ptr'
6017              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag213 := Val;
6018       end Set_Flag213;
6019
6020       procedure Set_Flag214 (N : Node_Id; Val : Boolean) is
6021       begin
6022          pragma Assert (Nkind (N) in N_Entity);
6023          To_Flag_Word4_Ptr
6024            (Union_Id_Ptr'
6025              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag214 := Val;
6026       end Set_Flag214;
6027
6028       procedure Set_Flag215 (N : Node_Id; Val : Boolean) is
6029       begin
6030          pragma Assert (Nkind (N) in N_Entity);
6031          To_Flag_Word4_Ptr
6032            (Union_Id_Ptr'
6033              (Nodes.Table (N + 4).Field11'Unrestricted_Access)).Flag215 := Val;
6034       end Set_Flag215;
6035
6036       procedure Set_Flag216 (N : Node_Id; Val : Boolean) is
6037       begin
6038          pragma Assert (Nkind (N) in N_Entity);
6039          To_Flag_Word5_Ptr
6040            (Union_Id_Ptr'
6041              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag216 := Val;
6042       end Set_Flag216;
6043
6044       procedure Set_Flag217 (N : Node_Id; Val : Boolean) is
6045       begin
6046          pragma Assert (Nkind (N) in N_Entity);
6047          To_Flag_Word5_Ptr
6048            (Union_Id_Ptr'
6049              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag217 := Val;
6050       end Set_Flag217;
6051
6052       procedure Set_Flag218 (N : Node_Id; Val : Boolean) is
6053       begin
6054          pragma Assert (Nkind (N) in N_Entity);
6055          To_Flag_Word5_Ptr
6056            (Union_Id_Ptr'
6057              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag218 := Val;
6058       end Set_Flag218;
6059
6060       procedure Set_Flag219 (N : Node_Id; Val : Boolean) is
6061       begin
6062          pragma Assert (Nkind (N) in N_Entity);
6063          To_Flag_Word5_Ptr
6064            (Union_Id_Ptr'
6065              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag219 := Val;
6066       end Set_Flag219;
6067
6068       procedure Set_Flag220 (N : Node_Id; Val : Boolean) is
6069       begin
6070          pragma Assert (Nkind (N) in N_Entity);
6071          To_Flag_Word5_Ptr
6072            (Union_Id_Ptr'
6073              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag220 := Val;
6074       end Set_Flag220;
6075
6076       procedure Set_Flag221 (N : Node_Id; Val : Boolean) is
6077       begin
6078          pragma Assert (Nkind (N) in N_Entity);
6079          To_Flag_Word5_Ptr
6080            (Union_Id_Ptr'
6081              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag221 := Val;
6082       end Set_Flag221;
6083
6084       procedure Set_Flag222 (N : Node_Id; Val : Boolean) is
6085       begin
6086          pragma Assert (Nkind (N) in N_Entity);
6087          To_Flag_Word5_Ptr
6088            (Union_Id_Ptr'
6089              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag222 := Val;
6090       end Set_Flag222;
6091
6092       procedure Set_Flag223 (N : Node_Id; Val : Boolean) is
6093       begin
6094          pragma Assert (Nkind (N) in N_Entity);
6095          To_Flag_Word5_Ptr
6096            (Union_Id_Ptr'
6097              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag223 := Val;
6098       end Set_Flag223;
6099
6100       procedure Set_Flag224 (N : Node_Id; Val : Boolean) is
6101       begin
6102          pragma Assert (Nkind (N) in N_Entity);
6103          To_Flag_Word5_Ptr
6104            (Union_Id_Ptr'
6105              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag224 := Val;
6106       end Set_Flag224;
6107
6108       procedure Set_Flag225 (N : Node_Id; Val : Boolean) is
6109       begin
6110          pragma Assert (Nkind (N) in N_Entity);
6111          To_Flag_Word5_Ptr
6112            (Union_Id_Ptr'
6113              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag225 := Val;
6114       end Set_Flag225;
6115
6116       procedure Set_Flag226 (N : Node_Id; Val : Boolean) is
6117       begin
6118          pragma Assert (Nkind (N) in N_Entity);
6119          To_Flag_Word5_Ptr
6120            (Union_Id_Ptr'
6121              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag226 := Val;
6122       end Set_Flag226;
6123
6124       procedure Set_Flag227 (N : Node_Id; Val : Boolean) is
6125       begin
6126          pragma Assert (Nkind (N) in N_Entity);
6127          To_Flag_Word5_Ptr
6128            (Union_Id_Ptr'
6129              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag227 := Val;
6130       end Set_Flag227;
6131
6132       procedure Set_Flag228 (N : Node_Id; Val : Boolean) is
6133       begin
6134          pragma Assert (Nkind (N) in N_Entity);
6135          To_Flag_Word5_Ptr
6136            (Union_Id_Ptr'
6137              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag228 := Val;
6138       end Set_Flag228;
6139
6140       procedure Set_Flag229 (N : Node_Id; Val : Boolean) is
6141       begin
6142          pragma Assert (Nkind (N) in N_Entity);
6143          To_Flag_Word5_Ptr
6144            (Union_Id_Ptr'
6145              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag229 := Val;
6146       end Set_Flag229;
6147
6148       procedure Set_Flag230 (N : Node_Id; Val : Boolean) is
6149       begin
6150          pragma Assert (Nkind (N) in N_Entity);
6151          To_Flag_Word5_Ptr
6152            (Union_Id_Ptr'
6153              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag230 := Val;
6154       end Set_Flag230;
6155
6156       procedure Set_Flag231 (N : Node_Id; Val : Boolean) is
6157       begin
6158          pragma Assert (Nkind (N) in N_Entity);
6159          To_Flag_Word5_Ptr
6160            (Union_Id_Ptr'
6161              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag231 := Val;
6162       end Set_Flag231;
6163
6164       procedure Set_Flag232 (N : Node_Id; Val : Boolean) is
6165       begin
6166          pragma Assert (Nkind (N) in N_Entity);
6167          To_Flag_Word5_Ptr
6168            (Union_Id_Ptr'
6169              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag232 := Val;
6170       end Set_Flag232;
6171
6172       procedure Set_Flag233 (N : Node_Id; Val : Boolean) is
6173       begin
6174          pragma Assert (Nkind (N) in N_Entity);
6175          To_Flag_Word5_Ptr
6176            (Union_Id_Ptr'
6177              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag233 := Val;
6178       end Set_Flag233;
6179
6180       procedure Set_Flag234 (N : Node_Id; Val : Boolean) is
6181       begin
6182          pragma Assert (Nkind (N) in N_Entity);
6183          To_Flag_Word5_Ptr
6184            (Union_Id_Ptr'
6185              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag234 := Val;
6186       end Set_Flag234;
6187
6188       procedure Set_Flag235 (N : Node_Id; Val : Boolean) is
6189       begin
6190          pragma Assert (Nkind (N) in N_Entity);
6191          To_Flag_Word5_Ptr
6192            (Union_Id_Ptr'
6193              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag235 := Val;
6194       end Set_Flag235;
6195
6196       procedure Set_Flag236 (N : Node_Id; Val : Boolean) is
6197       begin
6198          pragma Assert (Nkind (N) in N_Entity);
6199          To_Flag_Word5_Ptr
6200            (Union_Id_Ptr'
6201              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag236 := Val;
6202       end Set_Flag236;
6203
6204       procedure Set_Flag237 (N : Node_Id; Val : Boolean) is
6205       begin
6206          pragma Assert (Nkind (N) in N_Entity);
6207          To_Flag_Word5_Ptr
6208            (Union_Id_Ptr'
6209              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag237 := Val;
6210       end Set_Flag237;
6211
6212       procedure Set_Flag238 (N : Node_Id; Val : Boolean) is
6213       begin
6214          pragma Assert (Nkind (N) in N_Entity);
6215          To_Flag_Word5_Ptr
6216            (Union_Id_Ptr'
6217              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag238 := Val;
6218       end Set_Flag238;
6219
6220       procedure Set_Flag239 (N : Node_Id; Val : Boolean) is
6221       begin
6222          pragma Assert (Nkind (N) in N_Entity);
6223          To_Flag_Word5_Ptr
6224            (Union_Id_Ptr'
6225              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag239 := Val;
6226       end Set_Flag239;
6227
6228       procedure Set_Flag240 (N : Node_Id; Val : Boolean) is
6229       begin
6230          pragma Assert (Nkind (N) in N_Entity);
6231          To_Flag_Word5_Ptr
6232            (Union_Id_Ptr'
6233              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag240 := Val;
6234       end Set_Flag240;
6235
6236       procedure Set_Flag241 (N : Node_Id; Val : Boolean) is
6237       begin
6238          pragma Assert (Nkind (N) in N_Entity);
6239          To_Flag_Word5_Ptr
6240            (Union_Id_Ptr'
6241              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag241 := Val;
6242       end Set_Flag241;
6243
6244       procedure Set_Flag242 (N : Node_Id; Val : Boolean) is
6245       begin
6246          pragma Assert (Nkind (N) in N_Entity);
6247          To_Flag_Word5_Ptr
6248            (Union_Id_Ptr'
6249              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag242 := Val;
6250       end Set_Flag242;
6251
6252       procedure Set_Flag243 (N : Node_Id; Val : Boolean) is
6253       begin
6254          pragma Assert (Nkind (N) in N_Entity);
6255          To_Flag_Word5_Ptr
6256            (Union_Id_Ptr'
6257              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag243 := Val;
6258       end Set_Flag243;
6259
6260       procedure Set_Flag244 (N : Node_Id; Val : Boolean) is
6261       begin
6262          pragma Assert (Nkind (N) in N_Entity);
6263          To_Flag_Word5_Ptr
6264            (Union_Id_Ptr'
6265              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag244 := Val;
6266       end Set_Flag244;
6267
6268       procedure Set_Flag245 (N : Node_Id; Val : Boolean) is
6269       begin
6270          pragma Assert (Nkind (N) in N_Entity);
6271          To_Flag_Word5_Ptr
6272            (Union_Id_Ptr'
6273              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag245 := Val;
6274       end Set_Flag245;
6275
6276       procedure Set_Flag246 (N : Node_Id; Val : Boolean) is
6277       begin
6278          pragma Assert (Nkind (N) in N_Entity);
6279          To_Flag_Word5_Ptr
6280            (Union_Id_Ptr'
6281              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag246 := Val;
6282       end Set_Flag246;
6283
6284       procedure Set_Flag247 (N : Node_Id; Val : Boolean) is
6285       begin
6286          pragma Assert (Nkind (N) in N_Entity);
6287          To_Flag_Word5_Ptr
6288            (Union_Id_Ptr'
6289              (Nodes.Table (N + 4).Field12'Unrestricted_Access)).Flag247 := Val;
6290       end Set_Flag247;
6291
6292       procedure Set_Node1_With_Parent (N : Node_Id; Val : Node_Id) is
6293       begin
6294          pragma Assert (N <= Nodes.Last);
6295
6296          if Val > Error then
6297             Set_Parent (N => Val, Val => N);
6298          end if;
6299
6300          Set_Node1 (N, Val);
6301       end Set_Node1_With_Parent;
6302
6303       procedure Set_Node2_With_Parent (N : Node_Id; Val : Node_Id) is
6304       begin
6305          pragma Assert (N <= Nodes.Last);
6306
6307          if Val > Error then
6308             Set_Parent (N => Val, Val => N);
6309          end if;
6310
6311          Set_Node2 (N, Val);
6312       end Set_Node2_With_Parent;
6313
6314       procedure Set_Node3_With_Parent (N : Node_Id; Val : Node_Id) is
6315       begin
6316          pragma Assert (N <= Nodes.Last);
6317
6318          if Val > Error then
6319             Set_Parent (N => Val, Val => N);
6320          end if;
6321
6322          Set_Node3 (N, Val);
6323       end Set_Node3_With_Parent;
6324
6325       procedure Set_Node4_With_Parent (N : Node_Id; Val : Node_Id) is
6326       begin
6327          pragma Assert (N <= Nodes.Last);
6328
6329          if Val > Error then
6330             Set_Parent (N => Val, Val => N);
6331          end if;
6332
6333          Set_Node4 (N, Val);
6334       end Set_Node4_With_Parent;
6335
6336       procedure Set_Node5_With_Parent (N : Node_Id; Val : Node_Id) is
6337       begin
6338          pragma Assert (N <= Nodes.Last);
6339
6340          if Val > Error then
6341             Set_Parent (N => Val, Val => N);
6342          end if;
6343
6344          Set_Node5 (N, Val);
6345       end Set_Node5_With_Parent;
6346
6347       procedure Set_List1_With_Parent (N : Node_Id; Val : List_Id) is
6348       begin
6349          pragma Assert (N <= Nodes.Last);
6350          if Val /= No_List and then Val /= Error_List then
6351             Set_Parent (Val, N);
6352          end if;
6353          Set_List1 (N, Val);
6354       end Set_List1_With_Parent;
6355
6356       procedure Set_List2_With_Parent (N : Node_Id; Val : List_Id) is
6357       begin
6358          pragma Assert (N <= Nodes.Last);
6359          if Val /= No_List and then Val /= Error_List then
6360             Set_Parent (Val, N);
6361          end if;
6362          Set_List2 (N, Val);
6363       end Set_List2_With_Parent;
6364
6365       procedure Set_List3_With_Parent (N : Node_Id; Val : List_Id) is
6366       begin
6367          pragma Assert (N <= Nodes.Last);
6368          if Val /= No_List and then Val /= Error_List then
6369             Set_Parent (Val, N);
6370          end if;
6371          Set_List3 (N, Val);
6372       end Set_List3_With_Parent;
6373
6374       procedure Set_List4_With_Parent (N : Node_Id; Val : List_Id) is
6375       begin
6376          pragma Assert (N <= Nodes.Last);
6377          if Val /= No_List and then Val /= Error_List then
6378             Set_Parent (Val, N);
6379          end if;
6380          Set_List4 (N, Val);
6381       end Set_List4_With_Parent;
6382
6383       procedure Set_List5_With_Parent (N : Node_Id; Val : List_Id) is
6384       begin
6385          pragma Assert (N <= Nodes.Last);
6386          if Val /= No_List and then Val /= Error_List then
6387             Set_Parent (Val, N);
6388          end if;
6389          Set_List5 (N, Val);
6390       end Set_List5_With_Parent;
6391
6392    end Unchecked_Access;
6393
6394    ------------
6395    -- Unlock --
6396    ------------
6397
6398    procedure Unlock is
6399    begin
6400       Nodes.Locked := False;
6401       Orig_Nodes.Locked := False;
6402    end Unlock;
6403
6404 end Atree;