Introduction

On Monday, we continued our discussion of control flow in programming languages.
We looked at orthogonality of programming constructs and gave an example illustrating how assignment is reasonably orthogonally implemented in Algol.
We talked about assignment operators and multi-way assignment.
We looked at how ordering evaluation within expressions varies from language to language and sometimes even within context.
We talked about short circuit evaluation.
Finally, we concluded by talking about structured versus unstructured control flow.
We said that the use of goto's is an unstructured control flow
We begin today by looking at some structured programming techniques to avoid using gotos.

Multilevel Returns

Pascal, Algol 60, PL/I might allow code like:

function search(key : string) : string;
var rtn : string;
...
   (* nested procedure definition *)
   procedure search_file(fname : string); ...
   begin
   ...
   for ... (* iterate over lines *)
       ...
       if found(key, line) then begin
          rtn := line;
          goto 100;
       end;
       ...
   end;
...
begin (* search *)
   for ... (* iterate over files *)
      ...
      search_file(fname);
      ...
100: return rtn;
   end;

The idea is that if the desired key was found in search_file it could break out of the outer loop over files as well in one go.
Many modern languages (for example, PHP) support a break command that terminates the execution of the current loop or break some_level, to break out of some_level many nested loops that could be used in situations like if the inner loop was in the same procedure. Lisp has a notion of return-from that directly can handle this.
What's weird about the above is that the goto jumps out of an executing procedure to a label in a different scope. This entails unwinding the stack.

One way to do this in structured languages is to use exceptions like the following Ruby code:

def searchFile(fname, pattern) 
   file = File.open(fname) 
   file.each {|line|
      throw :found, line if line =~ /#{pattern}/
   }
end
match = catch :found do
   searchFile("f1", key) 
   searchFile("f2", key) 
   searchFile("f3", key)
   "not found\n"  #default value for catch,
end   #if control gets this far
print match

In-Class Exercise

Find out how multi-level breaks work in PHP.
Give a tiny concrete example.
Rust doesn't support multi-level breaks (does support break to labels). Recode your example in Rust, but avoid using labels.
Please post your solution to the Oct 27 In Class Exercise Thread.

Errors and Other Exceptions

Unwinding the stack like our goto example can be generalized by defining what are known as a continuation.
We might want to create such a generalization because sometimes it is useful to remember your current environment (scope), so that you can later "snap" back to it from a function call.
This is especially true when we are doing error or exception handling.
For example, in Java you might have a try block which has inside it for loops, while loops, functions call etc, deep inside this nesting an exception is generated. We would like some way to "snap" back to the catch block, remembering the scope just before doing the try block.
In C, this kind of exception handling can be done with the setjump/longjump functions found in setjmp.h.
The function int setjmp(jmp_buf env) saves the current environment in env (jmp_buf is an array type so changing its contents will be seen).
The function void longjmp(jmp_buf env, int value) restores the current environment to be that in env, and when a call to longjmp completes program execution continues as if the corresponding execution of setjmp had just completed with return value value.
A language which supports closures or allows returning functions from functions, like Scheme, typically has to store environments on the heap -- if enclosing scopes were stored on the stack we might not be sure when we could pop them off the stack, and this could block further execution.
A continuation is an abstract representation of the control state, much like what would be stored in a jmp_buf struct.
We next briefly look at continuations in Scheme (we will talk about Scheme in more detail later).

Continuations in Scheme

To set a single parameter procedure p to receive and manipulate an environment env to return to in Scheme (sorta like setjmp), you use the function call-with-continuation or call/cc (for short).
After invoking call/cc, the procedure p is run with the supplied env. When call/cc completes execution resumes.

Here is an example adapted from Wikipedia:

(define the-continuation #f)
 
(define (test)
  (let ((i 0))
    (call/cc (lambda (env) (set! the-continuation env)))
    (set! i (+ i 1))
    i))

> (test)
1
> (the-continuation)
2
> (the-continuation)
3

The idea in the above is when call/cc is called env refers to the environment of the let statement evaluated on the set! i and returning i. the-continuation gets the state of this env after the code to execute next has run , followed by the code to execute next (set! i , return i).
When we call, (the-continuation) we run on the-continuation's current value for i (which it will remember) and the code to execute next.

Sequencing

Sequencing in imperative languages is the principle means for controlling the order in which side effects (usually caused by assignment occur).
Typically, if one statement follows another in the programming text, then it will be executed before the second one is.
Groups of statements that are suppose to execute consecutively are often enclosed in begin...end or {}.
Such a delimited list of statements can then be used in any context as a single statement, and is called a compound statement.
A compound statement optionally preceded by a set of declarations is sometimes called a block.
Some languages like Algol say the returned value of a compound statement is the value of the last expression in the statement.

Selection

Starting with Algol 60, most imperative languages have a notion of if...then...else
If a language uses begin..end's (rather than {}) typically a variation on else if such as elseif is used to delimit the end of blocks so you don't too many end keywords:
```
if a == b then
   ...
elsif a == c then
   ...
elsif a == d then
   ...
else
   ...
end
```

Lisp and Scheme use the cond function to achieve the effect of if/then/else:

(cond
   ((= A B)
       (...)) ; what to do if A==B
   ((= A C)
       (...)) ; what to do if A==C
   ((= A D) ; what to do if A==D
      (...))
   (T ; what to do in all other cases
      (...))
)

cond is a little like match in Rust or a switch/case in C/Java.

Code Generation for if/then/else

If..then..else's are typically mapped to machine code using branch instructions.

For example:

if ((A > B) and (C > D)) or (E /= F) then 
   then_clause
else
   else_clause

might be implemented as (without shortcut evaluation):

   r1 := A
   r2 := B
   r1 := r1 > r2
   r2 := C
   r3 := D
   r2 := r2 > r3 
   r1 := r1 & r2 
   r2 := E
   r3 := F
   r2 := r2  /= r3
   r1 := r1 | r2
   if r1 = 0 goto L2
L1:then_clause 
   goto L3
L2:else_clause
   ...
L3:

If shortcut evaluation is being use this might instead become:

   r1 := A
   r2 := B
   if r1 <= r2 goto L4
   r1 := C
   r2 := D
   if r1 > r2 goto L1
L4:r1:=E 
   r2 := F
   if r1 = r2 goto L2 
L1:then_clause
   ...
   goto L3 
L2:else_clause
   ...
L3:

Code Generation for switch/case

You could imagine implementing switch/case statement by treating them as a series of if/then/else's.
Typically, this is not done because you can avoid using a sequence of branch statement by using table lookup.

For example,

switch (my_expr)
{
   case 1:
      //some code;
      break;
   case 2:
   case 7:
      //some code
      break;
   case 3:
   case 4:
   case 5:
      //some code
      break;
   default:
      // some code
}

could be implemented as:

T: &L1  -- controlling expression = 1
   &L2
   &L3
   &L3
   &L3
   &L5
   &L2
   &L5
   &L5
   &L4 -- controlling expression = 10
L6:r1:=... -- calculate controlling expression
   if r1 < 1 goto L5 -- L5 is the default case arm
   if r1 > 10 goto L5 -- subtract off lower bound
   r1 -:= 1
   r1 := T[r1]
   goto *r1
L7:

Iteration

Iteration and recursion are the two mechanisms that allow a computer to perform similar operations repeatedly.
In most languages, iteration takes the form of loops of which there are two main types:
1. An enumeration-controlled loop, where the loop is executed once for every value in a given finite set
2. A logically controlled loop, where the loop is executed until some Boolean condition changes value.

Enumeration-controlled loop

Fortran I was the first language to have enumeration-controlled loops. Its syntax looked like:
```
do i = 1, 10, 2
   ...
enddo
```
Many languages, for example C and Java, use for-loops as their mechanism for enumeration controlled loop. For example, the above in C might be written as:
```
for (i = 1; i <= 10; i +=2) {
   ...
}
```
Starting with Clu many languages also have a mechanism such as iterators for iterating over other kinds of data structures besides just sets.

Code Generation for for loops

A for loop like the previous slide but with first, step, last values, might be implemented in our pseudo-machine code as:

   r1 := first
   r2 := step
   r3 := last
   goto L2
L1: ... -- loop body
   r1 := r1 + r2
L2: if r1 ≤ r3 goto L1

Yet More Control Flow

Outline