0.9.3.11:

   Convert inadvertent tabs into spaces in source code.

diff --git a/src/code/early-type.lisp b/src/code/early-type.lisp
index b1833ec..31f05ae 100644 (file)
--- a/src/code/early-type.lisp
+++ b/src/code/early-type.lisp
@@ -341,9 +341,9 @@
   ;              (sort (mapcar #'car pairs) #'<)))
   ;; aver that the cars of the list elements are sorted into increasing order
   (aver (or (null pairs)
-           (do ((p pairs (cdr p)))
-               ((null (cdr p)) t)
-             (when (> (caar p) (caadr p)) (return nil)))))
+            (do ((p pairs (cdr p)))
+                ((null (cdr p)) t)
+              (when (> (caar p) (caadr p)) (return nil)))))
   (let ((pairs (let (result)
                 (do ((pairs pairs (cdr pairs)))
                     ((null pairs) (nreverse result))

diff --git a/src/code/late-type.lisp b/src/code/late-type.lisp
index 2851198..c2f9370 100644 (file)
--- a/src/code/late-type.lisp
+++ b/src/code/late-type.lisp
@@ -2958,7 +2958,7 @@
     (t (let ((pairs (character-set-type-pairs type)))
         `(member ,@(loop for (low . high) in pairs
                          nconc (loop for code from low upto high
-                                    collect (sb!xc:code-char code))))))))
+                                     collect (sb!xc:code-char code))))))))
 
 (!define-type-method (character-set :simple-=) (type1 type2)
   (let ((pairs1 (character-set-type-pairs type1))

diff --git a/src/code/seq.lisp b/src/code/seq.lisp
index e88cb37..67ade1b 100644 (file)
--- a/src/code/seq.lisp
+++ b/src/code/seq.lisp
@@ -1549,76 +1549,76 @@
   (let* ((result (list ())) ; Put a marker on the beginning to splice with.
          (splice result)
          (current list)
-        (end (or end (length list)))
-        (hash (and test
-                   (not key)
-                   (not test-not)
-                   (or (eql test #'eql)
-                       (eql test #'eq)
-                       (eql test #'equal)
-                       (eql test #'equalp))
-                   ; (> (- end start) 20)
-                   (make-hash-table :test test :size (- end start)))))
+         (end (or end (length list)))
+         (hash (and test
+                    (not key)
+                    (not test-not)
+                    (or (eql test #'eql)
+                        (eql test #'eq)
+                        (eql test #'equal)
+                        (eql test #'equalp))
+                    ; (> (- end start) 20)
+                    (make-hash-table :test test :size (- end start)))))
     (do ((index 0 (1+ index)))
         ((= index start))
       (declare (fixnum index))
       (setq splice (cdr (rplacd splice (list (car current)))))
       (setq current (cdr current)))
     (if hash
-       (do ((index start (1+ index)))
-           ((or (and end (= index (the fixnum end)))
-                (atom current)))
-         (declare (fixnum index))
-         ;; The hash table contains links from values that are
-         ;; already in result to the cons cell *preceding* theirs
-         ;; in the list.  That is, for each value v in the list,
-         ;; v and (cadr (gethash v hash)) are equal under TEST.
-         (let ((prev (gethash (car current) hash)))
-           (cond
-            ((not prev)
-             (setf (gethash (car current) hash) splice)
-             (setq splice (cdr (rplacd splice (list (car current))))))
-            ((not from-end)
-             (let* ((old (cdr prev))
-                    (next (cdr old)))
-               (if next
-                 (let ((next-val (car next)))
-                   ;; (assert (eq (gethash next-val hash) old))
-                   (setf (cdr prev) next
-                         (gethash next-val hash) prev
-                         (gethash (car current) hash) splice
-                         splice (cdr (rplacd splice (list (car current))))))
-                 (setf (car old) (car current)))))))
-         (setq current (cdr current)))
+        (do ((index start (1+ index)))
+            ((or (and end (= index (the fixnum end)))
+                 (atom current)))
+          (declare (fixnum index))
+          ;; The hash table contains links from values that are
+          ;; already in result to the cons cell *preceding* theirs
+          ;; in the list.  That is, for each value v in the list,
+          ;; v and (cadr (gethash v hash)) are equal under TEST.
+          (let ((prev (gethash (car current) hash)))
+            (cond
+             ((not prev)
+              (setf (gethash (car current) hash) splice)
+              (setq splice (cdr (rplacd splice (list (car current))))))
+             ((not from-end)
+              (let* ((old (cdr prev))
+                     (next (cdr old)))
+                (if next
+                  (let ((next-val (car next)))
+                    ;; (assert (eq (gethash next-val hash) old))
+                    (setf (cdr prev) next
+                          (gethash next-val hash) prev
+                          (gethash (car current) hash) splice
+                          splice (cdr (rplacd splice (list (car current))))))
+                  (setf (car old) (car current)))))))
+          (setq current (cdr current)))
       (do ((index start (1+ index)))
-         ((or (and end (= index (the fixnum end)))
-              (atom current)))
-       (declare (fixnum index))
-       (if (or (and from-end
-                    (not (if test-not
-                             (member (apply-key key (car current))
-                                     (nthcdr (1+ start) result)
-                                     :test-not test-not
-                                     :key key)
-                           (member (apply-key key (car current))
-                                   (nthcdr (1+ start) result)
-                                   :test test
-                                   :key key))))
-               (and (not from-end)
-                    (not (do ((it (apply-key key (car current)))
-                              (l (cdr current) (cdr l))
-                              (i (1+ index) (1+ i)))
-                             ((or (atom l) (and end (= i (the fixnum end))))
-                              ())
-                           (declare (fixnum i))
-                           (if (if test-not
-                                   (not (funcall test-not
-                                                 it
-                                                 (apply-key key (car l))))
-                                 (funcall test it (apply-key key (car l))))
-                               (return t))))))
-           (setq splice (cdr (rplacd splice (list (car current))))))
-       (setq current (cdr current))))
+          ((or (and end (= index (the fixnum end)))
+               (atom current)))
+        (declare (fixnum index))
+        (if (or (and from-end
+                     (not (if test-not
+                              (member (apply-key key (car current))
+                                      (nthcdr (1+ start) result)
+                                      :test-not test-not
+                                      :key key)
+                            (member (apply-key key (car current))
+                                    (nthcdr (1+ start) result)
+                                    :test test
+                                    :key key))))
+                (and (not from-end)
+                     (not (do ((it (apply-key key (car current)))
+                               (l (cdr current) (cdr l))
+                               (i (1+ index) (1+ i)))
+                              ((or (atom l) (and end (= i (the fixnum end))))
+                               ())
+                            (declare (fixnum i))
+                            (if (if test-not
+                                    (not (funcall test-not
+                                                  it
+                                                  (apply-key key (car l))))
+                                  (funcall test it (apply-key key (car l))))
+                                (return t))))))
+            (setq splice (cdr (rplacd splice (list (car current))))))
+        (setq current (cdr current))))
     (do ()
         ((atom current))
       (setq splice (cdr (rplacd splice (list (car current)))))

diff --git a/version.lisp-expr b/version.lisp-expr
index 1fa456c..b558fd8 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -17,4 +17,4 @@
 ;;; checkins which aren't released. (And occasionally for internal
 ;;; versions, especially for internal versions off the main CVS
 ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)
-"0.9.3.10"
+"0.9.3.11"