# HG changeset patch
# User james
# Date 1037127521 0
# Node ID 8b464283e8916b05c15f81512fba256d2a7c650c
# Parent  80d9ab2e9855c7cbece2c258b8743ada56a88925
[xemacs-hg @ 2002-11-12 18:58:13 by james]
Unconditionally compile the LISP_FLOAT_TYPE code.  Remove all
!LISP_FLOAT_TYPE code and the LISP_FLOAT_TYPE identifier itself.

diff -r 80d9ab2e9855 -r 8b464283e891 lisp/ChangeLog
--- a/lisp/ChangeLog	Tue Nov 12 03:57:48 2002 +0000
+++ b/lisp/ChangeLog	Tue Nov 12 18:58:41 2002 +0000
@@ -1,3 +1,9 @@
+2002-10-14  Jerry James  <james@xemacs.org>
+
+	* gtk-font-menu.el (gtk-reset-device-font-menus): Simplify code
+	that previously could not depend on LISP_FLOAT_TYPE.
+	* x-font-menu.el (x-reset-device-font-menus): Ditto.
+
 2002-11-12  Stephen J. Turnbull  <stephen@xemacs.org>
 
 	Synch to 21.4 (suggested by Edward M. Lee <edward@tailifer.com>):
diff -r 80d9ab2e9855 -r 8b464283e891 lisp/gtk-font-menu.el
--- a/lisp/gtk-font-menu.el	Tue Nov 12 03:57:48 2002 +0000
+++ b/lisp/gtk-font-menu.el	Tue Nov 12 18:58:41 2002 +0000
@@ -166,10 +166,8 @@
 	      families)
       (mapcar (lambda (x)
 		(vector (if (/= 0 (% x 10))
-			    ;; works with no LISP_FLOAT_TYPE
-			    (concat (int-to-string (/ x 10)) "."
-				    (int-to-string (% x 10)))
-			  (int-to-string (/ x 10)))
+			    (number-to-string (/ x 10.0))
+			  (number-to-string (/ x 10)))
 			(list 'font-menu-set-font nil nil x)
 			':style 'radio ':active nil ':selected nil))
 	      sizes)
diff -r 80d9ab2e9855 -r 8b464283e891 lisp/x-font-menu.el
--- a/lisp/x-font-menu.el	Tue Nov 12 03:57:48 2002 +0000
+++ b/lisp/x-font-menu.el	Tue Nov 12 18:58:41 2002 +0000
@@ -167,10 +167,8 @@
 	      families)
       (mapcar (lambda (x)
 		(vector (if (/= 0 (% x 10))
-			    ;; works with no LISP_FLOAT_TYPE
-			    (concat (int-to-string (/ x 10)) "."
-				    (int-to-string (% x 10)))
-			  (int-to-string (/ x 10)))
+			    (number-to-string (/ x 10.0))
+			  (number-to-string (/ x 10)))
 			(list 'font-menu-set-font nil nil x)
 			':style 'radio ':active nil ':selected nil))
 	      sizes)
diff -r 80d9ab2e9855 -r 8b464283e891 src/ChangeLog
--- a/src/ChangeLog	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/ChangeLog	Tue Nov 12 18:58:41 2002 +0000
@@ -1,3 +1,18 @@
+2002-10-14  Jerry James  <james@xemacs.org>
+
+	* alloc.c: Unconditionally use LISP_FLOAT_TYPE code.
+	* bytecode.c: Ditto.
+	* data.c: Ditto.
+	* ecrt0.c: Ditto.
+	* emacs.c: Ditto.
+	* event-stream.c: Ditto.
+	* floatfns.c: Ditto.
+	* lisp.h: Ditto.
+	* lread.c: Ditto.
+	* print.c: Ditto.
+	* config.h.in: Remove LISP_FLOAT_TYPE entry.
+	* s/windowsnt.h: Remove LISP_FLOAT_TYPE definition.
+
 2002-10-10  Stephen J. Turnbull  <stephen@xemacs.org>
 
 	* emacs.c (shut_down_emacs): Improve crash message.
diff -r 80d9ab2e9855 -r 8b464283e891 src/alloc.c
--- a/src/alloc.c	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/alloc.c	Tue Nov 12 18:58:41 2002 +0000
@@ -1095,8 +1095,6 @@
 /*			  Float allocation				*/
 /************************************************************************/
 
-#ifdef LISP_FLOAT_TYPE
-
 DECLARE_FIXED_TYPE_ALLOC (float, Lisp_Float);
 #define MINIMUM_ALLOWED_FIXED_TYPE_CELLS_float 1000
 
@@ -1116,8 +1114,6 @@
   return wrap_float (f);
 }
 
-#endif /* LISP_FLOAT_TYPE */
-
 
 /************************************************************************/
 /*			   Vector allocation				*/
@@ -3649,8 +3645,6 @@
   SWEEP_FIXED_TYPE_BLOCK (compiled_function, Lisp_Compiled_Function);
 }
 
-
-#ifdef LISP_FLOAT_TYPE
 static void
 sweep_floats (void)
 {
@@ -3659,7 +3653,6 @@
 
   SWEEP_FIXED_TYPE_BLOCK (float, Lisp_Float);
 }
-#endif /* LISP_FLOAT_TYPE */
 
 static void
 sweep_symbols (void)
@@ -4066,10 +4059,8 @@
   /* Free all unmarked compiled-function objects */
   sweep_compiled_functions ();
 
-#ifdef LISP_FLOAT_TYPE
   /* Put all unmarked floats on free list */
   sweep_floats ();
-#endif
 
   /* Put all unmarked symbols on free list */
   sweep_symbols ();
@@ -4581,11 +4572,9 @@
   HACK_O_MATIC (marker, "marker-storage", pl);
   pl = gc_plist_hack ("markers-free", gc_count_num_marker_freelist, pl);
   pl = gc_plist_hack ("markers-used", gc_count_num_marker_in_use, pl);
-#ifdef LISP_FLOAT_TYPE
   HACK_O_MATIC (float, "float-storage", pl);
   pl = gc_plist_hack ("floats-free", gc_count_num_float_freelist, pl);
   pl = gc_plist_hack ("floats-used", gc_count_num_float_in_use, pl);
-#endif /* LISP_FLOAT_TYPE */
   HACK_O_MATIC (string, "string-header-storage", pl);
   pl = gc_plist_hack ("long-strings-total-length",
                       gc_count_string_total_size
@@ -4874,9 +4863,7 @@
   init_cons_alloc ();
   init_symbol_alloc ();
   init_compiled_function_alloc ();
-#ifdef LISP_FLOAT_TYPE
   init_float_alloc ();
-#endif /* LISP_FLOAT_TYPE */
   init_marker_alloc ();
   init_extent_alloc ();
   init_event_alloc ();
diff -r 80d9ab2e9855 -r 8b464283e891 src/bytecode.c
--- a/src/bytecode.c	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/bytecode.c	Tue Nov 12 18:58:41 2002 +0000
@@ -247,9 +247,7 @@
  retry:
 
   if (INTP    (obj)) return make_int (- XINT (obj));
-#ifdef LISP_FLOAT_TYPE
   if (FLOATP  (obj)) return make_float (- XFLOAT_DATA (obj));
-#endif
   if (CHARP   (obj)) return make_int (- ((int) XCHAR (obj)));
   if (MARKERP (obj)) return make_int (- ((int) marker_position (obj)));
 
@@ -283,7 +281,6 @@
 {
   retry:
 
-#ifdef LISP_FLOAT_TYPE
   {
     EMACS_INT ival1, ival2;
 
@@ -327,37 +324,11 @@
 
     return dval1 < dval2 ? -1 : dval1 > dval2 ? 1 : 0;
   }
-#else /* !LISP_FLOAT_TYPE */
-  {
-    EMACS_INT ival1, ival2;
-
-    if      (INTP    (obj1)) ival1 = XINT  (obj1);
-    else if (CHARP   (obj1)) ival1 = XCHAR (obj1);
-    else if (MARKERP (obj1)) ival1 = marker_position (obj1);
-    else
-      {
-	obj1 = wrong_type_argument (Qnumber_char_or_marker_p, obj1);
-	goto retry;
-      }
-
-    if      (INTP    (obj2)) ival2 = XINT  (obj2);
-    else if (CHARP   (obj2)) ival2 = XCHAR (obj2);
-    else if (MARKERP (obj2)) ival2 = marker_position (obj2);
-    else
-      {
-	obj2 = wrong_type_argument (Qnumber_char_or_marker_p, obj2);
-	goto retry;
-      }
-
-    return ival1 < ival2 ? -1 : ival1 > ival2 ? 1 : 0;
-  }
-#endif /* !LISP_FLOAT_TYPE */
 }
 
 static Lisp_Object
 bytecode_arithop (Lisp_Object obj1, Lisp_Object obj2, Opcode opcode)
 {
-#ifdef LISP_FLOAT_TYPE
   EMACS_INT ival1, ival2;
   int float_p;
 
@@ -419,43 +390,6 @@
 	}
       return make_float (dval1);
     }
-#else /* !LISP_FLOAT_TYPE */
-  EMACS_INT ival1, ival2;
-
- retry:
-
-  if      (INTP    (obj1)) ival1 = XINT  (obj1);
-  else if (CHARP   (obj1)) ival1 = XCHAR (obj1);
-  else if (MARKERP (obj1)) ival1 = marker_position (obj1);
-  else
-    {
-      obj1 = wrong_type_argument (Qnumber_char_or_marker_p, obj1);
-      goto retry;
-    }
-
-  if      (INTP    (obj2)) ival2 = XINT  (obj2);
-  else if (CHARP   (obj2)) ival2 = XCHAR (obj2);
-  else if (MARKERP (obj2)) ival2 = marker_position (obj2);
-  else
-    {
-      obj2 = wrong_type_argument (Qnumber_char_or_marker_p, obj2);
-      goto retry;
-    }
-
-  switch (opcode)
-    {
-    case Bplus: ival1 += ival2; break;
-    case Bdiff: ival1 -= ival2; break;
-    case Bmult: ival1 *= ival2; break;
-    case Bquo:
-      if (ival2 == 0) Fsignal (Qarith_error, Qnil);
-      ival1 /= ival2;
-      break;
-    case Bmax:  if (ival1 < ival2) ival1 = ival2; break;
-    case Bmin:  if (ival1 > ival2) ival1 = ival2; break;
-    }
-  return make_int (ival1);
-#endif /* !LISP_FLOAT_TYPE */
 }
 
 
diff -r 80d9ab2e9855 -r 8b464283e891 src/config.h.in
--- a/src/config.h.in	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/config.h.in	Tue Nov 12 18:58:41 2002 +0000
@@ -136,9 +136,6 @@
 /* Undefine on systems which don't have processes */
 #undef HAVE_UNIX_PROCESSES
 
-/* Does XEmacs support floating-point numbers? */
-#undef LISP_FLOAT_TYPE
-
 /* Define GNU_MALLOC if you want to use the GNU memory allocator. */
 #undef GNU_MALLOC
 
diff -r 80d9ab2e9855 -r 8b464283e891 src/data.c
--- a/src/data.c	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/data.c	Tue Nov 12 18:58:41 2002 +0000
@@ -535,7 +535,6 @@
     ? Qt : Qnil;
 }
 
-#ifdef LISP_FLOAT_TYPE
 DEFUN ("floatp", Ffloatp, 1, 1, 0, /*
 Return t if OBJECT is a floating point number.
 */
@@ -543,7 +542,6 @@
 {
   return FLOATP (object) ? Qt : Qnil;
 }
-#endif /* LISP_FLOAT_TYPE */
 
 DEFUN ("type-of", Ftype_of, 1, 1, 0, /*
 Return a symbol representing the type of OBJECT.
@@ -819,9 +817,7 @@
   if      (INTP    (obj)) p->c.ival = XINT  (obj);
   else if (CHARP   (obj)) p->c.ival = XCHAR (obj);
   else if (MARKERP (obj)) p->c.ival = marker_position (obj);
-#ifdef LISP_FLOAT_TYPE
   else if (FLOATP  (obj)) p->c.dval = XFLOAT_DATA (obj), p->int_p = 0;
-#endif
   else
     {
       obj = wrong_type_argument (Qnumber_char_or_marker_p, obj);
@@ -836,9 +832,7 @@
   if      (INTP    (obj)) return (double) XINT  (obj);
   else if (CHARP   (obj)) return (double) XCHAR (obj);
   else if (MARKERP (obj)) return (double) marker_position (obj);
-#ifdef LISP_FLOAT_TYPE
   else if (FLOATP  (obj)) return XFLOAT_DATA (obj);
-#endif
   else
     {
       obj = wrong_type_argument (Qnumber_char_or_marker_p, obj);
@@ -965,10 +959,8 @@
  retry:
   if (INTP (number))
     return EQ (number, Qzero) ? Qt : Qnil;
-#ifdef LISP_FLOAT_TYPE
   else if (FLOATP (number))
     return XFLOAT_DATA (number) == 0.0 ? Qt : Qnil;
-#endif /* LISP_FLOAT_TYPE */
   else
     {
       number = wrong_type_argument (Qnumberp, number);
@@ -1014,7 +1006,6 @@
 {
   CHECK_INT_OR_FLOAT (number);
 
-#ifdef LISP_FLOAT_TYPE
   if (FLOATP (number))
     {
       char pigbuf[350];	/* see comments in float_to_string */
@@ -1022,7 +1013,6 @@
       float_to_string (pigbuf, XFLOAT_DATA (number));
       return build_string (pigbuf);
     }
-#endif /* LISP_FLOAT_TYPE */
 
   {
     char buffer[DECIMAL_PRINT_SIZE (long)];
@@ -1076,10 +1066,8 @@
   while (*p == ' ' || *p == '\t')
     p++;
 
-#ifdef LISP_FLOAT_TYPE
   if (isfloat_string (p) && b == 10)
     return make_float (atof (p));
-#endif /* LISP_FLOAT_TYPE */
 
   if (b == 10)
     {
@@ -1461,7 +1449,6 @@
   number_char_or_marker_to_int_or_double (x, &iod1);
   number_char_or_marker_to_int_or_double (y, &iod2);
 
-#ifdef LISP_FLOAT_TYPE
   if (!iod1.int_p || !iod2.int_p)
     {
       double dval1 = iod1.int_p ? (double) iod1.c.ival : iod1.c.dval;
@@ -1475,7 +1462,7 @@
 
       return make_float (dval1);
     }
-#endif /* LISP_FLOAT_TYPE */
+
   {
     EMACS_INT ival;
     if (iod2.c.ival == 0) goto divide_by_zero;
@@ -1535,9 +1522,7 @@
   if (INTP    (number)) return make_int (XINT  (number) + 1);
   if (CHARP   (number)) return make_int (XCHAR (number) + 1);
   if (MARKERP (number)) return make_int (marker_position (number) + 1);
-#ifdef LISP_FLOAT_TYPE
   if (FLOATP  (number)) return make_float (XFLOAT_DATA (number) + 1.0);
-#endif /* LISP_FLOAT_TYPE */
 
   number = wrong_type_argument (Qnumber_char_or_marker_p, number);
   goto retry;
@@ -1554,9 +1539,7 @@
   if (INTP    (number)) return make_int (XINT  (number) - 1);
   if (CHARP   (number)) return make_int (XCHAR (number) - 1);
   if (MARKERP (number)) return make_int (marker_position (number) - 1);
-#ifdef LISP_FLOAT_TYPE
   if (FLOATP  (number)) return make_float (XFLOAT_DATA (number) - 1.0);
-#endif /* LISP_FLOAT_TYPE */
 
   number = wrong_type_argument (Qnumber_char_or_marker_p, number);
   goto retry;
@@ -2488,10 +2471,7 @@
   DEFSYMBOL (Qcdr);
   DEFSYMBOL (Qerror_lacks_explanatory_string);
   DEFSYMBOL_MULTIWORD_PREDICATE (Qweak_listp);
-
-#ifdef LISP_FLOAT_TYPE
   DEFSYMBOL (Qfloatp);
-#endif /* LISP_FLOAT_TYPE */
 
   DEFSUBR (Fwrong_type_argument);
 
@@ -2517,9 +2497,7 @@
   DEFSUBR (Fnumberp);
   DEFSUBR (Fnumber_or_marker_p);
   DEFSUBR (Fnumber_char_or_marker_p);
-#ifdef LISP_FLOAT_TYPE
   DEFSUBR (Ffloatp);
-#endif /* LISP_FLOAT_TYPE */
   DEFSUBR (Fnatnump);
   DEFSUBR (Fsymbolp);
   DEFSUBR (Fkeywordp);
diff -r 80d9ab2e9855 -r 8b464283e891 src/ecrt0.c
--- a/src/ecrt0.c	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/ecrt0.c	Tue Nov 12 18:58:41 2002 +0000
@@ -371,9 +371,7 @@
 _start ()
 {
 #ifdef sun
-#ifdef LISP_FLOAT_TYPE
   finitfp_();
-#endif
 #endif     
 /* On 68000, _start pushes a6 onto stack  */
   start1 ();
diff -r 80d9ab2e9855 -r 8b464283e891 src/emacs.c
--- a/src/emacs.c	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/emacs.c	Tue Nov 12 18:58:41 2002 +0000
@@ -1048,9 +1048,7 @@
 
   init_signals_very_early ();
   init_data_very_early (); /* Catch math errors. */
-#ifdef LISP_FLOAT_TYPE
   init_floatfns_very_early (); /* Catch floating-point math errors. */
-#endif
   init_process_times_very_early (); /* Initialize our process timers.
 				       As early as possible, of course,
 				       so we can be fairly accurate. */
diff -r 80d9ab2e9855 -r 8b464283e891 src/event-stream.c
--- a/src/event-stream.c	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/event-stream.c	Tue Nov 12 18:58:41 2002 +0000
@@ -1521,15 +1521,9 @@
 static unsigned long
 lisp_number_to_milliseconds (Lisp_Object secs, int allow_0)
 {
-#ifdef LISP_FLOAT_TYPE
   double fsecs;
   CHECK_INT_OR_FLOAT (secs);
   fsecs = XFLOATINT (secs);
-#else
-  long fsecs;
-  CHECK_INT (secs);
-  fsecs = XINT (secs);
-#endif
   if (fsecs < 0)
     invalid_argument ("timeout is negative", secs);
   if (!allow_0 && fsecs == 0)
diff -r 80d9ab2e9855 -r 8b464283e891 src/floatfns.c
--- a/src/floatfns.c	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/floatfns.c	Tue Nov 12 18:58:41 2002 +0000
@@ -48,9 +48,6 @@
 #include <config.h>
 #include "lisp.h"
 #include "syssignal.h"
-
-#ifdef LISP_FLOAT_TYPE
-
 #include "sysfloat.h"
 
 /* The code uses emacs_rint, so that it works to undefine HAVE_RINT
@@ -211,11 +208,8 @@
 
   return extract_float (wrong_type_argument (Qnumberp, num));
 }
-#endif /* LISP_FLOAT_TYPE */
-
 
 /* Trig functions.  */
-#ifdef LISP_FLOAT_TYPE
 
 DEFUN ("acos", Facos, 1, 1, 0, /*
 Return the inverse cosine of NUMBER.
@@ -302,12 +296,9 @@
   IN_FLOAT (d = (sin (d) / c), "tan", number);
   return make_float (d);
 }
-#endif /* LISP_FLOAT_TYPE (trig functions) */
-
 
 /* Bessel functions */
 #if 0 /* Leave these out unless we find there's a reason for them.  */
-/* #ifdef LISP_FLOAT_TYPE */
 
 DEFUN ("bessel-j0", Fbessel_j0, 1, 1, 0, /*
 Return the bessel function j0 of NUMBER.
@@ -379,7 +370,6 @@
 
 /* Error functions. */
 #if 0 /* Leave these out unless we see they are worth having.  */
-/* #ifdef LISP_FLOAT_TYPE */
 
 DEFUN ("erf", Ferf, 1, 1, 0, /*
 Return the mathematical error function of NUMBER.
@@ -416,7 +406,6 @@
 
 /* Root and Log functions. */
 
-#ifdef LISP_FLOAT_TYPE
 DEFUN ("exp", Fexp, 1, 1, 0, /*
 Return the exponential base e of NUMBER.
 */
@@ -433,8 +422,6 @@
     IN_FLOAT (d = exp (d), "exp", number);
   return make_float (d);
 }
-#endif /* LISP_FLOAT_TYPE */
-
 
 DEFUN ("expt", Fexpt, 2, 2, 0, /*
 Return the exponential NUMBER1 ** NUMBER2.
@@ -471,7 +458,6 @@
       return make_int (retval);
     }
 
-#ifdef LISP_FLOAT_TYPE
   {
     double f1 = extract_float (number1);
     double f2 = extract_float (number2);
@@ -485,14 +471,8 @@
     IN_FLOAT2 (f1 = pow (f1, f2), "expt", number1, number2);
     return make_float (f1);
   }
-#else
-  CHECK_INT_OR_FLOAT (number1);
-  CHECK_INT_OR_FLOAT (number2);
-  return Fexpt (number1, number2);
-#endif /* LISP_FLOAT_TYPE */
 }
 
-#ifdef LISP_FLOAT_TYPE
 DEFUN ("log", Flog, 1, 2, 0, /*
 Return the natural logarithm of NUMBER.
 If second optional argument BASE is given, return the logarithm of
@@ -569,12 +549,8 @@
 #endif
   return make_float (d);
 }
-#endif /* LISP_FLOAT_TYPE */
-
 
 /* Inverse trig functions. */
-#ifdef LISP_FLOAT_TYPE
-/* #if 0  Not clearly worth adding...  */
 
 DEFUN ("acosh", Facosh, 1, 1, 0, /*
 Return the inverse hyperbolic cosine of NUMBER.
@@ -663,7 +639,6 @@
   IN_FLOAT (d = tanh (d), "tanh", number);
   return make_float (d);
 }
-#endif /* LISP_FLOAT_TYPE (inverse trig functions) */
 
 /* Rounding functions */
 
@@ -672,14 +647,12 @@
 */
        (number))
 {
-#ifdef LISP_FLOAT_TYPE
   if (FLOATP (number))
     {
       IN_FLOAT (number = make_float (fabs (XFLOAT_DATA (number))),
 		"abs", number);
       return number;
     }
-#endif /* LISP_FLOAT_TYPE */
 
   if (INTP (number))
     return (XINT (number) >= 0) ? number : make_int (- XINT (number));
@@ -687,7 +660,6 @@
   return Fabs (wrong_type_argument (Qnumberp, number));
 }
 
-#ifdef LISP_FLOAT_TYPE
 DEFUN ("float", Ffloat, 1, 1, 0, /*
 Return the floating point number numerically equal to NUMBER.
 */
@@ -701,10 +673,7 @@
 
   return Ffloat (wrong_type_argument (Qnumberp, number));
 }
-#endif /* LISP_FLOAT_TYPE */
 
-
-#ifdef LISP_FLOAT_TYPE
 DEFUN ("logb", Flogb, 1, 1, 0, /*
 Return largest integer <= the base 2 log of the magnitude of NUMBER.
 This is the same as the exponent of a float.
@@ -755,22 +724,18 @@
 #endif /* ! HAVE_FREXP */
 #endif /* ! HAVE_LOGB */
 }
-#endif /* LISP_FLOAT_TYPE */
-
 
 DEFUN ("ceiling", Fceiling, 1, 1, 0, /*
 Return the smallest integer no less than NUMBER.  (Round toward +inf.)
 */
        (number))
 {
-#ifdef LISP_FLOAT_TYPE
   if (FLOATP (number))
     {
       double d;
       IN_FLOAT ((d = ceil (XFLOAT_DATA (number))), "ceiling", number);
       return (float_to_int (d, "ceiling", number, Qunbound));
     }
-#endif /* LISP_FLOAT_TYPE */
 
   if (INTP (number))
     return number;
@@ -794,7 +759,6 @@
 
       CHECK_INT_OR_FLOAT (divisor);
 
-#ifdef LISP_FLOAT_TYPE
       if (FLOATP (number) || FLOATP (divisor))
 	{
 	  double f1 = extract_float (number);
@@ -806,7 +770,6 @@
 	  IN_FLOAT2 (f1 = floor (f1 / f2), "floor", number, divisor);
 	  return float_to_int (f1, "floor", number, divisor);
 	}
-#endif /* LISP_FLOAT_TYPE */
 
       i1 = XINT (number);
       i2 = XINT (divisor);
@@ -823,14 +786,12 @@
       return (make_int (i1));
     }
 
-#ifdef LISP_FLOAT_TYPE
   if (FLOATP (number))
     {
       double d;
       IN_FLOAT ((d = floor (XFLOAT_DATA (number))), "floor", number);
       return (float_to_int (d, "floor", number, Qunbound));
     }
-#endif /* LISP_FLOAT_TYPE */
 
   return number;
 }
@@ -840,7 +801,6 @@
 */
        (number))
 {
-#ifdef LISP_FLOAT_TYPE
   if (FLOATP (number))
     {
       double d;
@@ -848,7 +808,6 @@
       IN_FLOAT ((d = emacs_rint (XFLOAT_DATA (number))), "round", number);
       return (float_to_int (d, "round", number, Qunbound));
     }
-#endif /* LISP_FLOAT_TYPE */
 
   if (INTP (number))
     return number;
@@ -862,10 +821,8 @@
 */
        (number))
 {
-#ifdef LISP_FLOAT_TYPE
   if (FLOATP (number))
     return float_to_int (XFLOAT_DATA (number), "truncate", number, Qunbound);
-#endif /* LISP_FLOAT_TYPE */
 
   if (INTP (number))
     return number;
@@ -874,8 +831,6 @@
 }
 
 /* Float-rounding functions. */
-#ifdef LISP_FLOAT_TYPE
-/* #if 1  It's not clear these are worth adding... */
 
 DEFUN ("fceiling", Ffceiling, 1, 1, 0, /*
 Return the smallest integer no less than NUMBER, as a float.
@@ -922,11 +877,7 @@
     IN_FLOAT (d = ceil (d), "ftruncate", number);
   return make_float (d);
 }
-
-#endif /* LISP_FLOAT_TYPE (float-rounding functions) */
-
 
-#ifdef LISP_FLOAT_TYPE
 #ifdef FLOAT_CATCH_SIGILL
 static SIGTYPE
 float_error (int signo)
@@ -981,18 +932,14 @@
   return 1;	/* don't set errno or print a message */
 }
 #endif /* HAVE_MATHERR */
-#endif /* LISP_FLOAT_TYPE */
-
 
 void
 init_floatfns_very_early (void)
 {
-#ifdef LISP_FLOAT_TYPE
 # ifdef FLOAT_CATCH_SIGILL
   EMACS_SIGNAL (SIGILL, float_error);
 # endif
   in_float = 0;
-#endif /* LISP_FLOAT_TYPE */
 }
 
 void
@@ -1002,14 +949,12 @@
 
   /* Trig functions.  */
 
-#ifdef LISP_FLOAT_TYPE
   DEFSUBR (Facos);
   DEFSUBR (Fasin);
   DEFSUBR (Fatan);
   DEFSUBR (Fcos);
   DEFSUBR (Fsin);
   DEFSUBR (Ftan);
-#endif /* LISP_FLOAT_TYPE */
 
   /* Bessel functions */
 
@@ -1032,35 +977,27 @@
 
   /* Root and Log functions. */
 
-#ifdef LISP_FLOAT_TYPE
   DEFSUBR (Fexp);
-#endif /* LISP_FLOAT_TYPE */
   DEFSUBR (Fexpt);
-#ifdef LISP_FLOAT_TYPE
   DEFSUBR (Flog);
   DEFSUBR (Flog10);
   DEFSUBR (Fsqrt);
   DEFSUBR (Fcube_root);
-#endif /* LISP_FLOAT_TYPE */
 
   /* Inverse trig functions. */
 
-#ifdef LISP_FLOAT_TYPE
   DEFSUBR (Facosh);
   DEFSUBR (Fasinh);
   DEFSUBR (Fatanh);
   DEFSUBR (Fcosh);
   DEFSUBR (Fsinh);
   DEFSUBR (Ftanh);
-#endif /* LISP_FLOAT_TYPE */
 
   /* Rounding functions */
 
   DEFSUBR (Fabs);
-#ifdef LISP_FLOAT_TYPE
   DEFSUBR (Ffloat);
   DEFSUBR (Flogb);
-#endif /* LISP_FLOAT_TYPE */
   DEFSUBR (Fceiling);
   DEFSUBR (Ffloor);
   DEFSUBR (Fround);
@@ -1068,18 +1005,14 @@
 
   /* Float-rounding functions. */
 
-#ifdef LISP_FLOAT_TYPE
   DEFSUBR (Ffceiling);
   DEFSUBR (Fffloor);
   DEFSUBR (Ffround);
   DEFSUBR (Fftruncate);
-#endif /* LISP_FLOAT_TYPE */
 }
 
 void
 vars_of_floatfns (void)
 {
-#ifdef LISP_FLOAT_TYPE
   Fprovide (intern ("lisp-float-type"));
-#endif
 }
diff -r 80d9ab2e9855 -r 8b464283e891 src/lisp.h
--- a/src/lisp.h	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/lisp.h	Tue Nov 12 18:58:41 2002 +0000
@@ -2369,8 +2369,6 @@
 
 /*------------------------------ float ---------------------------------*/
 
-#ifdef LISP_FLOAT_TYPE
-
 /* Note: the 'unused_next_' field exists only to ensure that the
    `next' pointer fits within the structure, for the purposes of the
    free list.  This makes a difference in the unlikely case of
@@ -2407,20 +2405,6 @@
 
 # define INT_OR_FLOATP(x) (INTP (x) || FLOATP (x))
 
-#else /* not LISP_FLOAT_TYPE */
-
-#define XFLOAT(x) --- error!  No float support. ---
-#define FLOATP(x) 0
-#define CHECK_FLOAT(x) --- error!  No float support. ---
-#define CONCHECK_FLOAT(x) --- error!  No float support. ---
-
-#define XFLOATINT(n) XINT(n)
-#define CHECK_INT_OR_FLOAT CHECK_INT
-#define CONCHECK_INT_OR_FLOAT CONCHECK_INT
-#define INT_OR_FLOATP(x) INTP (x)
-
-#endif /* not LISP_FLOAT_TYPE */
-
 /*-------------------------------- int ---------------------------------*/
 
 #define ZEROP(x) EQ (x, Qzero)
diff -r 80d9ab2e9855 -r 8b464283e891 src/lread.c
--- a/src/lread.c	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/lread.c	Tue Nov 12 18:58:41 2002 +0000
@@ -1720,11 +1720,6 @@
   while (c > 040	/* #### - comma should be here as should backquote */
          && !(c == '\"' || c == '\'' || c == ';'
               || c == '(' || c == ')'
-#ifndef LISP_FLOAT_TYPE
-	      /* If we have floating-point support, then we need
-		 to allow <digits><dot><digits>.  */
-	      || c =='.'
-#endif /* not LISP_FLOAT_TYPE */
               || c == '[' || c == ']' || c == '#'
               ))
     {
@@ -1780,18 +1775,14 @@
 
           while (p1 != p && (c = *p1) >= '0' && c <= '9')
             p1++;
-#ifdef LISP_FLOAT_TYPE
 	  /* Integers can have trailing decimal points.  */
 	  if (p1 > read_ptr && p1 < p && *p1 == '.')
 	    p1++;
-#endif
           if (p1 == p)
             {
               /* It is an integer. */
-#ifdef LISP_FLOAT_TYPE
 	      if (p1[-1] == '.')
 		p1[-1] = '\0';
-#endif
 #if 0
 	      {
 		int number = 0;
@@ -1808,10 +1799,8 @@
 #endif
 	    }
 	}
-#ifdef LISP_FLOAT_TYPE
       if (isfloat_string (read_ptr))
 	return make_float (atof (read_ptr));
-#endif
     }
 
   {
@@ -2220,7 +2209,6 @@
       return noseeum_cons (Qunbound, make_char (c));
     case '.':
       {
-#ifdef LISP_FLOAT_TYPE
 	/* If a period is followed by a number, then we should read it
 	   as a floating point number.  Otherwise, it denotes a dotted
 	   pair.
@@ -2238,10 +2226,6 @@
 	   (I think this doesn't matter anymore because there should
 	   be no more danger in unreading multiple characters) */
         return read_atom (readcharfun, '.', 0);
-
-#else /* ! LISP_FLOAT_TYPE */
-	return noseeum_cons (Qunbound, make_char ('.'));
-#endif /* ! LISP_FLOAT_TYPE */
       }
 
     case '#':
@@ -2566,8 +2550,6 @@
 
 
 
-#ifdef LISP_FLOAT_TYPE
-
 #define LEAD_INT 1
 #define DOT_CHAR 2
 #define TRAIL_INT 4
@@ -2622,7 +2604,6 @@
 	      || state == (LEAD_INT|DOT_CHAR|TRAIL_INT|E_CHAR|EXP_INT)
 	      || state == (DOT_CHAR|TRAIL_INT|E_CHAR|EXP_INT)));
 }
-#endif /* LISP_FLOAT_TYPE */
 
 static void *
 sequence_reader (Lisp_Object readcharfun,
diff -r 80d9ab2e9855 -r 8b464283e891 src/print.c
--- a/src/print.c	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/print.c	Tue Nov 12 18:58:41 2002 +0000
@@ -971,8 +971,6 @@
 }
 
 
-#ifdef LISP_FLOAT_TYPE
-
 Lisp_Object Vfloat_output_format;
 
 /*
@@ -1060,7 +1058,6 @@
       buf [(buf [0] == '-' ? 1 : 0)] = '0';
     }
 }
-#endif /* LISP_FLOAT_TYPE */
 
 #define ONE_DIGIT(figure) *p++ = n / (figure) + '0'
 #define ONE_DIGIT_ADVANCE(figure) (ONE_DIGIT (figure), n %= (figure))
@@ -1608,8 +1605,6 @@
   unbind_to (specdepth);
 }
 
-
-#ifdef LISP_FLOAT_TYPE
 void
 print_float (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
@@ -1618,7 +1613,6 @@
   float_to_string (pigbuf, XFLOAT_DATA (obj));
   write_c_string (printcharfun, pigbuf);
 }
-#endif /* LISP_FLOAT_TYPE */
 
 void
 print_symbol (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
@@ -1707,13 +1701,11 @@
       }
   not_yet_confused:
 
-#ifdef LISP_FLOAT_TYPE
     if (!confusing)
       /* #### Ugh, this is needlessly complex and slow for what we
          need here.  It might be a good idea to copy equivalent code
          from FSF.  --hniksic */
       confusing = isfloat_string ((char *) data);
-#endif
     if (confusing)
       write_c_string (printcharfun, "\\");
   }
@@ -2040,7 +2032,6 @@
 */ );
   Vstandard_output = Qt;
 
-#ifdef LISP_FLOAT_TYPE
   DEFVAR_LISP ("float-output-format", &Vfloat_output_format /*
 The format descriptor string that lisp uses to print floats.
 This is a %-spec like those accepted by `printf' in C,
@@ -2064,7 +2055,6 @@
 are all zero.  This is to preserve read-equivalence.
 */ );
   Vfloat_output_format = Qnil;
-#endif /* LISP_FLOAT_TYPE */
 
   DEFVAR_LISP ("print-length", &Vprint_length /*
 Maximum length of list or vector to print before abbreviating.
diff -r 80d9ab2e9855 -r 8b464283e891 src/s/windowsnt.h
--- a/src/s/windowsnt.h	Tue Nov 12 03:57:48 2002 +0000
+++ b/src/s/windowsnt.h	Tue Nov 12 18:58:41 2002 +0000
@@ -118,8 +118,6 @@
 
 #define NTHEAP_PROBE_BASE 1
 
-#define LISP_FLOAT_TYPE
-
 #ifdef HAVE_X_WINDOWS
 
 #define HAVE_XREGISTERIMINSTANTIATECALLBACK