/* 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 */

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

/* The length hint function returns a non-negative value from o.__len__()

or o.__length_hint__(). If those methods aren't found or return a negative

value, then the defaultvalue is returned. This function never fails.

Accordingly, it will mask exceptions raised in either method.

*/

Py_ssize_t

_PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)

{

static PyObject *hintstrobj = NULL;

PyObject *ro;

Py_ssize_t rv;

/* try o.__len__() */

rv = PyObject_Size(o);

if (rv >= 0)

return rv;

if (PyErr_Occurred())

PyErr_Clear();

/* cache a hashed version of the attribute string */

if (hintstrobj == NULL) {

hintstrobj = PyUnicode_InternFromString("__length_hint__");

if (hintstrobj == NULL)

goto defaultcase;

}

/* try o.__length_hint__() */

ro = PyObject_CallMethodObjArgs(o, hintstrobj, NULL);

if (ro == NULL)

goto defaultcase;

rv = PyLong_AsSsize_t(ro);

Py_DECREF(ro);

if (rv >= 0)

return rv;

defaultcase:

if (PyErr_Occurred())

PyErr_Clear();

return defaultvalue;

}

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 = PyUnicode_FromString(key);

if (okey == NULL)

return -1;

ret = PyObject_DelItem(o, okey);

Py_DECREF(okey);

return ret;

}

/* We release the buffer right after use of this function which could

cause issues later on. Don't use these functions in new code.

*/

int

PyObject_AsCharBuffer(PyObject *obj,

const char **buffer,

Py_ssize_t *buffer_len)

{

PyBufferProcs *pb;

Py_buffer view;

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

null_error();

return -1;

}

pb = obj->ob_type->tp_as_buffer;

if (pb == NULL || pb->bf_getbuffer == NULL) {

PyErr_SetString(PyExc_TypeError,

"expected an object with the buffer interface");

return -1;

}

if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE)) return -1;

*buffer = view.buf;

*buffer_len = view.len;

if (pb->bf_releasebuffer != NULL)

(*pb->bf_releasebuffer)(obj, &view);

Py_XDECREF(view.obj);

return 0;

}

int

PyObject_CheckReadBuffer(PyObject *obj)

{

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

Py_buffer view;

if (pb == NULL ||

pb->bf_getbuffer == NULL)

return 0;

if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE) == -1) {

PyErr_Clear();

return 0;

}

PyBuffer_Release(&view);

return 1;

}

int PyObject_AsReadBuffer(PyObject *obj,

const void **buffer,

Py_ssize_t *buffer_len)

{

PyBufferProcs *pb;

Py_buffer view;

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

null_error();

return -1;

}

pb = obj->ob_type->tp_as_buffer;

if (pb == NULL ||

pb->bf_getbuffer == NULL) {

PyErr_SetString(PyExc_TypeError,

"expected an object with a buffer interface");

return -1;

}

if ((*pb->bf_getbuffer)(obj, &view, PyBUF_SIMPLE)) return -1;

*buffer = view.buf;

*buffer_len = view.len;

if (pb->bf_releasebuffer != NULL)

(*pb->bf_releasebuffer)(obj, &view);

Py_XDECREF(view.obj);

return 0;

}

int PyObject_AsWriteBuffer(PyObject *obj,

void **buffer,

Py_ssize_t *buffer_len)

{

PyBufferProcs *pb;

Py_buffer view;

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

null_error();

return -1;

}

pb = obj->ob_type->tp_as_buffer;

if (pb == NULL ||

pb->bf_getbuffer == NULL ||

((*pb->bf_getbuffer)(obj, &view, PyBUF_WRITABLE) != 0)) {

PyErr_SetString(PyExc_TypeError,

"expected an object with a writable buffer interface");

return -1;

}

*buffer = view.buf;

*buffer_len = view.len;

if (pb->bf_releasebuffer != NULL)

(*pb->bf_releasebuffer)(obj, &view);

Py_XDECREF(view.obj);

return 0;

}

/* Buffer C-API for Python 3.0 */

int

PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)

{

if (!PyObject_CheckBuffer(obj)) {

PyErr_Format(PyExc_TypeError,

"'%100s' does not have the buffer interface",

Py_TYPE(obj)->tp_name);

return -1;

}

return (*(obj->ob_type->tp_as_buffer->bf_getbuffer))(obj, view, flags);

}

static int

_IsFortranContiguous(Py_buffer *view)

{

Py_ssize_t sd, dim;

int i;

if (view->ndim == 0) return 1;

if (view->strides == NULL) return (view->ndim == 1);

sd = view->itemsize;

if (view->ndim == 1) return (view->shape[0] == 1 ||

sd == view->strides[0]);

for (i=0; i<view->ndim; i++) {

dim = view->shape[i];

if (dim == 0) return 1;

if (view->strides[i] != sd) return 0;

sd *= dim;

}

return 1;

}

static int

_IsCContiguous(Py_buffer *view)

{

Py_ssize_t sd, dim;

int i;

if (view->ndim == 0) return 1;

if (view->strides == NULL) return 1;

sd = view->itemsize;

if (view->ndim == 1) return (view->shape[0] == 1 ||

sd == view->strides[0]);

for (i=view->ndim-1; i>=0; i--) {

dim = view->shape[i];

if (dim == 0) return 1;

if (view->strides[i] != sd) return 0;

sd *= dim;

}

return 1;

}

int

PyBuffer_IsContiguous(Py_buffer *view, char fort)

{

if (view->suboffsets != NULL) return 0;

if (fort == 'C')

return _IsCContiguous(view);

else if (fort == 'F')

return _IsFortranContiguous(view);

else if (fort == 'A')

return (_IsCContiguous(view) || _IsFortranContiguous(view));

return 0;

}

void*

PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)

{

char* pointer;

int i;

pointer = (char *)view->buf;

for (i = 0; i < view->ndim; i++) {

pointer += view->strides[i]*indices[i];

if ((view->suboffsets != NULL) && (view->suboffsets[i] >= 0)) {

pointer = *((char**)pointer) + view->suboffsets[i];

}

}

return (void*)pointer;

}

void

_add_one_to_index_F(int nd, Py_ssize_t *index, Py_ssize_t *shape)

{

int k;

for (k=0; k<nd; k++) {

if (index[k] < shape[k]-1) {

index[k]++;

break;

}

else {

index[k] = 0;

}

}

}

void

_add_one_to_index_C(int nd, Py_ssize_t *index, Py_ssize_t *shape)

{

int k;

for (k=nd-1; k>=0; k--) {

if (index[k] < shape[k]-1) {

index[k]++;

break;

}

else {

index[k] = 0;

}

}

}

/* view is not checked for consistency in either of these. It is

assumed that the size of the buffer is view->len in

view->len / view->itemsize elements.

*/

int

PyBuffer_ToContiguous(void *buf, Py_buffer *view, Py_ssize_t len, char fort)

{

int k;

void (*addone)(int, Py_ssize_t *, Py_ssize_t *);

Py_ssize_t *indices, elements;

char *dest, *ptr;

if (len > view->len) {

len = view->len;

}

if (PyBuffer_IsContiguous(view, fort)) {

/* simplest copy is all that is needed */

memcpy(buf, view->buf, len);

return 0;

}

/* Otherwise a more elaborate scheme is needed */

/* XXX(nnorwitz): need to check for overflow! */

indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));

if (indices == NULL) {

PyErr_NoMemory();

return -1;

}

for (k=0; k<view->ndim;k++) {

indices[k] = 0;

}

if (fort == 'F') {

addone = _add_one_to_index_F;

}

else {

addone = _add_one_to_index_C;

}

dest = buf;

/* XXX : This is not going to be the fastest code in the world

several optimizations are possible.

*/

elements = len / view->itemsize;

while (elements--) {

addone(view->ndim, indices, view->shape);

ptr = PyBuffer_GetPointer(view, indices);

memcpy(dest, ptr, view->itemsize);

dest += view->itemsize;

}

PyMem_Free(indices);

return 0;

}

int

PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)

{

int k;

void (*addone)(int, Py_ssize_t *, Py_ssize_t *);

Py_ssize_t *indices, elements;

char *src, *ptr;

if (len > view->len) {

len = view->len;

}

if (PyBuffer_IsContiguous(view, fort)) {

/* simplest copy is all that is needed */

memcpy(view->buf, buf, len);

return 0;

}

/* Otherwise a more elaborate scheme is needed */

/* XXX(nnorwitz): need to check for overflow! */

indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*(view->ndim));

if (indices == NULL) {

PyErr_NoMemory();

return -1;

}

for (k=0; k<view->ndim;k++) {

indices[k] = 0;

}

if (fort == 'F') {

addone = _add_one_to_index_F;

}

else {

addone = _add_one_to_index_C;

}

src = buf;

/* XXX : This is not going to be the fastest code in the world

several optimizations are possible.

*/

elements = len / view->itemsize;

while (elements--) {

addone(view->ndim, indices, view->shape);

ptr = PyBuffer_GetPointer(view, indices);

memcpy(ptr, src, view->itemsize);

src += view->itemsize;

}

PyMem_Free(indices);

return 0;

}

int PyObject_CopyData(PyObject *dest, PyObject *src)

{

Py_buffer view_dest, view_src;

int k;

Py_ssize_t *indices, elements;

char *dptr, *sptr;

if (!PyObject_CheckBuffer(dest) ||

!PyObject_CheckBuffer(src)) {

PyErr_SetString(PyExc_TypeError,

"both destination and source must have the "\

"buffer interface");

return -1;

}

if (PyObject_GetBuffer(dest, &view_dest, PyBUF_FULL) != 0) return -1;

if (PyObject_GetBuffer(src, &view_src, PyBUF_FULL_RO) != 0) {

PyBuffer_Release(&view_dest);

return -1;

}

if (view_dest.len < view_src.len) {

PyErr_SetString(PyExc_BufferError,

"destination is too small to receive data from source");

PyBuffer_Release(&view_dest);

PyBuffer_Release(&view_src);

return -1;

}

if ((PyBuffer_IsContiguous(&view_dest, 'C') &&

PyBuffer_IsContiguous(&view_src, 'C')) ||

(PyBuffer_IsContiguous(&view_dest, 'F') &&

PyBuffer_IsContiguous(&view_src, 'F'))) {

/* simplest copy is all that is needed */

memcpy(view_dest.buf, view_src.buf, view_src.len);

PyBuffer_Release(&view_dest);

PyBuffer_Release(&view_src);

return 0;

}

/* Otherwise a more elaborate copy scheme is needed */

/* XXX(nnorwitz): need to check for overflow! */

indices = (Py_ssize_t *)PyMem_Malloc(sizeof(Py_ssize_t)*view_src.ndim);

if (indices == NULL) {

PyErr_NoMemory();

PyBuffer_Release(&view_dest);

PyBuffer_Release(&view_src);

return -1;

}

for (k=0; k<view_src.ndim;k++) {

indices[k] = 0;

}

elements = 1;

for (k=0; k<view_src.ndim; k++) {

/* XXX(nnorwitz): can this overflow? */

elements *= view_src.shape[k];

}

while (elements--) {

_add_one_to_index_C(view_src.ndim, indices, view_src.shape);

dptr = PyBuffer_GetPointer(&view_dest, indices);

sptr = PyBuffer_GetPointer(&view_src, indices);

memcpy(dptr, sptr, view_src.itemsize);

}

PyMem_Free(indices);

PyBuffer_Release(&view_dest);

PyBuffer_Release(&view_src);

return 0;

}

void

PyBuffer_FillContiguousStrides(int nd, Py_ssize_t *shape,

Py_ssize_t *strides, int itemsize,

char fort)

{

int k;

Py_ssize_t sd;

sd = itemsize;

if (fort == 'F') {

for (k=0; k<nd; k++) {

strides[k] = sd;

sd *= shape[k];

}

}

else {

for (k=nd-1; k>=0; k--) {

strides[k] = sd;

sd *= shape[k];

}

}

return;

}

int

PyBuffer_FillInfo(Py_buffer *view, PyObject *obj, void *buf, Py_ssize_t len,

int readonly, int flags)

{

if (view == NULL) return 0;

if (((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE) &&

(readonly == 1)) {

PyErr_SetString(PyExc_BufferError,

"Object is not writable.");

return -1;

}

view->obj = obj;

if (obj)

Py_INCREF(obj);

view->buf = buf;

view->len = len;

view->readonly = readonly;

view->itemsize = 1;

view->format = NULL;

if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)

view->format = "B";

view->ndim = 1;

view->shape = NULL;

if ((flags & PyBUF_ND) == PyBUF_ND)

view->shape = &(view->len);

view->strides = NULL;

if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES)

view->strides = &(view->itemsize);

view->suboffsets = NULL;

view->internal = NULL;

return 0;

}

void

PyBuffer_Release(Py_buffer *view)

{

PyObject *obj = view->obj;

if (obj && Py_TYPE(obj)->tp_as_buffer && Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer)

Py_TYPE(obj)->tp_as_buffer->bf_releasebuffer(obj, view);

Py_XDECREF(obj);

view->obj = NULL;

}

PyObject *

PyObject_Format(PyObject *obj, PyObject *format_spec)

{

static PyObject * str__format__ = NULL;

PyObject *meth;

PyObject *empty = NULL;

PyObject *result = NULL;

/* Initialize cached value */

if (str__format__ == NULL) {

/* Initialize static variable needed by _PyType_Lookup */

str__format__ = PyUnicode_FromString("__format__");

if (str__format__ == NULL)

goto done;

}

/* If no format_spec is provided, use an empty string */

if (format_spec == NULL) {

empty = PyUnicode_FromUnicode(NULL, 0);

format_spec = empty;

}

/* Make sure the type is initialized. float gets initialized late */

if (Py_TYPE(obj)->tp_dict == NULL)

if (PyType_Ready(Py_TYPE(obj)) < 0)

goto done;

/* Find the (unbound!) __format__ method (a borrowed reference) */

meth = _PyType_Lookup(Py_TYPE(obj), str__format__);

if (meth == NULL) {

PyErr_Format(PyExc_TypeError,

"Type %.100s doesn't define __format__",

Py_TYPE(obj)->tp_name);

goto done;

}

/* And call it, binding it to the value */

result = PyObject_CallFunctionObjArgs(meth, obj, format_spec, NULL);

if (result && !PyUnicode_Check(result)) {

PyErr_SetString(PyExc_TypeError,

"__format__ method did not return string");

Py_DECREF(result);

result = NULL;

goto done;

}

done:

Py_XDECREF(empty);

return result;

}

/* 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)

{

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

}

PyObject *

PyNumber_TrueDivide(PyObject *v, PyObject *w)

{

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 */