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 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.
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 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.
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.
|
