Contents Index Search Previous Next

# 4.5.1 Logical Operators and Short-circuit Control Forms

#### Name Resolution Rules

1

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;

the
expected type for both

relations
is that same boolean type.

#### Static Semantics

2

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:

3

**function** "**and**"(Left, Right : *T*) **return** *T*

**function** "**or**" (Left, Right : *T*) **return** *T*

**function** "**xor**"(Left, Right : *T*) **return** *T*

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.

#### Dynamic Semantics

7

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

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.

Also, a check
is made that each component of the result belongs to the component subtype.

The exception Constraint_Error is raised if either
of the above checks fails.

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

#### Examples

11

*Examples of
logical operators:*

12

`Sunny `**or** Warm

Filter(1 .. 10) **and** Filter(15 .. 24) *-- see 3.6.1 *
13

*Examples of short-circuit
control forms:*

14

`Next_Car.Owner /= `**null** **and** **then** Next_Car.Owner.Age > 25 *-- see 3.10.1*

N = 0 **or** **else** A(N) = Hit_Value

Contents Index Search Previous Next Legal