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

#include "Python.h"

#include <ctype.h>

/* Shorthands to return certain errors */

static PyObject *

type_error(const char *msg)

{

PyErr_SetString(PyExc_TypeError, msg);

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;

}

int

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

int

PyObject_Length(PyObject *o)

{

return PyObject_Size(o);

}

#define PyObject_Length PyObject_Size

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 (PyInt_Check(key))

return PySequence_GetItem(o, PyInt_AsLong(key));

else if (PyLong_Check(key)) {

long key_value = PyLong_AsLong(key);

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

return NULL;

return PySequence_GetItem(o, key_value);

}

return type_error("sequence index must be integer");

}

return type_error("unsubscriptable object");

}

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 (PyInt_Check(key))

return PySequence_SetItem(o, PyInt_AsLong(key), value);

else if (PyLong_Check(key)) {

long key_value = PyLong_AsLong(key);

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

return -1;

return PySequence_SetItem(o, key_value, value);

}

type_error("sequence index must be integer");

return -1;

}

type_error("object does not support item assignment");

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 (PyInt_Check(key))

return PySequence_DelItem(o, PyInt_AsLong(key));

else if (PyLong_Check(key)) {

long key_value = PyLong_AsLong(key);

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

return -1;

return PySequence_DelItem(o, key_value);

}

type_error("sequence index must be integer");

return -1;

}

type_error("object does not support item deletion");

return -1;

}

int PyObject_AsCharBuffer(PyObject *obj,

const char **buffer,

int *buffer_len)

{

PyBufferProcs *pb;

const char *pp;

int 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");

goto onError;

}

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

PyErr_SetString(PyExc_TypeError,

"expected a single-segment buffer object");

goto onError;

}

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

if (len < 0)

goto onError;

*buffer = pp;

*buffer_len = len;

return 0;

onError:

return -1;

}

int PyObject_AsReadBuffer(PyObject *obj,

const void **buffer,

int *buffer_len)

{

PyBufferProcs *pb;

void *pp;

int 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");

goto onError;

}

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

PyErr_SetString(PyExc_TypeError,

"expected a single-segment buffer object");

goto onError;

}

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

if (len < 0)

goto onError;

*buffer = pp;

*buffer_len = len;

return 0;

onError:

return -1;

}

int PyObject_AsWriteBuffer(PyObject *obj,

void **buffer,

int *buffer_len)

{

PyBufferProcs *pb;

void*pp;

int 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");

goto onError;

}

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

PyErr_SetString(PyExc_TypeError,

"expected a single-segment buffer object");

goto onError;

}

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

if (len < 0)

goto onError;

*buffer = pp;

*buffer_len = len;

return 0;

onError:

return -1;

}

/* Operations on numbers */

int

PyNumber_Check(PyObject *o)

{

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

}

/* Binary operators */

#define BINOP(v, w, opname, ropname, thisfunc) \

if (PyInstance_Check(v) || PyInstance_Check(w)) \

return PyInstance_DoBinOp(v, w, opname, ropname, thisfunc)

PyObject *

PyNumber_Or(PyObject *v, PyObject *w)

{

BINOP(v, w, "__or__", "__ror__", PyNumber_Or);

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_or) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for |");

}

PyObject *

PyNumber_Xor(PyObject *v, PyObject *w)

{

BINOP(v, w, "__xor__", "__rxor__", PyNumber_Xor);

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_xor) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for ^");

}

PyObject *

PyNumber_And(PyObject *v, PyObject *w)

{

BINOP(v, w, "__and__", "__rand__", PyNumber_And);

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_and) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for &");

}

PyObject *

PyNumber_Lshift(PyObject *v, PyObject *w)

{

BINOP(v, w, "__lshift__", "__rlshift__", PyNumber_Lshift);

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_lshift) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for <<");

}

PyObject *

PyNumber_Rshift(PyObject *v, PyObject *w)

{

BINOP(v, w, "__rshift__", "__rrshift__", PyNumber_Rshift);

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_rshift) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for >>");

}

PyObject *

PyNumber_Add(PyObject *v, PyObject *w)

{

PySequenceMethods *m;

BINOP(v, w, "__add__", "__radd__", PyNumber_Add);

m = v->ob_type->tp_as_sequence;

if (m && m->sq_concat)

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

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_add) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for +");

}

PyObject *

PyNumber_Subtract(PyObject *v, PyObject *w)

{

BINOP(v, w, "__sub__", "__rsub__", PyNumber_Subtract);

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_subtract) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for -");

}

PyObject *

PyNumber_Multiply(PyObject *v, PyObject *w)

{

PyTypeObject *tp = v->ob_type;

PySequenceMethods *m;

BINOP(v, w, "__mul__", "__rmul__", PyNumber_Multiply);

if (tp->tp_as_number != NULL &&

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

/* number*sequence -- swap v and w */

PyObject *tmp = v;

v = w;

w = tmp;

tp = v->ob_type;

}

if (tp->tp_as_number != NULL) {

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_multiply) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

m = tp->tp_as_sequence;

if (m && m->sq_repeat) {

long mul_value;

if (PyInt_Check(w)) {

mul_value = PyInt_AsLong(w);

}

else if (PyLong_Check(w)) {

mul_value = PyLong_AsLong(w);

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

return NULL;

}

else {

return type_error(

"can't multiply sequence with non-int");

}

return (*m->sq_repeat)(v, (int)mul_value);

}

return type_error("bad operand type(s) for *");

}

PyObject *

PyNumber_Divide(PyObject *v, PyObject *w)

{

BINOP(v, w, "__div__", "__rdiv__", PyNumber_Divide);

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_divide) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for /");

}

PyObject *

PyNumber_Remainder(PyObject *v, PyObject *w)

{

if (PyString_Check(v))

return PyString_Format(v, w);

else if (PyUnicode_Check(v))

return PyUnicode_Format(v, w);

BINOP(v, w, "__mod__", "__rmod__", PyNumber_Remainder);

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_remainder) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for %");

}

PyObject *

PyNumber_Divmod(PyObject *v, PyObject *w)

{

BINOP(v, w, "__divmod__", "__rdivmod__", PyNumber_Divmod);

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

PyObject *x = NULL;

PyObject * (*f)(PyObject *, PyObject *) = NULL;

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_divmod) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for divmod()");

}

/* Power (binary or ternary) */

static PyObject *

do_pow(PyObject *v, PyObject *w)

{

PyObject *res;

PyObject * (*f)(PyObject *, PyObject *, PyObject *);

BINOP(v, w, "__pow__", "__rpow__", do_pow);

if (v->ob_type->tp_as_number == NULL ||

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

PyErr_SetString(PyExc_TypeError,

"pow(x, y) requires numeric arguments");

return NULL;

}

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_power) != NULL)

res = (*f)(v, w, Py_None);

else

res = type_error("pow(x, y) not defined for these operands");

Py_DECREF(v);

Py_DECREF(w);

return res;

}

PyObject *

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

{

PyObject *res;

PyObject *v1, *z1, *w2, *z2;

PyObject * (*f)(PyObject *, PyObject *, PyObject *);

if (z == Py_None)

return do_pow(v, w);

/* XXX The ternary version doesn't do class instance coercions */

if (PyInstance_Check(v))

return v->ob_type->tp_as_number->nb_power(v, w, z);

if (v->ob_type->tp_as_number == NULL ||

z->ob_type->tp_as_number == NULL ||

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

return type_error("pow(x, y, z) requires numeric arguments");

}

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

res = NULL;

v1 = v;

z1 = z;

if (PyNumber_Coerce(&v1, &z1) != 0)

goto error2;

w2 = w;

z2 = z1;

if (PyNumber_Coerce(&w2, &z2) != 0)

goto error1;

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

(f = v1->ob_type->tp_as_number->nb_power) != NULL)

res = (*f)(v1, w2, z2);

else

res = type_error(

"pow(x, y, z) not defined for these operands");

Py_DECREF(w2);

Py_DECREF(z2);

error1:

Py_DECREF(v1);

Py_DECREF(z1);

error2:

Py_DECREF(v);

Py_DECREF(w);

return res;

}

/* 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, and to

take class instances into account. This is how it is supposed to work:

- If the left-hand-side object (the first argument) is an

instance object, try to let PyInstance_HalfBinOp() handle it. Pass the

non in-place variant of the function as callback, because it will only

be used if the left-hand object is changed by coercion.

- Otherwise, if the left hand object is not an instance object, it 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:

- If either object is an instance, let PyInstance_DoBinOp() handle it.

- Otherwise, both arguments are C types. If the left-hand object has

the appropriate struct members filled, coerce, call the

appropriate function, and return the result.

- Otherwise, we are out of options: raise a type error specific to

augmented assignment.

*/

#define HASINPLACE(t) PyType_HasFeature((t)->ob_type, Py_TPFLAGS_HAVE_INPLACEOPS)

PyObject *

PyNumber_InPlaceOr(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__ior__", &x,

PyNumber_Or, 0) <= 0)

return x;

}

else if (v->ob_type->tp_as_number != NULL && HASINPLACE(v) &&

(f = v->ob_type->tp_as_number->nb_inplace_or) != NULL)

return (*f)(v, w);

BINOP(v, w, "__or__", "__ror__", PyNumber_Or);

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

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_or) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for |=");

}

PyObject *

PyNumber_InPlaceXor(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__ixor__", &x,

PyNumber_Xor, 0) <= 0)

return x;

}

else if (v->ob_type->tp_as_number != NULL && HASINPLACE(v) &&

(f = v->ob_type->tp_as_number->nb_inplace_xor) != NULL)

return (*f)(v, w);

BINOP(v, w, "__xor__", "__rxor__", PyNumber_Xor);

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

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_xor) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for ^=");

}

PyObject *

PyNumber_InPlaceAnd(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__iand__", &x,

PyNumber_And, 0) <= 0)

return x;

}

else if (v->ob_type->tp_as_number != NULL && HASINPLACE(v) &&

(f = v->ob_type->tp_as_number->nb_inplace_and) != NULL)

return (*f)(v, w);

BINOP(v, w, "__and__", "__rand__", PyNumber_And);

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

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_and) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for &=");

}

PyObject *

PyNumber_InPlaceLshift(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__ilshift__", &x,

PyNumber_Lshift, 0) <= 0)

return x;

}

else if (v->ob_type->tp_as_number != NULL && HASINPLACE(v) &&

(f = v->ob_type->tp_as_number->nb_inplace_lshift) != NULL)

return (*f)(v, w);

BINOP(v, w, "__lshift__", "__rlshift__", PyNumber_Lshift);

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

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_lshift) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for <<=");

}

PyObject *

PyNumber_InPlaceRshift(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__irshift__", &x,

PyNumber_Rshift, 0) <= 0)

return x;

}

else if (v->ob_type->tp_as_number != NULL && HASINPLACE(v) &&

(f = v->ob_type->tp_as_number->nb_inplace_rshift) != NULL)

return (*f)(v, w);

BINOP(v, w, "__rshift__", "__rrshift__", PyNumber_Rshift);

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

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_rshift) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for >>=");

}

PyObject *

PyNumber_InPlaceAdd(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__iadd__", &x,

PyNumber_Add, 0) <= 0)

return x;

}

else if (HASINPLACE(v)) {

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

f = v->ob_type->tp_as_sequence->sq_inplace_concat;

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

f = v->ob_type->tp_as_number->nb_inplace_add;

if (f != NULL)

return (*f)(v, w);

}

BINOP(v, w, "__add__", "__radd__", PyNumber_Add);

if (v->ob_type->tp_as_sequence != NULL) {

f = v->ob_type->tp_as_sequence->sq_concat;

if (f != NULL)

return (*f)(v, w);

}

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

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

f = v->ob_type->tp_as_number->nb_add;

if (f != NULL)

x = (*f)(v, w);

}

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for +=");

}

PyObject *

PyNumber_InPlaceSubtract(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__isub__", &x,

PyNumber_Subtract, 0) <= 0)

return x;

}

else if (v->ob_type->tp_as_number != NULL && HASINPLACE(v) &&

(f = v->ob_type->tp_as_number->nb_inplace_subtract) != NULL)

return (*f)(v, w);

BINOP(v, w, "__sub__", "__rsub__", PyNumber_Subtract);

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

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_subtract) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for -=");

}

PyObject *

PyNumber_InPlaceMultiply(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject * (*g)(PyObject *, int) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__imul__", &x,

PyNumber_Multiply, 0) <= 0)

return x;

}

else if (v->ob_type->tp_as_number != NULL && HASINPLACE(v) &&

(f = v->ob_type->tp_as_number->nb_inplace_multiply) != NULL)

return (*f)(v, w);

else if (v->ob_type->tp_as_sequence != NULL && HASINPLACE(v) &&

(g = v->ob_type->tp_as_sequence->sq_inplace_repeat) != NULL) {

long mul_value;

if (PyInt_Check(w)) {

mul_value = PyInt_AsLong(w);

}

else if (PyLong_Check(w)) {

mul_value = PyLong_AsLong(w);

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

return NULL;

}

else {

return type_error(

"can't multiply sequence with non-int");

}

return (*g)(v, (int)mul_value);

}

BINOP(v, w, "__mul__", "__rmul__", PyNumber_Multiply);

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

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_multiply) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

else if (v->ob_type->tp_as_sequence != NULL &&

(g = v->ob_type->tp_as_sequence->sq_repeat) != NULL) {

long mul_value;

if (PyInt_Check(w)) {

mul_value = PyInt_AsLong(w);

}

else if (PyLong_Check(w)) {

mul_value = PyLong_AsLong(w);

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

return NULL;

}

else {

return type_error(

"can't multiply sequence with non-int");

}

return (*g)(v, (int)mul_value);

}

return type_error("bad operand type(s) for *=");

}

PyObject *

PyNumber_InPlaceDivide(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__idiv__", &x,

PyNumber_Divide, 0) <= 0)

return x;

}

else if (v->ob_type->tp_as_number != NULL && HASINPLACE(v) &&

(f = v->ob_type->tp_as_number->nb_inplace_divide) != NULL)

return (*f)(v, w);

BINOP(v, w, "__div__", "__rdiv__", PyNumber_Divide);

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

if (PyNumber_Coerce(&v, &w) != 0)

return NULL;

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

(f = v->ob_type->tp_as_number->nb_divide) != NULL)

x = (*f)(v, w);

Py_DECREF(v);

Py_DECREF(w);

if (f != NULL)

return x;

}

return type_error("bad operand type(s) for /=");

}

PyObject *

PyNumber_InPlaceRemainder(PyObject *v, PyObject *w)

{

PyObject * (*f)(PyObject *, PyObject *) = NULL;

PyObject *x;

if (PyInstance_Check(v)) {

if (PyInstance_HalfBinOp(v, w, "__imod__", &x,

PyNumber_Remainder, 0) <= 0)

return x;

}

else if (v->ob_type->tp_as_number != NULL && HASINPLACE(v) &&

(f = v->ob_type->tp_as_number->nb_inplace_remainder) != NULL)

return (*f)(v, w);