anchor.diff:    (check-type name (or package string-designator))
     (if (packagep name)
         name
  -      (cdr (assoc (string name) *package-list* :test 'string=))))
  +      (with-package-system-lock ()
  +        (cdr (assoc (string name) *package-list* :test 'string=)))))
   
   (defun find-global-package-or-die (name)
     (or (find-global-package name)
  
positive.code:   (package-%locally-nicknamed-by-list (find-package-or-die package)))
  
  (defun add-package-local-nickname (local-nickname actual-package &optional (package *package*))
    (let ((local-nickname (string local-nickname))
          (actual-package (find-global-package-or-die actual-package)))
      (when (member local-nickname '("CL" "COMMON-LISP" "KEYWORD") :test #'string=)
        (error "New package local nickname ~S conflicts with standard CL package." local-nickname))
      (let ((existing (assoc local-nickname (package-local-nicknames package) :test #'string=)))
        (cond ((not existing)
               (push (cons local-nickname actual-package) (package-%local-nickname-list package))
               (pushnew package (package-%locally-nicknamed-by-list actual-package)))
              ((not (eql actual-package (cdr existing)))
               (cerror "Replace it" "New local nickname ~S for package ~S conflicts with existing nickname for package ~S."
                       local-nickname actual-package (cdr existing))
               (remove-package-local-nickname local-nickname package)
               (push (cons local-nickname actual-package) (package-%local-nickname-list package))
               (pushnew package (package-%locally-nicknamed-by-list actual-package))))))
    package)
  
  (defun remove-package-local-nickname (local-nickname &optional (package *package*))
    (let* ((existing (assoc local-nickname (package-%local-nickname-list package) :test #'string=)))
      (when existing
        (let ((other-package (cdr existing)))
          (setf (package-%local-nickname-list package) (remove local-nickname (package-%local-nickname-list package)
                                                               :test #'string= :key #'car))
          (when (zerop (count other-package (package-%local-nickname-list package)
                              :key #'cdr))
            (setf (package-%locally-nicknamed-by-list other-package) (remove package (package-%locally-nicknamed-by-list other-package)))))
        t)))
  
  (defun initialize-package-system ()
    (write-line "Initializing package system.")
    ;; Create the core packages.
    (setf *package-list* '())
    (setf *keyword-package* (make-package "KEYWORD"))
    (make-package "COMMON-LISP" :nicknames '("CL"))
    (make-package "COMMON-LISP-USER" :nicknames '("CL-USER") :use '("CL"))
    (setf *package* (make-package "MEZZANO.INTERNALS" :use '("CL")))
    ;; Now import all the symbols.
    (dotimes (i (length *initial-obarray*))
      (let ((sym (aref *initial-obarray* i)))
        (let* ((package-keyword (symbol-package sym))
               (package (find-package (string package-keyword))))
          (when (not package)
            (setf package (make-package (string package-keyword) :use '("CL"))))
          (setf (symbol-package sym) nil)
          (import-one-symbol sym package)
          (when (member package-keyword '(:common-lisp :keyword))
            (export-one-symbol sym package)))))
    (values))
  
negative.code:   (package-%shadowing-symbols (find-package-or-die package)))
  
  (defun list-all-packages ()
    (with-package-system-lock ()
      (remove-duplicates (mapcar 'cdr *package-list*))))
  
  (defmacro in-package (name)
    `(eval-when (:compile-toplevel :load-toplevel :execute)
  