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