anchor.diff:          original-method)))
   
   (defun setup-parser (sock)
  -  "Setup a parser on a socket. This can be called multiple times on the same
  -   socket (usually at the end of a request) so that if another request comes in
  -   on the same connect, we'll have reset state =]"
  +  "This is the main parser function. It's responsible for listening to a socket,
  +   setting up an HTTP parser for it, handling the different events/callbacks the
  +   HTTP parser throws at it, dispatching routes, handling body chunking, etc. A
  +   lot of this is done via shared state which all lives under this function's
  +   top-level (let) form, and a set of local functions which read/modify this
  +   shared state.
  +
  +   This function is at the core of Wookie's being.
  +
  +   Note that setup-parser can be called multiple times on the same socket. The
  +   only reason to do this is if a request/response has come and gone on the
  +   socket and you wish to make the socket available for another request. Wookie
  +   handles all of this automatically."
     (let* ((http (make-instance 'http-parse:http-request))
            (route-path nil)
            (route nil)  ; holds the current route, filled in below once we get headers
  
positive.code:                    (setf error-occurred-p t)
                     (main-event-handler e sock))))
               (body-callback (chunk finishedp)
                 (when error-occurred-p
                   (return-from body-callback))
                 ;; forward the chunk to the callback provided in the chunk-enabled
  
negative.code:          (body-finished-p nil))
      (setf (as:socket-data sock) (list :request request :response response))
      (labels ((dispatch-route ()
                 "Dispatch the route under `route`. This not only handles calling
                  the route's main function, but also handles use-next-route
                  conditions and setting up intricate logic for resilient body
                  chunking. It also runs the :pre-route and :post-route hooks."
                 ;; dispatch the current route, but only if we haven't already done so
                 (when route-dispatched
                   (return-from dispatch-route))
  