Metacircular Evaluation SICP Chapter 4 Mark Boady Metacircular

Metacircular Evaluation SICP Chapter 4 Mark Boady

Metacircular Evaluator An interpreter built for a language using the same language as it is interpreting. We will be looking at a Scheme interpreter written in scheme Read Chapter 4 of SICP for a more detailed look at this interpreter Why? Extending an interpreted language Debuggers

Jikes RVM A Java Research Virtual Machine written in Java The RVM runs on the JVM Used For Research in: Garbage Collection Dynamic Parallelization Machine Learning for dynamic compilation Dynamic Typing Distributed VM

Scheme Metacircular Evaluator Eval Takes an expression and an Environment = Variable Names and Values Returns the result of evaluating the expression Apply Takes a Procedure and a list of arguments Produces an expression for eval (+ (* 4 5) 6)

Eval Definition (define (eval exp env) (cond ((selfevaluating? exp) ((variable? exp) (lookup-variablevalue exp env)) ((quoted? exp) (text-ofquotation exp)) ((assignment? exp) (evalassignment exp env)) ((definition? exp) (evaldefinition exp env)) ((if? exp) (evalif exp env)) ((lambda? exp) (make-procedure (lambdaparameters exp) (lambdabody exp) env)) ((begin? exp) (evalsequence (begin-actions exp) env)) ((cond? exp) (eval (cond>if exp) env)) ((application? exp) (apply (eval (operator exp) en v) (list-ofvalues (operands exp) env))) (else (error "Unknown expression t ype -- EVAL" exp))))

(define (beval exp env) (cond ((boolean? exp) ((conjunct? exp) (beval-and exp env)) ((disjunct? exp) (beval-or exp env)) ((negate? exp) (beval-not exp env)) ((variable? exp). . . ; You'll need to supply your own function that takes a frame, returns the assoc. value (else (error "beval: illegal syntax")))))

Apply Definition (define (apply procedure arguments) (cond ((primitiveprocedure? procedure) (apply-primitiveprocedure arguments)) ((compoundprocedure? procedure) (evalsequence (procedurebody procedure) (extendenvironment (procedureparameters procedure) arguments (proc edureenvironment procedure)))) (else (error "Unknown procedure type -- APPLY" procedure))))

What do eval and apply do? Eval Takes the expression and determines what the expression is Passes the work to a helper function that evaluates the specific type For procedures, pass control to apply Apply Determine the type of procedure Add to the environment Pass control to Eval

Concept We want to eval (+ 4 5) ((application? exp) (apply (eval (operator exp) en v) (list-of-values (operands exp) env))) List-of-values evaluates the inputs to the procedure Apply performs the actual procedure With a primitive (like +) the underlying language handles it With a custom procedure, we need to pass back to eval

Metacircular

Basic Example (eval ‘(+ a 5) ‘((a 10) (b 7)) Evaluate the expression a+5 with the variables a=10, b=7 Eval starts with a procedure and sees it is an apply Eval evaluates the inputs to the procedure Looks up variable values in this case Apply is asked to handle with (+ 10 5) Apply can determine 10+5=15 using the underlying system

Details Getting the arguments of a Procedure (apply (eval (operator exp) env) values (operands exp) env))) (list-of- (define (list-of-values exps env) (if (nooperands? exps) '() (cons (eval (firstoperand exps) env) (list-of-values (restoperands exps) env))))

If Statements (define (eval-if exp env) (if (true? (eval (ifpredicate exp) env)) (eval (ifconsequent exp) env) (eval (ifalternative exp) env))) Only Evaluate based on the true case (define (true? X) (not (eq? x false))) (define (if-alternative exp) (if (not (null? (cdddr exp))) (cadddr exp) 'false))

Evaluating Sequences (define (eval-sequence exps env) (cond ((lastexp? exps) (eval (firstexp exps) env)) (else (eval (firstexp exps) env) (eval-sequence (restexps) env)))) Evaluate the sequence of expressions in a procedure body

Assigning Variables (define (eval-assignment exp env) (set-variablevalue! (assignmentvariable exp) (eval (assignmentvalue exp) env) 'ok) set-variable-value! Bounds a value to a name

Expressions Basic functionality is implemented directly Assignment (define (assignment? exp) (taggedlist? exp 'set!)) (define (assignmentvariable exp) (cadr exp)) (define (assignmentvalue exp) (caddr exp)) Derived Expressions Some functionality is implemented using existing functionality Cond can be transformed into if statements Let statements can be transformed in lambda expressions

Derived Expressions Let expressions are derived expressions, because (let ((<var 1> <exp 1>). . . (<varn> <expn>)) <body>) is equivalent to ((lambda (<var 1>. . . <varn>). . . <expn>) <body>) <exp 1>

Derived Expressions (let ((a 4) (b 6)) (+ a b)) Value 10 ( (lambda (a b) (+ a b)) 4 6) Value 10 We can write a command that will translate a let to a lambda. Let eval handle the lambda command using existing tools.

Environment (lookup-variable-value <var> <env>) returns the value that is bound to the symbol <var> in the environment <env>, or signals an error if the variable is unbound. (extend-environment <variables> <values> <base-env>) returns a new environment, consisting of a new frame in which the symbols in the list <variables> are bound to the corresponding elements in the list <values>, where the enclosing environment is the environment <base-env>.

Environment (define-variable! <var> <value> <env>) adds to the first frame in the environment <env> a new binding that associates the variable <var> with the value <value>. (set-variable-value! <var> <value> <env>) changes the binding of the variable <var> in the environment <env> so that the variable is now bound to the value <value>, or signals an error if the variable is unbound.

Environments There are multiple scopes in the environment We make changes to the most recent Example: Initial memory: ( ( (a b) (5 7) ) ) A new function is called with inputs b=6, c=7 We push a new set of variables into the environment New Memory: ( ( (b c) (6 7) ) ( (a b) (5 7) ) ) When the function call is over we remove it from the environment New Memory: ( ( (a b) (5 7) ) )

Environments (define (lookup-variable-value var env) (define (envloop env) (define (scan vars vals) (cond ((null? vars) (env-loop (enclosingenvironment env))) ((eq? var (car vars)) (car va ls)) (else (scan (cdr vars) (cdr vals))))) (if (eq? env th e-emptyenvironment) (error "Unbound variable" var) (let ((fr ame (first-frame env))) (scan (framevariables frame) (frame-values frame))))) (envloop env))

Environments (define (lookup-variable-value var env) (env-loop env) ) (define (env-loop env) (if (eq? env the-empty-environment) (error "Unbound variable" var) (let ((frame (first-frame env))) (scan (frame-variables frame) (frame-values frame)) )) ) (define (scan vars vals) (cond ((null? vars) (env-loop (enclosing-environment env))) ((eq? var (car vars)) (car vals)) (else (scan (cdr vars) (cdr vals))) ) )

Primitives (define primitive-procedures (list 'car car) (list 'cdr cdr) (list 'cons) (list 'null? ) (list '- -) (list '+ +) )) (define (apply-primitive-procedure proc args) underlying-scheme (primitiveimplementation proc) args)) (apply-in-

Running the Evaluator Load the File (load "ch 4 -mceval. M. scm") Initialize the Global Environment (define the-global-environment (setup-environment)) Initialize the Evaluator (driver-loop) We can now execute code!

Running (load "ch 4 -mceval. M. scm") (define the-global-environment (setup-environment)) (driver-loop) ; ; ; M-Eval input: (define (append x y) (if (null? x) y (cons (car x) (append (cdr x) y)))) ; ; ; M-Eval value: ok ; ; ; M-Eval input: (append '(a b c) '(d e f)) ; ; ; M-Eval value: (a b c d e f)

Driver Loop (define input-prompt "; ; ; M-Eval input: ") (define outputprompt "; ; ; M-Eval value: ") (define (driver-loop) (prompt -for-inputprompt) (let ((input (read))) (let ((output (eval input the-global-environment))) (announce-outputprompt) (user-print output))) (driverloop)) (define (prompt-forinput string) (newline) (display string) (newlin e))

Environments (define (setup-environment) (let ((initial-env (extend-environment (primitive-procedure-names) (primitive-procedure-objects) the-empty-environment))) (define-variable! 'true initial-env) (define-variable! 'false initial-env))