anchor.diff:  (define-server-command ping (irc from message)
     (buffered-format (irc-connection irc) "PONG :~A~%" message))
   
  +(defun parse-origin (origin)
  +  "Return the nick, ident and host parts of a nick!ident@host name.
  +If ORIGIN is a server name, then only the host is valid. Nick and ident will be false."
  +  (let ((bang (position #\! origin))
  +        (at (position #\@ origin)))
  +    (cond ((and bang at)
  +           (values (subseq origin 0 bang)
  +                   (subseq origin (1+ bang) at)
  +                   (subseq origin (1+ at))))
  +          ((and (not bang) (not at))
  +           (values nil
  +                   nil
  +                   origin))
  +          (t (error "Unknown origin form ~S" origin)))))
  +
  +(define-server-command nick (irc from message)
  +  (multiple-value-bind (nick ident host)
  +      (parse-origin from)
  +    (cond ((and nick ident
  +                (string= nick (nickname irc)))
  +           (format (display-pane irc) "~&-!- Nickname changed to ~A." message)
  +           (setf (nickname irc) message))
  +          ((and nick ident)
  +           (format (display-pane irc) "~&-!- ~A is now known as ~A." nick message))
  +          (t (format (display-pane irc) "~&:~A NICK ~A" from message)))))
  +
   (defvar *known-servers*
     '((:freenode "chat.freenode.net" 6667))
     "A list of known/named IRC servers.")
  
positive.code:          (mezzanine.supervisor:fifo-push (make-instance 'server-line-event :line line) fifo)))))
  
  (defvar *top-level-commands* (make-hash-table :test 'equal))
  
  (defmacro define-command (name (irc text) &body body)
    `(setf (gethash ',(string-upcase (string name))
                    *top-level-commands*)
           (lambda (,irc ,text)
             (declare (system:lambda-name (irc-command ,name)))
             ,@body)))
  
  (define-command quit (irc text)
    (when (irc-connection irc)
      (buffered-format (irc-connection irc) "QUIT :~A~%" text))
    (throw 'quit nil))
  
  (define-command raw (irc text)
    (when (irc-connection irc)
      (write-string text (irc-connection irc))
      (terpri (irc-connection irc))))
  
  (define-command eval (irc text)
    (let ((*standard-output* (display-pane irc)))
      (format t "~&[eval] ~A~%" text)
      (eval (read-from-string text))
      (fresh-line)))
  
  (define-command say (irc text)
    (cond ((and (irc-connection irc) (current-channel irc))
           (format (display-pane irc) "~&[~A]<~A> ~A" (current-channel irc) (nickname irc) text)
           (buffered-format (irc-connection irc) "PRIVMSG ~A :~A~%"
  
negative.code:                (write-char ch (input-pane irc)))))))
  
  (defmethod dispatch-event (irc (event server-disconnect-event))
    (format (display-pane irc) "~&Disconnected from server.")
    (close (irc-connection irc))
    (setf (irc-connection irc) nil
          (receive-thread irc) nil)
    (setf (mezzanine.gui.widgets:frame-title (frame irc)) (format nil "IRC"))
    (mezzanine.gui.widgets:draw-frame (frame irc))
    (mezzanine.gui.compositor:damage-window (window irc)
                                            0 0
                                            (mezzanine.gui.compositor:width (window irc))
                                            (mezzanine.gui.compositor:height (window irc))))
  
  (defmethod dispatch-event (irc (event server-line-event))
    (let ((line (line event)))
  