anchor.diff:  ;;; symbol ERROR so that we can reach the ERROR function. 
   (defparameter *linkage-error-instructions*
     `((halt)))
  +
  +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  +;;;
  +;;; Host function.
  +;;;
  +;;; The great cheat object.
  +
  +(defparameter *host-functions* (make-hash-table))
  +
  +(defparameter *next-available-host-function-number* 0)
  +
  +(defunbound *class-host-function*)
  +
  +;;; SYMBOL will be a host symbol to be translated to a target
  +;;; symbol.  
  +(defun define-host-function (function-or-host-symbol symbol)
  +  (let ((fun (if (symbolp function-or-host-symbol)
  +		 (symbol-function function-or-host-symbol)
  +		 function-or-host-symbol))
  +	(target-sym (object-from-host-object symbol)))
  +    (setf (gethash *next-available-host-function-number* *host-functions*)
  +	  fun)
  +    (let ((slot-vector (malloc-words 2)))
  +      (memset (+ slot-vector (* 0 +word-size-in-bytes+))
  +	      +unbound+)
  +      (memset (+ slot-vector (* 1 +word-size-in-bytes+))
  +	      *next-available-host-function-number*)
  +      (let ((host-function (malloc-words 2)))
  +	(memset (+ host-function (* 0 +word-size-in-bytes+))
  +		*class-host-function*)
  +	(memset (+ host-function (* 1 +word-size-in-bytes+))
  +		slot-vector)
  +	(setf (scl:symbol-function target-sym)
  +	      host-function))))
  +  (incf *next-available-host-function-number*))
  +
  +(defop call-host-function (host-function) (host-function) ()
  +  (let* ((untagged (remove-tag host-function))
  +	 (slot-vector (memref (+ untagged (* 1 +word-size-in-bytes+))))
  +	 (function-number (memref (+ slot-vector (* 1 +word-size-in-bytes+))))
  +	 (fun (gethash function-number *host-functions*))
  +	 (args (loop for i from 0 below *number-of-arguments*
  +		     collect (aref *arguments* i)))
  +	 (results (multiple-value-list (apply fun args))))
  +    (loop for val in results
  +	  for i from 0
  +	  do (setf (aref *arguments* i) val))
  +    (setf *number-of-arguments* (length results))))
  +
  +(defunbound *linkage-host-function*)
  +
  +;;; Linkage code for host functions.  
  +(defparameter *linkage-host-function-instructions*
  +  `((call-host-function)
  +    (link-return)))
  +    
  +(defun init-host-functions ()
  +  (setf *host-functions* (make-hash-table))
  +  (setf *next-available-host-function-number* 0)
  +  (setunbound *linkage-host-function* (malloc-words 100))
  +  (setunbound *class-host-function*
  +	      (make-skeleton-class *linkage-host-function*))
  +  (fill-linkage *linkage-host-function-instructions*
  +		*linkage-host-function*))
  +
  +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  +;;;
  +;;; Test of host functions.
  +
  +(defun target-print (thing)
  +  (format t "printing-target-value: ~s~%" thing))
   
   ;;; The problem this function solves is the following: Before we
   ;;; started allocating target data objects on the heap, we needed the
  
positive.code: 		sicl-system:*linkage-error*)
    (make-rudimentary-setf-fdefinition)
    (make-rudimentary-funcall)
    )
    
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
negative.code:     (jump)                            ; CL ---
      ))
  
  ;;; Linkage code for symbols.  Find the contents of the
  ;;; symbol-function slot of the symbol and then the linkage code of
  ;;; the object contained therein, and finally, jump to that linkage
  ;;; code, supposedly that of a function. 
  (defparameter *linkage-symbol-instructions*
    '(                                  ; Sym ---
      ;; Find the slot vector.
  