anchor.diff:    "Save CNF logging configuration into *CONFIGURATIONS* list,
   overwriting the previous one by the same name."
     (declare (logging-configuration cnf))
  +  (let ((old (find (name-of cnf) *configurations* :key #'name-of :test #'equal)))
  +    ;; only keep configuration with the same name if they are different
  +    (when (and old (logging-configuration= old cnf))
  +      (setq *configurations* (remove old *configurations*))))
     (push cnf *configurations*)
     (trim-configuration-list '*configurations*)
     (when *save-configurations-to-file*
  
positive.code:           (elements-of cnf))
      (adjust-logger root)))
  
  (defun restore (&optional (configuration nil confp))
    "Restore logging configuration CONFIGURATION, which can be a name,
  or LOGGING-CONFIGURATION instance. Before restoring the configuration,
  the current logging configuration is automatically saved under the
  name \"Autosave <timestamp>\".
  
  If CONFIGURATION is NIL restores first element of *CONFIGURATIONS*, which is the last
  saved configuration."
    (when (and (null *configurations*)
               (probe-file (merge-pathnames *configurations-file*
                                            (user-homedir-pathname))))
      (setq *configurations* (read-configurations-from-file)))
    (setq configuration
          (or configuration (first *configurations*) 
              (error "There were no previously saved configurations")))
    (let* ((cnf (if (typep configuration 'logging-configuration) configuration
                    (find configuration *configurations* :key #'name-of :test #'equal))))
      (or cnf (error "Logging configuration ~S not found in ~S"
                     configuration '*configurations*))
      (let ((save (make-instance 'logging-configuration
                   :name (with-output-to-string (s)
                           (format-time s "Autosave on %Y-%m-%d %H:%M:%S"
                                        (get-universal-time) nil)))))
        (setf *configurations* (remove cnf *configurations*))
        (push cnf *configurations*)
        (push save *configurations*)
        (when confp
          (rotatef (first *configurations*) (second *configurations*)))
        (trim-configuration-list '*configurations*)
        (apply-logging-configuration cnf)
        (when *save-configurations-to-file*
          (save-configurations-to-file))
        (first *configurations*))))
  
  (defun trim-configuration-list (&optional (var '*configurations*))
    "Trim the list in global variable VAR to at most
  
negative.code: 
  (defvar *configurations-file* ".log4cl-configurations.lisp-expr")
  
  (defun logging-configuration= (c1 c2)
    "Compare two logging configurations and return T if they have
  exactly same loggers and levels"
    (declare (logging-configuration c1 c2))
    (or (eq c1 c2)
        (not (flet ((test (e1 e2) 
                      (and (eq (logger-of e1) (logger-of e2))
                           (eq (level-of e1) (level-of e2)))))
               (set-exclusive-or (elements-of c1) (elements-of c2) :test #'test)))))
  
  (defmacro save (&optional name (scope *default-logging-configuration-scope*))
    "Save current logging configuration into *CONFIGURATIONS* list
  
  