anchor.diff:    (with-slots (callbacks) self
       (let ((destination (get-destination frame)))
         (loop 
  -	 :for (dest func) :in callbacks
  -	 :do (if (string= dest destination)
  -		 (funcall func frame))))))
  +         :for (dest func) :in callbacks
  +         :do (if (string= dest destination)
  +                 (funcall func frame))))))
     
   (defmethod receive ((self stomp-connection))
     "Called whenever there's activity on the file descriptor."
     (with-slots (socket fd handler callbacks) self
       (let ((str (sb-sys:make-fd-stream fd :input t :element-type '(unsigned-byte 8)
  -				      :buffering :full)))
  +                                      :buffering :full)))
         (let ((buffer (loop 
  -		       :for b = (read-byte str nil 'eof)
  -		       :while (listen str)
  -		       :collect b)))
  -
  -	(if (> (length buffer) 0)
  -
  -	    ;; if we got something, send it to all the
  -	    ;; registered callbacks
  -
  -	    (let ((frame (make-frame (string-from-bytes buffer))))
  -	      (apply-callbacks self frame))
  -
  -	    ;; otherwise, it means the other end has terminated,
  -	    ;; so close things down (eventually go into a sleep/wait
  -	    ;; loop in case of reconnection
  -
  -	    (handler-case
  -		(progn
  -		  (log-debug "nothing to read from socket~%")
  -		  (disconnect self)
  -		  (sb-sys:remove-fd-handler handler)
  - 		  (sk-close socket))
  -	      (condition (c)
  -		(log-debug "close: ~a" c))))))))
  +                       :for b = (read-byte str nil 'eof)
  +                       :while (listen str)
  +                       :collect b)))
  +
  +        (if (> (length buffer) 0)
  +
  +            ;; if we got something, send it to all the
  +            ;; registered callbacks
  +
  +            (let ((frame (make-frame (string-from-bytes buffer))))
  +              (apply-callbacks self frame))
  +
  +            ;; otherwise, it means the other end has terminated,
  +            ;; so close things down (eventually go into a sleep/wait
  +            ;; loop in case of reconnection
  +
  +            (handler-case
  +                (progn
  +                  (log-debug "nothing to read from socket~%")
  +                  (disconnect self)
  +                  (sb-sys:remove-fd-handler handler)
  +                  (sk-close socket))
  +              (condition (c)
  +                (log-debug "close: ~a" c))))))))
   
   (defmethod register ((self stomp-connection) callback destination)
     (with-slots (callbacks) self
  
positive.code:   (let ((result ()))
      (with-input-from-string (stream string)
        (loop 
  	 :for line = (read-line stream nil 'eof)
  	 :while (not (eql line 'eof))
  	 :do (setf result (pushnew line result))))
      (nreverse result)))
  
  (defun string-contains (string str-or-char-list)
  
negative.code:       ;; open the socket and send the connect string
  
        (with-slots (host port ip socket fd handler) self
          (setf ip (ip-addr-of host))
          (setf socket (sk-make))
          (sk-connect socket ip port)
          (setf fd (sk-file-desc socket))
          (setf handler (sb-sys:add-fd-handler fd :input (lambda (x)
                                                           (declare (ignore x))
                                                           (receive self))))
          (let ((frame (make-instance 'frame :name "CONNECT")))
            (if user
                (set-header frame "login" user))
            (if pass
                (set-header frame "passcode" pass))
            (send self frame)))
  
      ;; just log the error for now
  
  