Peter Siebel - Practical Common Lisp

An alternate approach would be to use EVAL to evaluate Lisp expressions in the interpreter. The problem with this approach is that EVAL has no access to the lexical environment. Thus, there's no way to make something like this work:

(let ((x 10)) (emit-html '(:p x)))

when xis a lexical variable. The symbol xthat's passed to emit-htmlat runtime has no particular connection to the lexical variable named with the same symbol. The Lisp compiler arranges for references to xin the code to refer to the variable, but after the code is compiled, there's no longer necessarily any association between the name xand that variable. This is the main reason that when you think EVAL is the solution to your problem, you're probably wrong.

However, if xwas a dynamic variable, declared with DEFVAR or DEFPARAMETER (and likely named *x*instead of x), EVAL could get at its value. Thus, it might be useful to allow the FOO interpreter to use EVAL in some situations. But it's a bad idea to always use EVAL . You can get the best of both worlds by combining the idea of using EVAL with the condition system.

First define some error classes that you can signal when embed-valueand embed-codeare called in the interpreter.

(define-condition embedded-lisp-in-interpreter (error)

((form :initarg :form :reader form)))

(define-condition value-in-interpreter (embedded-lisp-in-interpreter) ()

(:report

(lambda (c s)

(format s "Can't embed values when interpreting. Value: ~s" (form c)))))

(define-condition code-in-interpreter (embedded-lisp-in-interpreter) ()

(:report

(lambda (c s)

(format s "Can't embed code when interpreting. Code: ~s" (form c)))))

Now you can implement embed-valueand embed-codeto signal those errors and provide a restart that'll evaluate the form with EVAL .

(defmethod embed-value ((pp html-pretty-printer) value)

(restart-case (error 'value-in-interpreter :form value)

(evaluate ()

:report (lambda (s) (format s "EVAL ~s in null lexical environment." value))

(raw-string pp (escape (princ-to-string (eval value)) *escapes*) t))))

(defmethod embed-code ((pp html-pretty-printer) code)

(restart-case (error 'code-in-interpreter :form code)

(evaluate ()

:report (lambda (s) (format s "EVAL ~s in null lexical environment." code))

(eval code))))

Now you can do something like this:

HTML> (defvar *x* 10)

*X*

HTML> (emit-html '(:p *x*))

and you'll get dropped into the debugger with this message:

Can't embed values when interpreting. Value: *X*

[Condition of type VALUE-IN-INTERPRETER]

Restarts:

0: [EVALUATE] EVAL *X* in null lexical environment.

1: [ABORT] Abort handling SLIME request.

2: [ABORT] Abort entirely from this process.

If you invoke the evaluaterestart, embed-valuewill EVAL*x*, get the value 10, and generate this HTML:

10

Then, as a convenience, you can provide restart functions—functions that invoke the evaluaterestart—in certain situations. The evaluaterestart function unconditionally invokes the restart, while eval-dynamic-variablesand eval-codeinvoke it only if the form in the condition is a dynamic variable or potential code.