CS 476 – Programming Language Design

1. CS 476 – Programming Language Design William Mansky

3. HW3 #3: Building a Proof Tree

4. HW3 #4: Writing Proof Rules

5. Adding Functions • With variables, assignment, declarations, and control flow, we have a simple imperative language • But every imperative language in use has at least one more feature: functions

7. Adding Functions • Main goal: code reuse • Requires: • Definitions and calls • Arguments and local state • Argument and return types • Ability to call a function from inside a function (even recursively!)

8. Functions: Syntax of Definitions E ::= … T ::= int | bool D ::= T <ident> | D; D F ::= T <ident>(T <ident>, …, T <ident>){ ?} P ::= D; C C ::= …

9. Functions: Syntax of Definitions E ::= … T ::= int | bool D ::= T <ident> | D; D F ::= T <ident>(T <ident>, …, T <ident>){ D; C }| F; F P ::= D; F; C C ::= …

10. Functions: Syntax of Definitions E ::= … T ::= int | bool D ::= T <ident> | D; D F ::= T <ident>(T <ident>, …, T <ident>){ D; C; return E } | F; F P ::= D; F; C C ::= …

11. Functions: Syntax of Calls E ::= … T ::= int | bool D ::= T <ident> | D; D F ::= T <ident>(T <ident>, …, T <ident>){ D; C } | F; F P ::= D; F; C C ::= … | return E

12. Functions: Syntax of Calls E ::= … | <ident>(E, …, E) T ::= int | bool D ::= T <ident> | D; D F ::= T <ident>(T <ident>, …, T <ident>){ D; C } | F; F P ::= D; F; C C ::= … | return E

13. Functions: Syntax of Calls E ::= … T ::= int | bool D ::= T <ident> | D; D F ::= T <ident>(T <ident>, …, T <ident>){ D; C } | F; F P ::= D; F; C C ::= … | return E | <ident> := <ident>(E, …, E)

16. Functions: Types • is a declared function • Each of has the right type • The return type of matches the type of • We can store this information in

17. Functions: Types int f(int x, int y){ return x + y } f is a function with return type int, and arguments int x and int y • We can store this information in

18. Functions: Types • is a declared function • Each of has the right type • The return type of matches the type of

19. Processing Function Declarations int f(int x, int y){ return x + y } function declaration new context old context

20. Processing Function Declarations int f(int x, int y){ return x + y } • The function’s parameters should be available in the function body

21. Processing Function Declarations int f(int x, int y){ return x + y } • The function’s parameters should be available in the function body • And so should the previously declared functions • (Mutually recursive functions would require an extra step)

22. Processing Function Declarations int f(int x, int y){ return x + y } • The function’s parameters should be available in the function body • And so should the previously declared functions • We can use a fake variable to type any return commands

23. Processing Function Declarations

25. Functions: Semantics of Declarations

26. Functions: Syntax of Calls E ::= … T ::= int | bool D ::= T <ident> | D; D F ::= T <ident>(T <ident>, …, T <ident>){ D; C } | F; F P ::= D; F; C C ::= … | return E | <ident> := <ident>(E, …, E)

27. Functions: Types • is a declared function • Each of has the right type • The return type of matches the type of

28. Functions: Semantics of Declarations

30. Functions: Semantics of Calls • Evaluate the arguments • Look up in • Execute the body of and produce a return value • Assign the return value to

31. Functions: Semantics of Calls • Evaluate the arguments • Look up in • Execute the body of and produce a return value • Assign the return value to

32. Functions: Semantics of Calls

33. Functions: Semantics of Calls • Evaluate the arguments • Look up in • Execute the body of and produce a return value • Assign the return value to

34. Functions: Semantics of Calls • Evaluate the arguments • Look up in • Execute the body of and produce a return value • Assign the return value to

35. Functions: Semantics of Calls • Evaluate the arguments • Look up in • Execute the body of and produce a return value • Assign the return value to

36. Functions: Semantics of Calls • Small-step relation is now , where is a stack of states

37. Functions: Semantics of Calls • Small-step relation is now , where is a stack of states

38. Functions: Semantics of Calls • Small-step relation is now , where is a stack of states

39. Functions: Semantics of Calls where ,

40. Functions: What Does This Mean? • Big-step and small-step describe the same behavior • Small-step semantics now need a whole extra piece of state • And that state corresponds to a feature of real language implementations!

41. Functions: Interpreter vs. Compiled let rec eval_cmd e s = match e with | Call (x, f, es) ->

42. Functions: Interpreter vs. Compiled let rec eval_cmd e s = match e with | Call (x, f, es) -> match eval_exps es s with Some vs -> match s f with Some (xs, c) -> match eval_cmd c (merge (funs s) (make_statexs vs)) with | Some (Ret v) -> Some (State (update s x v))

43. Functions: Interpreter vs. Compiled let rec eval_cmd e s = match e with | Call (x, f, es) -> match eval_exps es s with Some vs -> match s f with Some (xs, c) -> match eval_cmd c (merge (funs s) (make_statexs vs)) with | Some (Ret v) -> Some (State (update s x v)) push stackframe f: store args <compiled code for c> store ret addr pop stackframe jmp f jmp ret addr

45. Imperative Languages • Arithmetic and boolean expressions • Variables and assignment • Control flow (conditionals, loops) • Variable declarations • Exceptions and exception handling • Function declarations and calls • There’s more, but we’ve covered the essentials! • Next up: object-oriented languages