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