cs7100(Prasad) L8Interp 1
Interpreters
Study Semantics of Programming Languages through interpreters
(Executable Specifications)
cs7100(Prasad) L8Interp 2
Interpreters
• Input:– 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., 5 add1(+(3,j))
cs7100(Prasad) L8Interp 4
Informal Semanics
• Number 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) (literal-string28 "(" 1) (number 1 1) (literal-string28 "," 1) (number 3 1) (literal-string28 ")" 1) (literal-string28 ")" 1))
cs7100(Prasad) L8Interp 6
Example
> (scan&parse "add1(+(1,3))")(a-program (primapp-exp (incr-prim) ((primapp-exp (add-prim) ((lit-exp 1) (lit-exp 3))))))
> (eval-program (scan&parse "add1(+(1,3))"))5
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))
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)) ) )))
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)))
(define eval-rands (lambda (rands env)
(map (lambda (x) (eval-expression x env)) rands)))
cs7100(Prasad) L8Interp 10
(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 . . .
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))
)
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)))
cs7100(Prasad) L8Interp 13
Example (Dr. Racket)
> (scan&parse "-(v,x)")#(struct:a-program
#(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.
cs7100(Prasad) L8Interp 14
Adding conditional• Concrete 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)) )
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 -AbcDef+ # pqr") ((literal-string45 "if" 1) (identifier while 1) (literal-string45 "-" 1) (identifier Abc 2) (identifier Def 3) (literal-string45 "+" 4))
cs7100(Prasad) L8Interp 17
let x = 5 in let y = 6 + x in x + y;
• Sub-expressions may be evaluated in different contexts/environments.
let x = 5 in let x = 6 + x in x + x;
• Inner x shadows outer x in nested let-body.
x = 11
x = 5
x = 5y=11
x = 5
Local Bindings : Issues
cs7100(Prasad) L8Interp 18
let x = 5
in let xx = 6 + x
in xx + xx
*
x;
• Introducing let requires passing relevant environment to the evaluator.
• Inner binding hides the outer one in case of redefinion. (Example Expression Value: 110110)
x = 5
x = 5x = 11
x = 5
cs7100(Prasad) L8Interp 19
Adding let• Concrete 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))
)))
cs7100(Prasad) L8Interp 22
Recapitulation
Evaluator
Variable-free Arithmetic Expressions
(Integers, +, *,…)
Integer
syntax(program)
semantics structure (Scheme)
Semantics(meaning)
CALCULATOR
cs7100(Prasad) L8Interp 23
Evaluator
Arithmetic Expressions
Environment;(Integers, +, *,…)
Integer
syntax(program)
semantic structure (Scheme)
Semantics(meaning)
CALCULATOR WITH MEMORY
cs7100(Prasad) L8Interp 24
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.
Top Related