anchor.diff:      (when self
         ;; This is special adhoc case of configuring the LOG4CL:SELF
         (let ((config (cons :own
  -                          (remove-if (lambda (x) (member x '(:own :self)))
  +                          ;; we don't remember these
  +                          (remove-if (lambda (x)
  +                                       (member x '(:own :self :clear :all)))
                                        orig-args))))
           ;; if specified new appenders, simply remember new configuration
           (if (or sane daily) (setq *self-log-config* config)
  
positive.code:     ;; finally recalculate reach-ability
      (adjust-logger logger)))
  
  
  
  (defun loggers-from-string (regexp)
    (let ((regexp (create-scanner regexp :case-insensitive-mode t))
          loggers)
      (labels ((doit (logger)
                 (when (scan regexp (logger-category logger))
                   (push logger loggers))
                 (map-logger-children #'doit logger)))
        (doit *root-logger*))
      (nreverse loggers)))
  
  
  
negative.code:            (setq logger (get-logger-internal
                           (pop args)
                           (naming-option *package* :category-separator)
                           (naming-option *package* :category-case))))
            ((member :self args)
             (setq logger (make-logger '(log4cl self))
                   self t)
             (setq args (remove :self args))))
      (setq logger (or logger *root-logger*))
      (unless (setq orig-args args)
        (return-from log-config (show-logger-settings logger)))
      (loop
        (let ((arg (or (pop args) (return))))
          (case arg
            (:self ; still in the arglist means 1st arg was a logger
             (log4cl-error "Specifying a logger is incompatible with :SELF"))
            (:sane (setq sane t))
            (:clear (setq clear t))
            (:all (setq all t))
  