Revert to wraparound integer arithmetic, instead of going to float.

4 files changed, 66 insertions, 122 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index ee2db310562..2b4f498a0b9 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -11,16 +11,6 @@
 
         * term.c: Don't include <stdarg.h>, as <lisp.h> does that.
 
-        Arithmetic overflows now return float rather than wrapping around.
-        (Bug#8611).
-        * data.c: Include <intprops.h>.
-        (arith_driver): Use floating point if the accumulator would otherwise
-        go out of EMACS_INT range.
-        (arith_driver, Fadd1, Fsub1): Use floating point if the result is
-        out of Emacs fixnum range.
-        * bytecode.c (exec_byte_code): Likewise, for Bsub1, Badd1, Bnegate.
-        * floatfns.c (Fexpt): Likewise.
-
         * callproc.c (Fcall_process): Use 'volatile' to avoid vfork clobbering.
 
         * process.c (Fformat_network_address): Fix typo: args2 -> *args2.
diff --git a/src/bytecode.c b/src/bytecode.c
index ce79b011bbb..c3cd3d43072 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1186,7 +1186,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           {
             Lisp_Object v1;
             v1 = TOP;
-            if (INTEGERP (v1) && MOST_NEGATIVE_FIXNUM < XINT (v1))
+            if (INTEGERP (v1))
               {
                 XSETINT (v1, XINT (v1) - 1);
                 TOP = v1;
@@ -1204,7 +1204,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           {
             Lisp_Object v1;
             v1 = TOP;
-            if (INTEGERP (v1) && XINT (v1) < MOST_POSITIVE_FIXNUM)
+            if (INTEGERP (v1))
               {
                 XSETINT (v1, XINT (v1) + 1);
                 TOP = v1;
@@ -1290,7 +1290,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
           {
             Lisp_Object v1;
             v1 = TOP;
-            if (INTEGERP (v1) && - MOST_POSITIVE_FIXNUM <= XINT (v1))
+            if (INTEGERP (v1))
               {
                 XSETINT (v1, - XINT (v1));
                 TOP = v1;
diff --git a/src/data.c b/src/data.c
index beff570d552..577ae777d89 100644
--- a/src/data.c
+++ b/src/data.c
@@ -22,9 +22,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <signal.h>
 #include <stdio.h>
 #include <setjmp.h>
-
-#include <intprops.h>
-
 #include "lisp.h"
 #include "puresize.h"
 #include "character.h"
@@ -2429,8 +2426,10 @@ static Lisp_Object float_arith_driver (double, size_t, enum arithop,
 static Lisp_Object
 arith_driver (enum arithop code, size_t nargs, register Lisp_Object *args)
 {
+  register Lisp_Object val;
   register size_t argnum;
   register EMACS_INT accum = 0;
+  register EMACS_INT next;
 
   switch (SWITCH_ENUM_CAST (code))
     {
@@ -2452,89 +2451,58 @@ arith_driver (enum arithop code, size_t nargs, register Lisp_Object *args)
 
   for (argnum = 0; argnum < nargs; argnum++)
     {
-      EMACS_INT a = accum;
-      int use_float = 0;
-
       /* Using args[argnum] as argument to CHECK_NUMBER_... */
-      Lisp_Object val = args[argnum];
+      val = args[argnum];
       CHECK_NUMBER_OR_FLOAT_COERCE_MARKER (val);
-      args[argnum] = val;
 
       if (FLOATP (val))
-        use_float = 1;
-      else
+        return float_arith_driver ((double) accum, argnum, code,
+                                   nargs, args);
+      args[argnum] = val;
+      next = XINT (args[argnum]);
+      switch (SWITCH_ENUM_CAST (code))
         {
-          EMACS_INT next = XINT (val);
-          switch (SWITCH_ENUM_CAST (code))
+        case Aadd:
+          accum += next;
+          break;
+        case Asub:
+          accum = argnum ? accum - next : nargs == 1 ? - next : next;
+          break;
+        case Amult:
+          accum *= next;
+          break;
+        case Adiv:
+          if (!argnum)
+            accum = next;
+          else
             {
-            case Aadd:
-              if (next < 0
-                  ? a < TYPE_MINIMUM (EMACS_INT) - next
-                  : TYPE_MAXIMUM (EMACS_INT) - next < a)
-                use_float = 1;
-              else
-                a += next;
-              break;
-            case Asub:
-              if (argnum == 0 && nargs != 1)
-                a = next;
-              else if (next < 0
-                       ? TYPE_MAXIMUM (EMACS_INT) + next < a
-                       : a < TYPE_MINIMUM (EMACS_INT) + next)
-                use_float = 1;
-              else
-                a -= next;
-              break;
-            case Amult:
-              if (next < 0
-                  ? (a < 0
-                     ? a < TYPE_MAXIMUM (EMACS_INT) / next
-                     : next != -1 && TYPE_MINIMUM (EMACS_INT) / next < a)
-                  : (next != 0
-                     && (a < 0
-                         ? a < TYPE_MINIMUM (EMACS_INT) / next
-                         : TYPE_MAXIMUM (EMACS_INT) / next < a)))
-                use_float = 1;
-              else
-                a *= next;
-              break;
-            case Adiv:
-              if (!argnum)
-                a = next;
-              else
-                {
-                  if (next == 0)
-                    xsignal0 (Qarith_error);
-                  a /= next;
-                }
-              break;
-            case Alogand:
-              a &= next;
-              break;
-            case Alogior:
-              a |= next;
-              break;
-            case Alogxor:
-              a ^= next;
-              break;
-            case Amax:
-              if (!argnum || a < next)
-                a = next;
-              break;
-            case Amin:
-              if (!argnum || next < a)
-                a = next;
-              break;
+              if (next == 0)
+                xsignal0 (Qarith_error);
+              accum /= next;
             }
+          break;
+        case Alogand:
+          accum &= next;
+          break;
+        case Alogior:
+          accum |= next;
+          break;
+        case Alogxor:
+          accum ^= next;
+          break;
+        case Amax:
+          if (!argnum || next > accum)
+            accum = next;
+          break;
+        case Amin:
+          if (!argnum || next < accum)
+            accum = next;
+          break;
         }
-
-      if (use_float)
-        return float_arith_driver (accum, argnum, code, nargs, args);
-
-      accum = a;
     }
 
-  return make_fixnum_or_float (accum);
+  XSETINT (val, accum);
+  return val;
 }
 
 #undef isnan
@@ -2809,8 +2777,7 @@ Markers are converted to integers.  */)
 
   if (FLOATP (number))
     return (make_float (1.0 + XFLOAT_DATA (number)));
-  if (XINT (number) + 1 == MOST_POSITIVE_FIXNUM + 1)
-    return make_float (XINT (number) + 1);
+
   XSETINT (number, XINT (number) + 1);
   return number;
 }
@@ -2824,8 +2791,7 @@ Markers are converted to integers.  */)
 
   if (FLOATP (number))
     return (make_float (-1.0 + XFLOAT_DATA (number)));
-  if (XINT (number) - 1 == MOST_NEGATIVE_FIXNUM - 1)
-    return make_float (XINT (number) - 1);
+
   XSETINT (number, XINT (number) - 1);
   return number;
 }
diff --git a/src/floatfns.c b/src/floatfns.c
index 5c286772864..1232fc0afa1 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -491,39 +491,27 @@ DEFUN ("expt", Fexpt, Sexpt, 2, 2, 0,
       y = XINT (arg2);
       acc = 1;
 
-      if ((x == 0 && y != 0) || x == 1 || (x == -1 && (y & 1)))
-        return arg1;
-      if (x == -1)
-        y = 0;
-
-      while (1)
+      if (y < 0)
         {
-          if (y & 1)
-            {
-              if (x < 0
-                  ? (acc < 0
-                     ? acc < MOST_POSITIVE_FIXNUM / x
-                     : MOST_NEGATIVE_FIXNUM / x < acc)
-                  : (acc < 0
-                     ? acc < MOST_NEGATIVE_FIXNUM / x
-                     : MOST_POSITIVE_FIXNUM / x < acc))
-                break;
-              acc *= x;
-            }
-
-          y >>= 1;
-          if (y == 0)
+          if (x == 1)
+            acc = 1;
+          else if (x == -1)
+            acc = (y & 1) ? -1 : 1;
+          else
+            acc = 0;
+        }
+      else
+        {
+          while (y > 0)
             {
-              XSETINT (val, acc);
-              return val;
+              if (y & 1)
+                acc *= x;
+              x *= x;
+              y = (unsigned)y >> 1;
             }
-
-          if (x < 0
-              ? x < MOST_POSITIVE_FIXNUM / x
-              : MOST_POSITIVE_FIXNUM / x < x)
-            break;
-          x *= x;
         }
+      XSETINT (val, acc);
+      return val;
     }
   f1 = FLOATP (arg1) ? XFLOAT_DATA (arg1) : XINT (arg1);
   f2 = FLOATP (arg2) ? XFLOAT_DATA (arg2) : XINT (arg2);