/* Abstract Object Interface (many thanks to Jim Fulton) */

#include "Python.h"

#include <ctype.h>

#include "structmember.h" /* we need the offsetof() macro from there */

#include "longintrepr.h"

/* Shorthands to return certain errors */

static PyObject *

type_error(const char *msg, PyObject *obj)

{

PyErr_Format(PyExc_TypeError, msg, obj->ob_type->tp_name);

return NULL;

}

static PyObject *

null_error(void)

{

if (!PyErr_Occurred())

PyErr_SetString(PyExc_SystemError,

"null argument to internal routine");

return NULL;

}

/* Operations on any object */

int

PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)

{

int r;

if (o1 == NULL || o2 == NULL) {

null_error();

return -1;

}

r = PyObject_Compare(o1, o2);

if (PyErr_Occurred())

return -1;

*result = r;

return 0;

}

PyObject *

PyObject_Type(PyObject *o)

{

PyObject *v;

if (o == NULL)

return null_error();

v = (PyObject *)o->ob_type;

Py_INCREF(v);

return v;

}

Py_ssize_t

PyObject_Size(PyObject *o)

{

PySequenceMethods *m;

if (o == NULL) {

null_error();

return -1;

}

m = o->ob_type->tp_as_sequence;

if (m && m->sq_length)

return m->sq_length(o);

return PyMapping_Size(o);

}

#undef PyObject_Length

Py_ssize_t

PyObject_Length(PyObject *o)

{

return PyObject_Size(o);

}

#define PyObject_Length PyObject_Size

Py_ssize_t

_PyObject_LengthHint(PyObject *o)

{

Py_ssize_t rv = PyObject_Size(o);

if (rv != -1)

return rv;

if (PyErr_ExceptionMatches(PyExc_TypeError) ||

PyErr_ExceptionMatches(PyExc_AttributeError)) {

PyObject *err_type, *err_value, *err_tb, *ro;

PyErr_Fetch(&err_type, &err_value, &err_tb);

ro = PyObject_CallMethod(o, "__length_hint__", NULL);

if (ro != NULL) {

rv = PyInt_AsLong(ro);

Py_DECREF(ro);

Py_XDECREF(err_type);

Py_XDECREF(err_value);

Py_XDECREF(err_tb);

return rv;

}

PyErr_Restore(err_type, err_value, err_tb);

}

return -1;

}

PyObject *

PyObject_GetItem(PyObject *o, PyObject *key)

{

PyMappingMethods *m;

if (o == NULL || key == NULL)

return null_error();

m = o->ob_type->tp_as_mapping;

if (m && m->mp_subscript)

return m->mp_subscript(o, key);

if (o->ob_type->tp_as_sequence) {

if (PyIndex_Check(key)) {

Py_ssize_t key_value;

key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);

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

return NULL;

return PySequence_GetItem(o, key_value);

}

else if (o->ob_type->tp_as_sequence->sq_item)

return type_error("sequence index must "

"be integer, not '%.200s'", key);

}

return type_error("'%.200s' object is unsubscriptable", o);

}

int

PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)

{

PyMappingMethods *m;

if (o == NULL || key == NULL || value == NULL) {

null_error();

return -1;

}

m = o->ob_type->tp_as_mapping;

if (m && m->mp_ass_subscript)

return m->mp_ass_subscript(o, key, value);

if (o->ob_type->tp_as_sequence) {

if (PyIndex_Check(key)) {

Py_ssize_t key_value;

key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);

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

return -1;

return PySequence_SetItem(o, key_value, value);

}

else if (o->ob_type->tp_as_sequence->sq_ass_item) {

type_error("sequence index must be "

"integer, not '%.200s'", key);

return -1;

}

}

type_error("'%.200s' object does not support item assignment", o);

return -1;

}

int

PyObject_DelItem(PyObject *o, PyObject *key)

{

PyMappingMethods *m;

if (o == NULL || key == NULL) {

null_error();

return -1;

}

m = o->ob_type->tp_as_mapping;

if (m && m->mp_ass_subscript)

return m->mp_ass_subscript(o, key, (PyObject*)NULL);

if (o->ob_type->tp_as_sequence) {

if (PyIndex_Check(key)) {

Py_ssize_t key_value;

key_value = PyNumber_AsSsize_t(key, PyExc_IndexError);

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

return -1;

return PySequence_DelItem(o, key_value);

}

else if (o->ob_type->tp_as_sequence->sq_ass_item) {

type_error("sequence index must be "

"integer, not '%.200s'", key);

return -1;

}

}

type_error("'%.200s' object does not support item deletion", o);

return -1;

}

int

PyObject_DelItemString(PyObject *o, char *key)

{

PyObject *okey;

int ret;

if (o == NULL || key == NULL) {

null_error();

return -1;

}

okey = PyString_FromString(key);

if (okey == NULL)

return -1;

ret = PyObject_DelItem(o, okey);

Py_DECREF(okey);

return ret;

}

int

PyObject_AsCharBuffer(PyObject *obj,

const char **buffer,

Py_ssize_t *buffer_len)

{

PyBufferProcs *pb;

char *pp;

Py_ssize_t len;

if (obj == NULL || buffer == NULL || buffer_len == NULL) {

null_error();

return -1;

}

pb = obj->ob_type->tp_as_buffer;

if (pb == NULL ||

pb->bf_getcharbuffer == NULL ||

pb->bf_getsegcount == NULL) {

PyErr_SetString(PyExc_TypeError,

"expected a character buffer object");

return -1;

}

if ((*pb->bf_getsegcount)(obj,NULL) != 1) {

PyErr_SetString(PyExc_TypeError,

"expected a single-segment buffer object");

return -1;

}

len = (*pb->bf_getcharbuffer)(obj, 0, &pp);

if (len < 0)

return -1;

*buffer = pp;

*buffer_len = len;

return 0;

}

int

PyObject_CheckReadBuffer(PyObject *obj)

{

PyBufferProcs *pb = obj->ob_type->tp_as_buffer;

if (pb == NULL ||

pb->bf_getreadbuffer == NULL ||

pb->bf_getsegcount == NULL ||

(*pb->bf_getsegcount)(obj, NULL) != 1)

return 0;

return 1;

}

int PyObject_AsReadBuffer(PyObject *obj,

const void **buffer,

Py_ssize_t *buffer_len)

{

PyBufferProcs *pb;

void *pp;

Py_ssize_t len;

if (obj == NULL || buffer == NULL || buffer_len == NULL) {

null_error();

return -1;

}

pb = obj->ob_type->tp_as_buffer;

if (pb == NULL ||

pb->bf_getreadbuffer == NULL ||

pb->bf_getsegcount == NULL) {

PyErr_SetString(PyExc_TypeError,

"expected a readable buffer object");

return -1;

}

if ((*pb->bf_getsegcount)(obj, NULL) != 1) {

PyErr_SetString(PyExc_TypeError,

"expected a single-segment buffer object");

return -1;

}

len = (*pb->bf_getreadbuffer)(obj, 0, &pp);

if (len < 0)

return -1;

*buffer = pp;

*buffer_len = len;

return 0;

}

int PyObject_AsWriteBuffer(PyObject *obj,

void **buffer,

Py_ssize_t *buffer_len)

{

PyBufferProcs *pb;

void*pp;

Py_ssize_t len;

if (obj == NULL || buffer == NULL || buffer_len == NULL) {

null_error();

return -1;

}

pb = obj->ob_type->tp_as_buffer;

if (pb == NULL ||

pb->bf_getwritebuffer == NULL ||

pb->bf_getsegcount == NULL) {

PyErr_SetString(PyExc_TypeError,

"expected a writeable buffer object");

return -1;

}

if ((*pb->bf_getsegcount)(obj, NULL) != 1) {

PyErr_SetString(PyExc_TypeError,

"expected a single-segment buffer object");

return -1;

}

len = (*pb->bf_getwritebuffer)(obj,0,&pp);

if (len < 0)

return -1;

*buffer = pp;

*buffer_len = len;

return 0;

}

/* Operations on numbers */

int

PyNumber_Check(PyObject *o)

{

return o && o->ob_type->tp_as_number &&

(o->ob_type->tp_as_number->nb_int ||

o->ob_type->tp_as_number->nb_float);

}

/* Binary operators */

#define NB_SLOT(x) offsetof(PyNumberMethods, x)

#define NB_BINOP(nb_methods, slot) \

(*(binaryfunc*)(& ((char*)nb_methods)[slot]))

#define NB_TERNOP(nb_methods, slot) \

(*(ternaryfunc*)(& ((char*)nb_methods)[slot]))

/*

Calling scheme used for binary operations:

Order operations are tried until either a valid result or error:

w.op(v,w)[*], v.op(v,w), w.op(v,w)

[*] only when v->ob_type != w->ob_type && w->ob_type is a subclass of

v->ob_type

*/

static PyObject *

binary_op1(PyObject *v, PyObject *w, const int op_slot)

{

PyObject *x;

binaryfunc slotv = NULL;

binaryfunc slotw = NULL;

if (v->ob_type->tp_as_number != NULL)

slotv = NB_BINOP(v->ob_type->tp_as_number, op_slot);

if (w->ob_type != v->ob_type &&

w->ob_type->tp_as_number != NULL) {

slotw = NB_BINOP(w->ob_type->tp_as_number, op_slot);

if (slotw == slotv)

slotw = NULL;

}

if (slotv) {

if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {

x = slotw(v, w);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

slotw = NULL;

}

x = slotv(v, w);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

if (slotw) {

x = slotw(v, w);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

Py_INCREF(Py_NotImplemented);

return Py_NotImplemented;

}

static PyObject *

binop_type_error(PyObject *v, PyObject *w, const char *op_name)

{

PyErr_Format(PyExc_TypeError,

"unsupported operand type(s) for %.100s: "

"'%.100s' and '%.100s'",

op_name,

v->ob_type->tp_name,

w->ob_type->tp_name);

return NULL;

}

static PyObject *

binary_op(PyObject *v, PyObject *w, const int op_slot, const char *op_name)

{

PyObject *result = binary_op1(v, w, op_slot);

if (result == Py_NotImplemented) {

Py_DECREF(result);

return binop_type_error(v, w, op_name);

}

return result;

}

/*

Calling scheme used for ternary operations:

Order operations are tried until either a valid result or error:

v.op(v,w,z), w.op(v,w,z), z.op(v,w,z)

*/

static PyObject *

ternary_op(PyObject *v,

PyObject *w,

PyObject *z,

const int op_slot,

const char *op_name)

{

PyNumberMethods *mv, *mw, *mz;

PyObject *x = NULL;

ternaryfunc slotv = NULL;

ternaryfunc slotw = NULL;

ternaryfunc slotz = NULL;

mv = v->ob_type->tp_as_number;

mw = w->ob_type->tp_as_number;

if (mv != NULL)

slotv = NB_TERNOP(mv, op_slot);

if (w->ob_type != v->ob_type &&

mw != NULL) {

slotw = NB_TERNOP(mw, op_slot);

if (slotw == slotv)

slotw = NULL;

}

if (slotv) {

if (slotw && PyType_IsSubtype(w->ob_type, v->ob_type)) {

x = slotw(v, w, z);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

slotw = NULL;

}

x = slotv(v, w, z);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

if (slotw) {

x = slotw(v, w, z);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

mz = z->ob_type->tp_as_number;

if (mz != NULL) {

slotz = NB_TERNOP(mz, op_slot);

if (slotz == slotv || slotz == slotw)

slotz = NULL;

if (slotz) {

x = slotz(v, w, z);

if (x != Py_NotImplemented)

return x;

Py_DECREF(x); /* can't do it */

}

}

if (z == Py_None)

PyErr_Format(

PyExc_TypeError,

"unsupported operand type(s) for ** or pow(): "

"'%.100s' and '%.100s'",

v->ob_type->tp_name,

w->ob_type->tp_name);

else

PyErr_Format(

PyExc_TypeError,

"unsupported operand type(s) for pow(): "

"'%.100s', '%.100s', '%.100s'",

v->ob_type->tp_name,

w->ob_type->tp_name,

z->ob_type->tp_name);

return NULL;

}

#define BINARY_FUNC(func, op, op_name) \

PyObject * \

func(PyObject *v, PyObject *w) { \

return binary_op(v, w, NB_SLOT(op), op_name); \

}

BINARY_FUNC(PyNumber_Or, nb_or, "|")

BINARY_FUNC(PyNumber_Xor, nb_xor, "^")

BINARY_FUNC(PyNumber_And, nb_and, "&")

BINARY_FUNC(PyNumber_Lshift, nb_lshift, "<<")

BINARY_FUNC(PyNumber_Rshift, nb_rshift, ">>")

BINARY_FUNC(PyNumber_Subtract, nb_subtract, "-")

BINARY_FUNC(PyNumber_Divmod, nb_divmod, "divmod()")

PyObject *

PyNumber_Add(PyObject *v, PyObject *w)

{

PyObject *result = binary_op1(v, w, NB_SLOT(nb_add));

if (result == Py_NotImplemented) {

PySequenceMethods *m = v->ob_type->tp_as_sequence;

Py_DECREF(result);

if (m && m->sq_concat) {

return (*m->sq_concat)(v, w);

}

result = binop_type_error(v, w, "+");

}

return result;

}

static PyObject *

sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)

{

Py_ssize_t count;

if (PyIndex_Check(n)) {

count = PyNumber_AsSsize_t(n, PyExc_OverflowError);

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

return NULL;

}

else {

return type_error("can't multiply sequence by "

"non-int of type '%.200s'", n);

}

return (*repeatfunc)(seq, count);

}

PyObject *

PyNumber_Multiply(PyObject *v, PyObject *w)

{

PyObject *result = binary_op1(v, w, NB_SLOT(nb_multiply));

if (result == Py_NotImplemented) {

PySequenceMethods *mv = v->ob_type->tp_as_sequence;

PySequenceMethods *mw = w->ob_type->tp_as_sequence;

Py_DECREF(result);

if (mv && mv->sq_repeat) {

return sequence_repeat(mv->sq_repeat, v, w);

}

else if (mw && mw->sq_repeat) {

return sequence_repeat(mw->sq_repeat, w, v);

}

result = binop_type_error(v, w, "*");

}

return result;

}

PyObject *

PyNumber_FloorDivide(PyObject *v, PyObject *w)

{

/* XXX tp_flags test */

return binary_op(v, w, NB_SLOT(nb_floor_divide), "//");

}

PyObject *

PyNumber_TrueDivide(PyObject *v, PyObject *w)

{

/* XXX tp_flags test */

return binary_op(v, w, NB_SLOT(nb_true_divide), "/");

}

PyObject *

PyNumber_Remainder(PyObject *v, PyObject *w)

{

return binary_op(v, w, NB_SLOT(nb_remainder), "%");

}

PyObject *

PyNumber_Power(PyObject *v, PyObject *w, PyObject *z)

{

return ternary_op(v, w, z, NB_SLOT(nb_power), "** or pow()");

}

/* Binary in-place operators */

/* The in-place operators are defined to fall back to the 'normal',

non in-place operations, if the in-place methods are not in place.

- If the left hand object has the appropriate struct members, and

they are filled, call the appropriate function and return the

result. No coercion is done on the arguments; the left-hand object

is the one the operation is performed on, and it's up to the

function to deal with the right-hand object.

- Otherwise, in-place modification is not supported. Handle it exactly as

a non in-place operation of the same kind.

*/

static PyObject *

binary_iop1(PyObject *v, PyObject *w, const int iop_slot, const int op_slot)

{

PyNumberMethods *mv = v->ob_type->tp_as_number;

if (mv != NULL) {

binaryfunc slot = NB_BINOP(mv, iop_slot);

if (slot) {

PyObject *x = (slot)(v, w);

if (x != Py_NotImplemented) {

return x;

}

Py_DECREF(x);

}

}

return binary_op1(v, w, op_slot);

}

static PyObject *

binary_iop(PyObject *v, PyObject *w, const int iop_slot, const int op_slot,

const char *op_name)

{

PyObject *result = binary_iop1(v, w, iop_slot, op_slot);

if (result == Py_NotImplemented) {

Py_DECREF(result);

return binop_type_error(v, w, op_name);

}

return result;

}

#define INPLACE_BINOP(func, iop, op, op_name) \

PyObject * \

func(PyObject *v, PyObject *w) { \

return binary_iop(v, w, NB_SLOT(iop), NB_SLOT(op), op_name); \

}

INPLACE_BINOP(PyNumber_InPlaceOr, nb_inplace_or, nb_or, "|=")

INPLACE_BINOP(PyNumber_InPlaceXor, nb_inplace_xor, nb_xor, "^=")

INPLACE_BINOP(PyNumber_InPlaceAnd, nb_inplace_and, nb_and, "&=")

INPLACE_BINOP(PyNumber_InPlaceLshift, nb_inplace_lshift, nb_lshift, "<<=")

INPLACE_BINOP(PyNumber_InPlaceRshift, nb_inplace_rshift, nb_rshift, ">>=")

INPLACE_BINOP(PyNumber_InPlaceSubtract, nb_inplace_subtract, nb_subtract, "-=")

PyObject *

PyNumber_InPlaceFloorDivide(PyObject *v, PyObject *w)

{

/* XXX tp_flags test */

return binary_iop(v, w, NB_SLOT(nb_inplace_floor_divide),

NB_SLOT(nb_floor_divide), "//=");

}

PyObject *

PyNumber_InPlaceTrueDivide(PyObject *v, PyObject *w)

{

/* XXX tp_flags test */

return binary_iop(v, w, NB_SLOT(nb_inplace_true_divide),

NB_SLOT(nb_true_divide), "/=");

}

PyObject *

PyNumber_InPlaceAdd(PyObject *v, PyObject *w)

{

PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_add),

NB_SLOT(nb_add));

if (result == Py_NotImplemented) {

PySequenceMethods *m = v->ob_type->tp_as_sequence;

Py_DECREF(result);

if (m != NULL) {

binaryfunc f = NULL;

f = m->sq_inplace_concat;

if (f == NULL)

f = m->sq_concat;

if (f != NULL)

return (*f)(v, w);

}

result = binop_type_error(v, w, "+=");

}

return result;

}

PyObject *

PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)

{

PyObject *result = binary_iop1(v, w, NB_SLOT(nb_inplace_multiply),

NB_SLOT(nb_multiply));

if (result == Py_NotImplemented) {

ssizeargfunc f = NULL;

PySequenceMethods *mv = v->ob_type->tp_as_sequence;

PySequenceMethods *mw = w->ob_type->tp_as_sequence;

Py_DECREF(result);

if (mv != NULL) {

f = mv->sq_inplace_repeat;

if (f == NULL)

f = mv->sq_repeat;

if (f != NULL)

return sequence_repeat(f, v, w);

}

else if (mw != NULL) {

/* Note that the right hand operand should not be

* mutated in this case so sq_inplace_repeat is not

* used. */

if (mw->sq_repeat)

return sequence_repeat(mw->sq_repeat, w, v);

}

result = binop_type_error(v, w, "*=");

}

return result;

}

PyObject *

PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)

{

return binary_iop(v, w, NB_SLOT(nb_inplace_remainder),

NB_SLOT(nb_remainder), "%=");

}

PyObject *

PyNumber_InPlacePower(PyObject *v, PyObject *w, PyObject *z)

{

if (v->ob_type->tp_as_number &&

v->ob_type->tp_as_number->nb_inplace_power != NULL) {

return ternary_op(v, w, z, NB_SLOT(nb_inplace_power), "**=");

}

else {

return ternary_op(v, w, z, NB_SLOT(nb_power), "**=");

}

}

/* Unary operators and functions */

PyObject *

PyNumber_Negative(PyObject *o)

{

PyNumberMethods *m;

if (o == NULL)

return null_error();

m = o->ob_type->tp_as_number;

if (m && m->nb_negative)

return (*m->nb_negative)(o);

return type_error("bad operand type for unary -: '%.200s'", o);

}

PyObject *

PyNumber_Positive(PyObject *o)

{

PyNumberMethods *m;

if (o == NULL)

return null_error();

m = o->ob_type->tp_as_number;

if (m && m->nb_positive)

return (*m->nb_positive)(o);

return type_error("bad operand type for unary +: '%.200s'", o);

}

PyObject *

PyNumber_Invert(PyObject *o)

{

PyNumberMethods *m;

if (o == NULL)

return null_error();

m = o->ob_type->tp_as_number;

if (m && m->nb_invert)

return (*m->nb_invert)(o);

return type_error("bad operand type for unary ~: '%.200s'", o);

}

PyObject *

PyNumber_Absolute(PyObject *o)

{

PyNumberMethods *m;

if (o == NULL)

return null_error();

m = o->ob_type->tp_as_number;

if (m && m->nb_absolute)

return m->nb_absolute(o);

return type_error("bad operand type for abs(): '%.200s'", o);

}

/* Add a check for embedded NULL-bytes in the argument. */

static PyObject *

int_from_string(const char *s, Py_ssize_t len)

{

char *end;

PyObject *x;

x = PyInt_FromString((char*)s, &end, 10);

if (x == NULL)

return NULL;

if (end != s + len) {

PyErr_SetString(PyExc_ValueError,

"null byte in argument for int()");

Py_DECREF(x);

return NULL;

}

return x;

}

/* Return a Python Int or Long from the object item

Raise TypeError if the result is not an int-or-long

or if the object cannot be interpreted as an index.

*/

PyObject *

PyNumber_Index(PyObject *item)

{

PyObject *result = NULL;

if (item == NULL)

return null_error();

if (PyInt_Check(item) || PyLong_Check(item)) {

Py_INCREF(item);

return item;

}

if (PyIndex_Check(item)) {

result = item->ob_type->tp_as_number->nb_index(item);

if (result &&

!PyInt_Check(result) && !PyLong_Check(result)) {

PyErr_Format(PyExc_TypeError,

"__index__ returned non-(int,long) " \

"(type %.200s)",

result->ob_type->tp_name);

Py_DECREF(result);

return NULL;

}

}

else {

PyErr_Format(PyExc_TypeError,

"'%.200s' object cannot be interpreted "

"as an index", item->ob_type->tp_name);

}

return result;

}

/* Return an error on Overflow only if err is not NULL*/

Py_ssize_t

PyNumber_AsSsize_t(PyObject *item, PyObject *err)

{

Py_ssize_t result;

PyObject *runerr;

PyObject *value = PyNumber_Index(item);

if (value == NULL)

return -1;

/* We're done if PyInt_AsSsize_t() returns without error. */

result = PyInt_AsSsize_t(value);

if (result != -1 || !(runerr = PyErr_Occurred()))

goto finish;

/* Error handling code -- only manage OverflowError differently */

if (!PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError))

goto finish;

PyErr_Clear();

/* If no error-handling desired then the default clipping

is sufficient.

*/

if (!err) {

assert(PyLong_Check(value));

/* Whether or not it is less than or equal to

zero is determined by the sign of ob_size

*/

if (_PyLong_Sign(value) < 0)

result = PY_SSIZE_T_MIN;

else

result = PY_SSIZE_T_MAX;

}

else {

/* Otherwise replace the error with caller's error object. */

PyErr_Format(err,

"cannot fit '%.200s' into an index-sized integer",

item->ob_type->tp_name);

}

finish:

Py_DECREF(value);

return result;

}

PyObject *

PyNumber_Int(PyObject *o)

{

PyNumberMethods *m;

const char *buffer;

Py_ssize_t buffer_len;

if (o == NULL)

return null_error();

if (PyInt_CheckExact(o)) {

Py_INCREF(o);

return o;

}

m = o->ob_type->tp_as_number;

if (m && m->nb_int) { /* This should include subclasses of int */

PyObject *res = m->nb_int(o);

if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {

PyErr_Format(PyExc_TypeError,

"__int__ returned non-int (type %.200s)",

res->ob_type->tp_name);

Py_DECREF(res);

return NULL;

}

return res;

}

if (PyInt_Check(o)) { /* A int subclass without nb_int */

PyIntObject *io = (PyIntObject*)o;

return PyInt_FromLong(io->ob_ival);

}

if (PyString_Check(o))

return int_from_string(PyString_AS_STRING(o),

PyString_GET_SIZE(o));

#ifdef Py_USING_UNICODE

if (PyUnicode_Check(o))

return PyInt_FromUnicode(PyUnicode_AS_UNICODE(o),

PyUnicode_GET_SIZE(o),

10);

#endif

if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))

return int_from_string((char*)buffer, buffer_len);

return type_error("int() argument must be a string or a "

"number, not '%.200s'", o);

}

/* Add a check for embedded NULL-bytes in the argument. */

static PyObject *

long_from_string(const char *s, Py_ssize_t len)

{

char *end;

PyObject *x;

x = PyLong_FromString((char*)s, &end, 10);

if (x == NULL)

return NULL;

if (end != s + len) {

PyErr_SetString(PyExc_ValueError,

"null byte in argument for long()");

Py_DECREF(x);

return NULL;

}

return x;

}

PyObject *

PyNumber_Long(PyObject *o)

{

PyNumberMethods *m;

const char *buffer;

Py_ssize_t buffer_len;

if (o == NULL)

return null_error();

m = o->ob_type->tp_as_number;

if (m && m->nb_long) { /* This should include subclasses of long */

PyObject *res = m->nb_long(o);

if (res && (!PyInt_Check(res) && !PyLong_Check(res))) {

PyErr_Format(PyExc_TypeError,

"__long__ returned non-long (type %.200s)",

res->ob_type->tp_name);

Py_DECREF(res);

return NULL;

}

return res;

}

if (PyLong_Check(o)) /* A long subclass without nb_long */

return _PyLong_Copy((PyLongObject *)o);

if (PyString_Check(o))

/* need to do extra error checking that PyLong_FromString()

* doesn't do. In particular long('9.5') must raise an

* exception, not truncate the float.

*/

return long_from_string(PyString_AS_STRING(o),

PyString_GET_SIZE(o));

#ifdef Py_USING_UNICODE

if (PyUnicode_Check(o))

/* The above check is done in PyLong_FromUnicode(). */

return PyLong_FromUnicode(PyUnicode_AS_UNICODE(o),

PyUnicode_GET_SIZE(o),

10);

#endif

if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))

return long_from_string(buffer, buffer_len);

return type_error("long() argument must be a string or a "

"number, not '%.200s'", o);

}