File : sem_attr.ads
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- S E M _ A T T R --
6 -- --
7 -- S p e c --
8 -- --
9 -- Copyright (C) 1992-2015, Free Software Foundation, Inc. --
10 -- --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. --
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 -- Fixed_Value --
247 -----------------
248
249 Attribute_Fixed_Value => True,
250 -- For every fixed-point type S, S'Fixed_Value denotes a function
251 -- with the following specification:
252 --
253 -- function S'Fixed_Value (Arg : universal_integer) return S;
254 --
255 -- The value returned is the fixed-point value V such that
256 --
257 -- V = Arg * S'Small
258 --
259 -- The effect is thus equivalent to first converting the argument to
260 -- the integer type used to represent S, and then doing an unchecked
261 -- conversion to the fixed-point type. This attribute is primarily
262 -- intended for use in implementation of the input-output functions
263 -- for fixed-point values.
264
265 -----------------------
266 -- Has_Discriminants --
267 -----------------------
268
269 Attribute_Has_Discriminants => True,
270 -- Gtyp'Has_Discriminants, where Gtyp is a generic formal type, yields
271 -- a Boolean value indicating whether or not the actual instantiation
272 -- type has discriminants.
273
274 ---------
275 -- Img --
276 ---------
277
278 Attribute_Img => True,
279 -- The 'Img function is defined for any prefix, P, that denotes an
280 -- object of scalar type T. P'Img is equivalent to T'Image (P). This
281 -- is convenient for debugging. For example:
282 --
283 -- Put_Line ("X = " & X'Img);
284 --
285 -- has the same meaning as the more verbose:
286 --
287 -- Put_Line ("X = " & Temperature_Type'Image (X));
288 --
289 -- where Temperature_Type is the subtype of the object X.
290
291 -------------------
292 -- Integer_Value --
293 -------------------
294
295 Attribute_Integer_Value => True,
296 -- For every integer type S, S'Integer_Value denotes a function
297 -- with the following specification:
298 --
299 -- function S'Integer_Value (Arg : universal_fixed) return S;
300 --
301 -- The value returned is the integer value V, such that
302 --
303 -- Arg = V * fixed-type'Small
304 --
305 -- The effect is thus equivalent to first doing an unchecked convert
306 -- from the fixed-point type to its corresponding implementation type,
307 -- and then converting the result to the target integer type. This
308 -- attribute is primarily intended for use in implementation of the
309 -- standard input-output functions for fixed-point values.
310
311 Attribute_Invalid_Value => True,
312 -- For every scalar type, S'Invalid_Value designates an undefined value
313 -- of the type. If possible this value is an invalid value, and in fact
314 -- is identical to the value that would be set if Initialize_Scalars
315 -- mode were in effect (including the behavior of its value on
316 -- environment variables or binder switches). The intended use is to
317 -- set a value where initialization is required (e.g. as a result of the
318 -- coding standards in use), but logically no initialization is needed,
319 -- and the value should never be accessed.
320
321 Attribute_Loop_Entry => True,
322 -- For every object of a non-limited type, S'Loop_Entry [(Loop_Name)]
323 -- denotes the constant value of prefix S at the point of entry into the
324 -- related loop. The type of the attribute is the type of the prefix.
325
326 ------------------
327 -- Machine_Size --
328 ------------------
329
330 Attribute_Machine_Size => True,
331 -- This attribute is identical to the Object_Size attribute. It is
332 -- provided for compatibility with the DEC attribute of this name.
333
334 -----------------------
335 -- Maximum_Alignment --
336 -----------------------
337
338 Attribute_Maximum_Alignment => True,
339 -- Standard'Maximum_Alignment (Standard is the only permissible prefix)
340 -- provides the maximum useful alignment value for the target. This is a
341 -- static value that can be used to specify the alignment for an object,
342 -- guaranteeing that it is properly aligned in all cases. The time this
343 -- is useful is when an external object is imported and its alignment
344 -- requirements are unknown. This is a static attribute.
345
346 --------------------
347 -- Mechanism_Code --
348 --------------------
349
350 Attribute_Mechanism_Code => True,
351 -- function'Mechanism_Code yields an integer code for the mechanism
352 -- used for the result of function, and subprogram'Mechanism_Code (n)
353 -- yields the mechanism used for formal parameter number n (a static
354 -- integer value, 1 = first parameter). The code returned is:
355 --
356 -- 1 = by copy (value)
357 -- 2 = by reference
358 -- 3 = by descriptor (default descriptor type)
359 -- 4 = by descriptor (UBS unaligned bit string)
360 -- 5 = by descriptor (UBSB aligned bit string with arbitrary bounds)
361 -- 6 = by descriptor (UBA unaligned bit array)
362 -- 7 = by descriptor (S string, also scalar access type parameter)
363 -- 8 = by descriptor (SB string with arbitrary bounds)
364 -- 9 = by descriptor (A contiguous array)
365 -- 10 = by descriptor (NCA non-contiguous array)
366
367 --------------------
368 -- Null_Parameter --
369 --------------------
370
371 Attribute_Null_Parameter => True,
372 -- A reference T'Null_Parameter denotes an (imaginary) object of type
373 -- or subtype T allocated at (machine) address zero. The attribute is
374 -- allowed only as the default expression of a formal parameter, or
375 -- as an actual expression of a subprogram call. In either case, the
376 -- subprogram must be imported.
377 --
378 -- The identity of the object is represented by the address zero in
379 -- the argument list, independent of the passing mechanism (explicit
380 -- or default).
381 --
382 -- The reason that this capability is needed is that for a record or
383 -- other composite object passed by reference, there is no other way
384 -- of specifying that a zero address should be passed.
385
386 -----------------
387 -- Object_Size --
388 -----------------
389
390 Attribute_Object_Size => True,
391 -- Type'Object_Size is the same as Type'Size for all types except
392 -- fixed-point types and discrete types. For fixed-point types and
393 -- discrete types, this attribute gives the size used for default
394 -- allocation of objects and components of the size. See section in
395 -- Einfo ("Handling of type'Size values") for further details.
396
397 -------------------------
398 -- Passed_By_Reference --
399 -------------------------
400
401 Attribute_Passed_By_Reference => True,
402 -- T'Passed_By_Reference for any subtype T returns a boolean value that
403 -- is true if the type is normally passed by reference and false if the
404 -- type is normally passed by copy in calls. For scalar types, the
405 -- result is always False and is static. For non-scalar types, the
406 -- result is non-static (since it is computed by Gigi).
407
408 ------------------
409 -- Range_Length --
410 ------------------
411
412 Attribute_Range_Length => True,
413 -- T'Range_Length for any discrete type T yields the number of values
414 -- represented by the subtype (zero for a null range). The result is
415 -- static for static subtypes. Note that Range_Length applied to the
416 -- index subtype of a one dimensional array always gives the same result
417 -- as Range applied to the array itself. The result is of type universal
418 -- integer.
419
420 ---------
421 -- Ref --
422 ---------
423
424 Attribute_Ref => True,
425 -- System.Address'Ref (Address is the only permissible prefix) is
426 -- equivalent to System'To_Address, provided for compatibility with
427 -- other compilers.
428
429 ------------------
430 -- Storage_Unit --
431 ------------------
432
433 Attribute_Storage_Unit => True,
434 -- Standard'Storage_Unit (Standard is the only permissible prefix)
435 -- provides the value System.Storage_Unit, and is intended primarily
436 -- for constructing this definition in package System (see note above
437 -- in Default_Bit_Order description). The is a static attribute.
438
439 ---------------
440 -- Stub_Type --
441 ---------------
442
443 Attribute_Stub_Type => True,
444 -- The GNAT implementation of remote access-to-classwide types is
445 -- organised as described in AARM E.4(20.t): a value of an RACW type
446 -- (designating a remote object) is represented as a normal access
447 -- value, pointing to a "stub" object which in turn contains the
448 -- necessary information to contact the designated remote object. A
449 -- call on any dispatching operation of such a stub object does the
450 -- remote call, if necessary, using the information in the stub object
451 -- to locate the target partition, etc.
452 --
453 -- For a prefix T that denotes a remote access-to-classwide type,
454 -- T'Stub_Type denotes the type of the corresponding stub objects.
455 --
456 -- By construction, the layout of T'Stub_Type is identical to that of
457 -- System.Partition_Interface.RACW_Stub_Type (see implementation notes
458 -- in body of Exp_Dist).
459
460 -----------------
461 -- Target_Name --
462 -----------------
463
464 Attribute_Target_Name => True,
465 -- Standard'Target_Name yields the string identifying the target for the
466 -- compilation, taken from Sdefault.Target_Name.
467
468 ----------------
469 -- To_Address --
470 ----------------
471
472 Attribute_To_Address => True,
473 -- System'To_Address (System is the only permissible prefix) is a
474 -- function that takes any integer value, and converts it into an
475 -- address value. The semantics is to first convert the integer value to
476 -- type Integer_Address according to normal conversion rules, and then
477 -- to convert this to an address using the same semantics as the
478 -- System.Storage_Elements.To_Address function. The important difference
479 -- is that this is a static attribute so it can be used in
480 -- initializations in preelaborate packages.
481
482 ----------------
483 -- Type_Class --
484 ----------------
485
486 Attribute_Type_Class => True,
487 -- T'Type_Class for any type or subtype T yields the value of the type
488 -- class for the full type of T. If T is a generic formal type, then the
489 -- value is the value for the corresponding actual subtype. The value of
490 -- this attribute is of type System.Aux_DEC.Type_Class, which has the
491 -- following definition:
492 --
493 -- type Type_Class is
494 -- (Type_Class_Enumeration,
495 -- Type_Class_Integer,
496 -- Type_Class_Fixed_Point,
497 -- Type_Class_Floating_Point,
498 -- Type_Class_Array,
499 -- Type_Class_Record,
500 -- Type_Class_Access,
501 -- Type_Class_Task,
502 -- Type_Class_Address);
503 --
504 -- Protected types yield the value Type_Class_Task, which thus applies
505 -- to all concurrent types. This attribute is designed to be compatible
506 -- with the DEC Ada attribute of the same name.
507 --
508 -- Note: if pragma Extend_System is used to merge the definitions of
509 -- Aux_DEC into System, then the type Type_Class can be referenced
510 -- as an entity within System, as can its enumeration literals.
511
512 ------------------------------
513 -- Universal_Literal_String --
514 ------------------------------
515
516 Attribute_Universal_Literal_String => True,
517 -- The prefix of 'Universal_Literal_String must be a named number.
518 -- The static result is the string consisting of the characters of
519 -- the number as defined in the original source. This allows the
520 -- user program to access the actual text of named numbers without
521 -- intermediate conversions and without the need to enclose the
522 -- strings in quotes (which would preclude their use as numbers).
523
524 -------------------------
525 -- Unrestricted_Access --
526 -------------------------
527
528 Attribute_Unrestricted_Access => True,
529 -- The Unrestricted_Access attribute is similar to Access except that
530 -- all accessibility and aliased view checks are omitted. This is very
531 -- much a user-beware attribute. Basically its status is very similar
532 -- to Address, for which it is a desirable replacement where the value
533 -- desired is an access type. In other words, its effect is identical
534 -- to first taking 'Address and then doing an unchecked conversion to
535 -- a desired access type. Note that in GNAT, but not necessarily in
536 -- other implementations, the use of static chains for inner level
537 -- subprograms means that Unrestricted_Access applied to a subprogram
538 -- yields a value that can be called as long as the subprogram is in
539 -- scope (normal Ada 95 accessibility rules restrict this usage).
540
541 ---------------
542 -- VADS_Size --
543 ---------------
544
545 Attribute_VADS_Size => True,
546 -- Typ'VADS_Size yields the Size value typically yielded by some Ada 83
547 -- compilers. The differences between VADS_Size and Size is that for
548 -- scalar types for which no Size has been specified, VADS_Size yields
549 -- the Object_Size rather than the Value_Size. For example, while
550 -- Natural'Size is typically 31, the value of Natural'VADS_Size is 32.
551 -- For all other types, Size and VADS_Size yield the same value.
552
553 -------------------
554 -- Valid_Scalars --
555 -------------------
556
557 Attribute_Valid_Scalars => True,
558 -- Obj'Valid_Scalars can be applied to any object. The result depends
559 -- on the type of the object:
560 --
561 -- For a scalar type, the result is the same as obj'Valid
562 --
563 -- For an array object, the result is True if the result of applying
564 -- Valid_Scalars to every component is True. For an empty array the
565 -- result is True.
566 --
567 -- For a record object, the result is True if the result of applying
568 -- Valid_Scalars to every component is True. For class-wide types,
569 -- only the components of the base type are checked. For variant
570 -- records, only the components actually present are checked. The
571 -- discriminants, if any, are also checked. If there are no components
572 -- or discriminants, the result is True.
573 --
574 -- For any other type that has discriminants, the result is True if
575 -- the result of applying Valid_Scalars to each discriminant is True.
576 --
577 -- For all other types, the result is always True
578 --
579 -- A warning is given for a trivially True result, when the attribute
580 -- is applied to an object that is not of scalar, array, or record
581 -- type, or in the composite case if no scalar subcomponents exist. For
582 -- a variant record, the warning is given only if none of the variants
583 -- have scalar subcomponents. In addition, the warning is suppressed
584 -- for private types, or generic formal types in an instance.
585
586 ----------------
587 -- Value_Size --
588 ----------------
589
590 Attribute_Value_Size => True,
591 -- Type'Value_Size is the number of bits required to represent value of
592 -- the given subtype. It is the same as Type'Size, but, unlike Size, may
593 -- be set for non-first subtypes. See section in Einfo ("Handling of
594 -- type'Size values") for further details.
595
596 ---------------
597 -- Word_Size --
598 ---------------
599
600 Attribute_Word_Size => True,
601 -- Standard'Word_Size (Standard is the only permissible prefix)
602 -- provides the value System.Word_Size, and is intended primarily
603 -- for constructing this definition in package System (see note above
604 -- in Default_Bit_Order description). This is a static attribute.
605
606 others => False);
607
608 -- The following table lists all attributes that yield a result of a
609 -- universal type.
610
611 Universal_Type_Attribute : constant array (Attribute_Id) of Boolean :=
612 (Attribute_Aft => True,
613 Attribute_Alignment => True,
614 Attribute_Component_Size => True,
615 Attribute_Count => True,
616 Attribute_Delta => True,
617 Attribute_Digits => True,
618 Attribute_Exponent => True,
619 Attribute_First_Bit => True,
620 Attribute_Fore => True,
621 Attribute_Last_Bit => True,
622 Attribute_Length => True,
623 Attribute_Machine_Emax => True,
624 Attribute_Machine_Emin => True,
625 Attribute_Machine_Mantissa => True,
626 Attribute_Machine_Radix => True,
627 Attribute_Max_Alignment_For_Allocation => True,
628 Attribute_Max_Size_In_Storage_Elements => True,
629 Attribute_Model_Emin => True,
630 Attribute_Model_Epsilon => True,
631 Attribute_Model_Mantissa => True,
632 Attribute_Model_Small => True,
633 Attribute_Modulus => True,
634 Attribute_Pos => True,
635 Attribute_Position => True,
636 Attribute_Safe_First => True,
637 Attribute_Safe_Last => True,
638 Attribute_Scale => True,
639 Attribute_Size => True,
640 Attribute_Small => True,
641 Attribute_Wide_Wide_Width => True,
642 Attribute_Wide_Width => True,
643 Attribute_Width => True,
644 others => False);
645
646 -----------------
647 -- Subprograms --
648 -----------------
649
650 procedure Analyze_Attribute (N : Node_Id);
651 -- Performs bottom up semantic analysis of an attribute. Note that the
652 -- parser has already checked that type returning attributes appear only
653 -- in appropriate contexts (i.e. in subtype marks, or as prefixes for
654 -- other attributes).
655
656 function Name_Implies_Lvalue_Prefix (Nam : Name_Id) return Boolean;
657 -- Determine whether the name of an attribute reference categorizes its
658 -- prefix as an lvalue. The following attributes fall under this bracket
659 -- by directly or indirectly modifying their prefixes.
660 -- Access
661 -- Address
662 -- Input
663 -- Read
664 -- Unchecked_Access
665 -- Unrestricted_Access
666
667 procedure Resolve_Attribute (N : Node_Id; Typ : Entity_Id);
668 -- Performs type resolution of attribute. If the attribute yields a
669 -- universal value, mark its type as that of the context. On the other
670 -- hand, if the context itself is universal (as in T'Val (T'Pos (X)), mark
671 -- the type as being the largest type of that class that can be used at
672 -- run-time. This is correct since either the value gets folded (in which
673 -- case it doesn't matter what type of the class we give if, since the
674 -- folding uses universal arithmetic anyway) or it doesn't get folded (in
675 -- which case it is going to be dealt with at runtime, and the largest type
676 -- is right).
677
678 function Stream_Attribute_Available
679 (Typ : Entity_Id;
680 Nam : TSS_Name_Type;
681 Partial_View : Entity_Id := Empty) return Boolean;
682 -- For a limited type Typ, return True if and only if the given attribute
683 -- is available. For Ada 2005, availability is defined by 13.13.2(36/1).
684 -- For Ada 95, an attribute is considered to be available if it has been
685 -- specified using an attribute definition clause for the type, or for its
686 -- full view, or for an ancestor of either. Parameter Partial_View is used
687 -- only internally, when checking for an attribute definition clause that
688 -- is not visible (Ada 95 only).
689
690 end Sem_Attr;