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