A formula that defines the computation of a value.
expression ::= relation { and relation }
| relation { or relation }
| relation { xor relation }
| relation [ nand relation ]
| relation [ nor relation ]
| relation { xnor relation }
relation ::= shift_expression [ relational_operator shift_expression ]
shift_expression ::= simple_expression [ shift_operator simple_expression ]
simple_expression ::= [ + | - ] term { adding_operator term }
term ::= factor { multiplying_operator factor }
factor ::= primary [ ** primary ]
| abs primary
| not primary
primary ::= name
| literal
| aggregate
| function_call
| qualified_expression
| type_conversion
| allocator
| ( expression )
qualified_expression ::= type_mark ' ( expression )
| type_mark ' aggregate
Expressions define the way in which values are computed. They consist of operands and operators. For example, the expression "1 + 2" adds two integer numbers. The numbers are operands and the plus sign is a pre-defined adding operator. Each operand has a value and a type and the type of expression depends on the types of operands and the operation. The order in which the operations are performed depends on the priorities assumed in the language (see operators for details).
If an expression is constructed using logical operators and, or, xor or xnor, it may contain a sequence of operations, but if operations nand or nor are used, an expression may contain only one operation of this type (Example 1). If more are needed, parentheses can be used.
The expression is evaluated from left to right preserving precedence of operations. If this precedence is to be changed, parentheses (introducing highest priority) can be applied (Example 2).
An expression may consist of one or more relations. A relation is created from operands in the form of a shift expression in which the operands are connected with each other by the relation operator. The shift expression is written by shifting simple expressions using the shift operators.
The simple expression consists of the sign operator with operands being the terms connected with each other by the adding operator.
The term consists of factors, which are connected with each other by the multiplication operation.
The factor may be so-called primary, possibly preceded by the abs or not operators or two primaries connected with an operator **.
The primary can be the name, literal, aggregate, function call, type conversion, allocator (see respective topics for details). Example 3 presents an example of a complex expression with several operators.
Example 1
variable A, B, C, D : bit;
-- operator nand appears only once:
C := A nand B ;
-- operators and, or can be used more than once in one expression:
A := '1' and B and
C or D;
-- multilevel nand operation modeled with parentheses:
A := (D nand B) nand C;
Two logical operations (nand and nor) may appear only once in an
expression, unless parentheses are used.
Example 2
A := '1' and (B and (C or D));
Without the parentheses, first the and logical operation of '1' and B
would be performed, then C would be and-ed to the result, and finally
D would be or-ed with the rest. With the parentheses, first C would
be or-ed with D, then and-ed with B and finally logical and would be
performed on the result of the operations and logical '1'.
Example 3
A1 := a * (abs b) + 10 <= 256;
Expression composed of several operands. A1 must be of type BOOLEAN
as the relation operator has higher precedence than arithmetic operations.
Operators are defined for particular types of operands and this must be reflected in each expression.
Different operators can be mixed in one expression as long as the operands are of correct (for each individual operator) type.