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