gcc/ada/atree.adb

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