1 files changed, 82 insertions, 75 deletions

diff --git a/src/data.c b/src/data.c
index ece76a5bc6f..6afda1e6fb9 100644
--- a/src/data.c
+++ b/src/data.c
@@ -1132,7 +1132,7 @@ store_symval_forwarding (union Lisp_Fwd *valcontents, register Lisp_Object newva
                 else if ((prop = Fget (predicate, Qrange), !NILP (prop)))
                   {
                     Lisp_Object min = XCAR (prop), max = XCDR (prop);
-                    if (! FIXED_OR_FLOATP (newval)
+                    if (! NUMBERP (newval)
                         || NILP (CALLN (Fleq, min, newval, max)))
                       wrong_range (min, max, newval);
                   }
@@ -2627,48 +2627,21 @@ DEFUN ("/=", Fneq, Sneq, 2, 2, 0,
   return arithcompare (num1, num2, ARITH_NOTEQUAL);
 }
 
-/* Convert the integer I to a cons-of-integers, where I is not in
-   fixnum range.  */
-
-#define INTBIG_TO_LISP(i, extremum)                                 \
-  (eassert (FIXNUM_OVERFLOW_P (i)),                                 \
-   (! (FIXNUM_OVERFLOW_P ((extremum) >> 16)                         \
-       && FIXNUM_OVERFLOW_P ((i) >> 16))                            \
-    ? Fcons (make_fixnum ((i) >> 16), make_fixnum ((i) & 0xffff))   \
-    : ! (FIXNUM_OVERFLOW_P ((extremum) >> 16 >> 24)                 \
-         && FIXNUM_OVERFLOW_P ((i) >> 16 >> 24))                    \
-    ? Fcons (make_fixnum ((i) >> 16 >> 24),                         \
-             Fcons (make_fixnum ((i) >> 16 & 0xffffff),             \
-                    make_fixnum ((i) & 0xffff)))                    \
-    : make_float (i)))
-
-Lisp_Object
-intbig_to_lisp (intmax_t i)
-{
-  return INTBIG_TO_LISP (i, INTMAX_MIN);
-}
-
-Lisp_Object
-uintbig_to_lisp (uintmax_t i)
-{
-  return INTBIG_TO_LISP (i, UINTMAX_MAX);
-}
-
 /* Convert the cons-of-integers, integer, or float value C to an
    unsigned value with maximum value MAX, where MAX is one less than a
    power of 2.  Signal an error if C does not have a valid format or
-   is out of range.  */
+   is out of range.
+
+   Although Emacs represents large integers with bignums instead of
+   cons-of-integers or floats, for now this function still accepts the
+   obsolete forms in case some old Lisp code still generates them.  */
 uintmax_t
 cons_to_unsigned (Lisp_Object c, uintmax_t max)
 {
   bool valid = false;
   uintmax_t val UNINIT;
-  if (FIXNUMP (c))
-    {
-      valid = XFIXNUM (c) >= 0;
-      val = XFIXNUM (c);
-    }
-  else if (FLOATP (c))
+
+  if (FLOATP (c))
     {
       double d = XFLOAT_DATA (c);
       if (d >= 0 && d < 1.0 + max)
@@ -2677,27 +2650,44 @@ cons_to_unsigned (Lisp_Object c, uintmax_t max)
           valid = val == d;
         }
     }
-  else if (CONSP (c) && FIXNATP (XCAR (c)))
+  else
     {
-      uintmax_t top = XFIXNAT (XCAR (c));
-      Lisp_Object rest = XCDR (c);
-      if (top <= UINTMAX_MAX >> 24 >> 16
-          && CONSP (rest)
-          && FIXNATP (XCAR (rest)) && XFIXNAT (XCAR (rest)) < 1 << 24
-          && FIXNATP (XCDR (rest)) && XFIXNAT (XCDR (rest)) < 1 << 16)
+      Lisp_Object hi = CONSP (c) ? XCAR (c) : c;
+
+      if (FIXNUMP (hi))
         {
-          uintmax_t mid = XFIXNAT (XCAR (rest));
-          val = top << 24 << 16 | mid << 16 | XFIXNAT (XCDR (rest));
-          valid = true;
+          val = XFIXNUM (hi);
+          valid = 0 <= val;
         }
-      else if (top <= UINTMAX_MAX >> 16)
+      else
         {
-          if (CONSP (rest))
-            rest = XCAR (rest);
-          if (FIXNATP (rest) && XFIXNAT (rest) < 1 << 16)
+          val = bignum_to_uintmax (hi);
+          valid = val != 0;
+        }
+
+      if (valid && CONSP (c))
+        {
+          uintmax_t top = val;
+          Lisp_Object rest = XCDR (c);
+          if (top <= UINTMAX_MAX >> 24 >> 16
+              && CONSP (rest)
+              && FIXNATP (XCAR (rest)) && XFIXNAT (XCAR (rest)) < 1 << 24
+              && FIXNATP (XCDR (rest)) && XFIXNAT (XCDR (rest)) < 1 << 16)
             {
-              val = top << 16 | XFIXNAT (rest);
-              valid = true;
+              uintmax_t mid = XFIXNAT (XCAR (rest));
+              val = top << 24 << 16 | mid << 16 | XFIXNAT (XCDR (rest));
+            }
+          else
+            {
+              valid = top <= UINTMAX_MAX >> 16;
+              if (valid)
+                {
+                  if (CONSP (rest))
+                    rest = XCAR (rest);
+                  valid = FIXNATP (rest) && XFIXNAT (rest) < 1 << 16;
+                  if (valid)
+                    val = top << 16 | XFIXNAT (rest);
+                }
             }
         }
     }
@@ -2711,18 +2701,18 @@ cons_to_unsigned (Lisp_Object c, uintmax_t max)
    value with extrema MIN and MAX.  MAX should be one less than a
    power of 2, and MIN should be zero or the negative of a power of 2.
    Signal an error if C does not have a valid format or is out of
-   range.  */
+   range.
+
+   Although Emacs represents large integers with bignums instead of
+   cons-of-integers or floats, for now this function still accepts the
+   obsolete forms in case some old Lisp code still generates them.  */
 intmax_t
 cons_to_signed (Lisp_Object c, intmax_t min, intmax_t max)
 {
   bool valid = false;
   intmax_t val UNINIT;
-  if (FIXNUMP (c))
-    {
-      val = XFIXNUM (c);
-      valid = true;
-    }
-  else if (FLOATP (c))
+
+  if (FLOATP (c))
     {
       double d = XFLOAT_DATA (c);
       if (d >= min && d < 1.0 + max)
@@ -2731,27 +2721,44 @@ cons_to_signed (Lisp_Object c, intmax_t min, intmax_t max)
           valid = val == d;
         }
     }
-  else if (CONSP (c) && FIXNUMP (XCAR (c)))
+  else
     {
-      intmax_t top = XFIXNUM (XCAR (c));
-      Lisp_Object rest = XCDR (c);
-      if (top >= INTMAX_MIN >> 24 >> 16 && top <= INTMAX_MAX >> 24 >> 16
-          && CONSP (rest)
-          && FIXNATP (XCAR (rest)) && XFIXNAT (XCAR (rest)) < 1 << 24
-          && FIXNATP (XCDR (rest)) && XFIXNAT (XCDR (rest)) < 1 << 16)
+      Lisp_Object hi = CONSP (c) ? XCAR (c) : c;
+
+      if (FIXNUMP (hi))
         {
-          intmax_t mid = XFIXNAT (XCAR (rest));
-          val = top << 24 << 16 | mid << 16 | XFIXNAT (XCDR (rest));
+          val = XFIXNUM (hi);
           valid = true;
         }
-      else if (top >= INTMAX_MIN >> 16 && top <= INTMAX_MAX >> 16)
+      else if (BIGNUMP (hi))
         {
-          if (CONSP (rest))
-            rest = XCAR (rest);
-          if (FIXNATP (rest) && XFIXNAT (rest) < 1 << 16)
+          val = bignum_to_intmax (hi);
+          valid = val != 0;
+        }
+
+      if (valid && CONSP (c))
+        {
+          intmax_t top = val;
+          Lisp_Object rest = XCDR (c);
+          if (top >= INTMAX_MIN >> 24 >> 16 && top <= INTMAX_MAX >> 24 >> 16
+              && CONSP (rest)
+              && FIXNATP (XCAR (rest)) && XFIXNAT (XCAR (rest)) < 1 << 24
+              && FIXNATP (XCDR (rest)) && XFIXNAT (XCDR (rest)) < 1 << 16)
+            {
+              intmax_t mid = XFIXNAT (XCAR (rest));
+              val = top << 24 << 16 | mid << 16 | XFIXNAT (XCDR (rest));
+            }
+          else
             {
-              val = top << 16 | XFIXNAT (rest);
-              valid = true;
+              valid = INTMAX_MIN >> 16 <= top && top <= INTMAX_MAX >> 16;
+              if (valid)
+                {
+                  if (CONSP (rest))
+                    rest = XCAR (rest);
+                  valid = FIXNATP (rest) && XFIXNAT (rest) < 1 << 16;
+                  if (valid)
+                    val = top << 16 | XFIXNAT (rest);
+                }
             }
         }
     }
@@ -2770,11 +2777,11 @@ NUMBER may be an integer or a floating point number.  */)
   char buffer[max (FLOAT_TO_STRING_BUFSIZE, INT_BUFSIZE_BOUND (EMACS_INT))];
   int len;
 
+  CHECK_NUMBER (number);
+
   if (BIGNUMP (number))
     return bignum_to_string (number, 10);
 
-  CHECK_FIXNUM_OR_FLOAT (number);
-
   if (FLOATP (number))
     len = float_to_string (buffer, XFLOAT_DATA (number));
   else