#define ABS(x) ((x) < 0 ? -(x) : (x))
/* Forward */
-static PyLongObject *long_normalize Py_PROTO((PyLongObject *));
-static PyLongObject *mul1 Py_PROTO((PyLongObject *, wdigit));
-static PyLongObject *muladd1 Py_PROTO((PyLongObject *, wdigit, wdigit));
-static PyLongObject *divrem1 Py_PROTO((PyLongObject *, wdigit, digit *));
-static PyObject *long_format Py_PROTO((PyObject *aa, int base, int addL));
+static PyLongObject *long_normalize(PyLongObject *);
+static PyLongObject *mul1(PyLongObject *, wdigit);
+static PyLongObject *muladd1(PyLongObject *, wdigit, wdigit);
+static PyLongObject *divrem1(PyLongObject *, wdigit, digit *);
+static PyObject *long_format(PyObject *aa, int base, int addL);
static int ticker; /* XXX Could be shared with ceval? */
of the algorithms used, this could save at most be one word anyway. */
static PyLongObject *
-long_normalize(v)
- register PyLongObject *v;
+long_normalize(register PyLongObject *v)
{
int j = ABS(v->ob_size);
register int i = j;
Return NULL and set exception if we run out of memory. */
PyLongObject *
-_PyLong_New(size)
- int size;
+_PyLong_New(int size)
{
return PyObject_NEW_VAR(PyLongObject, &PyLong_Type, size);
}
/* Create a new long int object from a C long int */
PyObject *
-PyLong_FromLong(ival)
- long ival;
+PyLong_FromLong(long ival)
{
/* Assume a C long fits in at most 5 'digits' */
/* Works on both 32- and 64-bit machines */
/* Create a new long int object from a C unsigned long int */
PyObject *
-PyLong_FromUnsignedLong(ival)
- unsigned long ival;
+PyLong_FromUnsignedLong(unsigned long ival)
{
/* Assume a C long fits in at most 5 'digits' */
/* Works on both 32- and 64-bit machines */
/* Create a new long int object from a C double */
PyObject *
-#ifdef MPW
PyLong_FromDouble(double dval)
-#else
-PyLong_FromDouble(dval)
- double dval;
-#endif /* MPW */
{
PyLongObject *v;
double frac;
Returns -1 and sets an error condition if overflow occurs. */
long
-PyLong_AsLong(vv)
- PyObject *vv;
+PyLong_AsLong(PyObject *vv)
{
/* This version by Tim Peters */
register PyLongObject *v;
Returns -1 and sets an error condition if overflow occurs. */
unsigned long
-PyLong_AsUnsignedLong(vv)
- PyObject *vv;
+PyLong_AsUnsignedLong(PyObject *vv)
{
register PyLongObject *v;
unsigned long x, prev;
/* Get a C double from a long int object. */
double
-PyLong_AsDouble(vv)
- PyObject *vv;
+PyLong_AsDouble(PyObject *vv)
{
register PyLongObject *v;
double x;
/* Create a new long (or int) object from a C pointer */
PyObject *
-PyLong_FromVoidPtr(p)
- void *p;
+PyLong_FromVoidPtr(void *p)
{
#if SIZEOF_VOID_P == SIZEOF_LONG
return PyInt_FromLong((long)p);
/* Get a C pointer from a long object (or an int object in some cases) */
void *
-PyLong_AsVoidPtr(vv)
- PyObject *vv;
+PyLong_AsVoidPtr(PyObject *vv)
{
/* This function will allow int or long objects. If vv is neither,
then the PyLong_AsLong*() functions will raise the exception:
/* Create a new long int object from a C LONG_LONG int */
PyObject *
-PyLong_FromLongLong(ival)
- LONG_LONG ival;
+PyLong_FromLongLong(LONG_LONG ival)
{
#if SIZEOF_LONG_LONG == SIZEOF_LONG
/* In case the compiler is faking it. */
/* Create a new long int object from a C unsigned LONG_LONG int */
PyObject *
-PyLong_FromUnsignedLongLong(ival)
- unsigned LONG_LONG ival;
+PyLong_FromUnsignedLongLong(unsigned LONG_LONG ival)
{
#if SIZEOF_LONG_LONG == SIZEOF_LONG
/* In case the compiler is faking it. */
Returns -1 and sets an error condition if overflow occurs. */
LONG_LONG
-PyLong_AsLongLong(vv)
- PyObject *vv;
+PyLong_AsLongLong(PyObject *vv)
{
#if SIZEOF_LONG_LONG == SIZEOF_LONG
/* In case the compiler is faking it. */
}
unsigned LONG_LONG
-PyLong_AsUnsignedLongLong(vv)
- PyObject *vv;
+PyLong_AsUnsignedLongLong(PyObject *vv)
{
#if SIZEOF_LONG_LONG == 4
/* In case the compiler is faking it. */
/* Multiply by a single digit, ignoring the sign. */
static PyLongObject *
-mul1(a, n)
- PyLongObject *a;
- wdigit n;
+mul1(PyLongObject *a, wdigit n)
{
return muladd1(a, n, (digit)0);
}
/* Multiply by a single digit and add a single digit, ignoring the sign. */
static PyLongObject *
-muladd1(a, n, extra)
- PyLongObject *a;
- wdigit n;
- wdigit extra;
+muladd1(PyLongObject *a, wdigit n, wdigit extra)
{
int size_a = ABS(a->ob_size);
PyLongObject *z = _PyLong_New(size_a+1);
The sign of a is ignored; n should not be zero. */
static PyLongObject *
-divrem1(a, n, prem)
- PyLongObject *a;
- wdigit n;
- digit *prem;
+divrem1(PyLongObject *a, wdigit n, digit *prem)
{
int size = ABS(a->ob_size);
PyLongObject *z;
If base is 8 or 16, add the proper prefix '0' or '0x'. */
static PyObject *
-long_format(aa, base, addL)
- PyObject *aa;
- int base;
- int addL;
+long_format(PyObject *aa, int base, int addL)
{
register PyLongObject *a = (PyLongObject *)aa;
PyStringObject *str;
return (PyObject *)str;
}
-#if 0
-/* Convert a string to a long int object, in a given base.
- Base zero implies a default depending on the number.
- External linkage: used in compile.c and stropmodule.c. */
-
-PyObject *
-long_scan(str, base)
- char *str;
- int base;
-{
- return PyLong_FromString(str, (char **)NULL, base);
-}
-#endif
-
PyObject *
-PyLong_FromString(str, pend, base)
- char *str;
- char **pend;
- int base;
+PyLong_FromString(char *str, char **pend, int base)
{
int sign = 1;
char *start, *orig_str = str;
}
PyObject *
-PyLong_FromUnicode(u, length, base)
- Py_UNICODE *u;
- int length;
- int base;
+PyLong_FromUnicode(Py_UNICODE *u, int length, int base)
{
char buffer[256];
return PyLong_FromString(buffer, NULL, base);
}
+/* forward */
static PyLongObject *x_divrem
- Py_PROTO((PyLongObject *, PyLongObject *, PyLongObject **));
-static PyObject *long_pos Py_PROTO((PyLongObject *));
-static int long_divrem Py_PROTO((PyLongObject *, PyLongObject *,
- PyLongObject **, PyLongObject **));
+ (PyLongObject *, PyLongObject *, PyLongObject **);
+static PyObject *long_pos(PyLongObject *);
+static int long_divrem(PyLongObject *, PyLongObject *,
+ PyLongObject **, PyLongObject **);
/* Long division with remainder, top-level routine */
static int
-long_divrem(a, b, pdiv, prem)
- PyLongObject *a, *b;
- PyLongObject **pdiv;
- PyLongObject **prem;
+long_divrem(PyLongObject *a, PyLongObject *b,
+ PyLongObject **pdiv, PyLongObject **prem)
{
int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
PyLongObject *z;
/* Unsigned long division with remainder -- the algorithm */
static PyLongObject *
-x_divrem(v1, w1, prem)
- PyLongObject *v1, *w1;
- PyLongObject **prem;
+x_divrem(PyLongObject *v1, PyLongObject *w1, PyLongObject **prem)
{
int size_v = ABS(v1->ob_size), size_w = ABS(w1->ob_size);
digit d = (digit) ((twodigits)BASE / (w1->ob_digit[size_w-1] + 1));
/* Methods */
-/* Forward */
-static void long_dealloc Py_PROTO((PyObject *));
-static PyObject *long_repr Py_PROTO((PyObject *));
-static int long_compare Py_PROTO((PyLongObject *, PyLongObject *));
-static long long_hash Py_PROTO((PyLongObject *));
-
-static PyObject *long_add Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_sub Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_mul Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_div Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_mod Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_divmod Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_pow
- Py_PROTO((PyLongObject *, PyLongObject *, PyLongObject *));
-static PyObject *long_neg Py_PROTO((PyLongObject *));
-static PyObject *long_pos Py_PROTO((PyLongObject *));
-static PyObject *long_abs Py_PROTO((PyLongObject *));
-static int long_nonzero Py_PROTO((PyLongObject *));
-static PyObject *long_invert Py_PROTO((PyLongObject *));
-static PyObject *long_lshift Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_rshift Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_and Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_xor Py_PROTO((PyLongObject *, PyLongObject *));
-static PyObject *long_or Py_PROTO((PyLongObject *, PyLongObject *));
-
static void
-long_dealloc(v)
- PyObject *v;
+long_dealloc(PyObject *v)
{
PyObject_DEL(v);
}
static PyObject *
-long_repr(v)
- PyObject *v;
+long_repr(PyObject *v)
{
return long_format(v, 10, 1);
}
static PyObject *
-long_str(v)
- PyObject *v;
+long_str(PyObject *v)
{
return long_format(v, 10, 0);
}
static int
-long_compare(a, b)
- PyLongObject *a, *b;
+long_compare(PyLongObject *a, PyLongObject *b)
{
int sign;
}
static long
-long_hash(v)
- PyLongObject *v;
+long_hash(PyLongObject *v)
{
long x;
int i, sign;
/* Add the absolute values of two long integers. */
-static PyLongObject *x_add Py_PROTO((PyLongObject *, PyLongObject *));
static PyLongObject *
-x_add(a, b)
- PyLongObject *a, *b;
+x_add(PyLongObject *a, PyLongObject *b)
{
int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
PyLongObject *z;
/* Subtract the absolute values of two integers. */
-static PyLongObject *x_sub Py_PROTO((PyLongObject *, PyLongObject *));
static PyLongObject *
-x_sub(a, b)
- PyLongObject *a, *b;
+x_sub(PyLongObject *a, PyLongObject *b)
{
int size_a = ABS(a->ob_size), size_b = ABS(b->ob_size);
PyLongObject *z;
}
static PyObject *
-long_add(a, b)
- PyLongObject *a;
- PyLongObject *b;
+long_add(PyLongObject *a, PyLongObject *b)
{
PyLongObject *z;
}
static PyObject *
-long_sub(a, b)
- PyLongObject *a;
- PyLongObject *b;
+long_sub(PyLongObject *a, PyLongObject *b)
{
PyLongObject *z;
}
static PyObject *
-long_mul(a, b)
- PyLongObject *a;
- PyLongObject *b;
+long_mul(PyLongObject *a, PyLongObject *b)
{
int size_a;
int size_b;
have different signs. We then subtract one from the 'div'
part of the outcome to keep the invariant intact. */
-static int l_divmod Py_PROTO((PyLongObject *, PyLongObject *,
- PyLongObject **, PyLongObject **));
static int
-l_divmod(v, w, pdiv, pmod)
- PyLongObject *v;
- PyLongObject *w;
- PyLongObject **pdiv;
- PyLongObject **pmod;
+l_divmod(PyLongObject *v, PyLongObject *w,
+ PyLongObject **pdiv, PyLongObject **pmod)
{
PyLongObject *div, *mod;
}
static PyObject *
-long_div(v, w)
- PyLongObject *v;
- PyLongObject *w;
+long_div(PyLongObject *v, PyLongObject *w)
{
PyLongObject *div, *mod;
if (l_divmod(v, w, &div, &mod) < 0)
}
static PyObject *
-long_mod(v, w)
- PyLongObject *v;
- PyLongObject *w;
+long_mod(PyLongObject *v, PyLongObject *w)
{
PyLongObject *div, *mod;
if (l_divmod(v, w, &div, &mod) < 0)
}
static PyObject *
-long_divmod(v, w)
- PyLongObject *v;
- PyLongObject *w;
+long_divmod(PyLongObject *v, PyLongObject *w)
{
PyObject *z;
PyLongObject *div, *mod;
}
static PyObject *
-long_pow(a, b, c)
- PyLongObject *a;
- PyLongObject *b;
- PyLongObject *c;
+long_pow(PyLongObject *a, PyLongObject *b, PyLongObject *c)
{
PyLongObject *z, *div, *mod;
int size_b, i;
}
static PyObject *
-long_invert(v)
- PyLongObject *v;
+long_invert(PyLongObject *v)
{
/* Implement ~x as -(x+1) */
PyLongObject *x;
}
static PyObject *
-long_pos(v)
- PyLongObject *v;
+long_pos(PyLongObject *v)
{
Py_INCREF(v);
return (PyObject *)v;
}
static PyObject *
-long_neg(v)
- PyLongObject *v;
+long_neg(PyLongObject *v)
{
PyLongObject *z;
int i, n;
}
static PyObject *
-long_abs(v)
- PyLongObject *v;
+long_abs(PyLongObject *v)
{
if (v->ob_size < 0)
return long_neg(v);
}
static int
-long_nonzero(v)
- PyLongObject *v;
+long_nonzero(PyLongObject *v)
{
return ABS(v->ob_size) != 0;
}
static PyObject *
-long_rshift(a, b)
- PyLongObject *a;
- PyLongObject *b;
+long_rshift(PyLongObject *a, PyLongObject *b)
{
PyLongObject *z;
long shiftby;
}
static PyObject *
-long_lshift(a, b)
- PyLongObject *a;
- PyLongObject *b;
+long_lshift(PyLongObject *a, PyLongObject *b)
{
/* This version due to Tim Peters */
PyLongObject *z;
#define MAX(x, y) ((x) < (y) ? (y) : (x))
#define MIN(x, y) ((x) > (y) ? (y) : (x))
-static PyObject *long_bitwise Py_PROTO((PyLongObject *, int, PyLongObject *));
static PyObject *
-long_bitwise(a, op, b)
- PyLongObject *a;
- int op; /* '&', '|', '^' */
- PyLongObject *b;
+long_bitwise(PyLongObject *a,
+ int op, /* '&', '|', '^' */
+ PyLongObject *b)
{
digit maska, maskb; /* 0 or MASK */
int negz;
}
static PyObject *
-long_and(a, b)
- PyLongObject *a;
- PyLongObject *b;
+long_and(PyLongObject *a, PyLongObject *b)
{
return long_bitwise(a, '&', b);
}
static PyObject *
-long_xor(a, b)
- PyLongObject *a;
- PyLongObject *b;
+long_xor(PyLongObject *a, PyLongObject *b)
{
return long_bitwise(a, '^', b);
}
static PyObject *
-long_or(a, b)
- PyLongObject *a;
- PyLongObject *b;
+long_or(PyLongObject *a, PyLongObject *b)
{
return long_bitwise(a, '|', b);
}
static int
-long_coerce(pv, pw)
- PyObject **pv;
- PyObject **pw;
+long_coerce(PyObject **pv, PyObject **pw)
{
if (PyInt_Check(*pw)) {
*pw = PyLong_FromLong(PyInt_AsLong(*pw));
}
static PyObject *
-long_int(v)
- PyObject *v;
+long_int(PyObject *v)
{
long x;
x = PyLong_AsLong(v);
}
static PyObject *
-long_long(v)
- PyObject *v;
+long_long(PyObject *v)
{
Py_INCREF(v);
return v;
}
static PyObject *
-long_float(v)
- PyObject *v;
+long_float(PyObject *v)
{
double result;
PyFPE_START_PROTECT("long_float", return 0)
}
static PyObject *
-long_oct(v)
- PyObject *v;
+long_oct(PyObject *v)
{
return long_format(v, 8, 1);
}
static PyObject *
-long_hex(v)
- PyObject *v;
+long_hex(PyObject *v)
{
return long_format(v, 16, 1);
}
-
-#define UF (unaryfunc)
-#define BF (binaryfunc)
-#define TF (ternaryfunc)
-#define IF (inquiry)
-
static PyNumberMethods long_as_number = {
- BF long_add, /*nb_add*/
- BF long_sub, /*nb_subtract*/
- BF long_mul, /*nb_multiply*/
- BF long_div, /*nb_divide*/
- BF long_mod, /*nb_remainder*/
- BF long_divmod, /*nb_divmod*/
- TF long_pow, /*nb_power*/
- UF long_neg, /*nb_negative*/
- UF long_pos, /*tp_positive*/
- UF long_abs, /*tp_absolute*/
- IF long_nonzero,/*tp_nonzero*/
- UF long_invert, /*nb_invert*/
- BF long_lshift, /*nb_lshift*/
- BF long_rshift, /*nb_rshift*/
- BF long_and, /*nb_and*/
- BF long_xor, /*nb_xor*/
- BF long_or, /*nb_or*/
- (int (*) Py_FPROTO((PyObject **, PyObject **)))
- (coercion)long_coerce, /*nb_coerce*/
- UF long_int, /*nb_int*/
- UF long_long, /*nb_long*/
- UF long_float, /*nb_float*/
- UF long_oct, /*nb_oct*/
- UF long_hex, /*nb_hex*/
+ (binaryfunc) long_add, /*nb_add*/
+ (binaryfunc) long_sub, /*nb_subtract*/
+ (binaryfunc) long_mul, /*nb_multiply*/
+ (binaryfunc) long_div, /*nb_divide*/
+ (binaryfunc) long_mod, /*nb_remainder*/
+ (binaryfunc) long_divmod, /*nb_divmod*/
+ (ternaryfunc) long_pow, /*nb_power*/
+ (unaryfunc) long_neg, /*nb_negative*/
+ (unaryfunc) long_pos, /*tp_positive*/
+ (unaryfunc) long_abs, /*tp_absolute*/
+ (inquiry) long_nonzero, /*tp_nonzero*/
+ (unaryfunc) long_invert, /*nb_invert*/
+ (binaryfunc) long_lshift, /*nb_lshift*/
+ (binaryfunc) long_rshift, /*nb_rshift*/
+ (binaryfunc) long_and, /*nb_and*/
+ (binaryfunc) long_xor, /*nb_xor*/
+ (binaryfunc) long_or, /*nb_or*/
+ (int (*) (PyObject **, PyObject **))
+ (coercion)long_coerce, /*nb_coerce*/
+ (unaryfunc) long_int, /*nb_int*/
+ (unaryfunc) long_long, /*nb_long*/
+ (unaryfunc) long_float, /*nb_float*/
+ (unaryfunc) long_oct, /*nb_oct*/
+ (unaryfunc) long_hex, /*nb_hex*/
};
PyTypeObject PyLong_Type = {
"long int",
sizeof(PyLongObject) - sizeof(digit),
sizeof(digit),
- (destructor)long_dealloc, /*tp_dealloc*/
- 0, /*tp_print*/
- 0, /*tp_getattr*/
- 0, /*tp_setattr*/
- (int (*) Py_FPROTO((PyObject *, PyObject *)))
- (cmpfunc)long_compare, /*tp_compare*/
- (reprfunc)long_repr, /*tp_repr*/
- &long_as_number,/*tp_as_number*/
- 0, /*tp_as_sequence*/
- 0, /*tp_as_mapping*/
- (long (*) Py_FPROTO((PyObject *)))
- (hashfunc)long_hash, /*tp_hash*/
- 0, /*tp_call*/
- (reprfunc)long_str, /*tp_str*/
+ (destructor)long_dealloc, /*tp_dealloc*/
+ 0, /*tp_print*/
+ 0, /*tp_getattr*/
+ 0, /*tp_setattr*/
+ (int (*) (PyObject *, PyObject *))
+ (cmpfunc)long_compare, /*tp_compare*/
+ (reprfunc)long_repr, /*tp_repr*/
+ &long_as_number, /*tp_as_number*/
+ 0, /*tp_as_sequence*/
+ 0, /*tp_as_mapping*/
+ (long (*) (PyObject *))
+ (hashfunc)long_hash, /*tp_hash*/
+ 0, /*tp_call*/
+ (reprfunc)long_str, /*tp_str*/
};
projects / python / commitdiff