xemacs-beta: src/number-mp.c comparison

comparison src/number-mp.c @ 5736:3192994c49ca

Convert C (un)signed long long values to bignums properly. This patch also does the following: - Uses make_fixnum instead of make_integer when the argument is guaranteed to be in the fixnum range. - Introduces make_unsigned_integer so that we handle unsigned values with the high bit set correctly. - Introduces conversions between bignums and (un)signed long long values. - Uses mp_set_memory_functions with the BSD MP code, if it exists. - Eliminates some unnecessary consing in the Lisp + and * implementations. - Fixes a problem with check_valid_xbm_inline(). This function is called during intialization. It calls Ftimes. When using pdump, this is a problem, because (a) the bignum code is not initialized until *after* dumping, so we don't try to dump any bignums, and (b) multiplication of integers is done inside bignums so we handle fixnum overflow correctly. I decided that an XBM file with dimensions that don't fit into fixnums is probably not something we want to try to handle anyway, and did the arithmetic with C values instead of Lisp values. Doing that broke one test, which started getting a different error message from the one it expected, so I adjusted the test to match the new reality. - Fixes a few miscellaneous bugs in the BSD MP code. See <CAHCOHQk0u0=eD1fUMHTNWi2Yh=1WgiYyCXdMbsGzHBNhdqYz4w@mail.gmail.com> in xemacs-patches, as well as followup messages.

author	Jerry James <james@xemacs.org>
date	Mon, 17 Jun 2013 10:23:00 -0600
parents	7aa144d1404b
children	a2912073be85

comparison

equal deleted inserted replaced

-:ff13c44ce0d9
+:3192994c49ca
 /* Synched up with: Not in FSF. */
 #include <config.h>
 #include <limits.h>
 #include <math.h>
+#include <stdlib.h>
 #include "lisp.h"
-static MINT *bignum_bytesize, *bignum_long_sign_bit, *bignum_one, *bignum_two;
+static MINT *bignum_bytesize, *bignum_one, *bignum_two;
 MINT *bignum_zero, *intern_bignum;
 MINT *bignum_min_int, *bignum_max_int, *bignum_max_uint;
 MINT *bignum_min_long, *bignum_max_long, *bignum_max_ulong;
+MINT *bignum_min_llong, *bignum_max_llong, *bignum_max_ullong;
 short div_rem;
 char *
 bignum_to_string (bignum b, int base)
 {
 sign = bignum_sign (b);
 BIGNUM_TO_TYPE (unsigned long, unsigned long);
 return retval;
 }
+long long
+bignum_to_llong (bignum b)
+{
+short rem, sign;
+unsigned long long retval = 0LL;
+REGISTER unsigned int i;
+MINT *quo;
+sign = bignum_sign (b);
+BIGNUM_TO_TYPE (long long, unsigned long long);
+return ((long long) retval) * sign;
+}
+unsigned long long
+bignum_to_ullong (bignum b)
+{
+short rem, sign;
+unsigned long long retval = 0UL;
+REGISTER unsigned int i;
+MINT *quo;
+sign = bignum_sign (b);
+BIGNUM_TO_TYPE (unsigned long long, unsigned long long);
+return retval;
+}
 double
 bignum_to_double (bignum b)
 {
 short rem, sign;
 double retval = 0.0, factor = 1.0;
 MP_MULT (b, mbase, b);
 temp = MP_ITOM (digit);
 MP_MADD (b, temp, b);
 MP_MFREE (temp);
 }
+MP_MFREE (mbase);
 if (neg)
 MP_MSUB (bignum_zero, b, b);
 return (digit >= 0) ? -1 : 0;
 }
 void
-bignum_set_long (MINT *b, long l)
+bignum_set_long (bignum b, long l)
 {
-/* Negative l is hard, not least because -LONG_MIN == LONG_MIN.  We pretend
+char hex[SIZEOF_LONG * 2U + 2U];
-that l is unsigned, then subtract off the amount equal to the sign bit. */
+MINT *temp;
-bignum_set_ulong (b, (unsigned long) l);
+int neg = l < 0L;
-if (l < 0L)
-MP_MSUB (b, bignum_long_sign_bit, b);
+snprintf (hex, SIZEOF_LONG * 2U + 2U, "%lx",
+	    neg ? (unsigned long) -l : (unsigned long) l);
+temp = MP_XTOM (hex);
+if (neg)
+MP_MSUB (bignum_zero, temp, b);
+else
+MP_MOVE (temp, b);
+MP_MFREE (temp);
 }
 void
 bignum_set_ulong (bignum b, unsigned long l)
 {
-REGISTER unsigned int i;
+char hex[SIZEOF_LONG * 2U + 2U];
-MINT *multiplier = MP_ITOM (1);
+MINT *temp;
-MP_MOVE (bignum_zero, b);
+snprintf (hex, SIZEOF_LONG * 2U + 2U, "%lx", l);
-for (i = 0UL; l > 0UL; l >>= 8, i++)
+temp = MP_XTOM (hex);
-{
+MP_MOVE (temp, b);
-MINT *temp = MP_ITOM ((short) (l & 255));
+MP_MFREE (temp);
-MP_MULT (multiplier, temp, temp);
+}
-MP_MADD (b, temp, b);
-MP_MULT (multiplier, bignum_bytesize, multiplier);
+void
-MP_MFREE (temp);
+bignum_set_llong (bignum b, long long l)
-}
+{
-MP_MFREE (multiplier);
+char hex[SIZEOF_LONG_LONG * 2U + 2U];
+MINT *temp;
+int neg = l < 0LL;
+snprintf (hex, SIZEOF_LONG_LONG * 2U + 2U, "%llx",
+	    neg ? (unsigned long long) -l : (unsigned long long) l);
+temp = MP_XTOM (hex);
+if (neg)
+MP_MSUB (bignum_zero, temp, b);
+else
+MP_MOVE (temp, b);
+MP_MFREE (temp);
+}
+void
+bignum_set_ullong (bignum b, unsigned long long l)
+{
+char hex[SIZEOF_LONG_LONG * 2U + 2U];
+MINT *temp;
+snprintf (hex, SIZEOF_LONG_LONG * 2U + 2U, "%llx", l);
+temp = MP_XTOM (hex);
+MP_MOVE (temp, b);
+MP_MFREE (temp);
 }
 void
 bignum_set_double (bignum b, double d)
 {
 void
 bignum_clrbit (bignum b, unsigned long bit)
 {
 MINT *num = MP_ITOM (0);
-/* See if the bit is already set, and subtract it off if not */
+/* See if the bit is set, and subtract it off if so */
 MP_MOVE (b, intern_bignum);
 bignum_pow (num, bignum_two, bit);
 bignum_ior (intern_bignum, intern_bignum, num);
 if (MP_MCMP (b, intern_bignum) == 0)
 MP_MSUB (b, num, b);
 {
 bignum_pow (intern_bignum, bignum_two, bits);
 MP_MDIV (b, intern_bignum, result, intern_bignum);
 }
-void bignum_random_seed(unsigned long seed)
+void
-{
+bignum_random (bignum result, bignum limit)
-/* FIXME: Implement me */
+{
-}
+MINT *denominator = MP_ITOM (0), *divisor = MP_ITOM (0);
+bignum_set_long (denominator, RAND_MAX);
-void bignum_random(bignum result, bignum limit)
+MP_MADD (denominator, bignum_one, denominator);
-{
+MP_MADD (limit, bignum_one, divisor);
-/* FIXME: Implement me */
+MP_MDIV (denominator, divisor, denominator, intern_bignum);
-MP_MOVE (bignum_zero, result);
+MP_MFREE (divisor);
-}
+do
+{
+MINT *limitcmp = MP_ITOM (1);
+/* Accumulate at least as many random bits as in LIMIT */
+MP_MOVE (bignum_zero, result);
+do
+	{
+	  bignum_lshift (limitcmp, limitcmp, FIXNUM_VALBITS);
+	  bignum_lshift (result, result, FIXNUM_VALBITS);
+	  bignum_set_long (intern_bignum, get_random ());
+	  MP_MADD (intern_bignum, result, result);
+	}
+while (MP_MCMP (limitcmp, limit) <= 0);
+MP_MDIV (result, denominator, result, intern_bignum);
+MP_MFREE (limitcmp);
+}
+while (MP_MCMP (limit, result) <= 0);
+MP_MFREE (denominator);
+}
+#ifdef HAVE_MP_SET_MEMORY_FUNCTIONS
+/* We need the next two functions due to the extra parameter. */
+static void *
+mp_realloc (void *ptr, size_t UNUSED (old_size), size_t new_size)
+{
+return xrealloc (ptr, new_size);
+}
+static void
+mp_free (void *ptr, size_t UNUSED (size))
+{
+xfree (ptr);
+}
+#endif
 void
 init_number_mp ()
 {
-REGISTER unsigned int i;
+#ifdef HAVE_MP_SET_MEMORY_FUNCTIONS
+mp_set_memory_functions ((void *(*) (size_t)) xmalloc, mp_realloc, mp_free);
+#endif
 bignum_zero = MP_ITOM (0);
 bignum_one = MP_ITOM (1);
 bignum_two = MP_ITOM (2);
 /* intern_bignum holds throwaway values from macro expansions in
 number-mp.h.  Its value is immaterial. */
 intern_bignum = MP_ITOM (0);
-/* bignum_bytesize holds the number of bits in a byte. */
+/* The multiplier used to shift a number left by one byte's worth of bits */
 bignum_bytesize = MP_ITOM (256);
-/* bignum_long_sign_bit holds an adjustment for negative longs. */
-bignum_long_sign_bit = MP_ITOM (256);
-for (i = 1UL; i < sizeof (long); i++)
-MP_MULT (bignum_bytesize, bignum_long_sign_bit, bignum_long_sign_bit);
 /* The MP interface only supports turning short ints into MINTs, so we have
 to set these the hard way. */
 bignum_min_int = MP_ITOM (0);
 bignum_max_long = MP_ITOM (0);
 bignum_set_long (bignum_max_long, LONG_MAX);
 bignum_max_ulong = MP_ITOM (0);
 bignum_set_ulong (bignum_max_ulong, ULONG_MAX);
-}
+bignum_min_llong = MP_ITOM (0);
+bignum_set_llong (bignum_min_llong, LLONG_MIN);
+bignum_max_llong = MP_ITOM (0);
+bignum_set_llong (bignum_max_llong, LLONG_MAX);
+bignum_max_ullong = MP_ITOM (0);
+bignum_set_ullong (bignum_max_ullong, ULLONG_MAX);
+}

Mercurial > hg > xemacs-beta

comparison src/number-mp.c @ 5736:3192994c49ca