Ada Conformity Assessment Authority      Home Conformity Assessment   Test Suite ARGAda Standard
 
Ada Reference Manual (Ada 202x Draft 32)Legal 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.

Static Semantics

2
A static expression is a scalar or string expression that is one of the following:
3/5
a numeric_literal of a numeric type; 
4
a string_literal of a static string subtype; 
5/5
a name that denotes the declaration of a static constant;
5.1/5
a name that denotes a named number, and that is interpreted as a value of a numeric type;
6
a function_call whose function_name or function_prefix statically denotes a static function, and whose actual parameters, if any (whether given explicitly or by default), are all static expressions;
7
an attribute_reference that denotes a scalar value, and whose prefix denotes a static scalar subtype;
8/5
an attribute_reference whose prefix statically names a statically constrained array object or array subtype, and whose attribute_designator is First, Last, or Length, with an optional dimension;
8.1/5
an attribute_reference whose prefix denotes a non-generic entity that is not declared in a generic unit, and whose attribute_designator is Nonblocking;
9/5
a type_conversion whose subtype_mark denotes a static (scalar or string) subtype, and whose operand is a static expression;
10
a qualified_expression whose subtype_mark denotes a static (scalar or string) subtype, and whose operand is a static expression; 
11/4
a membership test whose tested_simple_expression is a static expression, and whose membership_choice_list consists only of membership_choices that are either static choice_simple_expressions, static ranges, or subtype_marks that denote a static (scalar or string) subtype; 
12
a short-circuit control form both of whose relations are static expressions;
12.1/3
a conditional_expression all of whose conditions, selecting_expressions, and dependent_expressions are static expressions;
12.2/5
a declare_expression whose body_expression is static and each of whose declarations, if any, is either the declaration of a static constant or is an object_renaming_declaration with an object_name that statically names the renamed object;
13
a static expression enclosed in parentheses. 
14
A name statically denotes an entity if it denotes the entity and: 
15
It is a direct_name, expanded name, or character_literal, and it denotes a declaration other than a renaming_declaration; or
16
It is an attribute_reference whose prefix statically denotes some entity; or
16.1/5
It is a target_name (see 5.2.1) in an assignment_statement whose variable_name statically denotes some entity; or
17
It denotes a renaming_declaration with a name that statically denotes the renamed entity. 
17.1/5
  A name statically names an object if it: 
17.2/5
statically denotes the declaration of an object (possibly through one or more renames); 
17.3/5
is a selected_component whose prefix statically names an object, there is no implicit dereference of the prefix, and the selector_name does not denote a component_declaration occurring within a variant_part; or 
17.4/5
is an indexed_component whose prefix statically names an object, there is no implicit dereference of the prefix, the object is statically constrained, and the index expressions of the object are static and have values that are within the range of the index constraint. 
17.5/5
  For an entity other than an object, a name statically names an entity if the name statically denotes the entity.
18
A static function is one of the following: 
19
a predefined operator whose parameter and result types are all scalar types none of which are descendants of formal scalar types;
19.1/5
a predefined relational operator whose parameters are of a string type that is not a descendant of a formal array type;
20/5
a predefined concatenation operator whose result type is a string type that is not a descendant of a formal array type;
20.1/5
a shifting or rotating function associated with a modular type declared in package Interfaces (see B.2);
21
an enumeration literal;
21.1/5
a static expression function (see 6.8);
22
a language-defined attribute that is a function, if the prefix denotes a static scalar subtype, and if the parameter and result types are scalar. 
23
In any case, a generic formal subprogram is not a static function.
24/5
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, and which satisfies any constraint or predicate that applies to the nominal subtype. 
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/3
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. Also, a subtype is not static if any Dynamic_Predicate specifications apply to it. 
27
The different kinds of static constraint are defined as follows: 
28
A null constraint is always static;
29
A scalar constraint is static if it has no range_constraint, or one with a static range;
30
An index constraint is static if each discrete_range is static, and each index subtype of the corresponding array type is static;
31
A discriminant constraint is static if each expression of the constraint is static, and the subtype of each discriminant is static. 
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

32.1/3
  An expression is statically unevaluated if it is part of:
32.2/3
the right operand of a static short-circuit control form whose value is determined by its left operand; or
32.3/3
a dependent_expression of an if_expression whose associated condition is static and equals False; or
32.4/3
a condition or dependent_expression of an if_expression where the condition corresponding to at least one preceding dependent_expression of the if_expression is static and equals True; or
32.5/3
a dependent_expression of a case_expression whose selecting_expression is static and whose value is not covered by the corresponding discrete_choice_list; or
32.6/4
a choice_simple_expression (or a simple_expression of a range that occurs as a membership_choice of a membership_choice_list) of a static membership test that is preceded in the enclosing membership_choice_list by another item whose individual membership test (see 4.5.2) statically yields True. 
33/3
A static expression is evaluated at compile time except when it is statically unevaluated. The compile-time evaluation of a static expression is performed exactly, without performing Overflow_Checks. For a static expression that is evaluated:
34/3
The expression is illegal if its evaluation fails a language-defined check other than Overflow_Check. For the purposes of this evaluation, the assertion policy is assumed to be Check.
35/2
If the expression is not part of a larger static expression and the expression is expected to be of a single specific type, then its value shall be within the base range of its expected type. Otherwise, the value may be arbitrarily large or small. 
36/2
If the expression is of type universal_real and its expected type is a decimal fixed point type, then its value shall be a multiple of the small of the decimal type. This restriction does not apply if the expected type is a descendant of a formal scalar type (or a corresponding actual type in an instance). 
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
29  An expression can be static even if it occurs in a context where staticness is not required. 
40
30  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 Ada 2005 and 2012 Editions sponsored in part by Ada-Europe