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