gcc/ada/atree.adb

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