0.6.7.20: removed DEFTRANSFORMs for some consing string operations

diff --git a/src/compiler/generic/vm-tran.lisp b/src/compiler/generic/vm-tran.lisp
index d0e4395..a191047 100644 (file)
--- a/src/compiler/generic/vm-tran.lisp
+++ b/src/compiler/generic/vm-tran.lisp
@@ -191,36 +191,19 @@
 ;;;; function call overhead or on the overhead of runtime type
 ;;;; dispatch in AREF.
 
-(deftransform subseq ((string start &optional (end nil))
-                     (simple-string t &optional t))
-  `(let* ((length (- (or end (length string))
-                    start))
-         (result (make-string length)))
-     (declare (optimize (safety 0)))
-     (bit-bash-copy string
-                   (the index
-                        (+ (the index (* start sb!vm:byte-bits))
-                           ,vector-data-bit-offset))
-                   result
-                   ,vector-data-bit-offset
-                   (the index (* length sb!vm:byte-bits)))
-     result))
-
-(deftransform copy-seq ((seq) (simple-string))
-  `(let* ((length (length seq))
-         (res (make-string length)))
-     (declare (optimize (safety 0)))
-     (bit-bash-copy seq
-                   ,vector-data-bit-offset
-                   res
-                   ,vector-data-bit-offset
-                   (the index (* length sb!vm:byte-bits)))
-     res))
-
+;;; FIXME: Shouldn't we be testing for legality of
+;;;   * START1, START2, END1, and END2 indices?
+;;;   * size of copied string relative to destination string?
+;;; (Either there should be tests conditional on SAFETY>=SPEED, or
+;;; the transform should be conditional on SPEED>SAFETY.)
+;;;
+;;; FIXME: Also, the transform should probably be dependent on
+;;; SPEED>SPACE.
 (deftransform replace ((string1 string2 &key (start1 0) (start2 0)
                                end1 end2)
                       (simple-string simple-string &rest t))
-  `(locally (declare (optimize (safety 0)))
+  `(locally
+     (declare (optimize (safety 0)))
      (bit-bash-copy string2
                    (the index
                         (+ (the index (* start2 sb!vm:byte-bits))
@@ -236,34 +219,6 @@
                                               start2)))
                            sb!vm:byte-bits)))
      string1))
-
-(deftransform concatenate ((rtype &rest sequences)
-                          (t &rest simple-string)
-                          simple-string)
-  (collect ((lets)
-           (forms)
-           (all-lengths)
-           (args))
-    (dolist (seq sequences)
-      (declare (ignore seq))
-      (let ((n-seq (gensym))
-           (n-length (gensym)))
-       (args n-seq)
-       (lets `(,n-length (the index (* (length ,n-seq) sb!vm:byte-bits))))
-       (all-lengths n-length)
-       (forms `(bit-bash-copy ,n-seq ,vector-data-bit-offset
-                              res start
-                              ,n-length))
-       (forms `(setq start (+ start ,n-length)))))
-    `(lambda (rtype ,@(args))
-       (declare (ignore rtype))
-       (let* (,@(lets)
-             (res (make-string (truncate (the index (+ ,@(all-lengths)))
-                                         sb!vm:byte-bits)))
-             (start ,vector-data-bit-offset))
-        (declare (type index start ,@(all-lengths)))
-        ,@(forms)
-        res))))
 \f
 ;;;; bit vector hackery
 

diff --git a/tests/run-tests.sh b/tests/run-tests.sh
index 9b75c37..809ec8f 100644 (file)
--- a/tests/run-tests.sh
+++ b/tests/run-tests.sh
@@ -3,10 +3,10 @@
 # Run the regression tests in this directory.
 
 # how we invoke SBCL
-sbcl=${1:-sbcl --noinform --noprint --noprogrammer}
+sbcl=${1:-../src/runtime/sbcl --core ../output/sbcl.core --noinform --noprint --noprogrammer}
 
 # "Ten four" is the closest numerical slang I can find to "OK", so
-# it's the return value we expect from a successful test.
+# it's the return value that we expect from a successful test.
 tenfour () {
     if [ $? = 104 ]; then
        echo ok

diff --git a/version.lisp-expr b/version.lisp-expr
index c8fa080..8b646d2 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -15,4 +15,4 @@
 ;;; versions, and a string a la "0.6.5.12" is used for versions which
 ;;; aren't released but correspond only to CVS tags or snapshots.
 
-"0.6.7.19"
+"0.6.7.20"