anchor.diff:  
   (in-package #:log5)
   
  +(defgeneric update-active-categories (sender maximum-id))
  +
  +(defgeneric create-handle-message-context (sender))
  +
  +(defgeneric start-handling (sender))
  +
  +(defgeneric finish-handling (sender))
  +
  +(defgeneric separate-properties (sender))
  +
  +(defgeneric close-sender (sender))
  +
  +(defgeneric handle-output (sender output))
  +
   (defparameter *default-logical-connective* 'or)
   
   (defvar *log-manager* nil)
  
positive.code: 	  new-array)
      sender))
  
  (defun sender-responds-to-category-p (sender-spec category-spec)
    (let* ((cat-positive (category-variables category-spec))
  	 (cat-negative (category-negated-variables category-spec))
  	 (sender-variables (determine-category-variables sender-spec))
  	 (sender-free (remove-if (lambda (x)
  				   (or (member x cat-positive)
  				       (member x cat-negative)))
  				 sender-variables)))
      (progv cat-positive (make-list (length cat-positive)
  				   :initial-element t) 
        (progv cat-negative (make-list (length cat-negative)
  				     :initial-element nil)
  	(progv sender-free (make-list (length sender-free)
  				      :initial-element nil)
  ;	  (print sender-spec)
  ;	  (print cat-positive)
  ;	  (print cat-negative)
  ;	  (print sender-free)
  	  (eval sender-spec))))))
  
  (defun build-handle-message-fn (sender)
    `(lambda (category-id sender message)
       (let (,@(create-handle-message-context sender))
         (unwind-protect
  	    (progn
  	      ,@(start-handling sender) 
  	      ,@(loop for name in (output-spec sender) 
  		   for output = (valid-output-p name) 
  		   for first? = t then nil
  		   unless output do (error 'output-not-found-error :name name)
  		   unless first? collect (separate-properties sender)
  		   when output collect 
  		   (handle-output sender output)))
  	 ,@(finish-handling sender)))))
  
  (defun valid-output-p (name)
    (or (predefined-output-p name)
  
negative.code: 
  (defmacro stop-sender (name)
    "Find the sender named `name` and stop it."
    `(progn (stop-sender-fn ',name) nil))
  
  (defun stop-sender-fn (name &key (warn-if-not-found-p t))
    (let ((sender (find name (log5-senders (log-manager)) 
  		      :key #'name))) 	
      (cond (sender
  