title: Given the following LISP eval function - what is required to add defmacro?
body: <p>Given the following <a href="http://lib.store.yahoo.net/lib/paulgraham/jmc.lisp" rel="noreferrer">definition</a> of the LISP eval function - what is required to add the <code>defmacro</code> function? (Or even just evaluate a macro)</p>
  
  <pre><code>(defun null. (x)
        (eq x '()))
  
  (defun and. (x y)
    (cond (x (cond (y 't) ('t '())))
          ('t '())))
  
  (defun not. (x)
    (cond (x '())
          ('t 't)))
  
  (defun append. (x y)
    (cond ((null. x) y)
          ('t (cons (car x) (append. (cdr x) y)))))
  
  (defun list. (x y)
    (cons x (cons y '())))
  
  (defun pair. (x y)
    (cond ((and. (null. x) (null. y)) '())
          ((and. (not. (atom x)) (not. (atom y)))
           (cons (list. (car x) (car y))
                 (pair. (cdr x) (cdr y))))))
  
  (defun assoc. (x y)
    (cond ((eq (caar y) x) (cadar y))
          ('t (assoc. x (cdr y)))))
  
  (defun eval. (e a)
    (cond
      ((atom e) (assoc. e a))
      ((atom (car e))
       (cond
         ((eq (car e) 'quote) (cadr e))
         ((eq (car e) 'atom)  (atom   (eval. (cadr e) a)))
         ((eq (car e) 'eq)    (eq     (eval. (cadr e) a)
                                      (eval. (caddr e) a)))
         ((eq (car e) 'car)   (car    (eval. (cadr e) a)))
         ((eq (car e) 'cdr)   (cdr    (eval. (cadr e) a)))
         ((eq (car e) 'cons)  (cons   (eval. (cadr e) a)
                                      (eval. (caddr e) a)))
         ((eq (car e) 'cond)  (evcon. (cdr e) a))
         ('t (eval. (cons (assoc. (car e) a)
                          (cdr e))
                    a))))
      ((eq (caar e) 'label)
       (eval. (cons (caddar e) (cdr e))
              (cons (list. (cadar e) (car e)) a)))
      ((eq (caar e) 'lambda)
       (eval. (caddar e)
              (append. (pair. (cadar e) (evlis. (cdr e) a))
                       a)))))
  
  (defun evcon. (c a)
    (cond ((eval. (caar c) a)
           (eval. (cadar c) a))
          ('t (evcon. (cdr c) a))))
  
  (defun evlis. (m a)
    (cond ((null. m) '())
          ('t (cons (eval.  (car m) a)
                    (evlis. (cdr m) a)))))
  
  
  (eval '(car '(a a)) )
  </code></pre>