1. Programming Languages (CS 550) Mini Language Semantics
September 4, 1997
Programming Languages (CS 550) Mini Language Semantics
Jeremy R. Johnson

2. September 4, 1997
Theme
Operational semantics: define language by describing its actions in terms of operations of an actual or hypothetical machine.
Scheme interpreter
Quick prototype – no parser needed
Relies on semantics of scheme
Prolog interpreter
Reduction machine
Reduction rules (logical inference rules)

3. September 4, 1997
Theme
Denotational semantics: Use functions to describe semantics of a programming language.
Associate semantic value to syntactically correct construct
Map syntactic domain to semantic domain
scheme implementation

4. September 4, 1997
Mini Language Syntax
1. < program > → < stmt-list>
2. < stmt-list> → < stmt > ; < stmt-list > | < stmt >
3. < stmt > → < assign-stmt > | < if-stmt > | < while-stmt >
4. < assign-stmt > → < identifier > := < expr >
5. < if-stmt > → if < expr > then < stmt-list > else < stmt-list > fi
6. < while-stmt > → while < expr > do < stmt-list > od
7. < expr > → < expr > + < term > | < expr > - < term > | < term >
8. < term > → < term > * < factor > | < factor >
9. < factor > → ( < expr > ) | < number > | < identifier >
10. < number > → < number > < digit > | < digit >
11. < digit > → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
12. < identifier > → < identifier > < letter > | < letter >
13. < letter > → a | b | c | ... | z

5. Operational Semantics
September 4, 1997
Operational Semantics
The meaning of a program is obtained by interpreting the result of each statement in some model of computation.
The meaning of a statement and a program (sequence of statements) is determined by its affect on the environment
Implementation in scheme
Implementation in prolog

6. September 4, 1997
Environments
Let an Environment be a map from indentifiers to values = integers  undefined
Mini language programs can be thought of as a map from an initial Environment to a final Environment (assuming it terminates)
The initial environment maps all identifiers to an undefined
Each statement is defined in terms of what it does to the current environment (another mapping)

7. Semantics of Mini Language Statements
September 4, 1997
Semantics of Mini Language Statements
1. Env: Identifier → Integer Union {undef}
2. (Env and {I = n})(J) = n if J=I, Env(J) otherwise
3. Env_0 = undef for all I
4. for if-stmt, if expr evaluates to value greater than 0, then evaluate stmt-list after then, else evaluate stmt-list after else
5. for while-stmt, as long as expr evaluates to a value greater than 0, stmt-list is repeatedly executed and expr evaluated.

8. Example Mini Language Program
September 4, 1997
Example Mini Language Program
1. n := 0 - 5;
2. if n then i := n else i := 0 - n fi;
3. fact := 1;
4. while i do fact := fact * i; i := i - 1 od
What is the final environment?

9. Operational Semantics
September 4, 1997
Operational Semantics
Define language by describing its actions in terms of operations of an actual or hypothetical machine.
Need precise description of machine
Program  Control  Store
Scheme evaluator
Rely on semantics of scheme
Parsing not required (program is abstract syntax tree)

10. Syntax in Scheme prog -> stmt-list stmt-list -> (stmt-seq)
stmt-seq -> stmt | stmt stmt-seq
stmt -> assign-stmt | if-stmt | while-stmt
assign-stmt -> (assign identifier expr)
if-stmt -> (if expr stmt-list stmt-list)
while-stmt -> (while expr stmt-list)
expr -> integer | identifier | (+ expr expr) | (- expr expr) | (* expr expr)

11. Example Input ((assign n (- 0 5))
(if n (assign i n) (assign i (- 0 n)))
(assign fact 1)
(while i ((assign fact (* fact i))
(assign i (- i 1)))))

12. Scheme Evaluator
(define (eval prog env) (if (stmtlist? prog) (eval-stmtlist prog env) (error "illegal program"))) (define (eval-stmtlist stmtlist env) (if (null? stmtlist) env (eval-stmtlist (cdr stmtlist) (eval-stmt (car stmtlist) env)))) (define (eval-stmt stmt env) (cond ((assign-stmt? stmt) (eval-assign stmt env)) ((if-stmt? stmt) (eval-if stmt env)) ((while-stmt? stmt) (eval-while stmt env)) )

13. Scheme Evaluator ; write eval-expr, insert-binding,
(define (eval-assign stmt env)
(let ((var (cadr stmt)) (expr (caddr stmt)))
(insert-binding var (eval-expr expr env) env)))
(define (eval-if stmt env)
(let ((expr (cadr stmt)) (S1 (caddr stmt)) (S2 (cadddr stmt)))
(if (> (eval-expr expr env) 0)
(eval-stmtlist S1 env)
(eval-stmtlist S2 env))))
(define (eval-while stmt env)
… ; fill in details )
; write eval-expr, insert-binding,

14. Evaluating Example (define env ()) (define prog '((assign n (- 0 5))
(if n ((assign i n)) ((assign i (- 0 n))))
(assign fact 1)
(while i ((assign fact (* fact i))
(assign i (- i 1))))))
(eval prog env) => ((fact 120) (i 0) (n -5))

15. Operational Semantics
September 4, 1997
Operational Semantics
Define language by describing its actions in terms of operations of an actual or hypothetical machine.
Need precise description of machine
Program  Control  Store
Reduction machine
Reduce program to a semantic “value”
Reduction rules (logical inference rules)

16. Operational Semantics of Mini Language Expressions
September 4, 1997
Operational Semantics of Mini Language Expressions
(1) ‘0’  0,…, ‘9’  9
(2) V’0’  10*V,…,V’9’  10*V+9
(3) V1 ‘+’ V2  V1 + V2
(4) V1 ‘+’ V2  V1 + V2
(5) V1 ‘*’ V2  V1 * V2

17. Mini Language Expressions
September 4, 1997
Mini Language Expressions
(7) E  E1
_____________________________________________________________________
E ‘+’ E2  E1 ‘+’ E2
(8) E  E1
E ‘-’ E2  E1 ‘-’ E2
(9) E  E _____________________________________________________________________
E ‘*’ E2  E1 ‘*’ E2

18. Mini Language Expressions
September 4, 1997
Mini Language Expressions
(10) E  E1
_____________________________________________________________________
V ‘+’ E  V ‘+’ E1
(11) E  E1
____________________________________________________________________
V ‘-’ E  V ‘-’ E1
(12) E  E1
V ‘*’ E  V ‘*’ E1
(14) E  E1, E1  E2 [transitive closure]
E  E2

19. Implementation in Prolog
September 4, 1997
Implementation in Prolog
% reduce_all(times(plus(2,3),minus(5,1)),V).
% V = 20 ?
reduce(plus(E,E2),plus(E1,E2)) :- reduce(E,E1).
reduce(minus(E,E2),minus(E1,E2)) :- reduce(E,E1).
reduce(times(E,E2),times(E1,E2)) :- reduce(E,E1).
reduce(plus(V,E),plus(V,E1)) :- reduce(E,E1).
reduce(minus(V,E),minus(V,E1)) :- reduce(E,E1).
reduce(times(V,E),times(V,E1)) :- reduce(E,E1).
reduce(plus(V1,V2),R) :- integer(V1), integer(V2), !, R is V1+V2.
reduce(minus(V1,V2),R) :- integer(V1), integer(V2), !, R is V1-V2.
reduce(times(V1,V2),R) :- integer(V1), integer(V2), !, R is V1*V2.
reduce_all(V,V) :- integer(V), !.
reduce_all(E,E2) :- reduce(E,E1), reduce_all(E1,E2).

20. Environments and Assignment
September 4, 1997
Environments and Assignment
(7) <E | Env>  <E1| Env>
______________________________________________________________________________________________________________________________
<E ‘+’ E2 | Env>  < E1 ‘+’ E2 | Env>
Env(I) = V
____________________________________________________________________________
<I | Env>  <V | Env>

21. Environments and Assignment
September 4, 1997
Environments and Assignment
(16) <I ‘:=’ V | Env>  Env & {I = V}
(17) <E | Env>  <E1 | Env>
______________________________________________________________________________________________________________________
<I ‘:=’ E | Env>  <I ‘:=’ E1 | Env>
<S | Env>  Env1
______________________________________________________________________________________________
<S ‘;’ L | Env>  <L | Env1>
(19) L  < L | Env0>

22. Implementation in Prolog
September 4, 1997
Implementation in Prolog
Configurations
<E | Env> Config(E,Env)
Environments
[value(I1,v1),...,value(In,vn)]
Predicate to lookup values
Lookup(Env,I,V)

23. Implementation in Prolog
September 4, 1997
Implementation in Prolog
Configurations
<E | Env> Config(E,Env)
Environments
[value(I1,v1),...,value(In,vn)]
Predicate to lookup values
Lookup(Env,I,V)
lookup([value(I,V)|_],I,V).
lookup([_|Es],I,V) :- lookup(Es,I,V), !.

24. Implementation in Prolog
September 4, 1997
Implementation in Prolog
% reduce_value(config(times(plus(x,3),minus(5,y)),[value(x,2),value(y,1)]),V).
% V = config(20,[value(x,2),value(y,1)]) ?
reduce(config(plus(E,E2),Env),config(plus(E1,E2),Env)) :-
reduce(config(E,Env),config(E1,Env)).
reduce(config(I,Env),config(V,Env)) :- atom(I), lookup(Env,I,V).
reduce_all(config(V,Env),config(V,Env)) :- integer(V), !.
reduce_all(config(E,Env),config(E2,Env)) :-
reduce(config(E,Env),config(E1,Env)), reduce_all(config(E1,Env),config(E2,Env)).
reduce_value(config(E,Env),V) :- reduce_all(config(E,Env),config(V,Env)).

25. If Statements (20) <E | Env>  <E1| Env>
September 4, 1997
If Statements
(20) <E | Env>  <E1| Env>
__________________________________________________________________________________________________________________________________
<‘if’ E ‘then’ L1 ‘else’ L2 ‘fi’ | Env>  <‘if’ E1 ‘then’ L1 ‘else’ L2 ‘fi’ | Env>
(21) V > 0
______________________________________________________________________________________________________________________________
<‘if’ V ‘then’ L1 ‘else’ L2 ‘fi’ | Env>  < L1|Env>
(22) V  _____________________________________________________________________
<‘if’ V ‘then’ L1 ‘else’ L2 ‘fi’ | Env>  < L2|Env>

26. While Statements (23) <E | Env>  <V| Env>, V  0
September 4, 1997
While Statements
(23) <E | Env>  <V| Env>, V  0
________________________________________________________________________________________________________________
<‘while’ E ‘do’ L ‘od’|Env>  Env
<E | Env>  <V| Env>, V > 0
_____________________________________________________________________________________________________________
<‘while’ E ‘do’ L ‘od’|Env>  <L;‘while’ E ‘do’ L ‘od’|Env> 

27. Implementation in Prolog
September 4, 1997
Implementation in Prolog
% Test cases:
% reduce_exp_all(config(plus(times(2,5),minus(2,5)),[]),V).
% V = config(7,[])
% reduce_exp_all(config(plus(times(x,5),minus(2,y)),[value(x,2),value(y,5)]),V).
% V = config(7,[value(x,2),value(y,5)])
% reduce_all(config(seq(assign(x,3),assign(y,4)),[]),Env).
% Env = [value(x,3),value(y,4)]
% reduce(config(if(3,assign(x,3),assign(x,4)),[]),Env).
% Env = [value(x,3)]
% reduce(config(if(0,assign(x,3),assign(x,4)),[]),Env).
% Env = [value(x,4)]
% reduce_all(config(if(n,assign(i,0),assign(i,1)),[value(n,3)]),Env).
% Env = [value(n,3),value(i,0)]

28. Implementation in Prolog
September 4, 1997
Implementation in Prolog
% reduce_all(config(while(x,assign(x,minus(x,1))),[value(x,3)]),Env).
% Env = [value(x,0)]
% reduce_all(config(
% seq(assign(n,minus(0,3)),
% seq(if(n,assign(i,n),assign(i,minus(0,n))),
% seq(assign(fact,1),
% while(i,seq(assign(fact,times(fact,i)),assign(i,minus(i,1)))))))
% ,[]),Env).
% Env = [value(n,-3),value(i,0),value(fact,6)]

29. Denotational Semantics
September 4, 1997
Denotational Semantics
Use functions to describe semantics of a programming language.
Associate semantic value to syntactically correct construct
Map syntactic domain to semantic domain
Val: Expression  Integer
Val(2 + 3*4) = 14
14 “denotes” the value of the expression 2+3*4
P: Program  (Input  Output)
Program  Input  Output [right associate]

30. Denotational Semantics of Mini Language (Expressions)
September 4, 1997
Denotational Semantics of Mini Language (Expressions)
E: Expression  Environment  Integer
E[[E1 ‘+’ E2]](Env) = E[[E1]](Env) + E[[E2]](Env)
E[[E1 ‘-’ E2]](Env) = E[[E1]](Env) - E[[E2]](Env)
E[[E1 ‘*’ E2]](Env) = E[[E1]](Env) * E[[E2]](Env)
E[[I]](Env) = Env(I)
E[[N]](Env) = N

31. Implementation in Scheme
September 4, 1997
Implementation in Scheme
(define (exprE expr)
(cond ((number? expr) (numE expr))
((ident? expr) (identE expr))
((plus? expr) (plusE expr))
((minus? expr) (minusE expr))
((times? expr) (timesE expr))
(else (error "illegal expression"))))
(define (env exp)
(if (eq? exp 'x) 3 'undef))
((exprE '(+ 2 x)) env)
;Value: 5
(define (numE expr)
(lambda (env) expr))
(define (identE expr)
(lambda (env) (env expr)))
(define (plusE expr)
(lambda (env)
(let ((expr1 (cadr expr)) (expr2 (caddr expr)))
(+ ((exprE expr1) env) ((exprE expr2) env)))))

32. Denotational Semantics of Mini Language (Expressions)
September 4, 1997
Denotational Semantics of Mini Language (Expressions)
P: Program  Environment
P[[L]] = L[[L]](Env0)
L: Statement-list  Environment  Environment
L[[L1 ‘;’ L2]] = L[[L1]]  L[[L2]]
L[[S]] = S[[S]]

33. Implementation in Scheme
September 4, 1997
Implementation in Scheme
(define (progP prog)
(if (stmt-list? prog)
(stmt-listL prog)
(error "illegal program")))
(define (stmt-listL stmt-list)
(let ((first-stmt (car stmt-list)) (remaining-stmts (cdr stmt-list)))
(if (null? remaining-stmts)
(stmtS first-stmt)
(compose (stmt-listL remaining-stmts) (stmtS first-stmt)))))
(define (compose f g)
(lambda (x)
(f (g x))))

34. Denotational Semantics of Mini Language (Statements)
September 4, 1997
Denotational Semantics of Mini Language (Statements)
S: Statement  Environment  Environment
S[[I ‘:=’ E]](Env) = Env & {I = E[[E]](Env)}
S[[‘if’ E ‘then’ L1 ‘else’ L2]](Env) = if E[[E]](Env) > 0 then L[[L1]](Env) else L[[L2]](Env)
S[[‘while’ E ‘do’ L od’]](Env) = if E[[E]](Env)  0 then Env else S[[‘while’ E ‘do’ L od’]](L[[L]](Env))

35. Implementation in Scheme
September 4, 1997
Implementation in Scheme
(define (stmtS stmt)
(cond ((assign-stmt? stmt) (assignS stmt))
((if-stmt? stmt) (ifS stmt))
((while-stmt? stmt) (whileS stmt))
(else (error "illegal statement"))))
(define (assignS stmt)
(let ((ident (cadr stmt)) (expr (caddr stmt)))
(lambda (env)
(lambda (var)
(if (eq? var ident) ((exprE expr) env) (env var))))))

36. Implementation in Scheme
September 4, 1997
Implementation in Scheme
(define (ifS stmt)
(let ((expr (cadr stmt)) (S1 (caddr stmt)) (S2 (cadddr stmt)))
(lambda (env)
(if (> ((exprE expr) env) 0)
((stmt-listL S1) env)
((stmt-listL S2) env)))))
(define (whileS stmt)
(let ((expr (cadr stmt)) (S (caddr stmt)))
(if (<= ((exprE expr) env) 0)
env
((whileS stmt) ((stmt-listL S) env))))))

37. Implementation in Scheme
September 4, 1997
Implementation in Scheme
(define prog
'((assign n (- 0 5))
(if n
((assign i n))
((assign i (- 0 n))))
(assign fact 1)
(while i
((assign fact (* fact i))
(assign i (- i 1))))))
(define env0
(lambda (ident) 'undef))
(env0 'x)
;Value: undef
(define envf ((progP prog) env0))
;Value: envf
(envf 'n)
;Value: -5
(envf 'i)
;Value: 0
(envf 'fact)
;Value: 120