X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ftypetran.lisp;h=e1983791e4b269399efbd3505756eeaea9be1938;hb=98a76d4426660876dec6649b1e228d2e5b47f579;hp=f41a06062c4b14e3ba4851f05aaf9f679cca653d;hpb=dea9bd5c1afe23d9e061c60db654b88187ba9a5e;p=sbcl.git

diff --git a/src/compiler/typetran.lisp b/src/compiler/typetran.lisp
index f41a060..e198379 100644
--- a/src/compiler/typetran.lisp
+++ b/src/compiler/typetran.lisp
@@ -72,6 +72,8 @@
 	   nil)
 	  ((csubtypep otype type)
 	   t)
+          ((eq type *empty-type*)
+           nil)
 	  (t
 	   (give-up-ir1-transform)))))
 
@@ -97,10 +99,10 @@
 
 ;;; If FIND-CLASS is called on a constant class, locate the CLASS-CELL
 ;;; at load time.
-(deftransform find-class ((name) ((constant-arg symbol)) *)
+(deftransform find-classoid ((name) ((constant-arg symbol)) *)
   (let* ((name (continuation-value name))
-	 (cell (find-class-cell name)))
-    `(or (class-cell-class ',cell)
+	 (cell (find-classoid-cell name)))
+    `(or (classoid-cell-classoid ',cell)
 	 (error "class not yet defined: ~S" name))))
 
 ;;;; standard type predicates, i.e. those defined in package COMMON-LISP,
@@ -153,7 +155,6 @@
 ;;; binds specified by TYPE. BASE is the name of the base type, for
 ;;; declaration. We make SAFETY locally 0 to inhibit any checking of
 ;;; this assertion.
-#!-negative-zero-is-not-zero
 (defun transform-numeric-bound-test (n-object type base)
   (declare (type numeric-type type))
   (let ((low (numeric-type-low type))
@@ -169,49 +170,6 @@
 		    `((< (the ,base ,n-object) ,(car high)))
 		    `((<= (the ,base ,n-object) ,high))))))))
 
-#!+negative-zero-is-not-zero
-(defun transform-numeric-bound-test (n-object type base)
-  (declare (type numeric-type type))
-  (let ((low (numeric-type-low type))
-	(high (numeric-type-high type))
-	(float-type-p (csubtypep type (specifier-type 'float)))
-	(x (gensym))
-	(y (gensym)))
-    `(locally
-       (declare (optimize (safety 0)))
-       (and ,@(when low
-		(if (consp low)
-		    `((let ((,x (the ,base ,n-object))
-			    (,y ,(car low)))
-			,(if (not float-type-p)
-			    `(> ,x ,y)
-			    `(if (and (zerop ,x) (zerop ,y))
-				 (> (float-sign ,x) (float-sign ,y))
-				 (> ,x ,y)))))
-		    `((let ((,x (the ,base ,n-object))
-			    (,y ,low))
-			,(if (not float-type-p)
-			    `(>= ,x ,y)
-			    `(if (and (zerop ,x) (zerop ,y))
-				 (>= (float-sign ,x) (float-sign ,y))
-				 (>= ,x ,y)))))))
-	    ,@(when high
-		(if (consp high)
-		    `((let ((,x (the ,base ,n-object))
-			    (,y ,(car high)))
-			,(if (not float-type-p)
-			     `(< ,x ,y)
-			     `(if (and (zerop ,x) (zerop ,y))
-				  (< (float-sign ,x) (float-sign ,y))
-				  (< ,x ,y)))))
-		    `((let ((,x (the ,base ,n-object))
-			    (,y ,high))
-			,(if (not float-type-p)
-			     `(<= ,x ,y)
-			     `(if (and (zerop ,x) (zerop ,y))
-				  (<= (float-sign ,x) (float-sign ,y))
-				  (<= ,x ,y)))))))))))
-
 ;;; Do source transformation of a test of a known numeric type. We can
 ;;; assume that the type doesn't have a corresponding predicate, since
 ;;; those types have already been picked off. In particular, CLASS
@@ -274,6 +232,11 @@
 					    `(typep ,n-obj ',x))
 					  (rest spec))))))))))
 
+(defun source-transform-negation-typep (object type)
+  (declare (type negation-type type))
+  (let ((spec (type-specifier (negation-type-type type))))
+    `(not (typep ,object ',spec))))
+
 ;;; Do source transformation for TYPEP of a known union type. If a
 ;;; union type contains LIST, then we pull that out and make it into a
 ;;; single LISTP call. Note that if SYMBOL is in the union, then LIST
@@ -388,7 +351,7 @@
   (aver (constant-continuation-p spec))
   (let* ((spec (continuation-value spec))
 	 (class (specifier-type spec))
-	 (name (sb!xc:class-name class))
+	 (name (classoid-name class))
 	 (otype (continuation-type object))
 	 (layout (let ((res (info :type :compiler-layout name)))
 		   (if (and res (not (layout-invalid res)))
@@ -401,7 +364,7 @@
       ((csubtypep otype class)
        t)
       ;; If not properly named, error.
-      ((not (and name (eq (sb!xc:find-class name) class)))
+      ((not (and name (eq (find-classoid name) class)))
        (compiler-error "can't compile TYPEP of anonymous or undefined ~
 			class:~%  ~S"
 		       class))
@@ -419,8 +382,8 @@
 	     (t
 	      (values '(lambda (x) (declare (ignore x)) t) 'layout-of)))
 	 (cond
-	   ((and (eq (class-state class) :sealed) layout
-		 (not (class-subclasses class)))
+	   ((and (eq (classoid-state class) :sealed) layout
+		 (not (classoid-subclasses class)))
 	    ;; Sealed and has no subclasses.
 	    (let ((n-layout (gensym)))
 	      `(and (,pred object)
@@ -429,7 +392,7 @@
 			      `((when (layout-invalid ,n-layout)
 				  (%layout-invalid-error object ',layout))))
 		      (eq ,n-layout ',layout)))))
-	   ((and (typep class 'basic-structure-class) layout)
+	   ((and (typep class 'basic-structure-classoid) layout)
 	    ;; structure type tests; hierarchical layout depths
 	    (let ((depthoid (layout-depthoid layout))
 		  (n-layout (gensym)))
@@ -467,9 +430,9 @@
 	   (t
 	    (/noshow "default case -- ,PRED and CLASS-CELL-TYPEP")
 	    `(and (,pred object)
-		  (class-cell-typep (,get-layout object)
-				    ',(find-class-cell name)
-				    object)))))))))
+		  (classoid-cell-typep (,get-layout object)
+				       ',(find-classoid-cell name)
+		                       object)))))))))
 
 ;;; If the specifier argument is a quoted constant, then we consider
 ;;; converting into a simple predicate or other stuff. If the type is
@@ -503,6 +466,8 @@
 	    (typecase type
 	      (hairy-type
 	       (source-transform-hairy-typep object type))
+	      (negation-type
+	       (source-transform-negation-typep object type))
 	      (union-type
 	       (source-transform-union-typep object type))
 	      (intersection-type
@@ -517,7 +482,7 @@
 	    (typecase type
 	      (numeric-type
 	       (source-transform-numeric-typep object type))
-	      (sb!xc:class
+	      (classoid
 	       `(%instance-typep ,object ,spec))
 	      (array-type
 	       (source-transform-array-typep object type))
@@ -529,7 +494,7 @@
 
 ;;;; coercion
 
-(deftransform coerce ((x type) (* *) *)
+(deftransform coerce ((x type) (* *) * :node node)
   (unless (constant-continuation-p type)
     (give-up-ir1-transform))
   (let ((tspec (ir1-transform-specifier-type (continuation-value type))))
@@ -544,7 +509,18 @@
 	     ;; FIXME: #!+long-float (t ,(error "LONG-FLOAT case needed"))
 	     ((csubtypep tspec (specifier-type 'float))
 	      '(%single-float x))
-	     ;; FIXME: VECTOR types?
+	     ((and (csubtypep tspec (specifier-type 'simple-vector))
+		   ;; Can we avoid checking for dimension issues like
+		   ;; (COERCE FOO '(SIMPLE-VECTOR 5)) returning a
+		   ;; vector of length 6?
+		   (or (policy node (< safety 3)) ; no need in unsafe code
+		       (and (array-type-p tspec) ; no need when no dimensions
+			    (equal (array-type-dimensions tspec) '(*)))))
+	      `(if (simple-vector-p x)
+		   x
+		   (replace (make-array (length x)) x)))
+	     ;; FIXME: other VECTOR types?
 	     (t
 	      (give-up-ir1-transform)))))))
 
+