gcc/ada/atree.adb

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