#include "Python.h"

#include "longintrepr.h"

#include <ctype.h>

#define ABS(x) ((x) < 0 ? -(x) : (x))

static PyLongObject *long_normalize(PyLongObject *);

static PyLongObject *mul1(PyLongObject *, wdigit);

static PyLongObject *muladd1(PyLongObject *, wdigit, wdigit);

static PyLongObject *divrem1(PyLongObject *, digit, digit *);

static PyObject *long_format(PyObject *aa, int base, int addL);

static int ticker; /* XXX Could be shared with ceval? */

#define SIGCHECK(PyTryBlock) \

if (--ticker < 0) { \

ticker = 100; \

if (PyErr_CheckSignals()) { PyTryBlock; } \

}

static PyLongObject *

long_normalize(register PyLongObject *v)

{

int j = ABS(v->ob_size);

register int i = j;

while (i > 0 && v->ob_digit[i-1] == 0)

--i;

if (i != j)

v->ob_size = (v->ob_size < 0) ? -(i) : i;

return v;

}

PyLongObject *

_PyLong_New(int size)

{

return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size);

}

PyObject *

_PyLong_Copy(PyLongObject *src)

{

PyLongObject *result;

int i;

assert(src != NULL);

i = src->ob_size;

if (i < 0)

i = -(i);

result = _PyLong_New(i);

if (result != NULL) {

result->ob_size = src->ob_size;

while (--i >= 0)

result->ob_digit[i] = src->ob_digit[i];

}

return (PyObject *)result;

}

PyObject *

PyLong_FromLong(long ival)

{

PyLongObject *v;

unsigned long t; /* unsigned so >> doesn't propagate sign bit */

int ndigits = 0;

int negative = 0;

if (ival < 0) {

ival = -ival;

negative = 1;

}

/* Count the number of Python digits.

t = (unsigned long)ival;

while (t) {

++ndigits;

t >>= SHIFT;

}

v = _PyLong_New(ndigits);

if (v != NULL) {

digit *p = v->ob_digit;

v->ob_size = negative ? -ndigits : ndigits;

t = (unsigned long)ival;

while (t) {

*p++ = (digit)(t & MASK);

t >>= SHIFT;

}

}

return (PyObject *)v;

}

PyObject *

PyLong_FromUnsignedLong(unsigned long ival)

{

PyLongObject *v;

unsigned long t;

int ndigits = 0;

/* Count the number of Python digits. */

t = (unsigned long)ival;

while (t) {

++ndigits;

t >>= SHIFT;

}

v = _PyLong_New(ndigits);

if (v != NULL) {

digit *p = v->ob_digit;

v->ob_size = ndigits;

while (ival) {

*p++ = (digit)(ival & MASK);

ival >>= SHIFT;

}

}

return (PyObject *)v;

}

PyObject *

PyLong_FromDouble(double dval)

{

PyLongObject *v;

double frac;

int i, ndig, expo, neg;

neg = 0;

if (Py_IS_INFINITY(dval)) {

PyErr_SetString(PyExc_OverflowError,

"cannot convert float infinity to long");

return NULL;

}

if (dval < 0.0) {

neg = 1;

dval = -dval;

}

frac = frexp(dval, &expo); /* dval = frac*2**expo; 0.0 <= frac < 1.0 */

if (expo <= 0)

return PyLong_FromLong(0L);

ndig = (expo-1) / SHIFT + 1; /* Number of 'digits' in result */

v = _PyLong_New(ndig);

if (v == NULL)

return NULL;

frac = ldexp(frac, (expo-1) % SHIFT + 1);

for (i = ndig; --i >= 0; ) {

long bits = (long)frac;

v->ob_digit[i] = (digit) bits;

frac = frac - (double)bits;

frac = ldexp(frac, SHIFT);

}

if (neg)

v->ob_size = -(v->ob_size);

return (PyObject *)v;

}

PyLong_AsLong(PyObject *vv)

{

/* This version by Tim Peters */

register PyLongObject *v;

unsigned long x, prev;

int i, sign;

if (vv == NULL || !PyLong_Check(vv)) {

if (vv != NULL && PyInt_Check(vv))

return PyInt_AsLong(vv);

PyErr_BadInternalCall();

return -1;

}

v = (PyLongObject *)vv;

i = v->ob_size;

sign = 1;

x = 0;

if (i < 0) {

sign = -1;

i = -(i);

}

while (--i >= 0) {

prev = x;

x = (x << SHIFT) + v->ob_digit[i];

if ((x >> SHIFT) != prev)

goto overflow;

}

/* Haven't lost any bits, but if the sign bit is set we're in

if ((long)x < 0 && (sign > 0 || (x << 1) != 0))

goto overflow;

return (long)x * sign;

overflow:

PyErr_SetString(PyExc_OverflowError,

"long int too large to convert to int");

return -1;

}

PyLong_AsUnsignedLong(PyObject *vv)

{

register PyLongObject *v;

unsigned long x, prev;

int i;

if (vv == NULL || !PyLong_Check(vv)) {

PyErr_BadInternalCall();

return (unsigned long) -1;

}

v = (PyLongObject *)vv;

i = v->ob_size;

x = 0;

if (i < 0) {

PyErr_SetString(PyExc_OverflowError,

"can't convert negative value to unsigned long");

return (unsigned long) -1;

}

while (--i >= 0) {

prev = x;

x = (x << SHIFT) + v->ob_digit[i];

if ((x >> SHIFT) != prev) {

PyErr_SetString(PyExc_OverflowError,

"long int too large to convert");

return (unsigned long) -1;

}

}

return x;

}

PyObject *

_PyLong_FromByteArray(const unsigned char* bytes, size_t n,

int little_endian, int is_signed)

{

const unsigned char* pstartbyte;/* LSB of bytes */

int incr; /* direction to move pstartbyte */

const unsigned char* pendbyte; /* MSB of bytes */

size_t numsignificantbytes; /* number of bytes that matter */

size_t ndigits; /* number of Python long digits */

PyLongObject* v; /* result */

int idigit = 0; /* next free index in v->ob_digit */

if (n == 0)

return PyLong_FromLong(0L);

if (little_endian) {

pstartbyte = bytes;

pendbyte = bytes + n - 1;

incr = 1;

}

else {

pstartbyte = bytes + n - 1;

pendbyte = bytes;

incr = -1;

}

if (is_signed)

is_signed = *pendbyte >= 0x80;

/* Compute numsignificantbytes. This consists of finding the most

{

size_t i;

const unsigned char* p = pendbyte;

const int pincr = -incr; /* search MSB to LSB */

const unsigned char insignficant = is_signed ? 0xff : 0x00;

for (i = 0; i < n; ++i, p += pincr) {

if (*p != insignficant)

break;

}

numsignificantbytes = n - i;

/* 2's-comp is a bit tricky here, e.g. 0xff00 == -0x0100, so

if (is_signed && numsignificantbytes < n)

++numsignificantbytes;

}

/* How many Python long digits do we need? We have

ndigits = (numsignificantbytes * 8 + SHIFT - 1) / SHIFT;

if (ndigits > (size_t)INT_MAX)

return PyErr_NoMemory();

v = _PyLong_New((int)ndigits);

if (v == NULL)

return NULL;

/* Copy the bits over. The tricky parts are computing 2's-comp on

{

size_t i;

twodigits carry = 1; /* for 2's-comp calculation */

twodigits accum = 0; /* sliding register */

unsigned int accumbits = 0; /* number of bits in accum */

const unsigned char* p = pstartbyte;

for (i = 0; i < numsignificantbytes; ++i, p += incr) {

twodigits thisbyte = *p;

/* Compute correction for 2's comp, if needed. */

if (is_signed) {

thisbyte = (0xff ^ thisbyte) + carry;

carry = thisbyte >> 8;

thisbyte &= 0xff;

}

/* Because we're going LSB to MSB, thisbyte is

accum |= thisbyte << accumbits;

accumbits += 8;

if (accumbits >= SHIFT) {

/* There's enough to fill a Python digit. */

assert(idigit < (int)ndigits);

v->ob_digit[idigit] = (digit)(accum & MASK);

++idigit;

accum >>= SHIFT;

accumbits -= SHIFT;

assert(accumbits < SHIFT);

}

}

assert(accumbits < SHIFT);

if (accumbits) {

assert(idigit < (int)ndigits);

v->ob_digit[idigit] = (digit)accum;

++idigit;

}

}

v->ob_size = is_signed ? -idigit : idigit;

return (PyObject *)long_normalize(v);

}

_PyLong_AsByteArray(PyLongObject* v,

unsigned char* bytes, size_t n,

int little_endian, int is_signed)

{

int i; /* index into v->ob_digit */

int ndigits; /* |v->ob_size| */

twodigits accum; /* sliding register */

unsigned int accumbits; /* # bits in accum */

int do_twos_comp; /* store 2's-comp? is_signed and v < 0 */

twodigits carry; /* for computing 2's-comp */

size_t j; /* # bytes filled */

unsigned char* p; /* pointer to next byte in bytes */

int pincr; /* direction to move p */

assert(v != NULL && PyLong_Check(v));

if (v->ob_size < 0) {

ndigits = -(v->ob_size);

if (!is_signed) {

PyErr_SetString(PyExc_TypeError,

"can't convert negative long to unsigned");

return -1;

}

do_twos_comp = 1;

}

else {

ndigits = v->ob_size;

do_twos_comp = 0;

}

if (little_endian) {

p = bytes;

pincr = 1;

}

else {

p = bytes + n - 1;

pincr = -1;

}

/* Copy over all the Python digits.

assert(ndigits == 0 || v->ob_digit[ndigits - 1] != 0);

j = 0;

accum = 0;

accumbits = 0;

carry = do_twos_comp ? 1 : 0;

for (i = 0; i < ndigits; ++i) {

twodigits thisdigit = v->ob_digit[i];

if (do_twos_comp) {

thisdigit = (thisdigit ^ MASK) + carry;

carry = thisdigit >> SHIFT;

thisdigit &= MASK;

}

/* Because we're going LSB to MSB, thisdigit is more

accum |= thisdigit << accumbits;

accumbits += SHIFT;

/* The most-significant digit may be (probably is) at least

if (i == ndigits - 1) {

/* Count # of sign bits -- they needn't be stored,

stwodigits s = (stwodigits)(thisdigit <<

(8*sizeof(stwodigits) - SHIFT));

unsigned int nsignbits = 0;

while ((s < 0) == do_twos_comp && nsignbits < SHIFT) {

++nsignbits;

s <<= 1;

}

accumbits -= nsignbits;

}

/* Store as many bytes as possible. */

while (accumbits >= 8) {

if (j >= n)

goto Overflow;

++j;

*p = (unsigned char)(accum & 0xff);

p += pincr;

accumbits -= 8;

accum >>= 8;

}

}

/* Store the straggler (if any). */

assert(accumbits < 8);

assert(carry == 0); /* else do_twos_comp and *every* digit was 0 */

if (accumbits > 0) {

if (j >= n)

goto Overflow;

++j;

if (do_twos_comp) {

/* Fill leading bits of the byte with sign bits

accum |= (~(twodigits)0) << accumbits;

}

*p = (unsigned char)(accum & 0xff);

p += pincr;

}

else if (j == n && n > 0 && is_signed) {

/* The main loop filled the byte array exactly, so the code

unsigned char msb = *(p - pincr);

int sign_bit_set = msb >= 0x80;

assert(accumbits == 0);

if (sign_bit_set == do_twos_comp)

return 0;

else

goto Overflow;

}

/* Fill remaining bytes with copies of the sign bit. */

{

unsigned char signbyte = do_twos_comp ? 0xffU : 0U;

for ( ; j < n; ++j, p += pincr)

*p = signbyte;

}

return 0;

Overflow:

PyErr_SetString(PyExc_OverflowError, "long too big to convert");

return -1;

}

_PyLong_AsScaledDouble(PyObject *vv, int *exponent)

{

#define NBITS_WANTED 57

PyLongObject *v;

double x;

const double multiplier = (double)(1L << SHIFT);

int i, sign;

int nbitsneeded;

if (vv == NULL || !PyLong_Check(vv)) {

PyErr_BadInternalCall();

return -1;

}

v = (PyLongObject *)vv;

i = v->ob_size;

sign = 1;

if (i < 0) {

sign = -1;

i = -(i);

}

else if (i == 0) {

*exponent = 0;

return 0.0;

}

--i;

x = (double)v->ob_digit[i];

nbitsneeded = NBITS_WANTED - 1;

/* Invariant: i Python digits remain unaccounted for. */

while (i > 0 && nbitsneeded > 0) {

--i;

x = x * multiplier + (double)v->ob_digit[i];

nbitsneeded -= SHIFT;

}

/* There are i digits we didn't shift in. Pretending they're all

*exponent = i;

assert(x > 0.0);

return x * sign;

#undef NBITS_WANTED

}

PyLong_AsDouble(PyObject *vv)

{

int e;

double x;

if (vv == NULL || !PyLong_Check(vv)) {

PyErr_BadInternalCall();

return -1;

}

x = _PyLong_AsScaledDouble(vv, &e);

if (x == -1.0 && PyErr_Occurred())

return -1.0;

if (e > INT_MAX / SHIFT)

goto overflow;

errno = 0;

x = ldexp(x, e * SHIFT);

if (Py_OVERFLOWED(x))

goto overflow;

return x;

overflow:

PyErr_SetString(PyExc_OverflowError,

"long int too large to convert to float");

return -1.0;

}

PyObject *

PyLong_FromVoidPtr(void *p)

{

#if SIZEOF_VOID_P <= SIZEOF_LONG

return PyInt_FromLong((long)p);

#ifndef HAVE_LONG_LONG

# error "PyLong_FromVoidPtr: sizeof(void*) > sizeof(long), but no long long"

#if SIZEOF_LONG_LONG < SIZEOF_VOID_P

# error "PyLong_FromVoidPtr: sizeof(LONG_LONG) < sizeof(void*)"

/* optimize null pointers */

if (p == NULL)

return PyInt_FromLong(0);

return PyLong_FromLongLong((LONG_LONG)p);

#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */

}

void *

PyLong_AsVoidPtr(PyObject *vv)

{

/* This function will allow int or long objects. If vv is neither,

#if SIZEOF_VOID_P <= SIZEOF_LONG

long x;

if (PyInt_Check(vv))

x = PyInt_AS_LONG(vv);

else

x = PyLong_AsLong(vv);

#ifndef HAVE_LONG_LONG

# error "PyLong_AsVoidPtr: sizeof(void*) > sizeof(long), but no long long"

#if SIZEOF_LONG_LONG < SIZEOF_VOID_P

# error "PyLong_AsVoidPtr: sizeof(LONG_LONG) < sizeof(void*)"

LONG_LONG x;

if (PyInt_Check(vv))

x = PyInt_AS_LONG(vv);

else

x = PyLong_AsLongLong(vv);

#endif /* SIZEOF_VOID_P <= SIZEOF_LONG */

if (x == -1 && PyErr_Occurred())

return NULL;

return (void *)x;

}

#ifdef HAVE_LONG_LONG

#define IS_LITTLE_ENDIAN (int)*(unsigned char*)&one

PyObject *

PyLong_FromLongLong(LONG_LONG ival)

{

LONG_LONG bytes = ival;

int one = 1;

return _PyLong_FromByteArray(

(unsigned char *)&bytes,

SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1);

}

PyObject *

PyLong_FromUnsignedLongLong(unsigned LONG_LONG ival)

{

unsigned LONG_LONG bytes = ival;

int one = 1;

return _PyLong_FromByteArray(

(unsigned char *)&bytes,

SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0);

}

PyLong_AsLongLong(PyObject *vv)

{

LONG_LONG bytes;

int one = 1;

int res;

if (vv == NULL) {

PyErr_BadInternalCall();

return -1;

}

if (!PyLong_Check(vv)) {

if (PyInt_Check(vv))

return (LONG_LONG)PyInt_AsLong(vv);

PyErr_BadInternalCall();

return -1;

}

res = _PyLong_AsByteArray(

(PyLongObject *)vv, (unsigned char *)&bytes,

SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 1);

return res < 0 ? (LONG_LONG)res : bytes;

}

PyLong_AsUnsignedLongLong(PyObject *vv)

{

unsigned LONG_LONG bytes;

int one = 1;

int res;

if (vv == NULL || !PyLong_Check(vv)) {

PyErr_BadInternalCall();

return -1;

}

res = _PyLong_AsByteArray(

(PyLongObject *)vv, (unsigned char *)&bytes,

SIZEOF_LONG_LONG, IS_LITTLE_ENDIAN, 0);

return res < 0 ? (unsigned LONG_LONG)res : bytes;

}

#undef IS_LITTLE_ENDIAN

#endif /* HAVE_LONG_LONG */

static int

convert_binop(PyObject *v, PyObject *w, PyLongObject **a, PyLongObject **b) {

if (PyLong_Check(v)) {

*a = (PyLongObject *) v;

Py_INCREF(v);

}

else if (PyInt_Check(v)) {

*a = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(v));

}

else {

return 0;

}

if (PyLong_Check(w)) {

*b = (PyLongObject *) w;

Py_INCREF(w);

}

else if (PyInt_Check(w)) {

*b = (PyLongObject *) PyLong_FromLong(PyInt_AS_LONG(w));

}

else {

Py_DECREF(*a);

return 0;

}

return 1;

}

#define CONVERT_BINOP(v, w, a, b) \

if (!convert_binop(v, w, a, b)) { \

Py_INCREF(Py_NotImplemented); \

return Py_NotImplemented; \

}

static PyLongObject *

mul1(PyLongObject *a, wdigit n)

{

return muladd1(a, n, (digit)0);

}

static PyLongObject *

muladd1(PyLongObject *a, wdigit n, wdigit extra)

{

int size_a = ABS(a->ob_size);

PyLongObject *z = _PyLong_New(size_a+1);

twodigits carry = extra;

int i;

if (z == NULL)

return NULL;

for (i = 0; i < size_a; ++i) {

carry += (twodigits)a->ob_digit[i] * n;

z->ob_digit[i] = (digit) (carry & MASK);

carry >>= SHIFT;

}

z->ob_digit[i] = (digit) carry;

return long_normalize(z);

}

static digit

inplace_divrem1(digit *pout, digit *pin, int size, digit n)

{

twodigits rem = 0;

assert(n > 0 && n <= MASK);

pin += size;

pout += size;

while (--size >= 0) {

digit hi;

rem = (rem << SHIFT) + *--pin;

*--pout = hi = (digit)(rem / n);

rem -= hi * n;

}

return (digit)rem;

}

static PyLongObject *

divrem1(PyLongObject *a, digit n, digit *prem)

{

const int size = ABS(a->ob_size);

PyLongObject *z;

assert(n > 0 && n <= MASK);

z = _PyLong_New(size);

if (z == NULL)

return NULL;

*prem = inplace_divrem1(z->ob_digit, a->ob_digit, size, n);

return long_normalize(z);

}

static PyObject *

long_format(PyObject *aa, int base, int addL)

{

register PyLongObject *a = (PyLongObject *)aa;

PyStringObject *str;

int i;

const int size_a = ABS(a->ob_size);

char *p;

int bits;

char sign = '\0';

if (a == NULL || !PyLong_Check(a)) {

PyErr_BadInternalCall();

return NULL;

}

assert(base >= 2 && base <= 36);

/* Compute a rough upper bound for the length of the string */

i = base;

bits = 0;

while (i > 1) {

++bits;

i >>= 1;

}

i = 5 + (addL ? 1 : 0) + (size_a*SHIFT + bits-1) / bits;

str = (PyStringObject *) PyString_FromStringAndSize((char *)0, i);

if (str == NULL)

return NULL;

p = PyString_AS_STRING(str) + i;

*p = '\0';

if (addL)

*--p = 'L';

if (a->ob_size < 0)

sign = '-';

if (a->ob_size == 0) {

*--p = '0';

}

else if ((base & (base - 1)) == 0) {

/* JRH: special case for power-of-2 bases */

twodigits accum = 0;

int accumbits = 0; /* # of bits in accum */

int basebits = 1; /* # of bits in base-1 */

i = base;

while ((i >>= 1) > 1)

++basebits;

for (i = 0; i < size_a; ++i) {

accum |= a->ob_digit[i] << accumbits;

accumbits += SHIFT;

assert(accumbits >= basebits);

do {

char cdigit = (char)(accum & (base - 1));

cdigit += (cdigit < 10) ? '0' : 'A'-10;

assert(p > PyString_AS_STRING(str));

*--p = cdigit;

accumbits -= basebits;

accum >>= basebits;

} while (i < size_a-1 ? accumbits >= basebits :

accum > 0);

}

}

else {

/* Not 0, and base not a power of 2. Divide repeatedly by

int size = size_a;

digit *pin = a->ob_digit;

PyLongObject *scratch;

/* powbasw <- largest power of base that fits in a digit. */

digit powbase = base; /* powbase == base ** power */

int power = 1;

for (;;) {

unsigned long newpow = powbase * (unsigned long)base;

if (newpow >> SHIFT) /* doesn't fit in a digit */

break;

powbase = (digit)newpow;

++power;

}

/* Get a scratch area for repeated division. */

scratch = _PyLong_New(size);

if (scratch == NULL) {

Py_DECREF(str);

return NULL;

}

/* Repeatedly divide by powbase. */

do {

int ntostore = power;

digit rem = inplace_divrem1(scratch->ob_digit,

pin, size, powbase);

pin = scratch->ob_digit; /* no need to use a again */

if (pin[size - 1] == 0)

--size;

SIGCHECK({

Py_DECREF(scratch);

Py_DECREF(str);

return NULL;

})

/* Break rem into digits. */

assert(ntostore > 0);

do {

digit nextrem = (digit)(rem / base);

char c = (char)(rem - nextrem * base);

assert(p > PyString_AS_STRING(str));

c += (c < 10) ? '0' : 'A'-10;

*--p = c;

rem = nextrem;

--ntostore;

/* Termination is a bit delicate: must not

} while (ntostore && (size || rem));

} while (size != 0);

Py_DECREF(scratch);

}

if (base == 8) {

if (size_a != 0)

*--p = '0';

}

else if (base == 16) {

*--p = 'x';

*--p = '0';

}

else if (base != 10) {

*--p = '#';

*--p = '0' + base%10;

if (base > 10)

*--p = '0' + base/10;

}

if (sign)

*--p = sign;

if (p != PyString_AS_STRING(str)) {

char *q = PyString_AS_STRING(str);

assert(p > q);

do {

} while ((*q++ = *p++) != '\0');

q--;

_PyString_Resize((PyObject **)&str,

(int) (q - PyString_AS_STRING(str)));

}

return (PyObject *)str;

}

PyObject *

PyLong_FromString(char *str, char **pend, int base)

{

int sign = 1;

char *start, *orig_str = str;

PyLongObject *z;

if ((base != 0 && base < 2) || base > 36) {

PyErr_SetString(PyExc_ValueError,

"long() arg 2 must be >= 2 and <= 36");

return NULL;

}

while (*str != '\0' && isspace(Py_CHARMASK(*str)))

str++;

if (*str == '+')

++str;

else if (*str == '-') {

++str;

sign = -1;

}