anchor.diff:  	    (effective-log-level (logger-parent logger))))))
   
   (defun have-appenders-for-level (logger level)
  -  "Return non-NIL if logging with LEVEL will actually
  -reach any appenders"
  +  "Return non-NIL if logging with LEVEL will actually reach any
  +appenders"
     (declare (type logger logger) (type fixnum level))
     ;; Note: below code actually walk parent chain twice but since its
     ;; cached anyway, don't optimize unless becomes a problem
  
positive.code: ;;; logging-macros.lisp had not yet complied.
  ;;;
  ;;; So any code that uses self-logging to log4cl:self logger, needs to be
  ;;; in the files that are later in the .asd 
  (in-package :log4cl)
  
  #+sbcl (declaim (sb-ext:always-bound
                   *log-indent*
                   *ndc-context* *log-event-time*
                   *inside-user-log-function*))
  
  (declaim (special *root-logger*)
           (type logger *root-logger*)
  	 (type fixnum *log-indent*)
           (inline is-enabled-for current-state 
                   log-level-to-string
                   log-event-time))
  
  (defstruct logger-state
    "Structure containng logger internal state"
    ;; list of appenders attached to this logger
    (appenders nil :type list)
    ;; explicit log level for this logger if its set
    (level nil :type (or null fixnum))
    ;; If true then log level and appenders are inherited from
    ;; parent logger
    (additivity t :type boolean)
    ;; performance hack, for each log level we set a bit in mask, if a
    ;; log message with said level will reach any appenders either in
    ;; this logger or it's parents
    ;;
    ;; update-logger-mask function recalculates this value for parent
    ;; and child loggers
    (mask 0 :type fixnum))
  
  (defstruct (logger (:constructor create-logger)
                     (:print-function 
                      (lambda  (logger stream depth)
                        (declare (ignore depth))
                        (let ((*print-circle* nil))
                          (print-unreadable-object (logger stream)
                            (princ "LOGGER " stream)
                            (princ (if (logger-parent logger) (logger-category logger)
                                       "+ROOT+") stream))))))
    ;; Full category name as in parent.sub-parent.thislogger
    (category  nil :type string)
    ;; Logger's native category separator string
    (category-separator nil :type string)
    ;; position of the 1st character of this logger name in full
    ;; category name
    (name-start-pos 0 :type fixnum)
    ;; parent logger, only nil for the root logger
    (parent    nil :type (or null logger))
    ;; How many parents up and including the root logger this logger has
    (depth     0   :type fixnum)
    ;; child loggers
    (children  nil :type (or null hash-table))
    ;; per-hierarchy configuration
    (state (map-into (make-array *hierarchy-max*) #'make-logger-state)
     :type (simple-array logger-state *)))
  
  
negative.code: 
  (defun map-logger-children (function logger)
    "Apply the function to all of logger's children (but not their
  descendants)"
    (let ((child-hash (logger-children logger)))
      (when child-hash
        (maphash (lambda (name logger)
  