0.pre7.105:

[sbcl.git] / src / compiler / generic / vm-tran.lisp

diff --git a/src/compiler/generic/vm-tran.lisp b/src/compiler/generic/vm-tran.lisp
index 0d5849e..0b81b5f 100644 (file)
--- a/src/compiler/generic/vm-tran.lisp
+++ b/src/compiler/generic/vm-tran.lisp
@@ -16,34 +16,34 @@
 ;;; FIXME: Add a comment telling whether this holds for all vectors
 ;;; or only for vectors based on simple arrays (non-adjustable, etc.).
 (defconstant vector-data-bit-offset
-  (* sb!vm:vector-data-offset sb!vm:word-bits))
+  (* sb!vm:vector-data-offset sb!vm:n-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.
-(def-source-transform short-float-p (x) `(single-float-p ,x))
+(define-source-transform short-float-p (x) `(single-float-p ,x))
 #!-long-float
-(def-source-transform long-float-p (x) `(double-float-p ,x))
+(define-source-transform long-float-p (x) `(double-float-p ,x))
 
-(def-source-transform compiled-function-p (x)
+(define-source-transform compiled-function-p (x)
   `(functionp ,x))
 
-(def-source-transform char-int (x)
+(define-source-transform char-int (x)
   `(char-code ,x))
 
 (deftransform abs ((x) (rational))
   '(if (< x 0) (- x) x))
 
 ;;; The layout is stored in slot 0.
-(def-source-transform %instance-layout (x)
+(define-source-transform %instance-layout (x)
   `(truly-the layout (%instance-ref ,x 0)))
-(def-source-transform %set-instance-layout (x val)
+(define-source-transform %set-instance-layout (x val)
   `(%instance-set ,x 0 (the layout ,val)))
 \f
 ;;;; character support
 
 ;;; In our implementation there are really only BASE-CHARs.
-(def-source-transform characterp (obj)
+(define-source-transform characterp (obj)
   `(base-char-p ,obj))
 \f
 ;;;; simplifying HAIRY-DATA-VECTOR-REF and HAIRY-DATA-VECTOR-SET
@@ -153,7 +153,7 @@
 #+nil
 (macrolet
     ((frob (type bits)
-       (let ((elements-per-word (truncate sb!vm:word-bits bits)))
+       (let ((elements-per-word (truncate sb!vm:n-word-bits bits)))
         `(progn
            (deftransform data-vector-ref ((vector index)
                                           (,type *))
@@ -161,7 +161,7 @@
                   (floor index ,',elements-per-word)
                 (ldb ,(ecase sb!vm:target-byte-order
                         (:little-endian '(byte ,bits (* bit ,bits)))
-                        (:big-endian '(byte ,bits (- sb!vm:word-bits
+                        (:big-endian '(byte ,bits (- sb!vm:n-word-bits
                                                      (* (1+ bit) ,bits)))))
                      (%raw-bits vector (+ word sb!vm:vector-data-offset)))))
            (deftransform data-vector-set ((vector index new-value)
@@ -171,7 +171,7 @@
                 (setf (ldb ,(ecase sb!vm:target-byte-order
                               (:little-endian '(byte ,bits (* bit ,bits)))
                               (:big-endian
-                               '(byte ,bits (- sb!vm:word-bits
+                               '(byte ,bits (- sb!vm:n-word-bits
                                                (* (1+ bit) ,bits)))))
                            (%raw-bits vector (+ word sb!vm:vector-data-offset)))
                       new-value)))))))
@@ -212,8 +212,8 @@
              (end (+ sb!vm:vector-data-offset
                      (truncate (the index
                                     (+ (length bit-array-1)
-                                       sb!vm:word-bits -1))
-                               sb!vm:word-bits))))
+                                       sb!vm:n-word-bits -1))
+                               sb!vm:n-word-bits))))
             ((= index end) result-bit-array)
           (declare (optimize (speed 3) (safety 0))
                    (type index index end))
@@ -236,8 +236,8 @@
          (end (+ sb!vm:vector-data-offset
                  (truncate (the index
                                 (+ (length bit-array)
-                                   (1- sb!vm:word-bits)))
-                           sb!vm:word-bits))))
+                                   (1- sb!vm:n-word-bits)))
+                           sb!vm:n-word-bits))))
         ((= index end) result-bit-array)
        (declare (optimize (speed 3) (safety 0))
                (type index index end))