1 / 27

Understanding Programming Languages through Interpreters: A Guide Based on EOPL3

This document explores the semantics of programming languages through interpreters, based on Chapter 3 of "Essentials of Programming Languages" by Prabhaker Mateti. It covers the LET language, the structure of abstract syntax trees (AST), and the roles and functions of various expressions within the language. It includes an introduction to interpreters versus compilers, detailed examples, code snippets, and the specification of value resolution in the LET language. The source code is provided for practical understanding, tested in PLT Scheme and Racket.

hung
Télécharger la présentation

Understanding Programming Languages through Interpreters: A Guide Based on EOPL3

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. Semantics of PLs via Interpreters: Getting Started CS784: Programming Languages Prabhaker Mateti

  2. Study … • EOPL3 Chapter 3: 3.1, 3.2 • source code: chapter3/let-lang/* • 1722 data-structures.scm • 4415 drscheme-init.scm • 1450 environments.scm • 2057 interp.scm • 1501 lang.scm • 1857 tests.scm • 2007 top.scm

  3. EOPL3 Source Code • All the code in the book, as a zip archive (211 Kb). • http://www.eopl3.com/allcode.zip • tested under PLT Scheme versions 372 and 4.2. • It should run unchanged in Racket 5.1.3 . • To make it more consistent with current Racket code, remove(module name (lib "eopl.ss" "eopl") .... )around each file, and write #langeoplat the top of the file instead. • If the module says(module name mzscheme .... ) use #langmzschemeinstead (NOT #lang racket -- the syntax for require/provide is slightly different).

  4. Interpreter vs Compiler • Input: Abstract Syntax of a program (AST) • Output:“Meaning” of the program • An interpreter carries out the meaning of a program. • A compiler transforms a program in one language into a program in a lower-level language preserving the meaning.

  5. Fig 3.2 The LET language Concrete/Abstract Syntax Comments on the syntax Six kinds of expressions. Assume Scheme syntax for id and number. Minus is used as a function name. Uses std math notation for apply. then-body and else-body are single expressions. exp1 is the first expression and body is the second expression.

  6. Examples in the LET language • let x = 5 in -(x,3) • let z = 5 in let x = 3 in let y = -(x,1) % here x = 3 in let x = 4 in -(z, -(x,y)) % here x = 4 • let x = 7 in let y = 2 in let y = let x = -(x,1) in -(x,y) in -(-(x,8), y)

  7. scan&parse • (scan&parse "-(55, -(x,11))") • #(struct:a-program • #(struct:diff-exp • #(struct:const-exp 55) • #(struct:diff-exp • #(struct:var-exp x) • #(struct:const-exp 11))))

  8. Values Of The Language • Expressed values are the values of exp. • Denoted values are bound to variables. • Not always the same, in general. • In LET, they are the same: • ExpVal = Int + Bool • DenVal = Int + Bool

  9. Functions in our LET-Interpreter • constructors • const-exp : Int →Exp • zero?-exp : Exp → Exp • if-exp : Exp × Exp × Exp → Exp • diff-exp : Exp × Exp → Exp • var-exp : Var → Exp • let-exp : Var × Exp × Exp → Exp • observer • value-of : Exp × Env → ExpVal

  10. Spec of value-of • (value-of (const-exp n) ρ) = (num-val n) • (value-of (var-exp var) ρ)= (apply-envρ var) • (value-of (diff-exp exp1 exp2) ρ)=(num-val(- (expval->num (value-of exp1 ρ))(expval->num (value-of exp2 ρ)))) • Three more remaining.

  11. Notation

  12. Figure 3.3 An example calculation

  13. Specifying Programs • initial environment • [i=1, v=5, x=10] • (value-of-program exp) = (value-of exp [i=[1],v=[5], x= [10]])

  14. Spec of value-of • (value-of (if-exp exp1 exp2 exp3) ρ) = (if (expval->bool (value-of exp1 ρ)) (value-of exp2 ρ) (value-of exp3 ρ)) • (value-of (let-expvarexp1 body) ρ) = (value-of body [var = (value-of exp1 ρ)] ρ)

  15. Fig 3.4 A conditional expression

  16. Eval of an example let

  17. Eval of an example let (contd)

  18. Fig 3.6 LET lang AST def (if-exp (exp1 expression?) (exp2 expression?) (exp3 expression?)) (var-exp (var identifier?)) (let-exp (var identifier?) (exp1 expression?) (body expression?))) • (define-datatype program program? (a-program (exp1 expression?))) • (define-datatype expression expression? • (const-exp • (num number?)) • (diff-exp • (exp1 expression?) • (exp2 expression?)) • (zero?-exp • (exp1 expression?))

  19. (init-env) = [i= 1,v= 5,x=10] • (define init-env • (lambda () • (extend-env • 'i (num-val 1) • (extend-env • 'v (num-val 5) • (extend-env • 'x (num-val 10) • (empty-env))))))

  20. Fig 3.7a Expressed values • (define-datatypeexpvalexpval? (num-val (num number?)) (bool-val (boolboolean?)))

  21. Fig 3.7b Expressed values • (define expval->num (lambda (val) (cases expvalval (num-val (num) num) (else (report-expval-extractor-error ’numval)))))

  22. Fig 3.7c Expressed values • (define expval->bool (lambda (val) (cases expvalval (bool-val (bool) bool) (else (report-expval-extractor-error `boolval)))))

  23. value-of: Exp × Env → ExpVal

  24. run, value-of-program

  25. (value-of (zero?-exp exp1) env)

  26. (value-of (if-exp e1 e2 e3) env)

  27. (value-of (let-exp …) env)

More Related