Contents Index Search Previous Next

1

{*short-circuit control form*}
{*and then (short-circuit control
form)*} {*or else (short-circuit
control form)*} An expression
consisting of two relations connected
by **and then** or **or else** (a *short-circuit control form*)
shall resolve to be of some boolean type; {*expected
type (short-circuit control form relation)* [partial]} the
expected type for both relations
is that same boolean type.

1.a

2

{*logical
operator*} {*operator
(logical)*} {*and operator*}
{*operator (and)*} {*or
operator*} {*operator
(or)*} {*xor operator*}
{*operator (xor)*} The
following logical operators are predefined for every boolean type *T*,
for every modular type *T*, and for every one-dimensional array
type *T* whose component type is a boolean type: {*bit
string: See logical operators on boolean arrays*}

3

3.a

4

For boolean types, the predefined logical operators
**and**, **or**, and **xor** perform the conventional operations
of conjunction, inclusive disjunction, and exclusive disjunction, respectively.

5

For modular types, the predefined logical operators
are defined on a bit-by-bit basis, using the binary representation of
the value of the operands to yield a binary representation for the result,
where zero represents False and one represents True. If this result is
outside the base range of the type, a final subtraction by the modulus
is performed to bring the result into the base range of the type.

6

The logical operators on arrays are performed
on a component-by-component basis on matching components (as for equality
-- see 4.5.2), using the predefined logical
operator for the component type. The bounds of the resulting array are
those of the left operand.

7

{*evaluation (short-circuit
control form)* [partial]} The short-circuit
control forms **and then** and **or else** deliver the same result
as the corresponding predefined **and** and **or** operators for
boolean types, except that the left operand is always evaluated first,
and the right operand is not evaluated if the value of the left operand
determines the result.

8

{*Length_Check* [partial]}
{*check, language-defined (Length_Check)*}
For the logical operators on arrays, a check is made
that for each component of the left operand there is a matching component
of the right operand, and vice versa. {*Range_Check*
[partial]} {*check, language-defined
(Range_Check)*} Also, a check is made that
each component of the result belongs to the component subtype. {*Constraint_Error
(raised by failure of run-time check)*} The
exception Constraint_Error is raised if either of the above checks fails.

8.a

NOTES

9

12 The
conventional meaning of the logical operators is given by the following
truth table:

10

A B (A **and** B) (A **or** B) (A **xor** B)

True True True True False

True False False True True

False True False True True

False False False False False

True True True True False

True False False True True

False True False True True

False False False False False

11

12

Filter(1 .. 10)

13

14

N = 0