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