Update some libtommath functions to the latest trunk versions. Small step forward in the upgrade to (upcoming) libtommath 1.2.

Advantage: simplify Tcl code accessing those functions.

9 files changed, 181 insertions, 302 deletions

diff --git a/generic/tclBasic.c b/generic/tclBasic.c
index b148333..3b9fca9 100644
--- a/generic/tclBasic.c
+++ b/generic/tclBasic.c
@@ -1920,7 +1920,7 @@ Tcl_CreateCommand(
 
 	/* An existing command conflicts. Try to delete it.. */
 	cmdPtr = Tcl_GetHashValue(hPtr);
-	
+
 	/*
 	 * Be careful to preserve
 	 * any existing import links so we can restore them down below. That
@@ -2107,7 +2107,7 @@ Tcl_CreateObjCommand(
 	cmdPtr = Tcl_GetHashValue(hPtr);
 
 	/*
-	 * [***] This is wrong.  See Tcl Bug a16752c252.  
+	 * [***] This is wrong.  See Tcl Bug a16752c252.
 	 * However, this buggy behavior is kept under particular
 	 * circumstances to accommodate deployed binaries of the
 	 * "tclcompiler" program. http://sourceforge.net/projects/tclpro/
@@ -5188,7 +5188,7 @@ TclEvalObjEx(
 		TclStackAlloc(interp, sizeof(CmdFrame));
 
 	eoFramePtr->type = TCL_LOCATION_EVAL_LIST;
-	eoFramePtr->level = (iPtr->cmdFramePtr == NULL?  1 
+	eoFramePtr->level = (iPtr->cmdFramePtr == NULL?  1
 		: iPtr->cmdFramePtr->level + 1);
 	eoFramePtr->framePtr = iPtr->framePtr;
 	eoFramePtr->nextPtr = iPtr->cmdFramePtr;
@@ -6346,7 +6346,7 @@ ExprIsqrtFunc(
 	if (Tcl_GetBignumFromObj(interp, objv[1], &big) != TCL_OK) {
 	    return TCL_ERROR;
 	}
-	if (SIGN(&big) == MP_NEG) {
+	if (mp_isneg(&big)) {
 	    mp_clear(&big);
 	    goto negarg;
 	}
@@ -6617,8 +6617,7 @@ ExprAbsFunc(
 #endif
 
     if (type == TCL_NUMBER_BIG) {
-	/* TODO: const correctness ? */
-	if (mp_cmp_d((mp_int *) ptr, 0) == MP_LT) {
+	if (mp_cmp_d(ptr, 0) == MP_LT) {
 	    Tcl_GetBignumFromObj(NULL, objv[1], &big);
 	tooLarge:
 	    mp_neg(&big, &big);
@@ -6768,7 +6767,7 @@ ExprIntFunc(
 	mp_int big;
 
 	Tcl_GetBignumFromObj(NULL, objPtr, &big);
-	mp_mod_2d(&big, (int) CHAR_BIT * sizeof(long), &big);
+	mp_mod_2d(&big, CHAR_BIT * sizeof(long), &big);
 	objPtr = Tcl_NewBignumObj(&big);
 	Tcl_IncrRefCount(objPtr);
 	TclGetLongFromObj(NULL, objPtr, &iResult);
@@ -6800,7 +6799,7 @@ ExprWideFunc(
 	mp_int big;
 
 	Tcl_GetBignumFromObj(NULL, objPtr, &big);
-	mp_mod_2d(&big, (int) CHAR_BIT * sizeof(Tcl_WideInt), &big);
+	mp_mod_2d(&big, CHAR_BIT * sizeof(Tcl_WideInt), &big);
 	objPtr = Tcl_NewBignumObj(&big);
 	Tcl_IncrRefCount(objPtr);
 	Tcl_GetWideIntFromObj(NULL, objPtr, &wResult);
@@ -7007,7 +7006,7 @@ ExprSrandFunc(
 	    return TCL_ERROR;
 	}
 
-	mp_mod_2d(&big, (int) CHAR_BIT * sizeof(long), &big);
+	mp_mod_2d(&big, CHAR_BIT * sizeof(long), &big);
 	objPtr = Tcl_NewBignumObj(&big);
 	Tcl_IncrRefCount(objPtr);
 	TclGetLongFromObj(NULL, objPtr, &i);
diff --git a/generic/tclExecute.c b/generic/tclExecute.c
index 61d0ddc..265b82f 100644
--- a/generic/tclExecute.c
+++ b/generic/tclExecute.c
@@ -1361,7 +1361,7 @@ FreeExprCodeInternalRep(
 
 ByteCode *
 TclCompileObj(
-    Tcl_Interp *interp, 
+    Tcl_Interp *interp,
     Tcl_Obj *objPtr,
     const CmdFrame *invoker,
     int word)
@@ -4942,29 +4942,28 @@ TclExecuteByteCode(
 
 		    Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
 
-		    /* TODO: internals intrusion */
-		    if ((l1 > 0) ^ (big2.sign == MP_ZPOS)) {
+		    if ((l1 > 0) ^ mp_isneg(&big2)) {
 			/*
-			 * Arguments are opposite sign; remainder is sum.
+			 * Arguments are same sign; remainder is first operand.
 			 */
 
-			mp_int big1;
-
-			TclBNInitBignumFromLong(&big1, l1);
-			mp_add(&big2, &big1, &big2);
-			mp_clear(&big1);
-			objResultPtr = Tcl_NewBignumObj(&big2);
-			TRACE(("%s\n", O2S(objResultPtr)));
-			NEXT_INST_F(1, 2, 1);
+			mp_clear(&big2);
+			TRACE(("%s\n", O2S(valuePtr)));
+			NEXT_INST_F(1, 1, 0);
 		    }
 
 		    /*
-		     * Arguments are same sign; remainder is first operand.
+		     * Arguments are opposite sign; remainder is sum.
 		     */
 
-		    mp_clear(&big2);
-		    TRACE(("%s\n", O2S(valuePtr)));
-		    NEXT_INST_F(1, 1, 0);
+		    mp_int big1;
+
+		    TclBNInitBignumFromLong(&big1, l1);
+		    mp_add(&big2, &big1, &big2);
+		    mp_clear(&big1);
+		    objResultPtr = Tcl_NewBignumObj(&big2);
+		    TRACE(("%s\n", O2S(objResultPtr)));
+		    NEXT_INST_F(1, 2, 1);
 		}
 	    }
 #ifndef NO_WIDE_TYPE
@@ -4999,28 +4998,28 @@ TclExecuteByteCode(
 		    Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
 
 		    /* TODO: internals intrusion */
-		    if ((w1 > ((Tcl_WideInt) 0)) ^ (big2.sign == MP_ZPOS)) {
+		    if ((w1 > ((Tcl_WideInt) 0)) ^ mp_isneg(&big2)) {
 			/*
-			 * Arguments are opposite sign; remainder is sum.
+			 * Arguments are same sign; remainder is first operand.
 			 */
 
-			mp_int big1;
-
-			TclBNInitBignumFromWideInt(&big1, w1);
-			mp_add(&big2, &big1, &big2);
-			mp_clear(&big1);
-			objResultPtr = Tcl_NewBignumObj(&big2);
-			TRACE(("%s\n", O2S(objResultPtr)));
-			NEXT_INST_F(1, 2, 1);
+			mp_clear(&big2);
+			TRACE(("%s\n", O2S(valuePtr)));
+			NEXT_INST_F(1, 1, 0);
 		    }
-
 		    /*
-		     * Arguments are same sign; remainder is first operand.
+		     * Arguments are opposite sign; remainder is sum.
 		     */
 
-		    mp_clear(&big2);
-		    TRACE(("%s\n", O2S(valuePtr)));
-		    NEXT_INST_F(1, 1, 0);
+		    mp_int big1;
+
+		    TclBNInitBignumFromWideInt(&big1, w1);
+		    mp_add(&big2, &big1, &big2);
+		    mp_clear(&big1);
+		    objResultPtr = Tcl_NewBignumObj(&big2);
+		    TRACE(("%s\n", O2S(objResultPtr)));
+		    NEXT_INST_F(1, 2, 1);
+
 		}
 	    }
 #endif
@@ -5033,7 +5032,7 @@ TclExecuteByteCode(
 		mp_init(&bigRemainder);
 		mp_div(&big1, &big2, &bigResult, &bigRemainder);
 		if (!mp_iszero(&bigRemainder)
-			&& (bigRemainder.sign != big2.sign)) {
+			&& (mp_isneg(&bigRemainder) != mp_isneg(&big2))) {
 		    /*
 		     * Convert to Tcl's integer division rules.
 		     */
@@ -5316,139 +5315,24 @@ TclExecuteByteCode(
 	}
 
 	if ((type1 == TCL_NUMBER_BIG) || (type2 == TCL_NUMBER_BIG)) {
-	    mp_int big1, big2, bigResult, *First, *Second;
-	    int numPos;
+	    mp_int big1, big2, bigResult;
 
 	    Tcl_TakeBignumFromObj(NULL, valuePtr, &big1);
 	    Tcl_TakeBignumFromObj(NULL, value2Ptr, &big2);
 
-	    /*
-	     * Count how many positive arguments we have. If only one of the
-	     * arguments is negative, store it in 'Second'.
-	     */
-
-	    if (mp_cmp_d(&big1, 0) != MP_LT) {
-		numPos = 1 + (mp_cmp_d(&big2, 0) != MP_LT);
-		First = &big1;
-		Second = &big2;
-	    } else {
-		First = &big2;
-		Second = &big1;
-		numPos = (mp_cmp_d(First, 0) != MP_LT);
-	    }
 	    mp_init(&bigResult);
 
 	    switch (*pc) {
 	    case INST_BITAND:
-		switch (numPos) {
-		case 2:
-		    /*
-		     * Both arguments positive, base case.
-		     */
-
-		    mp_and(First, Second, &bigResult);
-		    break;
-		case 1:
-		    /*
-		     * First is positive; second negative:
-		     * P & N = P & ~~N = P&~(-N-1) = P & (P ^ (-N-1))
-		     */
-
-		    mp_neg(Second, Second);
-		    mp_sub_d(Second, 1, Second);
-		    mp_xor(First, Second, &bigResult);
-		    mp_and(First, &bigResult, &bigResult);
-		    break;
-		case 0:
-		    /*
-		     * Both arguments negative:
-		     * a & b = ~ (~a | ~b) = -(-a-1|-b-1)-1
-		     */
-
-		    mp_neg(First, First);
-		    mp_sub_d(First, 1, First);
-		    mp_neg(Second, Second);
-		    mp_sub_d(Second, 1, Second);
-		    mp_or(First, Second, &bigResult);
-		    mp_neg(&bigResult, &bigResult);
-		    mp_sub_d(&bigResult, 1, &bigResult);
-		    break;
-		}
+		mp_and(&big1, &big2, &bigResult);
 		break;
 
 	    case INST_BITOR:
-		switch (numPos) {
-		case 2:
-		    /*
-		     * Both arguments positive, base case.
-		     */
-
-		    mp_or(First, Second, &bigResult);
-		    break;
-		case 1:
-		    /*
-		     * First is positive; second negative:
-		     * N|P = ~(~N&~P) = ~((-N-1)&~P) = -((-N-1)&((-N-1)^P))-1
-		     */
-
-		    mp_neg(Second, Second);
-		    mp_sub_d(Second, 1, Second);
-		    mp_xor(First, Second, &bigResult);
-		    mp_and(Second, &bigResult, &bigResult);
-		    mp_neg(&bigResult, &bigResult);
-		    mp_sub_d(&bigResult, 1, &bigResult);
-		    break;
-		case 0:
-		    /*
-		     * Both arguments negative:
-		     * a | b = ~ (~a & ~b) = -(-a-1&-b-1)-1
-		     */
-
-		    mp_neg(First, First);
-		    mp_sub_d(First, 1, First);
-		    mp_neg(Second, Second);
-		    mp_sub_d(Second, 1, Second);
-		    mp_and(First, Second, &bigResult);
-		    mp_neg(&bigResult, &bigResult);
-		    mp_sub_d(&bigResult, 1, &bigResult);
-		    break;
-		}
+		mp_or(&big1, &big2, &bigResult);
 		break;
 
 	    case INST_BITXOR:
-		switch (numPos) {
-		case 2:
-		    /*
-		     * Both arguments positive, base case.
-		     */
-
-		    mp_xor(First, Second, &bigResult);
-		    break;
-		case 1:
-		    /*
-		     * First is positive; second negative:
-		     * P^N = ~(P^~N) = -(P^(-N-1))-1
-		     */
-
-		    mp_neg(Second, Second);
-		    mp_sub_d(Second, 1, Second);
-		    mp_xor(First, Second, &bigResult);
-		    mp_neg(&bigResult, &bigResult);
-		    mp_sub_d(&bigResult, 1, &bigResult);
-		    break;
-		case 0:
-		    /*
-		     * Both arguments negative:
-		     * a ^ b = (~a ^ ~b) = (-a-1^-b-1)
-		     */
-
-		    mp_neg(First, First);
-		    mp_sub_d(First, 1, First);
-		    mp_neg(Second, Second);
-		    mp_sub_d(Second, 1, Second);
-		    mp_xor(First, Second, &bigResult);
-		    break;
-		}
+		mp_xor(&big1, &big2, &bigResult);
 		break;
 	    }
 
@@ -6256,9 +6140,8 @@ TclExecuteByteCode(
 		}
 		mp_init(&bigRemainder);
 		mp_div(&big1, &big2, &bigResult, &bigRemainder);
-		/* TODO: internals intrusion */
 		if (!mp_iszero(&bigRemainder)
-			&& (bigRemainder.sign != big2.sign)) {
+			&& (mp_isneg(&bigRemainder) != mp_isneg(&big2))) {
 		    /*
 		     * Convert to Tcl's integer division rules.
 		     */
diff --git a/generic/tclObj.c b/generic/tclObj.c
index 1738985..6bff71c 100644
--- a/generic/tclObj.c
+++ b/generic/tclObj.c
@@ -189,7 +189,7 @@ static Tcl_ThreadDataKey pendingObjDataKey;
 	    mp_shrink(&(bignum)); \
 	} \
 	(objPtr)->internalRep.ptrAndLongRep.ptr = (void*) (bignum).dp; \
-	(objPtr)->internalRep.ptrAndLongRep.value = ( ((bignum).sign << 30) \
+	(objPtr)->internalRep.ptrAndLongRep.value = ( (mp_isneg(&bignum) << 30) \
 		| ((bignum).alloc << 15) | ((bignum).used)); \
     }
 
@@ -2787,7 +2787,7 @@ Tcl_GetLongFromObj(
 		    while (numBytes-- > 0) {
 			value = (value << CHAR_BIT) | *bytes++;
 		    }
-		    if (big.sign) {
+		    if (mp_isneg(&big)) {
 			*longPtr = - (long) value;
 		    } else {
 			*longPtr = (long) value;
@@ -3089,7 +3089,7 @@ Tcl_GetWideIntFromObj(
 		    while (numBytes-- > 0) {
 			value = (value << CHAR_BIT) | *bytes++;
 		    }
-		    if (big.sign) {
+		    if (mp_isneg(&big)) {
 			*wideIntPtr = - (Tcl_WideInt) value;
 		    } else {
 			*wideIntPtr = (Tcl_WideInt) value;
@@ -3508,10 +3508,10 @@ Tcl_SetBignumObj(
 	while (numBytes-- > 0) {
 	    value = (value << CHAR_BIT) | *bytes++;
 	}
-	if (value > (((~(unsigned long)0) >> 1) + bignumValue->sign)) {
+	if (value > (((~(unsigned long)0) >> 1) + mp_isneg(bignumValue))) {
 	    goto tooLargeForLong;
 	}
-	if (bignumValue->sign) {
+	if (mp_isneg(bignumValue)) {
 	    TclSetLongObj(objPtr, -(long)value);
 	} else {
 	    TclSetLongObj(objPtr, (long)value);
@@ -3533,10 +3533,10 @@ Tcl_SetBignumObj(
 	while (numBytes-- > 0) {
 	    value = (value << CHAR_BIT) | *bytes++;
 	}
-	if (value > (((~(Tcl_WideUInt)0) >> 1) + bignumValue->sign)) {
+	if (value > (((~(Tcl_WideUInt)0) >> 1) + mp_isneg(bignumValue))) {
 	    goto tooLargeForWide;
 	}
-	if (bignumValue->sign) {
+	if (mp_isneg(bignumValue)) {
 	    TclSetWideIntObj(objPtr, -(Tcl_WideInt)value);
 	} else {
 	    TclSetWideIntObj(objPtr, (Tcl_WideInt)value);
diff --git a/generic/tclStrToD.c b/generic/tclStrToD.c
index 3ed4349..17d630b 100644
--- a/generic/tclStrToD.c
+++ b/generic/tclStrToD.c
@@ -129,7 +129,7 @@ typedef unsigned int fpu_control_t __attribute__ ((__mode__ (__HI__)));
 				/* Highest power of two that is greater than
 				 * DBL_MAX_10_EXP, divided by 16 */
 #define DIGIT_GROUP		8
-				/* floor(DIGIT_BIT*log(2)/log(10)) */
+				/* floor(MP_DIGIT_BIT*log(2)/log(10)) */
 
 /* Union used to dismantle floating point numbers. */
 
@@ -1447,9 +1447,9 @@ AccumulateDecimalDigit(
 	 * More than single digit multiplication. Multiply by the appropriate
 	 * small powers of 5, and then shift. Large strings of zeroes are
 	 * eaten 256 at a time; this is less efficient than it could be, but
-	 * seems implausible. We presume that DIGIT_BIT is at least 27. The
+	 * seems implausible. We presume that MP_DIGIT_BIT is at least 27. The
 	 * first multiplication, by up to 10**7, is done with a one-DIGIT
-	 * multiply (this presumes that DIGIT_BIT >= 24).
+	 * multiply (this presumes that MP_DIGIT_BIT >= 24).
 	 */
 
 	n = numZeros + 1;
@@ -3100,7 +3100,7 @@ StrictInt64Conversion(Double* dPtr,
  *
  *	Test whether bankers' rounding should round a digit up. Assumption
  *	is made that the denominator of the fraction being tested is
- *	a power of 2**DIGIT_BIT.
+ *	a power of 2**MP_DIGIT_BIT.
  *
  * Results:
  *	Returns 1 iff the fraction is more than 1/2, or if the fraction
@@ -3112,7 +3112,7 @@ StrictInt64Conversion(Double* dPtr,
 inline static int
 ShouldBankerRoundUpPowD(mp_int* b,
 				/* Numerator of the fraction */
-			int sd,	/* Denominator is 2**(sd*DIGIT_BIT) */
+			int sd,	/* Denominator is 2**(sd*MP_DIGIT_BIT) */
 			int isodd)
 				/* 1 if the digit is odd, 0 if even */
 {
@@ -3153,7 +3153,7 @@ ShouldBankerRoundUpToNextPowD(mp_int* b,
 			      mp_int* m,
 				/* Numerator of the rounding tolerance */
 			      int sd,
-				/* Common denominator is 2**(sd*DIGIT_BIT) */
+				/* Common denominator is 2**(sd*MP_DIGIT_BIT) */
 			      int convType,
 				/* Conversion type: STEELE defeats
 				 * round-to-even (Not sure why one wants to
@@ -3168,7 +3168,7 @@ ShouldBankerRoundUpToNextPowD(mp_int* b,
     /*
      * Compare B and S-m -- which is the same as comparing B+m and S --
      * which we do by computing b+m and doing a bitwhack compare against
-     * 2**(DIGIT_BIT*sd)
+     * 2**(MP_DIGIT_BIT*sd)
      */
     mp_add(b, m, temp);
     if (temp->used <= sd) {	/* too few digits to be > S */
@@ -3200,7 +3200,7 @@ ShouldBankerRoundUpToNextPowD(mp_int* b,
  *	digits that reconverts exactly to the given number, or to
  *	'ilim' digits if that will yield a shorter result. The denominator
  *	in David Gay's conversion algorithm is known to be a power of
- *	2**DIGIT_BIT, and hence the division in the main loop may be replaced
+ *	2**MP_DIGIT_BIT, and hence the division in the main loop may be replaced
  *	by a digit shift and mask.
  *
  * Results:
@@ -3289,7 +3289,7 @@ ShorteningBignumConversionPowD(Double* dPtr,
     }
     mp_init(&temp);
 
-    /* Loop through the digits. Do division and mod by s == 2**(sd*DIGIT_BIT)
+    /* Loop through the digits. Do division and mod by s == 2**(sd*MP_DIGIT_BIT)
      * by mp_digit extraction */
 
     i = 0;
@@ -3396,7 +3396,7 @@ ShorteningBignumConversionPowD(Double* dPtr,
  *	Converts a double-precision number to a fixed-lengt string of
  *	'ilim' digits (or 'ilim1' if log10(d) has been overestimated.)
  *	The denominator in David Gay's conversion algorithm is known to
- *	be a power of 2**DIGIT_BIT, and hence the division in the main
+ *	be a power of 2**MP_DIGIT_BIT, and hence the division in the main
  *	loop may be replaced by a digit shift and mask.
  *
  * Results:
@@ -3465,7 +3465,7 @@ StrictBignumConversionPowD(Double* dPtr,
     mp_init(&temp);
 
     /*
-     * Loop through the digits. Do division and mod by s == 2**(sd*DIGIT_BIT)
+     * Loop through the digits. Do division and mod by s == 2**(sd*MP_DIGIT_BIT)
      * by mp_digit extraction
      */
 
@@ -4234,7 +4234,7 @@ TclDoubleDigits(double dv,	/* Number to convert */
 	    /*
 	     * The denominator is a power of 2, so we can replace division
 	     * by digit shifts. First we round up s2 to a multiple of
-	     * DIGIT_BIT, and adjust m2 and b2 accordingly. Then we launch
+	     * MP_DIGIT_BIT, and adjust m2 and b2 accordingly. Then we launch
 	     * into a version of the comparison that's specialized for
 	     * the 'power of mp_digit in the denominator' case.
 	     */
@@ -4294,7 +4294,7 @@ TclDoubleDigits(double dv,	/* Number to convert */
 	    /*
 	     * The denominator is a power of 2, so we can replace division
 	     * by digit shifts. First we round up s2 to a multiple of
-	     * DIGIT_BIT, and adjust m2 and b2 accordingly. Then we launch
+	     * MP_DIGIT_BIT, and adjust m2 and b2 accordingly. Then we launch
 	     * into a version of the comparison that's specialized for
 	     * the 'power of mp_digit in the denominator' case.
 	     */
@@ -4573,10 +4573,10 @@ TclBignumToDouble(
     bits = mp_count_bits(a);
     if (bits > DBL_MAX_EXP*log2FLT_RADIX) {
 	errno = ERANGE;
-	if (a->sign == MP_ZPOS) {
-	    return HUGE_VAL;
-	} else {
+	if (mp_isneg(a)) {
 	    return -HUGE_VAL;
+	} else {
+	    return HUGE_VAL;
 	}
     }
     shift = mantBits - bits;
@@ -4606,10 +4606,10 @@ TclBignumToDouble(
 
 	    mp_div_2d(a, -shift, &b, NULL);
 	    if (mp_isodd(&b)) {
-		if (b.sign == MP_ZPOS) {
-		    mp_add_d(&b, 1, &b);
-		} else {
+		if (mp_isneg(&b)) {
 		    mp_sub_d(&b, 1, &b);
+		} else {
+		    mp_add_d(&b, 1, &b);
 		}
 	    }
 	} else {
@@ -4619,10 +4619,10 @@ TclBignumToDouble(
 	     */
 
 	    mp_div_2d(a, -1-shift, &b, NULL);
-	    if (b.sign == MP_ZPOS) {
-		mp_add_d(&b, 1, &b);
-	    } else {
+	    if (mp_isneg(&b)) {
 		mp_sub_d(&b, 1, &b);
+	    } else {
+		mp_add_d(&b, 1, &b);
 	    }
 	    mp_div_2d(&b, 1, &b, NULL);
 	}
@@ -4648,10 +4648,10 @@ TclBignumToDouble(
      * Return the result with the appropriate sign.
      */
 
-    if (a->sign == MP_ZPOS) {
-	return r;
-    } else {
+    if (mp_isneg(a)) {
 	return -r;
+    } else {
+	return r;
     }
 }
 
@@ -4824,7 +4824,7 @@ BignumToBiasedFrExp(
      */
 
     *machexp = bits - mantBits + 2;
-    return ((a->sign == MP_ZPOS) ? r : -r);
+    return (mp_isneg(a) ? -r : r);
 }
 
 /*
diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c
index 699dc5a..aeb4285 100644
--- a/generic/tclStringObj.c
+++ b/generic/tclStringObj.c
@@ -2093,7 +2093,7 @@ Tcl_AppendFormatToObj(
 		    if (Tcl_GetBignumFromObj(interp,segment,&big) != TCL_OK) {
 			goto error;
 		    }
-		    mp_mod_2d(&big, (int) CHAR_BIT*sizeof(Tcl_WideInt), &big);
+		    mp_mod_2d(&big, CHAR_BIT*sizeof(Tcl_WideInt), &big);
 		    objPtr = Tcl_NewBignumObj(&big);
 		    Tcl_IncrRefCount(objPtr);
 		    Tcl_GetWideIntFromObj(NULL, objPtr, &w);
@@ -2107,7 +2107,7 @@ Tcl_AppendFormatToObj(
 		    if (Tcl_GetBignumFromObj(interp,segment,&big) != TCL_OK) {
 			goto error;
 		    }
-		    mp_mod_2d(&big, (int) CHAR_BIT * sizeof(long), &big);
+		    mp_mod_2d(&big, CHAR_BIT * sizeof(long), &big);
 		    objPtr = Tcl_NewBignumObj(&big);
 		    Tcl_IncrRefCount(objPtr);
 		    TclGetLongFromObj(NULL, objPtr, &l);
diff --git a/generic/tclTestObj.c b/generic/tclTestObj.c
index 4226d51..b5d0d6b 100644
--- a/generic/tclTestObj.c
+++ b/generic/tclTestObj.c
@@ -269,9 +269,9 @@ TestbignumobjCmd(
 	    return TCL_ERROR;
 	}
 	if (!Tcl_IsShared(varPtr[varIndex])) {
-	    Tcl_SetIntObj(varPtr[varIndex], mp_iseven(&bignumValue));
+	    Tcl_SetIntObj(varPtr[varIndex], !mp_isodd(&bignumValue));
 	} else {
-	    SetVarToObj(varIndex, Tcl_NewIntObj(mp_iseven(&bignumValue)));
+	    SetVarToObj(varIndex, Tcl_NewIntObj(!mp_isodd(&bignumValue)));
 	}
 	mp_clear(&bignumValue);
 	break;
diff --git a/generic/tclTomMath.decls b/generic/tclTomMath.decls
index ab39e83..db37e41 100644
--- a/generic/tclTomMath.decls
+++ b/generic/tclTomMath.decls
@@ -1,9 +1,8 @@
 # tclTomMath.decls --
 #
-#	This file contains the declarations for the functions in
-#	'libtommath' that are contained within the Tcl library.
-#	This file is used to generate the 'tclTomMathDecls.h' and
-#	'tclStubInit.c' files.
+#	This file contains the declarations for the functions in 'libtommath'
+#	that are contained within the Tcl library.  This file is used to
+#	generate the 'tclTomMathDecls.h' and 'tclStubInit.c' files.
 #
 # If you edit this file, advance the revision number (and the epoch
 # if the new stubs are not backward compatible) in tclTomMathDecls.h
@@ -19,196 +18,197 @@ library tcl
 
 interface tclTomMath
 # hooks {tclTomMathInt}
+scspec EXTERN
 
 # Declare each of the functions in the Tcl tommath interface
 
-declare 0 generic {
+declare 0 {
     int TclBN_epoch(void)
 }
-declare 1 generic {
+declare 1 {
     int TclBN_revision(void)
 }
 
-declare 2 generic {
+declare 2 {
     int TclBN_mp_add(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 3 generic {
+declare 3 {
     int TclBN_mp_add_d(mp_int *a, mp_digit b, mp_int *c)
 }
-declare 4 generic {
-    int TclBN_mp_and(mp_int *a, mp_int *b, mp_int *c)
+declare 4 {
+    int TclBN_mp_and(const mp_int *a, const mp_int *b, mp_int *c)
 }
-declare 5 generic {
+declare 5 {
     void TclBN_mp_clamp(mp_int *a)
 }
-declare 6 generic {
+declare 6 {
     void TclBN_mp_clear(mp_int *a)
 }
-declare 7 generic {
+declare 7 {
     void TclBN_mp_clear_multi(mp_int *a, ...)
 }
-declare 8 generic {
-    int TclBN_mp_cmp(mp_int *a, mp_int *b)
+declare 8 {
+    int TclBN_mp_cmp(const mp_int *a, const mp_int *b)
 }
-declare 9 generic {
-    int TclBN_mp_cmp_d(mp_int *a, mp_digit b)
+declare 9 {
+    int TclBN_mp_cmp_d(const mp_int *a, mp_digit b)
 }
-declare 10 generic {
-    int TclBN_mp_cmp_mag(mp_int *a, mp_int *b)
+declare 10 {
+    int TclBN_mp_cmp_mag(const mp_int *a, const mp_int *b)
 }
-declare 11 generic {
+declare 11 {
     int TclBN_mp_copy(mp_int *a, mp_int *b)
 }
-declare 12 generic {
+declare 12 {
     int TclBN_mp_count_bits(mp_int *a)
 }
-declare 13 generic {
+declare 13 {
     int TclBN_mp_div(mp_int *a, mp_int *b, mp_int *q, mp_int *r)
 }
-declare 14 generic {
+declare 14 {
     int TclBN_mp_div_d(mp_int *a, mp_digit b, mp_int *q, mp_digit *r)
 }
-declare 15 generic {
+declare 15 {
     int TclBN_mp_div_2(mp_int *a, mp_int *q)
 }
-declare 16 generic {
+declare 16 {
     int TclBN_mp_div_2d(mp_int *a, int b, mp_int *q, mp_int *r)
 }
-declare 17 generic {
+declare 17 {
     int TclBN_mp_div_3(mp_int *a, mp_int *q, mp_digit *r)
 }
-declare 18 generic {
+declare 18 {
     void TclBN_mp_exch(mp_int *a, mp_int *b)
 }
-declare 19 generic {
+declare 19 {
     int TclBN_mp_expt_d(mp_int *a, mp_digit b, mp_int *c)
 }
-declare 20 generic {
+declare 20 {
     int TclBN_mp_grow(mp_int *a, int size)
 }
-declare 21 generic {
+declare 21 {
     int TclBN_mp_init(mp_int *a)
 }
-declare 22 generic {
+declare 22 {
     int TclBN_mp_init_copy(mp_int *a, mp_int *b)
 }
-declare 23 generic {
+declare 23 {
     int TclBN_mp_init_multi(mp_int *a, ...)
 }
-declare 24 generic {
+declare 24 {
     int TclBN_mp_init_set(mp_int *a, mp_digit b)
 }
-declare 25 generic {
+declare 25 {
     int TclBN_mp_init_size(mp_int *a, int size)
 }
-declare 26 generic {
+declare 26 {
     int TclBN_mp_lshd(mp_int *a, int shift)
 }
-declare 27 generic {
+declare 27 {
     int TclBN_mp_mod(mp_int *a, mp_int *b, mp_int *r)
 }
-declare 28 generic {
+declare 28 {
     int TclBN_mp_mod_2d(mp_int *a, int b, mp_int *r)
 }
-declare 29 generic {
+declare 29 {
     int TclBN_mp_mul(mp_int *a, mp_int *b, mp_int *p)
 }
-declare 30 generic {
+declare 30 {
     int TclBN_mp_mul_d(mp_int *a, mp_digit b, mp_int *p)
 }
-declare 31 generic {
+declare 31 {
     int TclBN_mp_mul_2(mp_int *a, mp_int *p)
 }
-declare 32 generic {
+declare 32 {
     int TclBN_mp_mul_2d(mp_int *a, int d, mp_int *p)
 }
-declare 33 generic {
+declare 33 {
     int TclBN_mp_neg(mp_int *a, mp_int *b)
 }
-declare 34 generic {
-    int TclBN_mp_or(mp_int *a, mp_int *b, mp_int *c)
+declare 34 {
+    int TclBN_mp_or(const mp_int *a, const mp_int *b, mp_int *c)
 }
-declare 35 generic {
+declare 35 {
     int TclBN_mp_radix_size(mp_int *a, int radix, int *size)
 }
-declare 36 generic {
+declare 36 {
     int TclBN_mp_read_radix(mp_int *a, const char *str, int radix)
 }
-declare 37 generic {
+declare 37 {
     void TclBN_mp_rshd(mp_int *a, int shift)
 }
-declare 38 generic {
+declare 38 {
     int TclBN_mp_shrink(mp_int *a)
 }
-declare 39 generic {
+declare 39 {
     void TclBN_mp_set(mp_int *a, mp_digit b)
 }
-declare 40 generic {
+declare 40 {
     int TclBN_mp_sqr(mp_int *a, mp_int *b)
 }
-declare 41 generic {
+declare 41 {
     int TclBN_mp_sqrt(mp_int *a, mp_int *b)
 }
-declare 42 generic {
+declare 42 {
     int TclBN_mp_sub(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 43 generic {
+declare 43 {
     int TclBN_mp_sub_d(mp_int *a, mp_digit b, mp_int *c)
 }
-declare 44 generic {
+declare 44 {
     int TclBN_mp_to_unsigned_bin(mp_int *a, unsigned char *b)
 }
-declare 45 generic {
+declare 45 {
     int TclBN_mp_to_unsigned_bin_n(mp_int *a, unsigned char *b,
 	    unsigned long *outlen)
 }
-declare 46 generic {
+declare 46 {
     int TclBN_mp_toradix_n(mp_int *a, char *str, int radix, int maxlen)
 }
-declare 47 generic {
+declare 47 {
     int TclBN_mp_unsigned_bin_size(mp_int *a)
 }
-declare 48 generic {
-    int TclBN_mp_xor(mp_int *a, mp_int *b, mp_int *c)
+declare 48 {
+    int TclBN_mp_xor(const mp_int *a, const mp_int *b, mp_int *c)
 }
-declare 49 generic {
+declare 49 {
     void TclBN_mp_zero(mp_int *a)
 }
 
 # internal routines to libtommath - should not be called but must be
 # exported to accommodate the "tommath" extension
 
-declare 50 generic {
+declare 50 {
     void TclBN_reverse(unsigned char *s, int len)
 }
-declare 51 generic {
+declare 51 {
     int TclBN_fast_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
 }
-declare 52 generic {
+declare 52 {
     int TclBN_fast_s_mp_sqr(mp_int *a, mp_int *b)
 }
-declare 53 generic {
+declare 53 {
     int TclBN_mp_karatsuba_mul(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 54 generic {
+declare 54 {
     int TclBN_mp_karatsuba_sqr(mp_int *a, mp_int *b)
 }
-declare 55 generic {
+declare 55 {
     int TclBN_mp_toom_mul(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 56 generic {
+declare 56 {
     int TclBN_mp_toom_sqr(mp_int *a, mp_int *b)
 }
-declare 57 generic {
+declare 57 {
     int TclBN_s_mp_add(mp_int *a, mp_int *b, mp_int *c)
 }
-declare 58 generic {
+declare 58 {
     int TclBN_s_mp_mul_digs(mp_int *a, mp_int *b, mp_int *c, int digs)
 }
-declare 59 generic {
+declare 59 {
     int TclBN_s_mp_sqr(mp_int *a, mp_int *b)
 }
-declare 60 generic {
+declare 60 {
     int TclBN_s_mp_sub(mp_int *a, mp_int *b, mp_int *c)
 }
 declare 61 {
diff --git a/generic/tclTomMath.h b/generic/tclTomMath.h
index b435d57..b219405 100644
--- a/generic/tclTomMath.h
+++ b/generic/tclTomMath.h
@@ -241,13 +241,13 @@ typedef int ltm_prime_callback(unsigned char *dst, int len, void *dat);
 
 /* error code to char* string */
 /*
-char *mp_error_to_string(int code);
+const char *mp_error_to_string(mp_err code);
 */
 
 /* ---> init and deinit bignum functions <--- */
 /* init a bignum */
 /*
-int mp_init(mp_int *a);
+mp_err mp_init(mp_int *a);
 */
 
 /* free a bignum */
@@ -257,7 +257,7 @@ void mp_clear(mp_int *a);
 
 /* init a null terminated series of arguments */
 /*
-int mp_init_multi(mp_int *mp, ...);
+mp_err mp_init_multi(mp_int *mp, ...);
 */
 
 /* clear a null terminated series of arguments */
@@ -272,23 +272,24 @@ void mp_exch(mp_int *a, mp_int *b);
 
 /* shrink ram required for a bignum */
 /*
-int mp_shrink(mp_int *a);
+mp_err mp_shrink(mp_int *a);
 */
 
 /* grow an int to a given size */
 /*
-int mp_grow(mp_int *a, int size);
+mp_err mp_grow(mp_int *a, int size);
 */
 
 /* init to a given number of digits */
 /*
-int mp_init_size(mp_int *a, int size);
+mp_err mp_init_size(mp_int *a, int size);
 */
 
 /* ---> Basic Manipulations <--- */
 #define mp_iszero(a) (((a)->used == 0) ? MP_YES : MP_NO)
 #define mp_iseven(a) (((a)->used == 0 || (((a)->dp[0] & 1) == 0)) ? MP_YES : MP_NO)
 #define mp_isodd(a)  (((a)->used > 0 && (((a)->dp[0] & 1) == 1)) ? MP_YES : MP_NO)
+#define mp_isneg(a)  (((a)->sign != MP_ZPOS) ? MP_YES : MP_NO)
 
 /* set to zero */
 /*
@@ -676,14 +677,14 @@ int mp_prime_is_divisible(mp_int *a, int *result);
  * Sets result to 0 if composite or 1 if probable prime
  */
 /*
-int mp_prime_fermat(mp_int *a, mp_int *b, int *result);
+mp_err mp_prime_fermat(const mp_int *a, const mp_int *b, mp_bool *result);
 */
 
 /* performs one Miller-Rabin test of "a" using base "b".
  * Sets result to 0 if composite or 1 if probable prime
  */
 /*
-int mp_prime_miller_rabin(mp_int *a, mp_int *b, int *result);
+mp_err mp_prime_miller_rabin(const mp_int *a, const mp_int *b, mp_bool *result);
 */
 
 /* This gives [for a given bit size] the number of trials required
@@ -701,7 +702,7 @@ int mp_prime_rabin_miller_trials(int size);
  * Sets result to 1 if probably prime, 0 otherwise
  */
 /*
-int mp_prime_is_prime(mp_int *a, int t, int *result);
+mp_err mp_prime_is_prime(const mp_int *a, int t, mp_bool *result);
 */
 
 /* finds the next prime after the number "a" using "t" trials
@@ -710,7 +711,7 @@ int mp_prime_is_prime(mp_int *a, int t, int *result);
  * bbs_style = 1 means the prime must be congruent to 3 mod 4
  */
 /*
-int mp_prime_next_prime(mp_int *a, int t, int bbs_style);
+mp_err mp_prime_next_prime(mp_int *a, int t, int bbs_style);
 */
 
 /* makes a truly random prime of a given size (bytes),
@@ -728,9 +729,9 @@ int mp_prime_next_prime(mp_int *a, int t, int bbs_style);
  *
  * Flags are as follows:
  *
- *   LTM_PRIME_BBS      - make prime congruent to 3 mod 4
- *   LTM_PRIME_SAFE     - make sure (p-1)/2 is prime as well (implies LTM_PRIME_BBS)
- *   LTM_PRIME_2MSB_ON  - make the 2nd highest bit one
+ *   MP_PRIME_BBS      - make prime congruent to 3 mod 4
+ *   MP_PRIME_SAFE     - make sure (p-1)/2 is prime as well (implies MP_PRIME_BBS)
+ *   MP_PRIME_2MSB_ON  - make the 2nd highest bit one
  *
  * You have to supply a callback which fills in a buffer with random bytes.  "dat" is a parameter you can
  * have passed to the callback (e.g. a state or something).  This function doesn't use "dat" itself
diff --git a/generic/tclTomMathDecls.h b/generic/tclTomMathDecls.h
index 7113f69..bd801a3 100644
--- a/generic/tclTomMathDecls.h
+++ b/generic/tclTomMathDecls.h
@@ -44,13 +44,6 @@
 #define XREALLOC(x,n) TclBNRealloc(x,n)
 #define XCALLOC(n,x) TclBNCalloc(n,x)
 
-/* Rename the global symbols in libtommath to avoid linkage conflicts */
-
-#define KARATSUBA_MUL_CUTOFF TclBNKaratsubaMulCutoff
-#define KARATSUBA_SQR_CUTOFF TclBNKaratsubaSqrCutoff
-#define TOOM_MUL_CUTOFF TclBNToomMulCutoff
-#define TOOM_SQR_CUTOFF TclBNToomSqrCutoff
-
 #define bn_reverse TclBN_reverse
 #define s_mp_reverse TclBN_reverse
 #define fast_s_mp_mul_digs TclBN_fast_s_mp_mul_digs
@@ -172,7 +165,8 @@ EXTERN int		TclBN_mp_add_d(mp_int *a, mp_digit b, mp_int *c);
 #ifndef TclBN_mp_and_TCL_DECLARED
 #define TclBN_mp_and_TCL_DECLARED
 /* 4 */
-EXTERN int		TclBN_mp_and(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_mp_and(CONST mp_int *a, CONST mp_int *b,
+				mp_int *c);
 #endif
 #ifndef TclBN_mp_clamp_TCL_DECLARED
 #define TclBN_mp_clamp_TCL_DECLARED
@@ -192,17 +186,17 @@ EXTERN void		TclBN_mp_clear_multi(mp_int *a, ...);
 #ifndef TclBN_mp_cmp_TCL_DECLARED
 #define TclBN_mp_cmp_TCL_DECLARED
 /* 8 */
-EXTERN int		TclBN_mp_cmp(mp_int *a, mp_int *b);
+EXTERN int		TclBN_mp_cmp(CONST mp_int *a, CONST mp_int *b);
 #endif
 #ifndef TclBN_mp_cmp_d_TCL_DECLARED
 #define TclBN_mp_cmp_d_TCL_DECLARED
 /* 9 */
-EXTERN int		TclBN_mp_cmp_d(mp_int *a, mp_digit b);
+EXTERN int		TclBN_mp_cmp_d(CONST mp_int *a, mp_digit b);
 #endif
 #ifndef TclBN_mp_cmp_mag_TCL_DECLARED
 #define TclBN_mp_cmp_mag_TCL_DECLARED
 /* 10 */
-EXTERN int		TclBN_mp_cmp_mag(mp_int *a, mp_int *b);
+EXTERN int		TclBN_mp_cmp_mag(CONST mp_int *a, CONST mp_int *b);
 #endif
 #ifndef TclBN_mp_copy_TCL_DECLARED
 #define TclBN_mp_copy_TCL_DECLARED
@@ -325,7 +319,8 @@ EXTERN int		TclBN_mp_neg(mp_int *a, mp_int *b);
 #ifndef TclBN_mp_or_TCL_DECLARED
 #define TclBN_mp_or_TCL_DECLARED
 /* 34 */
-EXTERN int		TclBN_mp_or(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_mp_or(CONST mp_int *a, CONST mp_int *b,
+				mp_int *c);
 #endif
 #ifndef TclBN_mp_radix_size_TCL_DECLARED
 #define TclBN_mp_radix_size_TCL_DECLARED
@@ -398,7 +393,8 @@ EXTERN int		TclBN_mp_unsigned_bin_size(mp_int *a);
 #ifndef TclBN_mp_xor_TCL_DECLARED
 #define TclBN_mp_xor_TCL_DECLARED
 /* 48 */
-EXTERN int		TclBN_mp_xor(mp_int *a, mp_int *b, mp_int *c);
+EXTERN int		TclBN_mp_xor(CONST mp_int *a, CONST mp_int *b,
+				mp_int *c);
 #endif
 #ifndef TclBN_mp_zero_TCL_DECLARED
 #define TclBN_mp_zero_TCL_DECLARED
@@ -487,13 +483,13 @@ typedef struct TclTomMathStubs {
     int (*tclBN_revision) (void); /* 1 */
     int (*tclBN_mp_add) (mp_int *a, mp_int *b, mp_int *c); /* 2 */
     int (*tclBN_mp_add_d) (mp_int *a, mp_digit b, mp_int *c); /* 3 */
-    int (*tclBN_mp_and) (mp_int *a, mp_int *b, mp_int *c); /* 4 */
+    int (*tclBN_mp_and) (CONST mp_int *a, CONST mp_int *b, mp_int *c); /* 4 */
     void (*tclBN_mp_clamp) (mp_int *a); /* 5 */
     void (*tclBN_mp_clear) (mp_int *a); /* 6 */
     void (*tclBN_mp_clear_multi) (mp_int *a, ...); /* 7 */
-    int (*tclBN_mp_cmp) (mp_int *a, mp_int *b); /* 8 */
-    int (*tclBN_mp_cmp_d) (mp_int *a, mp_digit b); /* 9 */
-    int (*tclBN_mp_cmp_mag) (mp_int *a, mp_int *b); /* 10 */
+    int (*tclBN_mp_cmp) (CONST mp_int *a, CONST mp_int *b); /* 8 */
+    int (*tclBN_mp_cmp_d) (CONST mp_int *a, mp_digit b); /* 9 */
+    int (*tclBN_mp_cmp_mag) (CONST mp_int *a, CONST mp_int *b); /* 10 */
     int (*tclBN_mp_copy) (mp_int *a, mp_int *b); /* 11 */
     int (*tclBN_mp_count_bits) (mp_int *a); /* 12 */
     int (*tclBN_mp_div) (mp_int *a, mp_int *b, mp_int *q, mp_int *r); /* 13 */
@@ -517,7 +513,7 @@ typedef struct TclTomMathStubs {
     int (*tclBN_mp_mul_2) (mp_int *a, mp_int *p); /* 31 */
     int (*tclBN_mp_mul_2d) (mp_int *a, int d, mp_int *p); /* 32 */
     int (*tclBN_mp_neg) (mp_int *a, mp_int *b); /* 33 */
-    int (*tclBN_mp_or) (mp_int *a, mp_int *b, mp_int *c); /* 34 */
+    int (*tclBN_mp_or) (CONST mp_int *a, CONST mp_int *b, mp_int *c); /* 34 */
     int (*tclBN_mp_radix_size) (mp_int *a, int radix, int *size); /* 35 */
     int (*tclBN_mp_read_radix) (mp_int *a, CONST char *str, int radix); /* 36 */
     void (*tclBN_mp_rshd) (mp_int *a, int shift); /* 37 */
@@ -531,7 +527,7 @@ typedef struct TclTomMathStubs {
     int (*tclBN_mp_to_unsigned_bin_n) (mp_int *a, unsigned char *b, unsigned long *outlen); /* 45 */
     int (*tclBN_mp_toradix_n) (mp_int *a, char *str, int radix, int maxlen); /* 46 */
     int (*tclBN_mp_unsigned_bin_size) (mp_int *a); /* 47 */
-    int (*tclBN_mp_xor) (mp_int *a, mp_int *b, mp_int *c); /* 48 */
+    int (*tclBN_mp_xor) (CONST mp_int *a, CONST mp_int *b, mp_int *c); /* 48 */
     void (*tclBN_mp_zero) (mp_int *a); /* 49 */
     void (*tclBN_reverse) (unsigned char *s, int len); /* 50 */
     int (*tclBN_fast_s_mp_mul_digs) (mp_int *a, mp_int *b, mp_int *c, int digs); /* 51 */