Make arithmetic work with bignums

* src/data.c (free_mpz_value): New function.
(arith_driver): Rewrite.
(float_arith_driver): Handle bignums.

1 files changed, 95 insertions, 34 deletions

diff --git a/src/data.c b/src/data.c
index 97554c7e1d2..b49daabe85d 100644
--- a/src/data.c
+++ b/src/data.c
@@ -2809,16 +2809,25 @@ enum arithop
     Alogxor
   };
 
+static void
+free_mpz_value (void *value_ptr)
+{
+  mpz_clear (*(mpz_t *) value_ptr);
+}
+
 static Lisp_Object float_arith_driver (double, ptrdiff_t, enum arithop,
                                        ptrdiff_t, Lisp_Object *);
+
 static Lisp_Object
 arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
 {
-  Lisp_Object val;
-  ptrdiff_t argnum, ok_args;
-  EMACS_INT accum = 0;
-  EMACS_INT next, ok_accum;
-  bool overflow = 0;
+  Lisp_Object val = Qnil;
+  ptrdiff_t argnum;
+  ptrdiff_t count = SPECPDL_INDEX ();
+  mpz_t accum;
+
+  mpz_init (accum);
+  record_unwind_protect_ptr (free_mpz_value, &accum);
 
   switch (code)
     {
@@ -2826,14 +2835,14 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
     case Alogxor:
     case Aadd:
     case Asub:
-      accum = 0;
+      /* ACCUM is already 0.  */
       break;
     case Amult:
     case Adiv:
-      accum = 1;
+      mpz_set_si (accum, 1);
       break;
     case Alogand:
-      accum = -1;
+      mpz_set_si (accum, -1);
       break;
     default:
       break;
@@ -2841,62 +2850,112 @@ arith_driver (enum arithop code, ptrdiff_t nargs, Lisp_Object *args)
 
   for (argnum = 0; argnum < nargs; argnum++)
     {
-      if (! overflow)
-	{
-	  ok_args = argnum;
-	  ok_accum = accum;
-	}
-
-      /* Using args[argnum] as argument to CHECK_FIXNUM_... */
+      /* Using args[argnum] as argument to CHECK_NUMBER... */
       val = args[argnum];
-      CHECK_FIXNUM_OR_FLOAT_COERCE_MARKER (val);
+      CHECK_NUMBER (val);
 
       if (FLOATP (val))
-	return float_arith_driver (ok_accum, ok_args, code,
-				   nargs, args);
-      args[argnum] = val;
-      next = XINT (args[argnum]);
+	return unbind_to (count,
+			  float_arith_driver (mpz_get_d (accum), argnum, code,
+					      nargs, args));
       switch (code)
 	{
 	case Aadd:
-	  overflow |= INT_ADD_WRAPV (accum, next, &accum);
+	  if (BIGNUMP (val))
+	    mpz_add (accum, accum, XBIGNUM (val)->value);
+	  else if (XINT (val) < 0)
+	    mpz_sub_ui (accum, accum, - XINT (val));
+	  else
+	    mpz_add_ui (accum, accum, XINT (val));
 	  break;
 	case Asub:
 	  if (! argnum)
-	    accum = nargs == 1 ? - next : next;
+	    {
+	      if (BIGNUMP (val))
+		mpz_set (accum, XBIGNUM (val)->value);
+	      else
+		mpz_set_si (accum, XINT (val));
+	      if (nargs == 1)
+		mpz_neg (accum, accum);
+	    }
+	  else if (BIGNUMP (val))
+	    mpz_sub (accum, accum, XBIGNUM (val)->value);
+	  else if (XINT (val) < 0)
+	    mpz_add_ui (accum, accum, - XINT (val));
 	  else
-	    overflow |= INT_SUBTRACT_WRAPV (accum, next, &accum);
+	    mpz_sub_ui (accum, accum, XINT (val));
 	  break;
 	case Amult:
-	  overflow |= INT_MULTIPLY_WRAPV (accum, next, &accum);
+	  if (BIGNUMP (val))
+	    mpz_mul (accum, accum, XBIGNUM (val)->value);
+	  else
+	    mpz_mul_si (accum, accum, XINT (val));
 	  break;
 	case Adiv:
 	  if (! (argnum || nargs == 1))
-	    accum = next;
+	    {
+	      if (BIGNUMP (val))
+		mpz_set (accum, XBIGNUM (val)->value);
+	      else
+		mpz_set_si (accum, XINT (val));
+	    }
 	  else
 	    {
-	      if (next == 0)
+	      /* Note that a bignum can never be 0, so we don't need
+		 to check that case.  */
+	      if (FIXNUMP (val) && XINT (val) == 0)
 		xsignal0 (Qarith_error);
-	      if (INT_DIVIDE_OVERFLOW (accum, next))
-		overflow = true;
+	      if (BIGNUMP (val))
+		mpz_tdiv_q (accum, accum, XBIGNUM (val)->value);
 	      else
-		accum /= next;
+		{
+		  EMACS_INT value = XINT (val);
+		  bool negate = value < 0;
+		  if (negate)
+		    value = -value;
+		  mpz_tdiv_q_ui (accum, accum, value);
+		  if (negate)
+		    mpz_neg (accum, accum);
+		}
 	    }
 	  break;
 	case Alogand:
-	  accum &= next;
+	  if (BIGNUMP (val))
+	    mpz_and (accum, accum, XBIGNUM (val)->value);
+	  else
+	    {
+	      mpz_t tem;
+	      mpz_init_set_ui (tem, XUINT (val));
+	      mpz_and (accum, accum, tem);
+	      mpz_clear (tem);
+	    }
 	  break;
 	case Alogior:
-	  accum |= next;
+	  if (BIGNUMP (val))
+	    mpz_ior (accum, accum, XBIGNUM (val)->value);
+	  else
+	    {
+	      mpz_t tem;
+	      mpz_init_set_ui (tem, XUINT (val));
+	      mpz_ior (accum, accum, tem);
+	      mpz_clear (tem);
+	    }
 	  break;
 	case Alogxor:
-	  accum ^= next;
+	  if (BIGNUMP (val))
+	    mpz_xor (accum, accum, XBIGNUM (val)->value);
+	  else
+	    {
+	      mpz_t tem;
+	      mpz_init_set_ui (tem, XUINT (val));
+	      mpz_xor (accum, accum, tem);
+	      mpz_clear (tem);
+	    }
 	  break;
 	}
     }
 
-  XSETINT (val, accum);
-  return val;
+  return unbind_to (count, make_number (accum));
 }
 
 #ifndef isnan
@@ -2919,6 +2978,8 @@ float_arith_driver (double accum, ptrdiff_t argnum, enum arithop code,
 	{
 	  next = XFLOAT_DATA (val);
 	}
+      else if (BIGNUMP (val))
+	next = mpz_get_d (XBIGNUM (val)->value);
       else
 	{
 	  args[argnum] = val;    /* runs into a compiler bug. */