Interpreters

cs7100(Prasad) L8Interp 1

Interpreters

Study Semantics of Programming Languages through interpreters

(Executable Specifications)


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.


Simple Expression Language <program> ::= <expression>

<expression>::= <number> | <identifier> | <primitive> <operands>

<operands> ::= () | (<expression>

{,<expression>}*)

<primitive> ::= + | - | * | add1 | sub1

E.g., 5 add1(+(3,j))


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.


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))


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


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))


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)) ) )))


(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)))


(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 . . .


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))

)


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)))


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.


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)) )


• 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.


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))


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


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


Adding let• Concrete Syntax

<expression> ::= let { <identifier> =

<expression> } * in <expression>

• Abstract Syntax

let-exp (ids rands body)


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?) ))


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))

)))


Recapitulation

Evaluator

Variable-free Arithmetic Expressions

(Integers, +, *,…)

Integer

syntax(program)

semantics structure (Scheme)

Semantics(meaning)

CALCULATOR


Evaluator

Arithmetic Expressions

Environment;(Integers, +, *,…)

Integer

syntax(program)

semantic structure (Scheme)

Semantics(meaning)

CALCULATOR WITH MEMORY


Evaluator

Arithmetic Expressions;Procedure Definitions and Calls

Environment; (Integers, +, *,…);Addl. Scheme Support

Integer; Procedures

syntax(program)

semantic structure (Scheme)

Semantics(meaning)

PROGRAMMABLE CALCULATOR


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.

Interpreters

Documents

Transcript of Interpreters