anchor.diff:    (declare (type multi-buffer buffer)
              (type fixnum n))
     (incf (multi-buffer-index buffer) n))
  +
  +(defun n-buffer-backward (buffer n)
  +  "moves the buffer n characters backward"
  +  (declare (type multi-buffer buffer)
  +           (type fixnum n))
  +  (decf (multi-buffer-index buffer) n))
   
   (defun buffer-unused-available-content (buffer)
     "yields all content in the buffer which is after the current index"
  
positive.code:                                                                        (stage-func :error))) ; we can't reach this, forward-buffer-while-not must have read all parts of the buffer we've used so far
                                      nil)
                                (header-info-headers header-info))
                          (call-stage :read-header-value-init))
    (:read-header-value-init (buffer-forward buffer) ; forward the #\:
                             (mark-buffer buffer)
                             (call-stage :read-header-value))
    (:read-header-value (forward-buffer-below buffer
                                              :elements #.(coerce #(#\Return #\Linefeed) 'simple-string)
                                              :not-followed-by #.(coerce #(#\Space #\Tab) 'simple-string)
                                              :restart-callback (stage-func :read-header-value))
                        (setf (cdr (first (header-info-headers header-info)))
                              (copy-marked-region buffer
                                                  (stage-func :error)))
                        (n-buffer-forward buffer
                                          3)
                        (call-stage :init))
    (:end-header-parsing (values T
                                 header-info
                                 (buffer-unused-available-content buffer)))
  
negative.code:           (t tree))))
  
  (defmacro define-parser-stages ((parser-state-var header-info-var buffer-var) name &rest stages)
    ;; (setf stages
    ;;       (loop for stage in stages
    ;;          collect `(,(first stage)
    ;;                     (break "entering stage ~A" ,(first stage))
    ;;                     ,@(rest stage))))
    (let ((expanded-stages nil))
      (loop for stage in (reverse stages)
         do (loop for es in expanded-stages ;; does this direction induce continuously expanded stages? (it should be irrelevant, yet still)
  