Interpreters

Document Sample
Interpreters Powered By Docstoc
					                    Interpreters

            Study Semantics of Programming
             Languages through interpreters
               (Executable Specifications)




cs784(Prasad)             L7Interp            1
                    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.
cs784(Prasad)              L7Interp                     2
                Simple Expression Language
   <program> ::= <expression>

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

  <operands> ::= ()
               | (<expression>
                     {,<expression>}*)
  <primitive> ::=          + | - | * | add1 | sub1

E.g.,                  5
                       add1(+(3,j))
cs784(Prasad)              L7Interp              3
                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.
cs784(Prasad)             L7Interp                   4
                  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))


  cs784(Prasad)            L7Interp         5
                    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


    cs784(Prasad)     L7Interp         6
                  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))

  cs784(Prasad)          L7Interp         7
                  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)) ) )))

  cs784(Prasad)       L7Interp             8
                   (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)))

  cs784(Prasad)      L7Interp             9
                                 (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 . . .

  cs784(Prasad)                      L7Interp                     10
                    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))

)


    cs784(Prasad)                 L7Interp                           11
                      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))
)


    cs784(Prasad)                 L7Interp               12
                     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.

     cs784(Prasad)               L7Interp            13
                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)) )
cs784(Prasad)           L7Interp                14
• 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.


cs784(Prasad)           L7Interp                       15
                  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))


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

                in let x = 6 + x
                                               x=5
                    in          x + x          x = 11
                    *
                    x;                         x=5


• Introducing let requires passing relevant
  environment to the evaluator.
• Inner binding overrides the outer one in case of
  conflict. (Example Expression Value: 110)
cs784(Prasad)            L7Interp                    18
                Adding let
• Concrete Syntax

  <expression> ::=
      let { <identifier> =
              <expression> } *
      in <expression>

• Abstract Syntax
    let-exp      (ids     rands   body)


cs784(Prasad)       L7Interp              19
          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?) )
)
 cs784(Prasad)           L7Interp              20
   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))
    )))



cs784(Prasad)                     L7Interp                         21
                        Recapitulation
                                    Variable-free
                 syntax
                (program)      Arithmetic Expressions

                       semantics structure
  Evaluator                                      (Integers, +, *,…)
                              (Scheme)

                  Semantics
                  (meaning)                 Integer

                     CALCULATOR


cs784(Prasad)                    L7Interp                             22
                               Arithmetic Expressions
                 syntax
                (program)


                       semantic structure
    Evaluator                                      Environment;
                              (Scheme)          (Integers, +, *,…)
                  Semantics
                  (meaning)                Integer

          CALCULATOR WITH MEMORY


cs784(Prasad)                   L7Interp                             23
                                 Arithmetic Expressions;
                 syntax
                (program)      Procedure Definitions and Calls

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

                  Semantics
                  (meaning)                 Integer; Procedures

        PROGRAMMABLE CALCULATOR



cs784(Prasad)                    L7Interp                               24
                 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.
cs784(Prasad)                     L7Interp                             25

				
DOCUMENT INFO