Ada Reference ManualLegal Information
Contents   Index   References   Search   Previous   Next 

4.9 Static Expressions and Static Subtypes

1
Certain expressions of a scalar or string type are defined to be static. Similarly, certain discrete ranges are defined to be static, and certain scalar and string subtypes are defined to be static subtypes. Static means determinable at compile time, using the declared properties or values of the program entities.
2
A static expression is a scalar or string expression that is one of the following:
3
4
5
6
7
8
9
10
11
12
13
14
A name statically denotes an entity if it denotes the entity and: 
15
16
17
18
A static function is one of the following: 
19
20
21
22
23
In any case, a generic formal subprogram is not a static function.
24
A static constant is a constant view declared by a full constant declaration or an object_renaming_declaration with a static nominal subtype, having a value defined by a static scalar expression or by a static string expression whose value has a length not exceeding the maximum length of a string_literal in the implementation. 
25
A static range is a range whose bounds are static expressions, or a range_attribute_reference that is equivalent to such a range. A static discrete_range is one that is a static range or is a subtype_indication that defines a static scalar subtype. The base range of a scalar type is a static range, unless the type is a descendant of a formal scalar type.
26/2
 A static subtype is either a static scalar subtype or a static string subtype. A static scalar subtype is an unconstrained scalar subtype whose type is not a descendant of a formal type, or a constrained scalar subtype formed by imposing a compatible static constraint on a static scalar subtype. A static string subtype is an unconstrained string subtype whose index subtype and component subtype are static, or a constrained string subtype formed by imposing a compatible static constraint on a static string subtype. In any case, the subtype of a generic formal object of mode in out, and the result subtype of a generic formal function, are not static. 
27
The different kinds of static constraint are defined as follows: 
28
29
30
31
31.1/2
   In any case, the constraint of the first subtype of a scalar formal type is neither static nor null.
32
A subtype is statically constrained if it is constrained, and its constraint is static. An object is statically constrained if its nominal subtype is statically constrained, or if it is a static string constant. 

Legality Rules

33
A static expression is evaluated at compile time except when it is part of the right operand of a static short-circuit control form whose value is determined by its left operand. This evaluation is performed exactly, without performing Overflow_Checks. For a static expression that is evaluated: 
34
35/2
36/2
37/2
 In addition to the places where Legality Rules normally apply (see 12.3), the above restrictions also apply in the private part of an instance of a generic unit.

Implementation Requirements

38/2
 For a real static expression that is not part of a larger static expression, and whose expected type is not a descendant of a formal type, the implementation shall round or truncate the value (according to the Machine_Rounds attribute of the expected type) to the nearest machine number of the expected type; if the value is exactly half-way between two machine numbers, the rounding performed is implementation-defined. If the expected type is a descendant of a formal type, or if the static expression appears in the body of an instance of a generic unit and the corresponding expression is nonstatic in the corresponding generic body, then no special rounding or truncating is required — normal accuracy rules apply (see Annex G). 

Implementation Advice

38.1/2
   For a real static expression that is not part of a larger static expression, and whose expected type is not a descendant of a formal type, the rounding should be the same as the default rounding for the target system. 
NOTES
39
27  An expression can be static even if it occurs in a context where staticness is not required. 
40
28  A static (or run-time) type_conversion from a real type to an integer type performs rounding. If the operand value is exactly half-way between two integers, the rounding is performed away from zero. 

Examples

41
Examples of static expressions: 
42
1 + 1       -- 2
abs(-10)*3  -- 30
43
Kilo : constant := 1000;
Mega : constant := Kilo*Kilo;   -- 1_000_000
Long : constant := Float'Digits*2;
44
Half_Pi    : constant := Pi/2;           -- see 3.3.2
Deg_To_Rad : constant := Half_Pi/90;
Rad_To_Deg : constant := 1.0/Deg_To_Rad; -- equivalent to 1.0/((3.14159_26536/2)/90)

Contents   Index   References   Search   Previous   Next 
Ada-Europe Sponsored by Ada-Europe