X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ffloat.lisp;h=bb60ed5607e0852d07f090a95f279b75c9847d26;hb=90ca09b75fbc3b63b2f7d09c67b04b866dd783f6;hp=be2fc98583d02667945c6c58232dd41639ef363c;hpb=5b06386093fe448abe3a9086fae4f8e15709d8a3;p=sbcl.git

diff --git a/src/code/float.lisp b/src/code/float.lisp
index be2fc98..bb60ed5 100644
--- a/src/code/float.lisp
+++ b/src/code/float.lisp
@@ -19,9 +19,10 @@
 
 (eval-when (:compile-toplevel :load-toplevel :execute)
 
-;;; These functions let us create floats from bits with the significand
-;;; uniformly represented as an integer. This is less efficient for double
-;;; floats, but is more convenient when making special values, etc.
+;;; These functions let us create floats from bits with the
+;;; significand uniformly represented as an integer. This is less
+;;; efficient for double floats, but is more convenient when making
+;;; special values, etc.
 (defun single-from-bits (sign exp sig)
   (declare (type bit sign) (type (unsigned-byte 24) sig)
 	   (type (unsigned-byte 8) exp))
@@ -119,8 +120,10 @@
 
 ;;; We don't want to do these DEFCONSTANTs at cross-compilation time,
 ;;; because the cross-compilation host might not support floating
-;;; point infinities.
-(eval-when (:load-toplevel :execute)
+;;; point infinities. Putting them inside a LET removes
+;;; toplevel-formness, so that any EVAL-WHEN trickiness in the
+;;; DEFCONSTANT forms is suppressed.
+(let ()
 (defconstant single-float-positive-infinity
   (single-from-bits 0 (1+ sb!vm:single-float-normal-exponent-max) 0))
 (defconstant short-float-positive-infinity single-float-positive-infinity)
@@ -143,7 +146,7 @@
 (defconstant long-float-negative-infinity
   (long-from-bits 1 (1+ sb!vm:long-float-normal-exponent-max)
 		  (ash sb!vm:long-float-hidden-bit 32)))
-) ; EVAL-WHEN
+) ; LET-to-suppress-possible-EVAL-WHENs
 
 (defconstant single-float-epsilon
   (single-from-bits 0 (- sb!vm:single-float-bias
@@ -252,7 +255,7 @@
 #!-sb-fluid (declaim (maybe-inline float-precision))
 (defun float-precision (f)
   #!+sb-doc
-  "Returns a non-negative number of significant digits in its float argument.
+  "Return a non-negative number of significant digits in its float argument.
   Will be less than FLOAT-DIGITS if denormalized or zero."
   (macrolet ((frob (digits bias decode)
 	       `(cond ((zerop f) 0)
@@ -277,7 +280,7 @@
 
 (defun float-sign (float1 &optional (float2 (float 1 float1)))
   #!+sb-doc
-  "Returns a floating-point number that has the same sign as
+  "Return a floating-point number that has the same sign as
    float1 and, if float2 is given, has the same absolute value
    as float2."
   (declare (float float1 float2))
@@ -309,7 +312,6 @@
 (defun float-radix (x)
   #!+sb-doc
   "Return (as an integer) the radix b of its floating-point argument."
-  (declare (type float x))
   ;; ANSI says this function "should signal an error if [..] argument
   ;; is not a float". Since X is otherwise ignored, Python doesn't
   ;; check the type by default, so we have to do it ourself:
@@ -472,7 +474,7 @@
 ;;; Dispatch to the correct type-specific i-d-f function.
 (defun integer-decode-float (x)
   #!+sb-doc
-  "Returns three values:
+  "Return three values:
    1) an integer representation of the significand.
    2) the exponent for the power of 2 that the significand must be multiplied
       by to get the actual value. This differs from the DECODE-FLOAT exponent
@@ -597,7 +599,7 @@
 ;;; Dispatch to the appropriate type-specific function.
 (defun decode-float (f)
   #!+sb-doc
-  "Returns three values:
+  "Return three values:
    1) a floating-point number representing the significand. This is always
       between 0.5 (inclusive) and 1.0 (exclusive).
    2) an integer representing the exponent.
@@ -719,7 +721,7 @@
 ;;; Dispatch to the correct type-specific scale-float function.
 (defun scale-float (f ex)
   #!+sb-doc
-  "Returns the value (* f (expt (float 2 f) ex)), but with no unnecessary loss
+  "Return the value (* f (expt (float 2 f) ex)), but with no unnecessary loss
   of precision or overflow."
   (number-dispatch ((f float))
     ((single-float)
@@ -862,19 +864,19 @@ uninterruptibly frob the rounding modes & do ieee round-to-integer.
 	   (exp (ldb sb!vm:double-float-exponent-byte hi-bits))
 	   (frac (logior (ldb sb!vm:double-float-significand-byte hi-bits)
 			 sb!vm:double-float-hidden-bit))
-	   (shift (- exp (- sb!vm:double-float-digits sb!vm:word-bits)
+	   (shift (- exp (- sb!vm:double-float-digits sb!vm:n-word-bits)
 		     sb!vm:double-float-bias)))
       (when (> exp sb!vm:double-float-normal-exponent-max)
 	(error 'floating-point-invalid-operation :operator 'truncate
 	       :operands (list x)))
-      (if (<= shift (- sb!vm:word-bits sb!vm:double-float-digits))
+      (if (<= shift (- sb!vm:n-word-bits sb!vm:double-float-digits))
 	  0
 	  (let* ((res-hi (ash frac shift))
 		 (res (if (plusp shift)
 			  (logior res-hi
 				  (the fixnum
 				       (ash (double-float-low-bits x)
-					    (- shift sb!vm:word-bits))))
+					    (- shift sb!vm:n-word-bits))))
 			  res-hi)))
 	    (declare (type (unsigned-byte 31) res-hi res))
 	    (if (minusp hi-bits)