- The binary adding operators + (addition) and - (subtraction) are
predefined for every specific numeric type T with their conventional meaning.
They have the following specifications:
function "+"(Left, Right : T) return T
function "-"(Left, Right : T) return T
- The concatenation operators & are predefined for every nonlimited,
one-dimensional array type T with component type C. They have the following
function "&"(Left : T; Right : T) return T
function "&"(Left : T; Right : C) return T
function "&"(Left : C; Right : T) return T
function "&"(Left : C; Right : C) return T
- For the evaluation of a concatenation with result type T, if both
operands are of type T, the result of the concatenation is a one-dimensional
array whose length is the sum of the lengths of its operands, and whose
components comprise the components of the left operand followed by the
components of the right operand. If the left operand is a null array, the
result of the concatenation is the right operand. Otherwise, the lower bound
of the result is determined as follows:
- If the ultimate ancestor of the array type was defined by a
constrained_array_definition, then the lower bound of the result
is that of the index subtype;
- If the ultimate ancestor of the array type was defined by an
unconstrained_array_definition, then the lower bound of the
result is that of the left operand.
- The upper bound is determined by the lower bound and the length. A check
is made that the upper bound of the result of the concatenation belongs to
the range of the index subtype, unless the result is a null array.
Constraint_Error is raised if this check fails.
- If either operand is of the component type C, the result of the
concatenation is given by the above rules, using in place of such an operand
an array having this operand as its only component (converted to the
component subtype) and having the lower bound of the index subtype of the
array type as its lower bound.
- The result of a concatenation is defined in terms of an assignment to an
anonymous object, as for any function call (see 6.5).
(15) As for all predefined operators on modular types, the binary adding
operators + and - on modular types include a final reduction modulo the
modulus if the result is outside the base range of the type.
- Examples of expressions involving binary adding operators:
Z + 0.1 -- Z has to be of a real type
"A" & "BCD" -- concatenation of two string literals
'A' & "BCD" -- concatenation of a character literal and a string literal
'A' & 'A' -- concatenation of two character literals
-- Email comments, additions, corrections, gripes, kudos, etc. to:
Magnus Kempe -- Magnus.Kempe@di.epfl.ch
Page last generated: 95-03-12