gcc/ada/atree.adb

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