X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fgeneric%2Fvm-tran.lisp;h=a78cf36fb6a8f4b4b8c708988f393e65bcb88ea7;hb=467a8e5dba8bfa2598ca8e22c1204dc173ce556f;hp=f4eb5c02478bcdeb8d88a0a98b82d17e46fbd0c0;hpb=a530bbe337109d898d5b4a001fc8f1afa3b5dc39;p=sbcl.git

diff --git a/src/compiler/generic/vm-tran.lisp b/src/compiler/generic/vm-tran.lisp
index f4eb5c0..a78cf36 100644
--- a/src/compiler/generic/vm-tran.lisp
+++ b/src/compiler/generic/vm-tran.lisp
@@ -11,9 +11,6 @@
 
 (in-package "SB!C")
 
-(file-comment
-  "$Header$")
-
 ;;; FIXME: It would be good to implement SB!XC:DEFCONSTANT, and use
 ;;; use that here, so that the compiler is born knowing this value.
 ;;; FIXME: Add a comment telling whether this holds for all vectors
@@ -21,9 +18,9 @@
 (defconstant vector-data-bit-offset
   (* sb!vm:vector-data-offset sb!vm:word-bits))
 
-;;; We need to define these predicates, since the TYPEP source transform picks
-;;; whichever predicate was defined last when there are multiple predicates for
-;;; equivalent types.
+;;; We need to define these predicates, since the TYPEP source
+;;; transform picks whichever predicate was defined last when there
+;;; are multiple predicates for equivalent types.
 (def-source-transform short-float-p (x) `(single-float-p ,x))
 #!-long-float
 (def-source-transform long-float-p (x) `(double-float-p ,x))
@@ -130,22 +127,22 @@
 			  new-value)))))
 
 (deftransform data-vector-set ((array index new-value)
-			       (simple-array t t))
+                               (simple-array t t))
   (let ((array-type (continuation-type array)))
     (unless (array-type-p array-type)
       (give-up-ir1-transform))
     (let ((dims (array-type-dimensions array-type)))
       (when (or (atom dims) (= (length dims) 1))
-	(give-up-ir1-transform))
+        (give-up-ir1-transform))
       (let ((el-type (array-type-element-type array-type))
-	    (total-size (if (member '* dims)
-			    '*
-			    (reduce #'* dims))))
-	`(data-vector-set (truly-the (simple-array ,(type-specifier el-type)
-						   (,total-size))
-				     (%array-data-vector array))
-			  index
-			  new-value)))))
+            (total-size (if (member '* dims)
+                            '*
+                            (reduce #'* dims))))
+        `(data-vector-set (truly-the (simple-array ,(type-specifier el-type)
+                                                   (,total-size))
+                                     (%array-data-vector array))
+                          index
+                          new-value)))))
 
 ;;; transforms for getting at simple arrays of (UNSIGNED-BYTE N) when (< N 8)
 ;;;
@@ -182,82 +179,6 @@
   (frob (simple-array (unsigned-byte 2) (*)) 2)
   (frob (simple-array (unsigned-byte 4) (*)) 4))
 
-;;;; simple string transforms
-
-(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))
-
-(deftransform replace ((string1 string2 &key (start1 0) (start2 0)
-				end1 end2)
-		       (simple-string simple-string &rest t))
-  `(locally (declare (optimize (safety 0)))
-     (bit-bash-copy string2
-		    (the index
-			 (+ (the index (* start2 sb!vm:byte-bits))
-			    ,vector-data-bit-offset))
-		    string1
-		    (the index
-			 (+ (the index (* start1 sb!vm:byte-bits))
-			    ,vector-data-bit-offset))
-		    (the index
-			 (* (min (the index (- (or end1 (length string1))
-					       start1))
-				 (the index (- (or end2 (length string2))
-					       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
 
 ;;; SIMPLE-BIT-VECTOR bit-array operations are transformed to a word loop that
@@ -360,3 +281,4 @@
 (deftransform eql ((x y) (double-float double-float))
   '(and (= (double-float-low-bits x) (double-float-low-bits y))
 	(= (double-float-high-bits x) (double-float-high-bits y))))
+