Control statements Simple statements Basic structured statements Sequence Selection Iteration The jump statement

Simple statements in imperative languages These are atomic (all or nothing) operations: assignment, the empty statement, a procedure call, exit, next, break, continue go to (jump). A block is also an all-or-nothing operation.

Structured statements Three fundamental mechanisms allow us to group simple statements into structured statements. sequence, or the compound statement: { S1 S2 } selection, or the conditional statement: if (C) S1 else S2 iteration, or the loop statement: while (C) S

Structured statements (2) All other control structures can be easily derived from the three basic mechanisms. if (C) S  if (C) S else {} do S while (C)  S while (C) S switch (i) { if (i == C1) S1 case C1: S1 …  else … and so on.

a :- b, c, d. This means evaluating b, then c, then d. Sequence (1) Languages Mechanisms Algol, Pascal, Ada, ... begin ... end C, Java, Perl { ... } Fortran IV nothing Prolog implicit a :- b, c, d. This means evaluating b, then c, then d. Scheme (begin ...)

single entry, single exit Sequence (2) A compound statement is treated as a simple statement. This is based on an important abstraction principle. The inner structure can be “abstracted away”. single entry, single exit

Selection if C then S1 else S2 end if The if-else construct is present in almost all programming languages (Prolog is the only major exception). Modula and Ada were the first to have properly bracketed if-then-else, with four keywords around three elements of the selection: if C then S1 else S2 end if Nested selection if-elsif-...-else was also introduced in Ada: if C1 then S1 elsif C2 then S2 ...... elsif Cn then Sn else Sn+1 end if

Special forms of selection in Fortran IV Computed GO TO. GO TO (label1, ..., labeln), expression Assigned GO TO. ASSIGN labeli TO variable GO TO variable(label1, ..., labeln)

Special forms of selection (2) The switch statement in C and Java has been probably inspired by computed GO TO. switch(expression){ case const1: S1; ... case constn: Sn; default: Sn+1;} After Si has been executed, control "falls through" to the subsequent case: Si+1 is executed next. Fall-through can be avoided by adding break statements.

Special forms of selection (3) Case statement in Pascal, Ada and other similar languages: each case is separate, there is no "fall-through". In Ada: case expression is when constantList1 => S1; ... when constantListn => Sn; when others => Sn+1; end case;

Special forms of selection (4) Selection in Prolog is driven by success and failure, not by the true-false opposition. Selection is implicit in backtracking: if you succeed, stop; if not, try another choice . union( [Elem | S1], S2, S1_S2 ) :- member( Elem, S2 ), union( S1, S2, S1_S2 ). union( [Elem | S1], S2, [Elem | S1_S2] ) :- \+ member( Elem, S2 ), union( S1, S2, S1_S2 ). union( [], S2, S2 ).

Graphical representation flowgraphs — flow diagrams — flowcharts if–then–else if–then Y N N Y C C S1 S2 S

Graphical representation (2) The abstraction principle: if ( C ) S1 else S2 is a simple statement. S2 C S1 Y N Single entry, single exit

Graphical representation (3) if–then–elsif-…elsif-then-else S2 S1 Y N C2 C1 S3 C3 Sn Cn … Sn+1

Graphical representation (4) case e of v1: S1; ... else Sn+1 end S2 S1 Y N e=v2 e=v1 S3 e=v3 Sn e=vn … Sn+1

Iteration Variations: pretest iteration or posttest iteration. while C do S Pascal repeat S until C while (C) S Java do S while (C) while C loop S end loop; Ada (no posttest iteration)

The bare loop statement must be stopped from inside the loop. Iteration (2) In Ada, the prefix while C is an extension of the basic iterative statement: loop S end loop; Another prefix: for i in range The bare loop statement must be stopped from inside the loop. Forced exit closes the nearest iteration: exit; unconditional exit when C;

The while prefix is an abbreviation. The construction Iteration (3) The while prefix is an abbreviation. The construction while C loop S end loop; is equivalent to loop exit when not C; S end loop;

Example: use of exit SUM := 0; loop get(X); exit when X = 0; SUM := SUM + X; end loop; Simpler, more intuitive SUM := 0; get(X); while X /= 0 loop SUM := SUM + X; end loop; Condition reversed, get(X) appears twice

Graphical representation while-do repeat-until repeat-until S Y N ¬C C Y N S C S Y N

Graphical representation (2) loop - exit - end loop S2 Y N S1 C

for loops For-loops ("counter-controlled") are historically earlier and less general than condition-controlled iterative structures. DO 1000 var = lo, hi Fortran IV ... 1000 CONTINUE DO label var = lo, hi, incr for var := expr do S Algol 60 for var := low step incr until high do S for var := expr while C do S Iterators can be combined: for i := 0, i+1 while i ≤ n do S(i)

for var in range Ada loop S end loop; for loops (2) for var in range Ada loop S end loop; for var in reverse range loop S end loop; for (e1; e2; e3) S C, Java, Perl (enough said J) What is this? for (;;) S

for loops 32) Iteration in Prolog and in Scheme is expressed by recursion. The same, of course, is possible in most other typical languages.

Jump (the goto statement) Unconstrained transfer of control is the only mechanism available in low-level languages — but they are very general. One-branch selection and goto allow us to express all other control structures. The jump mechanism is dangerous, may hurt readability, and should be avoided — advanced control structures work well for all typical and for most less typical uses.

Jump (the goto statemen)t (2) Some languages restrict goto (do not allow jumping inside an iteration or selection) and make it hard to use. Ada makes labels visible from far away (so that your boss can see it!).: SUM := 0; loop get(X); if X = 0 then goto DONE; end if; SUM := SUM + X; end loop; <<DONE>> put(SUM); goto may leave “unfinished business” — active control structures that must be "folded" at once.