From d437c0f67ff102acce320c282f29977cb81e6a5a Mon Sep 17 00:00:00 2001
From: Raymond Toy <toy.raymond@gmail.com>
Date: Sat, 9 Jan 2016 01:27:53 -0800
Subject: [PATCH] Update to asdf 3.1.6.9 to get one fix for cmucl.

---
 src/contrib/asdf/asdf.lisp     | 525 ++++++++++++++-------------------
 src/contrib/asdf/doc/asdf.html |   8 +-
 src/contrib/asdf/doc/asdf.info | 268 ++++++++---------
 src/contrib/asdf/doc/asdf.pdf  | Bin 498198 -> 498375 bytes
 4 files changed, 353 insertions(+), 448 deletions(-)

diff --git a/src/contrib/asdf/asdf.lisp b/src/contrib/asdf/asdf.lisp
index b4b80ca3d..85f9fdd0f 100644
--- a/src/contrib/asdf/asdf.lisp
+++ b/src/contrib/asdf/asdf.lisp
@@ -1,5 +1,5 @@
-;;; -*- mode: Common-Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; buffer-read-only: t; -*-
-;;; This is ASDF 3.1.6: Another System Definition Facility.
+;;; -*- mode: Lisp; Base: 10 ; Syntax: ANSI-Common-Lisp ; buffer-read-only: t; -*-
+;;; This is ASDF 3.1.6.9: Another System Definition Facility.
 ;;;
 ;;; Feedback, bug reports, and patches are all welcome:
 ;;; please mail to <asdf-devel@common-lisp.net>.
@@ -46,43 +46,6 @@
 ;;; we can't use defsystem to compile it.  Hence, all in one file.
 
 #+xcvb (module ())
-
-(in-package :cl-user)
-
-#+cmu
-(eval-when (:load-toplevel :compile-toplevel :execute)
-  (setf ext:*gc-verbose* nil))
-
-;;; pre 1.3.0 ABCL versions do not support the bundle-op on Mac OS X
-#+abcl
-(eval-when (:load-toplevel :compile-toplevel :execute)
-  (unless (and (member :darwin *features*)
-               (second (third (sys::arglist 'directory))))
-    (push :abcl-bundle-op-supported *features*)))
-
-;; Punt on hard package upgrade: from ASDF1 always, and even from ASDF2 on most implementations.
-(eval-when (:load-toplevel :compile-toplevel :execute)
-  (unless (member :asdf3 *features*)
-    (let* ((existing-version
-             (when (find-package :asdf)
-               (or (symbol-value (find-symbol (string :*asdf-version*) :asdf))
-                   (let ((ver (symbol-value (find-symbol (string :*asdf-revision*) :asdf))))
-                     (etypecase ver
-                       (string ver)
-                       (cons (format nil "~{~D~^.~}" ver))
-                       (null "1.0"))))))
-           (first-dot (when existing-version (position #\. existing-version)))
-           (second-dot (when first-dot (position #\. existing-version :start (1+ first-dot))))
-           (existing-major-minor (subseq existing-version 0 second-dot))
-           (existing-version-number (and existing-version (read-from-string existing-major-minor)))
-           (away (format nil "~A-~A" :asdf existing-version)))
-      (when (and existing-version
-                 (< existing-version-number
-                    #+(or allegro clisp lispworks sbcl) 2.0
-                    #-(or allegro clisp lispworks sbcl) 2.27))
-        (rename-package :asdf away)
-        (when *load-verbose*
-          (format t "~&; Renamed old ~A package away to ~A~%" :asdf away))))))
 ;;;; ---------------------------------------------------------------------------
 ;;;; Handle ASDF package upgrade, including implementation-dependent magic.
 ;;
@@ -822,19 +785,6 @@ UNINTERN -- Remove symbols here from PACKAGE."
        #+(or clasp ecl gcl mkcl) (defpackage ,package (:use))
        (eval-when (:compile-toplevel :load-toplevel :execute)
          ,ensure-form))))
-
-;;;; Final tricks to keep various implementations happy.
-;; We want most such tricks in common-lisp.lisp,
-;; but these need to be done before the define-package form there,
-;; that we nevertheless want to be the very first form.
-(eval-when (:load-toplevel :compile-toplevel :execute)
-  #+allegro ;; We need to disable autoloading BEFORE any mention of package ASDF.
-  (setf excl::*autoload-package-name-alist*
-        (remove "asdf" excl::*autoload-package-name-alist*
-                :test 'equalp :key 'car)))
-
-;; Compatibility with whoever calls asdf/package
-(define-package :asdf/package (:use :cl :uiop/package) (:reexport :uiop/package))
 ;;;; -------------------------------------------------------------------------
 ;;;; Handle compatibility with multiple implementations.
 ;;; This file is for papering over the deficiencies and peculiarities
@@ -844,10 +794,9 @@ UNINTERN -- Remove symbols here from PACKAGE."
 ;;; from this package only common-lisp symbols are exported.
 
 (uiop/package:define-package :uiop/common-lisp
-  (:nicknames :uoip/cl :asdf/common-lisp :asdf/cl)
+  (:nicknames :uoip/cl)
   (:use :uiop/package)
   (:use-reexport #-genera :common-lisp #+genera :future-common-lisp)
-  (:recycle :uiop/common-lisp :uoip/cl :asdf/common-lisp :asdf/cl :asdf)
   #+allegro (:intern #:*acl-warn-save*)
   #+cormanlisp (:shadow #:user-homedir-pathname)
   #+cormanlisp
@@ -856,10 +805,10 @@ UNINTERN -- Remove symbols here from PACKAGE."
    #:make-broadcast-stream #:file-namestring)
   #+genera (:shadowing-import-from :scl #:boolean)
   #+genera (:export #:boolean #:ensure-directories-exist #:read-sequence #:write-sequence)
-  #+mcl (:shadow #:user-homedir-pathname))
+  #+(or mcl cmucl) (:shadow #:user-homedir-pathname))
 (in-package :uiop/common-lisp)
 
-#-(or abcl allegro clasp clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
+#-(or abcl allegro clasp clisp clozure cmucl cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
 (error "ASDF is not supported on your implementation. Please help us port it.")
 
 ;; (declaim (optimize (speed 1) (debug 3) (safety 3))) ; DON'T: trust implementation defaults.
@@ -867,17 +816,23 @@ UNINTERN -- Remove symbols here from PACKAGE."
 
 ;;;; Early meta-level tweaks
 
-#+(or abcl allegro clasp clisp cmu ecl mkcl clozure lispworks mkcl sbcl scl)
+#+(or allegro clasp clisp cmucl ecl mkcl mkcl sbcl)
 (eval-when (:load-toplevel :compile-toplevel :execute)
-  ;; Check for unicode at runtime, so that a hypothetical FASL compiled with unicode
-  ;; but loaded in a non-unicode setting (e.g. on Allegro) won't tell a lie.
   (when (and #+allegro (member :ics *features*)
-             #+(or clasp clisp cmu ecl mkcl) (member :unicode *features*)
+             #+(or clasp clisp cmucl ecl mkcl) (member :unicode *features*)
              #+sbcl (member :sb-unicode *features*))
+    ;; Check for unicode at runtime, so that a hypothetical FASL compiled with unicode
+    ;; but loaded in a non-unicode setting (e.g. on Allegro) won't tell a lie.
     (pushnew :asdf-unicode *features*)))
 
 #+allegro
 (eval-when (:load-toplevel :compile-toplevel :execute)
+  ;; We need to disable autoloading BEFORE any mention of package ASDF.
+  ;; In particular, there must NOT be a mention of package ASDF in the defpackage of this file
+  ;; or any previous file.
+  (setf excl::*autoload-package-name-alist*
+        (remove "asdf" excl::*autoload-package-name-alist*
+                :test 'equalp :key 'car))
   (defparameter *acl-warn-save*
     (when (boundp 'excl:*warn-on-nested-reader-conditionals*)
       excl:*warn-on-nested-reader-conditionals*))
@@ -901,7 +856,13 @@ UNINTERN -- Remove symbols here from PACKAGE."
              (wait-on-semaphore (external-process-completed proc))))
        (values (external-process-%exit-code proc)
                (external-process-%status proc))))))
-#+clozure (in-package :uiop/common-lisp)
+#+clozure (in-package :uiop/common-lisp) ;; back in this package.
+
+#+cmucl
+(eval-when (:load-toplevel :compile-toplevel :execute)
+  (setf ext:*gc-verbose* nil)
+  (defun user-homedir-pathname ()
+    (first (ext:search-list (cl:user-homedir-pathname)))))
 
 #+cormanlisp
 (eval-when (:load-toplevel :compile-toplevel :execute)
@@ -1035,8 +996,6 @@ Return a string made of the parts not omitted or emitted by FROB."
 ;;;; General Purpose Utilities for ASDF
 
 (uiop/package:define-package :uiop/utility
-  (:nicknames :asdf/utility)
-  (:recycle :uiop/utility :asdf/utility :asdf)
   (:use :uiop/common-lisp :uiop/package)
   ;; import and reexport a few things defined in :uiop/common-lisp
   (:import-from :uiop/common-lisp #:compatfmt #:loop* #:frob-substrings
@@ -1618,11 +1577,11 @@ with later being determined by a lexicographical comparison of minor numbers."
     #+allegro 'excl::format-control
     #+clisp 'system::$format-control
     #+clozure 'ccl::format-control
-    #+(or cmu scl) 'conditions::format-control
+    #+(or cmucl scl) 'conditions::format-control
     #+(or clasp ecl mkcl) 'si::format-control
     #+(or gcl lispworks) 'conditions::format-string
     #+sbcl 'sb-kernel:format-control
-    #-(or abcl allegro clasp clisp clozure cmu ecl gcl lispworks mkcl sbcl scl) nil
+    #-(or abcl allegro clasp clisp clozure cmucl ecl gcl lispworks mkcl sbcl scl) nil
     "Name of the slot for FORMAT-CONTROL in simple-condition")
 
   (defun match-condition-p (x condition)
@@ -1637,7 +1596,7 @@ or a string describing the format-control of a simple-condition."
       (function (funcall x condition))
       (string (and (typep condition 'simple-condition)
                    ;; On SBCL, it's always set and the check triggers a warning
-                   #+(or allegro clozure cmu lispworks scl)
+                   #+(or allegro clozure cmucl lispworks scl)
                    (slot-boundp condition +simple-condition-format-control-slot+)
                    (ignore-errors (equal (simple-condition-format-control condition) x))))))
 
@@ -1659,8 +1618,6 @@ or a string describing the format-control of a simple-condition."
 ;;;; Access to the Operating System
 
 (uiop/package:define-package :uiop/os
-  (:nicknames :asdf/os)
-  (:recycle :uiop/os :asdf/os :asdf)
   (:use :uiop/common-lisp :uiop/package :uiop/utility)
   (:export
    #:featurep #:os-unix-p #:os-macosx-p #:os-windows-p #:os-genera-p #:detect-os ;; features
@@ -1744,7 +1701,7 @@ use getenvp to return NIL in such a case."
     #+(or abcl clasp clisp ecl xcl) (ext:getenv x)
     #+allegro (sys:getenv x)
     #+clozure (ccl:getenv x)
-    #+cmu (unix:unix-getenv x)
+    #+cmucl (unix:unix-getenv x)
     #+scl (cdr (assoc x ext:*environment-list* :test #'string=))
     #+cormanlisp
     (let* ((buffer (ct:malloc 1))
@@ -1765,7 +1722,7 @@ use getenvp to return NIL in such a case."
                 (ccl:%get-cstring value))))
     #+mkcl (#.(or (find-symbol* 'getenv :si nil) (find-symbol* 'getenv :mk-ext nil)) x)
     #+sbcl (sb-ext:posix-getenv x)
-    #-(or abcl allegro clasp clisp clozure cmu cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
+    #-(or abcl allegro clasp clisp clozure cmucl cormanlisp ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
     (error "~S is not supported on your implementation" 'getenv))
 
   (defsetf getenv (x) (val)
@@ -1774,12 +1731,12 @@ use getenvp to return NIL in such a case."
     #+allegro `(setf (sys:getenv ,x) ,val)
     #+clisp `(system::setenv ,x ,val)
     #+clozure `(ccl:setenv ,x ,val)
-    #+cmu `(unix:unix-setenv ,x ,val 1)
+    #+cmucl `(unix:unix-setenv ,x ,val 1)
     #+ecl `(ext:setenv ,x ,val)
     #+lispworks `(hcl:setenv ,x ,val)
     #+mkcl `(mkcl:setenv ,x ,val)
     #+sbcl `(progn (require :sb-posix) (symbol-call :sb-posix :setenv ,x ,val 1))
-    #-(or allegro clisp clozure cmu ecl lispworks mkcl sbcl)
+    #-(or allegro clisp clozure cmucl ecl lispworks mkcl sbcl)
     '(error "~S ~S is not supported on your implementation" 'setf 'getenv))
 
   (defun getenvp (x)
@@ -1871,7 +1828,7 @@ then returning the non-empty string value of the variable"
                 ccl::*openmcl-major-version*
                 ccl::*openmcl-minor-version*
                 (logand (ccl-fasl-version) #xFF))
-        #+cmu (substitute #\- #\/ s)
+        #+cmucl (substitute #\- #\/ s)
         #+scl (format nil "~A~A" s
                       ;; ANSI upper case vs lower case.
                       (ecase ext:*case-mode* (:upper "") (:lower "l")))
@@ -1905,7 +1862,7 @@ suitable for use as a directory name to segregate Lisp FASLs, C dynamic librarie
   (defun hostname ()
     "return the hostname of the current host"
     ;; Note: untested on RMCL
-    #+(or abcl clasp clozure cmu ecl genera lispworks mcl mkcl sbcl scl xcl) (machine-instance)
+    #+(or abcl clasp clozure cmucl ecl genera lispworks mcl mkcl sbcl scl xcl) (machine-instance)
     #+cormanlisp "localhost" ;; is there a better way? Does it matter?
     #+allegro (symbol-call :excl.osi :gethostname)
     #+clisp (first (split-string (machine-instance) :separator " "))
@@ -1915,7 +1872,7 @@ suitable for use as a directory name to segregate Lisp FASLs, C dynamic librarie
 ;;; Current directory
 (with-upgradability ()
 
-  #+cmu
+  #+cmucl
   (defun parse-unix-namestring* (unix-namestring)
     "variant of LISP::PARSE-UNIX-NAMESTRING that returns a pathname object"
     (multiple-value-bind (host device directory name type version)
@@ -1929,7 +1886,7 @@ suitable for use as a directory name to segregate Lisp FASLs, C dynamic librarie
         #+allegro (excl::current-directory)
         #+clisp (ext:default-directory)
         #+clozure (ccl:current-directory)
-        #+(or cmu scl) (#+cmu parse-unix-namestring* #+scl lisp::parse-unix-namestring
+        #+(or cmucl scl) (#+cmucl parse-unix-namestring* #+scl lisp::parse-unix-namestring
                         (strcat (nth-value 1 (unix:unix-current-directory)) "/"))
         #+cormanlisp (pathname (pl::get-current-directory)) ;; Q: what type does it return?
         #+(or clasp ecl) (ext:getcwd)
@@ -1947,7 +1904,7 @@ suitable for use as a directory name to segregate Lisp FASLs, C dynamic librarie
       #+allegro (excl:chdir x)
       #+clisp (ext:cd x)
       #+clozure (setf (ccl:current-directory) x)
-      #+(or cmu scl) (unix:unix-chdir (ext:unix-namestring x))
+      #+(or cmucl scl) (unix:unix-chdir (ext:unix-namestring x))
       #+cormanlisp (unless (zerop (win32::_chdir (namestring x)))
                      (error "Could not set current directory to ~A" x))
       #+(or clasp ecl) (ext:chdir x)
@@ -1955,7 +1912,7 @@ suitable for use as a directory name to segregate Lisp FASLs, C dynamic librarie
       #+lispworks (hcl:change-directory x)
       #+mkcl (mk-ext:chdir x)
       #+sbcl (progn (require :sb-posix) (symbol-call :sb-posix :chdir (sb-ext:native-namestring x)))
-      #-(or abcl allegro clasp clisp clozure cmu cormanlisp ecl gcl genera lispworks mkcl sbcl scl xcl)
+      #-(or abcl allegro clasp clisp clozure cmucl cormanlisp ecl gcl genera lispworks mkcl sbcl scl xcl)
       (error "chdir not supported on your implementation"))))
 
 
@@ -2048,8 +2005,7 @@ the number having BYTES octets (defaulting to 4)."
 ;; which all is necessary prior to any access the filesystem or environment.
 
 (uiop/package:define-package :uiop/pathname
-  (:nicknames :asdf/pathname)
-  (:recycle :uiop/pathname :asdf/pathname :asdf)
+  (:nicknames :asdf/pathname) ;; deprecated. Used by ceramic
   (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/os)
   (:export
    ;; Making and merging pathnames, portably
@@ -2092,7 +2048,7 @@ the number having BYTES octets (defaulting to 4)."
 implementation's MAKE-PATHNAME and other primitives to a CLHS-standard format
 that is a list and not a string."
     (cond
-      #-(or cmu sbcl scl) ;; these implementations already normalize directory components.
+      #-(or cmucl sbcl scl) ;; these implementations already normalize directory components.
       ((stringp directory) `(:absolute ,directory))
       ((or (null directory)
            (and (consp directory) (member (first directory) '(:absolute :relative))))
@@ -2135,22 +2091,17 @@ by the underlying implementation's MAKE-PATHNAME and other primitives"
   ;; See CLHS make-pathname and 19.2.2.2.3.
   ;; This will be :unspecific if supported, or NIL if not.
   (defparameter *unspecific-pathname-type*
-    #+(or abcl allegro clozure cmu genera lispworks sbcl scl) :unspecific
+    #+(or abcl allegro clozure cmucl genera lispworks sbcl scl) :unspecific
     #+(or clasp clisp ecl mkcl gcl xcl #|These haven't been tested:|# cormanlisp mcl) nil
     "Unspecific type component to use with the underlying implementation's MAKE-PATHNAME")
 
-  (defun make-pathname* (&rest keys &key (directory nil)
-                                      host (device () #+allegro devicep) name type version defaults
+  (defun make-pathname* (&rest keys &key directory host device name type version defaults
                                       #+scl &allow-other-keys)
     "Takes arguments like CL:MAKE-PATHNAME in the CLHS, and
    tries hard to make a pathname that will actually behave as documented,
-   despite the peculiarities of each implementation"
-    ;; TODO: reimplement defaulting for MCL, whereby an explicit NIL should override the defaults.
-    (declare (ignorable host device directory name type version defaults))
-    (apply 'make-pathname
-           (append
-            #+allegro (when (and devicep (null device)) `(:device :unspecific))
-            keys)))
+   despite the peculiarities of each implementation. DEPRECATED: just use MAKE-PATHNAME."
+    (declare (ignore host device directory name type version defaults))
+    (apply 'make-pathname keys))
 
   (defun make-pathname-component-logical (x)
     "Make a pathname component suitable for use in a logical-pathname"
@@ -2163,7 +2114,7 @@ by the underlying implementation's MAKE-PATHNAME and other primitives"
   (defun make-pathname-logical (pathname host)
     "Take a PATHNAME's directory, name, type and version components,
 and make a new pathname with corresponding components and specified logical HOST"
-    (make-pathname*
+    (make-pathname
      :host host
      :directory (make-pathname-component-logical (pathname-directory pathname))
      :name (make-pathname-component-logical (pathname-name pathname))
@@ -2206,10 +2157,10 @@ by default *DEFAULT-PATHNAME-DEFAULTS*, which cannot be NIL."
                        (pathname-device defaults)
                        (merge-pathname-directory-components directory (pathname-directory defaults))
                        (unspecific-handler defaults))))
-          (make-pathname* :host host :device device :directory directory
-                          :name (funcall unspecific-handler name)
-                          :type (funcall unspecific-handler type)
-                          :version (funcall unspecific-handler version))))))
+          (make-pathname :host host :device device :directory directory
+                         :name (funcall unspecific-handler name)
+                         :type (funcall unspecific-handler type)
+                         :version (funcall unspecific-handler version))))))
 
   (defun logical-pathname-p (x)
     "is X a logical-pathname?"
@@ -2234,13 +2185,13 @@ when merging, making or parsing pathnames"
     ;; But CMUCL decides to die on NIL.
     ;; MCL has issues with make-pathname, nil and defaulting
     (declare (ignorable defaults))
-    #.`(make-pathname* :directory nil :name nil :type nil :version nil
-                       :device (or #+(and mkcl unix) :unspecific)
-                       :host (or #+cmu lisp::*unix-host* #+(and mkcl unix) "localhost")
-                       #+scl ,@'(:scheme nil :scheme-specific-part nil
-                                 :username nil :password nil :parameters nil :query nil :fragment nil)
-                       ;; the default shouldn't matter, but we really want something physical
-                       #-mcl ,@'(:defaults defaults)))
+    #.`(make-pathname :directory nil :name nil :type nil :version nil
+                      :device (or #+(and mkcl unix) :unspecific)
+                      :host (or #+cmucl lisp::*unix-host* #+(and mkcl unix) "localhost")
+                      #+scl ,@'(:scheme nil :scheme-specific-part nil
+                                :username nil :password nil :parameters nil :query nil :fragment nil)
+                      ;; the default shouldn't matter, but we really want something physical
+                      #-mcl ,@'(:defaults defaults)))
 
   (defvar *nil-pathname* (nil-pathname (physicalize-pathname (user-homedir-pathname)))
     "A pathname that is as neutral as possible for use as defaults
@@ -2318,9 +2269,9 @@ actually-existing file.
 
 Returns the (parsed) PATHNAME when true"
     (when pathname
-      (let* ((pathname (pathname pathname))
-             (name (pathname-name pathname)))
-        (when (not (member name '(nil :unspecific "") :test 'equal))
+      (let ((pathname (pathname pathname)))
+        (unless (and (member (pathname-name pathname) '(nil :unspecific "") :test 'equal)
+                     (member (pathname-type pathname) '(nil :unspecific "") :test 'equal))
           pathname)))))
 
 
@@ -2337,10 +2288,10 @@ and NIL NAME, TYPE and VERSION components"
 i.e. removing one level of depth in the DIRECTORY component. e.g. if pathname is
 Unix pathname /foo/bar/baz/file.type then return /foo/bar/"
     (when pathname
-      (make-pathname* :name nil :type nil :version nil
-                      :directory (merge-pathname-directory-components
-                                  '(:relative :back) (pathname-directory pathname))
-                      :defaults pathname)))
+      (make-pathname :name nil :type nil :version nil
+                     :directory (merge-pathname-directory-components
+                                 '(:relative :back) (pathname-directory pathname))
+                     :defaults pathname)))
 
   (defun directory-pathname-p (pathname)
     "Does PATHNAME represent a directory?
@@ -2375,11 +2326,11 @@ actually-existing directory."
       ((directory-pathname-p pathspec)
        pathspec)
       (t
-       (make-pathname* :directory (append (or (normalize-pathname-directory-component
-                                               (pathname-directory pathspec))
-                                              (list :relative))
-                                          (list (file-namestring pathspec)))
-                       :name nil :type nil :version nil :defaults pathspec)))))
+       (make-pathname :directory (append (or (normalize-pathname-directory-component
+                                              (pathname-directory pathspec))
+                                             (list :relative))
+                                         (list (file-namestring pathspec)))
+                      :name nil :type nil :version nil :defaults pathspec)))))
 
 
 ;;; Parsing filenames
@@ -2512,7 +2463,7 @@ to throw an error if the pathname is absolute"
               (t
                (split-name-type filename)))
           (apply 'ensure-pathname
-                 (make-pathname*
+                 (make-pathname
                   :directory (unless file-only (cons relative path))
                   :name name :type type
                   :defaults (or #-mcl defaults *nil-pathname*))
@@ -2581,19 +2532,19 @@ then it is merged with the PATHNAME-DIRECTORY-PATHNAME of PATHNAME."
 
   (defun pathname-root (pathname)
     "return the root directory for the host and device of given PATHNAME"
-    (make-pathname* :directory '(:absolute)
-                    :name nil :type nil :version nil
-                    :defaults pathname ;; host device, and on scl, *some*
-                    ;; scheme-specific parts: port username password, not others:
-                    . #.(or #+scl '(:parameters nil :query nil :fragment nil))))
+    (make-pathname :directory '(:absolute)
+                   :name nil :type nil :version nil
+                   :defaults pathname ;; host device, and on scl, *some*
+                   ;; scheme-specific parts: port username password, not others:
+                   . #.(or #+scl '(:parameters nil :query nil :fragment nil))))
 
   (defun pathname-host-pathname (pathname)
     "return a pathname with the same host as given PATHNAME, and all other fields NIL"
-    (make-pathname* :directory nil
-                    :name nil :type nil :version nil :device nil
-                    :defaults pathname ;; host device, and on scl, *some*
-                    ;; scheme-specific parts: port username password, not others:
-                    . #.(or #+scl '(:parameters nil :query nil :fragment nil))))
+    (make-pathname :directory nil
+                   :name nil :type nil :version nil :device nil
+                   :defaults pathname ;; host device, and on scl, *some*
+                   ;; scheme-specific parts: port username password, not others:
+                   . #.(or #+scl '(:parameters nil :query nil :fragment nil))))
 
   (defun ensure-absolute-pathname (path &optional defaults (on-error 'error))
     "Given a pathname designator PATH, return an absolute pathname as specified by PATH
@@ -2660,12 +2611,12 @@ given DEFAULTS-PATHNAME as a base pathname."
                    :version (or #-(or allegro abcl xcl) *wild*))
     "A pathname object with wildcards for matching any file in a given directory")
   (defparameter *wild-directory*
-    (make-pathname* :directory `(:relative ,*wild-directory-component*)
-                    :name nil :type nil :version nil)
+    (make-pathname :directory `(:relative ,*wild-directory-component*)
+                   :name nil :type nil :version nil)
     "A pathname object with wildcards for matching any subdirectory")
   (defparameter *wild-inferiors*
-    (make-pathname* :directory `(:relative ,*wild-inferiors-component*)
-                    :name nil :type nil :version nil)
+    (make-pathname :directory `(:relative ,*wild-inferiors-component*)
+                   :name nil :type nil :version nil)
     "A pathname object with wildcards for matching any recursive subdirectory")
   (defparameter *wild-path*
     (merge-pathnames* *wild-file* *wild-inferiors*)
@@ -2692,13 +2643,13 @@ given DEFAULTS-PATHNAME as a base pathname."
   (defun relativize-pathname-directory (pathspec)
     "Given a PATHNAME, return a relative pathname with otherwise the same components"
     (let ((p (pathname pathspec)))
-      (make-pathname*
+      (make-pathname
        :directory (relativize-directory-component (pathname-directory p))
        :defaults p)))
 
   (defun directory-separator-for-host (&optional (pathname *default-pathname-defaults*))
     "Given a PATHNAME, return the character used to delimit directory names on this host and device."
-    (let ((foo (make-pathname* :directory '(:absolute "FOO") :defaults pathname)))
+    (let ((foo (make-pathname :directory '(:absolute "FOO") :defaults pathname)))
       (last-char (namestring foo))))
 
   #-scl
@@ -2722,8 +2673,7 @@ added to its DIRECTORY component. This is useful for output translations."
       (multiple-value-bind (relative path filename)
           (split-unix-namestring-directory-components root-string :ensure-directory t)
         (declare (ignore relative filename))
-        (let ((new-base
-                (make-pathname* :defaults root :directory `(:absolute ,@path))))
+        (let ((new-base (make-pathname :defaults root :directory `(:absolute ,@path))))
           (translate-pathname absolute-pathname wild-root (wilden new-base))))))
 
   #+scl
@@ -2745,8 +2695,8 @@ added to its DIRECTORY component. This is useful for output translations."
               (when (specificp scheme)
                 (setf prefix (strcat scheme prefix)))
               (assert (and directory (eq (first directory) :absolute)))
-              (make-pathname* :directory `(:absolute ,prefix ,@(rest directory))
-                              :defaults pathname)))
+              (make-pathname :directory `(:absolute ,prefix ,@(rest directory))
+                             :defaults pathname)))
         pathname)))
 
   (defun* (translate-pathname*) (path absolute-source destination &optional root source)
@@ -2785,8 +2735,6 @@ you need to still be able to use compile-op on that lisp file."))
 ;;;; Portability layer around Common Lisp filesystem access
 
 (uiop/package:define-package :uiop/filesystem
-  (:nicknames :asdf/filesystem)
-  (:recycle :uiop/filesystem :asdf/pathname :asdf)
   (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/os :uiop/pathname)
   (:export
    ;; Native namestrings
@@ -2817,9 +2765,9 @@ you need to still be able to use compile-op on that lisp file."))
     (when x
       (let ((p (pathname x)))
         #+clozure (with-pathname-defaults () (ccl:native-translated-namestring p)) ; see ccl bug 978
-        #+(or cmu scl) (ext:unix-namestring p nil)
+        #+(or cmucl scl) (ext:unix-namestring p nil)
         #+sbcl (sb-ext:native-namestring p)
-        #-(or clozure cmu sbcl scl)
+        #-(or clozure cmucl sbcl scl)
         (os-cond
          ((os-unix-p) (unix-namestring p))
          (t (namestring p))))))
@@ -2832,8 +2780,10 @@ a CL pathname satisfying all the specified constraints as per ENSURE-PATHNAME"
              (when string
                (with-pathname-defaults ()
                  #+clozure (ccl:native-to-pathname string)
+                 #+cmucl (uiop/os::parse-unix-namestring* string)
                  #+sbcl (sb-ext:parse-native-namestring string)
-                 #-(or clozure sbcl)
+                 #+scl (lisp::parse-unix-namestring string)
+                 #-(or clozure cmucl sbcl scl)
                  (os-cond
                   ((os-unix-p) (parse-unix-namestring string :ensure-directory ensure-directory))
                   (t (parse-namestring string))))))
@@ -2918,10 +2868,10 @@ or the original (parsed) pathname if it is false (the default)."
         (if truename
             (probe-file p)
             (and
-             #+(or cmu scl) (unix:unix-stat (ext:unix-namestring p))
+             #+(or cmucl scl) (unix:unix-stat (ext:unix-namestring p))
              #+(and lispworks unix) (system:get-file-stat p)
              #+sbcl (sb-unix:unix-stat (sb-ext:native-namestring p))
-             #-(or cmu (and lispworks unix) sbcl scl) (file-write-date p)
+             #-(or cmucl (and lispworks unix) sbcl scl) (file-write-date p)
              p))))))
 
   (defun directory-exists-p (x)
@@ -2948,7 +2898,7 @@ Try to override the defaults to not resolving symlinks, if implementation allows
            (append keys '#.(or #+allegro '(:directories-are-files nil :follow-symbolic-links nil)
                                #+(or clozure digitool) '(:follow-links nil)
                                #+clisp '(:circle t :if-does-not-exist :ignore)
-                               #+(or cmu scl) '(:follow-links nil :truenamep nil)
+                               #+(or cmucl scl) '(:follow-links nil :truenamep nil)
                                #+lispworks '(:link-transparency nil)
                                #+sbcl (when (find-symbol* :resolve-symlinks '#:sb-impl nil)
                                         '(:resolve-symlinks nil))))))
@@ -3014,9 +2964,9 @@ The behavior in presence of symlinks is not portable. Use IOlib to handle such s
     (let* ((directory (ensure-directory-pathname directory))
            #-(or abcl cormanlisp genera xcl)
            (wild (merge-pathnames*
-                  #-(or abcl allegro cmu lispworks sbcl scl xcl)
+                  #-(or abcl allegro cmucl lispworks sbcl scl xcl)
                   *wild-directory*
-                  #+(or abcl allegro cmu lispworks sbcl scl xcl) "*.*"
+                  #+(or abcl allegro cmucl lispworks sbcl scl xcl) "*.*"
                   directory))
            (dirs
              #-(or abcl cormanlisp genera xcl)
@@ -3025,17 +2975,17 @@ The behavior in presence of symlinks is not portable. Use IOlib to handle such s
                                        #+mcl '(:directories t))))
              #+(or abcl xcl) (system:list-directory directory)
              #+cormanlisp (cl::directory-subdirs directory)
-             #+genera (fs:directory-list directory))
-           #+(or abcl allegro cmu genera lispworks sbcl scl xcl)
+             #+genera (handler-case (fs:directory-list directory) (fs:directory-not-found () nil)))
+           #+(or abcl allegro cmucl genera lispworks sbcl scl xcl)
            (dirs (loop :for x :in dirs
                        :for d = #+(or abcl xcl) (extensions:probe-directory x)
                        #+allegro (excl:probe-directory x)
-                       #+(or cmu sbcl scl) (directory-pathname-p x)
+                       #+(or cmucl sbcl scl) (directory-pathname-p x)
                        #+genera (getf (cdr x) :directory)
                        #+lispworks (lw:file-directory-p x)
                        :when d :collect #+(or abcl allegro xcl) d
                          #+genera (ensure-directory-pathname (first x))
-                       #+(or cmu lispworks sbcl scl) x)))
+                       #+(or cmucl lispworks sbcl scl) x)))
       (filter-logical-directory-results
        directory dirs
        (let ((prefix (or (normalize-pathname-directory-component (pathname-directory directory))
@@ -3080,13 +3030,13 @@ The behavior in presence of symlinks is not portable. Use IOlib to handle such s
           (loop :while up-components :do
             (if-let (parent
                      (ignore-errors
-                      (probe-file* (make-pathname* :directory `(:absolute ,@(reverse up-components))
-                                                   :name nil :type nil :version nil :defaults p))))
+                      (probe-file* (make-pathname :directory `(:absolute ,@(reverse up-components))
+                                                  :name nil :type nil :version nil :defaults p))))
               (if-let (simplified
                        (ignore-errors
                         (merge-pathnames*
-                         (make-pathname* :directory `(:relative ,@down-components)
-                                         :defaults p)
+                         (make-pathname :directory `(:relative ,@down-components)
+                                        :defaults p)
                          (ensure-directory-pathname parent))))
                 (return simplified)))
             (push (pop up-components) down-components)
@@ -3332,7 +3282,7 @@ NILs."
             #+(or allegro clasp ecl mkcl) #p"SYS:"
             ;;#+clisp custom:*lib-directory* ; causes failure in asdf-pathname-test(!)
             #+clozure #p"ccl:"
-            #+cmu (ignore-errors (pathname-parent-directory-pathname (truename #p"modules:")))
+            #+cmucl (ignore-errors (pathname-parent-directory-pathname (truename #p"modules:")))
             #+gcl system::*system-directory*
             #+lispworks lispworks:*lispworks-directory*
             #+sbcl (if-let (it (find-symbol* :sbcl-homedir-pathname :sb-int nil))
@@ -3386,10 +3336,10 @@ in an atomic way if the implementation allows."
     #+allegro (excl:delete-directory directory-pathname)
     #+clisp (ext:delete-directory directory-pathname)
     #+clozure (ccl::delete-empty-directory directory-pathname)
-    #+(or cmu scl) (multiple-value-bind (ok errno)
+    #+(or cmucl scl) (multiple-value-bind (ok errno)
                        (unix:unix-rmdir (native-namestring directory-pathname))
                      (unless ok
-                       #+cmu (error "Error number ~A when trying to delete directory ~A"
+                       #+cmucl (error "Error number ~A when trying to delete directory ~A"
                                     errno directory-pathname)
                        #+scl (error "~@<Error deleting ~S: ~A~@:>"
                                     directory-pathname (unix:get-unix-error-msg errno))))
@@ -3402,7 +3352,7 @@ in an atomic way if the implementation allows."
                `(,dd directory-pathname) ;; requires SBCL 1.0.44 or later
                `(progn (require :sb-posix) (symbol-call :sb-posix :rmdir directory-pathname)))
     #+xcl (symbol-call :uiop :run-program `("rmdir" ,(native-namestring directory-pathname)))
-    #-(or abcl allegro clasp clisp clozure cmu cormanlisp digitool ecl gcl genera lispworks mkcl sbcl scl xcl)
+    #-(or abcl allegro clasp clisp clozure cmucl cormanlisp digitool ecl gcl genera lispworks mkcl sbcl scl xcl)
     (error "~S not implemented on ~S" 'delete-empty-directory (implementation-type))) ; genera
 
   (defun delete-directory-tree (directory-pathname &key (validate nil validatep) (if-does-not-exist :error))
@@ -3436,7 +3386,7 @@ If you're suicidal or extremely confident, just use :VALIDATE T."
           (error "~S was asked to delete ~S but the directory does not exist"
               'delete-directory-tree directory-pathname))
          (:ignore nil)))
-      #-(or allegro cmu clozure genera sbcl scl)
+      #-(or allegro cmucl clozure genera sbcl scl)
       ((os-unix-p) ;; On Unix, don't recursively walk the directory and delete everything in Lisp,
        ;; except on implementations where we can prevent DIRECTORY from following symlinks;
        ;; instead spawn a standard external program to do the dirty work.
@@ -3463,8 +3413,6 @@ If you're suicidal or extremely confident, just use :VALIDATE T."
 ;;;; Utilities related to streams
 
 (uiop/package:define-package :uiop/stream
-  (:nicknames :asdf/stream)
-  (:recycle :uiop/stream :asdf/stream :asdf)
   (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/os :uiop/pathname :uiop/filesystem)
   (:export
    #:*default-stream-element-type*
@@ -3495,7 +3443,7 @@ If you're suicidal or extremely confident, just use :VALIDATE T."
 
 (with-upgradability ()
   (defvar *default-stream-element-type*
-    (or #+(or abcl cmu cormanlisp scl xcl) 'character
+    (or #+(or abcl cmucl cormanlisp scl xcl) 'character
         #+lispworks 'lw:simple-char
         :default)
     "default element-type for open (depends on the current CL implementation)")
@@ -3506,7 +3454,7 @@ If you're suicidal or extremely confident, just use :VALIDATE T."
   (defun setup-stdin ()
     (setf *stdin*
           #.(or #+clozure 'ccl::*stdin*
-                #+(or cmu scl) 'system:*stdin*
+                #+(or cmucl scl) 'system:*stdin*
                 #+(or clasp ecl) 'ext::+process-standard-input+
                 #+sbcl 'sb-sys:*stdin*
                 '*standard-input*)))
@@ -3517,7 +3465,7 @@ If you're suicidal or extremely confident, just use :VALIDATE T."
   (defun setup-stdout ()
     (setf *stdout*
           #.(or #+clozure 'ccl::*stdout*
-                #+(or cmu scl) 'system:*stdout*
+                #+(or cmucl scl) 'system:*stdout*
                 #+(or clasp ecl) 'ext::+process-standard-output+
                 #+sbcl 'sb-sys:*stdout*
                 '*standard-output*)))
@@ -3529,7 +3477,7 @@ If you're suicidal or extremely confident, just use :VALIDATE T."
     (setf *stderr*
           #.(or #+allegro 'excl::*stderr*
                 #+clozure 'ccl::*stderr*
-                #+(or cmu scl) 'system:*stderr*
+                #+(or cmucl scl) 'system:*stderr*
                 #+(or clasp ecl) 'ext::+process-error-output+
                 #+sbcl 'sb-sys:*stderr*
                 '*error-output*)))
@@ -4027,7 +3975,7 @@ ELEMENT-TYPE (defaults to *DEFAULT-STREAM-ELEMENT-TYPE*) and
 EXTERNAL-FORMAT (defaults to *UTF-8-EXTERNAL-FORMAT*).
 If WANT-STREAM-P is true (the defaults to T), then THUNK will then be CALL-FUNCTION'ed
 with the stream and the pathname (if WANT-PATHNAME-P is true, defaults to T),
-and stream with be closed after the THUNK exits (either normally or abnormally).
+and stream will be closed after the THUNK exits (either normally or abnormally).
 If WANT-STREAM-P is false, then WANT-PATHAME-P must be true, and then
 THUNK is only CALL-FUNCTION'ed after the stream is closed, with the pathname as argument.
 Upon exit of THUNK, the AFTER thunk if defined is CALL-FUNCTION'ed with the pathname as argument.
@@ -4164,8 +4112,6 @@ For the latter case, we ought pick a random suffix and atomically open it."
 ;;;; Starting, Stopping, Dumping a Lisp image
 
 (uiop/package:define-package :uiop/image
-  (:nicknames :asdf/image)
-  (:recycle :uiop/image :asdf/image :xcvb-driver)
   (:use :uiop/common-lisp :uiop/package :uiop/utility :uiop/pathname :uiop/stream :uiop/os)
   (:export
    #:*image-dumped-p* #:raw-command-line-arguments #:*command-line-arguments*
@@ -4231,7 +4177,7 @@ This is designed to abstract away the implementation specific quit forms."
     #+clisp (ext:quit code)
     #+clozure (ccl:quit code)
     #+cormanlisp (win32:exitprocess code)
-    #+(or cmu scl) (unix:unix-exit code)
+    #+(or cmucl scl) (unix:unix-exit code)
     #+gcl (system:quit code)
     #+genera (error "~S: You probably don't want to Halt Genera. (code: ~S)" 'quit code)
     #+lispworks (lispworks:quit :status code :confirm nil :return nil :ignore-errors-p t)
@@ -4242,7 +4188,7 @@ This is designed to abstract away the implementation specific quit forms."
                (cond
                  (exit `(,exit :code code :abort (not finish-output)))
                  (quit `(,quit :unix-status code :recklessly-p (not finish-output)))))
-    #-(or abcl allegro clasp clisp clozure cmu ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
+    #-(or abcl allegro clasp clisp clozure cmucl ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
     (error "~S called with exit code ~S but there's no quitting on this implementation" 'quit code))
 
   (defun die (code format &rest arguments)
@@ -4285,7 +4231,7 @@ This is designed to abstract away the implementation specific quit forms."
       #+clozure (ccl:print-call-history :count count :start-frame-number 1)
       #+mcl (ccl:print-call-history :detailed-p nil)
       (finish-output stream))
-    #+(or cmu scl)
+    #+(or cmucl scl)
     (let ((debug:*debug-print-level* *print-level*)
           (debug:*debug-print-length* *print-length*))
       (debug:backtrace (or count most-positive-fixnum) stream))
@@ -4389,14 +4335,14 @@ depending on whether *LISP-INTERACTION* is set, enter debugger or die"
     #+(or clasp ecl) (loop :for i :from 0 :below (si:argc) :collect (si:argv i))
     #+clisp (coerce (ext:argv) 'list)
     #+clozure ccl:*command-line-argument-list*
-    #+(or cmu scl) extensions:*command-line-strings*
+    #+(or cmucl scl) extensions:*command-line-strings*
     #+gcl si:*command-args*
     #+(or genera mcl) nil
     #+lispworks sys:*line-arguments-list*
     #+mkcl (loop :for i :from 0 :below (mkcl:argc) :collect (mkcl:argv i))
     #+sbcl sb-ext:*posix-argv*
     #+xcl system:*argv*
-    #-(or abcl allegro clasp clisp clozure cmu ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
+    #-(or abcl allegro clasp clisp clozure cmucl ecl gcl genera lispworks mcl mkcl sbcl scl xcl)
     (error "raw-command-line-arguments not implemented yet"))
 
   (defun command-line-arguments (&optional (arguments (raw-command-line-arguments)))
@@ -4425,7 +4371,7 @@ Otherwise, return NIL."
     (cond
       ((eq *image-dumped-p* :executable) ; yes, this ARGV0 is our argv0 !
        ;; NB: not currently available on ABCL, Corman, Genera, MCL
-       (or #+(or allegro clisp clozure cmu gcl lispworks sbcl scl xcl)
+       (or #+(or allegro clisp clozure cmucl gcl lispworks sbcl scl xcl)
            (first (raw-command-line-arguments))
            #+(or clasp ecl) (si:argv 0) #+mkcl (mkcl:argv 0)))
       (t ;; argv[0] is the name of the interpreter.
@@ -4515,7 +4461,7 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
     (setf *image-dump-hook* dump-hook)
     (call-image-dump-hook)
     (setf *image-restored-p* nil)
-    #-(or clisp clozure cmu lispworks sbcl scl)
+    #-(or clisp clozure cmucl lispworks sbcl scl)
     (when executable
       (error "Dumping an executable is not supported on this implementation! Aborting."))
     #+allegro
@@ -4543,13 +4489,13 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
             (funcall (fdefinition 'ccl::write-elf-symbols-to-file) path)
             (dump path))
           (dump t)))
-    #+(or cmu scl)
+    #+(or cmucl scl)
     (progn
       (ext:gc :full t)
       (setf ext:*batch-mode* nil)
       (setf ext::*gc-run-time* 0)
       (apply 'ext:save-lisp filename
-             #+cmu :executable #+cmu t
+             #+cmucl :executable #+cmucl t
              (when executable '(:init-function restore-image :process-command-line nil))))
     #+gcl
     (progn
@@ -4572,7 +4518,7 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
               #+(and sbcl os-windows) ;; passing :application-type :gui will disable the console window.
               ;; the default is :console - only works with SBCL 1.1.15 or later.
               (when application-type (list :application-type application-type)))))
-    #-(or allegro clisp clozure cmu gcl lispworks sbcl scl)
+    #-(or allegro clisp clozure cmucl gcl lispworks sbcl scl)
     (error "Can't ~S ~S: UIOP doesn't support image dumping with ~A.~%"
            'dump-image filename (nth-value 1 (implementation-type))))
 
@@ -4636,8 +4582,7 @@ or COMPRESSION on SBCL, and APPLICATION-TYPE on SBCL/Windows."
 ;;;; run-program initially from xcvb-driver.
 
 (uiop/package:define-package :uiop/run-program
-  (:nicknames :asdf/run-program)
-  (:recycle :uiop/run-program :asdf/run-program :xcvb-driver)
+  (:nicknames :asdf/run-program) ; OBSOLETE. Used by cl-sane, printv.
   (:use :uiop/common-lisp :uiop/package :uiop/utility
    :uiop/pathname :uiop/os :uiop/filesystem :uiop/stream)
   (:export
@@ -5554,8 +5499,7 @@ or an indication of failure via the EXIT-CODE of the process"
 ;;;; Support to build (compile and load) Lisp files
 
 (uiop/package:define-package :uiop/lisp-build
-  (:nicknames :asdf/lisp-build)
-  (:recycle :uiop/lisp-build :asdf/lisp-build :asdf)
+  (:nicknames :asdf/lisp-build) ;; OBSOLETE, used by slime/contrib/swank-asdf.lisp
   (:use :uiop/common-lisp :uiop/package :uiop/utility
    :uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image)
   (:export
@@ -5618,7 +5562,7 @@ This can help you produce more deterministic output for FASLs."))
         #+clisp '() ;; system::*optimize* is a constant hash-table! (with non-constant contents)
         #+clozure '(ccl::*nx-speed* ccl::*nx-space* ccl::*nx-safety*
                     ccl::*nx-debug* ccl::*nx-cspeed*)
-        #+(or cmu scl) '(c::*default-cookie*)
+        #+(or cmucl scl) '(c::*default-cookie*)
         #+(and ecl (not clasp)) (unless (use-ecl-byte-compiler-p) '(c::*speed* c::*space* c::*safety* c::*debug*))
         #+clasp '()
         #+gcl '(compiler::*speed* compiler::*space* compiler::*compiler-new-safety* compiler::*debug*)
@@ -5627,11 +5571,11 @@ This can help you produce more deterministic output for FASLs."))
         #+sbcl '(sb-c::*policy*)))
   (defun get-optimization-settings ()
     "Get current compiler optimization settings, ready to PROCLAIM again"
-    #-(or abcl allegro clasp clisp clozure cmu ecl lispworks mkcl sbcl scl xcl)
+    #-(or abcl allegro clasp clisp clozure cmucl ecl lispworks mkcl sbcl scl xcl)
     (warn "~S does not support ~S. Please help me fix that."
           'get-optimization-settings (implementation-type))
-    #+(or abcl allegro clasp clisp clozure cmu ecl lispworks mkcl sbcl scl xcl)
-    (let ((settings '(speed space safety debug compilation-speed #+(or cmu scl) c::brevity)))
+    #+(or abcl allegro clasp clisp clozure cmucl ecl lispworks mkcl sbcl scl xcl)
+    (let ((settings '(speed space safety debug compilation-speed #+(or cmucl scl) c::brevity)))
       #.`(loop #+(or allegro clozure)
                ,@'(:with info = #+allegro (sys:declaration-information 'optimize)
                    #+clozure (ccl:declaration-information 'optimize nil))
@@ -5640,7 +5584,7 @@ This can help you produce more deterministic output for FASLs."))
                :for y = (or #+(or allegro clozure) (second (assoc x info)) ; normalize order
                             #+clisp (gethash x system::*optimize* 1)
                             #+(or abcl clasp ecl mkcl xcl) (symbol-value v)
-                            #+(or cmu scl) (slot-value c::*default-cookie*
+                            #+(or cmucl scl) (slot-value c::*default-cookie*
                                                        (case x (compilation-speed 'c::cspeed)
                                                              (otherwise x)))
                             #+lispworks (slot-value compiler::*optimization-level* x)
@@ -5682,7 +5626,7 @@ This can help you produce more deterministic output for FASLs."))
   (defvar *usual-uninteresting-conditions*
     (append
      ;;#+clozure '(ccl:compiler-warning)
-     #+cmu '("Deleting unreachable code.")
+     #+cmucl '("Deleting unreachable code.")
      #+lispworks '("~S being redefined in ~A (previously in ~A)."
                    "~S defined more than once in ~A.") ;; lispworks gets confused by eval-when.
      #+sbcl
@@ -5867,7 +5811,7 @@ Simple means made of symbols, numbers, characters, simple-strings, pathnames, co
                         :warning-type warning-type
                         :args (destructuring-bind (fun . more) args
                                 (cons (symbolify-function-name fun) more))))))
-  #+(or cmu scl)
+  #+(or cmucl scl)
   (defun reify-undefined-warning (warning)
     ;; Extracting undefined-warnings from the compilation-unit
     ;; To be passed through the above reify/unreify link, it must be a "simple-sexp"
@@ -5919,7 +5863,7 @@ WITH-COMPILATION-UNIT. One of three functions required for deferred-warnings sup
             (if-let (dw ccl::*outstanding-deferred-warnings*)
               (let ((mdw (ccl::ensure-merged-deferred-warnings dw)))
                 (ccl::deferred-warnings.warnings mdw))))
-    #+(or cmu scl)
+    #+(or cmucl scl)
     (when lisp::*in-compilation-unit*
       ;; Try to send nothing through the pipe if nothing needs to be accumulated
       `(,@(when c::*undefined-warnings*
@@ -5965,7 +5909,7 @@ One of three functions required for deferred-warnings support in ASDF."
                   (setf ccl::*outstanding-deferred-warnings* (ccl::%defer-warnings t)))))
       (appendf (ccl::deferred-warnings.warnings dw)
                (mapcar 'unreify-deferred-warning reified-deferred-warnings)))
-    #+(or cmu scl)
+    #+(or cmucl scl)
     (dolist (item reified-deferred-warnings)
       ;; Each item is (symbol . adjustment) where the adjustment depends on the symbol.
       ;; For *undefined-warnings*, the adjustment is a list of initargs.
@@ -6028,7 +5972,7 @@ One of three functions required for deferred-warnings support in ASDF."
     (if-let (dw ccl::*outstanding-deferred-warnings*)
       (let ((mdw (ccl::ensure-merged-deferred-warnings dw)))
         (setf (ccl::deferred-warnings.warnings mdw) nil)))
-    #+(or cmu scl)
+    #+(or cmucl scl)
     (when lisp::*in-compilation-unit*
       (setf c::*undefined-warnings* nil
             c::*compiler-error-count* 0
@@ -6344,8 +6288,7 @@ it will filter them appropriately."
 ;;;; Generic support for configuration files
 
 (uiop/package:define-package :uiop/configuration
-  (:nicknames :asdf/configuration)
-  (:recycle :uiop/configuration :asdf/configuration :asdf)
+  (:recycle :uiop/configuration :asdf/configuration) ;; necessary to upgrade from 2.27.
   (:use :uiop/common-lisp :uiop/utility
    :uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image :uiop/lisp-build)
   (:export
@@ -6541,7 +6484,7 @@ directive.")
         ;; but what it means to the output-translations is
         ;; "relative to the root of the source pathname's host and device".
         (return-from resolve-absolute-location
-          (let ((p (make-pathname* :directory '(:relative))))
+          (let ((p (make-pathname :directory '(:relative))))
             (if wilden (wilden p) p))))
        ((eql :home) (user-homedir-pathname))
        ((eql :here) (resolve-absolute-location
@@ -6758,14 +6701,11 @@ objects. Side-effects for cached file location computation."
 ;;; Hacks for backward-compatibility of the driver
 
 (uiop/package:define-package :uiop/backward-driver
-  (:nicknames :asdf/backward-driver)
-  (:recycle :uiop/backward-driver :asdf/backward-driver :asdf)
   (:use :uiop/common-lisp :uiop/package :uiop/utility
    :uiop/pathname :uiop/stream :uiop/os :uiop/image
    :uiop/run-program :uiop/lisp-build :uiop/configuration)
   (:export
-   #:coerce-pathname #:component-name-to-pathname-components
-   #+(or clasp ecl mkcl) #:compile-file-keeping-object
+   #:coerce-pathname
    #:user-configuration-directories #:system-configuration-directories
    #:in-first-directory #:in-user-configuration-directory #:in-system-configuration-directory
    ))
@@ -6776,27 +6716,11 @@ objects. Side-effects for cached file location computation."
 (with-upgradability ()
   (defun coerce-pathname (name &key type defaults)
     ;; For backward-compatibility only, for people using internals
-    ;; Reported users in quicklisp: hu.dwim.asdf, asdf-utils, xcvb
-    ;; Will be removed after 2014-01-16.
+    ;; Reported users in quicklisp 2015-11: hu.dwim.asdf (removed in next release)
+    ;; Will be removed after 2015-12.
     ;;(warn "Please don't use ASDF::COERCE-PATHNAME. Use ASDF/PATHNAME:PARSE-UNIX-NAMESTRING.")
     (parse-unix-namestring name :type type :defaults defaults))
 
-  (defun component-name-to-pathname-components (unix-style-namestring
-                                                 &key force-directory force-relative)
-    ;; Will be removed after 2014-01-16.
-    ;; (warn "Please don't use ASDF::COMPONENT-NAME-TO-PATHNAME-COMPONENTS, use SPLIT-UNIX-NAMESTRING-DIRECTORY-COMPONENTS")
-    (multiple-value-bind (relabs path filename file-only)
-        (split-unix-namestring-directory-components
-         unix-style-namestring :ensure-directory force-directory)
-      (declare (ignore file-only))
-      (when (and force-relative (not (eq relabs :relative)))
-        (error (compatfmt "~@<Absolute pathname designator not allowed: ~3i~_~S~@:>")
-               unix-style-namestring))
-      (values relabs path filename)))
-
-  #+(or clasp ecl mkcl)
-  (defun compile-file-keeping-object (&rest args) (apply #'compile-file* args))
-
   ;; Backward compatibility for ASDF 2.27 to 3.1.4
   (defun user-configuration-directories ()
     "Return the current user's list of user configuration directories
@@ -6829,7 +6753,8 @@ for common-lisp. DEPRECATED."
 ;;;; Re-export all the functionality in UIOP
 
 (uiop/package:define-package :uiop/driver
-  (:nicknames :uiop :asdf/driver :asdf-driver :asdf-utils)
+  (:nicknames :uiop :asdf/driver) ;; asdf/driver is obsolete (uiop isn't);
+  ;; but asdf/driver is still used by swap-bytes, static-vectors.
   (:use :uiop/common-lisp)
    ;; NB: not reexporting uiop/common-lisp
    ;; which include all of CL with compatibility modifications on select platforms,
@@ -6837,9 +6762,8 @@ for common-lisp. DEPRECATED."
    ;; or :use (closer-common-lisp uiop), etc.
   (:use-reexport
    :uiop/package :uiop/utility
-   :uiop/os :uiop/pathname :uiop/stream :uiop/filesystem :uiop/image
-   :uiop/run-program :uiop/lisp-build
-   :uiop/configuration :uiop/backward-driver))
+   :uiop/os :uiop/pathname :uiop/filesystem :uiop/stream :uiop/image
+   :uiop/run-program :uiop/lisp-build :uiop/configuration :uiop/backward-driver))
 
 ;; Provide both lowercase and uppercase, to satisfy more people.
 (provide "uiop") (provide "UIOP")
@@ -6853,7 +6777,7 @@ for common-lisp. DEPRECATED."
   (:export
    #:asdf-version #:*previous-asdf-versions* #:*asdf-version*
    #:asdf-message #:*verbose-out*
-   #:upgrading-p #:when-upgrading #:upgrade-asdf #:asdf-upgrade-error #:defparameter*
+   #:upgrading-p #:when-upgrading #:upgrade-asdf #:defparameter*
    #:*post-upgrade-cleanup-hook* #:*post-upgrade-restart-hook* #:cleanup-upgraded-asdf
    ;; There will be no symbol left behind!
    #:intern*)
@@ -6875,7 +6799,16 @@ You can compare this string with e.g.: (ASDF:VERSION-SATISFIES (ASDF:ASDF-VERSIO
               (cons (format nil "~{~D~^.~}" rev))
               (null "1.0"))))))
   ;; Important: define *p-a-v* /before/ *a-v* so that it initializes correctly.
-  (defvar *previous-asdf-versions* (if-let (previous (asdf-version)) (list previous)))
+  (defvar *previous-asdf-versions*
+    (let ((previous (asdf-version)))
+      (when previous
+        ;; Punt on hard package upgrade: from ASDF1 or ASDF2
+        (when (version< previous "2.27") ;; 2.27 is the first to have the :asdf3 feature.
+          (let ((away (format nil "~A-~A" :asdf previous)))
+            (rename-package :asdf away)
+            (when *load-verbose*
+              (format t "~&; Renamed old ~A package away to ~A~%" :asdf away)))))
+        (list previous)))
   (defvar *asdf-version* nil)
   ;; We need to clear systems from versions yet older than the below:
   (defparameter *oldest-forward-compatible-asdf-version* "2.33") ;; 2.32.13 renames a slot in component.
@@ -6912,7 +6845,7 @@ previously-loaded version of ASDF."
          ;; "3.4.5.67" would be a development version in the official branch, on top of 3.4.5.
          ;; "3.4.5.0.8" would be your eighth local modification of official release 3.4.5
          ;; "3.4.5.67.8" would be your eighth local modification of development version 3.4.5.67
-         (asdf-version "3.1.6")
+         (asdf-version "3.1.6.9")
          (existing-version (asdf-version)))
     (setf *asdf-version* asdf-version)
     (when (and existing-version (not (equal asdf-version existing-version)))
@@ -6926,21 +6859,7 @@ previously-loaded version of ASDF."
   (let ((redefined-functions ;; gf signature and/or semantics changed incompatibly. Oops.
           ;; NB: it's too late to do anything about functions in UIOP!
           ;; If you introduce some critically incompatibility there, you must change name.
-          '(#:component-relative-pathname #:component-parent-pathname ;; component
-            #:source-file-type
-            #:find-system #:system-source-file #:system-relative-pathname ;; system
-            #:find-component ;; find-component
-            #:explain #:perform #:perform-with-restarts #:input-files #:output-files ;; action
-            #:component-depends-on #:operation-done-p #:component-depends-on
-            #:traverse ;; backward-interface
-            #:map-direct-dependencies #:reduce-direct-dependencies #:direct-dependencies ;; plan
-            #:operate  ;; operate
-            #:parse-component-form ;; defsystem
-            #:apply-output-translations ;; output-translations
-            #:process-output-translations-directive
-            #:inherit-source-registry #:process-source-registry ;; source-registry
-            #:process-source-registry-directive
-            #:trivial-system-p)) ;; bundle
+          '()) ;; empty now that we don't unintern, but wholly punt on ASDF 2.26 or earlier.
         (redefined-classes
           ;; redefining the classes causes interim circularities
           ;; with the old ASDF during upgrade, and many implementations bork
@@ -6962,12 +6881,6 @@ previously-loaded version of ASDF."
 ;;; Self-upgrade functions
 
 (with-upgradability ()
-  (defun asdf-upgrade-error ()
-    ;; Important notice for whom it concerns. The crux of the matter is that
-    ;; TRAVERSE can be completely refactored, and so after the find-system returns, it's too late.
-    (error "When a system transitively depends on ASDF, it must :defsystem-depends-on (:asdf)~%~
-          Otherwise, when you upgrade from ASDF 2, you must do it before you operate on any system.~%"))
-
   (defun cleanup-upgraded-asdf (&optional (old-version (first *previous-asdf-versions*)))
     (let ((new-version (asdf-version)))
       (unless (equal old-version new-version)
@@ -7072,7 +6985,7 @@ another pathname in a degenerate way."))
     ;; condition objects, which in turn does inheritance of :report options at
     ;; run-time.  fortunately, inheritance means we only need this kludge here in
     ;; order to fix all conditions that build on it.  -- rgr, 28-Jul-02.]
-    #+cmu (:report print-object))
+    #+cmucl (:report print-object))
 
   (define-condition duplicate-names (system-definition-error)
     ((name :initarg :name :reader duplicate-names-name))
@@ -7110,10 +7023,9 @@ another pathname in a degenerate way."))
      ;; See our ASDF 2 paper for more complete explanations.
      (in-order-to :initform nil :initarg :in-order-to
                   :accessor component-in-order-to)
-     ;; methods defined using the "inline" style inside a defsystem form:
-     ;; need to store them somewhere so we can delete them when the system
-     ;; is re-evaluated.
-     (inline-methods :accessor component-inline-methods :initform nil) ;; OBSOLETE! DELETE THIS IF NO ONE USES.
+     ;; Methods defined using the "inline" style inside a defsystem form:
+     ;; we store them here so we can delete them when the system is re-evaluated.
+     (inline-methods :accessor component-inline-methods :initform nil)
      ;; ASDF4: rename it from relative-pathname to specified-pathname. It need not be relative.
      ;; There is no initform and no direct accessor for this specified pathname,
      ;; so we only access the information through appropriate methods, after it has been processed.
@@ -7502,7 +7414,8 @@ in which the system specification (.asd file) is located."
    #:remove-entry-from-registry #:coerce-entry-to-directory
    #:coerce-name #:primary-system-name #:coerce-filename
    #:find-system #:locate-system #:load-asd
-   #:system-registered-p #:register-system #:registered-systems #:clear-system #:map-systems
+   #:system-registered-p #:register-system #:registered-systems* #:registered-systems
+   #:clear-system #:map-systems
    #:missing-component #:missing-requires #:missing-parent
    #:formatted-system-definition-error #:format-control #:format-arguments #:sysdef-error
    #:load-system-definition-error #:error-name #:error-pathname #:error-condition
@@ -7567,9 +7480,12 @@ of which is a system object.")
   (defun system-registered-p (name)
     (gethash (coerce-name name) *defined-systems*))
 
-  (defun registered-systems ()
+  (defun registered-systems* ()
     (loop :for registered :being :the :hash-values :of *defined-systems*
-          :collect (coerce-name (cdr registered))))
+          :collect (cdr registered)))
+
+  (defun registered-systems ()
+    (mapcar 'coerce-name (registered-systems*)))
 
   (defun register-system (system)
     (check-type system system)
@@ -7788,7 +7704,8 @@ Going forward, we recommend new users should be using the source-registry.
     (find-system (coerce-name name) error-p))
 
   (defun find-system-if-being-defined (name)
-    ;; notable side effect: mark the system as being defined, to avoid infinite loops
+    ;; NB: this depends on a corresponding side-effect in parse-defsystem;
+    ;; this protocol may change somewhat in the future.
     (first (gethash `(find-system ,(coerce-name name)) *asdf-cache*)))
 
   (defun load-asd (pathname
@@ -7809,10 +7726,10 @@ Going forward, we recommend new users should be using the source-registry.
                 ;; resolve logical-pathnames so they won't wreak havoc in parsing namestrings.
                 (pathname-directory-pathname (physicalize-pathname pathname))))
           (handler-bind
-              ((error #'(lambda (condition)
-                          (error 'load-system-definition-error
-                                 :name name :pathname pathname
-                                 :condition condition))))
+              (((and error (not missing-component))
+                 #'(lambda (condition)
+                     (error 'load-system-definition-error
+                            :name name :pathname pathname :condition condition))))
             (asdf-message (compatfmt "~&~@<; ~@;Loading system definition~@[ for ~A~] from ~A~@:>~%")
                           name pathname)
             (load* pathname :external-format external-format))))))
@@ -8482,9 +8399,11 @@ in some previous image, or T if it needs to be done.")
   (defmethod component-operation-time ((o operation) (c component))
     (gethash (type-of o) (component-operation-times c)))
 
+  (defmethod (setf component-operation-time) (stamp (o operation) (c component))
+    (setf (gethash (type-of o) (component-operation-times c)) stamp))
+
   (defmethod mark-operation-done ((o operation) (c component))
-    (setf (gethash (type-of o) (component-operation-times c))
-          (compute-action-stamp nil o c :just-done t))))
+    (setf (component-operation-time o c) (compute-action-stamp nil o c :just-done t))))
 
 
 ;;;; Perform
@@ -9123,6 +9042,8 @@ the action of OPERATION on COMPONENT in the PLAN"))
                                  :index (if status ; index of action amongst all nodes in traversal
                                             (action-index status) ;; if already visited, keep index
                                             (incf (plan-total-action-count plan))))) ; else new index
+                          (when (and done-p (not add-to-plan-p))
+                            (setf (component-operation-time operation component) stamp))
                           (when add-to-plan-p ; if it needs to be added to the plan,
                             (incf (plan-planned-action-count plan)) ; count it
                             (unless aniip ; if it's output-producing,
@@ -9413,7 +9334,7 @@ to load it in current image."
 
   (defun already-loaded-systems ()
     "return a list of the names of the systems that have been successfully loaded so far"
-    (remove-if-not 'component-loaded-p (registered-systems)))
+    (mapcar 'coerce-name (remove-if-not 'component-loaded-p (registered-systems*))))
 
   (defun require-system (system &rest keys &key &allow-other-keys)
     "Ensure the specified SYSTEM is loaded, passing the KEYS to OPERATE, but skip any update to the
@@ -9853,7 +9774,7 @@ system names to pathnames of .asd files")
   (register-clear-configuration-hook 'clear-source-registry)
 
   (defparameter *wild-asd*
-    (make-pathname* :directory nil :name *wild* :type "asd" :version :newest))
+    (make-pathname :directory nil :name *wild* :type "asd" :version :newest))
 
   (defun directory-asd-files (directory)
     (directory-files directory *wild-asd*))
@@ -9978,7 +9899,7 @@ after having found a .asd file? True by default.")
       #+(or clasp ecl sbcl) (:tree ,(resolve-symlinks* (lisp-implementation-directory)))
       :inherit-configuration
       #+mkcl (:tree ,(translate-logical-pathname "CONTRIB:"))
-      #+cmu (:tree #p"modules:")
+      #+cmucl (:tree #p"modules:")
       #+scl (:tree #p"file://modules/")))
   (defun default-user-source-registry ()
     `(:source-registry
@@ -10295,7 +10216,7 @@ after having found a .asd file? True by default.")
 
 ;;; Main parsing function
 (with-upgradability ()
-  (defun* parse-dependency-def (dd)
+  (defun parse-dependency-def (dd)
     (if (listp dd)
         (case (first dd)
           (:feature
@@ -10316,12 +10237,12 @@ after having found a .asd file? True by default.")
           (otherwise (sysdef-error "Ill-formed dependency: ~s" dd)))
       (coerce-name dd)))
 
-  (defun* parse-dependency-defs (dd-list)
+  (defun parse-dependency-defs (dd-list)
     "Parse the dependency defs in DD-LIST into canonical form by translating all
 system names contained using COERCE-NAME. Return the result."
     (mapcar 'parse-dependency-def dd-list))
 
-  (defun* (parse-component-form) (parent options &key previous-serial-component)
+  (defun (parse-component-form) (parent options &key previous-serial-component)
     (destructuring-bind
         (type name &rest rest &key
                                 (builtin-system-p () bspp)
@@ -10411,6 +10332,15 @@ system names contained using COERCE-NAME. Return the result."
     (with-asdf-cache ()
       (let* ((name (coerce-name name))
              (source-file (if sfp source-file (resolve-symlinks* (load-pathname))))
+             ;; NB: handle defsystem-depends-on BEFORE to create the system object,
+             ;; so that in case it fails, there is no incomplete object polluting the build.
+             (checked-defsystem-depends-on
+               (let* ((dep-forms (parse-dependency-defs defsystem-depends-on))
+                      (deps (loop :for spec :in dep-forms
+                                  :when (resolve-dependency-spec nil spec)
+                                    :collect :it)))
+                 (load-systems* deps)
+                 dep-forms))
              (registered (system-registered-p name))
              (registered! (if registered
                               (rplaca registered (get-file-stamp source-file))
@@ -10419,17 +10349,12 @@ system names contained using COERCE-NAME. Return the result."
              (system (reset-system (cdr registered!)
                                    :name name :source-file source-file))
              (component-options
-              (remove-plist-keys '(:defsystem-depends-on :class) options))
-             (defsystem-dependencies (loop :for spec :in defsystem-depends-on
-                                           :when (resolve-dependency-spec nil spec)
-                                           :collect :it)))
-        ;; cache defsystem-depends-on in canonical form
-        (when defsystem-depends-on
-          (setf component-options
-                (append `(:defsystem-depends-on ,(parse-dependency-defs defsystem-depends-on))
-                        component-options)))
+              (append
+               (remove-plist-keys '(:defsystem-depends-on :class) options)
+               ;; cache defsystem-depends-on in canonical form
+               (when checked-defsystem-depends-on
+                 `(:defsystem-depends-on ,checked-defsystem-depends-on)))))
         (set-asdf-cache-entry `(find-system ,name) (list system))
-        (load-systems* defsystem-dependencies)
         ;; We change-class AFTER we loaded the defsystem-depends-on
         ;; since the class might be defined as part of those.
         (let ((class (class-for-type nil class)))
@@ -11023,16 +10948,6 @@ for all the linkable object files associated with the system or its dependencies
                :extra-object-files (or (extra-object-files o) (when programp (extra-object-files c)))
                :no-uiop (no-uiop c)
                (when programp `(:entry-point ,(component-entry-point c))))))))
-
-#+(and (not asdf-use-unsafe-mac-bundle-op)
-       (or (and clasp ecl darwin)
-           (and abcl darwin (not abcl-bundle-op-supported))))
-(defmethod perform :before ((o basic-compile-bundle-op) (c component))
-  (unless (featurep :asdf-use-unsafe-mac-bundle-op)
-    (cerror "Continue after modifying *FEATURES*."
-            "BASIC-COMPILE-BUNDLE-OP operations are not supported on Mac OS X for this lisp.~%~T~
-To continue, push :asdf-use-unsafe-mac-bundle-op onto *FEATURES*.~%~T~
-Please report to ASDF-DEVEL if this works for you.")))
 ;;;; -------------------------------------------------------------------------
 ;;;; Concatenate-source
 
@@ -11219,11 +11134,12 @@ otherwise return a default system name computed from PACKAGE-NAME."
       (remove t (mapcar 'package-name-system (package-dependencies defpackage-form)))
       (error 'package-inferred-system-missing-package-error :system system :pathname file)))
 
-  (defun same-package-inferred-system-p (system name directory subpath dependencies)
+  (defun same-package-inferred-system-p (system name directory subpath around-compile dependencies)
     (and (eq (type-of system) 'package-inferred-system)
          (equal (component-name system) name)
          (pathname-equal directory (component-pathname system))
          (equal dependencies (component-sideway-dependencies system))
+         (equal around-compile (around-compile-hook system))
          (let ((children (component-children system)))
            (and (length=n-p children 1)
                 (let ((child (first children)))
@@ -11243,14 +11159,16 @@ otherwise return a default system name computed from PACKAGE-NAME."
                                      :truename *resolve-symlinks*)))
                 (when (file-pathname-p f)
                   (let ((dependencies (package-inferred-system-file-dependencies f system))
-                        (previous (cdr (system-registered-p system))))
-                    (if (same-package-inferred-system-p previous system dir sub dependencies)
+                        (previous (cdr (system-registered-p system)))
+                        (around-compile (around-compile-hook top)))
+                    (if (same-package-inferred-system-p previous system dir sub around-compile dependencies)
                         previous
                         (eval `(defsystem ,system
                                  :class package-inferred-system
                                  :source-file nil
                                  :pathname ,dir
                                  :depends-on ,dependencies
+                                 :around-compile ,around-compile
                                  :components ((cl-source-file "lisp" :pathname ,sub)))))))))))))))
 
 (with-upgradability ()
@@ -11264,27 +11182,14 @@ otherwise return a default system name computed from PACKAGE-NAME."
 (uiop/package:define-package :asdf/backward-internals
   (:recycle :asdf/backward-internals :asdf)
   (:use :uiop/common-lisp :uiop :asdf/upgrade :asdf/find-system)
-  (:export ;; for internal use
-   #:make-sub-operation
-   #:load-sysdef #:make-temporary-package))
+  (:export #:load-sysdef))
 (in-package :asdf/backward-internals)
 
-(when-upgrading (:when (fboundp 'make-sub-operation))
-  (defun make-sub-operation (c o dep-c dep-o)
-    (declare (ignore c o dep-c dep-o)) (asdf-upgrade-error)))
-
-;;;; load-sysdef
 (with-upgradability ()
   (defun load-sysdef (name pathname)
-    (load-asd pathname :name name))
-
-  (defun make-temporary-package ()
-    ;; For loading a .asd file, we don't make a temporary package anymore,
-    ;; but use ASDF-USER. I'd like to have this function do this,
-    ;; but since whoever uses it is likely to delete-package the result afterwards,
-    ;; this would be a bad idea, so preserve the old behavior.
-    (make-package (fresh-package-name :prefix :asdf :index 0) :use '(:cl :asdf))))
-
+    (declare (ignore name pathname))
+    ;; Needed for backward compatibility with swank-asdf from SLIME 2015-12-01 or older.
+    (error "Use asdf:load-asd instead of asdf::load-sysdef")))
 ;;;; -------------------------------------------------------------------------
 ;;; Backward-compatible interfaces
 
@@ -11654,12 +11559,12 @@ Please use UIOP:RUN-PROGRAM instead."
 (in-package :asdf/footer)
 
 ;;;; Hook ASDF into the implementation's REQUIRE and other entry points.
-#+(or abcl clasp clisp clozure cmu ecl mkcl sbcl)
+#+(or abcl clasp clisp clozure cmucl ecl mkcl sbcl)
 (with-upgradability ()
   (if-let (x (and #+clisp (find-symbol* '#:*module-provider-functions* :custom nil)))
     (eval `(pushnew 'module-provide-asdf
                     #+abcl sys::*module-provider-functions*
-                    #+(or clasp cmu ecl) ext:*module-provider-functions*
+                    #+(or clasp cmucl ecl) ext:*module-provider-functions*
                     #+clisp ,x
                     #+clozure ccl:*module-provider-functions*
                     #+mkcl mk-ext:*module-provider-functions*
@@ -11683,7 +11588,7 @@ Please use UIOP:RUN-PROGRAM instead."
                           (and (first l) (register-preloaded-system (coerce-name name)))
                           (values-list l))))))))
 
-#+cmu ;; Hook into the CMUCL herald.
+#+cmucl ;; Hook into the CMUCL herald.
 (with-upgradability ()
   (defun herald-asdf (stream)
     (format stream "    ASDF ~A" (asdf-version)))
@@ -11694,7 +11599,7 @@ Please use UIOP:RUN-PROGRAM instead."
 (with-upgradability ()
   #+allegro
   (when (boundp 'excl:*warn-on-nested-reader-conditionals*)
-    (setf excl:*warn-on-nested-reader-conditionals* asdf/common-lisp::*acl-warn-save*))
+    (setf excl:*warn-on-nested-reader-conditionals* uiop/common-lisp::*acl-warn-save*))
 
   (dolist (f '(:asdf :asdf2 :asdf3 :asdf3.1 :asdf-package-system)) (pushnew f *features*))
 
diff --git a/src/contrib/asdf/doc/asdf.html b/src/contrib/asdf/doc/asdf.html
index d3793bd29..189e1c5f3 100644
--- a/src/contrib/asdf/doc/asdf.html
+++ b/src/contrib/asdf/doc/asdf.html
@@ -84,7 +84,6 @@ ul.no-bullet {list-style: none}
 
 
 
-
 <a name="SEC_Contents"></a>
 <h2 class="contents-heading">Table of Contents</h2>
 
@@ -275,7 +274,7 @@ ul.no-bullet {list-style: none}
 <a name="Top"></a>
 <a name="ASDF_003a-Another-System-Definition-Facility"></a>
 <h1 class="top">ASDF: Another System Definition Facility</h1>
-<p>Manual for Version 3.1.6
+<p>Manual for Version 3.1.6.9
 </p>
 
 <p>This manual describes ASDF, a system definition facility
@@ -1263,7 +1262,7 @@ simple-component-name := string
 pathname-specifier := pathname | string | symbol
 
 method-form := (operation-name qual lambda-list &amp;rest body)
-qual := method qualifier
+qual := method qualifier?
 
 component-dep-fail-option := :fail | :try-next | :ignore
 
@@ -1787,6 +1786,7 @@ whereas earlier versions ignore this option and use the <code>system-source-dire
 where the <samp>.asd</samp> file resides.
 </p>
 
+
 <hr>
 <a name="The-object-model-of-ASDF"></a>
 <a name="The-Object-model-of-ASDF"></a>
@@ -1799,7 +1799,7 @@ Both a system&rsquo;s structure and the operations that can be performed on syst
 follow a extensible protocol, allowing programmers to add new behaviours to ASDF.
 For example, <code>cffi</code> adds support for special FFI description files
 that interface with C libraries and for wrapper files that embed C code in Lisp.
-<code>abcl-jar</code> supports creating Java JAR archives in ABCL.
+<code>asdf-jar</code> supports creating Java JAR archives in ABCL.
 <code>poiu</code> supports compiling code in parallel using background processes.
 </p>
 <p>The key classes in ASDF are <code>component</code> and <code>operation</code>.
diff --git a/src/contrib/asdf/doc/asdf.info b/src/contrib/asdf/doc/asdf.info
index 8c65388a1..1ccf5608a 100644
--- a/src/contrib/asdf/doc/asdf.info
+++ b/src/contrib/asdf/doc/asdf.info
@@ -43,7 +43,7 @@ File: asdf.info,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)
 ASDF: Another System Definition Facility
 ****************************************
 
-Manual for Version 3.1.6
+Manual for Version 3.1.6.9
 
    This manual describes ASDF, a system definition facility for Common
 Lisp programs and libraries.
@@ -1173,7 +1173,7 @@ File: asdf.info,  Node: The defsystem grammar,  Next: Other code in .asd files,
      pathname-specifier := pathname | string | symbol
 
      method-form := (operation-name qual lambda-list &rest body)
-     qual := method qualifier
+     qual := method qualifier?
 
      component-dep-fail-option := :fail | :try-next | :ignore
 
@@ -1630,7 +1630,7 @@ system's structure and the operations that can be performed on systems
 follow a extensible protocol, allowing programmers to add new behaviours
 to ASDF. For example, 'cffi' adds support for special FFI description
 files that interface with C libraries and for wrapper files that embed C
-code in Lisp.  'abcl-jar' supports creating Java JAR archives in ABCL.
+code in Lisp.  'asdf-jar' supports creating Java JAR archives in ABCL.
 'poiu' supports compiling code in parallel using background processes.
 
    The key classes in ASDF are 'component' and 'operation'.  A
@@ -5647,136 +5647,136 @@ Variable Index
 
 Tag Table:
 Node: Top1684
-Node: Introduction7633
-Node: Quick start summary9936
-Node: Loading ASDF11643
-Node: Loading a pre-installed ASDF11945
-Ref: Loading a pre-installed ASDF-Footnote-113758
-Node: Checking whether ASDF is loaded13940
-Node: Upgrading ASDF14854
-Node: Replacing your implementation's ASDF15842
-Node: Loading ASDF from source17265
-Node: Configuring ASDF18366
-Node: Configuring ASDF to find your systems19139
-Ref: Configuring ASDF to find your systems-Footnote-122444
-Ref: Configuring ASDF to find your systems-Footnote-222691
-Ref: Configuring ASDF to find your systems-Footnote-322973
-Node: Configuring ASDF to find your systems --- old style23434
-Ref: Configuring ASDF to find your systems --- old style-Footnote-125861
-Ref: Configuring ASDF to find your systems --- old style-Footnote-226093
-Ref: Configuring ASDF to find your systems --- old style-Footnote-326860
-Node: Configuring where ASDF stores object files27016
-Node: Resetting the ASDF configuration28419
-Node: Using ASDF29476
-Node: Loading a system29687
-Node: Convenience Functions30704
-Ref: Convenience Functions-Footnote-133849
-Node: Moving on33927
-Node: Defining systems with defsystem34298
-Node: The defsystem form34726
-Node: A more involved example38132
-Ref: A more involved example-Footnote-145114
-Node: The defsystem grammar45796
-Ref: if-feature-option61935
-Node: Other code in .asd files63767
-Node: The package-inferred-system extension64903
-Node: The object model of ASDF69170
-Ref: The object model of ASDF-Footnote-171500
-Ref: The object model of ASDF-Footnote-271852
-Node: Operations72179
-Ref: operate73284
-Node: Predefined operations of ASDF75767
-Ref: test-op77882
-Node: Creating new operations85765
-Node: Components90978
-Ref: System names94462
-Ref: Components-Footnote-199134
-Ref: Components-Footnote-299430
-Node: Common attributes of components99752
-Ref: required-features101314
-Node: Pre-defined subclasses of component107161
-Node: Creating new component types109595
-Node: Dependencies110885
-Node: Functions112756
-Node: Controlling where ASDF searches for systems114590
-Node: Configurations115212
-Node: Truenames and other dangers118687
-Node: XDG base directory119973
-Node: Backward Compatibility121387
-Node: Configuration DSL122103
-Node: Configuration Directories127658
-Node: The here directive129485
-Node: Shell-friendly syntax for configuration131378
-Node: Search Algorithm132395
-Node: Caching Results133896
-Node: Configuration API137140
-Node: Introspection139179
-Node: *source-registry-parameter* variable139443
-Node: Information about system dependencies140012
-Node: Status140928
-Node: Rejected ideas141383
-Node: TODO143764
-Node: Credits for the source-registry143949
-Node: Controlling where ASDF saves compiled files144484
-Ref: Controlling where ASDF saves compiled files-Footnote-1145896
-Node: Output Configurations145940
-Ref: Output Configurations-Footnote-1148801
-Node: Output Backward Compatibility148867
-Node: Output Configuration DSL151593
-Node: Output Configuration Directories157048
-Node: Output Shell-friendly syntax for configuration158605
-Node: Semantics of Output Translations159914
-Node: Output Caching Results161483
-Node: Output location API161963
-Node: Credits for output translations164385
-Node: Error handling164905
-Node: Miscellaneous additional functionality165746
-Node: Controlling file compilation166218
-Node: Controlling source file character encoding169484
-Node: Miscellaneous Functions176299
-Ref: system-relative-pathname176596
-Ref: Miscellaneous Functions-Footnote-1182220
-Node: Some Utility Functions182331
-Node: Getting the latest version193059
-Node: FAQ194004
-Node: Where do I report a bug?194399
-Node: Mailing list194764
-Node: What has changed between ASDF 1 ASDF 2 and ASDF 3?195099
-Node: What are ASDF 1 2 3?197273
-Node: How do I detect the ASDF version?198314
-Node: ASDF can portably name files in subdirectories200621
-Node: Output translations202171
-Node: Source Registry Configuration203198
-Node: Usual operations are made easier to the user204825
-Node: Many bugs have been fixed205411
-Node: ASDF itself is versioned207243
-Node: ASDF can be upgraded208118
-Node: Decoupled release cycle209270
-Node: Pitfalls of the transition to ASDF 2210199
-Node: Pitfalls of the upgrade to ASDF 3214469
-Ref: Pitfalls of the upgrade to ASDF 3-Footnote-1218836
-Node: What happened to the bundle operations219006
-Node: Issues with installing the proper version of ASDF220108
-Node: My Common Lisp implementation comes with an outdated version of ASDF. What to do?220579
-Node: I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?221512
-Node: Issues with configuring ASDF225395
-Node: How can I customize where fasl files are stored?225770
-Node: How can I wholly disable the compiler output cache?226863
-Node: Issues with using and extending ASDF to define systems228242
-Node: How can I cater for unit-testing in my system?228966
-Node: How can I cater for documentation generation in my system?229855
-Node: How can I maintain non-Lisp (e.g. C) source files?230376
-Ref: report-bugs230808
-Node: I want to put my module's files at the top level. How do I do this?230808
-Node: How do I create a system definition where all the source files have a .cl extension?233958
-Node: How do I mark a source file to be loaded only and not compiled?235931
-Node: How do I work with readtables?236927
-Node: ASDF development FAQs240613
-Node: How do I run the tests interactively in a REPL?240852
-Node: Ongoing Work242718
-Node: Bibliography242997
-Node: Concept Index246433
-Node: Function and Class Index252725
-Node: Variable Index264553
+Node: Introduction7635
+Node: Quick start summary9938
+Node: Loading ASDF11645
+Node: Loading a pre-installed ASDF11947
+Ref: Loading a pre-installed ASDF-Footnote-113760
+Node: Checking whether ASDF is loaded13942
+Node: Upgrading ASDF14856
+Node: Replacing your implementation's ASDF15844
+Node: Loading ASDF from source17267
+Node: Configuring ASDF18368
+Node: Configuring ASDF to find your systems19141
+Ref: Configuring ASDF to find your systems-Footnote-122446
+Ref: Configuring ASDF to find your systems-Footnote-222693
+Ref: Configuring ASDF to find your systems-Footnote-322975
+Node: Configuring ASDF to find your systems --- old style23436
+Ref: Configuring ASDF to find your systems --- old style-Footnote-125863
+Ref: Configuring ASDF to find your systems --- old style-Footnote-226095
+Ref: Configuring ASDF to find your systems --- old style-Footnote-326862
+Node: Configuring where ASDF stores object files27018
+Node: Resetting the ASDF configuration28421
+Node: Using ASDF29478
+Node: Loading a system29689
+Node: Convenience Functions30706
+Ref: Convenience Functions-Footnote-133851
+Node: Moving on33929
+Node: Defining systems with defsystem34300
+Node: The defsystem form34728
+Node: A more involved example38134
+Ref: A more involved example-Footnote-145116
+Node: The defsystem grammar45798
+Ref: if-feature-option61938
+Node: Other code in .asd files63770
+Node: The package-inferred-system extension64906
+Node: The object model of ASDF69173
+Ref: The object model of ASDF-Footnote-171503
+Ref: The object model of ASDF-Footnote-271855
+Node: Operations72182
+Ref: operate73287
+Node: Predefined operations of ASDF75770
+Ref: test-op77885
+Node: Creating new operations85768
+Node: Components90981
+Ref: System names94465
+Ref: Components-Footnote-199137
+Ref: Components-Footnote-299433
+Node: Common attributes of components99755
+Ref: required-features101317
+Node: Pre-defined subclasses of component107164
+Node: Creating new component types109598
+Node: Dependencies110888
+Node: Functions112759
+Node: Controlling where ASDF searches for systems114593
+Node: Configurations115215
+Node: Truenames and other dangers118690
+Node: XDG base directory119976
+Node: Backward Compatibility121390
+Node: Configuration DSL122106
+Node: Configuration Directories127661
+Node: The here directive129488
+Node: Shell-friendly syntax for configuration131381
+Node: Search Algorithm132398
+Node: Caching Results133899
+Node: Configuration API137143
+Node: Introspection139182
+Node: *source-registry-parameter* variable139446
+Node: Information about system dependencies140015
+Node: Status140931
+Node: Rejected ideas141386
+Node: TODO143767
+Node: Credits for the source-registry143952
+Node: Controlling where ASDF saves compiled files144487
+Ref: Controlling where ASDF saves compiled files-Footnote-1145899
+Node: Output Configurations145943
+Ref: Output Configurations-Footnote-1148804
+Node: Output Backward Compatibility148870
+Node: Output Configuration DSL151596
+Node: Output Configuration Directories157051
+Node: Output Shell-friendly syntax for configuration158608
+Node: Semantics of Output Translations159917
+Node: Output Caching Results161486
+Node: Output location API161966
+Node: Credits for output translations164388
+Node: Error handling164908
+Node: Miscellaneous additional functionality165749
+Node: Controlling file compilation166221
+Node: Controlling source file character encoding169487
+Node: Miscellaneous Functions176302
+Ref: system-relative-pathname176599
+Ref: Miscellaneous Functions-Footnote-1182223
+Node: Some Utility Functions182334
+Node: Getting the latest version193062
+Node: FAQ194007
+Node: Where do I report a bug?194402
+Node: Mailing list194767
+Node: What has changed between ASDF 1 ASDF 2 and ASDF 3?195102
+Node: What are ASDF 1 2 3?197276
+Node: How do I detect the ASDF version?198317
+Node: ASDF can portably name files in subdirectories200624
+Node: Output translations202174
+Node: Source Registry Configuration203201
+Node: Usual operations are made easier to the user204828
+Node: Many bugs have been fixed205414
+Node: ASDF itself is versioned207246
+Node: ASDF can be upgraded208121
+Node: Decoupled release cycle209273
+Node: Pitfalls of the transition to ASDF 2210202
+Node: Pitfalls of the upgrade to ASDF 3214472
+Ref: Pitfalls of the upgrade to ASDF 3-Footnote-1218839
+Node: What happened to the bundle operations219009
+Node: Issues with installing the proper version of ASDF220111
+Node: My Common Lisp implementation comes with an outdated version of ASDF. What to do?220582
+Node: I'm a Common Lisp implementation vendor. When and how should I upgrade ASDF?221515
+Node: Issues with configuring ASDF225398
+Node: How can I customize where fasl files are stored?225773
+Node: How can I wholly disable the compiler output cache?226866
+Node: Issues with using and extending ASDF to define systems228245
+Node: How can I cater for unit-testing in my system?228969
+Node: How can I cater for documentation generation in my system?229858
+Node: How can I maintain non-Lisp (e.g. C) source files?230379
+Ref: report-bugs230811
+Node: I want to put my module's files at the top level. How do I do this?230811
+Node: How do I create a system definition where all the source files have a .cl extension?233961
+Node: How do I mark a source file to be loaded only and not compiled?235934
+Node: How do I work with readtables?236930
+Node: ASDF development FAQs240616
+Node: How do I run the tests interactively in a REPL?240855
+Node: Ongoing Work242721
+Node: Bibliography243000
+Node: Concept Index246436
+Node: Function and Class Index252728
+Node: Variable Index264556
 
 End Tag Table
diff --git a/src/contrib/asdf/doc/asdf.pdf b/src/contrib/asdf/doc/asdf.pdf
index d917b021c4c4ec734263b265c9c8d24790f7108a..935d65f2f46b472497e119c757be9a89d10637c1 100644
GIT binary patch
delta 35473
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

delta 35321
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

-- 
GitLab