X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftypedefs.lisp;h=bcbfecea2be2161a06f4a08d6c116eece6e23be0;hb=7dd568fb64927be78556ac27f1f0dc60e79cf942;hp=e904423d0e38314f40b8d0df7b7a6ad51c322fbf;hpb=a530bbe337109d898d5b4a001fc8f1afa3b5dc39;p=sbcl.git

diff --git a/src/code/typedefs.lisp b/src/code/typedefs.lisp
index e904423..bcbfece 100644
--- a/src/code/typedefs.lisp
+++ b/src/code/typedefs.lisp
@@ -22,15 +22,12 @@
 
 (in-package "SB!KERNEL")
 
-(file-comment
-  "$Header$")
-
 (!begin-collecting-cold-init-forms)
 
 ;;; Define the translation from a type-specifier to a type structure for
 ;;; some particular type. Syntax is identical to DEFTYPE.
-(defmacro def-type-translator (name arglist &body body)
-  (check-type name symbol)
+(defmacro !def-type-translator (name arglist &body body)
+  (declare (type symbol name))
   ;; FIXME: Now that the T%CL hack is ancient history and we just use CL
   ;; instead, we can probably return to using PARSE-DEFMACRO here.
   ;;
@@ -44,8 +41,8 @@
   ;;   package!)
   (multiple-value-bind (whole wholeless-arglist)
       (if (eq '&whole (car arglist))
-	(values (cadr arglist) (cddr arglist))
-	(values (gensym) arglist))
+	  (values (cadr arglist) (cddr arglist))
+	  (values (gensym) arglist))
     (multiple-value-bind (forms decls) (parse-body body nil)
       `(progn
 	 (!cold-init-forms
@@ -61,25 +58,24 @@
 ;;; DEFVARs for these come later, after we have enough stuff defined.
 (declaim (special *wild-type* *universal-type* *empty-type*))
 
-;;; The XXX-Type structures include the CTYPE structure for some slots that
-;;; apply to all types.
+;;; the base class for the internal representation of types
 (def!struct (ctype (:conc-name type-)
 		   (:constructor nil)
 		   (:make-load-form-fun make-type-load-form)
 		   #-sb-xc-host (:pure t))
-  ;; The class of this type.
+  ;; the class of this type
   ;;
   ;; FIXME: It's unnecessarily confusing to have a structure accessor
   ;; named TYPE-CLASS-INFO which is an accessor for the CTYPE structure
   ;; even though the TYPE-CLASS structure also exists in the system.
   ;; Rename this slot: TYPE-CLASS or ASSOCIATED-TYPE-CLASS or something.
   (class-info (required-argument) :type type-class)
-  ;; True if this type has a fixed number of members, and as such could
-  ;; possibly be completely specified in a MEMBER type. This is used by the
-  ;; MEMBER type methods.
-  (enumerable nil :type (member t nil) :read-only t)
-  ;; an arbitrary hash code used in EQ-style hashing of identity (since EQ
-  ;; hashing can't be done portably)
+  ;; True if this type has a fixed number of members, and as such
+  ;; could possibly be completely specified in a MEMBER type. This is
+  ;; used by the MEMBER type methods.
+  (enumerable nil :read-only t)
+  ;; an arbitrary hash code used in EQ-style hashing of identity
+  ;; (since EQ hashing can't be done portably)
   (hash-value (random (1+ most-positive-fixnum))
 	      :type (and fixnum unsigned-byte)
 	      :read-only t))
@@ -92,65 +88,26 @@
   (declare (type ctype type))
   `(specifier-type ',(type-specifier type)))
 
-;;;; utilities
-
-;;; Like ANY and EVERY, except that we handle two-arg uncertain predicates.
-;;; If the result is uncertain, then we return Default from the block PUNT.
-;;; If LIST-FIRST is true, then the list element is the first arg, otherwise
-;;; the second.
-(defmacro any-type-op (op thing list &key (default '(values nil nil))
-			  list-first)
-  (let ((n-this (gensym))
-	(n-thing (gensym))
-	(n-val (gensym))
-	(n-win (gensym))
-	(n-uncertain (gensym)))
-    `(let ((,n-thing ,thing)
-	   (,n-uncertain nil))
-       (dolist (,n-this ,list
-			(if ,n-uncertain
-			    (return-from PUNT ,default)
-			    nil))
-	 (multiple-value-bind (,n-val ,n-win)
-	     ,(if list-first
-		  `(,op ,n-this ,n-thing)
-		`(,op ,n-thing ,n-this))
-	   (unless ,n-win (setq ,n-uncertain t))
-	   (when ,n-val (return t)))))))
-(defmacro every-type-op (op thing list &key (default '(values nil nil))
-			    list-first)
-  (let ((n-this (gensym))
-	(n-thing (gensym))
-	(n-val (gensym))
-	(n-win (gensym)))
-    `(let ((,n-thing ,thing))
-       (dolist (,n-this ,list t)
-	 (multiple-value-bind (,n-val ,n-win)
-	     ,(if list-first
-		  `(,op ,n-this ,n-thing)
-		`(,op ,n-thing ,n-this))
-	   (unless ,n-win (return-from PUNT ,default))
-	   (unless ,n-val (return nil)))))))
-
-;;; Compute the intersection for types that intersect only when one is a
-;;; hierarchical subtype of the other.
-(defun vanilla-intersection (type1 type2)
-  (multiple-value-bind (stp1 win1) (csubtypep type1 type2)
-    (multiple-value-bind (stp2 win2) (csubtypep type2 type1)
-      (cond (stp1 (values type1 t))
-	    (stp2 (values type2 t))
-	    ((and win1 win2) (values *empty-type* t))
-	    (t
-	     (values type1 nil))))))
+;;;; miscellany
 
-(defun vanilla-union (type1 type2)
+;;; Look for nice relationships for types that have nice relationships
+;;; only when one is a hierarchical subtype of the other.
+(defun hierarchical-intersection2 (type1 type2)
+  (multiple-value-bind (subtypep1 win1) (csubtypep type1 type2)
+    (multiple-value-bind (subtypep2 win2) (csubtypep type2 type1)
+      (cond (subtypep1 type1)
+	    (subtypep2 type2)
+	    ((and win1 win2) *empty-type*)
+	    (t nil)))))
+(defun hierarchical-union2 (type1 type2)
   (cond ((csubtypep type1 type2) type2)
 	((csubtypep type2 type1) type1)
 	(t nil)))
 
-;;; Hash two things (types) down to 8 bits. In CMU CL this was an EQ hash, but
-;;; since it now needs to run in vanilla ANSI Common Lisp at cross-compile
-;;; time, it's now based on the CTYPE-HASH-VALUE field instead.
+;;; Hash two things (types) down to 8 bits. In CMU CL this was an EQ
+;;; hash, but since it now needs to run in vanilla ANSI Common Lisp at
+;;; cross-compile time, it's now based on the CTYPE-HASH-VALUE field
+;;; instead.
 ;;;
 ;;; FIXME: This was a macro in CMU CL, and is now an INLINE function. Is
 ;;; it important for it to be INLINE, or could be become an ordinary