GNAT IMPLEMENTED FEATURES LIST
Current as of 04/30/96

Here is the list of implemented and not implemented features, including
a full description of implementation-defined pragmas and attributes. For
information on how to use GNAT, see gnatinfo.txt.

Latest features in GNAT version 3.04
====================================

   GNAT attributes mantissa, safe_small for fixed points
   GNAT attribute small for floating point
   These attributes correspond to attributes defined in Ada 83.

   gnatlink (new utility program)

   pragma Unchecked_Union is fully implemented (see end of this document)

   More efficient execution of programs containing exception handlers
   (especially on Sun Sparc)

   Many new options to gnatmake: (see gnatinfo.txt for details)
   -aI -aO, -jnum, -k, -l, -o

   New Source & Library search path switches: (see gnatinfo.txt for details)
   -aLdir, -Adir, -aOdir, -aIdir, -Idir, -I-, -Ldir

   The DOS version has been migrated to DJGPP v2.
   Tasking is now fully functional in the DOS version.
   "Real" memory problems in the DOS version have been alleviated.

   New warnings for some infinite recursion cases

   When an Assert_Failure exception is raised, the exception is raised
   with a message, either the file name and line number by default of
   the pragma Assert, or the string explicitly supplied as the second
   parameter.

   The restriction names No_GNAT_Attributes and No_GNAT_Pragmas have
   been renamed No_Implementation_Attributes and No_Implementation_Pragmas.

   Record Representation Clauses which do not specify representations for
   all components (partial rep clauses) are now accepted by GNAT.

   Packed arrays of records are now implemented.

   The Size attribute is now handled as specified in the RM. This means
   that the value of 'Size will often be different from what it was
   before and what it was in Ada 83. Two new attributes Object_Size
   and Value_Size have been added to provide additional control.

Latest features in GNAT version 3.03
====================================

    Implement packing of multidimensional arrays

    Get_Immediate now follows the implementation advice and works as intended
    (for SGI IRIX, Sparc SunOS/Solaris, Alpha OSF1, IBM OS/2 and Linux)

    The task attributes package is now fully functional

    Warnings for unset variables, and possible access before initialization

    pragma Warnings (On | Off) allows more detailed control of warnings
    pragma Source_File_Name allows specifying non-standard file names
    pragma No_Return allows specifying a procedure that never returns
    pragma Attach_Handler    (implemented on Sparc SunOS and Sparc Solaris only)
    pragma Interrupt_Handler (implemented on Sparc SunOS and Sparc Solaris only)

Latest features in GNAT version 3.01
====================================

    pragma Normalize_Scalars
    Ada.Text_IO.Editing
    Ada.Wide_Text_IO.Editing
    Incomplete types declared in the private part that are
     completed in the package body as unconstrained arrays.
    Full implementation of stream attributes, including the
     dispatching cases for class wide types.
    Private protected operations
    Pointers to unconstrained arrays may be double or single length. Double
     ("fat") is the default size (e.g. 64 on SGI), but rep clauses or a
     foreign convention will force them to single length.
    Aggregates for composite Types with controlled components
    Objects of type with unknown discriminants
    pragma Queuing_Policy
    pragma Source_File_Name (GNAT specific)
    True multiprocessing on Sparc Solaris

Latest features in GNAT version 2.07
====================================

    Discriminant checks
    Package Ada.Exceptions
    External_Tag attribute
    Identity attribute
    Range Checks on the elaboration of a subtype_indication
    Duration is an ordinary fixed-point type with delta of one nanosecond
    Package Interfaces.COBOL
    Protected subprogram pointers
    Caller attribute
    Restriction pragma
    All restrictions in real time annex
    All restrictions in safety and security annex
    Higher resolution clocks for tasking on SunOS/Solaris

Latest features in GNAT version 2.06
====================================

    Requeue Statement involving task entries
    inter-unit inlining (enabled by -O2 -gnatn)
    aggregates for simple controlled types

Latest features in GNAT version 2.05
====================================

    Elaboration Checks
    A new switch -gnati8 specifies the use of IBM PC Code Page 850 for
     the identifier character set (this is Latin-1 a la IBM PC)
    Protected entry families
    Ada.Synchronous_Task_Control
    Attribute Storage_Pool
    Packed arrays (including packed boolean arrays)
    Accessibility checks
    -I for specifying source and object path (see gnatinfo.txt for details)
    Conditional protected entry calls
    Delay until inside select statements

Latest features in GNAT version 2.04
====================================

    GNATMAKE utility (see gnatinfo.txt for details)
    Pragma Export
    Ada.Streams.Stream_IO
    Attribute Definite
    Interrupt entries
    Input-Output for Modular Types
    Input-Output for Decimal Types
    Input-Output for Integer for type Long_Long_Integer.
    The following are now implemented in package Ada.Text_IO
      Flush
      Look_Ahead
      Get_Immediate
    Text_IO.Complex_IO
    Text_IO.Text_Streams
    Wide_Text_IO
    Wide_Text_IO.Complex_IO
    Wide_Text_IO.Text_Streams

    Note: All the I/O packages have been rewritten from the
    ground up for this release, and should completely implement all
    features of the RM. To get file sharing, allowed only if the
    files are for the same I/O package and same mode, use a form
    parameter shared=yes.

Status of Features

  This list applies to the ports for the following targets:

   SGI IRIX 5.2
   Sun Sparc (SunOS 4.1 and Solaris 2.3),
   x86 running IBM OS/2, Linux

  Other targets are generally complete except that no tasking constructs
  are implemented.

==========================================================
= All of Ada 83 is implemented EXCEPT for the following: =
==========================================================

   Stack overflow checking is implemented only on the SGI machines

=========================================================================
= All of Ada 95 implemented EXCEPT the following unimplemented features =
=========================================================================

  CORE
    (fully implemented)
 
  ANNEX A. PREDEFINED LANGUAGE ENVIRONMENT
    Ada.Interrupts (implemented on Sparc SunOS and Sparc Solaris only)

  ANNEX B. INTERFACING TO OTHER LANGUAGES
    (fully implemented)

  ANNEX C. SYSTEMS PROGRAMMING
    Machine intrinsic subprograms
    Interrupt support (implemented on Sparc SunOS and Sparc Solaris only)
    Ada.Interrupts (implemented on Sparc SunOS and Sparc Solaris only)
    Record rep clauses require full specification

  ANNEX D. REAL-TIME SYSTEMS
    (fully implemented)

  ANNEX E. DISTRIBUTED SYSTEMS
    (fully implemented)
    (this refers to the compiler part, stub generation and the pragmas)

  ANNEX F. INFORMATION SYSTEMS
    (fully implemented)

  ANNEX G. NUMERICS
    Accuracy requirements for floating-point and complex not fully met

  ANNEX H. SAFETY AND SECURITY
    (fully implemented)

  ANNEX I. OBSOLESCENT FEATURES
    (fully implemented)

  ANNEX J. LANGUAGE-DEFINED ATTRIBUTES
    (fully implemented)

  ANNEX K. LANGUAGE DEFINED PRAGMAS
    Attach_Handler (implemented on Sparc SunOS and Sparc Solaris only)
    Interrupt_Handler (implemented on Sparc SunOS and Sparc Solaris only)

================================
= Description of GNAT Pragmas ==
================================

  pragma Abort_Defer;
  
    This pragma is implementation (GNAT) defined. It must appear at
    the start of the statement sequence of a handled sequence of
    statements (right after the begin). It has the effect of deferring
    aborts for the sequence of statements (but not for the declarations
    or handlers, if any, associated with this statement sequence). The
    exception case is handled correctly, i.e. if the statement sequence
    propagates an exception, then abort is properly undeferred.
  
  pragma Ada_83;
  
    This pragma is implementation (GNAT) defined. It establishes Ada 83
    mode for following text, regardless of the mode set by the command
    line switches. Note that this is not a configuration pragma, so it
    must be given separately for each unit to which it applies.
  
  pragma Ada_95;
  
    This pragma is implementation (GNAT) defined. It establishes Ada 95
    mode for following text, regardless of the mode set by the command
    line switches. Note that this is not a configuration pragma, so it
    must be given separately for each unit to which it applies.
  
    Note: Ada 95 mode is set automatically for predefined language
    units, including children of GNAT, so need not be given for any
    such units.
  
  pragma Annotate (IDENTIFIER {, ARG});
  ARG ::= NAME | EXPRESSION
  
    This pragma is an implementation (GNAT) defined pragma used to
    annotate programs. The first argument is simply an identifier
    that identifies the type of annotation. GNAT verifies that this
    is an identifier, but does not otherwise analyze it. The arguments
    following this identifier are analyzed as follows:
  
      String literals are assumed to be of type Standard.String
      Names of entities are simply analyzed as entity names
      All other expressions are analyzed as expressions, and must
       be unambiguous
  
   The analyzed pragma is retained in the tree, but not otherwise
   processed by any part of the GNAT compiler. This pragma is intended
   for use by external tools.
  
  pragma Assert (Boolean_EXPRESSION [,static_string_EXPRESSION]);
  
    This pragma is implementation (GNAT) defined. Its effect depends
    on whether the corresponding command line switch is set to activate
    assertions. If assertions are inactive, the pragma has no effect.
    If asserts are enabled, then the semantics of the pragma is exactly
    equivalent to:
  
      if not Boolean_EXPRESSION then
         System.Assertions.Raise_Assert_Failure (string_EXPRESSION);
      end if;
  
    The effect of the call is to raise System.Assertions.Assert_Failure.
    The string argument, if given, is the message associated with the
    exception occurrence. If no second argument is given, the default
    message is "file:nnn", where file is the name of the source file
    containing the assert, and nnn is the line number of the assert.
  
    Note: a pragma is not a statement, so if a statement sequence
    contains nothing but a pragma assert, then a null statement is
    required in addition, as in:
  
       ...
       if J > 3 then
          pragma (Assert (K > 3, "Bad value for K"));
          null;
       end if;
  
    Note: if the boolean expression has side effects, then these side
    effects will turn on and off with the setting of the assertions mode,
    resulting in assertions that have an effect on the program. This
    should generally be avoided.
  
  pragma CPP_Class ([Entity =>] LOCAL_NAME)
  
    The argument denotes an entity in the current declarative region
    that is declared as a tagged or untagged record type. It indicates
    that the type corresponds to an externally declared C++ class type,
    and is to be layed out the same way that C++ would lay out the type.
    If (and only if) the type is tagged, at least one component in the
    record must be of type Interfaces.CPP.Vtable_Ptr, corresponding to
    the C++ Vtable (or Vtables in the case of multiple inheritance)
    used for dispatching.
  
    Types for which CPP_Class is defined do not have assignment or
    equality operators defined (such operations can be imported or
    declared as subprograms as required). Initialization is allowed
    only by constructor functions (see pragma CPP_Constructor).
  
  pragma CPP_Constructor ([Entity =>] LOCAL_NAME);
  
    This pragma identifies an imported function (imported in the usual
    way with pragma Import) as corresponding to a C++ constructor. The
    identified function must be previously mentioned in a pragma Import
    with convention C++, and must be of one of the following forms:
  
      function Fname return T'Class;
      function Fname (<parameters>) return T'Class;
  
    where T is a tagged type to which the pragma CPP_Class applies.
  
    The first form is the default constructor, used when an object
    of type T is created on the Ada side with no explicit constructor.
    Other constructors (including the copy constructor, which is simply
    a special case of the second form in which the one and only argument
    is of type T), can only appear in two contexts:
  
      On the right side of an initialization of an object of type T
      In an extension aggregate for an object of a type derived from T
  
    Note that although the constructor is described as a function that
    returns a value on the Ada side, it is typically a procedure with
    an extra implicit argument (the object being initialized) at the
    implementation level. GNAT takes care of issuing the appropriate
    call, whatever it is, to get the object properly initialized.
  
    Note: in the case of derived objects, there are two possible forms
    for declaring and creating an object:
  
      New_Object : Derived_T;
      New_Object : Derived_T := (constructor-function-call with ...);
  
    In the first case the default constructor is called, and extension
    fields if any are initialized according to the default initialization
    expressions in the Ada declaration. In the second case, the given
    constructor is called, and the extension aggregate indicates the
    explicit values of the extension fields.
  
    Note: if no constructors are imported then it is impossible to
    create any objects on the Ada side. If no default constructor is
    imported, then only the initialization forms using an explicit
    call to a constructor are permitted.
  
  pragma CPP_Destructor ([Entity =>] LOCAL_NAME);
  
    This pragma identifies an imported procedure (imported in the usual
    way with pragma Import) as corresponding to a C++ destructor. The
    identified procedure must be previously mentioned in a pragma Import
    with convention C++, and must be of the following forms:
  
      procedure Fname (obj : in out T'Class);
  
    where T is a tagged type to which the pragma CPP_Class applies.
    This procedure will be called automaticlly on scope exit if any
    objects of T are created on the Ada side.
  
  pragma CPP_Virtual
      [Entity =>]       LOCAL_NAME
    [ [Vtable_Ptr =>]   Component_NAME,
      [Position =>]     static_integer_EXPRESSION]);
  
    This pragma serves the same function as pragma Import for the case
    of a virtual function that is imported from C++. Entity must refer
    to a primitive subprogram of a tagged type to which pragma CPP_Class
    applies. Vtable_Ptr specifies the Vtable_Ptr component which contains
    the entry for this virtual function, and Position is the sequential
    number counting virtual functions for this Vtable starting at 1.
  
    The Vtable_Ptr and Position arguments may be omitted if there is
    one Vtable_Ptr present (single inheritance case), and all virtual
    functions are imported, since then the compiler can deduce both
    these values.
  
    Note that no External_Name or Link_Name arguments are required for
    a virtual function, since it is always accessed indirectly via the
    appropriate Vtable entry.
  
  pragma CPP_Vtable (
    [Entity =>]       LOCAL_NAME
    [Vtable_Ptr =>]   Component_NAME,
    [Entry_Count =>]  static_integer_EXPRESSION);
  
    One CPP_Vtable pragma can be present for each component of type
    CPP.Interfaces.Vtable_Ptr in a record to which pragma CPP_Class
    applies. Entity is the tagged type, Vtable_Ptr is the record field
    of type Vtable_Ptr, and Entry_Count is the number of virtual
    functions on the C++ side (not all of which need to be imported
    on the Ada side).
  
    It is permissible to omit the CPP_Vtable pragma if there is only
    one Vtable_Ptr component in the record, and all virtual functions
    are imported on the Ada side (the default value for the entry count
    in this case is simply the total number of virtual functions).
  
  pragma Debug (PROCEDURE_CALL_STATEMENT);
  
    This pragma is implementation (GNAT) defined. Its effect depends
    on the setting of the Assertions_Enabled flag in Opt. If this
    flag is off (False), then the pragma has no effect. If the flag
    is on (True), then the semantics of the pragma is equivalent to
    the procedure call.
  
  pragma Error_Monitoring (On | Off, STRING_LITERAL)
  
    This pragma is implementation (GNAT) defined. It is used to bracket
    a section of code, using one pragma with argument ON to start the
    section, and another with argument OFF to end the section. Within
    the monitored section of code, any error message issued will be
    considered a warning from the point of view of the return code
    issued by the compilation. Furthermore at least one such error
    must occur within each monitored region. If no error occurs, a
    fatal (non-warning) message is issued. The use of the pragma
    Error_Monitoring causes code generation to be turned off (since
    there really are errors in the program).
  
    If a second argument is given, then there is an additional check
    that the first error issued in the monitored region exactly matches
    the characters given in the string literal. The second argument is
    only relevant for the ON case, it is ignored for the OFF case.
  
    This pragma is provided to allow easy automation of error message
    generation, e.g. in ACVC B tests, and is primarily intended for
    compiler testing purposes.
  
  pragma Inline_Generic (generic_package_NAME)
    This is implemented for compatibility with Dec, and is recognized,
    but otherwise ignored by GNAT.
  
  pragma Interface_Name (
      [Entity =>]         LOCAL_NAME
    [,[External_Name =>]  static_string_EXPRESSION]]
    [,[Link_Name =>]      static_string_EXPRESSION]] );
  
    This pragma is implementation (GNAT) defined. It is an alternative
    way of specifying the interface name for an interfaced subprogram,
    and is provided for compatibility with Ada 83 compilers that use
    the pragma for this purpose. At least one of the arguments external
    name or link name must be present.
  
  pragma Machine_Attribute (
      [Attribute_Name =>] static_string_EXPRESSION
     ,[Entity =>]         LOCAL_NAME );
  
    This pragma is implementation (GNAT) defined. Machine dependent
    attributes can be specified for types and/or declarations. Currently
    only subprogram entities are supported. This pragma is semantically
    equivalent to __attribute__(( <Attribute_Name> )) in Gnu C, where
    <Attribute_Name> is recognized by the Gnu C macros:
  
       VALID_MACHINE_TYPE_ATTRIBUTE
       VALID_MACHINE_DECL_ATTRIBUTE,
  
    which are defined in the configuration header file tm.h.  Further
    documentation can be found in the gcc distribution document: tm.texi.
  
  pragma No_Return (procedure_LOCAL_NAME);
  
    The given name must refer to one or more procedure declarations
    in the current declarative part. A procedure to which this pragma
    is applied may not contain any explicit return statements, and
    also may not contain any implicit return statements from falling
    off the end of a statement sequence. One use of this pragma is to
    identify procedures whose only purpose is to raise an exception.
  
    One use of this pragma is to suppress incorrect warnings about
    missing returns in functions, where the last statement of a
    function statement sequence is a call to such a procedure.
  
  pragma Share_Generic (generic_package_NAME)
  
    This is implemented for compatibility with Dec, and is recognized,
    but otherwise ignored by GNAT.
  
  pragma Source_File_Name (
    [UNIT_NAME =>] unit_NAME,
    [BODY_FILE_NAME | SPEC_FILE_NAME] => STRING_LITERAL)
  
    The source file name pragma allows a program to override the normal
    naming convention. It is a configuration pragma, and so has the usual
    applicability of configuration pragmas (i.e. it applies to either an
    entire partition, or to all units in a compilation, or to a single
    unit, depending on how it is used. The form of the pragma is:
  
    The given unit name is mapped to the given file name. The identifier
    for the second argument is required, and indicates whether this is
    the file name for the spec or for the body.
  
  pragma Source_Reference (INTEGER_LITERAL [, STRING_LITERAL]);
  
    This pragma is implementation (GNAT) defined. It typically appears
    as the first line of a source file. The integer value is the logical
    line number of the line following the pragma line (for use in error
    messages and debugging information). The second argument is a static
    string constant that specifies the file name to be used in error
    messages and debugging information. This is most notably used for
    the output of gnatchop with the -r switch, to make sure that the
    original unchopped source file is the one referred to.
  
    Note: the second argument must be a string literal, it cannot be
    a static string expression other than a string literal. This is
    because its value is needed for error messages issued by all phases
    of the compiler.
  
  pragma Subtitle (...)
    Recognized but ignored
  
  pragma Task_Info (task_info_EXPRESSION)
    This pragma appears within a task definition (like pragma Priority)
    and applies to the task in which it appears. The argument must be
    of type System.Task_Info.Task_Info_Type.
  
  pragma Title (...)
    Recognized but ignored
  
  pragma Unchecked_Union (first_subtype_LOCAL_NAME)
    This pragma is implementation (GNAT) defined. It is used to declare
    that the named type should be equivalent to a C union type, and is
    intended only for use in interfacing with C code that uses union
    types. In Ada terms, the named type must obey the following rules:
  
       It is a non-tagged non-limited record type
       It has a single discrete discriminant with a default value
       Pragma Suppress (Discriminant_Check) applies implicitly
       The component list consists of a single variant part
       The default convention is C
       Each variant has a component list with a single component
       No nested variants are allowed
       No component can have an explicit default value
       No component can have a non-static constraint
  
    In addition, given a type that meets the above requirements, the
    following restrictions apply to its use throughout the program:
  
       The discriminant name can be mentioned only in an aggregate
       No subtypes may be created of this type
       The type may not be constrained by giving a discriminant value
       An unchecked union type cannot be passed as the actual for a
        generic formal with a discriminant.
  
    Also, equality and inequality operations on unchecked_unions are not
    available, since there is no discriminant to compare, and in general
    the compiler does not even know how many bits to compare. It is
    implementation dependent whether this is detected at compile time
    as an illegality, or whether it is undetected and considered to be
    an erroneous construct. In GNAT, a direct comparison is illegal,
    but GNAT does not attempt to catch the composite case (where two
    composites are compared that contain an unchecked union component),
    so such comparisons are simply considered erroneous.
  
    The layout of the resulting type corresponds exactly to a C union,
    where each branch of the union corresponds to a single variant in
    the Ada record. The semantics of the Ada program is not changed in
    any way by the pragma, i.e. provided the above restrictions are
    followed, and no erroneous incorrect references to fields or
    erroneous comparisons occur, the semantics is exactly as described
    by the Ada reference manual.
  
  pragma Unimplemented_Unit;
  
    This pragma is implementation (GNAT) defined. If it occurs in a
    unit that is processed by the compiler, the compilation is aborted
    with the message xxx not implemented, where xxx is the name of
    the current compilation unit followed by a compiler abort. This
    pragma is intended to allow the compiler to handle unimplemented
    library units in a clean manner.
  
    The abort only hapens if code is being generated. This allows the
    use of specs of unimplemented packages in syntax or semantic
    checking mode.
  
  pragma Unsuppress (IDENTIFIER [, [On =>] NAME]);
  
    This pragma is an implementation (GNAT) defined configuration pragma.
    It undoes the effect of a previous pragma Suppress. If there is no
    corresponding pragma Suppress in effect, then it has no effect. The
    range of the effect is the same as for pragma Suppress. The meaning
    of the arguments is identical to that used in pragma Suppress.
  
    One important application is to ensure that checks are on in cases
    where code depends on the checks for its correct functioning, so
    that the code will compile correctly even if the compiler switches
    are set to suppress checks.
  
  Pragma Warnings (On | Off, [LOCAL_NAME]);
  
    Normally warnings are enabled, with the output being controlled by
    the command line switch. Warnings (Off) turns off generation of
    warnings until a Warnings (On) is encountered or the end of the
    current unit. If generation of warnings is turned off using this
    pragma, then no warning messages are output, regardless of the
    setting of the command line switches.
  
    The form with a single argument is a configuration pragma.
  
    If a second parameter is present, then warnings are suppressed for
    the particular entity named in the pragma. This suppression is
    effective from the point where it occurs till the end of the
    extended scope of the variable (similar to the scope of Suppress).

==========================================
= Description of GNAT-defined Attributes =
==========================================

  Abort_Signal 
   
    Standard'Abort_Signal (Standard is the only allowed prefix)
    provides the entity for the special exception used to signal
    task abort or asynchronous transfer of control. Normally this
    attribute should only be used in the tasking runtime (it is
    highly peculiar, and completely outside the normal semantics
    of Ada, for a user program to intercept the abort exception).
   
  Address_Size 
   
    Standard'Address_Size (Standard is the only allowed prefix) is
    a static constant giving the number of bits in an Address. It
    is used primarily for constructing the definition of Memory_Size
    in package Standard, but may be freely used in user programs.
    This is a static attribute.
   
  Default_Bit_Order 
   
    Standard'Default_Bit_Order (Standard is the only permissible prefix),
    provides the value System.Default_Bit_Order as a Pos value (0 for
    High_Order_First, 1 for Low_Order_First). This is used to construct
    the definition of Default_Bit_Order in package System. This is a
    static attribute.
   
  Elab_Body 
   
    This attribute can only be applied to a program unit name. It
    returns the entity for the corresponding elaboration procedure
    for elaborating the body of the referenced unit. This is used
    in the main generated elaboration procedure by the binder, and
    is not normally used in any other context, but there may be
    specialized situations in which it is useful to be able to
    call this elaboration procedure from Ada code, e.g. if it
    is necessary to do selective reelaboration to fix some error.
   
  Elab_Spec 
   
    This attribute can only be applied to a program unit name. It
    returns the entity for the corresponding elaboration procedure
    for elaborating the spec of the referenced unit. This is used
    in the main generated elaboration procedure by the binder, and
    is not normally used in any other context, but there may be
    specialized situations in which it is useful to be able to
    call this elaboration procedure from Ada code, e.g. if it
    is necessary to do selective reelaboration to fix some error.
   
  Enum_Rep 
   
    For every enumeration subtype S, S'Enum_Rep denotes a function
    with the following specification:
   
      function S'Enum_Rep (Arg : S'Base) return universal_integer;
   
    The function returns the representation value for the given
    enumeration value. This will be equal to the 'Pos value in the
    absence of an enumeration representation clause. This is a static
    attribute (i.e. the result is static if the argument is static).
   
  Fixed_Value 
   
    For every fixed-point type S, S'Fixed_Value denotes a function
    with the following specification:
   
      function S'Fixed_Value (Arg : universal_integer) return S;
   
    The value returned is the fixed-point value V such that
   
      V = Arg * S'Small
   
    The effect is thus equivalent to first converting the argument
    to the integer type used to represent S, and then doing an
    unchecked conversion to the fixed-point type. This attribute is
    primarily intended for use in implementation of the input-output
    functions for fixed-point values.
   
  Img 
   
    The 'Img function is defined for any prefix, P, that denotes an
    object of scalar type T. P'Img is equivalent to T'Image (P). This
    is convenient for debugging. For example:
   
       Put_Line ("X = " & X'Img);
   
    has the same meaning as the more verbose:
   
       Put_Line ("X = " & Temperature_Type'Image (X));
   
    where Temperature_Type is the subtype of the object X.
   
  Integer_Value 
   
    For every integer type S, S'Integer_Value denotes a function
    with the following specification:
   
      function S'Integer_Value (Arg : universal_fixed) return S;
   
    The value returned is the integer value V, such that
   
      Arg = V * fixed-type'Small
   
    The effect is thus equivalent to first doing an unchecked convert
    from the fixed-point type to its corresponding implementation type,
    and then converting the result to the target integer type. This
    attribute is primarily intended for use in implementation of the
    standard input-output functions for fixed-point values.
   
  Max_Interrupt_Priority 
   
    Standard'Max_Interrupt_Priority (Standard is the only permissible
    prefix), provides the value System.Max_Interrupt_Priority, and is
    intended primarily for constructing this definition in package
    System (see note above in Default_Bit_Order description}. This
    is a static attribute.
   
  Max_Priority 
   
    Standard'Max_Priority (Standard is the only permissible prefix)
    provides the value System.Max_Priority, and is intended primarily
    for constructing this definition in package System (see note above
    in Default_Bit_Order description). This is a static attribute.
   
  Maximum_Alignment 
   
    Standard'Maximum_Alignment (Standard is the only permissible prefix)
    provides the maximum useful alignment value for the target. This
    is a static value that can be used to specify the alignment for an
    object, guaranteeing that it is properly aligned in all cases. The
    time this is useful is when an external object is imported and its
    alignment requirements are unknown. This is a static attribute.

  Object_Size

    Type'Object_Size is the same as Type'Size for all types except
    fixed-point types and discrete types. For fixed-point types and
    discrete types, this attribute gives the size used for default
    allocation of objects and components of the size. It may be set
    for any subtype (even a non-first subtype). See section on Size
    handling for further details.
   
  Passed_By_Reference 
   
    T'Passed_By_Reference for any subtype T returns a boolean value
    that is true if the type is normally passed by reference and
    false if the type is normally passed by copy in calls. For scalar
    types, the result is always False and is static. For non-scalar
    types, the result is non-static (since it is computed by Gigi).
   
  Range_Length 
   
    T'Range_Length for any discrete type T yields the number of
    values represented by the subtype (zero for a null range). The
    result is static for static subtypes. Note that Range_Length
    applied to the index subtype of a one dimensional array always
    gives the same result as Range applied to the array itself.
   
  Storage_Unit 
   
    Standard'Storage_Unit (Standard is the only permissible prefix)
    provides the value System.Storage_Unit, and is intended primarily
    for constructing this definition in package System (see note above
    in Default_Bit_Order description). The is a static attribute.
   
  Tick 
   
    Standard'Tick (Standard is the only permissible prefix) provides
    the value System.Tick, and is intended primarily for constructing
    this definition in package System (see note above in description
    of Default_Bit_Order). This is a static attribute.
   
  Universal_Literal_String 
   
    The prefix of 'Universal_Literal_String must be a named number.
    The static result is the string consisting of the characters of
    the number as defined in the original source. This allows the
    user program to access the actual text of named numbers without
    intermediate conversions and without the need to enclose the
    strings in quotes (which would preclude their use as numbers).
    This is used internally for the construction of values of the
    floating-point attributes from the file ttypef.ads, but may
    also be used by user programs.
   
  Unrestricted_Access 
   
    The Unrestricted_Access attribute is similar to Access except that
    all accessibility and aliased view checks are omitted. This is very
    much a user-beware attribute. Basically its status is very similar
    to Address, for which it is a desirable replacement where the value
    desired is an access type. In other words, its effect is identical
    to first taking 'Address and then doing an unchecked conversion to
    a desired access type. Note that in GNAT, but not necessarily in
    other implementations, the use of static chains for inner level
    subprograms means that Unrestricted_Access applied to a subprogram
    yields a value that can be called as long as the subprogram is in
    scope (normal Ada 95 accessibility rules restrict this usage).

  Value_Size

    Type'Value_Size is the number of bits required to represent a
    value of the given subtype. It is the same as Type'Size, but,
    unlike Size, may be set for non-first subtypes. See section
    on Size handling for further details.
   
  Word_Size 
   
    Standard'Word_Size (Standard is the only permissible prefix)
    provides the value System.Word_Size, and is intended primarily
    for constructing this definition in package System (see note above
    in Default_Bit_Order description). This is a static attribute.
