anchor.diff:  
   ;;; Search an ast to see whether its original form is eq to the ast
   (defun search-ast (form ast)
  -  (cond ((eq form (original-form ast))
  +  (cond ((eq form (form ast))
   	 ast)
  -	((typep ast 'compound-form)
  -	 (some (lambda (subform)
  -		 (search-ast form subform))
  -	       (subforms ast)))
  +	((typep ast 'compound-ast)
  +	 (some (lambda (child)
  +		 (search-ast form child))
  +	       (children ast)))
   	(t nil)))
   
   ;;; Create a new ast from the form by either finding
  
positive.code: (defun proper-list-p (list)
    (null (last list 0)))
  
  ;;; Create an abstract syntax tree from the raw form returned by
  ;;; the reader
  (defun make-ast (form)
    (cond ((symbolp form)
  	 (make-instance 'symbol-form
  			:original-form form))
  	((atom form)
  	 (make-instance 'constant-form
  			:original-form form))
  	(t
  	 (assert (proper-list-p form))
  	 (make-instance 'compound-form
  			:original-form form
  			:subforms (mapcar #'make-ast form)))))
  
  (defgeneric convert (ast environment))
  
  (defmethod convert ((ast constant-form) environment)
    ast)
  
  (defmethod convert ((ast symbol-form) environment)
    (let ((macro-expansion (lookup (original-form ast) environment 'symbol-macro)))
      (if (not (null macro-expansion))
  	(convert (make-ast macro-expansion) environment)
  	(let ((variable (lookup (original-form ast) environment 'variable)))
  	  (if (not (null variable))
  	      variable
  	      ;; handle unknown variable
  
negative.code: ;;;
  ;;; Internal representation of source code
  
  ;;; Terminology: We use `form' to mean raw Lisp expressions
  ;;; resulting from READing source code.  We use `ast'  for
  ;;; the abstract syntax tree resulting from converting such
  ;;; raw expressions to instances of our compiler objects. 
  
  ;;; The first step is to convert the raw Lisp form into an 
  ;;; abstract syntax tree, so that we can then use generic
  ;;; function dispatch for the following steps. 
  
  (defclass ast (compiler-object)
    ((%form :initarg :form :accessor form)))
  
  (defclass symbol-ast (ast) ())  
  
  (defclass constant-ast (ast) ())
  
  (defclass compound-ast (ast)
    ((%children :initarg :children :reader children)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  