OSDN Git Service

config/
[pf3gnuchains/gcc-fork.git] / gcc / ada / sem_ch3.ads
1 ------------------------------------------------------------------------------
2 --                                                                          --
3 --                         GNAT COMPILER COMPONENTS                         --
4 --                                                                          --
5 --                              S E M _ C H 3                               --
6 --                                                                          --
7 --                                 S p e c                                  --
8 --                                                                          --
9 --          Copyright (C) 1992-2010, 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 -- GNAT was originally developed  by the GNAT team at  New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
23 --                                                                          --
24 ------------------------------------------------------------------------------
25
26 with Nlists; use Nlists;
27 with Types;  use Types;
28
29 package Sem_Ch3 is
30    procedure Analyze_Component_Declaration         (N : Node_Id);
31    procedure Analyze_Full_Type_Declaration         (N : Node_Id);
32    procedure Analyze_Incomplete_Type_Decl          (N : Node_Id);
33    procedure Analyze_Itype_Reference               (N : Node_Id);
34    procedure Analyze_Number_Declaration            (N : Node_Id);
35    procedure Analyze_Object_Declaration            (N : Node_Id);
36    procedure Analyze_Others_Choice                 (N : Node_Id);
37    procedure Analyze_Private_Extension_Declaration (N : Node_Id);
38    procedure Analyze_Subtype_Indication            (N : Node_Id);
39    procedure Analyze_Variant_Part                  (N : Node_Id);
40
41    procedure Analyze_Subtype_Declaration
42      (N    : Node_Id;
43       Skip : Boolean := False);
44    --  Called to analyze a subtype declaration. The parameter Skip is used for
45    --  Ada 2005 (AI-412). We set to True in order to avoid reentering the
46    --  defining identifier of N when analyzing a rewritten incomplete subtype
47    --  declaration.
48
49    function Access_Definition
50      (Related_Nod : Node_Id;
51       N           : Node_Id) return Entity_Id;
52    --  An access definition defines a general access type for a formal
53    --  parameter. The procedure is called when processing formals, when
54    --  the current scope is the subprogram. The Implicit type is attached
55    --  to the Related_Nod put into the enclosing scope, so that the only
56    --  entities defined in the spec are the formals themselves.
57
58    procedure Access_Subprogram_Declaration
59      (T_Name : Entity_Id;
60       T_Def  : Node_Id);
61    --  The subprogram specification yields the signature of an implicit
62    --  type, whose Ekind is Access_Subprogram_Type. This implicit type is
63    --  the designated type of the declared access type. In subprogram calls,
64    --  the signature of the implicit type works like the profile of a regular
65    --  subprogram.
66
67    procedure Add_Internal_Interface_Entities (Tagged_Type : Entity_Id);
68    --  Add to the list of primitives of Tagged_Type the internal entities
69    --  associated with covered interface primitives. These entities link the
70    --  interface primitives with the tagged type primitives that cover them.
71
72    procedure Analyze_Declarations (L : List_Id);
73    --  Called to analyze a list of declarations (in what context ???). Also
74    --  performs necessary freezing actions (more description needed ???)
75
76    procedure Analyze_Interface_Declaration (T : Entity_Id; Def : Node_Id);
77    --  Analyze an interface declaration or a formal interface declaration
78
79    procedure Array_Type_Declaration (T : in out Entity_Id; Def : Node_Id);
80    --  Process an array type declaration. If the array is constrained, we
81    --  create an implicit parent array type, with the same index types and
82    --  component type.
83
84    procedure Access_Type_Declaration (T : Entity_Id; Def : Node_Id);
85    --  Process an access type declaration
86
87    procedure Build_Itype_Reference (Ityp : Entity_Id; Nod : Node_Id);
88    --  Create a reference to an internal type, for use by Gigi. The back-end
89    --  elaborates itypes on demand, i.e. when their first use is seen. This can
90    --  lead to scope anomalies if the first use is within a scope that is
91    --  nested within the scope that contains the point of definition of the
92    --  itype. The Itype_Reference node forces the elaboration of the itype
93    --  in the proper scope. The node is inserted after Nod, which is the
94    --  enclosing declaration that generated Ityp.
95    --
96    --  A related mechanism is used during expansion, for itypes created in
97    --  branches of conditionals. See Ensure_Defined in exp_util.
98    --  Could both mechanisms be merged ???
99
100    procedure Check_Abstract_Overriding (T : Entity_Id);
101    --  Check that all abstract subprograms inherited from T's parent type have
102    --  been overridden as required, and that nonabstract subprograms have not
103    --  been incorrectly overridden with an abstract subprogram.
104
105    procedure Check_Aliased_Component_Types (T : Entity_Id);
106    --  Given an array type or record type T, check that if the type is
107    --  nonlimited, then the nominal subtype of any components of T that
108    --  have discriminants must be constrained.
109
110    procedure Check_Completion (Body_Id : Node_Id := Empty);
111    --  At the end of a declarative part, verify that all entities that require
112    --  completion have received one. If Body_Id is absent, the error indicating
113    --  a missing completion is placed on the declaration that needs completion.
114    --  If Body_Id is present, it is the defining identifier of a package body,
115    --  and errors are posted on that node, rather than on the declarations that
116    --  require completion in the package declaration.
117
118    procedure Derive_Subprogram
119      (New_Subp     : in out Entity_Id;
120       Parent_Subp  : Entity_Id;
121       Derived_Type : Entity_Id;
122       Parent_Type  : Entity_Id;
123       Actual_Subp  : Entity_Id := Empty);
124    --  Derive the subprogram Parent_Subp from Parent_Type, and replace the
125    --  subsidiary subtypes with the derived type to build the specification
126    --  of the inherited subprogram (returned in New_Subp). For tagged types,
127    --  the derived subprogram is aliased to that of the actual (in the
128    --  case where Actual_Subp is nonempty) rather than to the corresponding
129    --  subprogram of the parent type.
130
131    procedure Derive_Subprograms
132      (Parent_Type    : Entity_Id;
133       Derived_Type   : Entity_Id;
134       Generic_Actual : Entity_Id := Empty);
135    --  To complete type derivation, collect/retrieve the primitive operations
136    --  of the parent type, and replace the subsidiary subtypes with the derived
137    --  type, to build the specs of the inherited ops. For generic actuals, the
138    --  mapping of the primitive operations to those of the parent type is also
139    --  done by rederiving the operations within the instance. For tagged types,
140    --  the derived subprograms are aliased to those of the actual, not those of
141    --  the ancestor.
142    --
143    --  Note: one might expect this to be private to the package body, but there
144    --  is one rather unusual usage in package Exp_Dist.
145
146    function Find_Hidden_Interface
147      (Src  : Elist_Id;
148       Dest : Elist_Id) return Entity_Id;
149    --  Ada 2005: Determine whether the interfaces in list Src are all present
150    --  in the list Dest. Return the first differing interface, or Empty
151    --  otherwise.
152
153    function Find_Type_Of_Subtype_Indic (S : Node_Id) return Entity_Id;
154    --  Given a subtype indication S (which is really an N_Subtype_Indication
155    --  node or a plain N_Identifier), find the type of the subtype mark.
156
157    function Find_Type_Name (N : Node_Id) return Entity_Id;
158    --  Enter the identifier in a type definition, or find the entity already
159    --  declared, in the case of the full declaration of an incomplete or
160    --  private type. If the previous declaration is tagged then the class-wide
161    --  entity is propagated to the identifier to prevent multiple incompatible
162    --  class-wide types that may be created for self-referential anonymous
163    --  access components.
164
165    function Get_Discriminant_Value
166      (Discriminant       : Entity_Id;
167       Typ_For_Constraint : Entity_Id;
168       Constraint         : Elist_Id) return Node_Id;
169    --  ??? MORE DOCUMENTATION
170    --  Given a discriminant somewhere in the Typ_For_Constraint tree and a
171    --  Constraint, return the value of that discriminant.
172
173    function Is_Null_Extension (T : Entity_Id) return Boolean;
174    --  Returns True if the tagged type T has an N_Full_Type_Declaration that
175    --  is a null extension, meaning that it has an extension part without any
176    --  components and does not have a known discriminant part.
177
178    function Is_Visible_Component (C : Entity_Id) return Boolean;
179    --  Determines if a record component C is visible in the present context.
180    --  Note that even though component C could appear in the entity chain
181    --  of a record type, C may not be visible in the current context. For
182    --  instance, C may be a component inherited in the full view of a private
183    --  extension which is not visible in the current context.
184
185    procedure Make_Index
186      (I            : Node_Id;
187       Related_Nod  : Node_Id;
188       Related_Id   : Entity_Id := Empty;
189       Suffix_Index : Nat := 1);
190    --  Process an index that is given in an array declaration, an entry
191    --  family declaration or a loop iteration. The index is given by an
192    --  index declaration (a 'box'), or by a discrete range. The later can
193    --  be the name of a discrete type, or a subtype indication.
194    --
195    --  Related_Nod is the node where the potential generated implicit types
196    --  will be inserted. The 2 last parameters are used for creating the name.
197
198    procedure Make_Class_Wide_Type (T : Entity_Id);
199    --  A Class_Wide_Type is created for each tagged type definition. The
200    --  attributes of a class-wide type are inherited from those of the type T.
201    --  If T is introduced by a private declaration, the corresponding class
202    --  wide type is created at the same time, and therefore there is a private
203    --  and a full declaration for the class-wide type as well.
204
205    function OK_For_Limited_Init_In_05
206      (Typ : Entity_Id;
207       Exp : Node_Id) return Boolean;
208    --  Presuming Exp is an expression of an inherently limited type Typ,
209    --  returns True if the expression is allowed in an initialization context
210    --  by the rules of Ada 2005. We use the rule in RM-7.5(2.1/2), "...it is an
211    --  aggregate, a function_call, or a parenthesized expression or qualified
212    --  expression whose operand is permitted...". Note that in Ada 95 mode,
213    --  we sometimes wish to give warnings based on whether the program _would_
214    --  be legal in Ada 2005. Note that Exp must already have been resolved,
215    --  so we can know whether it's a function call (as opposed to an indexed
216    --  component, for example). In the case where Typ is a limited interface's
217    --  class-wide type, then the expression is allowed to be of any kind if its
218    --  type is a nonlimited descendant of the interface.
219
220    function OK_For_Limited_Init
221      (Typ : Entity_Id;
222       Exp : Node_Id) return Boolean;
223    --  Always False in Ada 95 mode. Equivalent to OK_For_Limited_Init_In_05 in
224    --  Ada 2005 mode.
225
226    procedure Preanalyze_Spec_Expression (N : Node_Id; T : Entity_Id);
227    --  Default and per object expressions do not freeze their components, and
228    --  must be analyzed and resolved accordingly. The analysis is done by
229    --  calling the Preanalyze_And_Resolve routine and setting the global
230    --  In_Default_Expression flag. See the documentation section entitled
231    --  "Handling of Default and Per-Object Expressions" in sem.ads for full
232    --  details. N is the expression to be analyzed, T is the expected type.
233    --  This mechanism is also used for aspect specifications that have an
234    --  expression parameter that needs similar preanalysis.
235
236    procedure Process_Full_View (N : Node_Id; Full_T, Priv_T : Entity_Id);
237    --  Process some semantic actions when the full view of a private type is
238    --  encountered and analyzed. The first action is to create the full views
239    --  of the dependant private subtypes. The second action is to recopy the
240    --  primitive operations of the private view (in the tagged case).
241    --  N is the N_Full_Type_Declaration node.
242    --
243    --    Full_T is the full view of the type whose full declaration is in N.
244    --
245    --    Priv_T is the private view of the type whose full declaration is in N.
246
247    procedure Process_Range_Expr_In_Decl
248      (R           : Node_Id;
249       T           : Entity_Id;
250       Check_List  : List_Id := Empty_List;
251       R_Check_Off : Boolean := False);
252    --  Process a range expression that appears in a declaration context. The
253    --  range is analyzed and resolved with the base type of the given type, and
254    --  an appropriate check for expressions in non-static contexts made on the
255    --  bounds. R is analyzed and resolved using T, so the caller should if
256    --  necessary link R into the tree before the call, and in particular in the
257    --  case of a subtype declaration, it is appropriate to set the parent
258    --  pointer of R so that the types get properly frozen. Check_List is used
259    --  when the subprogram is called from Build_Record_Init_Proc and is used to
260    --  return a set of constraint checking statements generated by the Checks
261    --  package. R_Check_Off is set to True when the call to Range_Check is to
262    --  be skipped.
263
264    function Process_Subtype
265      (S           : Node_Id;
266       Related_Nod : Node_Id;
267       Related_Id  : Entity_Id := Empty;
268       Suffix      : Character := ' ') return Entity_Id;
269    --  Process a subtype indication S and return corresponding entity.
270    --  Related_Nod is the node where the potential generated implicit types
271    --  will be inserted. The Related_Id and Suffix parameters are used to
272    --  build the associated Implicit type name.
273
274    procedure Process_Discriminants
275      (N    : Node_Id;
276       Prev : Entity_Id := Empty);
277    --  Process the discriminants contained in an N_Full_Type_Declaration or
278    --  N_Incomplete_Type_Decl node N. If the declaration is a completion,
279    --  Prev is entity on the partial view, on which references are posted.
280    --  However, note that Process_Discriminants is called for a completion only
281    --  if partial view had no discriminants (else we just check conformance
282    --  between the two views and do not call Process_Discriminants again for
283    --  the completion).
284
285    function Replace_Anonymous_Access_To_Protected_Subprogram
286      (N : Node_Id) return Entity_Id;
287    --  Ada 2005 (AI-254): Create and decorate an internal full type declaration
288    --  for an anonymous access to protected subprogram. For a record component
289    --  declaration, the type is created in the enclosing scope, for an array
290    --  type declaration or an object declaration it is simply placed ahead of
291    --  this declaration.
292
293    procedure Set_Completion_Referenced (E : Entity_Id);
294    --  If E is the completion of a private or incomplete  type declaration,
295    --  or the completion of a deferred constant declaration, mark the entity
296    --  as referenced. Warnings on unused entities, if needed, go on the
297    --  partial view.
298
299 end Sem_Ch3;