home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gnat-2.06-src.tgz / tar.out / fsf / gnat / ada / sem_ch3.ads < prev    next >
Text File  |  1996-09-28  |  8KB  |  141 lines
  1. ------------------------------------------------------------------------------
  2. --                                                                          --
  3. --                         GNAT COMPILER COMPONENTS                         --
  4. --                                                                          --
  5. --                              S E M _ C H 3                               --
  6. --                                                                          --
  7. --                                 S p e c                                  --
  8. --                                                                          --
  9. --                            $Revision: 1.35 $                             --
  10. --                                                                          --
  11. --           Copyright (c) 1992,1993,1994 NYU, All Rights Reserved          --
  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, 675 Mass Ave, Cambridge, MA 02139, USA. --
  22. --                                                                          --
  23. ------------------------------------------------------------------------------
  24.  
  25. with Types; use Types;
  26.  
  27. package Sem_Ch3  is
  28.    procedure Analyze_Component_Declaration              (N : Node_Id);
  29.    procedure Analyze_Implicit_Types                     (N : Node_Id);
  30.    procedure Analyze_Number_Declaration                 (N : Node_Id);
  31.    procedure Analyze_Incomplete_Type_Decl               (N : Node_Id);
  32.    procedure Analyze_Object_Declaration                 (N : Node_Id);
  33.    procedure Analyze_Others_Choice                      (N : Node_Id);
  34.    procedure Analyze_Subtype_Declaration                (N : Node_Id);
  35.    procedure Analyze_Subtype_Indication                 (N : Node_Id);
  36.    procedure Analyze_Type_Declaration                   (N : Node_Id);
  37.    procedure Analyze_Variant_Part                       (N : Node_Id);
  38.    procedure Analyze_Private_Extension_Declaration      (N : Node_Id);
  39.  
  40.    function Access_Definition (
  41.      Related_Nod : Node_Id;
  42.      N           : Node_Id)
  43.      return        Entity_Id;
  44.    --  An access definition defines a general access type for a formal
  45.    --  parameter.  The procedure is called when processing formals, when
  46.    --  the current scope is the subprogram. The Implicit type is attached
  47.    --  to the Related_Nod put into the enclosing scope, so that the only
  48.    --  entities defined in the spec are the formals themselves.
  49.  
  50.    procedure Access_Subprogram_Declaration
  51.      (T_Name : Entity_Id;
  52.       T_Def  : Node_Id);
  53.    --  The subprogram specification yields the signature of an implicit
  54.    --  type, whose Ekind is Access_Subprogram_Type. This implicit type is
  55.    --  the designated type of the declared access type. In subprogram calls,
  56.    --  the signature of the implicit type works like the profile of a regular
  57.    --  subprogram.
  58.  
  59.    procedure Analyze_Declarations (L : List_Id);
  60.    --  Called to analyze a list of declarations (in what context ???). Also
  61.    --  performs necessary freezing actions (more description needed ???)
  62.  
  63.    procedure Analyze_Default_Expression (N : Node_Id; T : Entity_Id);
  64.    --  Default expressions do not freeze their components, and must be
  65.    --  analyzed and resolved accordingly, by setting the global flag
  66.    --  In_Default_Expression.
  67.  
  68.    procedure Array_Type_Declaration (T : in out Entity_Id; Def : Node_Id);
  69.    --  Process an array type declaration. If the array is constrained, we
  70.    --  create an implicit parent array type, with the same index types and
  71.    --  component type.
  72.  
  73.    procedure Access_Type_Declaration (T : Entity_Id; Def : Node_Id);
  74.    --  Process an access type declaration
  75.  
  76.    procedure Check_Completion (Body_Id : Node_Id := Empty);
  77.    --  At the end of a declarative part,  verify that all entities that
  78.    --  require completion have received one. If Body_Id is absent, the
  79.    --  error indicating a missing completion is placed on  the declaration
  80.    --  that needs completion. If Body_Id is present,  it is the defining
  81.    --  identifier of a package body, and errors are posted on that node,
  82.    --  rather than on the declarations that require completion in the package
  83.    --  declaration.
  84.  
  85.    function Collect_Primitive_Operations (T : Entity_Id) return Elist_Id;
  86.    --  Called upon type derivation and extension. We scan the declarative
  87.    --  part in  which the type appears, and collect subprograms that have
  88.    --  one subsidiary subtype of the type. These subprograms can only
  89.    --  appear after the type itself.
  90.  
  91.    procedure Determine_Enum_Representation (T : Entity_Id);
  92.    --  Determine the size in bits necessary to store enumeration literals
  93.    --  of type T. The sizes are rounded to 8, 16, 32 or 64 bit quantites.
  94.    --  The determination is based on the representation of the last literal,
  95.    --  and the resulting size is stored in the Esize field of T.
  96.  
  97.    function Find_Type_Name (N : Node_Id) return Entity_Id;
  98.    --  Enter the identifier in a type definition, or find the entity already
  99.    --  declared, in the case of the full declaration of an incomplete or
  100.    --  private type.
  101.  
  102.    function Is_Visible_Component (C : Entity_Id) return Boolean;
  103.    --  Determines if a component is visible in the present context.
  104.    --  it may be a component inherited from a private extension which
  105.    --  is not visible at this moment.
  106.  
  107.    procedure Make_Index
  108.      (I            : Node_Id;
  109.       Related_Nod  : Node_Id;
  110.       Related_Id   : Entity_Id := Empty;
  111.       Suffix_Index : Nat := 1);
  112.    --  Process an index that is given in an array declaration, an entry
  113.    --  family declaration or a loop iteration. The index is given by an
  114.    --  index declaration (a 'box'), or by a discrete range. The later can
  115.    --  be the name of a discrete type, or a subtype indication.
  116.    --  Related_Nod is the node where the potential generated implicit types
  117.    --  will be inserted. The 2 last parameters are used for creating the name.
  118.  
  119.    procedure Make_Class_Wide_Type (T : Entity_Id);
  120.    --  A Class_Wide_Type is created for each tagged type definition. The
  121.    --  attributes of a class wide type are inherited from those of the type
  122.    --  T. If T is introduced by a private declaration, the corresponding
  123.    --  class wide type is created at the same time, and therefore there is
  124.    --  a private and a full declaration for the class wide type type as well.
  125.  
  126.    function Process_Subtype
  127.      (S           : Node_Id;
  128.       Related_Nod : Node_Id;
  129.       Related_Id  : Entity_Id := Empty;
  130.       Suffix      : Character := ' ')
  131.       return        Entity_Id;
  132.    --  Process a subtype indication and return corresponding entity.
  133.    --  Related_Nod is the node where the potential generated implicit types
  134.    --  will be inserted. The 2 last parameters are used to build the associated
  135.    --  Implicit type name.
  136.  
  137.    procedure Process_Discriminants (N : Node_Id);
  138.    --  Process discriminants of a type with discriminants
  139.  
  140. end Sem_Ch3;
  141.