gcc/ada/sem_aux.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                              S E M _ A U X                               --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --          Copyright (C) 1992-2009, Free Software Foundation, Inc.         --
  10 --                                                                          --
  11 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  12 -- terms of the  GNU General Public License as published  by the Free Soft- --
  13 -- ware  Foundation;  either version 3,  or (at your option) any later ver- --
  14 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  15 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  16 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  17 -- for  more details.  You should have  received  a copy of the GNU General --
  18 -- Public License  distributed with GNAT; see file COPYING3.  If not, go to --
  19 -- http://www.gnu.org/licenses for a complete copy of the license.          --
  20 --                                                                          --
  21 -- As a special exception,  if other files  instantiate  generics from this --
  22 -- unit, or you link  this unit with other files  to produce an executable, --
  23 -- this  unit  does not  by itself cause  the resulting  executable  to  be --
  24 -- covered  by the  GNU  General  Public  License.  This exception does not --
  25 -- however invalidate  any other reasons why  the executable file  might be --
  26 -- covered by the  GNU Public License.                                      --
  27 --                                                                          --
  28 -- GNAT was originally developed  by the GNAT team at  New York University. --
  29 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  30 --                                                                          --
  31 ------------------------------------------------------------------------------
  32
  33 with Atree;  use Atree;
  34 with Einfo;  use Einfo;
  35 with Namet;  use Namet;
  36 with Sinfo;  use Sinfo;
  37 with Snames; use Snames;
  38 with Stand;  use Stand;
  39
  40 package body Sem_Aux is
  41
  42    ----------------------
  43    -- Ancestor_Subtype --
  44    ----------------------
  45
  46    function Ancestor_Subtype (Typ : Entity_Id) return Entity_Id is
  47    begin
  48       --  If this is first subtype, or is a base type, then there is no
  49       --  ancestor subtype, so we return Empty to indicate this fact.
  50
  51       if Is_First_Subtype (Typ) or else Typ = Base_Type (Typ) then
  52          return Empty;
  53       end if;
  54
  55       declare
  56          D : constant Node_Id := Declaration_Node (Typ);
  57
  58       begin
  59          --  If we have a subtype declaration, get the ancestor subtype
  60
  61          if Nkind (D) = N_Subtype_Declaration then
  62             if Nkind (Subtype_Indication (D)) = N_Subtype_Indication then
  63                return Entity (Subtype_Mark (Subtype_Indication (D)));
  64             else
  65                return Entity (Subtype_Indication (D));
  66             end if;
  67
  68          --  If not, then no subtype indication is available
  69
  70          else
  71             return Empty;
  72          end if;
  73       end;
  74    end Ancestor_Subtype;
  75
  76    --------------------
  77    -- Available_View --
  78    --------------------
  79
  80    function Available_View (Typ : Entity_Id) return Entity_Id is
  81    begin
  82       if Is_Incomplete_Type (Typ)
  83         and then Present (Non_Limited_View (Typ))
  84       then
  85          --  The non-limited view may itself be an incomplete type, in which
  86          --  case get its full view.
  87
  88          return Get_Full_View (Non_Limited_View (Typ));
  89
  90       elsif Is_Class_Wide_Type (Typ)
  91         and then Is_Incomplete_Type (Etype (Typ))
  92         and then Present (Non_Limited_View (Etype (Typ)))
  93       then
  94          return Class_Wide_Type (Non_Limited_View (Etype (Typ)));
  95
  96       else
  97          return Typ;
  98       end if;
  99    end Available_View;
 100
 101    --------------------
 102    -- Constant_Value --
 103    --------------------
 104
 105    function Constant_Value (Ent : Entity_Id) return Node_Id is
 106       D      : constant Node_Id := Declaration_Node (Ent);
 107       Full_D : Node_Id;
 108
 109    begin
 110       --  If we have no declaration node, then return no constant value. Not
 111       --  clear how this can happen, but it does sometimes and this is the
 112       --  safest approach.
 113
 114       if No (D) then
 115          return Empty;
 116
 117       --  Normal case where a declaration node is present
 118
 119       elsif Nkind (D) = N_Object_Renaming_Declaration then
 120          return Renamed_Object (Ent);
 121
 122       --  If this is a component declaration whose entity is a constant, it is
 123       --  a prival within a protected function (and so has no constant value).
 124
 125       elsif Nkind (D) = N_Component_Declaration then
 126          return Empty;
 127
 128       --  If there is an expression, return it
 129
 130       elsif Present (Expression (D)) then
 131          return (Expression (D));
 132
 133       --  For a constant, see if we have a full view
 134
 135       elsif Ekind (Ent) = E_Constant
 136         and then Present (Full_View (Ent))
 137       then
 138          Full_D := Parent (Full_View (Ent));
 139
 140          --  The full view may have been rewritten as an object renaming
 141
 142          if Nkind (Full_D) = N_Object_Renaming_Declaration then
 143             return Name (Full_D);
 144          else
 145             return Expression (Full_D);
 146          end if;
 147
 148       --  Otherwise we have no expression to return
 149
 150       else
 151          return Empty;
 152       end if;
 153    end Constant_Value;
 154
 155    -----------------------------
 156    -- Enclosing_Dynamic_Scope --
 157    -----------------------------
 158
 159    function Enclosing_Dynamic_Scope (Ent : Entity_Id) return Entity_Id is
 160       S : Entity_Id;
 161
 162    begin
 163       --  The following test is an error defense against some syntax errors
 164       --  that can leave scopes very messed up.
 165
 166       if Ent = Standard_Standard then
 167          return Ent;
 168       end if;
 169
 170       --  Normal case, search enclosing scopes
 171
 172       --  Note: the test for Present (S) should not be required, it defends
 173       --  against an ill-formed tree.
 174
 175       S := Scope (Ent);
 176       loop
 177          --  If we somehow got an empty value for Scope, the tree must be
 178          --  malformed. Rather than blow up we return Standard in this case.
 179
 180          if No (S) then
 181             return Standard_Standard;
 182
 183          --  Quit if we get to standard or a dynamic scope
 184
 185          elsif S = Standard_Standard
 186            or else Is_Dynamic_Scope (S)
 187          then
 188             return S;
 189
 190          --  Otherwise keep climbing
 191
 192          else
 193             S := Scope (S);
 194          end if;
 195       end loop;
 196    end Enclosing_Dynamic_Scope;
 197
 198    ------------------------
 199    -- First_Discriminant --
 200    ------------------------
 201
 202    function First_Discriminant (Typ : Entity_Id) return Entity_Id is
 203       Ent : Entity_Id;
 204
 205    begin
 206       pragma Assert
 207         (Has_Discriminants (Typ)
 208           or else Has_Unknown_Discriminants (Typ));
 209
 210       Ent := First_Entity (Typ);
 211
 212       --  The discriminants are not necessarily contiguous, because access
 213       --  discriminants will generate itypes. They are not the first entities
 214       --  either, because tag and controller record must be ahead of them.
 215
 216       if Chars (Ent) = Name_uTag then
 217          Ent := Next_Entity (Ent);
 218       end if;
 219
 220       if Chars (Ent) = Name_uController then
 221          Ent := Next_Entity (Ent);
 222       end if;
 223
 224       --  Skip all hidden stored discriminants if any
 225
 226       while Present (Ent) loop
 227          exit when Ekind (Ent) = E_Discriminant
 228            and then not Is_Completely_Hidden (Ent);
 229
 230          Ent := Next_Entity (Ent);
 231       end loop;
 232
 233       pragma Assert (Ekind (Ent) = E_Discriminant);
 234
 235       return Ent;
 236    end First_Discriminant;
 237
 238    -------------------------------
 239    -- First_Stored_Discriminant --
 240    -------------------------------
 241
 242    function First_Stored_Discriminant (Typ : Entity_Id) return Entity_Id is
 243       Ent : Entity_Id;
 244
 245       function Has_Completely_Hidden_Discriminant
 246         (Typ : Entity_Id) return Boolean;
 247       --  Scans the Discriminants to see whether any are Completely_Hidden
 248       --  (the mechanism for describing non-specified stored discriminants)
 249
 250       ----------------------------------------
 251       -- Has_Completely_Hidden_Discriminant --
 252       ----------------------------------------
 253
 254       function Has_Completely_Hidden_Discriminant
 255         (Typ : Entity_Id) return Boolean
 256       is
 257          Ent : Entity_Id;
 258
 259       begin
 260          pragma Assert (Ekind (Typ) = E_Discriminant);
 261
 262          Ent := Typ;
 263          while Present (Ent) and then Ekind (Ent) = E_Discriminant loop
 264             if Is_Completely_Hidden (Ent) then
 265                return True;
 266             end if;
 267
 268             Ent := Next_Entity (Ent);
 269          end loop;
 270
 271          return False;
 272       end Has_Completely_Hidden_Discriminant;
 273
 274    --  Start of processing for First_Stored_Discriminant
 275
 276    begin
 277       pragma Assert
 278         (Has_Discriminants (Typ)
 279           or else Has_Unknown_Discriminants (Typ));
 280
 281       Ent := First_Entity (Typ);
 282
 283       if Chars (Ent) = Name_uTag then
 284          Ent := Next_Entity (Ent);
 285       end if;
 286
 287       if Chars (Ent) = Name_uController then
 288          Ent := Next_Entity (Ent);
 289       end if;
 290
 291       if Has_Completely_Hidden_Discriminant (Ent) then
 292
 293          while Present (Ent) loop
 294             exit when Is_Completely_Hidden (Ent);
 295             Ent := Next_Entity (Ent);
 296          end loop;
 297
 298       end if;
 299
 300       pragma Assert (Ekind (Ent) = E_Discriminant);
 301
 302       return Ent;
 303    end First_Stored_Discriminant;
 304
 305    -------------------
 306    -- First_Subtype --
 307    -------------------
 308
 309    function First_Subtype (Typ : Entity_Id) return Entity_Id is
 310       B   : constant Entity_Id := Base_Type (Typ);
 311       F   : constant Node_Id   := Freeze_Node (B);
 312       Ent : Entity_Id;
 313
 314    begin
 315       --  If the base type has no freeze node, it is a type in standard,
 316       --  and always acts as its own first subtype unless it is one of the
 317       --  predefined integer types. If the type is formal, it is also a first
 318       --  subtype, and its base type has no freeze node. On the other hand, a
 319       --  subtype of a generic formal is not its own first_subtype. Its base
 320       --  type, if anonymous, is attached to the formal type decl. from which
 321       --  the first subtype is obtained.
 322
 323       if No (F) then
 324
 325          if B = Base_Type (Standard_Integer) then
 326             return Standard_Integer;
 327
 328          elsif B = Base_Type (Standard_Long_Integer) then
 329             return Standard_Long_Integer;
 330
 331          elsif B = Base_Type (Standard_Short_Short_Integer) then
 332             return Standard_Short_Short_Integer;
 333
 334          elsif B = Base_Type (Standard_Short_Integer) then
 335             return Standard_Short_Integer;
 336
 337          elsif B = Base_Type (Standard_Long_Long_Integer) then
 338             return Standard_Long_Long_Integer;
 339
 340          elsif Is_Generic_Type (Typ) then
 341             if Present (Parent (B)) then
 342                return Defining_Identifier (Parent (B));
 343             else
 344                return Defining_Identifier (Associated_Node_For_Itype (B));
 345             end if;
 346
 347          else
 348             return B;
 349          end if;
 350
 351       --  Otherwise we check the freeze node, if it has a First_Subtype_Link
 352       --  then we use that link, otherwise (happens with some Itypes), we use
 353       --  the base type itself.
 354
 355       else
 356          Ent := First_Subtype_Link (F);
 357
 358          if Present (Ent) then
 359             return Ent;
 360          else
 361             return B;
 362          end if;
 363       end if;
 364    end First_Subtype;
 365
 366    -------------------------
 367    -- First_Tag_Component --
 368    -------------------------
 369
 370    function First_Tag_Component (Typ : Entity_Id) return Entity_Id is
 371       Comp : Entity_Id;
 372       Ctyp : Entity_Id;
 373
 374    begin
 375       Ctyp := Typ;
 376       pragma Assert (Is_Tagged_Type (Ctyp));
 377
 378       if Is_Class_Wide_Type (Ctyp) then
 379          Ctyp := Root_Type (Ctyp);
 380       end if;
 381
 382       if Is_Private_Type (Ctyp) then
 383          Ctyp := Underlying_Type (Ctyp);
 384
 385          --  If the underlying type is missing then the source program has
 386          --  errors and there is nothing else to do (the full-type declaration
 387          --  associated with the private type declaration is missing).
 388
 389          if No (Ctyp) then
 390             return Empty;
 391          end if;
 392       end if;
 393
 394       Comp := First_Entity (Ctyp);
 395       while Present (Comp) loop
 396          if Is_Tag (Comp) then
 397             return Comp;
 398          end if;
 399
 400          Comp := Next_Entity (Comp);
 401       end loop;
 402
 403       --  No tag component found
 404
 405       return Empty;
 406    end First_Tag_Component;
 407
 408    ----------------
 409    -- Initialize --
 410    ----------------
 411
 412    procedure Initialize is
 413    begin
 414       Obsolescent_Warnings.Init;
 415    end Initialize;
 416
 417    ---------------------
 418    -- Is_By_Copy_Type --
 419    ---------------------
 420
 421    function Is_By_Copy_Type (Ent : Entity_Id) return Boolean is
 422    begin
 423       --  If Id is a private type whose full declaration has not been seen,
 424       --  we assume for now that it is not a By_Copy type. Clearly this
 425       --  attribute should not be used before the type is frozen, but it is
 426       --  needed to build the associated record of a protected type. Another
 427       --  place where some lookahead for a full view is needed ???
 428
 429       return
 430         Is_Elementary_Type (Ent)
 431           or else (Is_Private_Type (Ent)
 432                      and then Present (Underlying_Type (Ent))
 433                      and then Is_Elementary_Type (Underlying_Type (Ent)));
 434    end Is_By_Copy_Type;
 435
 436    --------------------------
 437    -- Is_By_Reference_Type --
 438    --------------------------
 439
 440    function Is_By_Reference_Type (Ent : Entity_Id) return Boolean is
 441       Btype : constant Entity_Id := Base_Type (Ent);
 442
 443    begin
 444       if Error_Posted (Ent)
 445         or else Error_Posted (Btype)
 446       then
 447          return False;
 448
 449       elsif Is_Private_Type (Btype) then
 450          declare
 451             Utyp : constant Entity_Id := Underlying_Type (Btype);
 452          begin
 453             if No (Utyp) then
 454                return False;
 455             else
 456                return Is_By_Reference_Type (Utyp);
 457             end if;
 458          end;
 459
 460       elsif Is_Incomplete_Type (Btype) then
 461          declare
 462             Ftyp : constant Entity_Id := Full_View (Btype);
 463          begin
 464             if No (Ftyp) then
 465                return False;
 466             else
 467                return Is_By_Reference_Type (Ftyp);
 468             end if;
 469          end;
 470
 471       elsif Is_Concurrent_Type (Btype) then
 472          return True;
 473
 474       elsif Is_Record_Type (Btype) then
 475          if Is_Limited_Record (Btype)
 476            or else Is_Tagged_Type (Btype)
 477            or else Is_Volatile (Btype)
 478          then
 479             return True;
 480
 481          else
 482             declare
 483                C : Entity_Id;
 484
 485             begin
 486                C := First_Component (Btype);
 487                while Present (C) loop
 488                   if Is_By_Reference_Type (Etype (C))
 489                     or else Is_Volatile (Etype (C))
 490                   then
 491                      return True;
 492                   end if;
 493
 494                   C := Next_Component (C);
 495                end loop;
 496             end;
 497
 498             return False;
 499          end if;
 500
 501       elsif Is_Array_Type (Btype) then
 502          return
 503            Is_Volatile (Btype)
 504              or else Is_By_Reference_Type (Component_Type (Btype))
 505              or else Is_Volatile (Component_Type (Btype))
 506              or else Has_Volatile_Components (Btype);
 507
 508       else
 509          return False;
 510       end if;
 511    end Is_By_Reference_Type;
 512
 513    ---------------------
 514    -- Is_Derived_Type --
 515    ---------------------
 516
 517    function Is_Derived_Type (Ent : E) return B is
 518       Par : Node_Id;
 519
 520    begin
 521       if Is_Type (Ent)
 522         and then Base_Type (Ent) /= Root_Type (Ent)
 523         and then not Is_Class_Wide_Type (Ent)
 524       then
 525          if not Is_Numeric_Type (Root_Type (Ent)) then
 526             return True;
 527
 528          else
 529             Par := Parent (First_Subtype (Ent));
 530
 531             return Present (Par)
 532               and then Nkind (Par) = N_Full_Type_Declaration
 533               and then Nkind (Type_Definition (Par)) =
 534                          N_Derived_Type_Definition;
 535          end if;
 536
 537       else
 538          return False;
 539       end if;
 540    end Is_Derived_Type;
 541
 542    ---------------------------
 543    -- Is_Indefinite_Subtype --
 544    ---------------------------
 545
 546    function Is_Indefinite_Subtype (Ent : Entity_Id) return Boolean is
 547       K : constant Entity_Kind := Ekind (Ent);
 548
 549    begin
 550       if Is_Constrained (Ent) then
 551          return False;
 552
 553       elsif K in Array_Kind
 554         or else K in Class_Wide_Kind
 555         or else Has_Unknown_Discriminants (Ent)
 556       then
 557          return True;
 558
 559       --  Known discriminants: indefinite if there are no default values
 560
 561       elsif K in Record_Kind
 562         or else Is_Incomplete_Or_Private_Type (Ent)
 563         or else Is_Concurrent_Type (Ent)
 564       then
 565          return (Has_Discriminants (Ent)
 566            and then
 567              No (Discriminant_Default_Value (First_Discriminant (Ent))));
 568
 569       else
 570          return False;
 571       end if;
 572    end Is_Indefinite_Subtype;
 573
 574    --------------------------------
 575    -- Is_Inherently_Limited_Type --
 576    --------------------------------
 577
 578    function Is_Inherently_Limited_Type (Ent : Entity_Id) return Boolean is
 579       Btype : constant Entity_Id := Base_Type (Ent);
 580
 581    begin
 582       if Is_Private_Type (Btype) then
 583          declare
 584             Utyp : constant Entity_Id := Underlying_Type (Btype);
 585          begin
 586             if No (Utyp) then
 587                return False;
 588             else
 589                return Is_Inherently_Limited_Type (Utyp);
 590             end if;
 591          end;
 592
 593       elsif Is_Concurrent_Type (Btype) then
 594          return True;
 595
 596       elsif Is_Record_Type (Btype) then
 597
 598          --  Note that we return True for all limited interfaces, even though
 599          --  (unsynchronized) limited interfaces can have descendants that are
 600          --  nonlimited, because this is a predicate on the type itself, and
 601          --  things like functions with limited interface results need to be
 602          --  handled as build in place even though they might return objects
 603          --  of a type that is not inherently limited.
 604
 605          if Is_Limited_Record (Btype) then
 606             return True;
 607
 608          elsif Is_Class_Wide_Type (Btype) then
 609             return Is_Inherently_Limited_Type (Root_Type (Btype));
 610
 611          else
 612             declare
 613                C : Entity_Id;
 614
 615             begin
 616                C := First_Component (Btype);
 617                while Present (C) loop
 618
 619                   --  Don't consider components with interface types (which can
 620                   --  only occur in the case of a _parent component anyway).
 621                   --  They don't have any components, plus it would cause this
 622                   --  function to return true for nonlimited types derived from
 623                   --  limited intefaces.
 624
 625                   if not Is_Interface (Etype (C))
 626                     and then Is_Inherently_Limited_Type (Etype (C))
 627                   then
 628                      return True;
 629                   end if;
 630
 631                   C := Next_Component (C);
 632                end loop;
 633             end;
 634
 635             return False;
 636          end if;
 637
 638       elsif Is_Array_Type (Btype) then
 639          return Is_Inherently_Limited_Type (Component_Type (Btype));
 640
 641       else
 642          return False;
 643       end if;
 644    end Is_Inherently_Limited_Type;
 645
 646    ---------------------
 647    -- Is_Limited_Type --
 648    ---------------------
 649
 650    function Is_Limited_Type (Ent : Entity_Id) return Boolean is
 651       Btype : constant E := Base_Type (Ent);
 652       Rtype : constant E := Root_Type (Btype);
 653
 654    begin
 655       if not Is_Type (Ent) then
 656          return False;
 657
 658       elsif Ekind (Btype) = E_Limited_Private_Type
 659         or else Is_Limited_Composite (Btype)
 660       then
 661          return True;
 662
 663       elsif Is_Concurrent_Type (Btype) then
 664          return True;
 665
 666          --  The Is_Limited_Record flag normally indicates that the type is
 667          --  limited. The exception is that a type does not inherit limitedness
 668          --  from its interface ancestor. So the type may be derived from a
 669          --  limited interface, but is not limited.
 670
 671       elsif Is_Limited_Record (Ent)
 672         and then not Is_Interface (Ent)
 673       then
 674          return True;
 675
 676       --  Otherwise we will look around to see if there is some other reason
 677       --  for it to be limited, except that if an error was posted on the
 678       --  entity, then just assume it is non-limited, because it can cause
 679       --  trouble to recurse into a murky erroneous entity!
 680
 681       elsif Error_Posted (Ent) then
 682          return False;
 683
 684       elsif Is_Record_Type (Btype) then
 685
 686          if Is_Limited_Interface (Ent) then
 687             return True;
 688
 689          --  AI-419: limitedness is not inherited from a limited interface
 690
 691          elsif Is_Limited_Record (Rtype) then
 692             return not Is_Interface (Rtype)
 693               or else Is_Protected_Interface (Rtype)
 694               or else Is_Synchronized_Interface (Rtype)
 695               or else Is_Task_Interface (Rtype);
 696
 697          elsif Is_Class_Wide_Type (Btype) then
 698             return Is_Limited_Type (Rtype);
 699
 700          else
 701             declare
 702                C : E;
 703
 704             begin
 705                C := First_Component (Btype);
 706                while Present (C) loop
 707                   if Is_Limited_Type (Etype (C)) then
 708                      return True;
 709                   end if;
 710
 711                   C := Next_Component (C);
 712                end loop;
 713             end;
 714
 715             return False;
 716          end if;
 717
 718       elsif Is_Array_Type (Btype) then
 719          return Is_Limited_Type (Component_Type (Btype));
 720
 721       else
 722          return False;
 723       end if;
 724    end Is_Limited_Type;
 725
 726    ---------------------------
 727    -- Nearest_Dynamic_Scope --
 728    ---------------------------
 729
 730    function Nearest_Dynamic_Scope (Ent : Entity_Id) return Entity_Id is
 731    begin
 732       if Is_Dynamic_Scope (Ent) then
 733          return Ent;
 734       else
 735          return Enclosing_Dynamic_Scope (Ent);
 736       end if;
 737    end Nearest_Dynamic_Scope;
 738
 739    ------------------------
 740    -- Next_Tag_Component --
 741    ------------------------
 742
 743    function Next_Tag_Component (Tag : Entity_Id) return Entity_Id is
 744       Comp : Entity_Id;
 745
 746    begin
 747       pragma Assert (Is_Tag (Tag));
 748
 749       --  Loop to look for next tag component
 750
 751       Comp := Next_Entity (Tag);
 752       while Present (Comp) loop
 753          if Is_Tag (Comp) then
 754             pragma Assert (Chars (Comp) /= Name_uTag);
 755             return Comp;
 756          end if;
 757
 758          Comp := Next_Entity (Comp);
 759       end loop;
 760
 761       --  No tag component found
 762
 763       return Empty;
 764    end Next_Tag_Component;
 765
 766    --------------------------
 767    -- Number_Discriminants --
 768    --------------------------
 769
 770    function Number_Discriminants (Typ : Entity_Id) return Pos is
 771       N     : Int;
 772       Discr : Entity_Id;
 773
 774    begin
 775       N := 0;
 776       Discr := First_Discriminant (Typ);
 777       while Present (Discr) loop
 778          N := N + 1;
 779          Discr := Next_Discriminant (Discr);
 780       end loop;
 781
 782       return N;
 783    end Number_Discriminants;
 784
 785    ---------------
 786    -- Tree_Read --
 787    ---------------
 788
 789    procedure Tree_Read is
 790    begin
 791       Obsolescent_Warnings.Tree_Read;
 792    end Tree_Read;
 793
 794    ----------------
 795    -- Tree_Write --
 796    ----------------
 797
 798    procedure Tree_Write is
 799    begin
 800       Obsolescent_Warnings.Tree_Write;
 801    end Tree_Write;
 802
 803 end Sem_Aux;