0.6.7.20: removed DEFTRANSFORMs for some consing string operations

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))))
 
 ;;;; bit vector hackery
 

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

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"