]>
Commit | Line | Data |
---|---|---|
996ae0b0 RK |
1 | ------------------------------------------------------------------------------ |
2 | -- -- | |
3 | -- GNAT COMPILER COMPONENTS -- | |
4 | -- -- | |
5 | -- S E M _ A T T R -- | |
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- -- | |
748086b7 | 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 -- | |
748086b7 JJ |
16 | -- or FITNESS FOR A PARTICULAR PURPOSE. -- |
17 | -- -- | |
18 | -- You should have received a copy of the GNU General Public License along -- | |
19 | -- with this program; see file COPYING3. If not see -- | |
20 | -- <http://www.gnu.org/licenses/>. -- | |
996ae0b0 RK |
21 | -- -- |
22 | -- GNAT was originally developed by the GNAT team at New York University. -- | |
71ff80dc | 23 | -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
996ae0b0 RK |
24 | -- -- |
25 | ------------------------------------------------------------------------------ | |
26 | ||
27 | -- Attribute handling is isolated in a separate package to ease the addition | |
28 | -- of implementation defined attributes. Logically this processing belongs | |
29 | -- in chapter 4. See Sem_Ch4 for a description of the relation of the | |
30 | -- Analyze and Resolve routines for expression components. | |
31 | ||
32 | -- This spec also documents all GNAT implementation defined pragmas | |
33 | ||
edd63e9b | 34 | with Exp_Tss; use Exp_Tss; |
822033eb | 35 | with Namet; use Namet; |
edd63e9b ES |
36 | with Snames; use Snames; |
37 | with Types; use Types; | |
996ae0b0 RK |
38 | |
39 | package Sem_Attr is | |
40 | ||
996ae0b0 RK |
41 | ----------------------------------------- |
42 | -- Implementation Dependent Attributes -- | |
43 | ----------------------------------------- | |
44 | ||
eaed2a2c AC |
45 | -- This section describes the implementation dependent attributes provided |
46 | -- in GNAT, as well as constructing an array of flags indicating which | |
47 | -- attributes these are. | |
996ae0b0 | 48 | |
aff557c7 AC |
49 | Attribute_Impl_Def : constant Attribute_Class_Array := |
50 | Attribute_Class_Array'( | |
996ae0b0 RK |
51 | |
52 | ------------------ | |
53 | -- Abort_Signal -- | |
54 | ------------------ | |
55 | ||
56 | Attribute_Abort_Signal => True, | |
edd63e9b ES |
57 | -- Standard'Abort_Signal (Standard is the only allowed prefix) provides |
58 | -- the entity for the special exception used to signal task abort or | |
59 | -- asynchronous transfer of control. Normally this attribute should only | |
60 | -- be used in the tasking runtime (it is highly peculiar, and completely | |
61 | -- outside the normal semantics of Ada, for a user program to intercept | |
62 | -- the abort exception). | |
996ae0b0 RK |
63 | |
64 | ------------------ | |
65 | -- Address_Size -- | |
66 | ------------------ | |
67 | ||
68 | Attribute_Address_Size => True, | |
996ae0b0 RK |
69 | -- Standard'Address_Size (Standard is the only allowed prefix) is |
70 | -- a static constant giving the number of bits in an Address. It | |
71 | -- is used primarily for constructing the definition of Memory_Size | |
72 | -- in package Standard, but may be freely used in user programs. | |
73 | -- This is a static attribute. | |
74 | ||
75 | --------------- | |
76 | -- Asm_Input -- | |
77 | --------------- | |
78 | ||
79 | Attribute_Asm_Input => True, | |
468c6c8a ES |
80 | -- Used only in conjunction with the Asm subprograms in package |
81 | -- Machine_Code to construct machine instructions. See documentation | |
82 | -- in package Machine_Code in file s-maccod.ads. | |
996ae0b0 RK |
83 | |
84 | ---------------- | |
85 | -- Asm_Output -- | |
86 | ---------------- | |
87 | ||
88 | Attribute_Asm_Output => True, | |
468c6c8a ES |
89 | -- Used only in conjunction with the Asm subprograms in package |
90 | -- Machine_Code to construct machine instructions. See documentation | |
91 | -- in package Machine_Code in file s-maccod.ads. | |
996ae0b0 | 92 | |
996ae0b0 RK |
93 | --------- |
94 | -- Bit -- | |
95 | --------- | |
96 | ||
97 | Attribute_Bit => True, | |
edd63e9b ES |
98 | -- Obj'Bit, where Obj is any object, yields the bit offset within the |
99 | -- storage unit (byte) that contains the first bit of storage allocated | |
100 | -- for the object. The attribute value is of type Universal_Integer, | |
101 | -- and is always a non-negative number not exceeding the value of | |
102 | -- System.Storage_Unit. | |
996ae0b0 RK |
103 | -- |
104 | -- For an object that is a variable or a constant allocated in a | |
105 | -- register, the value is zero. (The use of this attribute does not | |
106 | -- force the allocation of a variable to memory). | |
107 | -- | |
edd63e9b ES |
108 | -- For an object that is a formal parameter, this attribute applies to |
109 | -- either the matching actual parameter or to a copy of the matching | |
110 | -- actual parameter. | |
996ae0b0 RK |
111 | -- |
112 | -- For an access object the value is zero. Note that Obj.all'Bit is | |
113 | -- subject to an Access_Check for the designated object. Similarly | |
114 | -- for a record component X.C'Bit is subject to a discriminant check | |
115 | -- and X(I).Bit and X(I1..I2)'Bit are subject to index checks. | |
116 | -- | |
117 | -- This attribute is designed to be compatible with the DEC Ada | |
118 | -- definition and implementation of the Bit attribute. | |
119 | ||
120 | ------------------ | |
121 | -- Code_Address -- | |
122 | ------------------ | |
123 | ||
124 | Attribute_Code_Address => True, | |
edd63e9b ES |
125 | -- The reference subp'Code_Address, where subp is a subprogram entity, |
126 | -- gives the address of the first generated instruction for the sub- | |
127 | -- program. This is often, but not always the same as the 'Address | |
128 | -- value, which is the address to be used in a call. The differences | |
129 | -- occur in the case of a nested procedure (where Address yields the | |
130 | -- address of the trampoline code used to load the static link), and on | |
131 | -- some systems which use procedure descriptors (in which case Address | |
132 | -- yields the address of the descriptor). | |
996ae0b0 RK |
133 | |
134 | ----------------------- | |
135 | -- Default_Bit_Order -- | |
136 | ----------------------- | |
137 | ||
138 | Attribute_Default_Bit_Order => True, | |
7ed57189 | 139 | -- Standard'Default_Bit_Order (Standard is the only permissible prefix) |
996ae0b0 RK |
140 | -- provides the value System.Default_Bit_Order as a Pos value (0 for |
141 | -- High_Order_First, 1 for Low_Order_First). This is used to construct | |
142 | -- the definition of Default_Bit_Order in package System. This is a | |
143 | -- static attribute. | |
144 | ||
7ed57189 AC |
145 | ---------------------------------- |
146 | -- Default_Scalar_Storage_Order -- | |
147 | ---------------------------------- | |
148 | ||
149 | Attribute_Default_Scalar_Storage_Order => True, | |
150 | -- Standard'Default_Scalar_Storage_Order (Standard is the | |
151 | -- only permissible prefix) provides the current value of the | |
152 | -- default scalar storage order (as specified using pragma | |
153 | -- Default_Scalar_Storage_Order, or equal to Default_Bit_Order if | |
154 | -- unspecified) as a System.Bit_Order value. This is a static attribute. | |
155 | ||
eaed2a2c AC |
156 | ----------- |
157 | -- Deref -- | |
158 | ----------- | |
159 | ||
160 | Attribute_Deref => True, | |
161 | -- typ'Deref (expr) is valid only if expr is of type System'Address. | |
162 | -- The result is an object of type typ that is obtained by treating the | |
163 | -- address as an access-to-typ value that points to the result. It is | |
164 | -- basically equivalent to (atyp!expr).all where atyp is an access type | |
165 | -- for the type. | |
166 | ||
996ae0b0 RK |
167 | --------------- |
168 | -- Elab_Body -- | |
169 | --------------- | |
170 | ||
171 | Attribute_Elab_Body => True, | |
7ed57189 AC |
172 | -- This attribute can only be applied to a program unit name. It |
173 | -- returns the entity for the corresponding elaboration procedure for | |
174 | -- elaborating the body of the referenced unit. This is used in the main | |
edd63e9b ES |
175 | -- generated elaboration procedure by the binder, and is not normally |
176 | -- used in any other context, but there may be specialized situations in | |
177 | -- which it is useful to be able to call this elaboration procedure from | |
178 | -- Ada code, e.g. if it is necessary to do selective reelaboration to | |
179 | -- fix some error. | |
996ae0b0 | 180 | |
0bfc9a64 AC |
181 | -------------------- |
182 | -- Elab_Subp_Body -- | |
183 | -------------------- | |
184 | ||
185 | Attribute_Elab_Subp_Body => True, | |
186 | -- This attribute can only be applied to a library level subprogram | |
187 | -- name and is only relevant in CodePeer mode. It returns the entity | |
188 | -- for the corresponding elaboration procedure for elaborating the body | |
189 | -- of the referenced subprogram unit. This is used in the main generated | |
190 | -- elaboration procedure by the binder in CodePeer mode only. | |
191 | ||
996ae0b0 RK |
192 | --------------- |
193 | -- Elab_Spec -- | |
194 | --------------- | |
195 | ||
196 | Attribute_Elab_Spec => True, | |
996ae0b0 | 197 | -- This attribute can only be applied to a program unit name. It |
7ed57189 AC |
198 | -- returns the entity for the corresponding elaboration procedure for |
199 | -- elaborating the spec of the referenced unit. This is used in the main | |
200 | -- generated elaboration procedure by the binder, and is not normally | |
201 | -- used in any other context, but there may be specialized situations in | |
202 | -- which it is useful to be able to call this elaboration procedure from | |
203 | -- Ada code, e.g. if it is necessary to do selective reelaboration to | |
204 | -- fix some error. | |
996ae0b0 RK |
205 | |
206 | ---------------- | |
207 | -- Elaborated -- | |
208 | ---------------- | |
209 | ||
210 | Attribute_Elaborated => True, | |
996ae0b0 RK |
211 | -- Lunit'Elaborated, where Lunit is a library unit, yields a boolean |
212 | -- value indicating whether or not the body of the designated library | |
213 | -- unit has been elaborated yet. | |
214 | ||
996ae0b0 RK |
215 | -------------- |
216 | -- Enum_Rep -- | |
217 | -------------- | |
218 | ||
219 | Attribute_Enum_Rep => True, | |
996ae0b0 RK |
220 | -- For every enumeration subtype S, S'Enum_Rep denotes a function |
221 | -- with the following specification: | |
222 | -- | |
223 | -- function S'Enum_Rep (Arg : S'Base) return universal_integer; | |
224 | -- | |
225 | -- The function returns the representation value for the given | |
226 | -- enumeration value. This will be equal to the 'Pos value in the | |
227 | -- absence of an enumeration representation clause. This is a static | |
228 | -- attribute (i.e. the result is static if the argument is static). | |
229 | ||
21d27997 RD |
230 | -------------- |
231 | -- Enum_Val -- | |
232 | -------------- | |
233 | ||
234 | Attribute_Enum_Val => True, | |
7ed57189 AC |
235 | -- For every enumeration subtype S, S'Enum_Val denotes a function with |
236 | -- the following specification: | |
21d27997 RD |
237 | -- |
238 | -- function S'Enum_Val (Arg : universal_integer) return S'Base; | |
239 | -- | |
240 | -- This function performs the inverse transformation to Enum_Rep. Given | |
241 | -- a representation value for the type, it returns the corresponding | |
242 | -- enumeration value. Constraint_Error is raised if no value of the | |
243 | -- enumeration type corresponds to the given integer value. | |
244 | ||
f68d3344 JS |
245 | ----------------------- |
246 | -- Finalization_Size -- | |
247 | ----------------------- | |
248 | ||
249 | Attribute_Finalization_Size => True, | |
5e127570 AC |
250 | -- For every object or non-class-wide-type, Finalization_Size returns |
251 | -- the size of the hidden header used for finalization purposes as if | |
252 | -- the object or type was allocated on the heap. The size of the header | |
253 | -- does take into account any extra padding due to alignment issues. | |
f68d3344 | 254 | |
996ae0b0 RK |
255 | ----------------- |
256 | -- Fixed_Value -- | |
257 | ----------------- | |
258 | ||
259 | Attribute_Fixed_Value => True, | |
996ae0b0 RK |
260 | -- For every fixed-point type S, S'Fixed_Value denotes a function |
261 | -- with the following specification: | |
262 | -- | |
263 | -- function S'Fixed_Value (Arg : universal_integer) return S; | |
264 | -- | |
265 | -- The value returned is the fixed-point value V such that | |
266 | -- | |
267 | -- V = Arg * S'Small | |
268 | -- | |
edd63e9b ES |
269 | -- The effect is thus equivalent to first converting the argument to |
270 | -- the integer type used to represent S, and then doing an unchecked | |
271 | -- conversion to the fixed-point type. This attribute is primarily | |
7ed57189 AC |
272 | -- intended for use in implementation of the input-output functions |
273 | -- for fixed-point values. | |
996ae0b0 RK |
274 | |
275 | ----------------------- | |
276 | -- Has_Discriminants -- | |
277 | ----------------------- | |
278 | ||
279 | Attribute_Has_Discriminants => True, | |
996ae0b0 RK |
280 | -- Gtyp'Has_Discriminants, where Gtyp is a generic formal type, yields |
281 | -- a Boolean value indicating whether or not the actual instantiation | |
282 | -- type has discriminants. | |
283 | ||
284 | --------- | |
285 | -- Img -- | |
286 | --------- | |
287 | ||
288 | Attribute_Img => True, | |
996ae0b0 RK |
289 | -- The 'Img function is defined for any prefix, P, that denotes an |
290 | -- object of scalar type T. P'Img is equivalent to T'Image (P). This | |
291 | -- is convenient for debugging. For example: | |
292 | -- | |
293 | -- Put_Line ("X = " & X'Img); | |
294 | -- | |
295 | -- has the same meaning as the more verbose: | |
296 | -- | |
297 | -- Put_Line ("X = " & Temperature_Type'Image (X)); | |
298 | -- | |
299 | -- where Temperature_Type is the subtype of the object X. | |
300 | ||
301 | ------------------- | |
302 | -- Integer_Value -- | |
303 | ------------------- | |
304 | ||
305 | Attribute_Integer_Value => True, | |
996ae0b0 RK |
306 | -- For every integer type S, S'Integer_Value denotes a function |
307 | -- with the following specification: | |
308 | -- | |
309 | -- function S'Integer_Value (Arg : universal_fixed) return S; | |
310 | -- | |
311 | -- The value returned is the integer value V, such that | |
312 | -- | |
313 | -- Arg = V * fixed-type'Small | |
314 | -- | |
315 | -- The effect is thus equivalent to first doing an unchecked convert | |
316 | -- from the fixed-point type to its corresponding implementation type, | |
317 | -- and then converting the result to the target integer type. This | |
318 | -- attribute is primarily intended for use in implementation of the | |
319 | -- standard input-output functions for fixed-point values. | |
320 | ||
21d27997 RD |
321 | Attribute_Invalid_Value => True, |
322 | -- For every scalar type, S'Invalid_Value designates an undefined value | |
323 | -- of the type. If possible this value is an invalid value, and in fact | |
324 | -- is identical to the value that would be set if Initialize_Scalars | |
325 | -- mode were in effect (including the behavior of its value on | |
7ed57189 AC |
326 | -- environment variables or binder switches). The intended use is to |
327 | -- set a value where initialization is required (e.g. as a result of the | |
328 | -- coding standards in use), but logically no initialization is needed, | |
329 | -- and the value should never be accessed. | |
21d27997 | 330 | |
570104df | 331 | Attribute_Loop_Entry => True, |
b9daa96e | 332 | -- For every object of a non-limited type, S'Loop_Entry [(Loop_Name)] |
570104df AC |
333 | -- denotes the constant value of prefix S at the point of entry into the |
334 | -- related loop. The type of the attribute is the type of the prefix. | |
335 | ||
996ae0b0 RK |
336 | ------------------ |
337 | -- Machine_Size -- | |
338 | ------------------ | |
339 | ||
340 | Attribute_Machine_Size => True, | |
996ae0b0 RK |
341 | -- This attribute is identical to the Object_Size attribute. It is |
342 | -- provided for compatibility with the DEC attribute of this name. | |
343 | ||
996ae0b0 RK |
344 | ----------------------- |
345 | -- Maximum_Alignment -- | |
346 | ----------------------- | |
347 | ||
348 | Attribute_Maximum_Alignment => True, | |
996ae0b0 | 349 | -- Standard'Maximum_Alignment (Standard is the only permissible prefix) |
7ed57189 AC |
350 | -- provides the maximum useful alignment value for the target. This is a |
351 | -- static value that can be used to specify the alignment for an object, | |
352 | -- guaranteeing that it is properly aligned in all cases. The time this | |
353 | -- is useful is when an external object is imported and its alignment | |
354 | -- requirements are unknown. This is a static attribute. | |
996ae0b0 RK |
355 | |
356 | -------------------- | |
357 | -- Mechanism_Code -- | |
358 | -------------------- | |
359 | ||
360 | Attribute_Mechanism_Code => True, | |
12a13f01 | 361 | -- function'Mechanism_Code yields an integer code for the mechanism |
996ae0b0 RK |
362 | -- used for the result of function, and subprogram'Mechanism_Code (n) |
363 | -- yields the mechanism used for formal parameter number n (a static | |
364 | -- integer value, 1 = first parameter). The code returned is: | |
365 | -- | |
366 | -- 1 = by copy (value) | |
367 | -- 2 = by reference | |
368 | -- 3 = by descriptor (default descriptor type) | |
369 | -- 4 = by descriptor (UBS unaligned bit string) | |
370 | -- 5 = by descriptor (UBSB aligned bit string with arbitrary bounds) | |
371 | -- 6 = by descriptor (UBA unaligned bit array) | |
372 | -- 7 = by descriptor (S string, also scalar access type parameter) | |
373 | -- 8 = by descriptor (SB string with arbitrary bounds) | |
374 | -- 9 = by descriptor (A contiguous array) | |
375 | -- 10 = by descriptor (NCA non-contiguous array) | |
376 | ||
377 | -------------------- | |
378 | -- Null_Parameter -- | |
379 | -------------------- | |
380 | ||
381 | Attribute_Null_Parameter => True, | |
7ed57189 AC |
382 | -- A reference T'Null_Parameter denotes an (imaginary) object of type |
383 | -- or subtype T allocated at (machine) address zero. The attribute is | |
384 | -- allowed only as the default expression of a formal parameter, or | |
385 | -- as an actual expression of a subprogram call. In either case, the | |
edd63e9b | 386 | -- subprogram must be imported. |
996ae0b0 | 387 | -- |
7ed57189 AC |
388 | -- The identity of the object is represented by the address zero in |
389 | -- the argument list, independent of the passing mechanism (explicit | |
390 | -- or default). | |
996ae0b0 | 391 | -- |
edd63e9b | 392 | -- The reason that this capability is needed is that for a record or |
7ed57189 AC |
393 | -- other composite object passed by reference, there is no other way |
394 | -- of specifying that a zero address should be passed. | |
996ae0b0 RK |
395 | |
396 | ----------------- | |
397 | -- Object_Size -- | |
398 | ----------------- | |
399 | ||
400 | Attribute_Object_Size => True, | |
996ae0b0 RK |
401 | -- Type'Object_Size is the same as Type'Size for all types except |
402 | -- fixed-point types and discrete types. For fixed-point types and | |
403 | -- discrete types, this attribute gives the size used for default | |
edd63e9b | 404 | -- allocation of objects and components of the size. See section in |
4f94fa11 | 405 | -- Einfo ("Handling of Type'Size values") for further details. |
996ae0b0 RK |
406 | |
407 | ------------------------- | |
408 | -- Passed_By_Reference -- | |
409 | ------------------------- | |
410 | ||
411 | Attribute_Passed_By_Reference => True, | |
edd63e9b ES |
412 | -- T'Passed_By_Reference for any subtype T returns a boolean value that |
413 | -- is true if the type is normally passed by reference and false if the | |
414 | -- type is normally passed by copy in calls. For scalar types, the | |
415 | -- result is always False and is static. For non-scalar types, the | |
416 | -- result is non-static (since it is computed by Gigi). | |
996ae0b0 RK |
417 | |
418 | ------------------ | |
419 | -- Range_Length -- | |
420 | ------------------ | |
421 | ||
422 | Attribute_Range_Length => True, | |
edd63e9b ES |
423 | -- T'Range_Length for any discrete type T yields the number of values |
424 | -- represented by the subtype (zero for a null range). The result is | |
425 | -- static for static subtypes. Note that Range_Length applied to the | |
426 | -- index subtype of a one dimensional array always gives the same result | |
427 | -- as Range applied to the array itself. The result is of type universal | |
428 | -- integer. | |
996ae0b0 | 429 | |
1b0b0f18 AC |
430 | --------- |
431 | -- Ref -- | |
432 | --------- | |
433 | ||
434 | Attribute_Ref => True, | |
435 | -- System.Address'Ref (Address is the only permissible prefix) is | |
436 | -- equivalent to System'To_Address, provided for compatibility with | |
437 | -- other compilers. | |
438 | ||
996ae0b0 RK |
439 | ------------------ |
440 | -- Storage_Unit -- | |
441 | ------------------ | |
442 | ||
443 | Attribute_Storage_Unit => True, | |
996ae0b0 RK |
444 | -- Standard'Storage_Unit (Standard is the only permissible prefix) |
445 | -- provides the value System.Storage_Unit, and is intended primarily | |
446 | -- for constructing this definition in package System (see note above | |
447 | -- in Default_Bit_Order description). The is a static attribute. | |
448 | ||
468c6c8a ES |
449 | --------------- |
450 | -- Stub_Type -- | |
451 | --------------- | |
452 | ||
453 | Attribute_Stub_Type => True, | |
454 | -- The GNAT implementation of remote access-to-classwide types is | |
455 | -- organised as described in AARM E.4(20.t): a value of an RACW type | |
456 | -- (designating a remote object) is represented as a normal access | |
457 | -- value, pointing to a "stub" object which in turn contains the | |
458 | -- necessary information to contact the designated remote object. A | |
459 | -- call on any dispatching operation of such a stub object does the | |
460 | -- remote call, if necessary, using the information in the stub object | |
461 | -- to locate the target partition, etc. | |
462 | -- | |
463 | -- For a prefix T that denotes a remote access-to-classwide type, | |
464 | -- T'Stub_Type denotes the type of the corresponding stub objects. | |
465 | -- | |
466 | -- By construction, the layout of T'Stub_Type is identical to that of | |
467 | -- System.Partition_Interface.RACW_Stub_Type (see implementation notes | |
468 | -- in body of Exp_Dist). | |
469 | ||
fbf5a39b AC |
470 | ----------------- |
471 | -- Target_Name -- | |
472 | ----------------- | |
473 | ||
474 | Attribute_Target_Name => True, | |
edd63e9b ES |
475 | -- Standard'Target_Name yields the string identifying the target for the |
476 | -- compilation, taken from Sdefault.Target_Name. | |
fbf5a39b | 477 | |
996ae0b0 RK |
478 | ---------------- |
479 | -- To_Address -- | |
480 | ---------------- | |
481 | ||
482 | Attribute_To_Address => True, | |
1b0b0f18 | 483 | -- System'To_Address (System is the only permissible prefix) is a |
edd63e9b ES |
484 | -- function that takes any integer value, and converts it into an |
485 | -- address value. The semantics is to first convert the integer value to | |
486 | -- type Integer_Address according to normal conversion rules, and then | |
487 | -- to convert this to an address using the same semantics as the | |
488 | -- System.Storage_Elements.To_Address function. The important difference | |
489 | -- is that this is a static attribute so it can be used in | |
12a13f01 | 490 | -- initializations in preelaborate packages. |
996ae0b0 RK |
491 | |
492 | ---------------- | |
493 | -- Type_Class -- | |
494 | ---------------- | |
495 | ||
496 | Attribute_Type_Class => True, | |
edd63e9b ES |
497 | -- T'Type_Class for any type or subtype T yields the value of the type |
498 | -- class for the full type of T. If T is a generic formal type, then the | |
499 | -- value is the value for the corresponding actual subtype. The value of | |
500 | -- this attribute is of type System.Aux_DEC.Type_Class, which has the | |
501 | -- following definition: | |
996ae0b0 RK |
502 | -- |
503 | -- type Type_Class is | |
504 | -- (Type_Class_Enumeration, | |
505 | -- Type_Class_Integer, | |
506 | -- Type_Class_Fixed_Point, | |
507 | -- Type_Class_Floating_Point, | |
508 | -- Type_Class_Array, | |
509 | -- Type_Class_Record, | |
510 | -- Type_Class_Access, | |
511 | -- Type_Class_Task, | |
512 | -- Type_Class_Address); | |
513 | -- | |
edd63e9b ES |
514 | -- Protected types yield the value Type_Class_Task, which thus applies |
515 | -- to all concurrent types. This attribute is designed to be compatible | |
516 | -- with the DEC Ada attribute of the same name. | |
996ae0b0 RK |
517 | -- |
518 | -- Note: if pragma Extend_System is used to merge the definitions of | |
519 | -- Aux_DEC into System, then the type Type_Class can be referenced | |
520 | -- as an entity within System, as can its enumeration literals. | |
521 | ||
996ae0b0 RK |
522 | ------------------------------ |
523 | -- Universal_Literal_String -- | |
524 | ------------------------------ | |
525 | ||
526 | Attribute_Universal_Literal_String => True, | |
d32e3cee GB |
527 | -- The prefix of 'Universal_Literal_String must be a named number. |
528 | -- The static result is the string consisting of the characters of | |
529 | -- the number as defined in the original source. This allows the | |
530 | -- user program to access the actual text of named numbers without | |
531 | -- intermediate conversions and without the need to enclose the | |
532 | -- strings in quotes (which would preclude their use as numbers). | |
996ae0b0 RK |
533 | |
534 | ------------------------- | |
535 | -- Unrestricted_Access -- | |
536 | ------------------------- | |
537 | ||
538 | Attribute_Unrestricted_Access => True, | |
996ae0b0 RK |
539 | -- The Unrestricted_Access attribute is similar to Access except that |
540 | -- all accessibility and aliased view checks are omitted. This is very | |
541 | -- much a user-beware attribute. Basically its status is very similar | |
542 | -- to Address, for which it is a desirable replacement where the value | |
543 | -- desired is an access type. In other words, its effect is identical | |
544 | -- to first taking 'Address and then doing an unchecked conversion to | |
545 | -- a desired access type. Note that in GNAT, but not necessarily in | |
546 | -- other implementations, the use of static chains for inner level | |
547 | -- subprograms means that Unrestricted_Access applied to a subprogram | |
548 | -- yields a value that can be called as long as the subprogram is in | |
549 | -- scope (normal Ada 95 accessibility rules restrict this usage). | |
550 | ||
551 | --------------- | |
552 | -- VADS_Size -- | |
553 | --------------- | |
554 | ||
555 | Attribute_VADS_Size => True, | |
edd63e9b ES |
556 | -- Typ'VADS_Size yields the Size value typically yielded by some Ada 83 |
557 | -- compilers. The differences between VADS_Size and Size is that for | |
558 | -- scalar types for which no Size has been specified, VADS_Size yields | |
559 | -- the Object_Size rather than the Value_Size. For example, while | |
560 | -- Natural'Size is typically 31, the value of Natural'VADS_Size is 32. | |
561 | -- For all other types, Size and VADS_Size yield the same value. | |
996ae0b0 | 562 | |
2a1f6a1f AC |
563 | ------------------- |
564 | -- Valid_Scalars -- | |
565 | ------------------- | |
566 | ||
567 | Attribute_Valid_Scalars => True, | |
207503fa AC |
568 | -- Obj'Valid_Scalars can be applied to any object. The result depends |
569 | -- on the type of the object: | |
570 | -- | |
571 | -- For a scalar type, the result is the same as obj'Valid | |
572 | -- | |
573 | -- For an array object, the result is True if the result of applying | |
99fc068e RD |
574 | -- Valid_Scalars to every component is True. For an empty array the |
575 | -- result is True. | |
207503fa AC |
576 | -- |
577 | -- For a record object, the result is True if the result of applying | |
578 | -- Valid_Scalars to every component is True. For class-wide types, | |
579 | -- only the components of the base type are checked. For variant | |
99fc068e RD |
580 | -- records, only the components actually present are checked. The |
581 | -- discriminants, if any, are also checked. If there are no components | |
582 | -- or discriminants, the result is True. | |
583 | -- | |
584 | -- For any other type that has discriminants, the result is True if | |
585 | -- the result of applying Valid_Scalars to each discriminant is True. | |
207503fa AC |
586 | -- |
587 | -- For all other types, the result is always True | |
588 | -- | |
589 | -- A warning is given for a trivially True result, when the attribute | |
590 | -- is applied to an object that is not of scalar, array, or record | |
591 | -- type, or in the composite case if no scalar subcomponents exist. For | |
592 | -- a variant record, the warning is given only if none of the variants | |
593 | -- have scalar subcomponents. In addition, the warning is suppressed | |
99fc068e | 594 | -- for private types, or generic formal types in an instance. |
2a1f6a1f | 595 | |
996ae0b0 RK |
596 | ---------------- |
597 | -- Value_Size -- | |
598 | ---------------- | |
599 | ||
600 | Attribute_Value_Size => True, | |
edd63e9b ES |
601 | -- Type'Value_Size is the number of bits required to represent value of |
602 | -- the given subtype. It is the same as Type'Size, but, unlike Size, may | |
603 | -- be set for non-first subtypes. See section in Einfo ("Handling of | |
604 | -- type'Size values") for further details. | |
996ae0b0 RK |
605 | |
606 | --------------- | |
607 | -- Word_Size -- | |
608 | --------------- | |
609 | ||
610 | Attribute_Word_Size => True, | |
996ae0b0 RK |
611 | -- Standard'Word_Size (Standard is the only permissible prefix) |
612 | -- provides the value System.Word_Size, and is intended primarily | |
613 | -- for constructing this definition in package System (see note above | |
614 | -- in Default_Bit_Order description). This is a static attribute. | |
615 | ||
616 | others => False); | |
617 | ||
71129dde AC |
618 | -- The following table lists all attributes that yield a result of a |
619 | -- universal type. | |
620 | ||
621 | Universal_Type_Attribute : constant array (Attribute_Id) of Boolean := | |
622 | (Attribute_Aft => True, | |
623 | Attribute_Alignment => True, | |
624 | Attribute_Component_Size => True, | |
625 | Attribute_Count => True, | |
626 | Attribute_Delta => True, | |
627 | Attribute_Digits => True, | |
628 | Attribute_Exponent => True, | |
629 | Attribute_First_Bit => True, | |
630 | Attribute_Fore => True, | |
631 | Attribute_Last_Bit => True, | |
632 | Attribute_Length => True, | |
633 | Attribute_Machine_Emax => True, | |
634 | Attribute_Machine_Emin => True, | |
635 | Attribute_Machine_Mantissa => True, | |
636 | Attribute_Machine_Radix => True, | |
637 | Attribute_Max_Alignment_For_Allocation => True, | |
638 | Attribute_Max_Size_In_Storage_Elements => True, | |
639 | Attribute_Model_Emin => True, | |
640 | Attribute_Model_Epsilon => True, | |
641 | Attribute_Model_Mantissa => True, | |
642 | Attribute_Model_Small => True, | |
643 | Attribute_Modulus => True, | |
644 | Attribute_Pos => True, | |
645 | Attribute_Position => True, | |
646 | Attribute_Safe_First => True, | |
647 | Attribute_Safe_Last => True, | |
648 | Attribute_Scale => True, | |
649 | Attribute_Size => True, | |
650 | Attribute_Small => True, | |
651 | Attribute_Wide_Wide_Width => True, | |
652 | Attribute_Wide_Width => True, | |
653 | Attribute_Width => True, | |
654 | others => False); | |
655 | ||
996ae0b0 RK |
656 | ----------------- |
657 | -- Subprograms -- | |
658 | ----------------- | |
659 | ||
660 | procedure Analyze_Attribute (N : Node_Id); | |
661 | -- Performs bottom up semantic analysis of an attribute. Note that the | |
662 | -- parser has already checked that type returning attributes appear only | |
663 | -- in appropriate contexts (i.e. in subtype marks, or as prefixes for | |
664 | -- other attributes). | |
665 | ||
442ade9d RD |
666 | function Name_Implies_Lvalue_Prefix (Nam : Name_Id) return Boolean; |
667 | -- Determine whether the name of an attribute reference categorizes its | |
668 | -- prefix as an lvalue. The following attributes fall under this bracket | |
669 | -- by directly or indirectly modifying their prefixes. | |
670 | -- Access | |
671 | -- Address | |
672 | -- Input | |
673 | -- Read | |
674 | -- Unchecked_Access | |
675 | -- Unrestricted_Access | |
822033eb | 676 | |
996ae0b0 | 677 | procedure Resolve_Attribute (N : Node_Id; Typ : Entity_Id); |
edd63e9b ES |
678 | -- Performs type resolution of attribute. If the attribute yields a |
679 | -- universal value, mark its type as that of the context. On the other | |
680 | -- hand, if the context itself is universal (as in T'Val (T'Pos (X)), mark | |
681 | -- the type as being the largest type of that class that can be used at | |
682 | -- run-time. This is correct since either the value gets folded (in which | |
683 | -- case it doesn't matter what type of the class we give if, since the | |
684 | -- folding uses universal arithmetic anyway) or it doesn't get folded (in | |
685 | -- which case it is going to be dealt with at runtime, and the largest type | |
686 | -- is right). | |
687 | ||
688 | function Stream_Attribute_Available | |
689 | (Typ : Entity_Id; | |
690 | Nam : TSS_Name_Type; | |
691 | Partial_View : Entity_Id := Empty) return Boolean; | |
3e7302c3 AC |
692 | -- For a limited type Typ, return True if and only if the given attribute |
693 | -- is available. For Ada 2005, availability is defined by 13.13.2(36/1). | |
694 | -- For Ada 95, an attribute is considered to be available if it has been | |
695 | -- specified using an attribute definition clause for the type, or for its | |
696 | -- full view, or for an ancestor of either. Parameter Partial_View is used | |
697 | -- only internally, when checking for an attribute definition clause that | |
698 | -- is not visible (Ada 95 only). | |
996ae0b0 RK |
699 | |
700 | end Sem_Attr; |