slide 1

Dr. Mohammad El-RamlyFall 2010

Set 8.1 – Control Flow and Exceptions ISlides by John Mitchell and Vitaly Shmatikov

Cairo University Faculty of Computers and Information

CS317 Concepts of Programming Languages

Reading: “Concepts in Programming Languages”, Chapter 8.1 – 8.2

slide 2

Quote of the Day

“The primary duty of an exception handler is to get the error out of the lap of the programmer and into the surprised face of the user.” - Verity Stob

Topics Structured Programming

• Go to considered harmful Exceptions

• “structured” jumps that may return a value• dynamic scoping of exception handler

Continuations• Function representing the rest of the program• Generalized form of tail recursion

Discussion of functional programming• Relevant to Haskell, section 4.4 of text

8.1 Fortran Control Structure10 IF (X .GT. 0.000001) GO TO 2011 X = -X IF (X .LT. 0.000001) GO TO 5020 IF (X*Y .LT. 0.00001) GO TO 30 X = X-Y-Y30 X = X+Y ...50 CONTINUE X = A Y = B-A GO TO 11 …

•Similar structure may occur in assembly code

Historical Debate Dijkstra, Go To Statement Considered Harmful

• Letter to Editor, C ACM, March 1968• Link on CS242 web site

Knuth, Structured Prog. with go to Statements• You can use goto, but do so in structured way …

Continued discussion• Welch, “GOTO (Considered Harmful)n, n is Odd”

General questions• Do syntactic rules force good programming style?• Can they help?

Advance in Computer Science Standard constructs that structure jumps

if … then … else … endwhile … do … endfor … { … }case …

Modern style• Group code in logical blocks • Avoid explicit jumps except for function return• Cannot jump into middle of block or function

body

slide 7

8.2.1 Exceptions: Structured Exit Terminate part of computation

• Jump out of construct• Pass data as part of jump• Return to most recent site set up to handle exception• Unnecessary activation records may be deallocated

– May need to free heap space, other resources Two main language constructs

• Declaration to establish exception handler (exception catching)

• Statement or expression to raise or throw exception

Often used for unusual or exceptional condition, but not necessarily

slide 8

Why Exceptions? Exceptions became a widely accepted

language construct for a number of reasons.• Many languages do not otherwise have a clean

construct for aborting (jumping out) a function call.

• Exceptions also allow passing data as part of the jump.

• Exceptions provide a way for determining to where the jump goes.

Often used for unusual or exceptional condition, but not necessarily

slide 9

ML Exampleexception Determinant; (* declare exception name

*)fun invert (M) = (* function to invert matrix *) … if … then raise Determinant (* exit if Det=0 *) else … end;...invert (myMatrix) handle Determinant => … ;

Value for expression if determinant of myMatrix is 0

slide 10

C++ ExampleMatrix invert(Matrix m) {

if … throw Determinant;…

};

try { … invert(myMatrix); …}catch (Determinant) { …

// recover from error}

slide 11

C++ vs ML Exceptions C++ exceptions

• Can throw any type, but C++ father recommends:• Stroustrup: “I prefer to define types with no other purpose

than exception handling. This minimizes confusion about their purpose. In particular, I never use a built-in type, such as int, as an exception.” -- The C++ Programming Language, 3rd ed.

ML exceptions• Exceptions are a different kind of entity than types• Declare exceptions before useSimilar, but ML requires while C++ only recommends

slide 12

ML Exceptions Declaration: exception name of type

• Gives name of exception and type of data passed when this exception is raised

Raise: raise name parameters Handler: exp1 handle pattern => exp2

• Evaluate first expression• If exception that matches pattern is raised, then

evaluate second expression insteadGeneral form allows multiple patterns

slide 13

8.2.2 ML Exceptions exception Ovflw; exception Signal of int;

raise Ovflw; raise Signal (x + 4);

Which handler is used?

Note:• First call handles exception one way• Second call handles exception in a different way

• exception Ovflw;• fun reciprocal(x) = • if x<min then raise Ovflw else 1/x;• (reciprocal(x) handle Ovflw=>0) / (reciprocal(y) handle

Ovflw=>1);•try •try•catch •catch

•throw

A handler with pattern matching exception Signal of int; fun f(x) = if x = 0 then raise Signal (0)

else if x = 1 then raise Signal (1)else if x = 10 then raise Signal (x-8)else (x – 2) mod 4;

f(10) handle Signal (0) => 0| Signal (1) => 1| Signal (x) => x + 8;

8.2.3 C++ Exception try { // code that may throw an exception throw “Generating char * exception”}

catch (char * message) { // process the exception }

C++ uses types to differentiate between different types of exceptions.

C++ Exception throw “Hello World” // throws a char * throw 18 // throws int throw new String (“Hello”);

catch (char * message) {// process the char * exception

} catch (void *whatever) {// process all other pointer exceptions

}

slide 18

C++ vs ML Exceptions C++ exceptions

• Can throw any type• No need to declare exceptions beforehand• Uses type matching to determine the right handler• Not garbage collected. Some objects may become

inaccessible. ML exceptions

• Exceptions are a different kind of entity than types• Declare exceptions before use• Uses pattern matching to determine the right

handler • Inaccessible objects are deallocated.

8.2.4 Exception for Error Condition

- datatype 'a tree = Leaf of 'a | Node of ('a tree)*('a tree);

- exception No_Subtree;- fun lsub (Leaf x) = raise No_Subtree | lsub (Node (x,y)) = x;> val lsub = fn : ‘a tree -> ‘a tree

• This function raises an exception when there is no reasonable value to return

• We’ll look at typing later.

slide 20

Exceptions for Efficiency Function to multiply values of tree leaves

fun prod(Leaf x) = x| prod(Node(x,y)) = prod(x) * prod(y);

Optimize using exception fun prod(tree) = let exception Zero fun p(Leaf x) = if x=0 then (raise Zero) else x | p(Node (x,y)) = p(x) * p(y) in p(tree) handle Zero=>0 end;

slide 21

Dynamic Scoping of Handlersexception Ovflw;fun reciprocal(x) = if x<min then raise Ovflw else 1/x;(reciprocal(x) handle Ovflw=>0) / (reciprocal(y) handle

Ovflw=>1);– First call to reciprocal() handles exception one

way, second call handles it another way Dynamic scoping of handlers: in case of

exception, jump to most recently established handler on run-time stack

Dynamic scoping is not an accident• User knows how to handle error• Author of library function does not

slide 22

Scope of Exception Handlers

exception X;(let fun f(y) = raise X and g(h) = h(1) handle X => 2in g(f) handle X => 4end) handle X => 6;

scope

handler

Which handler is used?

slide 23

exception X;fun f(y) = raise Xfun g(h) = h(1) handle X => 2g(f) handle X => 4

Dynamic Scope of Handlers (1)

formal hhandler X 2

access link

formal y 1access link

g(f)

f(1)

fun f access link

access link fun g

Dynamic scope:find first X handler, going up the dynamic call chain leading to “raise X”

handler X 4access link

slide 24

Dynamic Scope of Handlers (2)exception X;(let fun f(y) = raise X and g(h) = h(1) handle X =>

2in g(f) handle X => 4end) handle X => 6;

handler X 6

formal hhandler X 2

access link

formal y 1access link

g(f)

f(1)

fun f access link

access link fun g

Dynamic scope: find first X handler, going up the dynamic call chain leading to “raise X”

handler X 4access link

slide 25

Scoping: Exceptions vs. Variablesexception X;(let fun f(y) = raise X and g(h) = h(1) handle X => 2in g(f) handle X => 4end) handle X => 6;

val x=6;(let fun f(y) = x and g(h) = let val x=2

in h(1) in let val x=4 in g(f) end);

slide 26

Static Scope of Declarationsval x=6;(let fun f(y) = x and g(h) = let val x=2 in h(1) in let val x=4 in g(f) end);

val x 6

formal hval x 2

access link

formal y 1access link

g(f)

f(1)

fun f access link

access link fun g

Static scope: find first x, following access links from the reference to X

val x 4access link

slide 27

8.2.5 Typing of Exceptions Typing of raise exn

• Definition of typing: expression e has type t if normal termination of e produces value of type t

• Raising an exception is not normal termination– Example: 1 + raise X

Typing of handle exception => value• Converts exception to normal termination• Need type agreement• Examples

– 1 + ((raise X) handle X => e) Type of e must be int (why?)– 1 + (e1 handle X => e2) Type of e1,e2 must be int

(why?)

slide 28

Exceptions and Resource Allocation

exception X;(let val x = ref [1,2,3] in let val y = ref [4,5,6] in … raise X endend); handle X => ...

Resources may be allocated between handler and raise• Memory, locks on

database, threads …

May be “garbage” after exception

General problem, no obvious

solution