anchor.diff:    (make-instance 'lexical-location
       :name name))
   
  +(defmethod print-object ((object lexical-location) stream)
  +  (print-unreadable-object (object stream :type t)
  +    (format stream "~a" (name object))))
  +
   (defmethod draw-datum ((datum lexical-location) stream)
     (format stream "   ~a [fillcolor = yellow, label = \"~a\"]~%"
   	  (gethash datum *datum-table*)
  
positive.code: 
  (defmethod (setf outputs) :before (new-outputs instruction)
    (assert (listp new-outputs))
    (assert (every (lambda (output) (typep output 'datum)) new-outputs)))
  
  (defclass instruction ()
    ((%predecessors :initform '() :initarg :predecessors :accessor predecessors)
  
negative.code:   (assert (= (length (successors existing)) 1))
    (insert-instruction-between new existing (car (successors existing))))
  
  (defun delete-instruction (instruction)
    (assert (= (length (successors instruction)) 1))
    (setf (inputs instruction) '())
    (setf (outputs instruction) '())
    (let ((successor (car (successors instruction)))
  	(predecessors (predecessors instruction)))
      ;; Avoid having our predecessors mention our successor multiple
      ;; times in case our successor is already a successor of some of
      ;; our predecessors.
      (loop for predecessor in predecessors
  	  do (setf (successors predecessor)
  		   (remove instruction (successors predecessor)
  			   :test #'eq))
  	     (pushnew successor (successors predecessor)
  		      :test #'eq))
      ;; Avoid having our successor mention som of our predecessors
      ;; multiple times in case some of our predecessors are already a
      ;; predecessors of our successor.
      (setf (predecessors successor)
  	  (remove instruction (predecessors successor)
  		  :test #'eq))
      (loop for predecessor in predecessors
  	  do (pushnew predecessor (predecessors successor)
  		      :test #'eq))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Instructions for Common Lisp operators.
  