1 / 25

Interpreters

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

seamus
Télécharger la présentation

Interpreters

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Interpreters Study Semantics of Programming Languages through interpreters (Executable Specifications) 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. L8Interp

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

  11. Scanner Specification (define the-lexical-spec '((whitespace (whitespace)skip) (comment ("%" (arbno (not #\newline)))skip) (identifier (letter (arbno (or letter digit "_" "-" "?")))symbol) (number (digit (arbno digit))number)) ) L8Interp

  12. Parser Specification (define the-grammar '((program (expression)a-program) (expression (number)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)) ) L8Interp

  13. Example (Dr. Scheme) > (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. 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)) ) 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 languagevsDefining language • Inductively defined data structure naturally leads to recursively defined function. 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)) L8Interp

  17. Local Bindings : Issues x = 5 x = 5 y=11 letx = 5 in lety = 6 + x inx + y; • Sub-expressions may be evaluated in different contexts/environments. letx = 5 in letx = 6 + x inx + x; • Inner x shadows outer x in nestedlet-body. x = 5 x = 11 L8Interp

  18. x = 5 x = 5 x = 11 letx = 5 inletx = 6 + x inx + x * x; • Introducing let requires passing relevant environment to the evaluator. • Inner binding overrides the outer one in case of conflict. (Example Expression Value: 110) x = 5 L8Interp

  19. Adding let • Concrete Syntax <expression> ::= let { <identifier> = <expression> } * in<expression> • Abstract Syntax let-exp (ids rands body) 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?) ) ) 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)) ))) L8Interp

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

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

  24. Arithmetic Expressions; Procedure Definitions and Calls syntax (program) Environment; (Integers, +, *,…); Addl. Scheme Support semantic structure (Scheme) Evaluator Semantics (meaning) Integer; Procedures PROGRAMMABLE CALCULATOR 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. L8Interp

More Related