|
111
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT COMPILER COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- S E M _ A T T R --
|
|
|
6 -- --
|
|
|
7 -- S p e c --
|
|
|
8 -- --
|
|
131
|
9 -- Copyright (C) 1992-2018, Free Software Foundation, Inc. --
|
|
111
|
10 -- --
|
|
|
11 -- GNAT is free software; you can redistribute it and/or modify it under --
|
|
|
12 -- terms of the GNU General Public License as published by the Free Soft- --
|
|
|
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
|
|
|
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
|
|
|
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
|
|
|
16 -- or FITNESS FOR A PARTICULAR PURPOSE. --
|
|
|
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/>. --
|
|
|
21 -- --
|
|
|
22 -- GNAT was originally developed by the GNAT team at New York University. --
|
|
|
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
|
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
|
|
|
34 with Exp_Tss; use Exp_Tss;
|
|
|
35 with Namet; use Namet;
|
|
|
36 with Snames; use Snames;
|
|
|
37 with Types; use Types;
|
|
|
38
|
|
|
39 package Sem_Attr is
|
|
|
40
|
|
|
41 -----------------------------------------
|
|
|
42 -- Implementation Dependent Attributes --
|
|
|
43 -----------------------------------------
|
|
|
44
|
|
|
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.
|
|
|
48
|
|
|
49 Attribute_Impl_Def : constant Attribute_Class_Array :=
|
|
|
50 Attribute_Class_Array'(
|
|
|
51
|
|
|
52 ------------------
|
|
|
53 -- Abort_Signal --
|
|
|
54 ------------------
|
|
|
55
|
|
|
56 Attribute_Abort_Signal => True,
|
|
|
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).
|
|
|
63
|
|
|
64 ------------------
|
|
|
65 -- Address_Size --
|
|
|
66 ------------------
|
|
|
67
|
|
|
68 Attribute_Address_Size => True,
|
|
|
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,
|
|
|
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.
|
|
|
83
|
|
|
84 ----------------
|
|
|
85 -- Asm_Output --
|
|
|
86 ----------------
|
|
|
87
|
|
|
88 Attribute_Asm_Output => True,
|
|
|
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.
|
|
|
92
|
|
|
93 ---------
|
|
|
94 -- Bit --
|
|
|
95 ---------
|
|
|
96
|
|
|
97 Attribute_Bit => True,
|
|
|
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.
|
|
|
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 --
|
|
|
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.
|
|
|
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,
|
|
|
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).
|
|
|
133
|
|
|
134 -----------------------
|
|
|
135 -- Default_Bit_Order --
|
|
|
136 -----------------------
|
|
|
137
|
|
|
138 Attribute_Default_Bit_Order => True,
|
|
|
139 -- Standard'Default_Bit_Order (Standard is the only permissible prefix)
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
167 ---------------
|
|
|
168 -- Elab_Body --
|
|
|
169 ---------------
|
|
|
170
|
|
|
171 Attribute_Elab_Body => True,
|
|
|
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
|
|
|
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.
|
|
|
180
|
|
|
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
|
|
|
192 ---------------
|
|
|
193 -- Elab_Spec --
|
|
|
194 ---------------
|
|
|
195
|
|
|
196 Attribute_Elab_Spec => True,
|
|
|
197 -- This attribute can only be applied to a program unit name. It
|
|
|
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.
|
|
|
205
|
|
|
206 ----------------
|
|
|
207 -- Elaborated --
|
|
|
208 ----------------
|
|
|
209
|
|
|
210 Attribute_Elaborated => True,
|
|
|
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
|
|
|
215 --------------
|
|
|
216 -- Enum_Rep --
|
|
|
217 --------------
|
|
|
218
|
|
|
219 Attribute_Enum_Rep => True,
|
|
|
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
|
|
|
230 --------------
|
|
|
231 -- Enum_Val --
|
|
|
232 --------------
|
|
|
233
|
|
|
234 Attribute_Enum_Val => True,
|
|
|
235 -- For every enumeration subtype S, S'Enum_Val denotes a function with
|
|
|
236 -- the following specification:
|
|
|
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
|
|
|
245 -----------------------
|
|
|
246 -- Finalization_Size --
|
|
|
247 -----------------------
|
|
|
248
|
|
|
249 Attribute_Finalization_Size => True,
|
|
|
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.
|
|
|
254
|
|
|
255 -----------------
|
|
|
256 -- Fixed_Value --
|
|
|
257 -----------------
|
|
|
258
|
|
|
259 Attribute_Fixed_Value => True,
|
|
|
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 --
|
|
|
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
|
|
|
272 -- intended for use in implementation of the input-output functions
|
|
|
273 -- for fixed-point values.
|
|
|
274
|
|
|
275 -----------------------
|
|
|
276 -- Has_Discriminants --
|
|
|
277 -----------------------
|
|
|
278
|
|
|
279 Attribute_Has_Discriminants => True,
|
|
|
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,
|
|
|
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,
|
|
|
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
|
|
|
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
|
|
|
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.
|
|
|
330
|
|
|
331 Attribute_Loop_Entry => True,
|
|
|
332 -- For every object of a non-limited type, S'Loop_Entry [(Loop_Name)]
|
|
|
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
|
|
|
336 ------------------
|
|
|
337 -- Machine_Size --
|
|
|
338 ------------------
|
|
|
339
|
|
|
340 Attribute_Machine_Size => True,
|
|
|
341 -- This attribute is identical to the Object_Size attribute. It is
|
|
|
342 -- provided for compatibility with the DEC attribute of this name.
|
|
|
343
|
|
|
344 -----------------------
|
|
|
345 -- Maximum_Alignment --
|
|
|
346 -----------------------
|
|
|
347
|
|
|
348 Attribute_Maximum_Alignment => True,
|
|
|
349 -- Standard'Maximum_Alignment (Standard is the only permissible prefix)
|
|
|
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.
|
|
|
355
|
|
|
356 --------------------
|
|
|
357 -- Mechanism_Code --
|
|
|
358 --------------------
|
|
|
359
|
|
|
360 Attribute_Mechanism_Code => True,
|
|
|
361 -- function'Mechanism_Code yields an integer code for the mechanism
|
|
|
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,
|
|
|
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
|
|
|
386 -- subprogram must be imported.
|
|
|
387 --
|
|
|
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).
|
|
|
391 --
|
|
|
392 -- The reason that this capability is needed is that for a record or
|
|
|
393 -- other composite object passed by reference, there is no other way
|
|
|
394 -- of specifying that a zero address should be passed.
|
|
|
395
|
|
|
396 -----------------
|
|
|
397 -- Object_Size --
|
|
|
398 -----------------
|
|
|
399
|
|
|
400 Attribute_Object_Size => True,
|
|
|
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
|
|
|
404 -- allocation of objects and components of the size. See section in
|
|
|
405 -- Einfo ("Handling of Type'Size values") for further details.
|
|
|
406
|
|
|
407 -------------------------
|
|
|
408 -- Passed_By_Reference --
|
|
|
409 -------------------------
|
|
|
410
|
|
|
411 Attribute_Passed_By_Reference => True,
|
|
|
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).
|
|
|
417
|
|
|
418 ------------------
|
|
|
419 -- Range_Length --
|
|
|
420 ------------------
|
|
|
421
|
|
|
422 Attribute_Range_Length => True,
|
|
|
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.
|
|
|
429
|
|
|
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
|
|
|
439 ------------------
|
|
|
440 -- Storage_Unit --
|
|
|
441 ------------------
|
|
|
442
|
|
|
443 Attribute_Storage_Unit => True,
|
|
|
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
|
|
|
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
|
|
|
470 -----------------
|
|
|
471 -- Target_Name --
|
|
|
472 -----------------
|
|
|
473
|
|
|
474 Attribute_Target_Name => True,
|
|
|
475 -- Standard'Target_Name yields the string identifying the target for the
|
|
|
476 -- compilation, taken from Sdefault.Target_Name.
|
|
|
477
|
|
|
478 ----------------
|
|
|
479 -- To_Address --
|
|
|
480 ----------------
|
|
|
481
|
|
|
482 Attribute_To_Address => True,
|
|
|
483 -- System'To_Address (System is the only permissible prefix) is a
|
|
|
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
|
|
|
490 -- initializations in preelaborate packages.
|
|
|
491
|
|
|
492 ----------------
|
|
|
493 -- Type_Class --
|
|
|
494 ----------------
|
|
|
495
|
|
|
496 Attribute_Type_Class => True,
|
|
|
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:
|
|
|
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 --
|
|
|
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.
|
|
|
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
|
|
|
522 ------------------------------
|
|
|
523 -- Universal_Literal_String --
|
|
|
524 ------------------------------
|
|
|
525
|
|
|
526 Attribute_Universal_Literal_String => True,
|
|
|
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).
|
|
|
533
|
|
|
534 -------------------------
|
|
|
535 -- Unrestricted_Access --
|
|
|
536 -------------------------
|
|
|
537
|
|
|
538 Attribute_Unrestricted_Access => True,
|
|
|
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,
|
|
|
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.
|
|
|
562
|
|
|
563 -------------------
|
|
|
564 -- Valid_Scalars --
|
|
|
565 -------------------
|
|
|
566
|
|
|
567 Attribute_Valid_Scalars => True,
|
|
|
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
|
|
|
574 -- Valid_Scalars to every component is True. For an empty array the
|
|
|
575 -- result is True.
|
|
|
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
|
|
|
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.
|
|
|
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
|
|
|
594 -- for private types, or generic formal types in an instance.
|
|
|
595
|
|
|
596 ----------------
|
|
|
597 -- Value_Size --
|
|
|
598 ----------------
|
|
|
599
|
|
|
600 Attribute_Value_Size => True,
|
|
|
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.
|
|
|
605
|
|
|
606 ---------------
|
|
|
607 -- Word_Size --
|
|
|
608 ---------------
|
|
|
609
|
|
|
610 Attribute_Word_Size => True,
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
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
|
|
|
676
|
|
|
677 procedure Resolve_Attribute (N : Node_Id; Typ : Entity_Id);
|
|
|
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;
|
|
|
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).
|
|
|
699
|
|
|
700 end Sem_Attr;
|
