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)
   ;              (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))
   (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
     (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))
 
 (!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)
   (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 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)))
       (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)))))
     (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".)
 ;;; 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"