Expression
Formal Definition
A formula that defines the
computation of a value.
Syntax:
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
Description
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 predefined 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 socalled 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.
Examples
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 anded to the result, and finally
D would be ored with the rest. With the parentheses, first C would
be ored with D, then anded 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.
Important Notes

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.
