anchor.diff:                                  :write (lambda (fd event exception)
                                            (declare (ignore fd event exception))
                                            (try-write-client client)))
  -                (setf (client-writer-active client) t))))
  +                #++(setf (client-writer-active client) t))))
          (handler-case
              (loop
                 unless (client-write-buffer client)
  
positive.code:            (client-disconnect client :close t)))))))
  
  (defmethod client-enable-handler ((client client) &key read write error)
    #++
    (lg "enable handlers for ~s:~s ~s ~s ~s~%"
        (client-host client) (client-port client) read write error)
    (when (and (not (client-socket-closed client))
  
negative.code:                  (not (client-writer-active client))
                   (not (client-write-closed client)))
          (try-write-client client))
        (when read (format t "enable read ~s ~s ~s~%"
                           fd
                           (client-reader-active client)
                           (client-read-closed client)))
        (when (and read
                   (not (client-reader-active client))
                   (not (client-read-closed client)))
          (set-io-handler *event-base* fd :read (client-reader client))
          #++(setf (client-reader-active client) t))
  
        (when (and error (not (client-error-active client)))
          (error "error handlers not implemented yet...")))))
  
  (defmethod client-disable-handler ((client client) &key read write error)
    (lg "disable handlers for ~s:~s ~s ~s ~s~%"
        (client-host client) (client-port client) read write error)
    (let ((fd (socket-os-fd (client-socket client))))
      (when (and write (client-writer-active client))
        (remove-fd-handlers *event-base* fd :write t)
        #++(setf (client-writer-active client) nil))
        (when read (format t "disable read ~s ~s ~s~%"
                           fd
                           (client-reader-active client)
                           (client-read-closed client)))
      (when (and read (client-reader-active client))
        (remove-fd-handlers *event-base* fd :read t)
        #++(setf (client-reader-active client) nil))
      (when (and error (client-error-active client))
        (error "error handlers not implemented yet..."))))
  
  