#include "Python.h"

#include <ctype.h>

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

#include "longintrepr.h"

#define NEW_STYLE_NUMBER(o) PyType_HasFeature((o)->ob_type, \

Py_TPFLAGS_CHECKTYPES)

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;

}

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;

}

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

PyObject_Length(PyObject *o)

{

return PyObject_Size(o);

}

#define PyObject_Length PyObject_Size

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

if (!PyErr_ExceptionMatches(PyExc_TypeError) &&

!PyErr_ExceptionMatches(PyExc_AttributeError))

return -1;

PyErr_Clear();

}

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

if (hintstrobj == NULL) {

hintstrobj = PyString_InternFromString("__length_hint__");

if (hintstrobj == NULL)

return -1;

}

/* try o.__length_hint__() */

ro = PyObject_CallMethodObjArgs(o, hintstrobj, NULL);

if (ro == NULL) {

if (!PyErr_ExceptionMatches(PyExc_TypeError) &&

!PyErr_ExceptionMatches(PyExc_AttributeError))

return -1;

PyErr_Clear();

return defaultvalue;

}

rv = PyLong_Check(ro) ? PyLong_AsSsize_t(ro) : defaultvalue;

Py_DECREF(ro);

return rv;

}

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

}

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;

}

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;

}

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;

}

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;

}

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;

}

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;

}

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;

}

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;

}

static 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;

}

}

}

static 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

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

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;

}

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

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;

}

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;

}

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;

}

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 *empty = NULL;

PyObject *result = NULL;

#ifdef Py_USING_UNICODE

int spec_is_unicode;

int result_is_unicode;

/* Initialize cached value */

if (str__format__ == NULL) {

/* Initialize static variable needed by _PyType_Lookup */

str__format__ = PyString_InternFromString("__format__");

if (str__format__ == NULL)

goto done;

}

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

if (format_spec == NULL) {

empty = PyString_FromStringAndSize(NULL, 0);

format_spec = empty;

}

/* Check the format_spec type, and make sure it's str or unicode */

#ifdef Py_USING_UNICODE

if (PyUnicode_Check(format_spec))

spec_is_unicode = 1;

else if (PyString_Check(format_spec))

spec_is_unicode = 0;

else {

if (!PyString_Check(format_spec)) {

PyErr_Format(PyExc_TypeError,

"format expects arg 2 to be string "

"or unicode, not %.100s", Py_TYPE(format_spec)->tp_name);

goto done;

}

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

/* Check for a __format__ method and call it. */

if (PyInstance_Check(obj)) {

/* We're an instance of a classic class */

PyObject *bound_method = PyObject_GetAttr(obj,

str__format__);

if (bound_method != NULL) {

result = PyObject_CallFunctionObjArgs(bound_method,

format_spec,

NULL);

Py_DECREF(bound_method);

} else {

PyObject *self_as_str;

PyObject *format_method;

PyErr_Clear();

/* Per the PEP, convert to str (or unicode,

#ifdef Py_USING_UNICODE

if (spec_is_unicode)

self_as_str = PyObject_Unicode(obj);

else

self_as_str = PyObject_Str(obj);

if (self_as_str == NULL)

goto done;

/* Then call str.__format__ on that result */

format_method = PyObject_GetAttr(self_as_str,

str__format__);

if (format_method == NULL) {

Py_DECREF(self_as_str);

goto done;

}

result = PyObject_CallFunctionObjArgs(format_method,

format_spec,

NULL);

Py_DECREF(self_as_str);

Py_DECREF(format_method);

if (result == NULL)

goto done;

}

} else {

/* Not an instance of a classic class, use the code

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

PyObject *method = _PyType_Lookup(Py_TYPE(obj),

str__format__);

if (method == 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(method, obj,

format_spec, NULL);

}

if (result == NULL)

goto done;

/* Check the result type, and make sure it's str or unicode */

#ifdef Py_USING_UNICODE

if (PyUnicode_Check(result))

result_is_unicode = 1;

else if (PyString_Check(result))

result_is_unicode = 0;

else {

if (!PyString_Check(result)) {

PyErr_Format(PyExc_TypeError,

"%.100s.__format__ must return string or "

"unicode, not %.100s", Py_TYPE(obj)->tp_name,

Py_TYPE(result)->tp_name);

Py_DECREF(result);

result = NULL;

goto done;

}

/* Convert to unicode, if needed. Required if spec is unicode

#ifdef Py_USING_UNICODE

if (spec_is_unicode && !result_is_unicode) {

PyObject *tmp = PyObject_Unicode(result);

/* This logic works whether or not tmp is NULL */

Py_DECREF(result);

result = tmp;

}

done:

Py_XDECREF(empty);

return result;

}

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

}

#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]))

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 && NEW_STYLE_NUMBER(v))

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 && NEW_STYLE_NUMBER(w)) {

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

}

if (!NEW_STYLE_NUMBER(v) || !NEW_STYLE_NUMBER(w)) {

int err = PyNumber_CoerceEx(&v, &w);

if (err < 0) {

return NULL;

}

if (err == 0) {

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

if (mv) {

binaryfunc slot;

slot = NB_BINOP(mv, op_slot);

if (slot) {

x = slot(v, w);

Py_DECREF(v);

Py_DECREF(w);

return x;

}

}

/* CoerceEx incremented the reference counts */

Py_DECREF(v);

Py_DECREF(w);

}

}

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;

}