]>
Commit | Line | Data |
---|---|---|
996ae0b0 RK |
1 | ------------------------------------------------------------------------------ |
2 | -- -- | |
3 | -- GNAT COMPILER COMPONENTS -- | |
4 | -- -- | |
5 | -- S E M _ U T I L -- | |
6 | -- -- | |
7 | -- S p e c -- | |
8 | -- -- | |
1d005acc | 9 | -- Copyright (C) 1992-2019, 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- -- | |
b5c84c3c | 13 | -- ware Foundation; either version 3, or (at your option) any later ver- -- |
996ae0b0 RK |
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 -- | |
b5c84c3c RD |
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. -- | |
996ae0b0 RK |
20 | -- -- |
21 | -- GNAT was originally developed by the GNAT team at New York University. -- | |
71ff80dc | 22 | -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
996ae0b0 RK |
23 | -- -- |
24 | ------------------------------------------------------------------------------ | |
25 | ||
26 | -- Package containing utility procedures used throughout the semantics | |
27 | ||
935b02ae | 28 | with Atree; use Atree; |
9aff36e9 | 29 | with Einfo; use Einfo; |
276e7ed0 | 30 | with Exp_Tss; use Exp_Tss; |
9aff36e9 | 31 | with Namet; use Namet; |
c61ef416 | 32 | with Opt; use Opt; |
9aff36e9 RD |
33 | with Snames; use Snames; |
34 | with Types; use Types; | |
35 | with Uintp; use Uintp; | |
36 | with Urealp; use Urealp; | |
996ae0b0 RK |
37 | |
38 | package Sem_Util is | |
39 | ||
9e87a68d | 40 | function Abstract_Interface_List (Typ : Entity_Id) return List_Id; |
b2c3160c AC |
41 | -- The list of interfaces implemented by Typ. Empty if there are none, |
42 | -- including the cases where there can't be any because e.g. the type is | |
43 | -- not tagged. | |
9e87a68d | 44 | |
6cd8f5b0 BD |
45 | function Acquire_Warning_Match_String (Str_Lit : Node_Id) return String; |
46 | -- Used by pragma Warnings (Off, string), and Warn_As_Error (string) to get | |
47 | -- the given string argument, adding leading and trailing asterisks if they | |
48 | -- are not already present. Str_Lit is the static value of the pragma | |
49 | -- argument. | |
50 | ||
996ae0b0 RK |
51 | procedure Add_Access_Type_To_Process (E : Entity_Id; A : Entity_Id); |
52 | -- Add A to the list of access types to process when expanding the | |
53 | -- freeze node of E. | |
54 | ||
7edfb4c6 HK |
55 | procedure Add_Block_Identifier (N : Node_Id; Id : out Entity_Id); |
56 | -- Given a block statement N, generate an internal E_Block label and make | |
57 | -- it the identifier of the block. Id denotes the generated entity. If the | |
e917e3b8 | 58 | -- block already has an identifier, Id returns the entity of its label. |
7edfb4c6 | 59 | |
f377c995 HK |
60 | procedure Add_Global_Declaration (N : Node_Id); |
61 | -- These procedures adds a declaration N at the library level, to be | |
62 | -- elaborated before any other code in the unit. It is used for example | |
63 | -- for the entity that marks whether a unit has been elaborated. The | |
64 | -- declaration is added to the Declarations list of the Aux_Decls_Node | |
65 | -- for the current unit. The declarations are added in the current scope, | |
66 | -- so the caller should push a new scope as required before the call. | |
67 | ||
e645cb39 AC |
68 | function Add_Suffix (E : Entity_Id; Suffix : Character) return Name_Id; |
69 | -- Returns the name of E adding Suffix | |
70 | ||
061828e3 AC |
71 | function Address_Integer_Convert_OK (T1, T2 : Entity_Id) return Boolean; |
72 | -- Given two types, returns True if we are in Allow_Integer_Address mode | |
d9d25d04 | 73 | -- and one of the types is (a descendant of) System.Address (and this type |
061828e3 AC |
74 | -- is private), and the other type is any integer type. |
75 | ||
f26a3587 AC |
76 | function Address_Value (N : Node_Id) return Node_Id; |
77 | -- Return the underlying value of the expression N of an address clause | |
78 | ||
094cefda AC |
79 | function Addressable (V : Uint) return Boolean; |
80 | function Addressable (V : Int) return Boolean; | |
81 | pragma Inline (Addressable); | |
9d2a2071 AC |
82 | -- Returns True if the value of V is the word size or an addressable factor |
83 | -- of the word size (typically 8, 16, 32 or 64). | |
094cefda | 84 | |
3f433bc0 ES |
85 | procedure Aggregate_Constraint_Checks |
86 | (Exp : Node_Id; | |
87 | Check_Typ : Entity_Id); | |
88 | -- Checks expression Exp against subtype Check_Typ. If Exp is an aggregate | |
89 | -- and Check_Typ a constrained record type with discriminants, we generate | |
90 | -- the appropriate discriminant checks. If Exp is an array aggregate then | |
91 | -- emit the appropriate length checks. If Exp is a scalar type, or a string | |
92 | -- literal, Exp is changed into Check_Typ'(Exp) to ensure that range checks | |
93 | -- are performed at run time. Also used for expressions in the argument of | |
94 | -- 'Update, which shares some of the features of an aggregate. | |
95 | ||
996ae0b0 RK |
96 | function Alignment_In_Bits (E : Entity_Id) return Uint; |
97 | -- If the alignment of the type or object E is currently known to the | |
98 | -- compiler, then this function returns the alignment value in bits. | |
99 | -- Otherwise Uint_0 is returned, indicating that the alignment of the | |
100 | -- entity is not yet known to the compiler. | |
101 | ||
2f7ae2aa BD |
102 | function All_Composite_Constraints_Static (Constr : Node_Id) return Boolean; |
103 | -- Used to implement pragma Restrictions (No_Dynamic_Sized_Objects). | |
104 | -- Given a constraint or subtree of a constraint on a composite | |
105 | -- subtype/object, returns True if there are no nonstatic constraints, | |
106 | -- which might cause objects to be created with dynamic size. | |
107 | -- Called for subtype declarations (including implicit ones created for | |
108 | -- subtype indications in object declarations, as well as discriminated | |
109 | -- record aggregate cases). For record aggregates, only records containing | |
110 | -- discriminant-dependent arrays matter, because the discriminants must be | |
111 | -- static when governing a variant part. Access discriminants are | |
112 | -- irrelevant. Also called for array aggregates, but only named notation, | |
113 | -- because those are the only dynamic cases. | |
114 | ||
72a26637 AC |
115 | procedure Append_Entity_Name (Buf : in out Bounded_String; E : Entity_Id); |
116 | -- Recursive procedure to construct string for qualified name of enclosing | |
117 | -- program unit. The qualification stops at an enclosing scope has no | |
118 | -- source name (block or loop). If entity is a subprogram instance, skip | |
119 | -- enclosing wrapper package. The name is appended to Buf. | |
120 | ||
2352eadb AC |
121 | procedure Append_Inherited_Subprogram (S : Entity_Id); |
122 | -- If the parent of the operation is declared in the visible part of | |
123 | -- the current scope, the inherited operation is visible even though the | |
124 | -- derived type that inherits the operation may be completed in the private | |
125 | -- part of the current package. | |
126 | ||
996ae0b0 | 127 | procedure Apply_Compile_Time_Constraint_Error |
07fc65c4 GB |
128 | (N : Node_Id; |
129 | Msg : String; | |
130 | Reason : RT_Exception_Code; | |
131 | Ent : Entity_Id := Empty; | |
132 | Typ : Entity_Id := Empty; | |
133 | Loc : Source_Ptr := No_Location; | |
fbf5a39b AC |
134 | Rep : Boolean := True; |
135 | Warn : Boolean := False); | |
8d45ce77 HK |
136 | -- N is a subexpression that will raise Constraint_Error when evaluated |
137 | -- at run time. Msg is a message that explains the reason for raising the | |
07fc65c4 GB |
138 | -- exception. The last character is ? if the message is always a warning, |
139 | -- even in Ada 95, and is not a ? if the message represents an illegality | |
140 | -- (because of violation of static expression rules) in Ada 95 (but not | |
141 | -- in Ada 83). Typically this routine posts all messages at the Sloc of | |
142 | -- node N. However, if Loc /= No_Location, Loc is the Sloc used to output | |
143 | -- the message. After posting the appropriate message, and if the flag | |
144 | -- Rep is set, this routine replaces the expression with an appropriate | |
145 | -- N_Raise_Constraint_Error node using the given Reason code. This node | |
146 | -- is then marked as being static if the original node is static, but | |
147 | -- sets the flag Raises_Constraint_Error, preventing further evaluation. | |
148 | -- The error message may contain a } or & insertion character. This | |
149 | -- normally references Etype (N), unless the Ent argument is given | |
996ae0b0 RK |
150 | -- explicitly, in which case it is used instead. The type of the raise |
151 | -- node that is built is normally Etype (N), but if the Typ parameter | |
fbf5a39b AC |
152 | -- is present, this is used instead. Warn is normally False. If it is |
153 | -- True then the message is treated as a warning even though it does | |
dcffd515 | 154 | -- not end with a ? (this is used when the caller wants to parameterize |
520c0201 AC |
155 | -- whether an error or warning is given), or when the message should be |
156 | -- treated as a warning even when SPARK_Mode is On (which otherwise would | |
157 | -- force an error). | |
996ae0b0 | 158 | |
6c3c671e AC |
159 | function Async_Readers_Enabled (Id : Entity_Id) return Boolean; |
160 | -- Given the entity of an abstract state or a variable, determine whether | |
161 | -- Id is subject to external property Async_Readers and if it is, the | |
162 | -- related expression evaluates to True. | |
163 | ||
164 | function Async_Writers_Enabled (Id : Entity_Id) return Boolean; | |
165 | -- Given the entity of an abstract state or a variable, determine whether | |
166 | -- Id is subject to external property Async_Writers and if it is, the | |
167 | -- related expression evaluates to True. | |
168 | ||
9b62eb32 AC |
169 | function Available_Full_View_Of_Component (T : Entity_Id) return Boolean; |
170 | -- If at the point of declaration an array type has a private or limited | |
5764ee3c | 171 | -- component, several array operations are not available on the type, and |
9b62eb32 AC |
172 | -- the array type is flagged accordingly. If in the immediate scope of |
173 | -- the array type the component becomes non-private or non-limited, these | |
5764ee3c | 174 | -- operations become available. This can happen if the scopes of both types |
9b62eb32 AC |
175 | -- are open, and the scope of the array is not outside the scope of the |
176 | -- component. | |
177 | ||
2d7b3fa4 TQ |
178 | procedure Bad_Attribute |
179 | (N : Node_Id; | |
180 | Nam : Name_Id; | |
181 | Warn : Boolean := False); | |
182 | -- Called when node N is expected to contain a valid attribute name, and | |
183 | -- Nam is found instead. If Warn is set True this is a warning, else this | |
184 | -- is an error. | |
185 | ||
86200f66 | 186 | procedure Bad_Predicated_Subtype_Use |
57081559 AC |
187 | (Msg : String; |
188 | N : Node_Id; | |
189 | Typ : Entity_Id; | |
190 | Suggest_Static : Boolean := False); | |
86200f66 | 191 | -- This is called when Typ, a predicated subtype, is used in a context |
57081559 AC |
192 | -- which does not allow the use of a predicated subtype. Msg is passed to |
193 | -- Error_Msg_FE to output an appropriate message using N as the location, | |
194 | -- and Typ as the entity. The caller must set up any insertions other than | |
195 | -- the & for the type itself. Note that if Typ is a generic actual type, | |
196 | -- then the message will be output as a warning, and a raise Program_Error | |
197 | -- is inserted using Insert_Action with node N as the insertion point. Node | |
198 | -- N also supplies the source location for construction of the raise node. | |
199 | -- If Typ does not have any predicates, the call has no effect. Set flag | |
200 | -- Suggest_Static when the context warrants an advice on how to avoid the | |
201 | -- use error. | |
86200f66 | 202 | |
428684fd RD |
203 | function Bad_Unordered_Enumeration_Reference |
204 | (N : Node_Id; | |
205 | T : Entity_Id) return Boolean; | |
206 | -- Node N contains a potentially dubious reference to type T, either an | |
207 | -- explicit comparison, or an explicit range. This function returns True | |
208 | -- if the type T is an enumeration type for which No pragma Order has been | |
209 | -- given, and the reference N is not in the same extended source unit as | |
210 | -- the declaration of T. | |
211 | ||
90e491a7 PMR |
212 | function Begin_Keyword_Location (N : Node_Id) return Source_Ptr; |
213 | -- Given block statement, entry body, package body, subprogram body, or | |
214 | -- task body N, return the closest source location to the "begin" keyword. | |
215 | ||
996ae0b0 | 216 | function Build_Actual_Subtype |
fbf5a39b AC |
217 | (T : Entity_Id; |
218 | N : Node_Or_Entity_Id) return Node_Id; | |
996ae0b0 RK |
219 | -- Build an anonymous subtype for an entity or expression, using the |
220 | -- bounds of the entity or the discriminants of the enclosing record. | |
221 | -- T is the type for which the actual subtype is required, and N is either | |
222 | -- a defining identifier, or any subexpression. | |
223 | ||
224 | function Build_Actual_Subtype_Of_Component | |
fbf5a39b AC |
225 | (T : Entity_Id; |
226 | N : Node_Id) return Node_Id; | |
996ae0b0 RK |
227 | -- Determine whether a selected component has a type that depends on |
228 | -- discriminants, and build actual subtype for it if so. | |
229 | ||
02848684 AC |
230 | -- Handling of inherited primitives whose ancestors have class-wide |
231 | -- pre/postconditions. | |
aaa0a838 | 232 | |
02848684 | 233 | -- If a primitive operation of a parent type has a class-wide pre/post- |
aaa0a838 ES |
234 | -- condition that includes calls to other primitives, and that operation |
235 | -- is inherited by a descendant type that also overrides some of these | |
236 | -- other primitives, the condition that applies to the inherited | |
237 | -- operation has a modified condition in which the overridden primitives | |
238 | -- have been replaced by the primitives of the descendent type. A call | |
239 | -- to the inherited operation cannot be simply a call to the parent | |
240 | -- operation (with an appropriate conversion) as is the case for other | |
241 | -- inherited operations, but must appear with a wrapper subprogram to which | |
242 | -- the modified conditions apply. Furthermore the call to the parent | |
243 | -- operation must not be subject to the original class-wide condition, | |
244 | -- given that modified conditions apply. To implement these semantics | |
245 | -- economically we create a subprogram body (a "class-wide clone") to | |
246 | -- which no pre/postconditions apply, and we create bodies for the | |
247 | -- original and the inherited operation that have their respective | |
02848684 | 248 | -- pre/postconditions and simply call the clone. The following operations |
aaa0a838 ES |
249 | -- take care of constructing declaration and body of the clone, and |
250 | -- building the calls to it within the appropriate wrappers. | |
251 | ||
252 | procedure Build_Class_Wide_Clone_Body | |
253 | (Spec_Id : Entity_Id; | |
254 | Bod : Node_Id); | |
255 | -- Build body of subprogram that has a class-wide condition that contains | |
256 | -- calls to other primitives. Spec_Id is the Id of the subprogram, and B | |
257 | -- is its source body, which becomes the body of the clone. | |
258 | ||
259 | function Build_Class_Wide_Clone_Call | |
260 | (Loc : Source_Ptr; | |
261 | Decls : List_Id; | |
262 | Spec_Id : Entity_Id; | |
263 | Spec : Node_Id) return Node_Id; | |
264 | -- Build a call to the common class-wide clone of a subprogram with | |
265 | -- class-wide conditions. The body of the subprogram becomes a wrapper | |
266 | -- for a call to the clone. The inherited operation becomes a similar | |
267 | -- wrapper to which modified conditions apply, and the call to the | |
268 | -- clone includes the proper conversion in a call the parent operation. | |
269 | ||
270 | procedure Build_Class_Wide_Clone_Decl (Spec_Id : Entity_Id); | |
02848684 | 271 | -- For a subprogram that has a class-wide condition that contains calls |
aaa0a838 ES |
272 | -- to other primitives, build an internal subprogram that is invoked |
273 | -- through a type-specific wrapper for all inherited subprograms that | |
274 | -- may have a modified condition. | |
275 | ||
9b0986f8 RD |
276 | function Build_Default_Subtype |
277 | (T : Entity_Id; | |
278 | N : Node_Id) return Entity_Id; | |
279 | -- If T is an unconstrained type with defaulted discriminants, build a | |
280 | -- subtype constrained by the default values, insert the subtype | |
281 | -- declaration in the tree before N, and return the entity of that | |
282 | -- subtype. Otherwise, simply return T. | |
283 | ||
996ae0b0 | 284 | function Build_Discriminal_Subtype_Of_Component |
fbf5a39b | 285 | (T : Entity_Id) return Node_Id; |
996ae0b0 RK |
286 | -- Determine whether a record component has a type that depends on |
287 | -- discriminants, and build actual subtype for it if so. | |
288 | ||
289 | procedure Build_Elaboration_Entity (N : Node_Id; Spec_Id : Entity_Id); | |
824e9320 | 290 | -- Given a compilation unit node N, allocate an elaboration counter for |
996ae0b0 RK |
291 | -- the compilation unit, and install it in the Elaboration_Entity field |
292 | -- of Spec_Id, the entity for the compilation unit. | |
293 | ||
a187206c AC |
294 | function Build_Overriding_Spec |
295 | (Op : Node_Id; | |
296 | Typ : Entity_Id) return Node_Id; | |
297 | -- Build a subprogram specification for the wrapper of an inherited | |
298 | -- operation with a modified pre- or postcondition (See AI12-0113). | |
299 | -- Op is the parent operation, and Typ is the descendant type that | |
300 | -- inherits the operation. | |
301 | ||
0812b84e AC |
302 | procedure Build_Explicit_Dereference |
303 | (Expr : Node_Id; | |
304 | Disc : Entity_Id); | |
305 | -- AI05-139: Names with implicit dereference. If the expression N is a | |
306 | -- reference type and the context imposes the corresponding designated | |
307 | -- type, convert N into N.Disc.all. Such expressions are always over- | |
308 | -- loaded with both interpretations, and the dereference interpretation | |
309 | -- carries the name of the reference discriminant. | |
3e24afaa | 310 | |
07fc65c4 GB |
311 | function Cannot_Raise_Constraint_Error (Expr : Node_Id) return Boolean; |
312 | -- Returns True if the expression cannot possibly raise Constraint_Error. | |
313 | -- The response is conservative in the sense that a result of False does | |
314 | -- not necessarily mean that CE could be raised, but a response of True | |
315 | -- means that for sure CE cannot be raised. | |
316 | ||
a7e68e7f HK |
317 | procedure Check_Dynamically_Tagged_Expression |
318 | (Expr : Node_Id; | |
319 | Typ : Entity_Id; | |
320 | Related_Nod : Node_Id); | |
321 | -- Check wrong use of dynamically tagged expression | |
322 | ||
323 | procedure Check_Fully_Declared (T : Entity_Id; N : Node_Id); | |
324 | -- Verify that the full declaration of type T has been seen. If not, place | |
325 | -- error message on node N. Used in object declarations, type conversions | |
326 | -- and qualified expressions. | |
327 | ||
879ac954 AC |
328 | procedure Check_Function_With_Address_Parameter (Subp_Id : Entity_Id); |
329 | -- A subprogram that has an Address parameter and is declared in a Pure | |
330 | -- package is not considered Pure, because the parameter may be used as a | |
331 | -- pointer and the referenced data may change even if the address value | |
332 | -- itself does not. | |
333 | -- If the programmer gave an explicit Pure_Function pragma, then we respect | |
334 | -- the pragma and leave the subprogram Pure. | |
335 | ||
d3820795 JM |
336 | procedure Check_Function_Writable_Actuals (N : Node_Id); |
337 | -- (Ada 2012): If the construct N has two or more direct constituents that | |
338 | -- are names or expressions whose evaluation may occur in an arbitrary | |
339 | -- order, at least one of which contains a function call with an in out or | |
340 | -- out parameter, then the construct is legal only if: for each name that | |
341 | -- is passed as a parameter of mode in out or out to some inner function | |
342 | -- call C2 (not including the construct N itself), there is no other name | |
343 | -- anywhere within a direct constituent of the construct C other than | |
344 | -- the one containing C2, that is known to refer to the same object (RM | |
345 | -- 6.4.1(6.17/3)). | |
346 | ||
71ff3d18 | 347 | procedure Check_Implicit_Dereference (N : Node_Id; Typ : Entity_Id); |
dedac3eb | 348 | -- AI05-139-2: Accessors and iterators for containers. This procedure |
44a10091 | 349 | -- checks whether T is a reference type, and if so it adds an interprettion |
71ff3d18 AC |
350 | -- to N whose type is the designated type of the reference_discriminant. |
351 | -- If N is a generalized indexing operation, the interpretation is added | |
352 | -- both to the corresponding function call, and to the indexing node. | |
44a10091 | 353 | |
c92e8586 AC |
354 | procedure Check_Internal_Protected_Use (N : Node_Id; Nam : Entity_Id); |
355 | -- Within a protected function, the current object is a constant, and | |
356 | -- internal calls to a procedure or entry are illegal. Similarly, other | |
357 | -- uses of a protected procedure in a renaming or a generic instantiation | |
358 | -- in the context of a protected function are illegal (AI05-0225). | |
359 | ||
23685ae6 AC |
360 | procedure Check_Later_Vs_Basic_Declarations |
361 | (Decls : List_Id; | |
362 | During_Parsing : Boolean); | |
363 | -- If During_Parsing is True, check for misplacement of later vs basic | |
364 | -- declarations in Ada 83. If During_Parsing is False, and the SPARK | |
365 | -- restriction is set, do the same: although SPARK 95 removes the | |
366 | -- distinction between initial and later declarative items, the distinction | |
367 | -- remains in the Examiner (JB01-005). Note that the Examiner does not | |
368 | -- count package declarations in later declarative items. | |
369 | ||
0812b84e AC |
370 | procedure Check_No_Hidden_State (Id : Entity_Id); |
371 | -- Determine whether object or state Id introduces a hidden state. If this | |
372 | -- is the case, emit an error. | |
373 | ||
847d950d HK |
374 | procedure Check_Nonvolatile_Function_Profile (Func_Id : Entity_Id); |
375 | -- Verify that the profile of nonvolatile function Func_Id does not contain | |
376 | -- effectively volatile parameters or return type. | |
377 | ||
22a4f9d5 AC |
378 | procedure Check_Part_Of_Reference (Var_Id : Entity_Id; Ref : Node_Id); |
379 | -- Verify the legality of reference Ref to variable Var_Id when the | |
380 | -- variable is a constituent of a single protected/task type. | |
381 | ||
996ae0b0 RK |
382 | procedure Check_Potentially_Blocking_Operation (N : Node_Id); |
383 | -- N is one of the statement forms that is a potentially blocking | |
c885d7a1 | 384 | -- operation. If it appears within a protected action, emit warning. |
996ae0b0 | 385 | |
8489c295 AC |
386 | procedure Check_Previous_Null_Procedure |
387 | (Decl : Node_Id; | |
388 | Prev : Entity_Id); | |
389 | -- A null procedure or a subprogram renaming can complete a previous | |
390 | -- declaration, unless that previous declaration is itself a null | |
391 | -- procedure. This must be treated specially because the analysis of | |
392 | -- the null procedure leaves the corresponding entity as having no | |
393 | -- completion, because its completion is provided by a generated body | |
394 | -- inserted after all other declarations. | |
395 | ||
c9d70ab1 AC |
396 | procedure Check_Result_And_Post_State (Subp_Id : Entity_Id); |
397 | -- Determine whether the contract of subprogram Subp_Id mentions attribute | |
398 | -- 'Result and it contains an expression that evaluates differently in pre- | |
399 | -- and post-state. | |
36eef04a | 400 | |
22a4f9d5 AC |
401 | procedure Check_State_Refinements |
402 | (Context : Node_Id; | |
403 | Is_Main_Unit : Boolean := False); | |
404 | -- Verify that all abstract states declared in a block statement, entry | |
405 | -- body, package body, protected body, subprogram body, task body, or a | |
406 | -- package declaration denoted by Context have proper refinement. Emit an | |
407 | -- error if this is not the case. Flag Is_Main_Unit should be set when | |
408 | -- Context denotes the main compilation unit. | |
409 | ||
879ac954 | 410 | procedure Check_Unused_Body_States (Body_Id : Entity_Id); |
e645cb39 AC |
411 | -- Verify that all abstract states and objects declared in the state space |
412 | -- of package body Body_Id are used as constituents. Emit an error if this | |
413 | -- is not the case. | |
879ac954 | 414 | |
ce4a6e84 RD |
415 | procedure Check_Unprotected_Access |
416 | (Context : Node_Id; | |
417 | Expr : Node_Id); | |
418 | -- Check whether the expression is a pointer to a protected component, | |
419 | -- and the context is external to the protected operation, to warn against | |
420 | -- a possible unlocked access to data. | |
421 | ||
00f45f30 AC |
422 | function Choice_List (N : Node_Id) return List_Id; |
423 | -- Utility to retrieve the choices of a Component_Association or the | |
424 | -- Discrete_Choices of an Iterated_Component_Association. For various | |
425 | -- reasons these nodes have a different structure even though they play | |
426 | -- similar roles in array aggregates. | |
427 | ||
e645cb39 AC |
428 | function Collect_Body_States (Body_Id : Entity_Id) return Elist_Id; |
429 | -- Gather the entities of all abstract states and objects declared in the | |
430 | -- body state space of package body Body_Id. | |
431 | ||
ce2b6ba5 JM |
432 | procedure Collect_Interfaces |
433 | (T : Entity_Id; | |
434 | Ifaces_List : out Elist_Id; | |
435 | Exclude_Parents : Boolean := False; | |
436 | Use_Full_View : Boolean := True); | |
9b0986f8 | 437 | -- Ada 2005 (AI-251): Collect whole list of abstract interfaces that are |
ce2b6ba5 JM |
438 | -- directly or indirectly implemented by T. Exclude_Parents is used to |
439 | -- avoid the addition of inherited interfaces to the generated list. | |
1b6c95c4 RD |
440 | -- Use_Full_View is used to collect the interfaces using the full-view |
441 | -- (if available). | |
9b0986f8 | 442 | |
f377c995 HK |
443 | procedure Collect_Interface_Components |
444 | (Tagged_Type : Entity_Id; | |
445 | Components_List : out Elist_Id); | |
446 | -- Ada 2005 (AI-251): Collect all the tag components associated with the | |
447 | -- secondary dispatch tables of a tagged type. | |
448 | ||
1b6c95c4 RD |
449 | procedure Collect_Interfaces_Info |
450 | (T : Entity_Id; | |
451 | Ifaces_List : out Elist_Id; | |
452 | Components_List : out Elist_Id; | |
453 | Tags_List : out Elist_Id); | |
454 | -- Ada 2005 (AI-251): Collect all the interfaces associated with T plus | |
455 | -- the record component and tag associated with each of these interfaces. | |
456 | -- On exit Ifaces_List, Components_List and Tags_List have the same number | |
457 | -- of elements, and elements at the same position on these tables provide | |
458 | -- information on the same interface type. | |
459 | ||
ea034236 AC |
460 | procedure Collect_Parents |
461 | (T : Entity_Id; | |
462 | List : out Elist_Id; | |
463 | Use_Full_View : Boolean := True); | |
464 | -- Collect all the parents of Typ. Use_Full_View is used to collect them | |
465 | -- using the full-view of private parents (if available). | |
466 | ||
996ae0b0 | 467 | function Collect_Primitive_Operations (T : Entity_Id) return Elist_Id; |
7c4b480f AC |
468 | -- Called upon type derivation and extension. We scan the declarative part |
469 | -- in which the type appears, and collect subprograms that have one | |
470 | -- subsidiary subtype of the type. These subprograms can only appear after | |
471 | -- the type itself. | |
996ae0b0 RK |
472 | |
473 | function Compile_Time_Constraint_Error | |
eb6b9c9b GD |
474 | (N : Node_Id; |
475 | Msg : String; | |
476 | Ent : Entity_Id := Empty; | |
477 | Loc : Source_Ptr := No_Location; | |
478 | Warn : Boolean := False; | |
479 | Extra_Msg : String := "") return Node_Id; | |
b8dc622e JM |
480 | -- This is similar to Apply_Compile_Time_Constraint_Error in that it |
481 | -- generates a warning (or error) message in the same manner, but it does | |
482 | -- not replace any nodes. For convenience, the function always returns its | |
483 | -- first argument. The message is a warning if the message ends with ?, or | |
7c4b480f | 484 | -- we are operating in Ada 83 mode, or the Warn parameter is set to True. |
eb6b9c9b GD |
485 | -- If Extra_Msg is not a null string, then it's associated with N and |
486 | -- emitted immediately after the main message (and before output of any | |
487 | -- message indicating that Constraint_Error will be raised). | |
996ae0b0 RK |
488 | |
489 | procedure Conditional_Delay (New_Ent, Old_Ent : Entity_Id); | |
315f0c42 AC |
490 | -- Sets the Has_Delayed_Freeze flag of New_Ent if the Delayed_Freeze flag |
491 | -- of Old_Ent is set and Old_Ent has not yet been Frozen (i.e. Is_Frozen is | |
492 | -- False). | |
996ae0b0 | 493 | |
a3068ca6 AC |
494 | function Copy_Component_List |
495 | (R_Typ : Entity_Id; | |
496 | Loc : Source_Ptr) return List_Id; | |
497 | -- Copy components from record type R_Typ that come from source. Used to | |
498 | -- create a new compatible record type. Loc is the source location assigned | |
499 | -- to the created nodes. | |
500 | ||
8d1fe980 AC |
501 | function Copy_Parameter_List (Subp_Id : Entity_Id) return List_Id; |
502 | -- Utility to create a parameter profile for a new subprogram spec, when | |
503 | -- the subprogram has a body that acts as spec. This is done for some cases | |
504 | -- of inlining, and for private protected ops. Also used to create bodies | |
505 | -- for stubbed subprograms. | |
506 | ||
0a3ec628 AC |
507 | procedure Copy_SPARK_Mode_Aspect (From : Node_Id; To : Node_Id); |
508 | -- Copy the SPARK_Mode aspect if present in the aspect specifications | |
509 | -- of node From to node To. On entry it is assumed that To does not have | |
510 | -- aspect specifications. If From has no aspects, the routine has no | |
511 | -- effect. | |
512 | ||
8d1fe980 AC |
513 | function Copy_Subprogram_Spec (Spec : Node_Id) return Node_Id; |
514 | -- Replicate a function or a procedure specification denoted by Spec. The | |
515 | -- resulting tree is an exact duplicate of the original tree. New entities | |
516 | -- are created for the unit name and the formal parameters. | |
517 | ||
65f7ed64 AC |
518 | function Corresponding_Generic_Type (T : Entity_Id) return Entity_Id; |
519 | -- If a type is a generic actual type, return the corresponding formal in | |
520 | -- the generic parent unit. There is no direct link in the tree for this | |
521 | -- attribute, except in the case of formal private and derived types. | |
522 | -- Possible optimization??? | |
523 | ||
996ae0b0 | 524 | function Current_Entity (N : Node_Id) return Entity_Id; |
b81a5940 | 525 | pragma Inline (Current_Entity); |
996ae0b0 RK |
526 | -- Find the currently visible definition for a given identifier, that is to |
527 | -- say the first entry in the visibility chain for the Chars of N. | |
528 | ||
529 | function Current_Entity_In_Scope (N : Node_Id) return Entity_Id; | |
530 | -- Find whether there is a previous definition for identifier N in the | |
531 | -- current scope. Because declarations for a scope are not necessarily | |
532 | -- contiguous (e.g. for packages) the first entry on the visibility chain | |
533 | -- for N is not necessarily in the current scope. | |
534 | ||
535 | function Current_Scope return Entity_Id; | |
536 | -- Get entity representing current scope | |
537 | ||
87fd6836 AC |
538 | function Current_Scope_No_Loops return Entity_Id; |
539 | -- Return the current scope ignoring internally generated loops | |
540 | ||
996ae0b0 RK |
541 | function Current_Subprogram return Entity_Id; |
542 | -- Returns current enclosing subprogram. If Current_Scope is a subprogram, | |
66bdcfd6 AC |
543 | -- then that is what is returned, otherwise the Enclosing_Subprogram of the |
544 | -- Current_Scope is returned. The returned value is Empty if this is called | |
545 | -- from a library package which is not within any subprogram. | |
996ae0b0 | 546 | |
d15f9422 | 547 | function Deepest_Type_Access_Level (Typ : Entity_Id) return Uint; |
996c8821 RD |
548 | -- Same as Type_Access_Level, except that if the type is the type of an Ada |
549 | -- 2012 stand-alone object of an anonymous access type, then return the | |
16b54914 | 550 | -- static accessibility level of the object. In that case, the dynamic |
996c8821 | 551 | -- accessibility level of the object may take on values in a range. The low |
50ef946c | 552 | -- bound of that range is returned by Type_Access_Level; this function |
f460d8f3 SB |
553 | -- yields the high bound of that range. Also differs from Type_Access_Level |
554 | -- in the case of a descendant of a generic formal type (returns Int'Last | |
555 | -- instead of 0). | |
d15f9422 | 556 | |
9aa357c7 | 557 | function Defining_Entity (N : Node_Id) return Entity_Id; |
7c4b480f AC |
558 | -- Given a declaration N, returns the associated defining entity. If the |
559 | -- declaration has a specification, the entity is obtained from the | |
560 | -- specification. If the declaration has a defining unit name, then the | |
561 | -- defining entity is obtained from the defining unit name ignoring any | |
562 | -- child unit prefixes. | |
02bb0765 AC |
563 | -- |
564 | -- Iterator loops also have a defining entity, which holds the list of | |
565 | -- local entities declared during loop expansion. These entities need | |
375cbc2b | 566 | -- debugging information, generated through Qualify_Entity_Names, and |
02bb0765 | 567 | -- the loop declaration must be placed in the table Name_Qualify_Units. |
996ae0b0 | 568 | |
c7732bbe EB |
569 | -- WARNING: There is a matching C declaration of this subprogram in fe.h |
570 | ||
fbf5a39b | 571 | function Denotes_Discriminant |
9b0986f8 RD |
572 | (N : Node_Id; |
573 | Check_Concurrent : Boolean := False) return Boolean; | |
7c4b480f AC |
574 | -- Returns True if node N is an Entity_Name node for a discriminant. If the |
575 | -- flag Check_Concurrent is true, function also returns true when N denotes | |
576 | -- the discriminal of the discriminant of a concurrent type. This is needed | |
577 | -- to disable some optimizations on private components of protected types, | |
578 | -- and constraint checks on entry families constrained by discriminants. | |
996ae0b0 | 579 | |
76b84bf0 | 580 | function Denotes_Same_Object (A1, A2 : Node_Id) return Boolean; |
02217452 | 581 | -- Detect suspicious overlapping between actuals in a call, when both are |
b3d18092 | 582 | -- writable (RM 2012 6.4.1(6.4/3)). |
02217452 | 583 | |
76b84bf0 AC |
584 | function Denotes_Same_Prefix (A1, A2 : Node_Id) return Boolean; |
585 | -- Functions to detect suspicious overlapping between actuals in a call, | |
27cdc66a | 586 | -- when one of them is writable. The predicates are those proposed in |
76b84bf0 | 587 | -- AI05-0144, to detect dangerous order dependence in complex calls. |
27cdc66a RD |
588 | -- I would add a parameter Warn which enables more extensive testing of |
589 | -- cases as we find appropriate when we are only warning ??? Or perhaps | |
590 | -- return an indication of (Error, Warn, OK) ??? | |
76b84bf0 | 591 | |
cb572b75 | 592 | function Denotes_Variable (N : Node_Id) return Boolean; |
2e43faea | 593 | -- Returns True if node N denotes a single variable without parentheses |
cb572b75 | 594 | |
996ae0b0 RK |
595 | function Depends_On_Discriminant (N : Node_Id) return Boolean; |
596 | -- Returns True if N denotes a discriminant or if N is a range, a subtype | |
597 | -- indication or a scalar subtype where one of the bounds is a | |
598 | -- discriminant. | |
599 | ||
600 | function Designate_Same_Unit | |
601 | (Name1 : Node_Id; | |
fbf5a39b | 602 | Name2 : Node_Id) return Boolean; |
3dfe4883 | 603 | -- Returns True if Name1 and Name2 designate the same unit name; each of |
7c4b480f AC |
604 | -- these names is supposed to be a selected component name, an expanded |
605 | -- name, a defining program unit name or an identifier. | |
996ae0b0 | 606 | |
7a71a7c4 AC |
607 | procedure Diagnose_Iterated_Component_Association (N : Node_Id); |
608 | -- Emit an error if iterated component association N is actually an illegal | |
609 | -- quantified expression lacking a quantifier. | |
610 | ||
c5b4738f AC |
611 | function Discriminated_Size (Comp : Entity_Id) return Boolean; |
612 | -- If a component size is not static then a warning will be emitted | |
613 | -- in Ravenscar or other restricted contexts. When a component is non- | |
614 | -- static because of a discriminant constraint we can specialize the | |
615 | -- warning by mentioning discriminants explicitly. This was created for | |
616 | -- private components of protected objects, but is generally useful when | |
8d45ce77 HK |
617 | -- restriction No_Implicit_Heap_Allocation is active. |
618 | ||
43fa58c2 JM |
619 | function Dynamic_Accessibility_Level (N : Node_Id) return Node_Id; |
620 | -- N should be an expression of an access type. Builds an integer literal | |
621 | -- except in cases involving anonymous access types, where accessibility | |
622 | -- levels are tracked at run time (access parameters and Ada 2012 stand- | |
623 | -- alone objects). | |
c5b4738f | 624 | |
d15f9422 AC |
625 | function Effective_Extra_Accessibility (Id : Entity_Id) return Entity_Id; |
626 | -- Same as Einfo.Extra_Accessibility except thtat object renames | |
627 | -- are looked through. | |
628 | ||
6c3c671e AC |
629 | function Effective_Reads_Enabled (Id : Entity_Id) return Boolean; |
630 | -- Given the entity of an abstract state or a variable, determine whether | |
631 | -- Id is subject to external property Effective_Reads and if it is, the | |
632 | -- related expression evaluates to True. | |
633 | ||
634 | function Effective_Writes_Enabled (Id : Entity_Id) return Boolean; | |
635 | -- Given the entity of an abstract state or a variable, determine whether | |
636 | -- Id is subject to external property Effective_Writes and if it is, the | |
637 | -- related expression evaluates to True. | |
638 | ||
c8957aae | 639 | function Enclosing_Comp_Unit_Node (N : Node_Id) return Node_Id; |
90a4b336 | 640 | -- Returns the enclosing N_Compilation_Unit node that is the root of a |
c8957aae AC |
641 | -- subtree containing N. |
642 | ||
cefce34c JM |
643 | function Enclosing_CPP_Parent (Typ : Entity_Id) return Entity_Id; |
644 | -- Returns the closest ancestor of Typ that is a CPP type. | |
645 | ||
ff1bedac | 646 | function Enclosing_Declaration (N : Node_Id) return Node_Id; |
7188885e | 647 | -- Returns the declaration node enclosing N (including possibly N itself), |
847d950d | 648 | -- if any, or Empty otherwise. |
ff1bedac | 649 | |
ca0eb951 | 650 | function Enclosing_Generic_Body (N : Node_Id) return Node_Id; |
7c4b480f AC |
651 | -- Returns the Node_Id associated with the innermost enclosing generic |
652 | -- body, if any. If none, then returns Empty. | |
996ae0b0 | 653 | |
ca0eb951 | 654 | function Enclosing_Generic_Unit (N : Node_Id) return Node_Id; |
7c4b480f AC |
655 | -- Returns the Node_Id associated with the innermost enclosing generic |
656 | -- unit, if any. If none, then returns Empty. | |
b8dc622e | 657 | |
8c5b2819 AC |
658 | function Enclosing_Lib_Unit_Entity |
659 | (E : Entity_Id := Current_Scope) return Entity_Id; | |
77237288 AC |
660 | -- Returns the entity of enclosing library unit node which is the root of |
661 | -- the current scope (which must not be Standard_Standard, and the caller | |
662 | -- is responsible for ensuring this condition) or other specified entity. | |
996ae0b0 | 663 | |
ff1bedac YM |
664 | function Enclosing_Lib_Unit_Node (N : Node_Id) return Node_Id; |
665 | -- Returns the N_Compilation_Unit node of the library unit that is directly | |
666 | -- or indirectly (through a subunit) at the root of a subtree containing | |
667 | -- N. This may be either the same as Enclosing_Comp_Unit_Node, or if | |
668 | -- Enclosing_Comp_Unit_Node returns a subunit, then the corresponding | |
669 | -- library unit. If no such item is found, returns Empty. | |
670 | ||
db72f10a AC |
671 | function Enclosing_Package (E : Entity_Id) return Entity_Id; |
672 | -- Utility function to return the Ada entity of the package enclosing | |
673 | -- the entity E, if any. Returns Empty if no enclosing package. | |
674 | ||
ff1bedac YM |
675 | function Enclosing_Package_Or_Subprogram (E : Entity_Id) return Entity_Id; |
676 | -- Returns the entity of the package or subprogram enclosing E, if any. | |
677 | -- Returns Empty if no enclosing package or subprogram. | |
678 | ||
996ae0b0 RK |
679 | function Enclosing_Subprogram (E : Entity_Id) return Entity_Id; |
680 | -- Utility function to return the Ada entity of the subprogram enclosing | |
681 | -- the entity E, if any. Returns Empty if no enclosing subprogram. | |
682 | ||
90e491a7 PMR |
683 | function End_Keyword_Location (N : Node_Id) return Source_Ptr; |
684 | -- Given block statement, entry body, package body, package declaration, | |
685 | -- protected body, [single] protected type declaration, subprogram body, | |
686 | -- task body, or [single] task type declaration N, return the closest | |
687 | -- source location of the "end" keyword. | |
688 | ||
996ae0b0 | 689 | procedure Ensure_Freeze_Node (E : Entity_Id); |
7c4b480f AC |
690 | -- Make sure a freeze node is allocated for entity E. If necessary, build |
691 | -- and initialize a new freeze node and set Has_Delayed_Freeze True for E. | |
996ae0b0 | 692 | |
b8dc622e | 693 | procedure Enter_Name (Def_Id : Entity_Id); |
996ae0b0 | 694 | -- Insert new name in symbol table of current scope with check for |
7c4b480f AC |
695 | -- duplications (error message is issued if a conflict is found). |
696 | -- Note: Enter_Name is not used for overloadable entities, instead these | |
697 | -- are entered using Sem_Ch6.Enter_Overloadable_Entity. | |
996ae0b0 | 698 | |
275d8313 | 699 | function Entity_Of (N : Node_Id) return Entity_Id; |
74a78a4f AC |
700 | -- Obtain the entity of arbitrary node N. If N is a renaming, return the |
701 | -- entity of the earliest renamed source abstract state or whole object. | |
8d45ce77 HK |
702 | -- If no suitable entity is available, return Empty. This routine carries |
703 | -- out actions that are tied to SPARK semantics. | |
275d8313 | 704 | |
69e6ee2f HK |
705 | function Exceptions_OK return Boolean; |
706 | -- Determine whether exceptions are allowed to be caught, propagated, or | |
707 | -- raised. | |
708 | ||
fbf5a39b | 709 | procedure Explain_Limited_Type (T : Entity_Id; N : Node_Id); |
7c4b480f AC |
710 | -- This procedure is called after issuing a message complaining about an |
711 | -- inappropriate use of limited type T. If useful, it adds additional | |
712 | -- continuation lines to the message explaining why type T is limited. | |
713 | -- Messages are placed at node N. | |
fbf5a39b | 714 | |
40bf00b1 AC |
715 | function Expression_Of_Expression_Function |
716 | (Subp : Entity_Id) return Node_Id; | |
717 | -- Return the expression of expression function Subp | |
718 | ||
039538bc AC |
719 | type Extensions_Visible_Mode is |
720 | (Extensions_Visible_None, | |
721 | -- Extensions_Visible does not yield a mode when SPARK_Mode is off. This | |
722 | -- value acts as a default in a non-SPARK compilation. | |
723 | ||
724 | Extensions_Visible_False, | |
725 | -- A value of "False" signifies that Extensions_Visible is either | |
726 | -- missing or the pragma is present and the value of its Boolean | |
727 | -- expression is False. | |
728 | ||
729 | Extensions_Visible_True); | |
730 | -- A value of "True" signifies that Extensions_Visible is present and | |
731 | -- the value of its Boolean expression is True. | |
732 | ||
733 | function Extensions_Visible_Status | |
734 | (Id : Entity_Id) return Extensions_Visible_Mode; | |
735 | -- Given the entity of a subprogram or formal parameter subject to pragma | |
736 | -- Extensions_Visible, return the Boolean value denoted by the expression | |
737 | -- of the pragma. | |
738 | ||
7f0e4cdb BD |
739 | procedure Find_Actual |
740 | (N : Node_Id; | |
741 | Formal : out Entity_Id; | |
742 | Call : out Node_Id); | |
1f145d79 | 743 | -- Determines if the node N is an actual parameter of a function or a |
e24329cd | 744 | -- procedure call. If so, then Formal points to the entity for the formal |
6320f5e1 AC |
745 | -- (Ekind is E_In_Parameter, E_Out_Parameter, or E_In_Out_Parameter) and |
746 | -- Call is set to the node for the corresponding call. If the node N is not | |
747 | -- an actual parameter then Formal and Call are set to Empty. | |
67ce0d7e | 748 | |
d7af5ea5 HK |
749 | function Find_Body_Discriminal |
750 | (Spec_Discriminant : Entity_Id) return Entity_Id; | |
751 | -- Given a discriminant of the record type that implements a task or | |
752 | -- protected type, return the discriminal of the corresponding discriminant | |
753 | -- of the actual concurrent type. | |
754 | ||
996ae0b0 RK |
755 | function Find_Corresponding_Discriminant |
756 | (Id : Node_Id; | |
fbf5a39b | 757 | Typ : Entity_Id) return Entity_Id; |
5a153b27 AC |
758 | -- Because discriminants may have different names in a generic unit and in |
759 | -- an instance, they are resolved positionally when possible. A reference | |
6ca9ec9c | 760 | -- to a discriminant carries the discriminant that it denotes when it is |
5a153b27 AC |
761 | -- analyzed. Subsequent uses of this id on a different type denotes the |
762 | -- discriminant at the same position in this new type. | |
996ae0b0 | 763 | |
8d9a1ba7 PMR |
764 | function Find_DIC_Type (Typ : Entity_Id) return Entity_Id; |
765 | -- Subsidiary to all Build_DIC_Procedure_xxx routines. Find the type which | |
766 | -- defines the Default_Initial_Condition pragma of type Typ. This is either | |
767 | -- Typ itself or a parent type when the pragma is inherited. | |
768 | ||
7edfb4c6 | 769 | function Find_Enclosing_Iterator_Loop (Id : Entity_Id) return Entity_Id; |
90e491a7 PMR |
770 | -- Find the nearest iterator loop which encloses arbitrary entity Id. If |
771 | -- such a loop exists, return the entity of its identifier (E_Loop scope), | |
772 | -- otherwise return Empty. | |
773 | ||
774 | function Find_Enclosing_Scope (N : Node_Id) return Entity_Id; | |
775 | -- Find the nearest scope which encloses arbitrary node N | |
7edfb4c6 | 776 | |
d436b30d AC |
777 | function Find_Loop_In_Conditional_Block (N : Node_Id) return Node_Id; |
778 | -- Find the nested loop statement in a conditional block. Loops subject to | |
779 | -- attribute 'Loop_Entry are transformed into blocks. Parts of the original | |
780 | -- loop are nested within the block. | |
781 | ||
f4cd2542 | 782 | procedure Find_Overlaid_Entity |
a7e68e7f | 783 | (N : Node_Id; |
f4cd2542 EB |
784 | Ent : out Entity_Id; |
785 | Off : out Boolean); | |
df3e68b1 HK |
786 | -- The node N should be an address representation clause. Determines if |
787 | -- the target expression is the address of an entity with an optional | |
788 | -- offset. If so, set Ent to the entity and, if there is an offset, set | |
789 | -- Off to True, otherwise to False. If N is not an address representation | |
f4cd2542 | 790 | -- clause, or if it is not possible to determine that the address is of |
df3e68b1 | 791 | -- this form, then set Ent to Empty. |
2642f998 | 792 | |
7f0e4cdb BD |
793 | function Find_Parameter_Type (Param : Node_Id) return Entity_Id; |
794 | -- Return the type of formal parameter Param as determined by its | |
795 | -- specification. | |
796 | ||
d7af5ea5 HK |
797 | -- The following type describes the placement of an arbitrary entity with |
798 | -- respect to SPARK visible / hidden state space. | |
799 | ||
800 | type State_Space_Kind is | |
801 | (Not_In_Package, | |
802 | -- An entity is not in the visible, private or body state space when | |
803 | -- the immediate enclosing construct is not a package. | |
804 | ||
805 | Visible_State_Space, | |
806 | -- An entity is in the visible state space when it appears immediately | |
807 | -- within the visible declarations of a package or when it appears in | |
808 | -- the visible state space of a nested package which in turn is declared | |
809 | -- in the visible declarations of an enclosing package: | |
810 | ||
811 | -- package Pack is | |
812 | -- Visible_Variable : ... | |
813 | -- package Nested | |
814 | -- with Abstract_State => Visible_State | |
815 | -- is | |
816 | -- Visible_Nested_Variable : ... | |
817 | -- end Nested; | |
818 | -- end Pack; | |
819 | ||
820 | -- Entities associated with a package instantiation inherit the state | |
821 | -- space from the instance placement: | |
822 | ||
823 | -- generic | |
824 | -- package Gen is | |
825 | -- Generic_Variable : ... | |
826 | -- end Gen; | |
827 | ||
828 | -- with Gen; | |
829 | -- package Pack is | |
830 | -- package Inst is new Gen; | |
831 | -- -- Generic_Variable is in the visible state space of Pack | |
832 | -- end Pack; | |
833 | ||
834 | Private_State_Space, | |
835 | -- An entity is in the private state space when it appears immediately | |
836 | -- within the private declarations of a package or when it appears in | |
837 | -- the visible state space of a nested package which in turn is declared | |
838 | -- in the private declarations of an enclosing package: | |
839 | ||
840 | -- package Pack is | |
841 | -- private | |
842 | -- Private_Variable : ... | |
843 | -- package Nested | |
844 | -- with Abstract_State => Private_State | |
845 | -- is | |
846 | -- Private_Nested_Variable : ... | |
847 | -- end Nested; | |
848 | -- end Pack; | |
849 | ||
850 | -- The same placement principle applies to package instantiations | |
851 | ||
852 | Body_State_Space); | |
853 | -- An entity is in the body state space when it appears immediately | |
854 | -- within the declarations of a package body or when it appears in the | |
855 | -- visible state space of a nested package which in turn is declared in | |
856 | -- the declarations of an enclosing package body: | |
857 | ||
858 | -- package body Pack is | |
859 | -- Body_Variable : ... | |
860 | -- package Nested | |
861 | -- with Abstract_State => Body_State | |
862 | -- is | |
863 | -- Body_Nested_Variable : ... | |
864 | -- end Nested; | |
865 | -- end Pack; | |
866 | ||
867 | -- The same placement principle applies to package instantiations | |
868 | ||
869 | procedure Find_Placement_In_State_Space | |
870 | (Item_Id : Entity_Id; | |
871 | Placement : out State_Space_Kind; | |
872 | Pack_Id : out Entity_Id); | |
873 | -- Determine the state space placement of an item. Item_Id denotes the | |
6a4f3b31 | 874 | -- entity of an abstract state, object, or package instantiation. Placement |
eb7d283d HK |
875 | -- captures the precise placement of the item in the enclosing state space. |
876 | -- If the state space is that of a package, Pack_Id denotes its entity, | |
877 | -- otherwise Pack_Id is Empty. | |
d7af5ea5 | 878 | |
59f7c716 JM |
879 | function Find_Primitive_Eq (Typ : Entity_Id) return Entity_Id; |
880 | -- Locate primitive equality for type if it exists. Return Empty if it is | |
881 | -- not available. | |
882 | ||
90e491a7 PMR |
883 | function Find_Specific_Type (CW : Entity_Id) return Entity_Id; |
884 | -- Find specific type of a class-wide type, and handle the case of an | |
885 | -- incomplete type coming either from a limited_with clause or from an | |
886 | -- incomplete type declaration. If resulting type is private return its | |
887 | -- full view. | |
888 | ||
2642f998 RD |
889 | function Find_Static_Alternative (N : Node_Id) return Node_Id; |
890 | -- N is a case statement whose expression is a compile-time value. | |
891 | -- Determine the alternative chosen, so that the code of non-selected | |
892 | -- alternatives, and the warnings that may apply to them, are removed. | |
893 | ||
996ae0b0 | 894 | function First_Actual (Node : Node_Id) return Node_Id; |
aafc151a AC |
895 | -- Node is an N_Function_Call, N_Procedure_Call_Statement or |
896 | -- N_Entry_Call_Statement node. The result returned is the first actual | |
897 | -- parameter in declaration order (not the order of parameters as they | |
898 | -- appeared in the source, which can be quite different as a result of the | |
899 | -- use of named parameters). Empty is returned for a call with no | |
900 | -- parameters. The procedure for iterating through the actuals in | |
901 | -- declaration order is to use this function to find the first actual, and | |
902 | -- then use Next_Actual to obtain the next actual in declaration order. | |
903 | -- Note that the value returned is always the expression (not the | |
904 | -- N_Parameter_Association nodes, even if named association is used). | |
996ae0b0 | 905 | |
c7732bbe EB |
906 | -- WARNING: There is a matching C declaration of this subprogram in fe.h |
907 | ||
fb69239a AC |
908 | function First_Global |
909 | (Subp : Entity_Id; | |
910 | Global_Mode : Name_Id; | |
911 | Refined : Boolean := False) return Node_Id; | |
912 | -- Returns the first global item of mode Global_Mode (which can be | |
913 | -- Name_Input, Name_Output, Name_In_Out or Name_Proof_In) associated to | |
914 | -- subprogram Subp, or Empty otherwise. If Refined is True, the global item | |
915 | -- is retrieved from the Refined_Global aspect/pragma associated to the | |
916 | -- body of Subp if present. Next_Global can be used to get the next global | |
917 | -- item with the same mode. | |
918 | ||
75b87c16 AC |
919 | function Fix_Msg (Id : Entity_Id; Msg : String) return String; |
920 | -- Replace all occurrences of a particular word in string Msg depending on | |
921 | -- the Ekind of Id as follows: | |
922 | -- * Replace "subprogram" with | |
923 | -- - "entry" when Id is an entry [family] | |
378dc6ca | 924 | -- - "task type" when Id is a single task object, task type or task |
75b87c16 AC |
925 | -- body. |
926 | -- * Replace "protected" with | |
927 | -- - "task" when Id is a single task object, task type or task body | |
928 | -- All other non-matching words remain as is | |
929 | ||
e1691d7e ES |
930 | function From_Nested_Package (T : Entity_Id) return Boolean; |
931 | -- A type declared in a nested package may be frozen by a declaration | |
932 | -- appearing after the package but before the package is frozen. If the | |
933 | -- type has aspects that generate subprograms, these may contain references | |
934 | -- to entities local to the nested package. In that case the package must | |
935 | -- be installed on the scope stack to prevent spurious visibility errors. | |
936 | ||
996ae0b0 RK |
937 | procedure Gather_Components |
938 | (Typ : Entity_Id; | |
939 | Comp_List : Node_Id; | |
940 | Governed_By : List_Id; | |
941 | Into : Elist_Id; | |
942 | Report_Errors : out Boolean); | |
9f4fd324 AC |
943 | -- The purpose of this procedure is to gather the valid components in a |
944 | -- record type according to the values of its discriminants, in order to | |
945 | -- validate the components of a record aggregate. | |
996ae0b0 RK |
946 | -- |
947 | -- Typ is the type of the aggregate when its constrained discriminants | |
948 | -- need to be collected, otherwise it is Empty. | |
949 | -- | |
950 | -- Comp_List is an N_Component_List node. | |
951 | -- | |
9f4fd324 AC |
952 | -- Governed_By is a list of N_Component_Association nodes, where each |
953 | -- choice list contains the name of a discriminant and the expression | |
954 | -- field gives its value. The values of the discriminants governing | |
955 | -- the (possibly nested) variant parts in Comp_List are found in this | |
956 | -- Component_Association List. | |
996ae0b0 | 957 | -- |
9f4fd324 AC |
958 | -- Into is the list where the valid components are appended. Note that |
959 | -- Into need not be an Empty list. If it's not, components are attached | |
960 | -- to its tail. | |
961 | -- | |
962 | -- Report_Errors is set to True if the values of the discriminants are | |
963 | -- non-static. | |
996ae0b0 | 964 | -- |
996ae0b0 RK |
965 | -- This procedure is also used when building a record subtype. If the |
966 | -- discriminant constraint of the subtype is static, the components of the | |
967 | -- subtype are only those of the variants selected by the values of the | |
968 | -- discriminants. Otherwise all components of the parent must be included | |
969 | -- in the subtype for semantic analysis. | |
970 | ||
43b26411 JS |
971 | function Get_Accessibility (E : Entity_Id) return Node_Id; |
972 | -- Obtain the accessibility level for a given entity formal taking into | |
973 | -- account both extra and minimum accessibility. | |
974 | ||
996ae0b0 RK |
975 | function Get_Actual_Subtype (N : Node_Id) return Entity_Id; |
976 | -- Given a node for an expression, obtain the actual subtype of the | |
977 | -- expression. In the case of a parameter where the formal is an | |
7c4b480f AC |
978 | -- unconstrained array or discriminated type, this will be the previously |
979 | -- constructed subtype of the actual. Note that this is not quite the | |
980 | -- "Actual Subtype" of the RM, since it is always a constrained type, i.e. | |
981 | -- it is the subtype of the value of the actual. The actual subtype is also | |
982 | -- returned in other cases where it has already been constructed for an | |
983 | -- object. Otherwise the expression type is returned unchanged, except for | |
984 | -- the case of an unconstrained array type, where an actual subtype is | |
985 | -- created, using Insert_Actions if necessary to insert any associated | |
986 | -- actions. | |
996ae0b0 RK |
987 | |
988 | function Get_Actual_Subtype_If_Available (N : Node_Id) return Entity_Id; | |
989 | -- This is like Get_Actual_Subtype, except that it never constructs an | |
990 | -- actual subtype. If an actual subtype is already available, i.e. the | |
991 | -- Actual_Subtype field of the corresponding entity is set, then it is | |
992 | -- returned. Otherwise the Etype of the node is returned. | |
993 | ||
60370fb1 | 994 | function Get_Body_From_Stub (N : Node_Id) return Node_Id; |
f145ece7 | 995 | -- Return the body node for a stub |
60370fb1 | 996 | |
110e2969 AC |
997 | function Get_Cursor_Type |
998 | (Aspect : Node_Id; | |
999 | Typ : Entity_Id) return Entity_Id; | |
90a4b336 YM |
1000 | -- Find Cursor type in scope of type Typ with Iterable aspect, by locating |
1001 | -- primitive operation First. For use in resolving the other primitive | |
1002 | -- operations of an Iterable type and expanding loops and quantified | |
1003 | -- expressions over formal containers. | |
1004 | ||
1005 | function Get_Cursor_Type (Typ : Entity_Id) return Entity_Id; | |
1006 | -- Find Cursor type in scope of type Typ with Iterable aspect, by locating | |
1007 | -- primitive operation First. For use after resolving the primitive | |
1008 | -- operations of an Iterable type. | |
110e2969 | 1009 | |
996ae0b0 RK |
1010 | function Get_Default_External_Name (E : Node_Or_Entity_Id) return Node_Id; |
1011 | -- This is used to construct the string literal node representing a | |
7c4b480f | 1012 | -- default external name, i.e. one that is constructed from the name of an |
ae93ccb2 | 1013 | -- entity, or (in the case of extended DEC import/export pragmas) an |
7c4b480f | 1014 | -- identifier provided as the external name. Letters in the name are |
996ae0b0 RK |
1015 | -- according to the setting of Opt.External_Name_Default_Casing. |
1016 | ||
c2db4b32 AC |
1017 | function Get_Enclosing_Object (N : Node_Id) return Entity_Id; |
1018 | -- If expression N references a part of an object, return this object. | |
1019 | -- Otherwise return Empty. Expression N should have been resolved already. | |
1020 | ||
07fc65c4 | 1021 | function Get_Generic_Entity (N : Node_Id) return Entity_Id; |
7c4b480f AC |
1022 | -- Returns the true generic entity in an instantiation. If the name in the |
1023 | -- instantiation is a renaming, the function returns the renamed generic. | |
07fc65c4 | 1024 | |
e6425869 AC |
1025 | function Get_Incomplete_View_Of_Ancestor (E : Entity_Id) return Entity_Id; |
1026 | -- Implements the notion introduced ever-so briefly in RM 7.3.1 (5.2/3): | |
1027 | -- in a child unit a derived type is within the derivation class of an | |
1028 | -- ancestor declared in a parent unit, even if there is an intermediate | |
1029 | -- derivation that does not see the full view of that ancestor. | |
1030 | ||
42e2600a | 1031 | procedure Get_Index_Bounds |
c63a2ad6 AC |
1032 | (N : Node_Id; |
1033 | L : out Node_Id; | |
1034 | H : out Node_Id; | |
42e2600a | 1035 | Use_Full_View : Boolean := False); |
7c4b480f AC |
1036 | -- This procedure assigns to L and H respectively the values of the low and |
1037 | -- high bounds of node N, which must be a range, subtype indication, or the | |
1038 | -- name of a scalar subtype. The result in L, H may be set to Error if | |
1039 | -- there was an earlier error in the range. | |
42e2600a AC |
1040 | -- Use_Full_View is intended for use by clients other than the compiler |
1041 | -- (specifically, gnat2scil) to indicate that we want the full view if | |
c63a2ad6 AC |
1042 | -- the index type turns out to be a partial view; this case should not |
1043 | -- arise during normal compilation of semantically correct programs. | |
996ae0b0 | 1044 | |
f4f5851e AC |
1045 | procedure Get_Interfacing_Aspects |
1046 | (Iface_Asp : Node_Id; | |
1047 | Conv_Asp : out Node_Id; | |
1048 | EN_Asp : out Node_Id; | |
1049 | Expo_Asp : out Node_Id; | |
1050 | Imp_Asp : out Node_Id; | |
1051 | LN_Asp : out Node_Id; | |
1052 | Do_Checks : Boolean := False); | |
1053 | -- Given a single interfacing aspect Iface_Asp, retrieve other interfacing | |
1054 | -- aspects that apply to the same related entity. The aspects considered by | |
1055 | -- this routine are as follows: | |
1056 | -- | |
1057 | -- Conv_Asp - aspect Convention | |
1058 | -- EN_Asp - aspect External_Name | |
1059 | -- Expo_Asp - aspect Export | |
1060 | -- Imp_Asp - aspect Import | |
1061 | -- LN_Asp - aspect Link_Name | |
1062 | -- | |
1063 | -- When flag Do_Checks is set, this routine will flag duplicate uses of | |
1064 | -- aspects. | |
1065 | ||
996ae0b0 | 1066 | function Get_Enum_Lit_From_Pos |
fbf5a39b AC |
1067 | (T : Entity_Id; |
1068 | Pos : Uint; | |
497b37ad | 1069 | Loc : Source_Ptr) return Node_Id; |
1d10f669 AC |
1070 | -- This function returns an identifier denoting the E_Enumeration_Literal |
1071 | -- entity for the specified value from the enumeration type or subtype T. | |
7727a9c1 AC |
1072 | -- The second argument is the Pos value. Constraint_Error is raised if |
1073 | -- argument Pos is not in range. The third argument supplies a source | |
1074 | -- location for constructed nodes returned by this function. If No_Location | |
1075 | -- is supplied as source location, the location of the returned node is | |
1076 | -- copied from the original source location for the enumeration literal, | |
1077 | -- when available. | |
996ae0b0 | 1078 | |
dd2bf554 ES |
1079 | function Get_Iterable_Type_Primitive |
1080 | (Typ : Entity_Id; | |
1081 | Nam : Name_Id) return Entity_Id; | |
1082 | -- Retrieve one of the primitives First, Next, Has_Element, Element from | |
2eda24e9 | 1083 | -- the value of the Iterable aspect of a type. |
dd2bf554 | 1084 | |
1735e55d AC |
1085 | procedure Get_Library_Unit_Name_String (Decl_Node : Node_Id); |
1086 | -- Retrieve the fully expanded name of the library unit declared by | |
1087 | -- Decl_Node into the name buffer. | |
1088 | ||
442d1abb AC |
1089 | function Get_Max_Queue_Length (Id : Entity_Id) return Uint; |
1090 | -- Return the argument of pragma Max_Queue_Length or zero if the annotation | |
1091 | -- is not present. It is assumed that Id denotes an entry. | |
1092 | ||
996ae0b0 | 1093 | function Get_Name_Entity_Id (Id : Name_Id) return Entity_Id; |
b81a5940 | 1094 | pragma Inline (Get_Name_Entity_Id); |
996ae0b0 | 1095 | -- An entity value is associated with each name in the name table. The |
7c4b480f AC |
1096 | -- Get_Name_Entity_Id function fetches the Entity_Id of this entity, which |
1097 | -- is the innermost visible entity with the given name. See the body of | |
1098 | -- Sem_Ch8 for further details on handling of entity visibility. | |
996ae0b0 | 1099 | |
ce6002ec | 1100 | function Get_Name_From_CTC_Pragma (N : Node_Id) return String_Id; |
ddb8a2c7 | 1101 | -- Return the Name component of Test_Case pragma N |
1a83142e | 1102 | -- Bad name now that this no longer applies to Contract_Case ??? |
1bf773bb | 1103 | |
4887624e AC |
1104 | function Get_Parent_Entity (Unit : Node_Id) return Entity_Id; |
1105 | -- Get defining entity of parent unit of a child unit. In most cases this | |
1106 | -- is the defining entity of the unit, but for a child instance whose | |
1107 | -- parent needs a body for inlining, the instantiation node of the parent | |
1108 | -- has not yet been rewritten as a package declaration, and the entity has | |
1109 | -- to be retrieved from the Instance_Spec of the unit. | |
1110 | ||
7e5e5cc7 RD |
1111 | function Get_Pragma_Id (N : Node_Id) return Pragma_Id; |
1112 | pragma Inline (Get_Pragma_Id); | |
6e759c2a | 1113 | -- Obtains the Pragma_Id from Pragma_Name_Unmapped (N) |
7e5e5cc7 | 1114 | |
32b794c8 AC |
1115 | function Get_Qualified_Name |
1116 | (Id : Entity_Id; | |
1117 | Suffix : Entity_Id := Empty) return Name_Id; | |
1118 | -- Obtain the fully qualified form of entity Id. The format is: | |
1119 | -- scope_of_id-1__scope_of_id__chars_of_id__chars_of_suffix | |
1120 | ||
1121 | function Get_Qualified_Name | |
1122 | (Nam : Name_Id; | |
1123 | Suffix : Name_Id := No_Name; | |
1124 | Scop : Entity_Id := Current_Scope) return Name_Id; | |
1125 | -- Obtain the fully qualified form of name Nam assuming it appears in scope | |
1126 | -- Scop. The format is: | |
1127 | -- scop-1__scop__nam__suffix | |
1128 | ||
0c7e0c32 AC |
1129 | procedure Get_Reason_String (N : Node_Id); |
1130 | -- Recursive routine to analyze reason argument for pragma Warnings. The | |
1131 | -- value of the reason argument is appended to the current string using | |
1132 | -- Store_String_Chars. The reason argument is expected to be a string | |
1133 | -- literal or concatenation of string literals. An error is given for | |
1134 | -- any other form. | |
1135 | ||
65cddf36 | 1136 | function Get_Reference_Discriminant (Typ : Entity_Id) return Entity_Id; |
00c93ba2 AC |
1137 | -- If Typ has Implicit_Dereference, return discriminant specified in the |
1138 | -- corresponding aspect. | |
65cddf36 | 1139 | |
7e5e5cc7 | 1140 | function Get_Referenced_Object (N : Node_Id) return Node_Id; |
9b95ecdf GD |
1141 | -- Given an arbitrary node, return the renamed object if the node |
1142 | -- represents a renamed object; otherwise return the node unchanged. | |
1143 | -- The node can represent an arbitrary expression or any other kind of | |
1144 | -- node (such as the name of a type). | |
7e5e5cc7 | 1145 | |
f377c995 HK |
1146 | function Get_Renamed_Entity (E : Entity_Id) return Entity_Id; |
1147 | -- Given an entity for an exception, package, subprogram or generic unit, | |
1148 | -- returns the ultimately renamed entity if this is a renaming. If this is | |
1149 | -- not a renamed entity, returns its argument. It is an error to call this | |
16b05213 | 1150 | -- with any other kind of entity. |
f377c995 | 1151 | |
90a4b336 YM |
1152 | function Get_Return_Object (N : Node_Id) return Entity_Id; |
1153 | -- Given an extended return statement, return the corresponding return | |
1154 | -- object, identified as the one for which Is_Return_Object = True. | |
1155 | ||
9b0986f8 | 1156 | function Get_Subprogram_Entity (Nod : Node_Id) return Entity_Id; |
7c4b480f AC |
1157 | -- Nod is either a procedure call statement, or a function call, or an |
1158 | -- accept statement node. This procedure finds the Entity_Id of the related | |
1159 | -- subprogram or entry and returns it, or if no subprogram can be found, | |
1160 | -- returns Empty. | |
9b0986f8 | 1161 | |
90e491a7 | 1162 | function Get_Task_Body_Procedure (E : Entity_Id) return Entity_Id; |
996ae0b0 | 1163 | -- Given an entity for a task type or subtype, retrieves the |
7c4b480f | 1164 | -- Task_Body_Procedure field from the corresponding task type declaration. |
996ae0b0 | 1165 | |
90a4b336 YM |
1166 | function Get_User_Defined_Eq (E : Entity_Id) return Entity_Id; |
1167 | -- For a type entity, return the entity of the primitive equality function | |
1168 | -- for the type if it exists, otherwise return Empty. | |
1169 | ||
3ddfabe3 AC |
1170 | procedure Get_Views |
1171 | (Typ : Entity_Id; | |
1172 | Priv_Typ : out Entity_Id; | |
1173 | Full_Typ : out Entity_Id; | |
1174 | Full_Base : out Entity_Id; | |
1175 | CRec_Typ : out Entity_Id); | |
1176 | -- Obtain the partial and full view of type Typ and in addition any extra | |
1177 | -- types the full view may have. The return entities are as follows: | |
1178 | -- | |
1179 | -- Priv_Typ - the partial view (a private type) | |
1180 | -- Full_Typ - the full view | |
1181 | -- Full_Base - the base type of the full view | |
1182 | -- CRec_Typ - the corresponding record type of the full view | |
1183 | ||
15ce9ca2 | 1184 | function Has_Access_Values (T : Entity_Id) return Boolean; |
ce4a6e84 RD |
1185 | -- Returns true if type or subtype T is an access type, or has a component |
1186 | -- (at any recursive level) that is an access type. This is a conservative | |
1187 | -- predicate, if it is not known whether or not T contains access values | |
1188 | -- (happens for generic formals in some cases), then False is returned. | |
1189 | -- Note that tagged types return False. Even though the tag is implemented | |
1190 | -- as an access type internally, this function tests only for access types | |
1191 | -- known to the programmer. See also Has_Tagged_Component. | |
15ce9ca2 | 1192 | |
9b0986f8 RD |
1193 | type Alignment_Result is (Known_Compatible, Unknown, Known_Incompatible); |
1194 | -- Result of Has_Compatible_Alignment test, description found below. Note | |
1195 | -- that the values are arranged in increasing order of problematicness. | |
1196 | ||
9b0986f8 | 1197 | function Has_Compatible_Alignment |
e9c12b91 AC |
1198 | (Obj : Entity_Id; |
1199 | Expr : Node_Id; | |
1200 | Layout_Done : Boolean) return Alignment_Result; | |
9b0986f8 RD |
1201 | -- Obj is an object entity, and expr is a node for an object reference. If |
1202 | -- the alignment of the object referenced by Expr is known to be compatible | |
1203 | -- with the alignment of Obj (i.e. is larger or the same), then the result | |
1204 | -- is Known_Compatible. If the alignment of the object referenced by Expr | |
1205 | -- is known to be less than the alignment of Obj, then Known_Incompatible | |
1206 | -- is returned. If neither condition can be reliably established at compile | |
e9c12b91 AC |
1207 | -- time, then Unknown is returned. If Layout_Done is True, the function can |
1208 | -- assume that the information on size and alignment of types and objects | |
1209 | -- is present in the tree. This is used to determine if alignment checks | |
1210 | -- are required for address clauses (Layout_Done is False in this case) as | |
1211 | -- well as to issue appropriate warnings for them in the post compilation | |
1212 | -- phase (Layout_Done is True in this case). | |
9b0986f8 RD |
1213 | -- |
1214 | -- Note: Known_Incompatible does not mean that at run time the alignment | |
1215 | -- of Expr is known to be wrong for Obj, just that it can be determined | |
7c4b480f AC |
1216 | -- that alignments have been explicitly or implicitly specified which are |
1217 | -- incompatible (whereas Unknown means that even this is not known). The | |
1218 | -- appropriate reaction of a caller to Known_Incompatible is to treat it as | |
1219 | -- Unknown, but issue a warning that there may be an alignment error. | |
9b0986f8 | 1220 | |
7324bf49 AC |
1221 | function Has_Declarations (N : Node_Id) return Boolean; |
1222 | -- Determines if the node can have declarations | |
1223 | ||
75b87c16 AC |
1224 | function Has_Defaulted_Discriminants (Typ : Entity_Id) return Boolean; |
1225 | -- Simple predicate to test for defaulted discriminants | |
1226 | ||
b887f1a0 AC |
1227 | function Has_Denormals (E : Entity_Id) return Boolean; |
1228 | -- Determines if the floating-point type E supports denormal numbers. | |
1229 | -- Returns False if E is not a floating-point type. | |
1230 | ||
edd63e9b ES |
1231 | function Has_Discriminant_Dependent_Constraint |
1232 | (Comp : Entity_Id) return Boolean; | |
7c4b480f AC |
1233 | -- Returns True if and only if Comp has a constrained subtype that depends |
1234 | -- on a discriminant. | |
edd63e9b | 1235 | |
576da1ea HK |
1236 | function Has_Effectively_Volatile_Profile |
1237 | (Subp_Id : Entity_Id) return Boolean; | |
1238 | -- Determine whether subprogram Subp_Id has an effectively volatile formal | |
1239 | -- parameter or returns an effectively volatile value. | |
1240 | ||
1f55088d AC |
1241 | function Has_Full_Default_Initialization (Typ : Entity_Id) return Boolean; |
1242 | -- Determine whether type Typ defines "full default initialization" as | |
1243 | -- specified by SPARK RM 3.1. To qualify as such, the type must be | |
1244 | -- * A scalar type with specified Default_Value | |
1245 | -- * An array-of-scalar type with specified Default_Component_Value | |
1246 | -- * An array type whose element type defines full default initialization | |
1247 | -- * A protected type, record type or type extension whose components | |
1248 | -- either include a default expression or have a type which defines | |
1249 | -- full default initialization. In the case of type extensions, the | |
1250 | -- parent type defines full default initialization. | |
b3801819 PMR |
1251 | -- * A task type |
1252 | -- * A private type with pragma Default_Initial_Condition that provides | |
1253 | -- full default initialization. | |
1254 | ||
1255 | function Has_Fully_Default_Initializing_DIC_Pragma | |
1256 | (Typ : Entity_Id) return Boolean; | |
1257 | -- Determine whether type Typ has a suitable Default_Initial_Condition | |
1258 | -- pragma which provides the full default initialization of the type. | |
1f55088d | 1259 | |
996ae0b0 RK |
1260 | function Has_Infinities (E : Entity_Id) return Boolean; |
1261 | -- Determines if the range of the floating-point type E includes | |
1262 | -- infinities. Returns False if E is not a floating-point type. | |
1263 | ||
ce2b6ba5 JM |
1264 | function Has_Interfaces |
1265 | (T : Entity_Id; | |
1266 | Use_Full_View : Boolean := True) return Boolean; | |
1267 | -- Where T is a concurrent type or a record type, returns true if T covers | |
1268 | -- any abstract interface types. In case of private types the argument | |
1269 | -- Use_Full_View controls if the check is done using its full view (if | |
1270 | -- available). | |
1271 | ||
442d1abb AC |
1272 | function Has_Max_Queue_Length (Id : Entity_Id) return Boolean; |
1273 | -- Determine whether Id is subject to pragma Max_Queue_Length. It is | |
1274 | -- assumed that Id denotes an entry. | |
1275 | ||
82893775 AC |
1276 | function Has_No_Obvious_Side_Effects (N : Node_Id) return Boolean; |
1277 | -- This is a simple minded function for determining whether an expression | |
1278 | -- has no obvious side effects. It is used only for determining whether | |
1279 | -- warnings are needed in certain situations, and is not guaranteed to | |
1280 | -- be accurate in either direction. Exceptions may mean an expression | |
1281 | -- does in fact have side effects, but this may be ignored and True is | |
1282 | -- returned, or a complex expression may in fact be side effect free | |
1283 | -- but we don't recognize it here and return False. The Side_Effect_Free | |
1284 | -- routine in Remove_Side_Effects is much more extensive and perhaps could | |
1285 | -- be shared, so that this routine would be more accurate. | |
1286 | ||
2f54ef3d AC |
1287 | function Has_Non_Null_Refinement (Id : Entity_Id) return Boolean; |
1288 | -- Determine whether abstract state Id has at least one nonnull constituent | |
1289 | -- as expressed in pragma Refined_State. This function does not take into | |
1290 | -- account the visible refinement region of abstract state Id. | |
1291 | ||
90e491a7 PMR |
1292 | function Has_Non_Trivial_Precondition (Subp : Entity_Id) return Boolean; |
1293 | -- Determine whether subprogram Subp has a class-wide precondition that is | |
1294 | -- not statically True. | |
7782ff67 | 1295 | |
90e491a7 PMR |
1296 | function Has_Null_Body (Proc_Id : Entity_Id) return Boolean; |
1297 | -- Determine whether the body of procedure Proc_Id contains a sole null | |
1298 | -- statement, possibly followed by an optional return. Used to optimize | |
1299 | -- useless calls to assertion checks. | |
321c24f7 | 1300 | |
9b0986f8 RD |
1301 | function Has_Null_Exclusion (N : Node_Id) return Boolean; |
1302 | -- Determine whether node N has a null exclusion | |
1303 | ||
2f54ef3d AC |
1304 | function Has_Null_Refinement (Id : Entity_Id) return Boolean; |
1305 | -- Determine whether abstract state Id has a null refinement as expressed | |
1306 | -- in pragma Refined_State. This function does not take into account the | |
1307 | -- visible refinement region of abstract state Id. | |
1308 | ||
56af8688 PMR |
1309 | function Has_Non_Null_Statements (L : List_Id) return Boolean; |
1310 | -- Return True if L has non-null statements | |
1311 | ||
ce4a6e84 RD |
1312 | function Has_Overriding_Initialize (T : Entity_Id) return Boolean; |
1313 | -- Predicate to determine whether a controlled type has a user-defined | |
c228a069 AC |
1314 | -- Initialize primitive (and, in Ada 2012, whether that primitive is |
1315 | -- non-null), which causes the type to not have preelaborable | |
1316 | -- initialization. | |
ce4a6e84 | 1317 | |
9b0986f8 | 1318 | function Has_Preelaborable_Initialization (E : Entity_Id) return Boolean; |
de5cd98e | 1319 | -- Return True iff type E has preelaborable initialization as defined in |
9b0986f8 RD |
1320 | -- Ada 2005 (see AI-161 for details of the definition of this attribute). |
1321 | ||
4bde5d8c JM |
1322 | function Has_Prefix (N : Node_Id) return Boolean; |
1323 | -- Return True if N has attribute Prefix | |
1324 | ||
996ae0b0 RK |
1325 | function Has_Private_Component (Type_Id : Entity_Id) return Boolean; |
1326 | -- Check if a type has a (sub)component of a private type that has not | |
1327 | -- yet received a full declaration. | |
1328 | ||
b887f1a0 AC |
1329 | function Has_Signed_Zeros (E : Entity_Id) return Boolean; |
1330 | -- Determines if the floating-point type E supports signed zeros. | |
1331 | -- Returns False if E is not a floating-point type. | |
1332 | ||
c9d70ab1 AC |
1333 | function Has_Significant_Contract (Subp_Id : Entity_Id) return Boolean; |
1334 | -- Determine whether subprogram [body] Subp_Id has a significant contract. | |
1335 | -- All subprograms have a N_Contract node, but this does not mean that the | |
1336 | -- contract is useful. | |
1337 | ||
e280f981 AC |
1338 | function Has_Static_Array_Bounds (Typ : Node_Id) return Boolean; |
1339 | -- Return whether an array type has static bounds | |
1340 | ||
529749b9 HK |
1341 | function Has_Static_Non_Empty_Array_Bounds (Typ : Node_Id) return Boolean; |
1342 | -- Determine whether array type Typ has static non-empty bounds | |
1343 | ||
1735e55d | 1344 | function Has_Stream (T : Entity_Id) return Boolean; |
7c4b480f AC |
1345 | -- Tests if type T is derived from Ada.Streams.Root_Stream_Type, or in the |
1346 | -- case of a composite type, has a component for which this predicate is | |
1347 | -- True, and if so returns True. Otherwise a result of False means that | |
1348 | -- there is no Stream type in sight. For a private type, the test is | |
1349 | -- applied to the underlying type (or returns False if there is no | |
1350 | -- underlying type). | |
1735e55d | 1351 | |
cefce34c JM |
1352 | function Has_Suffix (E : Entity_Id; Suffix : Character) return Boolean; |
1353 | -- Returns true if the last character of E is Suffix. Used in Assertions. | |
1354 | ||
996ae0b0 | 1355 | function Has_Tagged_Component (Typ : Entity_Id) return Boolean; |
f0478a53 AC |
1356 | -- Returns True if Typ is a composite type (array or record) that is either |
1357 | -- a tagged type or has a subcomponent that is tagged. Returns False for a | |
1358 | -- noncomposite type, or if no tagged subcomponents are present. This | |
1359 | -- function is used to check if "=" has to be expanded into a bunch | |
1360 | -- component comparisons. | |
996ae0b0 | 1361 | |
e645cb39 AC |
1362 | function Has_Undefined_Reference (Expr : Node_Id) return Boolean; |
1363 | -- Given arbitrary expression Expr, determine whether it contains at | |
1364 | -- least one name whose entity is Any_Id. | |
1365 | ||
f1bd0415 | 1366 | function Has_Volatile_Component (Typ : Entity_Id) return Boolean; |
e645cb39 | 1367 | -- Given arbitrary type Typ, determine whether it contains at least one |
f1bd0415 AC |
1368 | -- volatile component. |
1369 | ||
bfae1846 AC |
1370 | function Implementation_Kind (Subp : Entity_Id) return Name_Id; |
1371 | -- Subp is a subprogram marked with pragma Implemented. Return the specific | |
1372 | -- implementation requirement which the pragma imposes. The return value is | |
1373 | -- either Name_By_Any, Name_By_Entry or Name_By_Protected_Procedure. | |
1374 | ||
ce2b6ba5 JM |
1375 | function Implements_Interface |
1376 | (Typ_Ent : Entity_Id; | |
1377 | Iface_Ent : Entity_Id; | |
1378 | Exclude_Parents : Boolean := False) return Boolean; | |
bfae1846 | 1379 | -- Returns true if the Typ_Ent implements interface Iface_Ent |
ce2b6ba5 | 1380 | |
2c9f8c0a | 1381 | function In_Assertion_Expression_Pragma (N : Node_Id) return Boolean; |
d566e90a HK |
1382 | -- Returns True if node N appears within a pragma that acts as an assertion |
1383 | -- expression. See Sem_Prag for the list of qualifying pragmas. | |
2c9f8c0a | 1384 | |
ca0eb951 AC |
1385 | function In_Generic_Scope (E : Entity_Id) return Boolean; |
1386 | -- Returns True if entity E is inside a generic scope | |
1387 | ||
996ae0b0 | 1388 | function In_Instance return Boolean; |
bf7c85c9 | 1389 | -- Returns True if the current scope is within a generic instance |
996ae0b0 RK |
1390 | |
1391 | function In_Instance_Body return Boolean; | |
1392 | -- Returns True if current scope is within the body of an instance, where | |
1393 | -- several semantic checks (e.g. accessibility checks) are relaxed. | |
1394 | ||
1395 | function In_Instance_Not_Visible return Boolean; | |
1396 | -- Returns True if current scope is with the private part or the body of | |
1397 | -- an instance. Other semantic checks are suppressed in this context. | |
1398 | ||
90e491a7 PMR |
1399 | function In_Instance_Visible_Part |
1400 | (Id : Entity_Id := Current_Scope) return Boolean; | |
1401 | -- Returns True if arbitrary entity Id is within the visible part of a | |
1402 | -- package instance, where several additional semantic checks apply. | |
996ae0b0 | 1403 | |
fbf5a39b AC |
1404 | function In_Package_Body return Boolean; |
1405 | -- Returns True if current scope is within a package body | |
1406 | ||
87e9b935 RD |
1407 | function In_Pragma_Expression (N : Node_Id; Nam : Name_Id) return Boolean; |
1408 | -- Returns true if the expression N occurs within a pragma with name Nam | |
1409 | ||
d566e90a HK |
1410 | function In_Pre_Post_Condition (N : Node_Id) return Boolean; |
1411 | -- Returns True if node N appears within a pre/postcondition pragma. Note | |
1412 | -- the pragma Check equivalents are NOT considered. | |
1413 | ||
85ee7b49 YM |
1414 | function In_Quantified_Expression (N : Node_Id) return Boolean; |
1415 | -- Returns true if the expression N occurs within a quantified expression | |
1416 | ||
75965852 AC |
1417 | function In_Reverse_Storage_Order_Object (N : Node_Id) return Boolean; |
1418 | -- Returns True if N denotes a component or subcomponent in a record or | |
1419 | -- array that has Reverse_Storage_Order. | |
8c5b2819 | 1420 | |
eaf51442 JS |
1421 | function In_Same_Declarative_Part |
1422 | (Context : Node_Id; | |
1423 | N : Node_Id) return Boolean; | |
1424 | -- True if the node N appears within the same declarative part denoted by | |
1425 | -- the node Context. | |
1426 | ||
996ae0b0 | 1427 | function In_Subprogram_Or_Concurrent_Unit return Boolean; |
7c4b480f | 1428 | -- Determines if the current scope is within a subprogram compilation unit |
87e9b935 RD |
1429 | -- (inside a subprogram declaration, subprogram body, or generic subprogram |
1430 | -- declaration) or within a task or protected body. The test is for | |
1431 | -- appearing anywhere within such a construct (that is it does not need | |
7c4b480f | 1432 | -- to be directly within). |
996ae0b0 | 1433 | |
90e491a7 | 1434 | function In_Subtree (N : Node_Id; Root : Node_Id) return Boolean; |
683af98c AC |
1435 | -- Determine whether node N is within the subtree rooted at Root |
1436 | ||
90e491a7 PMR |
1437 | function In_Subtree |
1438 | (N : Node_Id; | |
1439 | Root1 : Node_Id; | |
1440 | Root2 : Node_Id) return Boolean; | |
1441 | -- Determine whether node N is within the subtree rooted at Root1 or Root2. | |
1442 | -- This version is more efficient than calling the single root version of | |
1443 | -- Is_Subtree twice. | |
1444 | ||
996ae0b0 RK |
1445 | function In_Visible_Part (Scope_Id : Entity_Id) return Boolean; |
1446 | -- Determine whether a declaration occurs within the visible part of a | |
1447 | -- package specification. The package must be on the scope stack, and the | |
1448 | -- corresponding private part must not. | |
1449 | ||
2e3795d0 YM |
1450 | function In_While_Loop_Condition (N : Node_Id) return Boolean; |
1451 | -- Returns true if the expression N occurs within the condition of a while | |
1452 | ||
c5cec2fe AC |
1453 | function Incomplete_Or_Partial_View (Id : Entity_Id) return Entity_Id; |
1454 | -- Given the entity of a constant or a type, retrieve the incomplete or | |
1455 | -- partial view of the same entity. Note that Id may not have a partial | |
1456 | -- view in which case the function returns Empty. | |
df3e68b1 | 1457 | |
d00301ec BD |
1458 | function Incomplete_View_From_Limited_With |
1459 | (Typ : Entity_Id) return Entity_Id; | |
1460 | -- Typ is a type entity. This normally returns Typ. However, if there is | |
1461 | -- an incomplete view of this entity that comes from a limited-with'ed | |
1462 | -- package, then this returns that incomplete view. | |
1463 | ||
36d3d5d3 EB |
1464 | function Indexed_Component_Bit_Offset (N : Node_Id) return Uint; |
1465 | -- Given an N_Indexed_Component node, return the first bit position of the | |
1466 | -- component if it is known at compile time. A value of No_Uint means that | |
1467 | -- either the value is not yet known before back-end processing or it is | |
1468 | -- not known at compile time after back-end processing. | |
1469 | ||
e699b76e AC |
1470 | procedure Inherit_Rep_Item_Chain (Typ : Entity_Id; From_Typ : Entity_Id); |
1471 | -- Inherit the rep item chain of type From_Typ without clobbering any | |
1472 | -- existing rep items on Typ's chain. Typ is the destination type. | |
1473 | ||
65641255 JM |
1474 | function Inherits_From_Tagged_Full_View (Typ : Entity_Id) return Boolean; |
1475 | pragma Inline (Inherits_From_Tagged_Full_View); | |
1476 | -- Return True if Typ is an untagged private type completed with a | |
1477 | -- derivation of an untagged private type declaration whose full view | |
1478 | -- is a tagged type. | |
1479 | ||
fbf5a39b | 1480 | procedure Insert_Explicit_Dereference (N : Node_Id); |
1e0e6534 AC |
1481 | -- In a context that requires a composite or subprogram type and where a |
1482 | -- prefix is an access type, rewrite the access type node N (which is the | |
1483 | -- prefix, e.g. of an indexed component) as an explicit dereference. | |
fbf5a39b | 1484 | |
de5cd98e TQ |
1485 | procedure Inspect_Deferred_Constant_Completion (Decls : List_Id); |
1486 | -- Examine all deferred constants in the declaration list Decls and check | |
1487 | -- whether they have been completed by a full constant declaration or an | |
1488 | -- Import pragma. Emit the error message if that is not the case. | |
1489 | ||
7255f3c3 HK |
1490 | procedure Install_Elaboration_Model (Unit_Id : Entity_Id); |
1491 | -- Install the elaboration model specified by pragma Elaboration_Checks | |
1492 | -- associated with compilation unit Unit_Id. No action is taken when the | |
1493 | -- unit lacks such pragma. | |
1494 | ||
c9d70ab1 AC |
1495 | procedure Install_Generic_Formals (Subp_Id : Entity_Id); |
1496 | -- Install both the generic formal parameters and the formal parameters of | |
1497 | -- generic subprogram Subp_Id into visibility. | |
1498 | ||
f9a8f910 HK |
1499 | procedure Install_SPARK_Mode (Mode : SPARK_Mode_Type; Prag : Node_Id); |
1500 | -- Establish the SPARK_Mode and SPARK_Mode_Pragma currently in effect | |
1501 | ||
529749b9 HK |
1502 | function Invalid_Scalar_Value |
1503 | (Loc : Source_Ptr; | |
1504 | Scal_Typ : Scalar_Id) return Node_Id; | |
1505 | -- Obtain the invalid value for scalar type Scal_Typ as either specified by | |
1506 | -- pragma Initialize_Scalars or by the binder. Return an expression created | |
1507 | -- at source location Loc, which denotes the invalid value. | |
1508 | ||
75ba322d AC |
1509 | function Is_Actual_Out_Parameter (N : Node_Id) return Boolean; |
1510 | -- Determines if N is an actual parameter of out mode in a subprogram call | |
1511 | ||
996ae0b0 | 1512 | function Is_Actual_Parameter (N : Node_Id) return Boolean; |
bf7c85c9 | 1513 | -- Determines if N is an actual parameter in a subprogram call |
996ae0b0 | 1514 | |
e24329cd YM |
1515 | function Is_Actual_Tagged_Parameter (N : Node_Id) return Boolean; |
1516 | -- Determines if N is an actual parameter of a formal of tagged type in a | |
1517 | -- subprogram call. | |
1518 | ||
996ae0b0 | 1519 | function Is_Aliased_View (Obj : Node_Id) return Boolean; |
7c4b480f | 1520 | -- Determine if Obj is an aliased view, i.e. the name of an object to which |
a4901c08 AC |
1521 | -- 'Access or 'Unchecked_Access can apply. Note that this routine uses the |
1522 | -- rules of the language, it does not take into account the restriction | |
1523 | -- No_Implicit_Aliasing, so it can return True if the restriction is active | |
1524 | -- and Obj violates the restriction. The caller is responsible for calling | |
1525 | -- Restrict.Check_No_Implicit_Aliasing if True is returned, but there is a | |
1526 | -- requirement for obeying the restriction in the call context. | |
996ae0b0 | 1527 | |
9bc856dd AC |
1528 | function Is_Ancestor_Package |
1529 | (E1 : Entity_Id; | |
1530 | E2 : Entity_Id) return Boolean; | |
1531 | -- Determine whether package E1 is an ancestor of E2 | |
1532 | ||
996ae0b0 | 1533 | function Is_Atomic_Object (N : Node_Id) return Boolean; |
56a05ce0 | 1534 | -- Determine whether arbitrary node N denotes a reference to an atomic |
2cee58d8 | 1535 | -- object as per RM C.6(7) and the crucial remark in RM C.6(8). |
996ae0b0 | 1536 | |
f280dd8f | 1537 | function Is_Atomic_Or_VFA_Object (N : Node_Id) return Boolean; |
56a05ce0 HK |
1538 | -- Determine whether arbitrary node N denotes a reference to an object |
1539 | -- which is either atomic or Volatile_Full_Access. | |
f280dd8f | 1540 | |
ee7c961d PT |
1541 | function Is_Attribute_Old (N : Node_Id) return Boolean; |
1542 | -- Determine whether node N denotes attribute 'Old | |
1543 | ||
39d3009f AC |
1544 | function Is_Attribute_Result (N : Node_Id) return Boolean; |
1545 | -- Determine whether node N denotes attribute 'Result | |
1546 | ||
ff1bedac YM |
1547 | function Is_Attribute_Update (N : Node_Id) return Boolean; |
1548 | -- Determine whether node N denotes attribute 'Update | |
1549 | ||
a7e68e7f HK |
1550 | function Is_Body_Or_Package_Declaration (N : Node_Id) return Boolean; |
1551 | -- Determine whether node N denotes a body or a package declaration | |
1552 | ||
3058f181 BD |
1553 | function Is_Bounded_String (T : Entity_Id) return Boolean; |
1554 | -- True if T is a bounded string type. Used to make sure "=" composes | |
1555 | -- properly for bounded string types. | |
1556 | ||
da1c23dd AC |
1557 | function Is_Constant_Bound (Exp : Node_Id) return Boolean; |
1558 | -- Exp is the expression for an array bound. Determines whether the | |
1559 | -- bound is a compile-time known value, or a constant entity, or an | |
1560 | -- enumeration literal, or an expression composed of constant-bound | |
1561 | -- subexpressions which are evaluated by means of standard operators. | |
1562 | ||
dd2bf554 ES |
1563 | function Is_Container_Element (Exp : Node_Id) return Boolean; |
1564 | -- This routine recognizes expressions that denote an element of one of | |
1565 | -- the predefined containers, when the source only contains an indexing | |
82d4f390 RD |
1566 | -- operation and an implicit dereference is inserted by the compiler. |
1567 | -- In the absence of this optimization, the indexing creates a temporary | |
dd2bf554 ES |
1568 | -- controlled cursor that sets the tampering bit of the container, and |
1569 | -- restricts the use of the convenient notation C (X) to contexts that | |
82d4f390 RD |
1570 | -- do not check the tampering bit (e.g. C.Include (X, C (Y)). Exp is an |
1571 | -- explicit dereference. The transformation applies when it has the form | |
1572 | -- F (X).Discr.all. | |
dd2bf554 | 1573 | |
8d1fe980 AC |
1574 | function Is_Contract_Annotation (Item : Node_Id) return Boolean; |
1575 | -- Determine whether aspect specification or pragma Item is a contract | |
1576 | -- annotation. | |
1577 | ||
2c867f5a ES |
1578 | function Is_Controlling_Limited_Procedure |
1579 | (Proc_Nam : Entity_Id) return Boolean; | |
1580 | -- Ada 2005 (AI-345): Determine whether Proc_Nam is a primitive procedure | |
1581 | -- of a limited interface with a controlling first parameter. | |
1582 | ||
236fecbf JM |
1583 | function Is_CPP_Constructor_Call (N : Node_Id) return Boolean; |
1584 | -- Returns True if N is a call to a CPP constructor | |
1585 | ||
780d73d7 AC |
1586 | function Is_CCT_Instance |
1587 | (Ref_Id : Entity_Id; | |
1588 | Context_Id : Entity_Id) return Boolean; | |
1589 | -- Subsidiary to the analysis of pragmas [Refined_]Depends and [Refined_] | |
1554ed7e PMR |
1590 | -- Global; also used when analyzing default expressions of protected and |
1591 | -- record components. Determine whether entity Ref_Id (which must represent | |
1592 | -- either a protected type or a task type) denotes the current instance of | |
1593 | -- a concurrent type. Context_Id denotes the associated context where the | |
780d73d7 AC |
1594 | -- pragma appears. |
1595 | ||
061828e3 | 1596 | function Is_Child_Or_Sibling |
d7af5ea5 HK |
1597 | (Pack_1 : Entity_Id; |
1598 | Pack_2 : Entity_Id) return Boolean; | |
061828e3 AC |
1599 | -- Determine the following relations between two arbitrary packages: |
1600 | -- 1) One package is the parent of a child package | |
1601 | -- 2) Both packages are siblings and share a common parent | |
061828e3 AC |
1602 | |
1603 | function Is_Concurrent_Interface (T : Entity_Id) return Boolean; | |
1604 | -- First determine whether type T is an interface and then check whether | |
1605 | -- it is of protected, synchronized or task kind. | |
1606 | ||
596b25f9 AC |
1607 | function Is_Current_Instance (N : Node_Id) return Boolean; |
1608 | -- Predicate is true if N legally denotes a type name within its own | |
1609 | -- declaration. Prior to Ada 2012 this covered only synchronized type | |
a7b37927 | 1610 | -- declarations. In Ada 2012 it also covers type and subtype declarations |
596b25f9 AC |
1611 | -- with aspects: Invariant, Predicate, and Default_Initial_Condition. |
1612 | ||
a85dbeec HK |
1613 | function Is_Declaration |
1614 | (N : Node_Id; | |
1615 | Body_OK : Boolean := True; | |
1616 | Concurrent_OK : Boolean := True; | |
1617 | Formal_OK : Boolean := True; | |
1618 | Generic_OK : Boolean := True; | |
1619 | Instantiation_OK : Boolean := True; | |
1620 | Renaming_OK : Boolean := True; | |
1621 | Stub_OK : Boolean := True; | |
1622 | Subprogram_OK : Boolean := True; | |
1623 | Type_OK : Boolean := True) return Boolean; | |
1624 | -- Determine whether arbitrary node N denotes a declaration depending | |
1625 | -- on the allowed subsets of declarations. Set the following flags to | |
1626 | -- consider specific subsets of declarations: | |
1627 | -- | |
1628 | -- * Body_OK - body declarations | |
1629 | -- | |
1630 | -- * Concurrent_OK - concurrent type declarations | |
1631 | -- | |
1632 | -- * Formal_OK - formal declarations | |
1633 | -- | |
1634 | -- * Generic_OK - generic declarations, including generic renamings | |
1635 | -- | |
1636 | -- * Instantiation_OK - generic instantiations | |
1637 | -- | |
1638 | -- * Renaming_OK - renaming declarations, including generic renamings | |
1639 | -- | |
1640 | -- * Stub_OK - stub declarations | |
1641 | -- | |
1642 | -- * Subprogram_OK - entry, expression function, and subprogram | |
1643 | -- declarations. | |
1644 | -- | |
1645 | -- * Type_OK - type declarations, including concurrent types | |
d65a80fd | 1646 | |
c96c518f AC |
1647 | function Is_Declared_Within_Variant (Comp : Entity_Id) return Boolean; |
1648 | -- Returns True iff component Comp is declared within a variant part | |
1649 | ||
fbf5a39b AC |
1650 | function Is_Dependent_Component_Of_Mutable_Object |
1651 | (Object : Node_Id) return Boolean; | |
9337aa0a AC |
1652 | -- Returns True if Object is the name of a subcomponent that depends on |
1653 | -- discriminants of a variable whose nominal subtype is unconstrained and | |
1654 | -- not indefinite, and the variable is not aliased. Otherwise returns | |
1655 | -- False. The nodes passed to this function are assumed to denote objects. | |
fbf5a39b AC |
1656 | |
1657 | function Is_Dereferenced (N : Node_Id) return Boolean; | |
1e0e6534 AC |
1658 | -- N is a subexpression node of an access type. This function returns true |
1659 | -- if N appears as the prefix of a node that does a dereference of the | |
1660 | -- access value (selected/indexed component, explicit dereference or a | |
1661 | -- slice), and false otherwise. | |
fbf5a39b | 1662 | |
d9d25d04 AC |
1663 | function Is_Descendant_Of (T1 : Entity_Id; T2 : Entity_Id) return Boolean; |
1664 | -- Returns True if type T1 is a descendant of type T2, and false otherwise. | |
1665 | -- This is the RM definition, a type is a descendant of another type if it | |
1666 | -- is the same type or is derived from a descendant of the other type. | |
9f4fd324 | 1667 | |
75b87c16 AC |
1668 | function Is_Descendant_Of_Suspension_Object |
1669 | (Typ : Entity_Id) return Boolean; | |
1670 | -- Determine whether type Typ is a descendant of type Suspension_Object | |
1671 | -- defined in Ada.Synchronous_Task_Control. This version is different from | |
d9d25d04 | 1672 | -- Is_Descendant_Of as the detection of Suspension_Object does not involve |
75b87c16 AC |
1673 | -- an entity and by extension a call to RTSfind. |
1674 | ||
90a4b336 YM |
1675 | function Is_Double_Precision_Floating_Point_Type |
1676 | (E : Entity_Id) return Boolean; | |
1677 | -- Return whether E is a double precision floating point type, | |
1678 | -- characterized by: | |
1679 | -- . machine_radix = 2 | |
1680 | -- . machine_mantissa = 53 | |
1681 | -- . machine_emax = 2**10 | |
1682 | -- . machine_emin = 3 - machine_emax | |
1683 | ||
d780e54f | 1684 | function Is_Effectively_Volatile (Id : Entity_Id) return Boolean; |
847d950d HK |
1685 | -- Determine whether a type or object denoted by entity Id is effectively |
1686 | -- volatile (SPARK RM 7.1.2). To qualify as such, the entity must be either | |
9dfc6c55 | 1687 | -- * Volatile without No_Caching |
847d950d HK |
1688 | -- * An array type subject to aspect Volatile_Components |
1689 | -- * An array type whose component type is effectively volatile | |
1690 | -- * A protected type | |
1691 | -- * Descendant of type Ada.Synchronous_Task_Control.Suspension_Object | |
d780e54f AC |
1692 | |
1693 | function Is_Effectively_Volatile_Object (N : Node_Id) return Boolean; | |
1694 | -- Determine whether an arbitrary node denotes an effectively volatile | |
847d950d | 1695 | -- object (SPARK RM 7.1.2). |
d780e54f | 1696 | |
f99ff327 AC |
1697 | function Is_Entry_Body (Id : Entity_Id) return Boolean; |
1698 | -- Determine whether entity Id is the body entity of an entry [family] | |
1699 | ||
1700 | function Is_Entry_Declaration (Id : Entity_Id) return Boolean; | |
1701 | -- Determine whether entity Id is the spec entity of an entry [family] | |
1702 | ||
f73dc37f ES |
1703 | function Is_Expanded_Priority_Attribute (E : Entity_Id) return Boolean; |
1704 | -- Check whether a function in a call is an expanded priority attribute, | |
1705 | -- which is transformed into an Rtsfind call to Get_Ceiling. This expansion | |
1706 | -- does not take place in a configurable runtime. | |
1707 | ||
d2b10647 | 1708 | function Is_Expression_Function (Subp : Entity_Id) return Boolean; |
2bfad6eb HK |
1709 | -- Determine whether subprogram [body] Subp denotes an expression function |
1710 | ||
1711 | function Is_Expression_Function_Or_Completion | |
1712 | (Subp : Entity_Id) return Boolean; | |
1713 | -- Determine whether subprogram [body] Subp denotes an expression function | |
1714 | -- or is completed by an expression function body. | |
d2b10647 | 1715 | |
039538bc AC |
1716 | function Is_EVF_Expression (N : Node_Id) return Boolean; |
1717 | -- Determine whether node N denotes a reference to a formal parameter of | |
1718 | -- a specific tagged type whose related subprogram is subject to pragma | |
847d950d HK |
1719 | -- Extensions_Visible with value "False" (SPARK RM 6.1.7). Several other |
1720 | -- constructs fall under this category: | |
039538bc AC |
1721 | -- 1) A qualified expression whose operand is EVF |
1722 | -- 2) A type conversion whose operand is EVF | |
1723 | -- 3) An if expression with at least one EVF dependent_expression | |
1724 | -- 4) A case expression with at least one EVF dependent_expression | |
1725 | ||
996ae0b0 | 1726 | function Is_False (U : Uint) return Boolean; |
b81a5940 JM |
1727 | pragma Inline (Is_False); |
1728 | -- The argument is a Uint value which is the Boolean'Pos value of a Boolean | |
1729 | -- operand (i.e. is either 0 for False, or 1 for True). This function tests | |
1730 | -- if it is False (i.e. zero). | |
996ae0b0 RK |
1731 | |
1732 | function Is_Fixed_Model_Number (U : Ureal; T : Entity_Id) return Boolean; | |
ded8909b AC |
1733 | -- Returns True iff the number U is a model number of the fixed-point type |
1734 | -- T, i.e. if it is an exact multiple of Small. | |
996ae0b0 RK |
1735 | |
1736 | function Is_Fully_Initialized_Type (Typ : Entity_Id) return Boolean; | |
9337aa0a AC |
1737 | -- Typ is a type entity. This function returns true if this type is fully |
1738 | -- initialized, meaning that an object of the type is fully initialized. | |
1bc619ef | 1739 | -- Note that initialization resulting from use of pragma Normalize_Scalars |
9337aa0a AC |
1740 | -- does not count. Note that this is only used for the purpose of issuing |
1741 | -- warnings for objects that are potentially referenced uninitialized. This | |
1742 | -- means that the result returned is not crucial, but should err on the | |
1743 | -- side of thinking things are fully initialized if it does not know. | |
996ae0b0 | 1744 | |
caf07df9 AC |
1745 | function Is_Generic_Declaration_Or_Body (Decl : Node_Id) return Boolean; |
1746 | -- Determine whether arbitrary declaration Decl denotes a generic package, | |
1747 | -- a generic subprogram or a generic body. | |
1748 | ||
2cee58d8 EB |
1749 | function Is_Independent_Object (N : Node_Id) return Boolean; |
1750 | -- Determine whether arbitrary node N denotes a reference to an independent | |
1751 | -- object as per RM C.6(8). | |
1752 | ||
996ae0b0 RK |
1753 | function Is_Inherited_Operation (E : Entity_Id) return Boolean; |
1754 | -- E is a subprogram. Return True is E is an implicit operation inherited | |
12f0c50c AC |
1755 | -- by a derived type declaration. |
1756 | ||
1757 | function Is_Inherited_Operation_For_Type | |
690943fc RD |
1758 | (E : Entity_Id; |
1759 | Typ : Entity_Id) return Boolean; | |
12f0c50c AC |
1760 | -- E is a subprogram. Return True is E is an implicit operation inherited |
1761 | -- by the derived type declaration for type Typ. | |
996ae0b0 | 1762 | |
40bf00b1 AC |
1763 | function Is_Inlinable_Expression_Function (Subp : Entity_Id) return Boolean; |
1764 | -- Return True if Subp is an expression function that fulfills all the | |
1765 | -- following requirements for inlining: | |
1766 | -- 1. pragma/aspect Inline_Always | |
1767 | -- 2. No formals | |
1768 | -- 3. No contracts | |
1769 | -- 4. No dispatching primitive | |
1770 | -- 5. Result subtype controlled (or with controlled components) | |
1771 | -- 6. Result subtype not subject to type-invariant checks | |
1772 | -- 7. Result subtype not a class-wide type | |
1773 | -- 8. Return expression naming an object global to the function | |
1774 | -- 9. Nominal subtype of the returned object statically compatible | |
1775 | -- with the result subtype of the expression function. | |
1776 | ||
3e24afaa | 1777 | function Is_Iterator (Typ : Entity_Id) return Boolean; |
2fcc44fa AC |
1778 | -- AI05-0139-2: Check whether Typ is one of the predefined interfaces in |
1779 | -- Ada.Iterator_Interfaces, or it is derived from one. | |
3e24afaa | 1780 | |
fc90cc62 AC |
1781 | function Is_Iterator_Over_Array (N : Node_Id) return Boolean; |
1782 | -- N is an iterator specification. Returns True iff N is an iterator over | |
1783 | -- an array, either inside a loop of the form 'for X of A' or a quantified | |
1784 | -- expression of the form 'for all/some X of A' where A is of array type. | |
1785 | ||
a54ffd6c AC |
1786 | type Is_LHS_Result is (Yes, No, Unknown); |
1787 | function Is_LHS (N : Node_Id) return Is_LHS_Result; | |
1788 | -- Returns Yes if N is definitely used as Name in an assignment statement. | |
1789 | -- Returns No if N is definitely NOT used as a Name in an assignment | |
1790 | -- statement. Returns Unknown if we can't tell at this stage (happens in | |
1791 | -- the case where we don't know the type of N yet, and we have something | |
1792 | -- like N.A := 3, where this counts as N being used on the left side of | |
1793 | -- an assignment only if N is not an access type. If it is an access type | |
1794 | -- then it is N.all.A that is assigned, not N. | |
75ba322d | 1795 | |
996ae0b0 RK |
1796 | function Is_Library_Level_Entity (E : Entity_Id) return Boolean; |
1797 | -- A library-level declaration is one that is accessible from Standard, | |
1798 | -- i.e. a library unit or an entity declared in a library package. | |
1799 | ||
1a36a0cd | 1800 | function Is_Limited_Class_Wide_Type (Typ : Entity_Id) return Boolean; |
b5bdffcc AC |
1801 | -- Determine whether a given type is a limited class-wide type, in which |
1802 | -- case it needs a Master_Id, because extensions of its designated type | |
1803 | -- may include task components. A class-wide type that comes from a | |
1804 | -- limited view must be treated in the same way. | |
1a36a0cd | 1805 | |
996ae0b0 | 1806 | function Is_Local_Variable_Reference (Expr : Node_Id) return Boolean; |
1e0e6534 AC |
1807 | -- Determines whether Expr is a reference to a variable or IN OUT mode |
1808 | -- parameter of the current enclosing subprogram. | |
5d09245e | 1809 | -- Why are OUT parameters not considered here ??? |
996ae0b0 | 1810 | |
a51368fa AC |
1811 | function Is_Name_Reference (N : Node_Id) return Boolean; |
1812 | -- Determine whether arbitrary node N is a reference to a name. This is | |
1813 | -- similar to Is_Object_Reference but returns True only if N can be renamed | |
1814 | -- without the need for a temporary, the typical example of an object not | |
1815 | -- in this category being a function call. | |
1816 | ||
8dce7371 PMR |
1817 | function Is_Non_Preelaborable_Construct (N : Node_Id) return Boolean; |
1818 | -- Determine whether arbitrary construct N violates preelaborability as | |
1819 | -- defined in ARM 10.2.1 5-9/3. This routine takes into account both the | |
1820 | -- syntactic and semantic properties of the construct. | |
1821 | ||
f63d601b | 1822 | function Is_Nontrivial_DIC_Procedure (Id : Entity_Id) return Boolean; |
31101470 | 1823 | -- Determine whether entity Id denotes the procedure that verifies the |
e9ea8f9e | 1824 | -- assertion expression of pragma Default_Initial_Condition and if it does, |
31101470 | 1825 | -- the encapsulated expression is nontrivial. |
e9ea8f9e | 1826 | |
680d5f61 AC |
1827 | function Is_Null_Record_Type (T : Entity_Id) return Boolean; |
1828 | -- Determine whether T is declared with a null record definition or a | |
1829 | -- null component list. | |
1830 | ||
b276ab7a | 1831 | function Is_Object_Image (Prefix : Node_Id) return Boolean; |
643827e9 | 1832 | -- Returns True if an 'Image, 'Wide_Image, or 'Wide_Wide_Image attribute |
b276ab7a AC |
1833 | -- is applied to a given object or named value prefix (see below). |
1834 | ||
1835 | -- AI12-00124: The ARG has adopted the GNAT semantics of 'Img for scalar | |
1836 | -- types, so that the prefix of any 'Image attribute can be an object, a | |
1837 | -- named value, or a type, and there is no need for an argument in the | |
1838 | -- case it is an object reference. | |
1839 | ||
996ae0b0 RK |
1840 | function Is_Object_Reference (N : Node_Id) return Boolean; |
1841 | -- Determines if the tree referenced by N represents an object. Both | |
1842 | -- variable and constant objects return True (compare Is_Variable). | |
1843 | ||
1844 | function Is_OK_Variable_For_Out_Formal (AV : Node_Id) return Boolean; | |
b81a5940 JM |
1845 | -- Used to test if AV is an acceptable formal for an OUT or IN OUT formal. |
1846 | -- Note that the Is_Variable function is not quite the right test because | |
1847 | -- this is a case in which conversions whose expression is a variable (in | |
7c0c194b | 1848 | -- the Is_Variable sense) with an untagged type target are considered view |
b81a5940 | 1849 | -- conversions and hence variables. |
996ae0b0 | 1850 | |
b3143037 AC |
1851 | function Is_OK_Volatile_Context |
1852 | (Context : Node_Id; | |
1853 | Obj_Ref : Node_Id) return Boolean; | |
1854 | -- Determine whether node Context denotes a "non-interfering context" (as | |
1855 | -- defined in SPARK RM 7.1.3(12)) where volatile reference Obj_Ref can | |
1856 | -- safely reside. | |
1857 | ||
caf07df9 AC |
1858 | function Is_Package_Contract_Annotation (Item : Node_Id) return Boolean; |
1859 | -- Determine whether aspect specification or pragma Item is one of the | |
1860 | -- following package contract annotations: | |
1861 | -- Abstract_State | |
1862 | -- Initial_Condition | |
1863 | -- Initializes | |
1864 | -- Refined_State | |
1865 | ||
b4ca2d2c | 1866 | function Is_Partially_Initialized_Type |
f2acf80c AC |
1867 | (Typ : Entity_Id; |
1868 | Include_Implicit : Boolean := True) return Boolean; | |
1e0e6534 AC |
1869 | -- Typ is a type entity. This function returns true if this type is partly |
1870 | -- initialized, meaning that an object of the type is at least partly | |
1871 | -- initialized (in particular in the record case, that at least one | |
1872 | -- component has an initialization expression). Note that initialization | |
1bc619ef | 1873 | -- resulting from the use of pragma Normalize_Scalars does not count. |
308e6f3a | 1874 | -- Include_Implicit controls whether implicit initialization of access |
f2acf80c AC |
1875 | -- values to null, and of discriminant values, is counted as making the |
1876 | -- type be partially initialized. For the default setting of True, these | |
1877 | -- implicit cases do count, and discriminated types or types containing | |
1878 | -- access values not explicitly initialized will return True. Otherwise | |
1879 | -- if Include_Implicit is False, these cases do not count as making the | |
308e6f3a | 1880 | -- type be partially initialized. |
07fc65c4 | 1881 | |
c733429f AC |
1882 | function Is_Potentially_Unevaluated (N : Node_Id) return Boolean; |
1883 | -- Predicate to implement definition given in RM 6.1.1 (20/3) | |
1884 | ||
edd63e9b ES |
1885 | function Is_Potentially_Persistent_Type (T : Entity_Id) return Boolean; |
1886 | -- Determines if type T is a potentially persistent type. A potentially | |
7c0c194b | 1887 | -- persistent type is defined (recursively) as a scalar type, an untagged |
edd63e9b ES |
1888 | -- record whose components are all of a potentially persistent type, or an |
1889 | -- array with all static constraints whose component type is potentially | |
1890 | -- persistent. A private type is potentially persistent if the full type | |
1891 | -- is potentially persistent. | |
1892 | ||
7a500fd7 HK |
1893 | function Is_Predefined_Dispatching_Operation (E : Entity_Id) return Boolean; |
1894 | -- Ada 2005 (AI-251): Determines if E is a predefined primitive operation | |
1895 | ||
1896 | function Is_Predefined_Interface_Primitive (E : Entity_Id) return Boolean; | |
1897 | -- Ada 2005 (AI-345): Returns True if E is one of the predefined primitives | |
1898 | -- required to implement interfaces. | |
1899 | ||
1900 | function Is_Predefined_Internal_Operation (E : Entity_Id) return Boolean; | |
1901 | -- Similar to the previous one, but excludes stream operations, because | |
1902 | -- these may be overridden, and need extra formals, like user-defined | |
1903 | -- operations. | |
1904 | ||
90e491a7 PMR |
1905 | function Is_Preelaborable_Aggregate (Aggr : Node_Id) return Boolean; |
1906 | -- Determine whether aggregate Aggr violates the restrictions of | |
1907 | -- preelaborable constructs as defined in ARM 10.2.1(5-9). | |
1908 | ||
1909 | function Is_Preelaborable_Construct (N : Node_Id) return Boolean; | |
1910 | -- Determine whether arbitrary node N violates the restrictions of | |
8dce7371 PMR |
1911 | -- preelaborable constructs as defined in ARM 10.2.1(5-9). Routine |
1912 | -- Is_Non_Preelaborable_Construct takes into account the syntactic | |
1913 | -- and semantic properties of N for a more accurate diagnostic. | |
90e491a7 | 1914 | |
2d14501c ST |
1915 | function Is_Protected_Self_Reference (N : Node_Id) return Boolean; |
1916 | -- Return True if node N denotes a protected type name which represents | |
1917 | -- the current instance of a protected object according to RM 9.4(21/2). | |
1918 | ||
996ae0b0 RK |
1919 | function Is_RCI_Pkg_Spec_Or_Body (Cunit : Node_Id) return Boolean; |
1920 | -- Return True if a compilation unit is the specification or the | |
1921 | -- body of a remote call interface package. | |
1922 | ||
1923 | function Is_Remote_Access_To_Class_Wide_Type (E : Entity_Id) return Boolean; | |
9e87a68d | 1924 | -- Return True if E is a remote access-to-class-wide type |
996ae0b0 RK |
1925 | |
1926 | function Is_Remote_Access_To_Subprogram_Type (E : Entity_Id) return Boolean; | |
bf7c85c9 | 1927 | -- Return True if E is a remote access to subprogram type |
996ae0b0 RK |
1928 | |
1929 | function Is_Remote_Call (N : Node_Id) return Boolean; | |
1930 | -- Return True if N denotes a potentially remote call | |
1931 | ||
2c867f5a ES |
1932 | function Is_Renamed_Entry (Proc_Nam : Entity_Id) return Boolean; |
1933 | -- Return True if Proc_Nam is a procedure renaming of an entry | |
1934 | ||
241ebe89 HK |
1935 | function Is_Renaming_Declaration (N : Node_Id) return Boolean; |
1936 | -- Determine whether arbitrary node N denotes a renaming declaration | |
1937 | ||
690943fc RD |
1938 | function Is_Reversible_Iterator (Typ : Entity_Id) return Boolean; |
1939 | -- AI05-0139-2: Check whether Typ is derived from the predefined interface | |
1940 | -- Ada.Iterator_Interfaces.Reversible_Iterator. | |
1941 | ||
996ae0b0 RK |
1942 | function Is_Selector_Name (N : Node_Id) return Boolean; |
1943 | -- Given an N_Identifier node N, determines if it is a Selector_Name. | |
1944 | -- As described in Sinfo, Selector_Names are special because they | |
f3d57416 | 1945 | -- represent use of the N_Identifier node for a true identifier, when |
996ae0b0 RK |
1946 | -- normally such nodes represent a direct name. |
1947 | ||
75b87c16 AC |
1948 | function Is_Single_Concurrent_Object (Id : Entity_Id) return Boolean; |
1949 | -- Determine whether arbitrary entity Id denotes the anonymous object | |
1950 | -- created for a single protected or single task type. | |
1951 | ||
1952 | function Is_Single_Concurrent_Type (Id : Entity_Id) return Boolean; | |
1953 | -- Determine whether arbitrary entity Id denotes a single protected or | |
1954 | -- single task type. | |
1955 | ||
1956 | function Is_Single_Concurrent_Type_Declaration (N : Node_Id) return Boolean; | |
1957 | -- Determine whether arbitrary node N denotes the declaration of a single | |
1958 | -- protected type or single task type. | |
1959 | ||
90a4b336 YM |
1960 | function Is_Single_Precision_Floating_Point_Type |
1961 | (E : Entity_Id) return Boolean; | |
1962 | -- Return whether E is a single precision floating point type, | |
1963 | -- characterized by: | |
1964 | -- . machine_radix = 2 | |
1965 | -- . machine_mantissa = 24 | |
1966 | -- . machine_emax = 2**7 | |
1967 | -- . machine_emin = 3 - machine_emax | |
1968 | ||
e645cb39 AC |
1969 | function Is_Single_Protected_Object (Id : Entity_Id) return Boolean; |
1970 | -- Determine whether arbitrary entity Id denotes the anonymous object | |
1971 | -- created for a single protected type. | |
1972 | ||
1973 | function Is_Single_Task_Object (Id : Entity_Id) return Boolean; | |
1974 | -- Determine whether arbitrary entity Id denotes the anonymous object | |
1975 | -- created for a single task type. | |
1976 | ||
ce5ba43a | 1977 | function Is_SPARK_05_Initialization_Expr (N : Node_Id) return Boolean; |
aa1e353a | 1978 | -- Determines if the tree referenced by N represents an initialization |
ce5ba43a AC |
1979 | -- expression in SPARK 2005, suitable for initializing an object in an |
1980 | -- object declaration. | |
1981 | ||
1982 | function Is_SPARK_05_Object_Reference (N : Node_Id) return Boolean; | |
1983 | -- Determines if the tree referenced by N represents an object in SPARK | |
1984 | -- 2005. This differs from Is_Object_Reference in that only variables, | |
1985 | -- constants, formal parameters, and selected_components of those are | |
1986 | -- valid objects in SPARK 2005. | |
12f0c50c | 1987 | |
039538bc AC |
1988 | function Is_Specific_Tagged_Type (Typ : Entity_Id) return Boolean; |
1989 | -- Determine whether an arbitrary [private] type is specifically tagged | |
1990 | ||
996ae0b0 | 1991 | function Is_Statement (N : Node_Id) return Boolean; |
b81a5940 | 1992 | pragma Inline (Is_Statement); |
996ae0b0 RK |
1993 | -- Check if the node N is a statement node. Note that this includes |
1994 | -- the case of procedure call statements (unlike the direct use of | |
cd91501c RD |
1995 | -- the N_Statement_Other_Than_Procedure_Call subtype from Sinfo). |
1996 | -- Note that a label is *not* a statement, and will return False. | |
996ae0b0 | 1997 | |
d6c7e020 EB |
1998 | function Is_Subcomponent_Of_Atomic_Object (N : Node_Id) return Boolean; |
1999 | -- Determine whether arbitrary node N denotes a reference to a subcomponent | |
2cee58d8 | 2000 | -- of an atomic object as per RM C.6(7). |
d6c7e020 | 2001 | |
caf07df9 AC |
2002 | function Is_Subprogram_Contract_Annotation (Item : Node_Id) return Boolean; |
2003 | -- Determine whether aspect specification or pragma Item is one of the | |
2004 | -- following subprogram contract annotations: | |
2005 | -- Contract_Cases | |
2006 | -- Depends | |
2007 | -- Extensions_Visible | |
2008 | -- Global | |
2009 | -- Post | |
2010 | -- Post_Class | |
2011 | -- Postcondition | |
2012 | -- Pre | |
2013 | -- Pre_Class | |
2014 | -- Precondition | |
2015 | -- Refined_Depends | |
2016 | -- Refined_Global | |
2017 | -- Refined_Post | |
2018 | -- Test_Case | |
2019 | ||
60370fb1 AC |
2020 | function Is_Subprogram_Stub_Without_Prior_Declaration |
2021 | (N : Node_Id) return Boolean; | |
f3e0577c PT |
2022 | -- Given an N_Subprogram_Body_Stub node N, return True if N is a subprogram |
2023 | -- stub with no prior subprogram declaration. | |
60370fb1 | 2024 | |
9057bd6a HK |
2025 | function Is_Suitable_Primitive (Subp_Id : Entity_Id) return Boolean; |
2026 | -- Determine whether arbitrary subprogram Subp_Id may act as a primitive of | |
2027 | -- an arbitrary tagged type. | |
2028 | ||
ca7e6c26 AC |
2029 | function Is_Suspension_Object (Id : Entity_Id) return Boolean; |
2030 | -- Determine whether arbitrary entity Id denotes Suspension_Object defined | |
2031 | -- in Ada.Synchronous_Task_Control. | |
2032 | ||
75b87c16 AC |
2033 | function Is_Synchronized_Object (Id : Entity_Id) return Boolean; |
2034 | -- Determine whether entity Id denotes an object and if it does, whether | |
2035 | -- this object is synchronized as specified in SPARK RM 9.1. To qualify as | |
2036 | -- such, the object must be | |
2037 | -- * Of a type that yields a synchronized object | |
2038 | -- * An atomic object with enabled Async_Writers | |
2039 | -- * A constant | |
2040 | -- * A variable subject to pragma Constant_After_Elaboration | |
2041 | ||
1b6c95c4 RD |
2042 | function Is_Synchronized_Tagged_Type (E : Entity_Id) return Boolean; |
2043 | -- Returns True if E is a synchronized tagged type (AARM 3.9.4 (6/2)) | |
2044 | ||
996ae0b0 | 2045 | function Is_Transfer (N : Node_Id) return Boolean; |
b81a5940 | 2046 | -- Returns True if the node N is a statement which is known to cause an |
8d45ce77 | 2047 | -- unconditional transfer of control at run time, i.e. the following |
996ae0b0 RK |
2048 | -- statement definitely will not be executed. |
2049 | ||
2050 | function Is_True (U : Uint) return Boolean; | |
b81a5940 JM |
2051 | pragma Inline (Is_True); |
2052 | -- The argument is a Uint value which is the Boolean'Pos value of a Boolean | |
2053 | -- operand (i.e. is either 0 for False, or 1 for True). This function tests | |
2054 | -- if it is True (i.e. non-zero). | |
996ae0b0 | 2055 | |
6c3c671e AC |
2056 | function Is_Unchecked_Conversion_Instance (Id : Entity_Id) return Boolean; |
2057 | -- Determine whether an arbitrary entity denotes an instance of function | |
2058 | -- Ada.Unchecked_Conversion. | |
2059 | ||
d7567964 | 2060 | function Is_Universal_Numeric_Type (T : Entity_Id) return Boolean; |
74e7891f | 2061 | pragma Inline (Is_Universal_Numeric_Type); |
d7567964 TQ |
2062 | -- True if T is Universal_Integer or Universal_Real |
2063 | ||
ed323421 AC |
2064 | function Is_User_Defined_Equality (Id : Entity_Id) return Boolean; |
2065 | -- Determine whether an entity denotes a user-defined equality | |
2066 | ||
89b6c83e AC |
2067 | function Is_Validation_Variable_Reference (N : Node_Id) return Boolean; |
2068 | -- Determine whether N denotes a reference to a variable which captures the | |
2069 | -- value of an object for validation purposes. | |
2070 | ||
da1c23dd AC |
2071 | function Is_Variable_Size_Array (E : Entity_Id) return Boolean; |
2072 | -- Returns true if E has variable size components | |
2073 | ||
2074 | function Is_Variable_Size_Record (E : Entity_Id) return Boolean; | |
2075 | -- Returns true if E has variable size components | |
2076 | ||
c7732bbe EB |
2077 | -- WARNING: There is a matching C declaration of this subprogram in fe.h |
2078 | ||
62be5d0a JM |
2079 | function Is_Variable |
2080 | (N : Node_Id; | |
2081 | Use_Original_Node : Boolean := True) return Boolean; | |
1e0e6534 AC |
2082 | -- Determines if the tree referenced by N represents a variable, i.e. can |
2083 | -- appear on the left side of an assignment. There is one situation (formal | |
7c0c194b | 2084 | -- parameters) in which untagged type conversions are also considered |
1e0e6534 AC |
2085 | -- variables, but Is_Variable returns False for such cases, since it has |
2086 | -- no knowledge of the context. Note that this is the point at which | |
2087 | -- Assignment_OK is checked, and True is returned for any tree thus marked. | |
62be5d0a JM |
2088 | -- Use_Original_Node is used to perform the test on Original_Node (N). By |
2089 | -- default is True since this routine is commonly invoked as part of the | |
2090 | -- semantic analysis and it must not be disturbed by the rewriten nodes. | |
996ae0b0 | 2091 | |
fd0d899b | 2092 | function Is_Visibly_Controlled (T : Entity_Id) return Boolean; |
1e0e6534 AC |
2093 | -- Check whether T is derived from a visibly controlled type. This is true |
2094 | -- if the root type is declared in Ada.Finalization. If T is derived | |
2095 | -- instead from a private type whose full view is controlled, an explicit | |
2096 | -- Initialize/Adjust/Finalize subprogram does not override the inherited | |
2097 | -- one. | |
fd0d899b | 2098 | |
2cee58d8 EB |
2099 | function Is_Volatile_Full_Access_Object (N : Node_Id) return Boolean; |
2100 | -- Determine whether arbitrary node N denotes a reference to an object | |
2101 | -- which is Volatile_Full_Access. | |
2102 | ||
847d950d HK |
2103 | function Is_Volatile_Function (Func_Id : Entity_Id) return Boolean; |
2104 | -- Determine whether [generic] function Func_Id is subject to enabled | |
2105 | -- pragma Volatile_Function. Protected functions are treated as volatile | |
2106 | -- (SPARK RM 7.1.2). | |
2107 | ||
996ae0b0 | 2108 | function Is_Volatile_Object (N : Node_Id) return Boolean; |
2cee58d8 EB |
2109 | -- Determine whether arbitrary node N denotes a reference to a volatile |
2110 | -- object as per RM C.6(8). Note that the test here is for something that | |
2111 | -- is actually declared as volatile, not for an object that gets treated | |
2112 | -- as volatile (see Einfo.Treat_As_Volatile). | |
fbf5a39b | 2113 | |
8437edb4 YM |
2114 | generic |
2115 | with procedure Handle_Parameter (Formal : Entity_Id; Actual : Node_Id); | |
2116 | procedure Iterate_Call_Parameters (Call : Node_Id); | |
2117 | -- Calls Handle_Parameter for each pair of formal and actual parameters of | |
2118 | -- a function, procedure, or entry call. | |
2119 | ||
9fd9d2be AC |
2120 | function Itype_Has_Declaration (Id : Entity_Id) return Boolean; |
2121 | -- Applies to Itypes. True if the Itype is attached to a declaration for | |
2122 | -- the type through its Parent field, which may or not be present in the | |
2123 | -- tree. | |
2124 | ||
67ce0d7e | 2125 | procedure Kill_Current_Values (Last_Assignment_Only : Boolean := False); |
fbf5a39b AC |
2126 | -- This procedure is called to clear all constant indications from all |
2127 | -- entities in the current scope and in any parent scopes if the current | |
1b6c95c4 RD |
2128 | -- scope is a block or a package (and that recursion continues to the top |
2129 | -- scope that is not a block or a package). This is used when the | |
f3d57416 RW |
2130 | -- sequential flow-of-control assumption is violated (occurrence of a |
2131 | -- label, head of a loop, or start of an exception handler). The effect of | |
54bb89ca | 2132 | -- the call is to clear the Current_Value field (but we do not need to |
f3d57416 RW |
2133 | -- clear the Is_True_Constant flag, since that only gets reset if there |
2134 | -- really is an assignment somewhere in the entity scope). This procedure | |
2135 | -- also calls Kill_All_Checks, since this is a special case of needing to | |
cff7cd9b AC |
2136 | -- forget saved values. This procedure also clears the Is_Known_Null and |
2137 | -- Is_Known_Non_Null and Is_Known_Valid flags in variables, constants or | |
2138 | -- parameters since these are also not known to be trustable any more. | |
67ce0d7e RD |
2139 | -- |
2140 | -- The Last_Assignment_Only flag is set True to clear only Last_Assignment | |
2141 | -- fields and leave other fields unchanged. This is used when we encounter | |
2142 | -- an unconditional flow of control change (return, goto, raise). In such | |
2143 | -- cases we don't need to clear the current values, since it may be that | |
2144 | -- the flow of control change occurs in a conditional context, and if it | |
2145 | -- is not taken, then it is just fine to keep the current values. But the | |
2146 | -- Last_Assignment field is different, if we have a sequence assign-to-v, | |
2147 | -- conditional-return, assign-to-v, we do not want to complain that the | |
2148 | -- second assignment clobbers the first. | |
2149 | ||
2150 | procedure Kill_Current_Values | |
2151 | (Ent : Entity_Id; | |
2152 | Last_Assignment_Only : Boolean := False); | |
b8dc622e JM |
2153 | -- This performs the same processing as described above for the form with |
2154 | -- no argument, but for the specific entity given. The call has no effect | |
cff7cd9b AC |
2155 | -- if the entity Ent is not for an object. Last_Assignment_Only has the |
2156 | -- same meaning as for the call with no Ent. | |
b8dc622e | 2157 | |
996ae0b0 | 2158 | procedure Kill_Size_Check_Code (E : Entity_Id); |
ce4a6e84 RD |
2159 | -- Called when an address clause or pragma Import is applied to an entity. |
2160 | -- If the entity is a variable or a constant, and size check code is | |
1e0e6534 AC |
2161 | -- present, this size check code is killed, since the object will not be |
2162 | -- allocated by the program. | |
996ae0b0 | 2163 | |
bf604a5e AC |
2164 | function Known_Non_Null (N : Node_Id) return Boolean; |
2165 | -- Given a node N for a subexpression of an access type, determines if | |
2166 | -- this subexpression yields a value that is known at compile time to | |
2167 | -- be non-null and returns True if so. Returns False otherwise. It is | |
2168 | -- an error to call this function if N is not of an access type. | |
2169 | ||
2170 | function Known_Null (N : Node_Id) return Boolean; | |
2171 | -- Given a node N for a subexpression of an access type, determines if this | |
2172 | -- subexpression yields a value that is known at compile time to be null | |
2173 | -- and returns True if so. Returns False otherwise. It is an error to call | |
2174 | -- this function if N is not of an access type. | |
2175 | ||
9b0986f8 RD |
2176 | function Known_To_Be_Assigned (N : Node_Id) return Boolean; |
2177 | -- The node N is an entity reference. This function determines whether the | |
2178 | -- reference is for sure an assignment of the entity, returning True if | |
2179 | -- so. This differs from May_Be_Lvalue in that it defaults in the other | |
2180 | -- direction. Cases which may possibly be assignments but are not known to | |
2181 | -- be may return True from May_Be_Lvalue, but False from this function. | |
2182 | ||
2933b16c RD |
2183 | function Last_Source_Statement (HSS : Node_Id) return Node_Id; |
2184 | -- HSS is a handled statement sequence. This function returns the last | |
2185 | -- statement in Statements (HSS) that has Comes_From_Source set. If no | |
2186 | -- such statement exists, Empty is returned. | |
1d801f21 | 2187 | |
90e491a7 PMR |
2188 | procedure Mark_Coextensions (Context_Nod : Node_Id; Root_Nod : Node_Id); |
2189 | -- Given a node which designates the context of analysis and an origin in | |
2190 | -- the tree, traverse from Root_Nod and mark all allocators as either | |
2191 | -- dynamic or static depending on Context_Nod. Any incorrect marking is | |
2192 | -- cleaned up during resolution. | |
2193 | ||
2194 | procedure Mark_Elaboration_Attributes | |
7fb62ca1 HK |
2195 | (N_Id : Node_Or_Entity_Id; |
2196 | Checks : Boolean := False; | |
2197 | Level : Boolean := False; | |
2198 | Modes : Boolean := False; | |
2199 | Warnings : Boolean := False); | |
90e491a7 | 2200 | -- Preserve relevant elaboration-related properties of the context in |
7fb62ca1 HK |
2201 | -- arbitrary entity or node N_Id. The flags control the properties as |
2202 | -- follows: | |
2203 | -- | |
2204 | -- Checks - Save the status of Elaboration_Check | |
2205 | -- Level - Save the declaration level of N_Id (if appicable) | |
2206 | -- Modes - Save the Ghost and SPARK modes in effect (if applicable) | |
2207 | -- Warnings - Save the status of Elab_Warnings | |
90e491a7 | 2208 | |
69e6ee2f HK |
2209 | procedure Mark_Save_Invocation_Graph_Of_Body; |
2210 | -- Notify the body of the main unit that the invocation constructs and | |
2211 | -- relations expressed within it must be recorded by the ABE mechanism. | |
2212 | ||
780d052e RD |
2213 | function Matching_Static_Array_Bounds |
2214 | (L_Typ : Node_Id; | |
2215 | R_Typ : Node_Id) return Boolean; | |
2216 | -- L_Typ and R_Typ are two array types. Returns True when they have the | |
2217 | -- same number of dimensions, and the same static bounds for each index | |
2218 | -- position. | |
2219 | ||
9b0986f8 RD |
2220 | function May_Be_Lvalue (N : Node_Id) return Boolean; |
2221 | -- Determines if N could be an lvalue (e.g. an assignment left hand side). | |
2222 | -- An lvalue is defined as any expression which appears in a context where | |
2223 | -- a name is required by the syntax, and the identity, rather than merely | |
2224 | -- the value of the node is needed (for example, the prefix of an Access | |
2225 | -- attribute is in this category). Note that, as implied by the name, this | |
2226 | -- test is conservative. If it cannot be sure that N is NOT an lvalue, then | |
2227 | -- it returns True. It tries hard to get the answer right, but it is hard | |
2228 | -- to guarantee this in all cases. Note that it is more possible to give | |
2229 | -- correct answer if the tree is fully analyzed. | |
2230 | ||
85be939e AC |
2231 | function Might_Raise (N : Node_Id) return Boolean; |
2232 | -- True if evaluation of N might raise an exception. This is conservative; | |
2233 | -- if we're not sure, we return True. If N is a subprogram body, this is | |
2234 | -- about whether execution of that body can raise. | |
2235 | ||
522aa6ee AC |
2236 | function Nearest_Enclosing_Instance (E : Entity_Id) return Entity_Id; |
2237 | -- Return the entity of the nearest enclosing instance which encapsulates | |
2238 | -- entity E. If no such instance exits, return Empty. | |
2239 | ||
a3d1ca01 HK |
2240 | function Needs_Finalization (Typ : Entity_Id) return Boolean; |
2241 | -- Determine whether type Typ is controlled and this requires finalization | |
2242 | -- actions. | |
2243 | ||
9e87a68d | 2244 | function Needs_One_Actual (E : Entity_Id) return Boolean; |
9fb1e654 AC |
2245 | -- Returns True if a function has defaults for all but its first formal, |
2246 | -- which is a controlling formal. Used in Ada 2005 mode to solve the | |
2247 | -- syntactic ambiguity that results from an indexing of a function call | |
2248 | -- that returns an array, so that Obj.F (X, Y) may mean F (Ob) (X, Y). | |
9e87a68d | 2249 | |
529749b9 HK |
2250 | function Needs_Simple_Initialization |
2251 | (Typ : Entity_Id; | |
2252 | Consider_IS : Boolean := True) return Boolean; | |
2253 | -- Certain types need initialization even though there is no specific | |
2254 | -- initialization routine: | |
2255 | -- Access types (which need initializing to null) | |
2256 | -- All scalar types if Normalize_Scalars mode set | |
2257 | -- Descendants of standard string types if Normalize_Scalars mode set | |
2258 | -- Scalar types having a Default_Value attribute | |
2259 | -- Regarding Initialize_Scalars mode, this is ignored if Consider_IS is | |
2260 | -- set to False, but if Consider_IS is set to True, then the cases above | |
2261 | -- mentioning Normalize_Scalars also apply for Initialize_Scalars mode. | |
2262 | ||
692918a9 HK |
2263 | function Needs_Variable_Reference_Marker |
2264 | (N : Node_Id; | |
2265 | Calls_OK : Boolean) return Boolean; | |
2266 | -- Determine whether arbitrary node N denotes a reference to a variable | |
2267 | -- which is suitable for SPARK elaboration checks. Flag Calls_OK should | |
2268 | -- be set when the reference is allowed to appear within calls. | |
2269 | ||
f3b01cd9 AC |
2270 | function New_Copy_List_Tree (List : List_Id) return List_Id; |
2271 | -- Copy recursively an analyzed list of nodes. Uses New_Copy_Tree defined | |
2272 | -- below. As for New_Copy_Tree, it is illegal to attempt to copy extended | |
2273 | -- nodes (entities) either directly or indirectly using this function. | |
2274 | ||
2275 | function New_Copy_Tree | |
6a4f3b31 HK |
2276 | (Source : Node_Id; |
2277 | Map : Elist_Id := No_Elist; | |
2278 | New_Sloc : Source_Ptr := No_Location; | |
2279 | New_Scope : Entity_Id := Empty; | |
2280 | Scopes_In_EWA_OK : Boolean := False) return Node_Id; | |
683af98c AC |
2281 | -- Perform a deep copy of the subtree rooted at Source. Entities, itypes, |
2282 | -- and nodes are handled separately as follows: | |
2283 | -- | |
2284 | -- * A node is replicated by first creating a shallow copy, then copying | |
2285 | -- its syntactic fields, where all Parent pointers of the fields are | |
2286 | -- updated to refer to the copy. In addition, the following semantic | |
2287 | -- fields are recreated after the replication takes place. | |
2288 | -- | |
2289 | -- First_Named_Actual | |
2290 | -- First_Real_Statement | |
2291 | -- Next_Named_Actual | |
2292 | -- | |
2293 | -- If applicable, the Etype field (if any) is updated to refer to a | |
2294 | -- local itype or type (see below). | |
2295 | -- | |
2296 | -- * An entity defined within an N_Expression_With_Actions node in the | |
2297 | -- subtree is given a new entity, and all references to the original | |
2298 | -- entity are updated to refer to the new entity. In addition, the | |
2299 | -- following semantic fields are replicated and/or updated to refer | |
2300 | -- to a local entity or itype. | |
2301 | -- | |
2302 | -- Discriminant_Constraint | |
2303 | -- Etype | |
2304 | -- First_Index | |
2305 | -- Next_Entity | |
2306 | -- Packed_Array_Impl_Type | |
2307 | -- Scalar_Range | |
2308 | -- Scope | |
2309 | -- | |
2310 | -- Note that currently no other expression can define entities. | |
2311 | -- | |
2312 | -- * An itype whose Associated_Node_For_Itype node is in the subtree | |
2313 | -- is given a new entity, and all references to the original itype | |
2314 | -- are updated to refer to the new itype. In addition, the following | |
2315 | -- semantic fields are replicated and/or updated to refer to a local | |
2316 | -- entity or itype. | |
2317 | -- | |
2318 | -- Discriminant_Constraint | |
2319 | -- Etype | |
2320 | -- First_Index | |
2321 | -- Next_Entity | |
2322 | -- Packed_Array_Impl_Type | |
2323 | -- Scalar_Range | |
2324 | -- Scope | |
2325 | -- | |
2326 | -- The Associated_Node_For_Itype is updated to refer to a replicated | |
2327 | -- node. | |
2328 | -- | |
2329 | -- The routine can replicate both analyzed and unanalyzed trees. Copying an | |
2330 | -- Empty or Error node yields the same node. | |
f3b01cd9 | 2331 | -- |
683af98c AC |
2332 | -- Parameter Map may be used to specify a set of mappings between entities. |
2333 | -- These mappings are then taken into account when replicating entities. | |
2334 | -- The format of Map must be as follows: | |
f3b01cd9 | 2335 | -- |
683af98c AC |
2336 | -- old entity 1 |
2337 | -- new entity to replace references to entity 1 | |
2338 | -- old entity 2 | |
2339 | -- new entity to replace references to entity 2 | |
2340 | -- ... | |
f3b01cd9 | 2341 | -- |
683af98c | 2342 | -- Map and its contents are left unchanged. |
f3b01cd9 | 2343 | -- |
683af98c AC |
2344 | -- Parameter New_Sloc may be used to specify a new source location for all |
2345 | -- replicated entities, itypes, and nodes. The Comes_From_Source indicator | |
2346 | -- is defaulted if a new source location is provided. | |
f3b01cd9 | 2347 | -- |
683af98c AC |
2348 | -- Parameter New_Scope may be used to specify a new scope for all copied |
2349 | -- entities and itypes. | |
6a4f3b31 HK |
2350 | -- |
2351 | -- Parameter Scopes_In_EWA_OK may be used to force the replication of both | |
2352 | -- scoping entities and non-scoping entities found within expression with | |
2353 | -- actions nodes. | |
f3b01cd9 | 2354 | |
996ae0b0 RK |
2355 | function New_External_Entity |
2356 | (Kind : Entity_Kind; | |
2357 | Scope_Id : Entity_Id; | |
2358 | Sloc_Value : Source_Ptr; | |
2359 | Related_Id : Entity_Id; | |
2360 | Suffix : Character; | |
2e5df295 | 2361 | Suffix_Index : Int := 0; |
fbf5a39b | 2362 | Prefix : Character := ' ') return Entity_Id; |
996ae0b0 RK |
2363 | -- This function creates an N_Defining_Identifier node for an internal |
2364 | -- created entity, such as an implicit type or subtype, or a record | |
2365 | -- initialization procedure. The entity name is constructed with a call | |
2366 | -- to New_External_Name (Related_Id, Suffix, Suffix_Index, Prefix), so | |
2367 | -- that the generated name may be referenced as a public entry, and the | |
2368 | -- Is_Public flag is set if needed (using Set_Public_Status). If the | |
2369 | -- entity is for a type or subtype, the size/align fields are initialized | |
2370 | -- to unknown (Uint_0). | |
2371 | ||
2372 | function New_Internal_Entity | |
2373 | (Kind : Entity_Kind; | |
2374 | Scope_Id : Entity_Id; | |
2375 | Sloc_Value : Source_Ptr; | |
fbf5a39b | 2376 | Id_Char : Character) return Entity_Id; |
996ae0b0 RK |
2377 | -- This function is similar to New_External_Entity, except that the |
2378 | -- name is constructed by New_Internal_Name (Id_Char). This is used | |
2379 | -- when the resulting entity does not have to be referenced as a | |
2380 | -- public entity (and in this case Is_Public is not set). | |
2381 | ||
996ae0b0 RK |
2382 | function Next_Actual (Actual_Id : Node_Id) return Node_Id; |
2383 | -- Find next actual parameter in declaration order. As described for | |
2384 | -- First_Actual, this is the next actual in the declaration order, not | |
2385 | -- the call order, so this does not correspond to simply taking the | |
2386 | -- next entry of the Parameter_Associations list. The argument is an | |
2387 | -- actual previously returned by a call to First_Actual or Next_Actual. | |
bf7c85c9 | 2388 | -- Note that the result produced is always an expression, not a parameter |
f3d57416 | 2389 | -- association node, even if named notation was used. |
996ae0b0 | 2390 | |
c7732bbe EB |
2391 | -- WARNING: There is a matching C declaration of this subprogram in fe.h |
2392 | ||
2393 | procedure Next_Actual (Actual_Id : in out Node_Id); | |
fb69239a | 2394 | pragma Inline (Next_Actual); |
c7732bbe EB |
2395 | -- Next_Actual (N) is equivalent to N := Next_Actual (N). Note that we |
2396 | -- inline this procedural form, but not the functional form above. | |
fb69239a AC |
2397 | |
2398 | function Next_Global (Node : Node_Id) return Node_Id; | |
2399 | -- Node is a global item from a list, obtained through calling First_Global | |
2400 | -- and possibly Next_Global a number of times. Returns the next global item | |
2401 | -- with the same mode. | |
2402 | ||
c7732bbe EB |
2403 | procedure Next_Global (Node : in out Node_Id); |
2404 | pragma Inline (Next_Actual); | |
2405 | -- Next_Global (N) is equivalent to N := Next_Global (N). Note that we | |
2406 | -- inline this procedural form, but not the functional form above. | |
2407 | ||
9dfc6c55 YM |
2408 | function No_Caching_Enabled (Id : Entity_Id) return Boolean; |
2409 | -- Given the entity of a variable, determine whether Id is subject to | |
2410 | -- volatility property No_Caching and if it is, the related expression | |
2411 | -- evaluates to True. | |
2412 | ||
d1eb8a82 AC |
2413 | function No_Heap_Finalization (Typ : Entity_Id) return Boolean; |
2414 | -- Determine whether type Typ is subject to pragma No_Heap_Finalization | |
2415 | ||
996ae0b0 RK |
2416 | procedure Normalize_Actuals |
2417 | (N : Node_Id; | |
2418 | S : Entity_Id; | |
2419 | Report : Boolean; | |
2420 | Success : out Boolean); | |
2421 | -- Reorders lists of actuals according to names of formals, value returned | |
f3d57416 | 2422 | -- in Success indicates success of reordering. For more details, see body. |
996ae0b0 RK |
2423 | -- Errors are reported only if Report is set to True. |
2424 | ||
ce4a6e84 | 2425 | procedure Note_Possible_Modification (N : Node_Id; Sure : Boolean); |
996ae0b0 RK |
2426 | -- This routine is called if the sub-expression N maybe the target of |
2427 | -- an assignment (e.g. it is the left side of an assignment, used as | |
2428 | -- an out parameters, or used as prefixes of access attributes). It | |
2429 | -- sets May_Be_Modified in the associated entity if there is one, | |
2430 | -- taking into account the rule that in the case of renamed objects, | |
2431 | -- it is the flag in the renamed object that must be set. | |
ce4a6e84 RD |
2432 | -- |
2433 | -- The parameter Sure is set True if the modification is sure to occur | |
2434 | -- (e.g. target of assignment, or out parameter), and to False if the | |
2435 | -- modification is only potential (e.g. address of entity taken). | |
996ae0b0 | 2436 | |
a8a42b93 AC |
2437 | function Null_To_Null_Address_Convert_OK |
2438 | (N : Node_Id; | |
2439 | Typ : Entity_Id := Empty) return Boolean; | |
2440 | -- Return True if we are compiling in relaxed RM semantics mode and: | |
3ab53b0d GD |
2441 | -- 1) N is a N_Null node and Typ is a descendant of System.Address, or |
2442 | -- 2) N is a comparison operator, one of the operands is null, and the | |
a8a42b93 AC |
2443 | -- type of the other operand is a descendant of System.Address. |
2444 | ||
bad0a3df | 2445 | function Number_Of_Elements_In_Array (T : Entity_Id) return Int; |
92b751fd PMR |
2446 | -- Returns the number of elements in the array T if the index bounds of T |
2447 | -- is known at compile time. If the bounds are not known at compile time, | |
2448 | -- the function returns the value zero. | |
bad0a3df | 2449 | |
e477d718 AC |
2450 | function Object_Access_Level (Obj : Node_Id) return Uint; |
2451 | -- Return the accessibility level of the view of the object Obj. For | |
2452 | -- convenience, qualified expressions applied to object names are also | |
2453 | -- allowed as actuals for this function. | |
2454 | ||
c9d70ab1 | 2455 | function Original_Aspect_Pragma_Name (N : Node_Id) return Name_Id; |
683af98c | 2456 | -- Retrieve the name of aspect or pragma N, taking into account a possible |
c9d70ab1 AC |
2457 | -- rewrite and whether the pragma is generated from an aspect as the names |
2458 | -- may be different. The routine also deals with 'Class in which case it | |
2459 | -- returns the following values: | |
2460 | -- | |
2461 | -- Invariant -> Name_uInvariant | |
c9d70ab1 | 2462 | -- Post'Class -> Name_uPost |
c9d70ab1 AC |
2463 | -- Pre'Class -> Name_uPre |
2464 | -- Type_Invariant -> Name_uType_Invariant | |
2465 | -- Type_Invariant'Class -> Name_uType_Invariant | |
ff7a7e12 | 2466 | |
e5f2c03c AC |
2467 | function Original_Corresponding_Operation (S : Entity_Id) return Entity_Id; |
2468 | -- [Ada 2012: AI05-0125-1]: If S is an inherited dispatching primitive S2, | |
2469 | -- or overrides an inherited dispatching primitive S2, the original | |
2470 | -- corresponding operation of S is the original corresponding operation of | |
2471 | -- S2. Otherwise, it is S itself. | |
2472 | ||
caa64a44 AC |
2473 | procedure Output_Entity (Id : Entity_Id); |
2474 | -- Print entity Id to standard output. The name of the entity appears in | |
2475 | -- fully qualified form. | |
2476 | -- | |
2477 | -- WARNING: this routine should be used in debugging scenarios such as | |
2478 | -- tracking down undefined symbols as it is fairly low level. | |
2479 | ||
2480 | procedure Output_Name (Nam : Name_Id; Scop : Entity_Id := Current_Scope); | |
2481 | -- Print name Nam to standard output. The name appears in fully qualified | |
2482 | -- form assuming it appears in scope Scop. Note that this may not reflect | |
2483 | -- the final qualification as the entity which carries the name may be | |
2484 | -- relocated to a different scope. | |
2485 | -- | |
2486 | -- WARNING: this routine should be used in debugging scenarios such as | |
2487 | -- tracking down undefined symbols as it is fairly low level. | |
2488 | ||
c5cec2fe AC |
2489 | function Policy_In_Effect (Policy : Name_Id) return Name_Id; |
2490 | -- Given a policy, return the policy identifier associated with it. If no | |
2491 | -- such policy is in effect, the value returned is No_Name. | |
2492 | ||
b8e6830b AC |
2493 | function Predicate_Tests_On_Arguments (Subp : Entity_Id) return Boolean; |
2494 | -- Subp is the entity for a subprogram call. This function returns True if | |
2495 | -- predicate tests are required for the arguments in this call (this is the | |
2496 | -- normal case). It returns False for special cases where these predicate | |
2497 | -- tests should be skipped (see body for details). | |
2498 | ||
ce2b6ba5 JM |
2499 | function Primitive_Names_Match (E1, E2 : Entity_Id) return Boolean; |
2500 | -- Returns True if the names of both entities correspond with matching | |
2501 | -- primitives. This routine includes support for the case in which one | |
2502 | -- or both entities correspond with entities built by Derive_Subprogram | |
30783513 RW |
2503 | -- with a special name to avoid being overridden (i.e. return true in case |
2504 | -- of entities with names "nameP" and "name" or vice versa). | |
ce2b6ba5 | 2505 | |
996ae0b0 RK |
2506 | function Private_Component (Type_Id : Entity_Id) return Entity_Id; |
2507 | -- Returns some private component (if any) of the given Type_Id. | |
2508 | -- Used to enforce the rules on visibility of operations on composite | |
2509 | -- types, that depend on the full view of the component type. For a | |
2510 | -- record type there may be several such components, we just return | |
2511 | -- the first one. | |
2512 | ||
07fc65c4 GB |
2513 | procedure Process_End_Label |
2514 | (N : Node_Id; | |
2515 | Typ : Character; | |
91b1417d | 2516 | Ent : Entity_Id); |
996ae0b0 RK |
2517 | -- N is a node whose End_Label is to be processed, generating all |
2518 | -- appropriate cross-reference entries, and performing style checks | |
2519 | -- for any identifier references in the end label. Typ is either | |
2520 | -- 'e' or 't indicating the type of the cross-reference entity | |
07fc65c4 GB |
2521 | -- (e for spec, t for body, see Lib.Xref spec for details). The |
2522 | -- parameter Ent gives the entity to which the End_Label refers, | |
2523 | -- and to which cross-references are to be generated. | |
996ae0b0 | 2524 | |
124bed29 | 2525 | procedure Propagate_Concurrent_Flags |
4969efdf AC |
2526 | (Typ : Entity_Id; |
2527 | Comp_Typ : Entity_Id); | |
2528 | -- Set Has_Task, Has_Protected and Has_Timing_Event on Typ when the flags | |
2529 | -- are set on Comp_Typ. This follows the definition of these flags which | |
2530 | -- are set (recursively) on any composite type which has a component marked | |
2531 | -- by one of these flags. This procedure can only set flags for Typ, and | |
2532 | -- never clear them. Comp_Typ is the type of a component or a parent. | |
2533 | ||
f63d601b HK |
2534 | procedure Propagate_DIC_Attributes |
2535 | (Typ : Entity_Id; | |
2536 | From_Typ : Entity_Id); | |
2537 | -- Inherit all Default_Initial_Condition-related attributes from type | |
2538 | -- From_Typ. Typ is the destination type. | |
2539 | ||
2540 | procedure Propagate_Invariant_Attributes | |
2541 | (Typ : Entity_Id; | |
2542 | From_Typ : Entity_Id); | |
2543 | -- Inherit all invariant-related attributes form type From_Typ. Typ is the | |
2544 | -- destination type. | |
2545 | ||
fdc54be6 AC |
2546 | procedure Record_Possible_Part_Of_Reference |
2547 | (Var_Id : Entity_Id; | |
2548 | Ref : Node_Id); | |
2549 | -- Save reference Ref to variable Var_Id when the variable is subject to | |
2550 | -- pragma Part_Of. If the variable is known to be a constituent of a single | |
2551 | -- protected/task type, the legality of the reference is verified and the | |
2552 | -- save does not take place. | |
2553 | ||
f40f731b AC |
2554 | function Referenced (Id : Entity_Id; Expr : Node_Id) return Boolean; |
2555 | -- Determine whether entity Id is referenced within expression Expr | |
2556 | ||
93c3fca7 | 2557 | function References_Generic_Formal_Type (N : Node_Id) return Boolean; |
3ab53b0d GD |
2558 | -- Returns True if the expression Expr contains any references to a generic |
2559 | -- type. This can only happen within a generic template. | |
93c3fca7 | 2560 | |
3f6d1daa | 2561 | procedure Remove_Entity_And_Homonym (Id : Entity_Id); |
74a78a4f AC |
2562 | -- Remove arbitrary entity Id from both the homonym and scope chains. Use |
2563 | -- Remove_Overloaded_Entity for overloadable entities. Note: the removal | |
2564 | -- performed by this routine does not affect the visibility of existing | |
2565 | -- homonyms. | |
2566 | ||
3f6d1daa JS |
2567 | procedure Remove_Homonym (Id : Entity_Id); |
2568 | -- Removes entity Id from the homonym chain | |
ce2b6ba5 | 2569 | |
e5f2c03c AC |
2570 | procedure Remove_Overloaded_Entity (Id : Entity_Id); |
2571 | -- Remove arbitrary entity Id from the homonym chain, the scope chain and | |
74a78a4f AC |
2572 | -- the primitive operations list of the associated controlling type. Use |
2573 | -- Remove_Entity for non-overloadable entities. Note: the removal performed | |
2574 | -- by this routine does not affect the visibility of existing homonyms. | |
e5f2c03c | 2575 | |
e645cb39 AC |
2576 | function Remove_Suffix (E : Entity_Id; Suffix : Character) return Name_Id; |
2577 | -- Returns the name of E without Suffix | |
2578 | ||
a8a42b93 AC |
2579 | procedure Replace_Null_By_Null_Address (N : Node_Id); |
2580 | -- N is N_Null or a binary comparison operator, we are compiling in relaxed | |
3ab53b0d | 2581 | -- RM semantics mode, and one of the operands is null. Replace null with |
a8a42b93 AC |
2582 | -- System.Null_Address. |
2583 | ||
fbf5a39b AC |
2584 | function Rep_To_Pos_Flag (E : Entity_Id; Loc : Source_Ptr) return Node_Id; |
2585 | -- This is used to construct the second argument in a call to Rep_To_Pos | |
2586 | -- which is Standard_True if range checks are enabled (E is an entity to | |
2587 | -- which the Range_Checks_Suppressed test is applied), and Standard_False | |
2588 | -- if range checks are suppressed. Loc is the location for the node that | |
2589 | -- is returned (which is a New_Occurrence of the appropriate entity). | |
2590 | -- | |
2591 | -- Note: one might think that it would be fine to always use True and | |
2592 | -- to ignore the suppress in this case, but it is generally better to | |
2593 | -- believe a request to suppress exceptions if possible, and further | |
2594 | -- more there is at least one case in the generated code (the code for | |
2595 | -- array assignment in a loop) that depends on this suppression. | |
2596 | ||
2597 | procedure Require_Entity (N : Node_Id); | |
2598 | -- N is a node which should have an entity value if it is an entity name. | |
2599 | -- If not, then check if there were previous errors. If so, just fill | |
2600 | -- in with Any_Id and ignore. Otherwise signal a program error exception. | |
2601 | -- This is used as a defense mechanism against ill-formed trees caused by | |
2602 | -- previous errors (particularly in -gnatq mode). | |
2603 | ||
996ae0b0 | 2604 | function Requires_Transient_Scope (Id : Entity_Id) return Boolean; |
2c1b72d7 | 2605 | -- Id is a type entity. The result is True when temporaries of this type |
df3e68b1 HK |
2606 | -- need to be wrapped in a transient scope to be reclaimed properly when a |
2607 | -- secondary stack is in use. Examples of types requiring such wrapping are | |
2608 | -- controlled types and variable-sized types including unconstrained | |
2609 | -- arrays. | |
996ae0b0 | 2610 | |
c7732bbe EB |
2611 | -- WARNING: There is a matching C declaration of this subprogram in fe.h |
2612 | ||
996ae0b0 RK |
2613 | procedure Reset_Analyzed_Flags (N : Node_Id); |
2614 | -- Reset the Analyzed flags in all nodes of the tree whose root is N | |
2615 | ||
3815f967 | 2616 | procedure Restore_SPARK_Mode (Mode : SPARK_Mode_Type; Prag : Node_Id); |
f9a8f910 HK |
2617 | -- Set the current SPARK_Mode to Mode and SPARK_Mode_Pragma to Prag. This |
2618 | -- routine must be used in tandem with Set_SPARK_Mode. | |
c61ef416 | 2619 | |
84f4072a JM |
2620 | function Returns_Unconstrained_Type (Subp : Entity_Id) return Boolean; |
2621 | -- Return true if Subp is a function that returns an unconstrained type | |
2622 | ||
8a5e4b2a AC |
2623 | function Root_Type_Of_Full_View (T : Entity_Id) return Entity_Id; |
2624 | -- Similar to attribute Root_Type, but this version always follows the | |
2625 | -- Full_View of a private type (if available) while searching for the | |
2626 | -- ultimate derivation ancestor. | |
2627 | ||
fbf5a39b AC |
2628 | function Safe_To_Capture_Value |
2629 | (N : Node_Id; | |
9b0986f8 RD |
2630 | Ent : Entity_Id; |
2631 | Cond : Boolean := False) return Boolean; | |
2632 | -- The caller is interested in capturing a value (either the current value, | |
2633 | -- or an indication that the value is non-null) for the given entity Ent. | |
2634 | -- This value can only be captured if sequential execution semantics can be | |
2635 | -- properly guaranteed so that a subsequent reference will indeed be sure | |
2636 | -- that this current value indication is correct. The node N is the | |
2637 | -- construct which resulted in the possible capture of the value (this | |
2638 | -- is used to check if we are in a conditional). | |
2639 | -- | |
2640 | -- Cond is used to skip the test for being inside a conditional. It is used | |
2641 | -- in the case of capturing values from if/while tests, which already do a | |
2642 | -- proper job of handling scoping issues without this help. | |
2643 | -- | |
2644 | -- The only entities whose values can be captured are OUT and IN OUT formal | |
2645 | -- parameters, and variables unless Cond is True, in which case we also | |
2646 | -- allow IN formals, loop parameters and constants, where we cannot ever | |
2647 | -- capture actual value information, but we can capture conditional tests. | |
fbf5a39b | 2648 | |
996ae0b0 | 2649 | function Same_Name (N1, N2 : Node_Id) return Boolean; |
1b6c95c4 RD |
2650 | -- Determine if two (possibly expanded) names are the same name. This is |
2651 | -- a purely syntactic test, and N1 and N2 need not be analyzed. | |
2652 | ||
2653 | function Same_Object (Node1, Node2 : Node_Id) return Boolean; | |
2654 | -- Determine if Node1 and Node2 are known to designate the same object. | |
f3d57416 | 2655 | -- This is a semantic test and both nodes must be fully analyzed. A result |
1b6c95c4 RD |
2656 | -- of True is decisively correct. A result of False does not necessarily |
2657 | -- mean that different objects are designated, just that this could not | |
2658 | -- be reliably determined at compile time. | |
996ae0b0 RK |
2659 | |
2660 | function Same_Type (T1, T2 : Entity_Id) return Boolean; | |
2661 | -- Determines if T1 and T2 represent exactly the same type. Two types | |
2662 | -- are the same if they are identical, or if one is an unconstrained | |
2663 | -- subtype of the other, or they are both common subtypes of the same | |
638e383e | 2664 | -- type with identical constraints. The result returned is conservative. |
996ae0b0 RK |
2665 | -- It is True if the types are known to be the same, but a result of |
2666 | -- False is indecisive (e.g. the compiler may not be able to tell that | |
2667 | -- two constraints are identical). | |
2668 | ||
1b6c95c4 RD |
2669 | function Same_Value (Node1, Node2 : Node_Id) return Boolean; |
2670 | -- Determines if Node1 and Node2 are known to be the same value, which is | |
2671 | -- true if they are both compile time known values and have the same value, | |
2672 | -- or if they are the same object (in the sense of function Same_Object). | |
2673 | -- A result of False does not necessarily mean they have different values, | |
2674 | -- just that it is not possible to determine they have the same value. | |
2675 | ||
f16cb8df HK |
2676 | function Scalar_Part_Present (Typ : Entity_Id) return Boolean; |
2677 | -- Determine whether arbitrary type Typ is a scalar type, or contains at | |
2678 | -- least one scalar subcomponent. | |
e5c4e2bc | 2679 | |
90e491a7 PMR |
2680 | function Scope_Within |
2681 | (Inner : Entity_Id; | |
2682 | Outer : Entity_Id) return Boolean; | |
2683 | -- Determine whether scope Inner appears within scope Outer. Note that | |
2684 | -- scopes are partially ordered, so Scope_Within (A, B) and Scope_Within | |
2685 | -- (B, A) may both return False. | |
2686 | ||
2687 | function Scope_Within_Or_Same | |
2688 | (Inner : Entity_Id; | |
2689 | Outer : Entity_Id) return Boolean; | |
9aaea2cc | 2690 | -- Determine whether scope Inner appears within scope Outer or both denote |
90e491a7 PMR |
2691 | -- the same scope. Note that scopes are partially ordered, so Scope_Within |
2692 | -- (A, B) and Scope_Within (B, A) may both return False. | |
996ae0b0 | 2693 | |
7f0e4cdb BD |
2694 | procedure Set_Convention (E : Entity_Id; Val : Convention_Id); |
2695 | -- Same as Basic_Set_Convention, but with an extra check for access types. | |
2696 | -- In particular, if E is an access-to-subprogram type, and Val is a | |
2697 | -- foreign convention, then we set Can_Use_Internal_Rep to False on E. | |
80c2c202 AC |
2698 | -- Also, if the Etype of E is set and is an anonymous access type with |
2699 | -- no convention set, this anonymous type inherits the convention of E. | |
7f0e4cdb | 2700 | |
996ae0b0 | 2701 | procedure Set_Current_Entity (E : Entity_Id); |
b81a5940 | 2702 | pragma Inline (Set_Current_Entity); |
996ae0b0 | 2703 | -- Establish the entity E as the currently visible definition of its |
1d10f669 | 2704 | -- associated name (i.e. the Node_Id associated with its name). |
996ae0b0 | 2705 | |
7e5e5cc7 RD |
2706 | procedure Set_Debug_Info_Needed (T : Entity_Id); |
2707 | -- Sets the Debug_Info_Needed flag on entity T , and also on any entities | |
2708 | -- that are needed by T (for an object, the type of the object is needed, | |
2709 | -- and for a type, various subsidiary types are needed -- see body for | |
2710 | -- details). Never has any effect on T if the Debug_Info_Off flag is set. | |
2711 | -- This routine should always be used instead of Set_Needs_Debug_Info to | |
2712 | -- ensure that subsidiary entities are properly handled. | |
2713 | ||
e7ba564f RD |
2714 | procedure Set_Entity_With_Checks (N : Node_Id; Val : Entity_Id); |
2715 | -- This procedure has the same calling sequence as Set_Entity, but it | |
2716 | -- performs additional checks as follows: | |
2717 | -- | |
2718 | -- If Style_Check is set, then it calls a style checking routine which | |
2719 | -- can check identifier spelling style. This procedure also takes care | |
2720 | -- of checking the restriction No_Implementation_Identifiers. | |
2721 | -- | |
2722 | -- If restriction No_Abort_Statements is set, then it checks that the | |
2723 | -- entity is not Ada.Task_Identification.Abort_Task. | |
2724 | -- | |
2725 | -- If restriction No_Dynamic_Attachment is set, then it checks that the | |
2726 | -- entity is not one of the restricted names for this restriction. | |
2727 | -- | |
bb012790 | 2728 | -- If restriction No_Long_Long_Integers is set, then it checks that the |
ee10c0ec RD |
2729 | -- entity is not Standard.Long_Long_Integer. |
2730 | -- | |
e7ba564f RD |
2731 | -- If restriction No_Implementation_Identifiers is set, then it checks |
2732 | -- that the entity is not implementation defined. | |
996ae0b0 | 2733 | |
529749b9 HK |
2734 | procedure Set_Invalid_Scalar_Value |
2735 | (Scal_Typ : Float_Scalar_Id; | |
2736 | Value : Ureal); | |
2737 | -- Associate invalid value Value with scalar type Scal_Typ as specified by | |
2738 | -- pragma Initialize_Scalars. | |
2739 | ||
2740 | procedure Set_Invalid_Scalar_Value | |
2741 | (Scal_Typ : Integer_Scalar_Id; | |
2742 | Value : Uint); | |
2743 | -- Associate invalid value Value with scalar type Scal_Typ as specified by | |
2744 | -- pragma Initialize_Scalars. | |
2745 | ||
996ae0b0 | 2746 | procedure Set_Name_Entity_Id (Id : Name_Id; Val : Entity_Id); |
b81a5940 | 2747 | pragma Inline (Set_Name_Entity_Id); |
996ae0b0 RK |
2748 | -- Sets the Entity_Id value associated with the given name, which is the |
2749 | -- Id of the innermost visible entity with the given name. See the body | |
2750 | -- of package Sem_Ch8 for further details on the handling of visibility. | |
2751 | ||
2752 | procedure Set_Next_Actual (Ass1_Id : Node_Id; Ass2_Id : Node_Id); | |
2753 | -- The arguments may be parameter associations, whose descendants | |
2754 | -- are the optional formal name and the actual parameter. Positional | |
2755 | -- parameters are already members of a list, and do not need to be | |
2756 | -- chained separately. See also First_Actual and Next_Actual. | |
2757 | ||
ce4a6e84 RD |
2758 | procedure Set_Optimize_Alignment_Flags (E : Entity_Id); |
2759 | pragma Inline (Set_Optimize_Alignment_Flags); | |
f3d0f304 | 2760 | -- Sets Optimize_Alignment_Space/Time flags in E from current settings |
ce4a6e84 | 2761 | |
996ae0b0 RK |
2762 | procedure Set_Public_Status (Id : Entity_Id); |
2763 | -- If an entity (visible or otherwise) is defined in a library | |
2764 | -- package, or a package that is itself public, then this subprogram | |
2765 | -- labels the entity public as well. | |
2766 | ||
7f0e4cdb BD |
2767 | procedure Set_Referenced_Modified (N : Node_Id; Out_Param : Boolean); |
2768 | -- N is the node for either a left hand side (Out_Param set to False), | |
2769 | -- or an Out or In_Out parameter (Out_Param set to True). If there is | |
2770 | -- an assignable entity being referenced, then the appropriate flag | |
2771 | -- (Referenced_As_LHS if Out_Param is False, Referenced_As_Out_Parameter | |
2772 | -- if Out_Param is True) is set True, and the other flag set False. | |
2773 | ||
72a26637 | 2774 | procedure Set_Rep_Info (T1 : Entity_Id; T2 : Entity_Id); |
db174c98 AC |
2775 | pragma Inline (Set_Rep_Info); |
2776 | -- Copies the Is_Atomic, Is_Independent and Is_Volatile_Full_Access flags | |
2777 | -- from sub(type) entity T2 to (sub)type entity T1, as well as Is_Volatile | |
2778 | -- if T1 is a base type. | |
2779 | ||
996ae0b0 RK |
2780 | procedure Set_Scope_Is_Transient (V : Boolean := True); |
2781 | -- Set the flag Is_Transient of the current scope | |
2782 | ||
2783 | procedure Set_Size_Info (T1, T2 : Entity_Id); | |
b81a5940 | 2784 | pragma Inline (Set_Size_Info); |
bf7c85c9 RD |
2785 | -- Copies the Esize field and Has_Biased_Representation flag from sub(type) |
2786 | -- entity T2 to (sub)type entity T1. Also copies the Is_Unsigned_Type flag | |
2787 | -- in the fixed-point and discrete cases, and also copies the alignment | |
2788 | -- value from T2 to T1. It does NOT copy the RM_Size field, which must be | |
2789 | -- separately set if this is required to be copied also. | |
996ae0b0 | 2790 | |
f9a8f910 HK |
2791 | procedure Set_SPARK_Mode (Context : Entity_Id); |
2792 | -- Establish the SPARK_Mode and SPARK_Mode_Pragma (if any) of a package or | |
2793 | -- a subprogram denoted by Context. This routine must be used in tandem | |
2794 | -- with Restore_SPARK_Mode. | |
2795 | ||
1b6c95c4 | 2796 | function Scope_Is_Transient return Boolean; |
bf7c85c9 | 2797 | -- True if the current scope is transient |
996ae0b0 | 2798 | |
be3416c6 AC |
2799 | function Should_Ignore_Pragma_Par (Prag_Name : Name_Id) return Boolean; |
2800 | function Should_Ignore_Pragma_Sem (N : Node_Id) return Boolean; | |
b043ae01 AC |
2801 | -- True if we should ignore pragmas with the specified name. In particular, |
2802 | -- this returns True if pragma Ignore_Pragma applies, and we are not in a | |
be3416c6 AC |
2803 | -- predefined unit. The _Par version should be called only from the parser; |
2804 | -- the _Sem version should be called only during semantic analysis. | |
b043ae01 | 2805 | |
1c54829e AC |
2806 | function Static_Boolean (N : Node_Id) return Uint; |
2807 | -- This function analyzes the given expression node and then resolves it | |
2808 | -- as Standard.Boolean. If the result is static, then Uint_1 or Uint_0 is | |
2809 | -- returned corresponding to the value, otherwise an error message is | |
2810 | -- output and No_Uint is returned. | |
2811 | ||
996ae0b0 RK |
2812 | function Static_Integer (N : Node_Id) return Uint; |
2813 | -- This function analyzes the given expression node and then resolves it | |
2814 | -- as any integer type. If the result is static, then the value of the | |
2815 | -- universal expression is returned, otherwise an error message is output | |
2816 | -- and a value of No_Uint is returned. | |
2817 | ||
2818 | function Statically_Different (E1, E2 : Node_Id) return Boolean; | |
2819 | -- Return True if it can be statically determined that the Expressions | |
2820 | -- E1 and E2 refer to different objects | |
2821 | ||
d436b30d AC |
2822 | function Subject_To_Loop_Entry_Attributes (N : Node_Id) return Boolean; |
2823 | -- Determine whether node N is a loop statement subject to at least one | |
2824 | -- 'Loop_Entry attribute. | |
2825 | ||
996ae0b0 | 2826 | function Subprogram_Access_Level (Subp : Entity_Id) return Uint; |
bf7c85c9 | 2827 | -- Return the accessibility level of the view denoted by Subp |
996ae0b0 | 2828 | |
0ebc109a VP |
2829 | function Support_Atomic_Primitives (Typ : Entity_Id) return Boolean; |
2830 | -- Return True if Typ supports the GCC built-in atomic operations (i.e. if | |
2831 | -- Typ is properly sized and aligned). | |
2832 | ||
996ae0b0 | 2833 | procedure Trace_Scope (N : Node_Id; E : Entity_Id; Msg : String); |
bf7c85c9 | 2834 | -- Print debugging information on entry to each unit being analyzed |
996ae0b0 RK |
2835 | |
2836 | procedure Transfer_Entities (From : Entity_Id; To : Entity_Id); | |
2837 | -- Move a list of entities from one scope to another, and recompute | |
2838 | -- Is_Public based upon the new scope. | |
2839 | ||
935b02ae YM |
2840 | generic |
2841 | with function Process (N : Node_Id) return Traverse_Result is <>; | |
1debd630 | 2842 | Process_Itypes : Boolean := False; |
935b02ae YM |
2843 | function Traverse_More_Func (Node : Node_Id) return Traverse_Final_Result; |
2844 | -- This is a version of Atree.Traverse_Func that not only traverses | |
2845 | -- syntactic children of nodes, but also semantic children which are | |
2846 | -- logically children of the node. This concerns currently lists of | |
2847 | -- action nodes and ranges under Itypes, both inserted by the compiler. | |
1debd630 | 2848 | -- Itypes are only traversed when Process_Itypes is True. |
935b02ae YM |
2849 | |
2850 | generic | |
2851 | with function Process (N : Node_Id) return Traverse_Result is <>; | |
1debd630 | 2852 | Process_Itypes : Boolean := False; |
935b02ae YM |
2853 | procedure Traverse_More_Proc (Node : Node_Id); |
2854 | pragma Inline (Traverse_More_Proc); | |
2855 | -- This is the same as Traverse_More_Func except that no result is | |
2856 | -- returned, i.e. Traverse_More_Func is called and the result is simply | |
2857 | -- discarded. | |
2858 | ||
996ae0b0 | 2859 | function Type_Access_Level (Typ : Entity_Id) return Uint; |
91b1417d | 2860 | -- Return the accessibility level of Typ |
996ae0b0 | 2861 | |
276e7ed0 | 2862 | function Type_Without_Stream_Operation |
9aff36e9 RD |
2863 | (T : Entity_Id; |
2864 | Op : TSS_Name_Type := TSS_Null) return Entity_Id; | |
2865 | -- AI05-0161: In Ada 2012, if the restriction No_Default_Stream_Attributes | |
2866 | -- is active then we cannot generate stream subprograms for composite types | |
2867 | -- with elementary subcomponents that lack user-defined stream subprograms. | |
276e7ed0 AC |
2868 | -- This predicate determines whether a type has such an elementary |
2869 | -- subcomponent. If Op is TSS_Null, a type that lacks either Read or Write | |
2870 | -- prevents the construction of a composite stream operation. If Op is | |
2871 | -- specified we check only for the given stream operation. | |
2872 | ||
b3b3ada9 HK |
2873 | function Ultimate_Prefix (N : Node_Id) return Node_Id; |
2874 | -- Obtain the "outermost" prefix of arbitrary node N. Return N if no such | |
2875 | -- prefix exists. | |
2876 | ||
d9b056ea | 2877 | function Unique_Defining_Entity (N : Node_Id) return Entity_Id; |
6b5eb7d7 | 2878 | -- Return the entity that represents declaration N, so that different |
57a8057a | 2879 | -- views of the same entity have the same unique defining entity: |
877a5a12 | 2880 | -- * private view and full view of a deferred constant |
7738270b AC |
2881 | -- --> full view |
2882 | -- * entry spec and entry body | |
2883 | -- --> entry spec | |
2884 | -- * formal parameter on spec and body | |
2885 | -- --> formal parameter on spec | |
2886 | -- * package spec, body, and body stub | |
2887 | -- --> package spec | |
2888 | -- * protected type, protected body, and protected body stub | |
2889 | -- --> protected type (full view if private) | |
2890 | -- * subprogram spec, body, and body stub | |
2891 | -- --> subprogram spec | |
2892 | -- * task type, task body, and task body stub | |
2893 | -- --> task type (full view if private) | |
2894 | -- * private or incomplete view and full view of a type | |
2895 | -- --> full view | |
57a8057a AC |
2896 | -- In other cases, return the defining entity for N. |
2897 | ||
2898 | function Unique_Entity (E : Entity_Id) return Entity_Id; | |
2899 | -- Return the unique entity for entity E, which would be returned by | |
2900 | -- Unique_Defining_Entity if applied to the enclosing declaration of E. | |
d9b056ea | 2901 | |
6a2e5d0f AC |
2902 | function Unique_Name (E : Entity_Id) return String; |
2903 | -- Return a unique name for entity E, which could be used to identify E | |
2904 | -- across compilation units. | |
2905 | ||
1ae0159e SB |
2906 | Child_Prefix : constant String := "ada___"; |
2907 | -- Prefix for child packages when building a unique name for an entity. It | |
2908 | -- is included here to share between Unique_Name and gnatprove. | |
2909 | ||
4561baf7 ES |
2910 | function Unit_Is_Visible (U : Entity_Id) return Boolean; |
2911 | -- Determine whether a compilation unit is visible in the current context, | |
2912 | -- because there is a with_clause that makes the unit available. Used to | |
2913 | -- provide better messages on common visiblity errors on operators. | |
2914 | ||
fbf5a39b | 2915 | function Universal_Interpretation (Opnd : Node_Id) return Entity_Id; |
d7567964 | 2916 | -- Yields Universal_Integer or Universal_Real if this is a candidate |
996ae0b0 | 2917 | |
9b0986f8 | 2918 | function Unqualify (Expr : Node_Id) return Node_Id; |
b81a5940 JM |
2919 | pragma Inline (Unqualify); |
2920 | -- Removes any qualifications from Expr. For example, for T1'(T2'(X)), this | |
2921 | -- returns X. If Expr is not a qualified expression, returns Expr. | |
9b0986f8 | 2922 | |
0691ed6b AC |
2923 | function Unqual_Conv (Expr : Node_Id) return Node_Id; |
2924 | pragma Inline (Unqual_Conv); | |
2925 | -- Similar to Unqualify, but removes qualified expressions, type | |
2926 | -- conversions, and unchecked conversions. | |
2927 | ||
f16cb8df HK |
2928 | function Validated_View (Typ : Entity_Id) return Entity_Id; |
2929 | -- Obtain the "validated view" of arbitrary type Typ which is suitable | |
2930 | -- for verification by attributes 'Valid and 'Valid_Scalars. This view | |
2931 | -- is the type itself or its full view while stripping away concurrency, | |
2932 | -- derivations, and privacy. | |
2933 | ||
ea034236 AC |
2934 | function Visible_Ancestors (Typ : Entity_Id) return Elist_Id; |
2935 | -- [Ada 2012:AI-0125-1]: Collect all the visible parents and progenitors | |
2936 | -- of a type extension or private extension declaration. If the full-view | |
2937 | -- of private parents and progenitors is available then it is used to | |
2938 | -- generate the list of visible ancestors; otherwise their partial | |
2939 | -- view is added to the resulting list. | |
2940 | ||
996ae0b0 | 2941 | function Within_Init_Proc return Boolean; |
fbf5a39b | 2942 | -- Determines if Current_Scope is within an init proc |
996ae0b0 | 2943 | |
66f95f60 AC |
2944 | function Within_Protected_Type (E : Entity_Id) return Boolean; |
2945 | -- Returns True if entity E is declared within a protected type | |
2946 | ||
42959b0c | 2947 | function Within_Scope (E : Entity_Id; S : Entity_Id) return Boolean; |
eeedaac5 | 2948 | -- Returns True if entity E is declared within scope S |
42959b0c | 2949 | |
daf82dd8 HK |
2950 | function Within_Subprogram_Call (N : Node_Id) return Boolean; |
2951 | -- Determine whether arbitrary node N appears in an entry, function, or | |
2952 | -- procedure call. | |
2953 | ||
996ae0b0 | 2954 | procedure Wrong_Type (Expr : Node_Id; Expected_Type : Entity_Id); |
b81a5940 JM |
2955 | -- Output error message for incorrectly typed expression. Expr is the node |
2956 | -- for the incorrectly typed construct (Etype (Expr) is the type found), | |
2957 | -- and Expected_Type is the entity for the expected type. Note that Expr | |
2958 | -- does not have to be a subexpression, anything with an Etype field may | |
2959 | -- be used. | |
996ae0b0 | 2960 | |
75b87c16 AC |
2961 | function Yields_Synchronized_Object (Typ : Entity_Id) return Boolean; |
2962 | -- Determine whether type Typ "yields synchronized object" as specified by | |
2963 | -- SPARK RM 9.1. To qualify as such, a type must be | |
2964 | -- * An array type whose element type yields a synchronized object | |
2965 | -- * A descendant of type Ada.Synchronous_Task_Control.Suspension_Object | |
2966 | -- * A protected type | |
2967 | -- * A record type or type extension without defaulted discriminants | |
2968 | -- whose components are of a type that yields a synchronized object. | |
2969 | -- * A synchronized interface type | |
2970 | -- * A task type | |
2971 | ||
5c63aafa HK |
2972 | function Yields_Universal_Type (N : Node_Id) return Boolean; |
2973 | -- Determine whether unanalyzed node N yields a universal type | |
2974 | ||
c8324fe7 SB |
2975 | package Interval_Lists is |
2976 | type Discrete_Interval is | |
2977 | record | |
2978 | Low, High : Uint; | |
2979 | end record; | |
2980 | ||
2981 | type Discrete_Interval_List is | |
2982 | array (Pos range <>) of Discrete_Interval; | |
2983 | -- A sorted (in ascending order) list of non-empty pairwise-disjoint | |
2984 | -- intervals, always with a gap of at least one value between | |
2985 | -- successive intervals (i.e., mergeable intervals are merged). | |
2986 | -- Low bound is one; high bound is nonnegative. | |
2987 | ||
2988 | function Type_Intervals (Typ : Entity_Id) return Discrete_Interval_List; | |
2989 | -- Given a static discrete type or subtype, returns the (unique) | |
2990 | -- interval list representing the values of the type/subtype. | |
2991 | -- If no static predicates are involved, the length of the result | |
2992 | -- will be at most one. | |
2993 | ||
2994 | function Choice_List_Intervals (Discrete_Choices : List_Id) | |
2995 | return Discrete_Interval_List; | |
2996 | -- Given a discrete choice list, returns the (unique) interval | |
60f66f34 | 2997 | -- list representing the chosen values. |
c8324fe7 SB |
2998 | |
2999 | function Is_Subset (Subset, Of_Set : Discrete_Interval_List) | |
3000 | return Boolean; | |
3001 | -- Returns True iff every value belonging to some interval of | |
3002 | -- Subset also belongs to some interval of Of_Set. | |
3003 | ||
3004 | -- TBD: When we get around to implementing "is statically compatible" | |
3005 | -- correctly for real types with static predicates, we may need | |
3006 | -- an analogous Real_Interval_List type. Most of the language | |
3007 | -- rules that reference "is statically compatible" pertain to | |
3008 | -- discriminants and therefore do require support for real types; | |
3009 | -- the exception is 12.5.1(8). | |
3010 | end Interval_Lists; | |
996ae0b0 | 3011 | end Sem_Util; |