Control Structures

• Any mechanism that departs from straight-line execution:

– Selection: if-statements

– Multiway-selection: case statements

– Unbounded iteration: while-loops

– Definite iteration: for-loops

– Iterations over collections

– transfer of control: gotos

– unbounded transfer of control: exceptions, backtracking

Selection

• if Condition then Statement -- Pascal, Ada• if (Condition) Statement -- C, C++ Java• All you need for a universal machine: increment, decrement, branch on

zero. All the rest is programmer convenience!• To avoid ambiguities, use end marker: end if, “}” • To deal with alternatives, use keyword or bracketing:

if Condition then if (Condition) {

Statements Statements }

elsif Condition then else if (Condition) {

Statements Statements}

else else {

Statements Statements}

end if;

Nesting

if Condition then if (Condition)

if Condition then if (Condition) {

Statements Statements

end if; }

else else {

Statements Statements

end if; }

Statement Grouping

• Pascal introduces begin-end pair to mark sequence• C/C++/Java abbreviate keywords to { }• Ada dispenses with brackets for sequences, because keywords

for the enclosing control structure are sufficient:

• for J in 1 .. N loop … end loop;– More writing => more readable

• The use of grouping in C a reminder that it is an expression language

• The use of grouping in C++/Java is just syntactic tradition• Another possibility (ABC, Python): make indentation significant

Short-Circuit Evaluation

• If x is more than five times greater than y, compute z:• if x / y > 5 then z := … -- but what if y is 0?

• If y /= 0 and x/ y > 5then z := … -- but operators evaluate their arguments

• Solutions:– a lazy evaluation rule for logical operators (LISP, C, etc)

– a control structure with a different syntax

• C1 && C2 does not evaluate C2 if C1 is false • if C1 and then C2 then ditto• C1 || C2 does not evaluate C2 if C1 is true• if C1 or else C2 then ditto

Multiway selection

• The case statement is the most useful control structure because most programs are interpreters.

• Can be simulated with a sequence of if-statements, but logic• become obscured.

case Next_Char is

when ‘I’ => Val := 1;

when ‘V’ => Val := 5;

when ‘X’ => Val := 10;

when ‘C’ => Val := 100;

when ‘D’ => Val := 500;

when ‘M’ => Val := 1000;

when others => raise Illegal_Numeral;

end case;

The well-structured case statement

• Type of expression must be discrete: an enumerable set of values (floating-point numbers not acceptable)

• each choice is independent of the others (no flow-through)• There are no duplicate choices• All possible choices are covered• There is mechanism to specify a default outcome for choices

not given explicitly.

Implementation

• Finite set of possibilities: can build a table of addresses, and• convert expression into table index:

– compute value

– transform into index

– retrieve address of corresponding code fragment

– branch to code fragment and execute

– branch to end of case statement

• All cases have the same execution cost• All choices must be static: computable at compile-time

Complications

case (X + 1) is -- any integer value (discrete but large)

when integer’first .. 0 => Put_Line (“negative”);

when 1 => Put_Line (“unit”);

when 3 | 5 | 7 | 11 => Put_Line (“smal prime”);

when 2 | 4 | 6 | 8 | 10 => Put_Line (“small even”);

when 21 => Put_Line (“the house wins”);

when 12 .. 20 | 22 .. 99 => Put_Line (“manageable”);

when others => Put_Line (“Irrelevant”);

end case;• Implementation must be combination of tables and if-statements.

Unstructured flow (Duff’s device)

void send (int* to, int* from, int count) {int n = (count + 7 ) / 8;switch (count % 8) {

case 0 : do { *to++ = *from++;case 7 : *to++ = *from++;case 6 : *to++ = *from++;case 5 : *to++ = *from++;case 4 : *to++ = *from++;case 3 : *to++ = *from++;case 2 : *to++ = *from++;case 1 : *to++ = *from++; } while (--n >0); }}

What does this do? Why bother?

Indefinite loops

• All loops can be expressed as while-loops• Condition is evaluated at each iteration• If condition is initially false, loop is never executed

while Condition loop .. end loop;

• equivalent to

if Condition then

while Condition loop … end loop;

end if;

• (provided Condition has no side-effects…)

What if we want to execute at least once?

• Pascal introduces until-loop.• C/C++ use different syntax with while:

while (Condition) { … }

do { … } while (Condition)

• While form is most common• Can always simulate with a boolean variable:

first := True;

while (Condition or else first) loop

…

first := False;

end loop;

Breaking out

• More common is the need for an indefinite loop that terminates in the middle of an iteration.

• C/C++/Java: break• Ada : exit statement

loop -- infinite loop

compute_first_part;

exit when got_it;

compute_some_more;

end loop;

Multiple exits

• Within nested loops, useful to specify exit from several of them• Ada solution: give names to loops• Otherwise: use a counter (Modula) or use a goto.

• Outer: while C1 loop ...• Inner: while C2 loop...• Innermost: while C3 loop...• exit Outer when Major_Failure;• exit Inner when Small_Annoyance;• ...• end loop Innermost;• end loop Inner;• end loop Outer;

Definite loops

• Counting loops are iterators over discrete domains:• for J in 1..10 loop …• for (int I = 0; I < N; I++ ) ..• Design issues:

– Evaluation of bounds (only once, ever since Algol60)

– Scope of loop variable

– Empty loops

– Increments other than one

– Backwards iteration

– non-numeric domains

Evaluation of bounds

for J in 1 .. N loop

…

N := N + 1;

end loop; -- terminates?

• In Ada, bounds are evaluated once before iteration starts. The above always terminates (and is abominable style).

• The C/C++/Java loop has hybrid semantics: for (int J = 0; J < last; J++) { … last++; -- does not terminate! }

The loop variable

• Best if local to loop and treated as constant• Avoids issue of value at termination, and value on abrupt exit

• counter : integer := 17; -- outer declaration• ...• for counter in 1 ..10 loop• do_something; -- 1 <= counter <= 10• end loop;• …• -- counter is still 17

Different increments

• The universal Algol60 form:• for J from Exp1 to Exp2 by Exp3 do…• Too rich for most cases. Exp3 is most often +1, -1.• What is meaning if Exp1 > Exp2 and Exp3 < 0 ?• In C/ C++

for (int J = Exp1; J <= Exp2; J = J + Exp3) …

• In Ada:

for J in 1 .. N loop -- increment is +1

for J in reverse 1 .. N loop -- increment is -1

• Everything else can be programmed with while-loop

Non-numeric domains

• Ada form generalizes to discrete types:

• for M in months loop …

• Basic pattern on other data-types:• define primitive operations: first, next, more_elements:

Iterator = Collection.Iterate(); // build an iterator over a collection of elements

element thing = iterator.first; // define loop variable

while (iterator.more_elements ()) {

...

thing = iterator.next (); // value is each successive element

}

How do we know it’s right?

• Pre-Conditions and Post-conditions:• {P} S {Q} means:• if Proposition P holds before executing S,• and the execution of S terminates,• then proposition Q holds afterwards.• Need to formulate pre- and post-conditions for all statement

forms, and syntax-directed rules of inference.

{P and C} S {P}

(P and C} while C do S end loop; {P and not C}

i.e. on exit from a while-loop we know the condition is false.

Efficient exponentiation

function Exp (Base : Integer; Expon : Integer) return integer is

N : Integer := Expon; -- to pick up successive bits of exponent

Res : Integer := 1; -- running result

Pow : Integer := Base; -- successive powers: Base ** (2 ** I)

begin

while N > 0 loop

if N mod 2 = 1 then

Res := Res * Pow;

end if;

Pow := Pow * Pow;

N := N / 2;

end loop;

return Res;

end Exp;

Adding invariants

function Exp (Base : Integer; Expon : Integer) return integer is

… declarations

… {i = 0} to count iterations

begin

while N > 0 loop

{i := i + 1}

if N mod 2 = 1 then { N mod 2 is ith bit of Expon from left}

Res := Res * Pow; { Res := Base ** (Expon mod 2 ** i}

end if;

Pow := Pow * Pow; { Pow := Base ** (2 ** i)}

N := N / 2; { N := Expon / ( 2 ** i) }

end loop;

return Res; {i = log Expon; N = 0; Res = Base ** Expon}

end Exp;