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