Prepared by - PowerPoint PPT Presentation

1 / 28
About This Presentation
Title:

Prepared by

Description:

'error' (and others) should probably be ' error ', so we allow those as variable names in Tiny. ... Extending Tiny. First, add more comparison operators, and ... – PowerPoint PPT presentation

Number of Views:74
Avg rating:3.0/5.0
Slides: 29
Provided by: johnqadmi
Learn more at: https://www.cise.ufl.edu
Category:
Tags: prepared | tiny

less

Transcript and Presenter's Notes

Title: Prepared by


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

2
Tinys 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
  • R _at_EQ 'error' - 'error' g R
  • in

3
Tinys Denotational Semantics in RPAL
  • let PIPE x f x _at_EQ 'error'
  • - 'error' (f x)
  • in
  • let Return v s (v,s)
  • in
  • let Check Dom (v,s)
  • Dom eq 'Num' -
  • Isinteger v - (v,s) 'error'
  • Dom eq 'Bool' -
  • Istruthvalue v - (v,s) 'error'
  • 'error'
  • in

4
Tinys Denotational Semantics in RPAL
  • let Dummy s s
  • in
  • let Cond F1 F2 (v,s)
  • s _at_PIPE (v - F1 F2)
  • in
  • let Replace m i v x x _at_EQ i - v m x
  • in
  • let Head i i 1
  • in
  • let Tail T rtail T (Order T)
  • where rec rtail T N
  • N eq 1 - nil
  • (rtail T (N-1) aug (T N))
  • in

5
Tinys 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 R _at_EQ 'undef'
  • - 'error' (R,(m,i,o))
  • )
  • )

6
Tinys Denotational Semantics in RPAL
  • Istuple E -
  • ( (E 1) _at_EQ 'not' -
  • (m,i,o) _at_PIPE EE(E 2)
  • _at_PIPE (Check 'Bool')
  • _at_PIPE (fn(v,s).(not v,s))

7
Tinys Denotational Semantics in RPAL
  • (E 1) _at_EQ ' (m,i,o)
  • _at_PIPE EE(E 2)
  • _at_PIPE (Check 'Num')
  • _at_PIPE (fn(v1,s1). s1
  • _at_PIPE EE(E 3)
  • _at_PIPE (Check 'Num')
  • _at_PIPE
  • (fn(v2,s2).(v1 le v2,s2))
  • )

8
Tinys Denotational Semantics in RPAL
  • (E 1) _at_EQ '' - (m,i,o)
  • _at_PIPE EE(E 2)
  • _at_PIPE (Check 'Num')
  • _at_PIPE (fn(v1,s1). S1
  • _at_PIPE EE(E 3)
  • _at_PIPE (Check 'Num')
  • _at_PIPE
  • (fn(v2,s2).(v1 v2,s2))
  • )
  • 'error' // not 'not', '
  • )
  • 'error' // not a tuple
  • in

9
Tinys Denotational Semantics in RPAL
  • let rec CC C s
  • not (Istuple C) - 'error'
  • (C 1) _at_EQ ''
  • - s _at_PIPE EE (C 3)
  • _at_PIPE (fn(v,s).
  • (Replace (s 1) (C 2) v,s 2,s 3))
  • (C 1) _at_EQ 'print'
  • - s _at_PIPE EE (C 2)
  • _at_PIPE (fn(v,s).
  • (s 1,s 2,s 3 aug v))

10
Tinys Denotational Semantics in RPAL
  • (C 1) _at_EQ 'if'
  • - s _at_PIPE EE (C 2)
  • _at_PIPE (Check 'Bool')
  • _at_PIPE (Cond (CC(C 3)) (CC(C 4)))
  • (C 1) _at_EQ 'while'
  • - s _at_PIPE EE (C 2)
  • _at_PIPE (Check 'Bool')
  • _at_PIPE Cond (CC('',C 3,C)) Dummy

11
Tinys Denotational Semantics in RPAL
  • (C 1) _at_EQ ''
  • - s _at_PIPE CC (C 2) _at_PIPE CC (C 3)
  • 'error' // not '', 'if', ...
  • in
  • let PP P
  • not (Istuple P) - (fn i. 'error')
  • not ((P 1) _at_EQ 'program')
  • - (fn i. 'error')
  • ((fn i. CC (P 2)
  • ((fn i.'undef'),i,nil) //start state!
  • ) _at_COMP (fn s.(s 3)) )
  • in

12
Tinys Denotational Semantics in RPAL
  • Print
  • ( PP ('program', // test program
  • ('',
  • ('', 'x',3),
  • ('print', 'x')
  • )
  • ) (nil aug 3) // the input
  • )
  • Whew ! Now, RUN IT !!

13
Tinys 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
    '', 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 EEE1 o (Check Num) o
(?(v1,s1). s1 EEE2 (Check Num)
(?(v2,s2).(v1 - v2,s2) )
15
Extending Tiny
  • Lets add the '' comparison operator. Allow for
    Num and Bool. This allows type mixing !
  • EE
  • EEE1
  • o (Check Num)
  • o (?(v1,s1). s1 EEE2
  • (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)
  • ? (Val x State)
  • Econd ?EF1. ?EF2. ?(v,s). s (v ? EF1 EF2)
  • EE EEE1
  • o (Check Bool)
  • o (Econd EEE2 EEE3)

17
Add prefix auto-increment operator
  • EE
  • EEI o (Check Num)
  • (?(v,(m,i,o)). v eq ? ? error
  • (v1, (Replace m I (v1)),
    i, o)
  • )
  • For postfix (n), change this to v !

18
Adding the one-armed if to Tiny
  • CC EEE
  • o (Check Bool)
  • o (Cond CCC Dummy)
  • Of course, for most of these, the syntactic
    domains need to be updated.

19
Adding a repeat statement to Tiny
  • CC
  • CCC o EEE o (Check Bool) o
  • (Cond Dummy (CC))
  • or better yet,
  • CC
  • CCC o CC C

20
Adding a read statement to Tiny
  • CC
  • ?(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 EEL o (Check Num) o
  • (?(l,s). S EEF (Check Num)
  • (?(f,(m,i,o)). (Replace m I f, i,
    o)
  • CC
  • I 1
  • )
  • ) o
  • (?(m,i,o). (Replace m I ?, i, o))
  • Yuck. Cant enforce lots of rules.

22
Adding the C for loop to Tiny
  • CC
  • CCF o CC
  • or
  • CC
  • 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
  • EEE o (Check Num) o
  • C_CCCC1 ... C_CCCCn o (?(v,s).s)
  • Need a new syntactic domain, for case-clauses
  • C_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
  • ?(v,s). v eq ? ? (v,s)
  • v ne n ? (v,s)
  • (? , s CCC)
  • 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 (CFGs) good for everyone
  • Language user.
  • Language implementer.
  • Language designer.
  • Not so in the world of semantics.

27
Remarks on Semantic Specifications
User
Designer
Implementer
Operational
Denotational
Attribute Grammar
E Excellent, G Good F Fair, T -
Terrible
28
Extending Tiny
Programming Language Principles Lecture 27
  • Prepared by
  • Manuel E. Bermúdez, Ph.D.
  • Associate Professor
  • University of Florida
Write a Comment
User Comments (0)
About PowerShow.com