anchor.diff:  (defun rel (label)
     (let ((addr (context-address *context*))
           (label (label label)))
  -    (relative (delay (label) (- label addr 2)))))
  +    (relative (delay :relative (label) (- label addr 2)))))
   
   ;;; Instruction parameters, according to addressing mode
   
  
positive.code:   (declare (ignore force-p))
    expression)
  
  (defmethod force ((delay delay) &optional (force-p t))
    (if (not (eq (delay-value delay) *lazy-marker*))
        (delay-value delay)
        (handler-case (setf (delay-value delay) (funcall (delay-fun delay)))
          (resolvable-condition (condition)
            (when (or (delay-name delay) (stringp force-p))
              (setf (text condition)
                    (format nil "~A~A~A: ~A"
                            (if (stringp force-p) force-p "")
                            (if (and (delay-name delay) (stringp force-p)) "/" "")
                            (or (delay-name delay) "")
                            (text condition))))
            (funcall (if force-p #'error #'signal) condition)
            delay))))
  
  (defmacro forcing (dependencies &body body)
    (labels ((dep-name (spec) (etypecase spec (cons (first spec)) (symbol spec)))
             (dep-expr (spec) (etypecase spec (cons (second spec)) (symbol spec)))
             (dep-description (spec)
               (etypecase spec
                 (cons (or (third spec) (princ-to-string (dep-name spec))))
                 (symbol (princ-to-string spec)))))
      `((lambda ,(mapcar #'dep-name dependencies) ,@body)
        ,@(loop for dep in dependencies
                collect `(force ,(dep-expr dep) ,(dep-description dep))))))
  
  (defmacro delay (dependencies &body body)
    (let ((name (second (find-if (lambda (x) (and (consp x) (eql :name (first x)))) dependencies))))
      (setf dependencies (remove-if (lambda (x) (and (consp x) (eql :name (first x)))) dependencies))
      `(force
        (make-delay :name ,name :fun (lambda () (forcing ,dependencies ,@body)))
        nil)))
  
  ;;;; Utilities
  
  (defgeneric msb (x)
    (:method ((x integer)) (ldb (byte 8 8) x))
    (:method ((value delay))
      (delay ((:name "MSB") value)
        (msb value))))
  
  (defgeneric lsb (x)
    (:method ((x integer)) (ldb (byte 8 0) x))
    (:method ((value delay))
      (delay ((:name "LSB") value)
        (lsb value))))
  
  (defun 8-bit-encodable (x)
    (etypecase x
      ((integer -128 255) x)))
  
  (defun encode-byte (byte &optional (name "byte"))
    (vector (delay ((:name name) byte) (lsb (8-bit-encodable byte)))))
  
  (defun encode-signed-byte (x &optional (name "signed-byte"))
    (vector (delay ((:name name) x)
              (unless (and (>= x -128) (<= x 127))
                (error "Signed byte out of range"))
              (lsb x))))
  
  (defun 16-bit-encodable (x)
    (if (and (integerp x)
  	   (>= x 0)
  	   (< x 65536))
        x
        (error "Operand ~A cannot be encoded as a 16-bit operand." x)))
  
  (defun encode-word (word &optional (name "encode"))
    (vector (delay ((:name (format nil "~A LSB" name)) word) (lsb word))
            (delay ((:name (format nil "~A MSB" name)) word) (msb word))))
  
  (defun join-masks (x y)
    (unless (zerop (logand x y))
  
negative.code: ;;;; Delayed evaluation
  
  (defvar *lazy-marker* '#:postponed)
  (defstruct promise name fun (value *lazy-marker*))
  
  (define-condition resolvable-condition ()
    ((path :initform nil :initarg :path :accessor path))
    (:report (lambda (condition stream)
               (format stream "~A" (path condition)))))
  
  (defgeneric force (expression &optional force-p)
    (:documentation "Forces computing the value of a delayed expression"))
  