1. Interpreters
Study Semantics of Programming Languages through interpreters
(Executable Specifications)
cs7100(Prasad)
L8Interp

2. Interpreters Input: Output: Interpreter vs Compiler
Representation of a program (AST)
Output:
“Meaning” of the program
Interpreter vs Compiler
Interpreter carries out the meaning of a program, while a compiler transforms a program in one language into a program in a lower-level language preserving the meaning.
cs7100(Prasad)
L8Interp

3. Simple Expression Language
<program> ::= <expression>
<expression>::= <number>
| <identifier>
| <primitive> <operands>
<operands> ::= ()
| (<expression>
{,<expression>}*)
<primitive> ::= + | - | * | add1 | sub1
E.g.,
add1(+(3,j))
cs7100(Prasad)
L8Interp

4. Informal Semanics Number Symbolic names Application expression
same as what Scheme associates with numerals.
(internal to the entity)
Symbolic names
value bound to it in the environment
(external to the entity)
Application expression
recursively evaluate operator and operands.
primitive operators interpreted by Scheme.
cs7100(Prasad)
L8Interp

5. Example (Petite Scheme)
> (just-scan "add1(+(1,3))")
((literal-string28 "add1" 1)
(literal-string28 "(" 1)
(literal-string28 "+" 1)
(number 1 1)
(literal-string28 "," 1)
(number 3 1)
(literal-string28 ")" 1)
(literal-string28 ")" 1))
Token stream due to scanning
> (just-scan "add1(+(1,3))")
((literal-string45 "add1" 1) (literal-string45 "(" 1) (literal-string45 "+" 1) (literal-string45 "(" 1) (number 1 1) (literal-string45 "," 1) (number 3 1)
(literal-string45 ")" 1) (literal-string45 ")" 1))
EOPL-specifics : keywords are parsed as strings while identifiers are turned into symbols; unexpected letters ignored; third arg line number
=========
> (just-scan "if while")
((literal-string57 "if" 1) (identifier while 1))
> (just-scan ", + ? $")
((literal-string57 "," 1) (literal-string57 "+" 1))
> (just-scan " # ") ()
> (just-scan "-----_____")
((literal-string57 "-" 1) (literal-string57 "-" 1) (literal-string57 "-" 1) (literal-string57 "-" 1) (literal-string57 "-" 1))
> (just-scan "abc
def
ghi")
((identifier abc 1) (identifier def 2) (identifier ghi 3))
cs7100(Prasad)
L8Interp

6. Example > (scan&parse "add1(+(1,3))") > (eval-program
(a-program
(primapp-exp
(incr-prim)
((primapp-exp (add-prim)
((lit-exp 1)
(lit-exp 3))))))
> (eval-program
(scan&parse "add1(+(1,3))")) 5
AST and final evaluation result: View the AST as a labeled root with children, which are either a labeled tree or a list.
> (scan&parse "add1(+(1,3))")
#(struct:a-program
#(struct:primapp-exp
#(struct:incr-prim)
(#(struct:primapp-exp
#(struct:add-prim)
(#(struct:lit-exp 1) #(struct:lit-exp 3))))))
List red parenthesis
cs7100(Prasad)
L8Interp

7. The Abstract Syntax (define-datatype program program?
(a-program (exp expression?)))
(define-datatype expression expression?
(lit-exp (datum number?))
(var-exp (id symbol?))
(primapp-exp
(prim primitive?)
(rand (list-of expression?))) )
(define-datatype primitive primitive?
(add-prim)
(subtract-prim)
(mult-prim)
(incr-prim)
(decr-prim))
Variant record: expression
Characteristic function: expression?
Tags: lit-exp. var-exp, prim-exp
Typed Fields: datum number?, id symbol?, …
Eventually generated automatically from the grammar.
cs7100(Prasad)
L8Interp

8. The evaluator (define eval-program (lambda (pgm) (cases program pgm
(a-program (body)
(eval-expression body (init-env))))))
(define eval-expression
(lambda (exp env)
(cases expression exp
(lit-exp (datum) datum)
(var-exp (id) (apply-env env id) )
(primapp-exp (prim rands)
(let ((args (eval-rands rands env)))
(apply-primitive prim args)) ) )))
Fixed global environment: R-values, Call by value
cs7100(Prasad)
L8Interp

9. (cont’d) (define eval-rands (lambda (rands env)
(map (lambda (x)(eval-rand x env))
rands)))
(define eval-rand
(lambda (rand env)
(eval-expression rand env)))
(map (lambda (x)
(eval-expression x env))
All operands evaluated in the same environment.
cs7100(Prasad)
L8Interp

10. . . . Code for environment manipulation . . .
(cont’d)
(define apply-primitive
(lambda (prim args)
(cases primitive prim
(add-prim () (+ (car args) (cadr args)) )
(subtract-prim () (- (car args) (cadr args)) )
(mult-prim () (* (car args) (cadr args)) )
(incr-prim () (+ (car args) 1) )
(decr-prim () (- (car args) 1) ) )))
(define init-env
(lambda ()
(extend-env
'(i v x) '(1 5 10) (empty-env))))
. . . Code for environment manipulation . . .
(zero-test-prim () (if (zero? (car args)) 1 0)) needed to test for 0
init-env contains arbitrary bindings for variables
Consider the consequence of the “apply-primitive” definition on:
Number of arguments allowed. (2) Type of arguments allowed.
(3) Robustness issues: errors and exceptions …
(4) Flexible use with overloaded meaning of operators
cs7100(Prasad)
L8Interp

11. Scanner Specification
(define the-lexical-spec
'((whitespace (whitespace) skip)
(comment ("%" (arbno (not #\newline))) skip)
(identifier
(letter (arbno (or letter digit "_" "-" "?"))) symbol)
(integer (digit (arbno digit)) number)) )
Token type - lexeme regular expression - action
Whitespace includes newline.
cs7100(Prasad)
L8Interp

12. Parser Specification (define the-grammar
'((program (expression) a-program)
(expression (integer) lit-exp)
(expression (identifier) var-exp)
(expression
(primitive "(" (separated-list expression ",") ")")
primapp-exp)
(primitive ("+") add-prim)
(primitive ("-") subtract-prim)
(primitive ("*") mult-prim)
(primitive ("add1") incr-prim)
(primitive ("sub1") decr-prim)) )
Lhs nonterminal - RHS seq of terminals and nonterminals – abstract syntax automatically generated
The scanner returns language keywords given in the grammar as strings and other identifiers as symbols.
(primitive "(“expression ( arbno ( ",“ expression ) ) ")")
cs7100(Prasad)
L8Interp

13. Example (Dr. Racket) #(struct:a-program > (scan&parse "-(v,x)")
#(struct:primapp-exp
#(struct:subtract-prim)
( #(struct:var-exp v)
#(struct:var-exp x) )
) )
> (eval-program
(scan&parse "-(v,x)")) -5
Recall that v = 5 and x = 10 in init-env.
AST and final evaluation result
cs7100(Prasad)
L8Interp

14. Adding conditional Concrete Syntax Abstract Syntax
<expression> ::= if <expression>
then <expression> else <expression>
Abstract Syntax
if-exp (test-exp true-exp false-exp)
Addl. Semantic Function
(define (true-value? x)
(not (zero? x)) )
Recall that conditional expression is a special form and needs to be supported by the interpreter as opposed to simulatable via procedure call.
cs7100(Prasad)
L8Interp

15. Addl. Interpreter Clause
(if-exp (test-exp true-exp false-exp)
(if (true-value?
(eval-expression test-exp env))
(eval-expression true-exp env)
(eval-expression false-exp env)) )
Defined language vs Defining language
Inductively defined data structure naturally leads to recursively defined function.
cs7100(Prasad)
L8Interp

16. Scanner Details > (just-scan "if while - Abc Def + # pqr")
((literal-string45 "if" 1)
(identifier while 1)
(literal-string45 "-" 1)
(identifier Abc 2)
(identifier Def 3)
(literal-string45 "+" 4))
Token stream due to scanning
> (just-scan "if while - #
abc
def")
((literal-string57 "if" 1) (identifier while 1) (literal-string57 "-" 1))
> (just-scan "if while -
Abc
Def
+ # pqr")
((literal-string57 "if" 1)
(identifier while 1)
(literal-string57 "-" 1)
(identifier |Abc| 2)
(identifier |Def| 3)
(literal-string57 "+" 4))
+ pqr")
((literal-string45 "if" 1)
(literal-string45 "-" 1)
(identifier Abc 2)
(identifier Def 3)
(literal-string45 "+" 4)
(identifier pqr 4))
>
cs7100(Prasad)
L8Interp

17. Local Bindings : Issues
x = 5
let x = 5
in let y = 6 + x
in x + y;
Sub-expressions may be evaluated in different contexts/environments.
in let x = 6 + x
in x + x;
Inner x shadows outer x in nested let-body.
x = 5
y=11
x = 5
x = 11
cs7100(Prasad)
L8Interp

18. let x = 5 in let x = 6 + x in x + x * x;
Introducing let requires passing relevant environment to the evaluator.
Inner binding hides the outer one in case of redefinion. (Example Expression Value: 110)
x = 5
x = 5
x = 11
x = 5
cs7100(Prasad)
L8Interp

19. Adding let Concrete Syntax Abstract Syntax <expression> ::=
let { <identifier> =
<expression> } *
in <expression>
Abstract Syntax
let-exp (ids rands body)
cs7100(Prasad)
L8Interp

20. Introducing if and let expressions
(define-datatype expression expression?
. . .
(if-exp
(test-exp expression?)
(true-exp expression?)
(false-exp expression?))
(let-exp
(ids (list-of symbol?))
(rands (list-of expression?))
(body expression?) ) )
cs7100(Prasad)
L8Interp

21. Introducing if and let into the evaluator
(define eval-expression
(lambda (exp env)
(cases expression exp
. . .
(if-exp (test-exp true-exp false-exp)
(if (true-value? (eval-expression test-exp env))
(eval-expression true-exp env)
(eval-expression false-exp env)) )
(let-exp (ids rands body)
(let ((args (eval-rands rands env)))
(eval-expression body (extend-env ids args env))
) )
(else (eopl:error 'eval-expression "Not here:~s" exp))
)))
Semantic specification: let variable initialization expressions evaluated in the
Same surrounding environment --- other choices “let*”-interpretation possible.
cs7100(Prasad)
L8Interp

22. Recapitulation Variable-free Arithmetic Expressions (Integers, +, *,…)
Evaluator
Variable-free
Arithmetic Expressions
(Integers, +, *,…)
Integer
syntax
(program)
semantics structure
(Scheme)
Semantics
(meaning)
CALCULATOR
cs7100(Prasad)
L8Interp

23. Arithmetic Expressions
Evaluator
Arithmetic Expressions
Environment;
(Integers, +, *,…)
Integer
syntax
(program)
semantic structure
(Scheme)
Semantics
(meaning)
CALCULATOR WITH MEMORY
cs7100(Prasad)
L8Interp

24. Arithmetic Expressions; Procedure Definitions and Calls
Evaluator
Arithmetic Expressions;
Procedure Definitions and Calls
Environment;
(Integers, +, *,…);
Addl. Scheme Support
Integer; Procedures
syntax
(program)
semantic structure
(Scheme)
Semantics
(meaning)
PROGRAMMABLE CALCULATOR
cs7100(Prasad)
L8Interp

25. Polynomial Calculators
To specify/design a programmable polynomial calculator, the object language must contain syntax for creating and manipulating polynomials, and
the meta-language (Scheme) must provide suitable semantic structure
to map variables to polynomials (environment).
to interpret operations on polynomials (using corresponding Scheme code).
Meta-language support is analogous to hardware support.
The semantics of the ADT Polynomials can be specified through algebraic techniques.
cs7100(Prasad)
L8Interp