]>
Commit | Line | Data |
---|---|---|
996ae0b0 RK |
1 | ------------------------------------------------------------------------------ |
2 | -- -- | |
3 | -- GNAT COMPILER COMPONENTS -- | |
4 | -- -- | |
5 | -- S E M _ C H 3 -- | |
6 | -- -- | |
7 | -- S p e c -- | |
8 | -- -- | |
fbf5a39b | 9 | -- Copyright (C) 1992-2003 Free Software Foundation, Inc. -- |
996ae0b0 RK |
10 | -- -- |
11 | -- GNAT is free software; you can redistribute it and/or modify it under -- | |
12 | -- terms of the GNU General Public License as published by the Free Soft- -- | |
13 | -- ware Foundation; either version 2, or (at your option) any later ver- -- | |
14 | -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- | |
15 | -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- | |
16 | -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- | |
17 | -- for more details. You should have received a copy of the GNU General -- | |
18 | -- Public License distributed with GNAT; see file COPYING. If not, write -- | |
19 | -- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, -- | |
20 | -- MA 02111-1307, USA. -- | |
21 | -- -- | |
22 | -- GNAT was originally developed by the GNAT team at New York University. -- | |
71ff80dc | 23 | -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
996ae0b0 RK |
24 | -- -- |
25 | ------------------------------------------------------------------------------ | |
26 | ||
27 | with Nlists; use Nlists; | |
28 | with Types; use Types; | |
29 | ||
30 | package Sem_Ch3 is | |
31 | procedure Analyze_Component_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_Declaration (N : Node_Id); | |
39 | procedure Analyze_Subtype_Indication (N : Node_Id); | |
40 | procedure Analyze_Type_Declaration (N : Node_Id); | |
41 | procedure Analyze_Variant_Part (N : Node_Id); | |
42 | ||
43 | function Access_Definition | |
44 | (Related_Nod : Node_Id; | |
45 | N : Node_Id) | |
46 | return Entity_Id; | |
47 | -- An access definition defines a general access type for a formal | |
48 | -- parameter. The procedure is called when processing formals, when | |
49 | -- the current scope is the subprogram. The Implicit type is attached | |
50 | -- to the Related_Nod put into the enclosing scope, so that the only | |
51 | -- entities defined in the spec are the formals themselves. | |
52 | ||
53 | procedure Access_Subprogram_Declaration | |
54 | (T_Name : Entity_Id; | |
55 | T_Def : Node_Id); | |
56 | -- The subprogram specification yields the signature of an implicit | |
57 | -- type, whose Ekind is Access_Subprogram_Type. This implicit type is | |
58 | -- the designated type of the declared access type. In subprogram calls, | |
59 | -- the signature of the implicit type works like the profile of a regular | |
60 | -- subprogram. | |
61 | ||
62 | procedure Analyze_Declarations (L : List_Id); | |
63 | -- Called to analyze a list of declarations (in what context ???). Also | |
64 | -- performs necessary freezing actions (more description needed ???) | |
65 | ||
fbf5a39b AC |
66 | procedure Analyze_Per_Use_Expression (N : Node_Id; T : Entity_Id); |
67 | -- Default and per object expressions do not freeze their components, | |
68 | -- and must be analyzed and resolved accordingly. The analysis is | |
69 | -- done by calling the Pre_Analyze_And_Resolve routine and setting | |
70 | -- the global In_Default_Expression flag. See the documentation section | |
71 | -- entitled "Handling of Default and Per-Object Expressions" in sem.ads | |
72 | -- for details. N is the expression to be analyzed, T is the expected type. | |
996ae0b0 RK |
73 | |
74 | procedure Array_Type_Declaration (T : in out Entity_Id; Def : Node_Id); | |
75 | -- Process an array type declaration. If the array is constrained, we | |
76 | -- create an implicit parent array type, with the same index types and | |
77 | -- component type. | |
78 | ||
79 | procedure Access_Type_Declaration (T : Entity_Id; Def : Node_Id); | |
80 | -- Process an access type declaration | |
81 | ||
82 | procedure Check_Abstract_Overriding (T : Entity_Id); | |
83 | -- Check that all abstract subprograms inherited from T's parent type | |
84 | -- have been overridden as required, and that nonabstract subprograms | |
85 | -- have not been incorrectly overridden with an abstract subprogram. | |
86 | ||
87 | procedure Check_Aliased_Component_Types (T : Entity_Id); | |
88 | -- Given an array type or record type T, check that if the type is | |
89 | -- nonlimited, then the nominal subtype of any components of T | |
90 | -- that have discriminants must be constrained. | |
91 | ||
92 | procedure Check_Completion (Body_Id : Node_Id := Empty); | |
93 | -- At the end of a declarative part, verify that all entities that | |
94 | -- require completion have received one. If Body_Id is absent, the | |
95 | -- error indicating a missing completion is placed on the declaration | |
96 | -- that needs completion. If Body_Id is present, it is the defining | |
97 | -- identifier of a package body, and errors are posted on that node, | |
98 | -- rather than on the declarations that require completion in the package | |
99 | -- declaration. | |
100 | ||
101 | procedure Derive_Subprogram | |
102 | (New_Subp : in out Entity_Id; | |
103 | Parent_Subp : Entity_Id; | |
104 | Derived_Type : Entity_Id; | |
105 | Parent_Type : Entity_Id; | |
106 | Actual_Subp : Entity_Id := Empty); | |
107 | -- Derive the subprogram Parent_Subp from Parent_Type, and replace the | |
108 | -- subsidiary subtypes with the derived type to build the specification | |
109 | -- of the inherited subprogram (returned in New_Subp). For tagged types, | |
110 | -- the derived subprogram is aliased to that of the actual (in the | |
111 | -- case where Actual_Subp is nonempty) rather than to the corresponding | |
112 | -- subprogram of the parent type. | |
113 | ||
114 | procedure Derive_Subprograms | |
115 | (Parent_Type : Entity_Id; | |
116 | Derived_Type : Entity_Id; | |
117 | Generic_Actual : Entity_Id := Empty); | |
118 | -- To complete type derivation, collect or retrieve the primitive | |
119 | -- operations of the parent type, and replace the subsidiary subtypes | |
120 | -- with the derived type, to build the specs of the inherited ops. | |
121 | -- For generic actuals, the mapping of the primitive operations to those | |
122 | -- of the parent type is also done by rederiving the operations within | |
123 | -- the instance. For tagged types, the derived subprograms are aliased to | |
124 | -- those of the actual, not those of the ancestor. | |
125 | ||
996ae0b0 RK |
126 | function Find_Type_Name (N : Node_Id) return Entity_Id; |
127 | -- Enter the identifier in a type definition, or find the entity already | |
128 | -- declared, in the case of the full declaration of an incomplete or | |
129 | -- private type. | |
130 | ||
131 | function Get_Discriminant_Value | |
132 | (Discriminant : Entity_Id; | |
133 | Typ_For_Constraint : Entity_Id; | |
134 | Constraint : Elist_Id) | |
135 | return Node_Id; | |
136 | -- ??? MORE DOCUMENTATION | |
137 | -- Given a discriminant somewhere in the Typ_For_Constraint tree | |
138 | -- and a Constraint, return the value of that discriminant. | |
139 | ||
140 | function Is_Visible_Component (C : Entity_Id) return Boolean; | |
141 | -- Determines if a record component C is visible in the present context. | |
142 | -- Note that even though component C could appear in the entity chain | |
143 | -- of a record type, C may not be visible in the current context. For | |
144 | -- instance, C may be a component inherited in the full view of a private | |
145 | -- extension which is not visible in the current context. | |
146 | ||
147 | procedure Make_Index | |
148 | (I : Node_Id; | |
149 | Related_Nod : Node_Id; | |
150 | Related_Id : Entity_Id := Empty; | |
151 | Suffix_Index : Nat := 1); | |
152 | -- Process an index that is given in an array declaration, an entry | |
153 | -- family declaration or a loop iteration. The index is given by an | |
154 | -- index declaration (a 'box'), or by a discrete range. The later can | |
155 | -- be the name of a discrete type, or a subtype indication. | |
156 | -- Related_Nod is the node where the potential generated implicit types | |
157 | -- will be inserted. The 2 last parameters are used for creating the name. | |
158 | ||
159 | procedure Make_Class_Wide_Type (T : Entity_Id); | |
160 | -- A Class_Wide_Type is created for each tagged type definition. The | |
161 | -- attributes of a class wide type are inherited from those of the type | |
162 | -- T. If T is introduced by a private declaration, the corresponding | |
163 | -- class wide type is created at the same time, and therefore there is | |
164 | -- a private and a full declaration for the class wide type type as well. | |
165 | ||
166 | procedure Process_Full_View (N : Node_Id; Full_T, Priv_T : Entity_Id); | |
167 | -- Process some semantic actions when the full view of a private type is | |
168 | -- encountered and analyzed. The first action is to create the full views | |
fbf5a39b | 169 | -- of the dependant private subtypes. The second action is to recopy the |
996ae0b0 RK |
170 | -- primitive operations of the private view (in the tagged case). |
171 | -- N is the N_Full_Type_Declaration node. | |
172 | ||
173 | -- Full_T is the full view of the type whose full declaration is in N. | |
174 | -- | |
175 | -- Priv_T is the private view of the type whose full declaration is in N. | |
176 | ||
177 | procedure Process_Range_Expr_In_Decl | |
178 | (R : Node_Id; | |
179 | T : Entity_Id; | |
996ae0b0 RK |
180 | Check_List : List_Id := Empty_List; |
181 | R_Check_Off : Boolean := False); | |
182 | -- Process a range expression that appears in a declaration context. The | |
183 | -- range is analyzed and resolved with the base type of the given type, | |
184 | -- and an appropriate check for expressions in non-static contexts made | |
185 | -- on the bounds. R is analyzed and resolved using T, so the caller should | |
186 | -- if necessary link R into the tree before the call, and in particular in | |
187 | -- the case of a subtype declaration, it is appropriate to set the parent | |
188 | -- pointer of R so that the types get properly frozen. The Check_List | |
189 | -- parameter is used when the subprogram is called from | |
190 | -- Build_Record_Init_Proc and is used to return a set of constraint | |
191 | -- checking statements generated by the Checks package. R_Check_Off is | |
192 | -- set to True when the call to Range_Check is to be skipped. | |
193 | ||
194 | function Process_Subtype | |
195 | (S : Node_Id; | |
196 | Related_Nod : Node_Id; | |
197 | Related_Id : Entity_Id := Empty; | |
198 | Suffix : Character := ' ') | |
199 | return Entity_Id; | |
200 | -- Process a subtype indication S and return corresponding entity. | |
201 | -- Related_Nod is the node where the potential generated implicit types | |
202 | -- will be inserted. The Related_Id and Suffix parameters are used to | |
203 | -- build the associated Implicit type name. | |
204 | ||
fbf5a39b AC |
205 | procedure Process_Discriminants |
206 | (N : Node_Id; | |
207 | Prev : Entity_Id := Empty); | |
996ae0b0 | 208 | -- Process the discriminants contained in an N_Full_Type_Declaration or |
fbf5a39b AC |
209 | -- N_Incomplete_Type_Decl node N. If the declaration is a completion, |
210 | -- Prev is entity on the partial view, on which references are posted. | |
996ae0b0 | 211 | |
07fc65c4 GB |
212 | procedure Set_Completion_Referenced (E : Entity_Id); |
213 | -- If E is the completion of a private or incomplete type declaration, | |
214 | -- or the completion of a deferred constant declaration, mark the entity | |
215 | -- as referenced. Warnings on unused entities, if needed, go on the | |
216 | -- partial view. | |
217 | ||
996ae0b0 | 218 | end Sem_Ch3; |