gcc/ada/atree.adb

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