Ada Conformity Assessment Authority

Home

Conformity Assessment

Test Suite

ARG

Ada Standard

Ada Reference Manual (Ada 2022 with Amendment 1) — Legal Information

4.4 Expressions

1/3

An expression is a formula that defines the computation or retrieval of a value. In this Reference Manual, the term “expression” refers to a construct of the syntactic category expression or of any of the following categories: choice_expression, choice_relation, relation, simple_expression, term, factor, primary, conditional_expression, quantified_expression.

Syntax

expression ::=
     relation {and relation}  | relation {and then relation}
   | relation {or relation}  | relation {or else relation}
   | relation {xor relation}

2.1/3

choice_expression ::=
     choice_relation {and choice_relation}
   | choice_relation {or choice_relation}
   | choice_relation {xor choice_relation}
   | choice_relation {and then choice_relation}
   | choice_relation {or else choice_relation}

2.2/3

choice_relation ::=
simple_expression [relational_operator simple_expression]

3/4

relation ::=
     simple_expression [relational_operator simple_expression]
   | tested_simple_expression [not] in membership_choice_list
   | raise_expression

3.1/5

membership_choice_list ::= membership_choice {'|' membership_choice}

3.2/4

membership_choice ::= choice_simple_expression | range | subtype_mark

simple_expression ::=
[unary_adding_operator] term {binary_adding_operator term}

term ::= factor {multiplying_operator factor}

factor ::= primary [** primary] | abs primary | not primary

7/5

Name Resolution Rules

A name used as a primary shall resolve to denote an object or a value.

8.1/6

A primary that is an expression surrounded by ( and ) is known as a parenthesized expression; the expression of a parenthesized expression is the operand of the parenthesized expression. If a parenthesized expression is expected to be of type T, the expected type of the operand is T. Similarly, if the parenthesized expression is expected to be of some class of types, the operand of the parenthesized expression is expected to be of the same class of types.

Static Semantics

Each expression has a type; it specifies the computation or retrieval of a value of that type.

9.1/6

This paragraph was deleted.

9.2/5

Every name or expression consists of one or more operative constituent names or expressions, only one of which is evaluated as part of evaluating the name or expression (the evaluated operative constituent). The operative constituents are determined as follows, according to the form of the expression (or name):

9.3/5

if the expression is a conditional_expression, the operative constituents of its dependent_expressions;

9.4/5

if the expression (or name) is a parenthesized expression, a qualified_expression, or a view conversion, the operative constituent(s) of its operand;

9.5/5

if the expression is a declare_expression, the operative constituent(s) of its body_expression;

9.6/5

otherwise, the expression (or name) itself.

9.7/5

In certain contexts, we specify that an operative constituent shall (or shall not) be newly constructed. This means the operative constituent shall (or shall not) be an aggregate or a function_call; in either case, a raise_expression is permitted.

9.8/6

An iterative context is a context for an expression that can be evaluated multiple times, and includes the following:

9.9/6

the predicate of a quantified_expression;

9.10/6

the expression or <> of an array_component_association;

9.11/6

the expression or <> of a container_element_association;

9.12/6

the key_expression or expression of an iterated_element_association.

Dynamic Semantics

The value of a primary that is a name denoting an object is the value of the object.

10.1/5

An expression of a numeric universal type is evaluated as if it has type root_integer (for universal_integer) or root_real (otherwise) unless the context identifies a specific type (in which case that type is used).

10.2/6

The evaluation of a parenthesized expression evaluates the operand of the parenthesized expression, and yields the result of the operand evaluation.

Implementation Permissions

For the evaluation of a primary that is a name denoting an object of an unconstrained numeric subtype, if the value of the object is outside the base range of its type, the implementation may either raise Constraint_Error or return the value of the object.

Examples

Examples of primaries:

4.0                -- real literal
Pi                 -- named number
(1 .. 10 => 0)     -- array aggregate
Sum                -- variable
Integer'Last       -- attribute
Sine(X)            -- function call
Color'(Blue)       -- qualified expression
Real(M*N)          -- conversion
(Line_Count + 10)  -- parenthesized expression

Examples of expressions:

15/2

Volume                      -- primary
not Destroyed               -- factor
2*Line_Count                -- term
-4.0                        -- simple expression
-4.0 + A                    -- simple expression
B**2 - 4.0*A*C              -- simple expression
R*Sin(θ)*Cos(φ)             -- simple expression
Password(1 .. 3) = "Bwv"    -- relation
Count in Small_Int          -- relation
Count not in Small_Int      -- relation
Index = 0 or Item_Hit       -- expression
(Cold and Sunny) or Warm    -- expression (parentheses are required)
A**(B**C)                   -- expression (parentheses are required)

Ada 2005 and 2012 Editions sponsored in part by Ada-Europe