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

#include "Python.h"

#include "pycore_abstract.h" // _PyIndex_Check()

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_ceval.h" // _Py_EnterRecursiveCallTstate()

#include "pycore_crossinterp.h" // _Py_CallInInterpreter()

#include "pycore_genobject.h" // _PyGen_FetchStopIterationValue()

#include "pycore_list.h" // _PyList_AppendTakeRef()

#include "pycore_long.h" // _PyLong_IsNegative()

#include "pycore_object.h" // _Py_CheckSlotResult()

#include "pycore_pybuffer.h" // _PyBuffer_ReleaseInInterpreterAndRawFree()

#include "pycore_pyerrors.h" // _PyErr_Occurred()

#include "pycore_pystate.h" // _PyThreadState_GET()

#include "pycore_tuple.h" // _PyTuple_FromArraySteal()

#include "pycore_unionobject.h" // _PyUnion_Check()

#include <stddef.h> // offsetof()

/* Shorthands to return certain errors */

static PyObject *

type_error(const char *msg, PyObject *obj)

{

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

return NULL;

}

static PyObject *

null_error(void)

{

PyThreadState *tstate = _PyThreadState_GET();

if (!_PyErr_Occurred(tstate)) {

_PyErr_SetString(tstate, 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 *)Py_TYPE(o);

return Py_NewRef(v);

}

Py_ssize_t

PyObject_Size(PyObject *o)

{

if (o == NULL) {

null_error();

return -1;

}

PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;

if (m && m->sq_length) {

Py_ssize_t len = m->sq_length(o);

assert(_Py_CheckSlotResult(o, "__len__", len >= 0));

return len;

}

return PyMapping_Size(o);

}

#undef PyObject_Length

Py_ssize_t

PyObject_Length(PyObject *o)

{

return PyObject_Size(o);

}

#define PyObject_Length PyObject_Size

int

_PyObject_HasLen(PyObject *o) {

return (Py_TYPE(o)->tp_as_sequence && Py_TYPE(o)->tp_as_sequence->sq_length) ||

(Py_TYPE(o)->tp_as_mapping && Py_TYPE(o)->tp_as_mapping->mp_length);

}

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

or o.__length_hint__(). If those methods aren't found the defaultvalue is

returned. If one of the calls fails with an exception other than TypeError

this function returns -1.

*/

Py_ssize_t

PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)

{

PyObject *hint, *result;

Py_ssize_t res;

if (_PyObject_HasLen(o)) {

res = PyObject_Length(o);

if (res < 0) {

PyThreadState *tstate = _PyThreadState_GET();

assert(_PyErr_Occurred(tstate));

if (!_PyErr_ExceptionMatches(tstate, PyExc_TypeError)) {

return -1;

}

_PyErr_Clear(tstate);

}

else {

return res;

}

}

hint = _PyObject_LookupSpecial(o, &_Py_ID(__length_hint__));

if (hint == NULL) {

if (PyErr_Occurred()) {

return -1;

}

return defaultvalue;

}

result = _PyObject_CallNoArgs(hint);

Py_DECREF(hint);

if (result == NULL) {

PyThreadState *tstate = _PyThreadState_GET();

if (_PyErr_ExceptionMatches(tstate, PyExc_TypeError)) {

_PyErr_Clear(tstate);

return defaultvalue;

}

return -1;

}

else if (result == Py_NotImplemented) {

Py_DECREF(result);

return defaultvalue;

}

if (!PyLong_Check(result)) {

PyErr_Format(PyExc_TypeError,

"%T.__length_hint__() must return an int, not %T",

o, result);

Py_DECREF(result);

return -1;

}

res = PyLong_AsSsize_t(result);

Py_DECREF(result);

if (res < 0 && PyErr_Occurred()) {

return -1;

}

if (res < 0) {

PyErr_Format(PyExc_ValueError,

"%T.__length_hint__() must return a non-negative int", o);

return -1;

}

return res;

}

PyObject *

PyObject_GetItem(PyObject *o, PyObject *key)

{

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

return null_error();

}

PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;

if (m && m->mp_subscript) {

PyObject *item = m->mp_subscript(o, key);

assert(_Py_CheckSlotResult(o, "__getitem__", item != NULL));

return item;

}

PySequenceMethods *ms = Py_TYPE(o)->tp_as_sequence;

if (ms && ms->sq_item) {

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 {

return type_error("sequence index must "

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

}

}

if (PyType_Check(o)) {

PyObject *meth, *result;

// Special case type[int], but disallow other types so str[int] fails

if ((PyTypeObject*)o == &PyType_Type) {

return Py_GenericAlias(o, key);

}

if (PyObject_GetOptionalAttr(o, &_Py_ID(__class_getitem__), &meth) < 0) {

return NULL;

}

if (meth && meth != Py_None) {

result = PyObject_CallOneArg(meth, key);

Py_DECREF(meth);

return result;

}

Py_XDECREF(meth);

PyErr_Format(PyExc_TypeError, "type '%.200s' is not subscriptable",

((PyTypeObject *)o)->tp_name);

return NULL;

}

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

}

int

PyMapping_GetOptionalItem(PyObject *obj, PyObject *key, PyObject **result)

{

if (PyDict_CheckExact(obj)) {

return PyDict_GetItemRef(obj, key, result);

}

*result = PyObject_GetItem(obj, key);

if (*result) {

return 1;

}

assert(PyErr_Occurred());

if (!PyErr_ExceptionMatches(PyExc_KeyError)) {

return -1;

}

PyErr_Clear();

return 0;

}

PyObject*

_PyMapping_GetOptionalItem2(PyObject *obj, PyObject *key, int *err)

{

PyObject* result;

*err = PyMapping_GetOptionalItem(obj, key, &result);

return result;

}

int

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

{

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

null_error();

return -1;

}

PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;

if (m && m->mp_ass_subscript) {

int res = m->mp_ass_subscript(o, key, value);

assert(_Py_CheckSlotResult(o, "__setitem__", res >= 0));

return res;

}

if (Py_TYPE(o)->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 (Py_TYPE(o)->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)

{

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

null_error();

return -1;

}

PyMappingMethods *m = Py_TYPE(o)->tp_as_mapping;

if (m && m->mp_ass_subscript) {

int res = m->mp_ass_subscript(o, key, (PyObject*)NULL);

assert(_Py_CheckSlotResult(o, "__delitem__", res >= 0));

return res;

}

if (Py_TYPE(o)->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 (Py_TYPE(o)->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, const 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;

}

/* Return 1 if the getbuffer function is available, otherwise return 0. */

int

PyObject_CheckBuffer(PyObject *obj)

{

PyBufferProcs *tp_as_buffer = Py_TYPE(obj)->tp_as_buffer;

return (tp_as_buffer != NULL && tp_as_buffer->bf_getbuffer != NULL);

}

// Old buffer protocols (deprecated, abi only)

/* Checks whether an arbitrary object supports the (character, single segment)

buffer interface.

Returns 1 on success, 0 on failure.

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

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

*/

PyAPI_FUNC(int) /* abi_only */

PyObject_CheckReadBuffer(PyObject *obj)

{

PyBufferProcs *pb = Py_TYPE(obj)->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;

}

static int

as_read_buffer(PyObject *obj, const void **buffer, Py_ssize_t *buffer_len)

{

Py_buffer view;

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

null_error();

return -1;

}

if (PyObject_GetBuffer(obj, &view, PyBUF_SIMPLE) != 0)

return -1;

*buffer = view.buf;

*buffer_len = view.len;

PyBuffer_Release(&view);

return 0;

}

/* Takes an arbitrary object which must support the (character, single segment)

buffer interface and returns a pointer to a read-only memory location

usable as character based input for subsequent processing.

Return 0 on success. buffer and buffer_len are only set in case no error

occurs. Otherwise, -1 is returned and an exception set. */

PyAPI_FUNC(int) /* abi_only */

PyObject_AsCharBuffer(PyObject *obj,

const char **buffer,

Py_ssize_t *buffer_len)

{

return as_read_buffer(obj, (const void **)buffer, buffer_len);

}

/* Same as PyObject_AsCharBuffer() except that this API expects (readable,

single segment) buffer interface and returns a pointer to a read-only memory

location which can contain arbitrary data.

0 is returned on success. buffer and buffer_len are only set in case no

error occurs. Otherwise, -1 is returned and an exception set. */

PyAPI_FUNC(int) /* abi_only */

PyObject_AsReadBuffer(PyObject *obj,

const void **buffer,

Py_ssize_t *buffer_len)

{

return as_read_buffer(obj, buffer, buffer_len);

}

/* Takes an arbitrary object which must support the (writable, single segment)

buffer interface and returns a pointer to a writable memory location in

buffer of size 'buffer_len'.

Return 0 on success. buffer and buffer_len are only set in case no error

occurs. Otherwise, -1 is returned and an exception set. */

PyAPI_FUNC(int) /* abi_only */

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 = Py_TYPE(obj)->tp_as_buffer;

if (pb == NULL ||

pb->bf_getbuffer == NULL ||

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

PyErr_SetString(PyExc_TypeError,

"expected a writable bytes-like object");

return -1;

}

*buffer = view.buf;

*buffer_len = view.len;

PyBuffer_Release(&view);

return 0;

}

/* Buffer C-API for Python 3.0 */

int

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

{

if (flags != PyBUF_SIMPLE) { /* fast path */

if (flags == PyBUF_READ || flags == PyBUF_WRITE) {

PyErr_BadInternalCall();

return -1;

}

}

PyBufferProcs *pb = Py_TYPE(obj)->tp_as_buffer;

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

PyErr_Format(PyExc_TypeError,

"a bytes-like object is required, not '%.100s'",

Py_TYPE(obj)->tp_name);

return -1;

}

int res = (*pb->bf_getbuffer)(obj, view, flags);

assert(_Py_CheckSlotResult(obj, "getbuffer", res >= 0));

return res;

}

static int

_IsFortranContiguous(const Py_buffer *view)

{

Py_ssize_t sd, dim;

int i;

/* 1) len = product(shape) * itemsize

2) itemsize > 0

3) len = 0 <==> exists i: shape[i] = 0 */

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

if (view->strides == NULL) { /* C-contiguous by definition */

/* Trivially F-contiguous */

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

/* ndim > 1 implies shape != NULL */

assert(view->shape != NULL);

/* Effectively 1-d */

sd = 0;

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

if (view->shape[i] > 1) sd += 1;

}

return sd <= 1;

}

/* strides != NULL implies both of these */

assert(view->ndim > 0);

assert(view->shape != NULL);

sd = view->itemsize;

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

dim = view->shape[i];

if (dim > 1 && view->strides[i] != sd) {

return 0;

}

sd *= dim;

}

return 1;

}

static int

_IsCContiguous(const Py_buffer *view)

{

Py_ssize_t sd, dim;

int i;

/* 1) len = product(shape) * itemsize

2) itemsize > 0

3) len = 0 <==> exists i: shape[i] = 0 */

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

if (view->strides == NULL) return 1; /* C-contiguous by definition */

/* strides != NULL implies both of these */

assert(view->ndim > 0);

assert(view->shape != NULL);

sd = view->itemsize;

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

dim = view->shape[i];

if (dim > 1 && view->strides[i] != sd) {

return 0;

}

sd *= dim;

}

return 1;

}

int

PyBuffer_IsContiguous(const Py_buffer *view, char order)

{

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

if (order == 'C')

return _IsCContiguous(view);

else if (order == 'F')

return _IsFortranContiguous(view);

else if (order == 'A')

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

return 0;

}

void*

PyBuffer_GetPointer(const Py_buffer *view, const 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;

}

static void

_Py_add_one_to_index_F(int nd, Py_ssize_t *index, const 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;

}

}

}

static void

_Py_add_one_to_index_C(int nd, Py_ssize_t *index, const 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;

}

}

}

Py_ssize_t

PyBuffer_SizeFromFormat(const char *format)

{

PyObject *calcsize = NULL;

PyObject *res = NULL;

PyObject *fmt = NULL;

Py_ssize_t itemsize = -1;

calcsize = PyImport_ImportModuleAttrString("struct", "calcsize");

if (calcsize == NULL) {

goto done;

}

fmt = PyUnicode_FromString(format);

if (fmt == NULL) {

goto done;

}

res = PyObject_CallFunctionObjArgs(calcsize, fmt, NULL);

if (res == NULL) {

goto done;

}

itemsize = PyLong_AsSsize_t(res);

if (itemsize < 0) {

goto done;

}

done:

Py_XDECREF(calcsize);

Py_XDECREF(fmt);

Py_XDECREF(res);

return itemsize;

}

int

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

{

int k;

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

Py_ssize_t *indices, elements;

char *ptr;

const char *src;

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

/* view->ndim <= 64 */

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 = _Py_add_one_to_index_F;

}

else {

addone = _Py_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--) {

ptr = PyBuffer_GetPointer(view, indices);

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

src += view->itemsize;

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

}

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 be "\

"bytes-like objects");

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--) {

_Py_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) {

PyErr_SetString(PyExc_BufferError,

"PyBuffer_FillInfo: view==NULL argument is obsolete");

return -1;

}

if (flags != PyBUF_SIMPLE) { /* fast path */

if (flags == PyBUF_READ || flags == PyBUF_WRITE) {

PyErr_BadInternalCall();

return -1;

}

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

(readonly == 1)) {

PyErr_SetString(PyExc_BufferError,

"Object is not writable.");

return -1;

}

}

view->obj = Py_XNewRef(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;

PyBufferProcs *pb;

if (obj == NULL)

return;

pb = Py_TYPE(obj)->tp_as_buffer;

if (pb && pb->bf_releasebuffer) {

pb->bf_releasebuffer(obj, view);

}

view->obj = NULL;

Py_DECREF(obj);

}

static int

_buffer_release_call(void *arg)

{

PyBuffer_Release((Py_buffer *)arg);

return 0;

}

int

_PyBuffer_ReleaseInInterpreter(PyInterpreterState *interp,

Py_buffer *view)

{

return _Py_CallInInterpreter(interp, _buffer_release_call, view);

}

int

_PyBuffer_ReleaseInInterpreterAndRawFree(PyInterpreterState *interp,

Py_buffer *view)

{

return _Py_CallInInterpreterAndRawFree(interp, _buffer_release_call, view);

}

PyObject *

PyObject_Format(PyObject *obj, PyObject *format_spec)

{

PyObject *meth;

PyObject *empty = NULL;

PyObject *result = NULL;

if (format_spec != NULL && !PyUnicode_Check(format_spec)) {

PyErr_Format(PyExc_SystemError,

"Format specifier must be a string, not %.200s",

Py_TYPE(format_spec)->tp_name);

return NULL;

}

/* Fast path for common types. */

if (format_spec == NULL || PyUnicode_GET_LENGTH(format_spec) == 0) {

if (PyUnicode_CheckExact(obj)) {

return Py_NewRef(obj);

}

if (PyLong_CheckExact(obj)) {

return PyObject_Str(obj);

}

}

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

if (format_spec == NULL) {

empty = Py_GetConstant(Py_CONSTANT_EMPTY_STR);

format_spec = empty;

}

/* Find the (unbound!) __format__ method */

meth = _PyObject_LookupSpecial(obj, &_Py_ID(__format__));

if (meth == NULL) {

PyThreadState *tstate = _PyThreadState_GET();

if (!_PyErr_Occurred(tstate)) {

_PyErr_Format(tstate, PyExc_TypeError,

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

Py_TYPE(obj)->tp_name);

}

goto done;

}

/* And call it. */

result = PyObject_CallOneArg(meth, format_spec);

Py_DECREF(meth);

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

PyErr_Format(PyExc_TypeError,

"%T.__format__() must return a str, not %T",

obj, result);

Py_SETREF(result, NULL);

goto done;

}

done:

Py_XDECREF(empty);

return result;

}

/* Operations on numbers */

int

PyNumber_Check(PyObject *o)

{

if (o == NULL)

return 0;

PyNumberMethods *nb = Py_TYPE(o)->tp_as_number;

return nb && (nb->nb_index || nb->nb_int || nb->nb_float || PyComplex_Check(o));

}

/* 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 Py_TYPE(v) != Py_TYPE(w) && Py_TYPE(w) is a subclass of

Py_TYPE(v)

*/

static PyObject *

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

#ifndef NDEBUG

, const char *op_name

#endif

)

{

binaryfunc slotv;

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

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

}

else {

slotv = NULL;

}

binaryfunc slotw;

if (!Py_IS_TYPE(w, Py_TYPE(v)) && Py_TYPE(w)->tp_as_number != NULL) {

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

if (slotw == slotv) {

slotw = NULL;

}

}

else {

slotw = NULL;

}

if (slotv) {

PyObject *x;

if (slotw && PyType_IsSubtype(Py_TYPE(w), Py_TYPE(v))) {

x = slotw(v, w);

if (x != Py_NotImplemented)

return x;

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

slotw = NULL;

}

x = slotv(v, w);

assert(_Py_CheckSlotResult(v, op_name, x != NULL));

if (x != Py_NotImplemented) {

return x;

}

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

}

if (slotw) {

PyObject *x = slotw(v, w);

assert(_Py_CheckSlotResult(w, op_name, x != NULL));

if (x != Py_NotImplemented) {

return x;

}

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

}

Py_RETURN_NOTIMPLEMENTED;

}

#ifdef NDEBUG

# define BINARY_OP1(v, w, op_slot, op_name) binary_op1(v, w, op_slot)

#else

# define BINARY_OP1(v, w, op_slot, op_name) binary_op1(v, w, op_slot, op_name)

#endif

static PyObject *

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

{