#include <assert.h>
#include <stdlib.h>
#include <string.h>
+#include <limits.h>
#include "misc.h"
static Bignum newbn(int length)
{
- Bignum b = snewn(length + 1, BignumInt);
+ Bignum b;
+
+ assert(length >= 0 && length < INT_MAX / BIGNUM_INT_BITS);
+
+ b = snewn(length + 1, BignumInt);
if (!b)
abort(); /* FIXME */
memset(b, 0, (length + 1) * sizeof(*b));
Bignum bn_power_2(int n)
{
- Bignum ret = newbn(n / BIGNUM_INT_BITS + 1);
+ Bignum ret;
+
+ assert(n >= 0);
+
+ ret = newbn(n / BIGNUM_INT_BITS + 1);
bignum_set_bit(ret, n, 1);
return ret;
}
addend = (BignumDblInt)n << bshift;
while (addend) {
+ assert(word <= number[0]);
addend += number[word];
number[word] = (BignumInt) addend & BIGNUM_INT_MASK;
addend >>= BIGNUM_INT_BITS;
Bignum result;
int w, i;
+ assert(nbytes >= 0 && nbytes < INT_MAX/8);
+
w = (nbytes + BIGNUM_INT_BYTES - 1) / BIGNUM_INT_BYTES; /* bytes->words */
result = newbn(w);
*/
int bignum_byte(Bignum bn, int i)
{
- if (i >= (int)(BIGNUM_INT_BYTES * bn[0]))
+ if (i < 0 || i >= (int)(BIGNUM_INT_BYTES * bn[0]))
return 0; /* beyond the end */
else
return (bn[i / BIGNUM_INT_BYTES + 1] >>
*/
int bignum_bit(Bignum bn, int i)
{
- if (i >= (int)(BIGNUM_INT_BITS * bn[0]))
+ if (i < 0 || i >= (int)(BIGNUM_INT_BITS * bn[0]))
return 0; /* beyond the end */
else
return (bn[i / BIGNUM_INT_BITS + 1] >> (i % BIGNUM_INT_BITS)) & 1;
*/
void bignum_set_bit(Bignum bn, int bitnum, int value)
{
- if (bitnum >= (int)(BIGNUM_INT_BITS * bn[0]))
+ if (bitnum < 0 || bitnum >= (int)(BIGNUM_INT_BITS * bn[0]))
abort(); /* beyond the end */
else {
int v = bitnum / BIGNUM_INT_BITS + 1;
int bignum_cmp(Bignum a, Bignum b)
{
int amax = a[0], bmax = b[0];
- int i = (amax > bmax ? amax : bmax);
+ int i;
+
+ /* Annoyingly we have two representations of zero */
+ if (amax == 1 && a[amax] == 0)
+ amax = 0;
+ if (bmax == 1 && b[bmax] == 0)
+ bmax = 0;
+
+ assert(amax == 0 || a[amax] != 0);
+ assert(bmax == 0 || b[bmax] != 0);
+
+ i = (amax > bmax ? amax : bmax);
while (i) {
BignumInt aval = (i > amax ? 0 : a[i]);
BignumInt bval = (i > bmax ? 0 : b[i]);
int i, shiftw, shiftb, shiftbb, bits;
BignumInt ai, ai1;
+ assert(shift >= 0);
+
bits = bignum_bitcount(a) - shift;
ret = newbn((bits + BIGNUM_INT_BITS - 1) / BIGNUM_INT_BITS);
* Found a common factor between the inputs, so we cannot
* return a modular inverse at all.
*/
+ freebn(b);
+ freebn(a);
+ freebn(xp);
+ freebn(x);
return NULL;
}