gcc/ada/atree.adb

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