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-2019, 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 34with Exp_Tss; use Exp_Tss; 35with Namet; use Namet; 36with Snames; use Snames; 37with Types; use Types; 38 39package 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 700end Sem_Attr; 701