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

2. 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.

3. 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

4. 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.

5. 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 ...)

6. 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

7. 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 S elsif Cn then Sn else Sn+1 end if

8. 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)

9. 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.

10. 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;

11. 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 ).

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

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

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

15. 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

16. 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)

17. 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;

18. 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;

19. 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

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

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

22. 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)

23. 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

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

25. 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.

26. 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.