anchor.diff:    pos
     (funstack     nil)
     (stack        (make-array 16384))
  -  (stack-pos    16384))
  +  (stack-pos    16384)
  +  (interrupt    nil))
   
   (defun trecode-fetch (tc)
     (prog1
  
positive.code: (defun trecode-pop-fun (tc)
    (pop (trecode-funstack tc)))
  
  (defun trecode-call (tc fun args)
    (| (function? fun)
       (macro? fun)
       (error "Function expexted instead of ~A." fun))
    (| (function-bytecode fun)
       (error "Function ~A has no bytecode." fun))
    (tc-push-many tc args)
    (let bytecode (function-bytecode fun)
      (| (array? bytecode)
         (error "Bytecode for ~A is not an array." fun))
      (let num-locals (aref bytecode 2)
        (= (trecode-fun tc) bytecode)
        (adotimes num-locals
          (trecode-push tc nil))
        (trecode-push-fun tc fun args num-locals))))
  
  (defun trecode-return (tc)
    (alet (trecode-pop-fun tc)
      (tc-pop (+ (length .!.) ..!))))
  
negative.code: (defun trecode-exec-set-vec (tc)
      (= (aref (trecode-get tc) (trecode-get tc)) (trecode-get tc)))
  
  (defun trecode-exec-set-place (tc value place)
    (?
      (number? place) (trecode-set-stack tc place value)
      (= (symbol-value place) value)))
  
  (defun trecode-exec-set (tc)
    (trecode-exec-set-place tc (trecode-get tc) (trecode-get tc)))
  
  (defun trecode-exec (tc)
      (loop
        (awhen (trecode-interrupt tc)
          (& (funcall ! tc)
             (return)))
        (case (trecode-fetch tc) :test #'eq
          '%%go      (| (trecode-exec-cond tc)
                        (return))
          '%%go-nil  (trecode-exec-jump tc)
          '%%set-vec (trecode-exec-set-vec tc)
          (trecode-exec-set tc))))
  
  (defun trecode-push-fun (tc fun args num-locals)
    (push (cons fun (cons args num-locals)) (trecode-funstack tc)))
  