2. Implementation Defined Aspects
Ada defines (throughout the Ada 2012 reference manual, summarized
in annex K) a set of aspects that can be specified for certain entities.
These language defined aspects are implemented in GNAT in Ada 2012 mode
and work as described in the Ada 2012 Reference Manual.
In addition, Ada 2012 allows implementations to define additional aspects
whose meaning is defined by the implementation. GNAT provides
a number of these implementation-dependent aspects which can be used
to extend and enhance the functionality of the compiler. This section of
the GNAT reference manual describes these additional attributes.
Note that any program using these aspects may not be portable to
other compilers (although GNAT implements this set of aspects on all
platforms). Therefore if portability to other compilers is an important
consideration, you should minimize the use of these aspects.
Note that for many of these aspects, the effect is essentially similar
to the use of a pragma or attribute specification with the same name
applied to the entity. For example, if we write:
| | type R is range 1 .. 100
with Value_Size => 10;
|
then the effect is the same as:
| | type R is range 1 .. 100;
for R'Value_Size use 10;
|
and if we write:
| | type R is new Integer
with Shared => True;
|
then the effect is the same as:
| | type R is new Integer;
pragma Shared (R);
|
In the documentation sections that follow, such cases are simply marked
as being equivalent to the corresponding pragma or attribute definition
clause.
Aspect Abstract_State
This aspect is equivalent to pragma Abstract_State.
Aspect Ada_2005
This aspect is equivalent to the one argument form of pragma Ada_2005.
Aspect Ada_2012
This aspect is equivalent to the one argument form of pragma Ada_2012.
Aspect Compiler_Unit
This aspect is equivalent to pragma Compiler_Unit.
Aspect Contract_Cases
This aspect is equivalent to pragma Contract_Cases, the sequence
of clauses being enclosed in parentheses so that syntactically it is an
aggregate.
Aspect Depends
This aspect is equivalent to pragma Depends.
* Dimension::
Aspect Dimension
The Dimension aspect is used to specify the dimensions of a given
subtype of a dimensioned numeric type. The aspect also specifies a symbol
used when doing formatted output of dimensioned quantities. The syntax is:
| | with Dimension =>
([Symbol =>] SYMBOL, DIMENSION_VALUE {, DIMENSION_Value})
SYMBOL ::= STRING_LITERAL | CHARACTER_LITERAL
DIMENSION_VALUE ::=
RATIONAL
| others => RATIONAL
| DISCRETE_CHOICE_LIST => RATIONAL
RATIONAL ::= [-] NUMERIC_LITERAL [/ NUMERIC_LITERAL]
|
This aspect can only be applied to a subtype whose parent type has
a Dimension_Systen aspect. The aspect must specify values for
all dimensions of the system. The rational values are the powers of the
corresponding dimensions that are used by the compiler to verify that
physical (numeric) computations are dimensionally consistent. For example,
the computation of a force must result in dimensions (L => 1, M => 1, T => -2).
For further examples of the usage
of this aspect, see package System.Dim.Mks.
Note that when the dimensioned type is an integer type, then any
dimension value must be an integer literal.
Aspect Dimension_System
The Dimension_System aspect is used to define a system of
dimensions that will be used in subsequent subtype declarations with
Dimension aspects that reference this system. The syntax is:
| | with Dimension_System => (DIMENSION {, DIMENSION});
DIMENSION ::= ([Unit_Name =>] IDENTIFIER,
[Unit_Symbol =>] SYMBOL,
[Dim_Symbol =>] SYMBOL)
SYMBOL ::= CHARACTER_LITERAL | STRING_LITERAL
|
This aspect is applied to a type, which must be a numeric derived type
(typically a floating-point type), that
will represent values within the dimension system. Each DIMENSION
corresponds to one particular dimension. A maximum of 7 dimensions may
be specified. Unit_Name is the name of the dimension (for example
Meter). Unit_Symbol is the shorthand used for quantities
of this dimension (for example 'm' for Meter). Dim_Symbol gives
the identification within the dimension system (typically this is a
single letter, e.g. 'L' standing for length for unit name Meter). The
Unit_Smbol is used in formatted output of dimensioned quantities. The
Dim_Symbol is used in error messages when numeric operations have
inconsistent dimensions.
GNAT provides the standard definition of the International MKS system in
the run-time package System.Dim.Mks. You can easily define
similar packages for cgs units or British units, and define conversion factors
between values in different systems. The MKS system is characterized by the
following aspect:
| | type Mks_Type is new Long_Long_Float
with
Dimension_System => (
(Unit_Name => Meter, Unit_Symbol => 'm', Dim_Symbol => 'L'),
(Unit_Name => Kilogram, Unit_Symbol => "kg", Dim_Symbol => 'M'),
(Unit_Name => Second, Unit_Symbol => 's', Dim_Symbol => 'T'),
(Unit_Name => Ampere, Unit_Symbol => 'A', Dim_Symbol => 'I'),
(Unit_Name => Kelvin, Unit_Symbol => 'K', Dim_Symbol => "Theta"),
(Unit_Name => Mole, Unit_Symbol => "mol", Dim_Symbol => 'N'),
(Unit_Name => Candela, Unit_Symbol => "cd", Dim_Symbol => 'J'));
|
See section "Performing Dimensionality Analysis in GNAT" in the GNAT Users
Guide for detailed examples of use of the dimension system.
Aspect Favor_Top_Level
This aspect is equivalent to pragma Favor_Top_Level.
Aspect Global
This aspect is equivalent pragma Global.
Aspect Inline_Always
This aspect is equivalent to pragma Inline_Always.
Aspect Invariant
This aspect is equivalent to pragma Invariant. It is a
synonym for the language defined aspect Type_Invariant except
that it is separately controllable using pragma Assertion_Policy.
Aspect Lock_Free
This aspect is equivalent to pragma Lock_Free.
Aspect Object_Size
This aspect is equivalent to an Object_Size attribute definition
clause.
Aspect Persistent_BSS
This aspect is equivalent to pragma Persistent_BSS.
Aspect Predicate
This aspect is equivalent to pragma Predicate. It is thus
similar to the language defined aspects Dynamic_Predicate
and Static_Predicate except that whether the resulting
predicate is static or dynamic is controlled by the form of the
expression. It is also separately controllable using pragma
Assertion_Policy.
Aspect Preelaborate_05
This aspect is equivalent to pragma Preelaborate_05.
Aspect Pure_05
This aspect is equivalent to pragma Pure_05.
Aspect Pure_12
This aspect is equivalent to pragma Pure_12.
Aspect Pure_Function
This aspect is equivalent to pragma Pure_Function.
Aspect Remote_Access_Type
This aspect is equivalent to pragma Remote_Access_Type.
Aspect Scalar_Storage_Order
This aspect is equivalent to a Scalar_Storage_Order
attribute definition clause.
Aspect Shared
This aspect is equivalent to pragma Shared, and is thus a synonym
for aspect Atomic.
Aspect Simple_Storage_Pool
This aspect is equivalent to a Simple_Storage_Pool
attribute definition clause.
Aspect Simple_Storage_Pool_Type
This aspect is equivalent to pragma Simple_Storage_Pool_Type.
Aspect SPARK_Mode
This aspect is equivalent to pragma SPARK_Mode.
Aspect Suppress_Debug_Info
This aspect is equivalent to pragma Suppress_Debug_Info.
Aspect Test_Case
This aspect is equivalent to pragma Test_Case.
Aspect Universal_Aliasing
This aspect is equivalent to pragma Universal_Aliasing.
Aspect Universal_Data
This aspect is equivalent to pragma Universal_Data.
Aspect Unmodified
This aspect is equivalent to pragma Unmodified.
Aspect Unreferenced
This aspect is equivalent to pragma Unreferenced.
Aspect Unreferenced_Objects
This aspect is equivalent to pragma Unreferenced_Objects.
Aspect Value_Size
This aspect is equivalent to a Value_Size
attribute definition clause.
Aspect Warnings
This aspect is equivalent to the two argument form of pragma Warnings,
where the first argument is ON or OFF and the second argument
is the entity.
This document was generated
by GNAT Mailserver on May, 17 2013
using texi2html