X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcompiler%2Fsrctran.lisp;h=478e5785e048a265bf7e48aa1b6ba1306df2c3a4;hb=c41cb4c87eae7b04f844dca5f7edb5086c5d2d68;hp=fb6f0f765e890259d4cc72ccef13062fe1fdbb69;hpb=b42068e9080417a073dcb709cdd2e0315599b3df;p=sbcl.git

diff --git a/src/compiler/srctran.lisp b/src/compiler/srctran.lisp
index fb6f0f7..478e578 100644
--- a/src/compiler/srctran.lisp
+++ b/src/compiler/srctran.lisp
@@ -1001,41 +1001,41 @@
 ;;; a function.
 ;;;
 ;;; Given the continuation ARG, derive the resulting type using the
-;;; DERIVE-FCN. DERIVE-FCN takes exactly one argument which is some
+;;; DERIVE-FUN. DERIVE-FUN takes exactly one argument which is some
 ;;; "atomic" continuation type like numeric-type or member-type
 ;;; (containing just one element). It should return the resulting
 ;;; type, which can be a list of types.
 ;;;
-;;; For the case of member types, if a member-fcn is given it is
+;;; For the case of member types, if a MEMBER-FUN is given it is
 ;;; called to compute the result otherwise the member type is first
-;;; converted to a numeric type and the derive-fcn is call.
-(defun one-arg-derive-type (arg derive-fcn member-fcn
+;;; converted to a numeric type and the DERIVE-FUN is called.
+(defun one-arg-derive-type (arg derive-fun member-fun
 				&optional (convert-type t))
-  (declare (type function derive-fcn)
-	   (type (or null function) member-fcn))
+  (declare (type function derive-fun)
+	   (type (or null function) member-fun))
   (let ((arg-list (prepare-arg-for-derive-type (continuation-type arg))))
     (when arg-list
       (flet ((deriver (x)
 	       (typecase x
 		 (member-type
-		  (if member-fcn
+		  (if member-fun
 		      (with-float-traps-masked
 			  (:underflow :overflow :divide-by-zero)
 			(make-member-type
 			 :members (list
-				   (funcall member-fcn
+				   (funcall member-fun
 					    (first (member-type-members x))))))
 		      ;; Otherwise convert to a numeric type.
 		      (let ((result-type-list
-			     (funcall derive-fcn (convert-member-type x))))
+			     (funcall derive-fun (convert-member-type x))))
 			(if convert-type
 			    (convert-back-numeric-type-list result-type-list)
 			    result-type-list))))
 		 (numeric-type
 		  (if convert-type
 		      (convert-back-numeric-type-list
-		       (funcall derive-fcn (convert-numeric-type x)))
-		      (funcall derive-fcn x)))
+		       (funcall derive-fun (convert-numeric-type x)))
+		      (funcall derive-fun x)))
 		 (t
 		  *universal-type*))))
 	;; Run down the list of args and derive the type of each one,
@@ -1051,14 +1051,14 @@
 	      (first results)))))))
 
 ;;; Same as ONE-ARG-DERIVE-TYPE, except we assume the function takes
-;;; two arguments. DERIVE-FCN takes 3 args in this case: the two
+;;; two arguments. DERIVE-FUN takes 3 args in this case: the two
 ;;; original args and a third which is T to indicate if the two args
 ;;; really represent the same continuation. This is useful for
 ;;; deriving the type of things like (* x x), which should always be
 ;;; positive. If we didn't do this, we wouldn't be able to tell.
-(defun two-arg-derive-type (arg1 arg2 derive-fcn fcn
+(defun two-arg-derive-type (arg1 arg2 derive-fun fun
 				 &optional (convert-type t))
-  (declare (type function derive-fcn fcn))
+  (declare (type function derive-fun fun))
   (flet ((deriver (x y same-arg)
 	   (cond ((and (member-type-p x) (member-type-p y))
 		  (let* ((x (first (member-type-members x)))
@@ -1066,7 +1066,7 @@
 			 (result (with-float-traps-masked
 				     (:underflow :overflow :divide-by-zero
 				      :invalid)
-				   (funcall fcn x y))))
+				   (funcall fun x y))))
 		    (cond ((null result))
 			  ((and (floatp result) (float-nan-p result))
 			   (make-numeric-type :class 'float
@@ -1077,21 +1077,21 @@
 		 ((and (member-type-p x) (numeric-type-p y))
 		  (let* ((x (convert-member-type x))
 			 (y (if convert-type (convert-numeric-type y) y))
-			 (result (funcall derive-fcn x y same-arg)))
+			 (result (funcall derive-fun x y same-arg)))
 		    (if convert-type
 			(convert-back-numeric-type-list result)
 			result)))
 		 ((and (numeric-type-p x) (member-type-p y))
 		  (let* ((x (if convert-type (convert-numeric-type x) x))
 			 (y (convert-member-type y))
-			 (result (funcall derive-fcn x y same-arg)))
+			 (result (funcall derive-fun x y same-arg)))
 		    (if convert-type
 			(convert-back-numeric-type-list result)
 			result)))
 		 ((and (numeric-type-p x) (numeric-type-p y))
 		  (let* ((x (if convert-type (convert-numeric-type x) x))
 			 (y (if convert-type (convert-numeric-type y) y))
-			 (result (funcall derive-fcn x y same-arg)))
+			 (result (funcall derive-fun x y same-arg)))
 		    (if convert-type
 			(convert-back-numeric-type-list result)
 			result)))
@@ -2226,10 +2226,10 @@
        (t
 	(specifier-type 'integer))))))
 
-(macrolet ((deffrob (logfcn)
-	     (let ((fcn-aux (symbolicate logfcn "-DERIVE-TYPE-AUX")))
-	     `(defoptimizer (,logfcn derive-type) ((x y))
-		(two-arg-derive-type x y #',fcn-aux #',logfcn)))))
+(macrolet ((deffrob (logfun)
+	     (let ((fun-aux (symbolicate logfun "-DERIVE-TYPE-AUX")))
+	     `(defoptimizer (,logfun derive-type) ((x y))
+		(two-arg-derive-type x y #',fun-aux #',logfun)))))
   (deffrob logand)
   (deffrob logior)
   (deffrob logxor))