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