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