anchor.diff:           (error "TODO: character peek."))
           (t (error "Bad peek type ~S." peek-type))))
   
  +(defun backtrace (&optional limit)
  +  (do ((i 0 (1+ i))
  +       (fp (read-frame-pointer)
  +           (memref-unsigned-byte-64 fp 0)))
  +      ((or (and limit (> i limit))
  +           (= fp 0)))
  +    (write-char #\Newline)
  +    (write-integer fp 16)
  +    (write-char #\Space)
  +    (let* ((fn (memref-t fp -2))
  +           (name (when (functionp fn) (function-name fn))))
  +      (write-integer (lisp-object-address fn) 16)
  +      (when name
  +        (write-char #\Space)
  +        (write name)))))
  +
   (defun raise-undefined-function (invoked-through &rest args)
     (declare (ignore args))
     (write-char #\!)
     (write-char #\#)
     (when (symbolp invoked-through)
       (write-string (symbol-name invoked-through)))
  +  (backtrace)
     (loop (%hlt)))
   
   (defun raise-unbound-error (symbol)
     (write-char #\!)
     (write-char #\*)
     (write-string (symbol-name symbol))
  +  (backtrace)
     (loop (%hlt)))
   
   (defun raise-type-error (datum expected-type)
  
positive.code:                                     'base-char
                                      'character)
                    :initial-contents string)))
  
  (declaim (special * ** ***))
  
  
negative.code:       (when (string= name (symbol-name (aref pkg i)))
          (return (values (aref pkg i) :internal))))))
  
  (defun %defpackage (&rest args)
    (declare (ignore args)))
  
  (defun export (&rest args)
    (declare (ignore args)))
  
  ;;; The compiler can only handle (apply function arg-list).
  (defun apply (function arg &rest more-args)
    (declare (dynamic-extent more-args))
    (cond (more-args
           ;; Convert (... (final-list ...)) to (... final-list...)
           (do* ((arg-list (cons arg more-args))
                 (i arg-list (cdr i)))
                ((null (cddr i))
                 (setf (cdr i) (cadr i))
                 (apply function arg-list))))
          (t (apply function arg))))
  
  ;;; TODO: This requires a considerably more flexible mechanism.
  ;;; 12 is where the TLS slots in a stack group start.
  (defparameter *next-symbol-tls-slot* 12)
  