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