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