1. Programming Language Principles
Extending Tiny
Programming Language Principles
Lecture 27
Prepared by
Manuel E. Bermúdez, Ph.D.
Associate Professor
University of Florida

2. Tiny’s Denotational Semantics in RPAL
let EQ x y = Istruthvalue x & Istruthvalue y
-> (x & y) or (not x & not y)
| Isstring x & Isstring y
or Isinteger x & Isinteger y
-> x eq y | false in
let COMP f g x = let R = f x in
'error' -> 'error' | g R

3. Tiny’s Denotational Semantics in RPAL
let PIPE x f = 'error'
-> 'error' | (f x) in
let Return v s = (v,s)
let Check Dom (v,s) =
Dom eq 'Num' ->
Isinteger v -> (v,s) | 'error'
| Dom eq 'Bool' ->
Istruthvalue v -> (v,s) | 'error'
| 'error'

4. Tiny’s Denotational Semantics in RPAL
let Dummy s = s in
let Cond F1 F2 (v,s) =
(v -> F1 | F2)
let Replace m i v x = i -> v | m x
let Head i = i 1
let Tail T = rtail T (Order T)
where rec rtail T N =
N eq 1 -> nil |
(rtail T (N-1) aug (T N))

5. Tiny’s Denotational Semantics in RPAL
let rec EE E (m,i,o) =
Isinteger E -> Return E (m,i,o)
| Isstring E ->
( E eq 'true' -> Return true (m,i,o)
| E eq 'false' -> Return false (m,i,o)
| E eq 'read' -> Null i -> 'error'
| (Head i,(m,Tail i,o))
| (let R = m E in 'undef'
-> 'error' | (R,(m,i,o)) )

6. Tiny’s Denotational Semantics in RPAL
| Istuple E ->
( (E 'not' ->
EE(E 2)
@PIPE (Check 'Bool')
@PIPE (fn(v,s).(not v,s))

7. Tiny’s Denotational Semantics in RPAL
| (E '<=' -> (m,i,o)
@PIPE EE(E 2)
@PIPE (Check 'Num')
@PIPE (fn(v1,s1). s1
@PIPE EE(E 3)
@PIPE
(fn(v2,s2).(v1 le v2,s2)) )

8. Tiny’s Denotational Semantics in RPAL
| (E '+' -> (m,i,o)
@PIPE EE(E 2)
@PIPE (Check 'Num')
@PIPE (fn(v1,s1). S1
@PIPE EE(E 3)
@PIPE
(fn(v2,s2).(v1 + v2,s2)) )
| 'error' // not 'not', '<=', '+'
| 'error' // not a tuple in

9. Tiny’s Denotational Semantics in RPAL
let rec CC C s =
not (Istuple C) -> 'error'
|(C ':='
-> EE (C 3)
@PIPE (fn(v,s).
(Replace (s 1) (C 2) v,s 2,s 3))
|(C 'print'
-> EE (C 2)
(s 1,s 2,s 3 aug v))

10. Tiny’s Denotational Semantics in RPAL
| (C 'if'
-> EE (C 2)
@PIPE (Check 'Bool')
@PIPE (Cond (CC(C 3)) (CC(C 4)))
| (C 'while'
@PIPE Cond (CC(';',C 3,C)) Dummy

11. Tiny’s Denotational Semantics in RPAL
|(C ';'
-> CC (C CC (C 3)
| 'error' // not ':=', 'if', ... in
let PP P =
not (Istuple P) -> (fn i. 'error')
| not ((P 'program')
-> (fn i. 'error')
| ((fn i. CC (P 2)
((fn i.'undef'),i,nil) //start state!
(fn s.(s 3)) )

12. Tiny’s Denotational Semantics in RPAL
Print
( PP ('program', // test program
(';',
(':=', 'x',3),
('print', 'x') )
) (nil aug 3) // the input
Whew ! Now, RUN IT !!

13. Tiny’s Denotational Semantics in RPAL
Executable semantic specification of Tiny.
Add a parser, and voilà ... Tiny is implemented !
Could even write the parser in RPAL ... 
Inefficient, but who cares ...
'error' (and others) should probably be '<error>', so we allow those as variable names in Tiny.
Subject to change:
Alter order of evaluation of operands.
Allow comparison of booleans.

14. Extending Tiny
First, add more comparison operators, and lots of arithmetic operators (easy). Example:
EE[<- E1 E2>] =
EE[E1]
o (Check Num)
o (λ(v1,s1). s1 => EE[E2]
=> (Check Num)
=> (λ(v2,s2).(v1 - v2,s2) )

15. Extending Tiny
Let’s add the '=' comparison operator. Allow for Num and Bool. This allows type mixing !
EE[<= E1 E2>] =
EE[E1]
o (Check Num)
o (λ(v1,s1). s1 => EE[E2]
=> (Check Num)
=> (λ(v2,s2).(v1 eq v2,s2) )

16. Add Conditional Expression
Need a new auxiliary function: Econd.
ECond: (State → Val x State)
→ (State → Val x State)
→ (Val x State)
Econd = λEF1. λEF2. λ(v,s). s => (v → EF1 | EF2)
EE[<cond E1 E2 E3>] = EE[E1]
o (Check Bool)
o (Econd EE[E2] EE[E3])

17. Add prefix auto-increment operator
EE[<++ I>] =
| EE[I] o (Check Num)
(λ(v,(m,i,o)). v eq  → error
| (v+1, (Replace m I (v+1)), i, o) )
For postfix (n++), change this to v !

18. Adding the one-armed ‘if’ to Tiny
CC[<if E C>] = EE[E]
o (Check Bool)
o (Cond CC[C] Dummy)
Of course, for most of these, the syntactic domains need to be updated.

19. Adding a ‘repeat’ statement to Tiny
CC[<repeat C E>] =
CC[C] o EE[E] o (Check Bool) o
(Cond Dummy (CC[<repeat C E>]))
or better yet,
CC[C] o CC[<while <not E> C>]

20. Adding a read statement to Tiny
CC[<read I>] =
| λ(m,i,o). Null i → error
| (Replace m I (Head i), Tail i, o)
Would need to remove the ‘read’ expression.

21. Adding the Pascal ‘for’ loop to Tiny
CC[<for I F L C>] = EE[L] o (Check Num) o
(λ(l,s). S => EE[F] => (Check Num)
=> (λ(f,(m,i,o)). (Replace m I f, i, o)
=> CC[<while < ≤ I l>
<; C <:= I <+ I 1>>> ] )
) o
(λ(m,i,o). (Replace m I , i, o))
Yuck. Can’t enforce lots of rules.

22. Adding the C ‘for’ loop to Tiny
CC[<for F E I C>] =
CC[F] o CC[<while E <; C I>>] or
CC[<; F <while E <; C I>>]
Remarkably simple, eh ?
Of course, Tiny has no continue statement to get in the way.
We assume default values have been added for any missing parts, e.g. true for E.

23. Adding a ‘case’ statement to Tiny
CC[<case E CC1 ... CCn >] =
EE[E] o (Check Num) o
C_CC[CC1] ... C_CC[CCn] o (λ(v,s).s)
Need a new syntactic domain, for case-clauses:
C_C = <c_c n C>
Also, a new semantic function to process them:
C_CC: C_C → (Val x State) → (Val x State)

24. Adding a ‘case’ statement to Tiny
To process one case clause:
C_CC[<c_c n C>] =
λ(v,s). v eq  → (v,s)
| v ne n → (v,s)
| ( , s => CC[C])
Aborts all subsequent case clauses.
To process them all, change this to v !

25. Remarks on Denotational Semantics
Exercise: implement these in RPAL ! (see ‘medium’ on website)
Can this be done for “real” programming languages ? Yes, but ...
We now have three formalisms for specifying the semantics of programming languages:
Operational (RPAL)
Attribute grammars (Tiny)
Denotational (Tiny)

26. Remarks on Semantic Specifications
Remember, parsing was *easy* 
Reason: one formalism (CFG’s) good for everyone:
Language user.
Language implementer.
Language designer.
Not so in the world of semantics.

27. Remarks on Semantic Specifications
User
Designer
Implementer F E T G
Operational
Denotational
Attribute Grammar
E – Excellent, G – Good
F – Fair, T - Terrible

28. Programming Language Principles
Extending Tiny
Programming Language Principles
Lecture 27
Prepared by
Manuel E. Bermúdez, Ph.D.
Associate Professor
University of Florida