diff --git a/asdf.lisp b/asdf.lisp
index c713bdad0632442f945ebd7e57451a71f7ea28f2..8be8d376a7482c25462880351204f800f555b35b 100644
--- a/asdf.lisp
+++ b/asdf.lisp
@@ -1,4 +1,4 @@
-;;; This is asdf: Another System Definition Facility. 
+;;; This is asdf: Another System Definition Facility.
 ;;; hash - $Format:%H$
 ;;;
 ;;; Local Variables:
@@ -19,7 +19,7 @@
 ;;; RELEASE may be slightly older but is considered `stable'
 
 ;;; -- LICENSE START
-;;; (This is the MIT / X Consortium license as taken from 
+;;; (This is the MIT / X Consortium license as taken from
 ;;;  http://www.opensource.org/licenses/mit-license.html on or about
 ;;;  Monday; July 13, 2009)
 ;;;
@@ -55,12 +55,12 @@
   (:documentation "Another System Definition Facility")
   (:export #:defsystem #:oos #:operate #:find-system #:run-shell-command
            #:system-definition-pathname #:find-component ; miscellaneous
-	   #:compile-system #:load-system #:test-system
+           #:compile-system #:load-system #:test-system
            #:compile-op #:load-op #:load-source-op
            #:test-op
-           #:operation		 ; operations
-           #:feature		 ; sort-of operation
-           #:version		 ; metaphorically sort-of an operation
+           #:operation           ; operations
+           #:feature             ; sort-of operation
+           #:version             ; metaphorically sort-of an operation
 
            #:input-files #:output-files #:perform ; operation methods
            #:operation-done-p #:explain
@@ -95,61 +95,61 @@
            #:system-licence
            #:system-source-file
            #:system-relative-pathname
-	   #:map-systems
+           #:map-systems
 
            #:operation-on-warnings
            #:operation-on-failure
 
-					;#:*component-parent-pathname*
+                                        ;#:*component-parent-pathname*
            #:*system-definition-search-functions*
            #:*central-registry*         ; variables
            #:*compile-file-warnings-behaviour*
            #:*compile-file-failure-behaviour*
            #:*asdf-revision*
-	   #:*resolve-symlinks*
+           #:*resolve-symlinks*
 
            #:operation-error #:compile-failed #:compile-warned #:compile-error
            #:error-component #:error-operation
            #:system-definition-error
            #:missing-component
-	   #:missing-component-of-version
+           #:missing-component-of-version
            #:missing-dependency
            #:missing-dependency-of-version
            #:circular-dependency        ; errors
            #:duplicate-names
 
-	   #:try-recompiling
+           #:try-recompiling
            #:retry
            #:accept                     ; restarts
-	   #:coerce-entry-to-directory
-	   #:remove-entry-from-registry
+           #:coerce-entry-to-directory
+           #:remove-entry-from-registry
 
            #:standard-asdf-method-combination
            #:around                     ; protocol assistants
-	   
-	   #:*source-to-target-mappings*
-	   #:*default-toplevel-directory*
-	   #:*centralize-lisp-binaries*
-	   #:*include-per-user-information*
-	   #:*map-all-source-files*
-	   #:output-files-for-system-and-operation
-	   #:*enable-asdf-binary-locations*
-	   #:implementation-specific-directory-name)
+
+           #:*source-to-target-mappings*
+           #:*default-toplevel-directory*
+           #:*centralize-lisp-binaries*
+           #:*include-per-user-information*
+           #:*map-all-source-files*
+           #:output-files-for-system-and-operation
+           #:*enable-asdf-binary-locations*
+           #:implementation-specific-directory-name)
   (:intern #:coerce-name
-	   #:system-registered-p
-	   #:asdf-message
-	   #:resolve-symlinks
-	   #:pathname-sans-name+type)
+           #:system-registered-p
+           #:asdf-message
+           #:resolve-symlinks
+           #:pathname-sans-name+type)
   (:use :cl))
 
 (defpackage #:asdf-extensions
   (:use #:common-lisp #:asdf)
   (:import-from #:asdf
-		#:coerce-name
-		#:system-registered-p
-		#:asdf-message
-		#:resolve-symlinks
-		#:pathname-sans-name+type))
+                #:coerce-name
+                #:system-registered-p
+                #:asdf-message
+                #:resolve-symlinks
+                #:pathname-sans-name+type))
 
 #+nil
 (error "The author of this file habitually uses #+nil to comment out ~
@@ -158,10 +158,10 @@
 
 (in-package #:asdf)
 
-(defvar *asdf-revision* 
+(defvar *asdf-revision*
   ;; the 1+ hair is to ensure that we don't do an inadvertent find and replace
   (subseq "REVISION:1.369" (1+ (length "REVISION"))))
-  
+
 
 (defvar *resolve-symlinks* t
   "Determine whether or not ASDF resolves symlinks when defining systems.
@@ -204,8 +204,8 @@ Defaults to `t`.")
                         (,@(rest around-asdf) (make-method ,standard-form)))
           standard-form))))
 
-(setf (documentation 'standard-asdf-method-combination 
-		     'method-combination)
+(setf (documentation 'standard-asdf-method-combination
+                     'method-combination)
       "This method combination is based on the standard method combination,
 but defines a new method-qualifier, `asdf:around`.  `asdf:around`
 methods will be run *around* any `:around` methods, so that the core
@@ -281,15 +281,15 @@ the head of the tree"))
 (defgeneric component-self-dependencies (operation component))
 
 (defgeneric traverse (operation component)
-  (:documentation 
+  (:documentation
 "Generate and return a plan for performing `operation` on `component`.
 
 The plan returned is a list of dotted-pairs. Each pair is the `cons`
-of ASDF operation object and a `component` object. The pairs will be 
+of ASDF operation object and a `component` object. The pairs will be
 processed in order by `operate`."))
 
 (defgeneric output-files-using-mappings (source possible-paths path-mappings)
-  (:documentation 
+  (:documentation
 "Use the variable \\*source-to-target-mappings\\* to find
 an output path for the source. The algorithm transforms each
 entry in possible-paths as follows: If there is a mapping
@@ -379,7 +379,7 @@ and NIL NAME and TYPE components"
   ((required-by :initarg :required-by :reader missing-required-by)))
 
 (define-condition missing-dependency-of-version (missing-dependency
-						 missing-component-of-version)
+                                                 missing-component-of-version)
   ())
 
 (define-condition operation-error (error)
@@ -421,8 +421,8 @@ and NIL NAME and TYPE components"
           (call-next-method c nil) (missing-required-by c)))
 
 (defun sysdef-error (format &rest arguments)
-  (error 'formatted-system-definition-error :format-control 
-	 format :format-arguments arguments))
+  (error 'formatted-system-definition-error :format-control
+         format :format-arguments arguments))
 
 ;;;; methods: components
 
@@ -438,8 +438,8 @@ and NIL NAME and TYPE components"
               ~@[ in ~A~]~@:>"
            (missing-requires c)
            (missing-version c)
-	   (when (missing-parent c)
-	     (component-name (missing-parent c)))))
+           (when (missing-parent c)
+             (component-name (missing-parent c)))))
 
 (defmethod component-system ((component component))
   (aif (component-parent component)
@@ -469,7 +469,7 @@ and NIL NAME and TYPE components"
 (defmethod component-relative-pathname ((component module))
   (or (slot-value component 'relative-pathname)
       (multiple-value-bind (relative path)
-	  (split-path-string (component-name component) t)
+          (split-path-string (component-name component) t)
         (make-pathname
          :directory `(,relative ,@path)
          :host (pathname-host (component-parent-pathname component))))))
@@ -497,7 +497,7 @@ and NIL NAME and TYPE components"
    (licence :accessor system-licence :initarg :licence
             :accessor system-license :initarg :license)
    (source-file :reader system-source-file :initarg :source-file
-		:writer %set-system-source-file)))
+                :writer %set-system-source-file)))
 
 ;;; version-satisfies
 
@@ -518,8 +518,11 @@ and NIL NAME and TYPE components"
 (defmethod version-satisfies ((c component) version)
   (unless (and version (slot-boundp c 'version))
     (return-from version-satisfies t))
+  (version-satisfies (component-version c) version))
+
+(defmethod version-satisfies ((cver string) version)
   (let ((x (mapcar #'parse-integer
-                   (split (component-version c) nil '(#\.))))
+                   (split cver nil '(#\.))))
         (y (mapcar #'parse-integer
                    (split version nil '(#\.)))))
     (labels ((bigger (x y)
@@ -555,11 +558,11 @@ and NIL NAME and TYPE components"
 `fn` should be a function of one argument. It will be
 called with an object of type asdf:system."
   (maphash (lambda (_ datum)
-	     (declare (ignore _))
-	     (destructuring-bind (_ . def) datum
-	       (declare (ignore _))
-	       (funcall fn def)))
-	   *defined-systems*))
+             (declare (ignore _))
+             (destructuring-bind (_ . def) datum
+               (declare (ignore _))
+               (funcall fn def)))
+           *defined-systems*))
 
 ;;; for the sake of keeping things reasonably neat, we adopt a
 ;;; convention that functions in this list are prefixed SYSDEF-
@@ -571,16 +574,16 @@ called with an object of type asdf:system."
   (let ((system-name (coerce-name system)))
     (or
      (some (lambda (x) (funcall x system-name))
-	   *system-definition-search-functions*)
+           *system-definition-search-functions*)
      (let ((system-pair (system-registered-p system-name)))
        (and system-pair
-	    (system-source-file (cdr system-pair)))))))
+            (system-source-file (cdr system-pair)))))))
 
 (defvar *central-registry*
   `((directory-namestring *default-pathname-defaults*))
 "A list of 'system directory designators' ASDF uses to find systems.
 
-A 'system directory designator' is a pathname or a function 
+A 'system directory designator' is a pathname or a function
 which evaluates to a pathname. For example:
 
     (setf asdf:*central-registry*
@@ -593,95 +596,95 @@ which evaluates to a pathname. For example:
   "Does `pathname` represent a directory?
 
 A directory-pathname is a pathname _without_ a filename. The three
-ways that the filename components can be missing are for it to be `nil`, 
+ways that the filename components can be missing are for it to be `nil`,
 `:unspecific` or the empty string.
 
 Note that this does _not_ check to see that `pathname` points to an
 actually-existing directory."
   (flet ((check-one (x)
-	   (not (null (member x '(nil :unspecific "")
-			      :test 'equal)))))
+           (not (null (member x '(nil :unspecific "")
+                              :test 'equal)))))
     (and (check-one (pathname-name pathname))
-	 (check-one (pathname-type pathname)))))
+         (check-one (pathname-type pathname)))))
 
 #+(or)
 ;;test
 ;;?? move into testsuite sometime soon
 (every (lambda (p)
-	  (directory-pathname-p p))
-	(list 
-	 (make-pathname :name "." :type nil :directory '(:absolute "tmp"))
-	 (make-pathname :name "." :type "" :directory '(:absolute "tmp"))
-	 (make-pathname :name nil :type "" :directory '(:absolute "tmp"))
-	 (make-pathname :name "" :directory '(:absolute "tmp"))
-	 (make-pathname :type :unspecific :directory '(:absolute "tmp"))
-	 (make-pathname :name :unspecific :directory '(:absolute "tmp"))
-	 (make-pathname :name :unspecific :directory '(:absolute "tmp"))
-	 (make-pathname :type "" :directory '(:absolute "tmp"))
-	 ))
+          (directory-pathname-p p))
+        (list
+         (make-pathname :name "." :type nil :directory '(:absolute "tmp"))
+         (make-pathname :name "." :type "" :directory '(:absolute "tmp"))
+         (make-pathname :name nil :type "" :directory '(:absolute "tmp"))
+         (make-pathname :name "" :directory '(:absolute "tmp"))
+         (make-pathname :type :unspecific :directory '(:absolute "tmp"))
+         (make-pathname :name :unspecific :directory '(:absolute "tmp"))
+         (make-pathname :name :unspecific :directory '(:absolute "tmp"))
+         (make-pathname :type "" :directory '(:absolute "tmp"))
+         ))
 
 (defun ensure-directory-pathname (pathname)
   (if (directory-pathname-p pathname)
       pathname
       (make-pathname :defaults pathname
-		     :directory (append
-				 (pathname-directory pathname)
-				 (list (file-namestring pathname)))
-		     :name nil :type nil :version nil)))
+                     :directory (append
+                                 (pathname-directory pathname)
+                                 (list (file-namestring pathname)))
+                     :name nil :type nil :version nil)))
 
 (defun sysdef-central-registry-search (system)
   (let ((name (coerce-name system))
-	(to-remove nil)
-	(to-replace nil))
+        (to-remove nil)
+        (to-replace nil))
     (block nil
       (unwind-protect
-	   (dolist (dir *central-registry*)
-	     (let ((defaults (eval dir)))
-	       (when defaults
-		 (cond ((directory-pathname-p defaults)
-			(let ((file (and defaults
-					 (make-pathname
-					  :defaults defaults :version :newest
-					  :name name :type "asd" :case :local)))
+           (dolist (dir *central-registry*)
+             (let ((defaults (eval dir)))
+               (when defaults
+                 (cond ((directory-pathname-p defaults)
+                        (let ((file (and defaults
+                                         (make-pathname
+                                          :defaults defaults :version :newest
+                                          :name name :type "asd" :case :local)))
                                #+(and (or win32 windows) (not :clisp))
                                (shortcut (make-pathname
                                           :defaults defaults :version :newest
                                           :name name :type "asd.lnk" :case :local)))
-			  (if (and file (probe-file file))
-			      (return file))
+                          (if (and file (probe-file file))
+                              (return file))
                           #+(and (or win32 windows) (not :clisp))
                           (when (probe-file shortcut)
                             (let ((target (parse-windows-shortcut shortcut)))
                               (when target
                                 (return (pathname target)))))))
-		       (t
-			(restart-case 
-			    (let* ((*print-circle* nil)
-				   (message 
-				    (format nil 
-					    "~@<While searching for system `~a`: `~a` evaluated ~
-to `~a` which is not a directory.~@:>" 
-					    system dir defaults)))
-			      (error message))
-			  (remove-entry-from-registry ()
-			    :report "Remove entry from *central-registry* and continue"
-			    (push dir to-remove))
-			  (coerce-entry-to-directory ()
-			    :report (lambda (s)
-				      (format s "Coerce entry to ~a, replace ~a and continue."
-					      (ensure-directory-pathname defaults) dir))
-			    (push (cons dir (ensure-directory-pathname defaults)) to-replace))))))))
-	;; cleanup
-	(dolist (dir to-remove)
-	  (setf *central-registry* (remove dir *central-registry*)))
-	(dolist (pair to-replace)
-	  (let* ((current (car pair))
-		 (new (cdr pair))
-		 (position (position current *central-registry*)))
-	    (setf *central-registry*
-		  (append (subseq *central-registry* 0 position)
-			  (list new)
-			  (subseq *central-registry* (1+ position))))))))))
+                       (t
+                        (restart-case
+                            (let* ((*print-circle* nil)
+                                   (message
+                                    (format nil
+                                            "~@<While searching for system `~a`: `~a` evaluated ~
+to `~a` which is not a directory.~@:>"
+                                            system dir defaults)))
+                              (error message))
+                          (remove-entry-from-registry ()
+                            :report "Remove entry from *central-registry* and continue"
+                            (push dir to-remove))
+                          (coerce-entry-to-directory ()
+                            :report (lambda (s)
+                                      (format s "Coerce entry to ~a, replace ~a and continue."
+                                              (ensure-directory-pathname defaults) dir))
+                            (push (cons dir (ensure-directory-pathname defaults)) to-replace))))))))
+        ;; cleanup
+        (dolist (dir to-remove)
+          (setf *central-registry* (remove dir *central-registry*)))
+        (dolist (pair to-replace)
+          (let* ((current (car pair))
+                 (new (cdr pair))
+                 (position (position current *central-registry*)))
+            (setf *central-registry*
+                  (append (subseq *central-registry* 0 position)
+                          (list new)
+                          (subseq *central-registry* (1+ position))))))))))
 
 (defun make-temporary-package ()
   (flet ((try (counter)
@@ -710,7 +713,7 @@ to `~a` which is not a directory.~@:>"
       (let ((package (make-temporary-package)))
         (unwind-protect
              (let ((*package* package))
-	       (asdf-message
+               (asdf-message
                 "~&~@<; ~@;loading system definition from ~A into ~A~@:>~%"
                 ;; FIXME: This wants to be (ENOUGH-NAMESTRING
                 ;; ON-DISK), but CMUCL barfs on that.
@@ -720,8 +723,8 @@ to `~a` which is not a directory.~@:>"
           (delete-package package))))
     (let ((in-memory (system-registered-p name)))
       (if in-memory
-          (progn (if on-disk (setf (car in-memory) 
-				   (safe-file-write-date on-disk)))
+          (progn (if on-disk (setf (car in-memory)
+                                   (safe-file-write-date on-disk)))
                  (cdr in-memory))
           (if error-p (error 'missing-component :requires name))))))
 
@@ -921,7 +924,7 @@ to `~a` which is not a directory.~@:>"
 ;;; So you look at this code and think "why isn't it a bunch of
 ;;; methods".  And the answer is, because standard method combination
 ;;; runs :before methods most->least-specific, which is back to front
-;;; for our purposes.  
+;;; for our purposes.
 
 (defmethod traverse ((operation operation) (c component))
   (let ((forced nil))
@@ -932,36 +935,36 @@ to `~a` which is not a directory.~@:>"
                                   ;; in-order-to slot with canonicalized
                                   ;; names instead of coercing this late
                                   (coerce-name required-c) required-v)
-				 (if required-v
-				     (error 'missing-dependency-of-version
-					    :required-by c
-					    :version required-v
-					    :requires required-c)
-				     (error 'missing-dependency
-					    :required-by c
-					    :requires required-c))))
+                                 (if required-v
+                                     (error 'missing-dependency-of-version
+                                            :required-by c
+                                            :version required-v
+                                            :requires required-c)
+                                     (error 'missing-dependency
+                                            :required-by c
+                                            :requires required-c))))
                       (op (make-sub-operation c operation dep-c required-op)))
                  (traverse op dep-c)))
-	     (do-one-dep (required-op required-c required-v)
+             (do-one-dep (required-op required-c required-v)
                (loop
-		  (restart-case
-		      (return (%do-one-dep required-op required-c required-v))
-		    (retry ()
-		      :report (lambda (s)
-				(format s "~@<Retry loading component ~S.~@:>"
-					required-c))
-		      :test
-		      (lambda (c)
+                  (restart-case
+                      (return (%do-one-dep required-op required-c required-v))
+                    (retry ()
+                      :report (lambda (s)
+                                (format s "~@<Retry loading component ~S.~@:>"
+                                        required-c))
+                      :test
+                      (lambda (c)
 #|
-			(print (list :c1 c (typep c 'missing-dependency)))
-			(when (typep c 'missing-dependency)
-			  (print (list :c2 (missing-requires c) required-c
-				       (equalp (missing-requires c)
-					       required-c))))
+                        (print (list :c1 c (typep c 'missing-dependency)))
+                        (when (typep c 'missing-dependency)
+                          (print (list :c2 (missing-requires c) required-c
+                                       (equalp (missing-requires c)
+                                               required-c))))
 |#
-			(and (typep c 'missing-dependency)
-			     (equalp (missing-requires c)
-				     required-c)))))))
+                        (and (typep c 'missing-dependency)
+                             (equalp (missing-requires c)
+                                     required-c)))))))
              (do-dep (op dep)
                (cond ((eq op 'feature)
                       (or (member (car dep) *features*)
@@ -971,22 +974,22 @@ to `~a` which is not a directory.~@:>"
                      (t
                       (dolist (d dep)
                         (cond ((consp d)
-			       (cond ((string-equal
-				       (symbol-name (first d))
-				       "VERSION")
-				      (appendf
-				       forced
-				       (do-one-dep op (second d) (third d))))
-				     ((and (string-equal
-					    (symbol-name (first d))
-					    "FEATURE")
-					   (find (second d) *features*
-						 :test 'string-equal))
-				      (appendf
-				       forced
-				       (do-one-dep op (second d) (third d))))
-				     (t
-				      (error "Bad dependency ~a.  Dependencies must be (:version <version>), (:feature <feature>), or a name" d))))
+                               (cond ((string-equal
+                                       (symbol-name (first d))
+                                       "VERSION")
+                                      (appendf
+                                       forced
+                                       (do-one-dep op (second d) (third d))))
+                                     ((and (string-equal
+                                            (symbol-name (first d))
+                                            "FEATURE")
+                                           (find (second d) *features*
+                                                 :test 'string-equal))
+                                      (appendf
+                                       forced
+                                       (do-one-dep op (second d) (third d))))
+                                     (t
+                                      (error "Bad dependency ~a.  Dependencies must be (:version <version>), (:feature <feature>), or a name" d))))
                               (t
                                (appendf forced (do-one-dep op d nil)))))))))
       (aif (component-visited-p operation c)
@@ -997,50 +1000,50 @@ to `~a` which is not a directory.~@:>"
           (error 'circular-dependency :components (list c)))
       (setf (visiting-component operation c) t)
       (unwind-protect
-	   (progn
-	     (loop for (required-op . deps) in
-		  (component-depends-on operation c)
-		  do (do-dep required-op deps))
-	     ;; constituent bits
-	     (let ((module-ops
-		    (when (typep c 'module)
-		      (let ((at-least-one nil)
-			    (forced nil)
-			    (error nil))
-			(loop for kid in (module-components c)
-			   do (handler-case
-				  (appendf forced (traverse operation kid ))
-				(missing-dependency (condition)
-				  (if (eq (module-if-component-dep-fails c)
-					  :fail)
-				      (error condition))
-				  (setf error condition))
-				(:no-error (c)
-				  (declare (ignore c))
-				  (setf at-least-one t))))
-			(when (and (eq (module-if-component-dep-fails c)
-				       :try-next)
-				   (not at-least-one))
-			  (error error))
-			forced))))
-	       ;; now the thing itself
-	       (when (or forced module-ops
-			 (not (operation-done-p operation c))
-			 (let ((f (operation-forced
-				   (operation-ancestor operation))))
-			   (and f (or (not (consp f))
-				      (member (component-name
-					       (operation-ancestor operation))
-					      (mapcar #'coerce-name f)
-					      :test #'string=)))))
-		 (let ((do-first (cdr (assoc (class-name (class-of operation))
-					     (slot-value c 'do-first)))))
-		   (loop for (required-op . deps) in do-first
-		      do (do-dep required-op deps)))
-		 (setf forced (append (delete 'pruned-op forced :key #'car)
-				      (delete 'pruned-op module-ops :key #'car)
-				      (list (cons operation c)))))))
-	(setf (visiting-component operation c) nil))
+           (progn
+             (loop for (required-op . deps) in
+                  (component-depends-on operation c)
+                  do (do-dep required-op deps))
+             ;; constituent bits
+             (let ((module-ops
+                    (when (typep c 'module)
+                      (let ((at-least-one nil)
+                            (forced nil)
+                            (error nil))
+                        (loop for kid in (module-components c)
+                           do (handler-case
+                                  (appendf forced (traverse operation kid ))
+                                (missing-dependency (condition)
+                                  (if (eq (module-if-component-dep-fails c)
+                                          :fail)
+                                      (error condition))
+                                  (setf error condition))
+                                (:no-error (c)
+                                  (declare (ignore c))
+                                  (setf at-least-one t))))
+                        (when (and (eq (module-if-component-dep-fails c)
+                                       :try-next)
+                                   (not at-least-one))
+                          (error error))
+                        forced))))
+               ;; now the thing itself
+               (when (or forced module-ops
+                         (not (operation-done-p operation c))
+                         (let ((f (operation-forced
+                                   (operation-ancestor operation))))
+                           (and f (or (not (consp f))
+                                      (member (component-name
+                                               (operation-ancestor operation))
+                                              (mapcar #'coerce-name f)
+                                              :test #'string=)))))
+                 (let ((do-first (cdr (assoc (class-name (class-of operation))
+                                             (slot-value c 'do-first)))))
+                   (loop for (required-op . deps) in do-first
+                      do (do-dep required-op deps)))
+                 (setf forced (append (delete 'pruned-op forced :key #'car)
+                                      (delete 'pruned-op module-ops :key #'car)
+                                      (list (cons operation c)))))))
+        (setf (visiting-component operation c) nil))
       (visit-component operation c (and forced t))
       forced)))
 
@@ -1124,42 +1127,42 @@ to `~a` which is not a directory.~@:>"
 (defmethod perform around ((o load-op) (c cl-source-file))
   (let ((state :initial))
     (loop until (or (eq state :success)
-		    (eq state :failure)) do
-	 (case state
-	   (:recompiled
-	    (setf state :failure)
-	    (call-next-method)
-	    (setf state :success))
-	   (:failed-load
-	    (setf state :recompiled)
-	    (perform (make-instance 'asdf:compile-op) c))
-	   (t
-	    (with-simple-restart
-		(try-recompiling "Recompile ~a and try loading it again"
-				  (component-name c))
-	      (setf state :failed-load)
-	      (call-next-method)
-	      (setf state :success)))))))
+                    (eq state :failure)) do
+         (case state
+           (:recompiled
+            (setf state :failure)
+            (call-next-method)
+            (setf state :success))
+           (:failed-load
+            (setf state :recompiled)
+            (perform (make-instance 'asdf:compile-op) c))
+           (t
+            (with-simple-restart
+                (try-recompiling "Recompile ~a and try loading it again"
+                                  (component-name c))
+              (setf state :failed-load)
+              (call-next-method)
+              (setf state :success)))))))
 
 (defmethod perform around ((o compile-op) (c cl-source-file))
   (let ((state :initial))
     (loop until (or (eq state :success)
-		    (eq state :failure)) do
-	 (case state
-	   (:recompiled
-	    (setf state :failure)
-	    (call-next-method)
-	    (setf state :success))
-	   (:failed-compile
-	    (setf state :recompiled)
-	    (perform (make-instance 'asdf:compile-op) c))
-	   (t
-	    (with-simple-restart
-		(try-recompiling "Try recompiling ~a"
-				  (component-name c))
-	      (setf state :failed-compile)
-	      (call-next-method)
-	      (setf state :success)))))))
+                    (eq state :failure)) do
+         (case state
+           (:recompiled
+            (setf state :failure)
+            (call-next-method)
+            (setf state :success))
+           (:failed-compile
+            (setf state :recompiled)
+            (perform (make-instance 'asdf:compile-op) c))
+           (t
+            (with-simple-restart
+                (try-recompiling "Try recompiling ~a"
+                                  (component-name c))
+              (setf state :failed-compile)
+              (call-next-method)
+              (setf state :success)))))))
 
 (defmethod perform ((operation load-op) (c static-file))
   nil)
@@ -1259,7 +1262,7 @@ to `~a` which is not a directory.~@:>"
     op))
 
 (defun oos (operation-class system &rest args &key force (verbose t) version
-	    &allow-other-keys)
+            &allow-other-keys)
   (declare (ignore force verbose version))
   (apply #'operate operation-class system args))
 
@@ -1282,11 +1285,11 @@ operations on the system or its components: the new operations will be
 created with the same initargs as the original one.
 "))
   (setf (documentation 'oos 'function)
-	(format nil
-		"Short for _operate on system_ and an alias for the [operate][] function. ~&~&~a"
-		operate-docstring))
+        (format nil
+                "Short for _operate on system_ and an alias for the [operate][] function. ~&~&~a"
+                operate-docstring))
   (setf (documentation 'operate 'function)
-	operate-docstring))
+        operate-docstring))
 
 (defun load-system (system &rest args &key force (verbose t) version)
   "Shorthand for `(operate 'asdf:load-op system)`. See [operate][] for details."
@@ -1323,7 +1326,7 @@ created with the same initargs as the original one.
 (defun determine-system-pathname (pathname pathname-supplied-p)
   ;; called from the defsystem macro.
   ;; the pathname of a system is either
-  ;; 1. the one supplied, 
+  ;; 1. the one supplied,
   ;; 2. derived from the *load-truename* (see below), or
   ;; 3. taken from *default-pathname-defaults*
   ;;
@@ -1333,10 +1336,10 @@ created with the same initargs as the original one.
   ;; implementations, the latter has *already resolved it.
   (or (and pathname-supplied-p pathname)
       (when *load-pathname*
-	(pathname-sans-name+type 
-	 (if *resolve-symlinks*
-	     (resolve-symlinks *load-truename*)
-	     *load-pathname*)))
+        (pathname-sans-name+type
+         (if *resolve-symlinks*
+             (resolve-symlinks *load-truename*)
+             *load-pathname*)))
       *default-pathname-defaults*))
 
 (defmacro defsystem (name &body options)
@@ -1356,15 +1359,15 @@ created with the same initargs as the original one.
                  (t
                   (register-system (quote ,name)
                                    (make-instance ',class :name ',name))))
-           (%set-system-source-file *load-truename* 
-				    (cdr (system-registered-p ',name))))
-         (parse-component-form 
-	  nil (apply
-	       #'list
-	       :module (coerce-name ',name)
-	       :pathname
-	       ,(determine-system-pathname pathname pathname-arg-p)
-	       ',component-options))))))
+           (%set-system-source-file *load-truename*
+                                    (cdr (system-registered-p ',name))))
+         (parse-component-form
+          nil (apply
+               #'list
+               :module (coerce-name ',name)
+               :pathname
+               ,(determine-system-pathname pathname pathname-arg-p)
+               ',component-options))))))
 
 
 (defun class-for-type (parent type)
@@ -1424,8 +1427,8 @@ Returns the new tree (which probably shares structure with the old one)"
                              "~&The value specified for ~(~A~) ~A is ~W")
                 type name value))
 
-(defun check-component-input (type name weakly-depends-on 
-			      depends-on components in-order-to)
+(defun check-component-input (type name weakly-depends-on
+                              depends-on components in-order-to)
   "A partial test of the values of a component."
   (unless (listp depends-on)
     (sysdef-error-component ":depends-on must be a list."
@@ -1455,21 +1458,21 @@ Returns the new tree (which probably shares structure with the old one)"
 (defun %define-component-inline-methods (ret rest)
   (loop for name in +asdf-methods+ do
        (let ((keyword (intern (symbol-name name) :keyword)))
-	 (loop for data = rest then (cddr data)
-	      for key = (first data)
-	      for value = (second data)
+         (loop for data = rest then (cddr data)
+              for key = (first data)
+              for value = (second data)
               while data
-	      when (eq key keyword) do
-	      (destructuring-bind (op qual (o c) &body body) value
-	      (pushnew
-		 (eval `(defmethod ,name ,qual ((,o ,op) (,c (eql ,ret)))
-				   ,@body))
-		 (component-inline-methods ret)))))))
+              when (eq key keyword) do
+              (destructuring-bind (op qual (o c) &body body) value
+              (pushnew
+                 (eval `(defmethod ,name ,qual ((,o ,op) (,c (eql ,ret)))
+                                   ,@body))
+                 (component-inline-methods ret)))))))
 
 (defun %refresh-component-inline-methods (component rest)
   (%remove-component-inline-methods component)
   (%define-component-inline-methods component rest))
-  
+
 (defun parse-component-form (parent options)
 
   (destructuring-bind
@@ -1563,10 +1566,10 @@ output to `*verbose-out*`.  Returns the shell's exit code."
     #+sbcl
     (sb-ext:process-exit-code
      (apply #'sb-ext:run-program
-	    #+win32 "sh" #-win32 "/bin/sh"
-	    (list  "-c" command)
-	    :input nil :output *verbose-out*
-	    #+win32 '(:search t) #-win32 nil))
+            #+win32 "sh" #-win32 "/bin/sh"
+            (list  "-c" command)
+            :input nil :output *verbose-out*
+            #+win32 '(:search t) #-win32 nil))
 
     #+(or cmu scl)
     (ext:process-exit-code
@@ -1578,11 +1581,11 @@ output to `*verbose-out*`.  Returns the shell's exit code."
     #+allegro
     ;; will this fail if command has embedded quotes - it seems to work
     (multiple-value-bind (stdout stderr exit-code)
-        (excl.osi:command-output 
-	 (format nil "~a -c \"~a\"" 
-		 #+mswindows "sh" #-mswindows "/bin/sh" command)
-	 :input nil :whole nil
-	 #+mswindows :show-window #+mswindows :hide)
+        (excl.osi:command-output
+         (format nil "~a -c \"~a\""
+                 #+mswindows "sh" #-mswindows "/bin/sh" command)
+         :input nil :whole nil
+         #+mswindows :show-window #+mswindows :hide)
       (format *verbose-out* "~{~&; ~a~%~}~%" stderr)
       (format *verbose-out* "~{~&; ~a~%~}~%" stdout)
       exit-code)
@@ -1648,7 +1651,7 @@ their sources.")
 
 (defparameter *enable-asdf-binary-locations* nil
   "
-If true, then compiled lisp files will be placed into a directory 
+If true, then compiled lisp files will be placed into a directory
 computed from the Lisp version, Operating System and computer archetecture.
 See [implementation-specific-directory-name][] for details.")
 
@@ -1667,7 +1670,7 @@ See [implementation-specific-directory-name][] for details.")
   nil
   "If true, then all subclasses of source-file will have their output locations mapped by ASDF-Binary-Locations. If nil (the default), then only subclasses of cl-source-file will be mapped.")
 
-(defvar *source-to-target-mappings* 
+(defvar *source-to-target-mappings*
   #-sbcl
   nil
   #+sbcl
@@ -1675,7 +1678,7 @@ See [implementation-specific-directory-name][] for details.")
   "The \\*source-to-target-mappings\\* variable specifies mappings from source to target. If the target is nil, then it means to not map the source to anything. I.e., to leave it as is. This has the effect of turning off ASDF-Binary-Locations for the given source directory. Examples:
 
     ;; compile everything in .../src and below into .../cmucl
-    '((\"/nfs/home/compbio/d95-bli/share/common-lisp/src/\" 
+    '((\"/nfs/home/compbio/d95-bli/share/common-lisp/src/\"
        \"/nfs/home/compbio/d95-bli/lib/common-lisp/cmucl/\"))
 
     ;; leave SBCL innards alone (SBCL specific)
@@ -1694,25 +1697,25 @@ See [implementation-specific-directory-name][] for details.")
     :linux :unix))
 
 (defparameter *architecture-features*
-  '(:amd64 (:x86-64 :x86_64 :x8664-target) :i686 :i586 :pentium3 
+  '(:amd64 (:x86-64 :x86_64 :x8664-target) :i686 :i586 :pentium3
     :i486 (:i386 :pc386 :iapx386) (:x86 :x8632-target) :pentium4
     :hppa64 :hppa :ppc64 :ppc32 :powerpc :ppc :sparc64 :sparc))
 
 ;; note to gwking: this is in slime, system-check, and system-check-server too
 (defun lisp-version-string ()
-  #+cmu       (substitute #\- #\/ 
-			  (substitute #\_ #\Space 
-				      (lisp-implementation-version)))
+  #+cmu       (substitute #\- #\/
+                          (substitute #\_ #\Space
+                                      (lisp-implementation-version)))
   #+scl       (lisp-implementation-version)
   #+sbcl      (lisp-implementation-version)
   #+ecl       (reduce (lambda (x str) (substitute #\_ str x))
-		      '(#\Space #\: #\( #\)) 
-		      :initial-value (lisp-implementation-version))
+                      '(#\Space #\: #\( #\))
+                      :initial-value (lisp-implementation-version))
   #+gcl       (let ((s (lisp-implementation-version))) (subseq s 4))
   #+openmcl   (format nil "~d.~d~@[-~d~]"
-                      ccl::*openmcl-major-version* 
+                      ccl::*openmcl-major-version*
                       ccl::*openmcl-minor-version*
-                      #+ppc64-target 64 
+                      #+ppc64-target 64
                       #-ppc64-target nil)
   #+lispworks (format nil "~A~@[~A~]"
                       (lisp-implementation-version)
@@ -1720,16 +1723,16 @@ See [implementation-specific-directory-name][] for details.")
   #+allegro   (format nil
                       "~A~A~A~A"
                       excl::*common-lisp-version-number*
-					; ANSI vs MoDeRn
-		      ;; thanks to Robert Goldman and Charley Cox for
-		      ;; an improvement to my hack
-		      (if (eq excl:*current-case-mode* 
-			      :case-sensitive-lower) "M" "A")
-		      ;; Note if not using International ACL
-		      ;; see http://www.franz.com/support/documentation/8.1/doc/operators/excl/ics-target-case.htm
-		      (excl:ics-target-case
-			(:-ics "8")
-			(:+ics ""))
+                                        ; ANSI vs MoDeRn
+                      ;; thanks to Robert Goldman and Charley Cox for
+                      ;; an improvement to my hack
+                      (if (eq excl:*current-case-mode*
+                              :case-sensitive-lower) "M" "A")
+                      ;; Note if not using International ACL
+                      ;; see http://www.franz.com/support/documentation/8.1/doc/operators/excl/ics-target-case.htm
+                      (excl:ics-target-case
+                        (:-ics "8")
+                        (:+ics ""))
                       (if (member :64bit *features*) "-64bit" ""))
   #+clisp     (let ((s (lisp-implementation-version)))
                 (subseq s 0 (position #\space s)))
@@ -1745,40 +1748,40 @@ See [implementation-specific-directory-name][] for details.")
 unique to a Lisp implementation, Lisp implementation version,
 operating system, and hardware architecture."
   (and *enable-asdf-binary-locations*
-       (list 
-	(or *implementation-specific-directory-name*
-	    (setf *implementation-specific-directory-name*
-		  (labels 
-		      ((fp (thing)
-			 (etypecase thing
-			   (symbol
-			    (let ((feature (find thing *features*)))
-			      (when feature (return-from fp feature))))
-			   ;; allows features to be lists of which the first
-			   ;; member is the "main name", the rest being aliases
-			   (cons
-			    (dolist (subf thing)
-			      (let ((feature (find subf *features*)))
-				(when feature (return-from fp (first thing))))))))
-		       (first-of (features)
-			 (loop for f in features
-			    when (fp f) return it))
-		       (maybe-warn (value fstring &rest args)
-			 (cond (value)
-			       (t (apply #'warn fstring args)
-				  "unknown"))))
-		    (let ((lisp (maybe-warn (first-of *implementation-features*)
-					    "No implementation feature found in ~a." 
-					    *implementation-features*))
-			  (os   (maybe-warn (first-of *os-features*)
-					    "No os feature found in ~a." *os-features*))
-			  (arch (maybe-warn (first-of *architecture-features*)
-					    "No architecture feature found in ~a."
-					    *architecture-features*))
-			  (version (maybe-warn (lisp-version-string)
-					       "Don't know how to get Lisp ~
+       (list
+        (or *implementation-specific-directory-name*
+            (setf *implementation-specific-directory-name*
+                  (labels
+                      ((fp (thing)
+                         (etypecase thing
+                           (symbol
+                            (let ((feature (find thing *features*)))
+                              (when feature (return-from fp feature))))
+                           ;; allows features to be lists of which the first
+                           ;; member is the "main name", the rest being aliases
+                           (cons
+                            (dolist (subf thing)
+                              (let ((feature (find subf *features*)))
+                                (when feature (return-from fp (first thing))))))))
+                       (first-of (features)
+                         (loop for f in features
+                            when (fp f) return it))
+                       (maybe-warn (value fstring &rest args)
+                         (cond (value)
+                               (t (apply #'warn fstring args)
+                                  "unknown"))))
+                    (let ((lisp (maybe-warn (first-of *implementation-features*)
+                                            "No implementation feature found in ~a."
+                                            *implementation-features*))
+                          (os   (maybe-warn (first-of *os-features*)
+                                            "No os feature found in ~a." *os-features*))
+                          (arch (maybe-warn (first-of *architecture-features*)
+                                            "No architecture feature found in ~a."
+                                            *architecture-features*))
+                          (version (maybe-warn (lisp-version-string)
+                                               "Don't know how to get Lisp ~
                                           implementation version.")))
-		      (format nil "~(~@{~a~^-~}~)" lisp version os arch))))))))
+                      (format nil "~(~@{~a~^-~}~)" lisp version os arch))))))))
 
 (defun pathname-prefix-p (prefix pathname)
   (let ((prefix-ns (namestring prefix))
@@ -1800,11 +1803,11 @@ SBCL_HOME is set through that symlink, the default rule above
 preventing SBCL contribs from being mapped elsewhere will not be
 applied by the plain `*source-to-target-mappings*`."
   (loop for mapping in asdf:*source-to-target-mappings*
-	for (source target) = mapping
-	for true-source = (and source (resolve-symlinks source))
-	if (equal source true-source)
-	  collect mapping
-	else append (list mapping (list true-source target))))
+        for (source target) = mapping
+        for true-source = (and source (resolve-symlinks source))
+        if (equal source true-source)
+          collect mapping
+        else append (list mapping (list true-source target))))
 
 (defmethod output-files-for-system-and-operation
            ((system system) operation component source possible-paths)
@@ -1813,55 +1816,55 @@ applied by the plain `*source-to-target-mappings*`."
    source possible-paths (source-to-target-resolved-mappings)))
 
 (defmethod output-files-using-mappings (source possible-paths path-mappings)
-  (mapcar 
-   (lambda (path) 
-     (loop for (from to) in path-mappings 
-	when (pathname-prefix-p from source) 
-	do (return 
-	     (if to
-		 (merge-pathnames 
-		  (make-pathname :type (pathname-type path)) 
-		  (merge-pathnames (enough-namestring source from) 
-				   to))
-		 path))
-		  
-	finally
-	  (return 
-	    ;; Instead of just returning the path when we 
-	    ;; don't find a mapping, we stick stuff into 
-	    ;; the appropriate binary directory based on 
-	    ;; the implementation
-	    (if *centralize-lisp-binaries*
-		(merge-pathnames
-		 (make-pathname
-		  :type (pathname-type path)
-		  :directory `(:relative
-			       ,@(cond ((eq *include-per-user-information* t)
-					(cdr (pathname-directory
-					      (user-homedir-pathname))))
-				       ((not (null *include-per-user-information*))
-					(list *include-per-user-information*)))
-			       ,@(implementation-specific-directory-name)
-			       ,@(rest (pathname-directory path)))
-		  :defaults path)
-		 *default-toplevel-directory*)
-		(make-pathname 
-		 :type (pathname-type path)
-		 :directory (append
-			     (pathname-directory path)
-			     (implementation-specific-directory-name))
-		 :defaults path))))) 
-	  possible-paths))
-
-(defmethod output-files 
-    :around ((operation compile-op) (component source-file)) 
+  (mapcar
+   (lambda (path)
+     (loop for (from to) in path-mappings
+        when (pathname-prefix-p from source)
+        do (return
+             (if to
+                 (merge-pathnames
+                  (make-pathname :type (pathname-type path))
+                  (merge-pathnames (enough-namestring source from)
+                                   to))
+                 path))
+
+        finally
+          (return
+            ;; Instead of just returning the path when we
+            ;; don't find a mapping, we stick stuff into
+            ;; the appropriate binary directory based on
+            ;; the implementation
+            (if *centralize-lisp-binaries*
+                (merge-pathnames
+                 (make-pathname
+                  :type (pathname-type path)
+                  :directory `(:relative
+                               ,@(cond ((eq *include-per-user-information* t)
+                                        (cdr (pathname-directory
+                                              (user-homedir-pathname))))
+                                       ((not (null *include-per-user-information*))
+                                        (list *include-per-user-information*)))
+                               ,@(implementation-specific-directory-name)
+                               ,@(rest (pathname-directory path)))
+                  :defaults path)
+                 *default-toplevel-directory*)
+                (make-pathname
+                 :type (pathname-type path)
+                 :directory (append
+                             (pathname-directory path)
+                             (implementation-specific-directory-name))
+                 :defaults path)))))
+          possible-paths))
+
+(defmethod output-files
+    :around ((operation compile-op) (component source-file))
   (if (or *map-all-source-files*
-	    (typecase component 
-	      (cl-source-file t)
-	      (t nil)))
-    (let ((source (component-pathname component )) 
-	  (paths (call-next-method))) 
-      (output-files-for-system-and-operation 
+            (typecase component
+              (cl-source-file t)
+              (t nil)))
+    (let ((source (component-pathname component ))
+          (paths (call-next-method)))
+      (output-files-for-system-and-operation
        (component-system component) operation component source paths))
     (call-next-method)))
 
@@ -1878,71 +1881,71 @@ applied by the plain `*source-to-target-mappings*`."
 (defun read-null-terminated-string (s)
   (with-output-to-string (out)
     (loop
-	for code = (read-byte s)
-	until (zerop code)
-	do (write-char (code-char code) out))))
+        for code = (read-byte s)
+        until (zerop code)
+        do (write-char (code-char code) out))))
 
 (defun read-little-endian (s &optional (bytes 4))
   (let ((result 0))
     (loop
-	for i from 0 below bytes
-	do
-	  (setf result (logior result (ash (read-byte s) (* 8 i)))))
+        for i from 0 below bytes
+        do
+          (setf result (logior result (ash (read-byte s) (* 8 i)))))
     result))
 
 (defun parse-file-location-info (s)
   (let ((start (file-position s))
-	(total-length (read-little-endian s))
-	(end-of-header (read-little-endian s))
-	(fli-flags (read-little-endian s))
-	(local-volume-offset (read-little-endian s))
-	(local-offset (read-little-endian s))
-	(network-volume-offset (read-little-endian s))
-	(remaining-offset (read-little-endian s)))
+        (total-length (read-little-endian s))
+        (end-of-header (read-little-endian s))
+        (fli-flags (read-little-endian s))
+        (local-volume-offset (read-little-endian s))
+        (local-offset (read-little-endian s))
+        (network-volume-offset (read-little-endian s))
+        (remaining-offset (read-little-endian s)))
     (declare (ignore total-length end-of-header local-volume-offset))
     (unless (zerop fli-flags)
       (cond
-	((logbitp 0 fli-flags)
-	  (file-position s (+ start local-offset)))
-	((logbitp 1 fli-flags)
-	  (file-position s (+ start
-			      network-volume-offset
-			      #x14))))
+        ((logbitp 0 fli-flags)
+          (file-position s (+ start local-offset)))
+        ((logbitp 1 fli-flags)
+          (file-position s (+ start
+                              network-volume-offset
+                              #x14))))
       (concatenate 'string
-	(read-null-terminated-string s)
-	(progn
-	  (file-position s (+ start remaining-offset))
-	  (read-null-terminated-string s))))))
+        (read-null-terminated-string s)
+        (progn
+          (file-position s (+ start remaining-offset))
+          (read-null-terminated-string s))))))
 
 (defun parse-windows-shortcut (pathname)
   (with-open-file (s pathname :element-type '(unsigned-byte 8))
     (handler-case
-	(when (and (= (read-little-endian s) *link-initial-dword*)
-		   (let ((header (make-array (length *link-guid*))))
-		     (read-sequence header s)
-		     (equalp header *link-guid*)))
-	  (let ((flags (read-little-endian s)))
-	    (file-position s 76)	;skip rest of header
-	    (when (logbitp 0 flags)
-	      ;; skip shell item id list
-	      (let ((length (read-little-endian s 2)))
-		(file-position s (+ length (file-position s)))))
-	    (cond
-	      ((logbitp 1 flags)
-		(parse-file-location-info s))
-	      (t
-		(when (logbitp 2 flags)
-		  ;; skip description string
-		  (let ((length (read-little-endian s 2)))
-		    (file-position s (+ length (file-position s)))))
-		(when (logbitp 3 flags)
-		  ;; finally, our pathname
-		  (let* ((length (read-little-endian s 2))
-			 (buffer (make-array length)))
-		    (read-sequence buffer s)
-		    (map 'string #'code-char buffer)))))))
+        (when (and (= (read-little-endian s) *link-initial-dword*)
+                   (let ((header (make-array (length *link-guid*))))
+                     (read-sequence header s)
+                     (equalp header *link-guid*)))
+          (let ((flags (read-little-endian s)))
+            (file-position s 76)        ;skip rest of header
+            (when (logbitp 0 flags)
+              ;; skip shell item id list
+              (let ((length (read-little-endian s 2)))
+                (file-position s (+ length (file-position s)))))
+            (cond
+              ((logbitp 1 flags)
+                (parse-file-location-info s))
+              (t
+                (when (logbitp 2 flags)
+                  ;; skip description string
+                  (let ((length (read-little-endian s 2)))
+                    (file-position s (+ length (file-position s)))))
+                (when (logbitp 3 flags)
+                  ;; finally, our pathname
+                  (let* ((length (read-little-endian s 2))
+                         (buffer (make-array length)))
+                    (read-sequence buffer s)
+                    (map 'string #'code-char buffer)))))))
       (end-of-file ()
-	nil))))
+        nil))))
 
 (pushnew :asdf *features*)
 
@@ -2005,7 +2008,7 @@ applied by the plain `*source-to-target-mappings*`."
     (load
      (merge-pathnames
       (make-pathname :name "asdf-binary-locations"
-		     :type "lisp"
-		     :directory '(:relative ".asdf"))
+                     :type "lisp"
+                     :directory '(:relative ".asdf"))
       (truename (user-homedir-pathname)))
      :if-does-not-exist nil)))