#define PY_SSIZE_T_CLEAN

#include "Python.h"

static PyObject *structmodule = NULL;

static PyObject *Struct = NULL;

static PyObject *calcsize = NULL;

static const char *simple_fmt = "B";

static PyObject *simple_format = NULL;

#define SIMPLE_FORMAT(fmt) (fmt == NULL || strcmp(fmt, "B") == 0)

#define FIX_FORMAT(fmt) (fmt == NULL ? "B" : fmt)

static PyTypeObject NDArray_Type;

#define NDArray_Check(v) (Py_TYPE_IS(v, &NDArray_Type))

#define CHECK_LIST_OR_TUPLE(v) \

if (!PyList_Check(v) && !PyTuple_Check(v)) { \

PyErr_SetString(PyExc_TypeError, \

#v " must be a list or a tuple"); \

return NULL; \

} \

#define PyMem_XFree(v) \

do { if (v) PyMem_Free(v); } while (0)

#define ND_MAX_NDIM (2 * PyBUF_MAX_NDIM)

#define HAVE_PTR(suboffsets) (suboffsets && suboffsets[0] >= 0)

#define ADJUST_PTR(ptr, suboffsets) \

(HAVE_PTR(suboffsets) ? *((char**)ptr) + suboffsets[0] : ptr)

#define ND_DEFAULT 0x000

#define ND_VAREXPORT 0x001 /* change layout while buffers are exported */

#define ND_WRITABLE 0x002 /* mark base buffer as writable */

#define ND_FORTRAN 0x004 /* Fortran contiguous layout */

#define ND_SCALAR 0x008 /* scalar: ndim = 0 */

#define ND_PIL 0x010 /* convert to PIL-style array (suboffsets) */

#define ND_REDIRECT 0x020 /* redirect buffer requests */

#define ND_GETBUF_FAIL 0x040 /* trigger getbuffer failure */

#define ND_GETBUF_UNDEFINED 0x080 /* undefined view.obj */

#define ND_C 0x100 /* C contiguous layout (default) */

#define ND_OWN_ARRAYS 0x200 /* consumer owns arrays */

#define ND_IS_CONSUMER(nd) \

(((NDArrayObject *)nd)->head == &((NDArrayObject *)nd)->staticbuf)

#define ND_C_CONTIGUOUS(flags) (!!(flags&(ND_SCALAR|ND_C)))

#define ND_FORTRAN_CONTIGUOUS(flags) (!!(flags&(ND_SCALAR|ND_FORTRAN)))

#define ND_ANY_CONTIGUOUS(flags) (!!(flags&(ND_SCALAR|ND_C|ND_FORTRAN)))

#define REQ_INDIRECT(flags) ((flags&PyBUF_INDIRECT) == PyBUF_INDIRECT)

#define REQ_C_CONTIGUOUS(flags) ((flags&PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS)

#define REQ_F_CONTIGUOUS(flags) ((flags&PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS)

#define REQ_ANY_CONTIGUOUS(flags) ((flags&PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS)

#define REQ_STRIDES(flags) ((flags&PyBUF_STRIDES) == PyBUF_STRIDES)

#define REQ_SHAPE(flags) ((flags&PyBUF_ND) == PyBUF_ND)

#define REQ_WRITABLE(flags) (flags&PyBUF_WRITABLE)

#define REQ_FORMAT(flags) (flags&PyBUF_FORMAT)

static PyTypeObject NDArray_Type;

struct ndbuf;

typedef struct ndbuf {

} ndbuf_t;

typedef struct {

PyObject_HEAD

int flags; /* ndarray flags */

ndbuf_t staticbuf; /* static buffer for re-exporting mode */

ndbuf_t *head; /* currently active base buffer */

} NDArrayObject;

static ndbuf_t *

ndbuf_new(Py_ssize_t nitems, Py_ssize_t itemsize, Py_ssize_t offset, int flags)

{

ndbuf_t *ndbuf;

Py_buffer *base;

Py_ssize_t len;

len = nitems * itemsize;

if (offset % itemsize) {

PyErr_SetString(PyExc_ValueError,

"offset must be a multiple of itemsize");

return NULL;

}

if (offset < 0 || offset+itemsize > len) {

PyErr_SetString(PyExc_ValueError, "offset out of bounds");

return NULL;

}

ndbuf = PyMem_Malloc(sizeof *ndbuf);

if (ndbuf == NULL) {

PyErr_NoMemory();

return NULL;

}

ndbuf->next = NULL;

ndbuf->prev = NULL;

ndbuf->len = len;

ndbuf->offset= offset;

ndbuf->data = PyMem_Malloc(len);

if (ndbuf->data == NULL) {

PyErr_NoMemory();

PyMem_Free(ndbuf);

return NULL;

}

ndbuf->flags = flags;

ndbuf->exports = 0;

base = &ndbuf->base;

base->obj = NULL;

base->buf = ndbuf->data;

base->len = len;

base->itemsize = 1;

base->readonly = 0;

base->format = NULL;

base->ndim = 1;

base->shape = NULL;

base->strides = NULL;

base->suboffsets = NULL;

base->internal = ndbuf;

return ndbuf;

}

static void

ndbuf_free(ndbuf_t *ndbuf)

{

Py_buffer *base = &ndbuf->base;

PyMem_XFree(ndbuf->data);

PyMem_XFree(base->format);

PyMem_XFree(base->shape);

PyMem_XFree(base->strides);

PyMem_XFree(base->suboffsets);

PyMem_Free(ndbuf);

}

static void

ndbuf_push(NDArrayObject *nd, ndbuf_t *elt)

{

elt->next = nd->head;

if (nd->head) nd->head->prev = elt;

nd->head = elt;

elt->prev = NULL;

}

static void

ndbuf_delete(NDArrayObject *nd, ndbuf_t *elt)

{

if (elt->prev)

elt->prev->next = elt->next;

else

nd->head = elt->next;

if (elt->next)

elt->next->prev = elt->prev;

ndbuf_free(elt);

}

static void

ndbuf_pop(NDArrayObject *nd)

{

ndbuf_delete(nd, nd->head);

}

static PyObject *

ndarray_new(PyTypeObject *type, PyObject *args, PyObject *kwds)

{

NDArrayObject *nd;

nd = PyObject_New(NDArrayObject, &NDArray_Type);

if (nd == NULL)

return NULL;

nd->flags = 0;

nd->head = NULL;

return (PyObject *)nd;

}

static void

ndarray_dealloc(NDArrayObject *self)

{

if (self->head) {

if (ND_IS_CONSUMER(self)) {

Py_buffer *base = &self->head->base;

if (self->head->flags & ND_OWN_ARRAYS) {

PyMem_XFree(base->shape);

PyMem_XFree(base->strides);

PyMem_XFree(base->suboffsets);

}

PyBuffer_Release(base);

}

else {

while (self->head)

ndbuf_pop(self);

}

}

PyObject_Del(self);

}

static int

ndarray_init_staticbuf(PyObject *exporter, NDArrayObject *nd, int flags)

{

Py_buffer *base = &nd->staticbuf.base;

if (PyObject_GetBuffer(exporter, base, flags) < 0)

return -1;

nd->head = &nd->staticbuf;

nd->head->next = NULL;

nd->head->prev = NULL;

nd->head->len = -1;

nd->head->offset = -1;

nd->head->data = NULL;

nd->head->flags = base->readonly ? 0 : ND_WRITABLE;

nd->head->exports = 0;

return 0;

}

static void

init_flags(ndbuf_t *ndbuf)

{

if (ndbuf->base.ndim == 0)

ndbuf->flags |= ND_SCALAR;

if (ndbuf->base.suboffsets)

ndbuf->flags |= ND_PIL;

if (PyBuffer_IsContiguous(&ndbuf->base, 'C'))

ndbuf->flags |= ND_C;

if (PyBuffer_IsContiguous(&ndbuf->base, 'F'))

ndbuf->flags |= ND_FORTRAN;

}

static Py_ssize_t *strides_from_shape(const ndbuf_t *, int flags);

typedef struct {

PyObject_HEAD

Py_ssize_t s_size;

Py_ssize_t s_len;

} PyPartialStructObject;

static Py_ssize_t

get_nmemb(PyObject *s)

{

return ((PyPartialStructObject *)s)->s_len;

}

static int

pack_from_list(PyObject *obj, PyObject *items, PyObject *format,

Py_ssize_t itemsize)

{

PyObject *structobj, *pack_into;

PyObject *args, *offset;

PyObject *item, *tmp;

Py_ssize_t nitems; /* number of items */

Py_ssize_t nmemb; /* number of members in a single item */

Py_ssize_t i, j;

int ret = 0;

assert(PyObject_CheckBuffer(obj));

assert(PyList_Check(items) || PyTuple_Check(items));

structobj = PyObject_CallFunctionObjArgs(Struct, format, NULL);

if (structobj == NULL)

return -1;

nitems = PySequence_Fast_GET_SIZE(items);

nmemb = get_nmemb(structobj);

assert(nmemb >= 1);

pack_into = PyObject_GetAttrString(structobj, "pack_into");

if (pack_into == NULL) {

Py_DECREF(structobj);

return -1;

}

/* nmemb >= 1 */

args = PyTuple_New(2 + nmemb);

if (args == NULL) {

Py_DECREF(pack_into);

Py_DECREF(structobj);

return -1;

}

offset = NULL;

for (i = 0; i < nitems; i++) {

/* Loop invariant: args[j] are borrowed references or NULL. */

PyTuple_SetItemRef(args, 0, obj);

for (j = 1; j < 2+nmemb; j++) {

PyTuple_SetItemRef(args, j, NULL);

}

assert(offset == NULL);

offset = PyLong_FromSsize_t(i*itemsize);

if (offset == NULL) {

ret = -1;

break;

}

PyTuple_SetItemRef(args, 1, offset);

Py_CLEAR(offset);

item = PySequence_Fast_GetItemRef(items, i);

if ((PyBytes_Check(item) || PyLong_Check(item) ||

PyFloat_Check(item)) && nmemb == 1) {

PyTuple_SetItemRef(args, 2, item);

Py_DECREF(item);

}

else if ((PyList_Check(item) || PyTuple_Check(item)) &&

PySequence_Length(item) == nmemb) {

for (j = 0; j < nmemb; j++) {

tmp = PySequence_Fast_GetItemRef(item, j);

PyTuple_SetItemRef(args, 2+j, tmp);

Py_DECREF(tmp);

}

Py_DECREF(item);

}

else {

Py_DECREF(item);

PyErr_SetString(PyExc_ValueError,

"mismatch between initializer element and format string");

ret = -1;

break;

}

tmp = PyObject_CallObject(pack_into, args);

if (tmp == NULL) {

ret = -1;

break;

}

Py_DECREF(tmp);

}

Py_DECREF(args);

Py_DECREF(pack_into);

Py_DECREF(structobj);

return ret;

}

static int

pack_single(char *ptr, PyObject *item, const char *fmt, Py_ssize_t itemsize)

{

PyObject *structobj = NULL, *pack_into = NULL, *args = NULL;

PyObject *format = NULL, *mview = NULL, *zero = NULL;

Py_ssize_t i, nmemb;

int ret = -1;

PyObject *x;

if (fmt == NULL) fmt = "B";

format = PyUnicode_FromString(fmt);

if (format == NULL)

goto out;

structobj = PyObject_CallFunctionObjArgs(Struct, format, NULL);

if (structobj == NULL)

goto out;

nmemb = get_nmemb(structobj);

assert(nmemb >= 1);

mview = PyMemoryView_FromMemory(ptr, itemsize, PyBUF_WRITE);

if (mview == NULL)

goto out;

zero = PyLong_FromLong(0);

if (zero == NULL)

goto out;

pack_into = PyObject_GetAttrString(structobj, "pack_into");

if (pack_into == NULL)

goto out;

args = PyTuple_New(2+nmemb);

if (args == NULL)

goto out;

PyTuple_SetItemRef(args, 0, mview);

Py_DECREF(mview);

PyTuple_SetItemRef(args, 1, zero);

Py_DECREF(zero);

if ((PyBytes_Check(item) || PyLong_Check(item) ||

PyFloat_Check(item)) && nmemb == 1) {

PyTuple_SetItemRef(args, 2, item);

Py_DECREF(item);

}

else if ((PyList_Check(item) || PyTuple_Check(item)) &&

PySequence_Length(item) == nmemb) {

for (i = 0; i < nmemb; i++) {

x = PySequence_Fast_GetItemRef(item, i);

PyTuple_SetItemRef(args, 2+i, x);

Py_DECREF(x);

Py_DECREF(x);

}

}

else {

PyErr_SetString(PyExc_ValueError,

"mismatch between initializer element and format string");

goto args_out;

}

x = PyObject_CallObject(pack_into, args);

if (x != NULL) {

Py_DECREF(x);

ret = 0;

}

args_out:

for (i = 0; i < 2+nmemb; i++) {

/* increment the reference counter */

PyTuple_GetItemRef(args, i);

}

Py_XDECREF(args);

out:

Py_XDECREF(pack_into);

Py_XDECREF(zero);

Py_XDECREF(mview);

Py_XDECREF(structobj);

Py_XDECREF(format);

return ret;

}

static void

copy_rec(const Py_ssize_t *shape, Py_ssize_t ndim, Py_ssize_t itemsize,

char *dptr, const Py_ssize_t *dstrides, const Py_ssize_t *dsuboffsets,

char *sptr, const Py_ssize_t *sstrides, const Py_ssize_t *ssuboffsets,

char *mem)

{

Py_ssize_t i;

assert(ndim >= 1);

if (ndim == 1) {

if (!HAVE_PTR(dsuboffsets) && !HAVE_PTR(ssuboffsets) &&

dstrides[0] == itemsize && sstrides[0] == itemsize) {

memmove(dptr, sptr, shape[0] * itemsize);

}

else {

char *p;

assert(mem != NULL);

for (i=0, p=mem; i<shape[0]; p+=itemsize, sptr+=sstrides[0], i++) {

char *xsptr = ADJUST_PTR(sptr, ssuboffsets);

memcpy(p, xsptr, itemsize);

}

for (i=0, p=mem; i<shape[0]; p+=itemsize, dptr+=dstrides[0], i++) {

char *xdptr = ADJUST_PTR(dptr, dsuboffsets);

memcpy(xdptr, p, itemsize);

}

}

return;

}

for (i = 0; i < shape[0]; dptr+=dstrides[0], sptr+=sstrides[0], i++) {

char *xdptr = ADJUST_PTR(dptr, dsuboffsets);

char *xsptr = ADJUST_PTR(sptr, ssuboffsets);

copy_rec(shape+1, ndim-1, itemsize,

xdptr, dstrides+1, dsuboffsets ? dsuboffsets+1 : NULL,

xsptr, sstrides+1, ssuboffsets ? ssuboffsets+1 : NULL,

mem);

}

}

static int

cmp_structure(Py_buffer *dest, Py_buffer *src)

{

Py_ssize_t i;

if (strcmp(FIX_FORMAT(dest->format), FIX_FORMAT(src->format)) != 0 ||

dest->itemsize != src->itemsize ||

dest->ndim != src->ndim)

return -1;

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

if (dest->shape[i] != src->shape[i])

return -1;

if (dest->shape[i] == 0)

break;

}

return 0;

}

static int

copy_buffer(Py_buffer *dest, Py_buffer *src)

{

char *mem = NULL;

assert(dest->ndim > 0);

if (cmp_structure(dest, src) < 0) {

PyErr_SetString(PyExc_ValueError,

"ndarray assignment: lvalue and rvalue have different structures");

return -1;

}

if ((dest->suboffsets && dest->suboffsets[dest->ndim-1] >= 0) ||

(src->suboffsets && src->suboffsets[src->ndim-1] >= 0) ||

dest->strides[dest->ndim-1] != dest->itemsize ||

src->strides[src->ndim-1] != src->itemsize) {

mem = PyMem_Malloc(dest->shape[dest->ndim-1] * dest->itemsize);

if (mem == NULL) {

PyErr_NoMemory();

return -1;

}

}

copy_rec(dest->shape, dest->ndim, dest->itemsize,

dest->buf, dest->strides, dest->suboffsets,

src->buf, src->strides, src->suboffsets,

mem);

PyMem_XFree(mem);

return 0;

}

static PyObject *

unpack_single(char *ptr, const char *fmt, Py_ssize_t itemsize)

{

PyObject *x, *unpack_from, *mview;

if (fmt == NULL) {

fmt = "B";

itemsize = 1;

}

unpack_from = PyObject_GetAttrString(structmodule, "unpack_from");

if (unpack_from == NULL)

return NULL;

mview = PyMemoryView_FromMemory(ptr, itemsize, PyBUF_READ);

if (mview == NULL) {

Py_DECREF(unpack_from);

return NULL;

}

x = PyObject_CallFunction(unpack_from, "sO", fmt, mview);

Py_DECREF(unpack_from);

Py_DECREF(mview);

if (x == NULL)

return NULL;

if (PyTuple_GET_SIZE(x) == 1) {

PyObject *tmp = PyTuple_GetItemRef(x, 0);

Py_DECREF(x);

return tmp;

}

return x;

}

static PyObject *

unpack_rec(PyObject *unpack_from, char *ptr, PyObject *mview, char *item,

const Py_ssize_t *shape, const Py_ssize_t *strides,

const Py_ssize_t *suboffsets, Py_ssize_t ndim, Py_ssize_t itemsize)

{

PyObject *lst, *x;

Py_ssize_t i;

assert(ndim >= 0);

assert(shape != NULL);

assert(strides != NULL);

if (ndim == 0) {

memcpy(item, ptr, itemsize);

x = PyObject_CallFunctionObjArgs(unpack_from, mview, NULL);

if (x == NULL)

return NULL;

if (PyTuple_GET_SIZE(x) == 1) {

PyObject *tmp = PyTuple_GetItemRef(x, 0);

Py_DECREF(x);

return tmp;

}

return x;

}

lst = PyList_New(shape[0]);

if (lst == NULL)

return NULL;

for (i = 0; i < shape[0]; ptr+=strides[0], i++) {

char *nextptr = ADJUST_PTR(ptr, suboffsets);

x = unpack_rec(unpack_from, nextptr, mview, item,

shape+1, strides+1, suboffsets ? suboffsets+1 : NULL,

ndim-1, itemsize);

if (x == NULL) {

Py_DECREF(lst);

return NULL;

}

PyList_SET_ITEM(lst, i, x);

}

return lst;

}

static PyObject *

ndarray_as_list(NDArrayObject *nd)

{

PyObject *structobj = NULL, *unpack_from = NULL;

PyObject *lst = NULL, *mview = NULL;

Py_buffer *base = &nd->head->base;

Py_ssize_t *shape = base->shape;

Py_ssize_t *strides = base->strides;

Py_ssize_t simple_shape[1];

Py_ssize_t simple_strides[1];

char *item = NULL;

PyObject *format;

char *fmt = base->format;

base = &nd->head->base;

if (fmt == NULL) {

PyErr_SetString(PyExc_ValueError,

"ndarray: tolist() does not support format=NULL, use "

"tobytes()");

return NULL;

}

if (shape == NULL) {

assert(ND_C_CONTIGUOUS(nd->head->flags));

assert(base->strides == NULL);

assert(base->ndim <= 1);

shape = simple_shape;

shape[0] = base->len;

strides = simple_strides;

strides[0] = base->itemsize;

}

else if (strides == NULL) {

assert(ND_C_CONTIGUOUS(nd->head->flags));

strides = strides_from_shape(nd->head, 0);

if (strides == NULL)

return NULL;

}

format = PyUnicode_FromString(fmt);

if (format == NULL)

goto out;

structobj = PyObject_CallFunctionObjArgs(Struct, format, NULL);

Py_DECREF(format);

if (structobj == NULL)

goto out;

unpack_from = PyObject_GetAttrString(structobj, "unpack_from");

if (unpack_from == NULL)

goto out;

item = PyMem_Malloc(base->itemsize);

if (item == NULL) {

PyErr_NoMemory();

goto out;

}

mview = PyMemoryView_FromMemory(item, base->itemsize, PyBUF_WRITE);

if (mview == NULL)

goto out;

lst = unpack_rec(unpack_from, base->buf, mview, item,

shape, strides, base->suboffsets,

base->ndim, base->itemsize);

out:

Py_XDECREF(mview);

PyMem_XFree(item);

Py_XDECREF(unpack_from);

Py_XDECREF(structobj);

if (strides != base->strides && strides != simple_strides)

PyMem_XFree(strides);

return lst;

}

static Py_ssize_t

get_itemsize(PyObject *format)

{

PyObject *tmp;

Py_ssize_t itemsize;

tmp = PyObject_CallFunctionObjArgs(calcsize, format, NULL);

if (tmp == NULL)

return -1;

itemsize = PyLong_AsSsize_t(tmp);

Py_DECREF(tmp);

return itemsize;

}

static char *

get_format(PyObject *format)

{

PyObject *tmp;

char *fmt;

tmp = PyUnicode_AsASCIIString(format);

if (tmp == NULL)

return NULL;

fmt = PyMem_Malloc(PyBytes_GET_SIZE(tmp)+1);

if (fmt == NULL) {

PyErr_NoMemory();

Py_DECREF(tmp);

return NULL;

}

strcpy(fmt, PyBytes_AS_STRING(tmp));

Py_DECREF(tmp);

return fmt;

}

static int

init_simple(ndbuf_t *ndbuf, PyObject *items, PyObject *format,

Py_ssize_t itemsize)

{

PyObject *mview;

Py_buffer *base = &ndbuf->base;

int ret;

mview = PyMemoryView_FromBuffer(base);

if (mview == NULL)

return -1;

ret = pack_from_list(mview, items, format, itemsize);

Py_DECREF(mview);

if (ret < 0)

return -1;

base->readonly = !(ndbuf->flags & ND_WRITABLE);

base->itemsize = itemsize;

base->format = get_format(format);

if (base->format == NULL)

return -1;

return 0;

}

static Py_ssize_t *

seq_as_ssize_array(PyObject *seq, Py_ssize_t len, int is_shape)

{

Py_ssize_t *dest;

Py_ssize_t x, i;

/* ndim = len <= ND_MAX_NDIM, so PyMem_New() is actually not needed. */

dest = PyMem_New(Py_ssize_t, len);

if (dest == NULL) {

PyErr_NoMemory();

return NULL;

}

for (i = 0; i < len; i++) {

PyObject *tmp = PySequence_Fast_GetItemRef(seq, i);

if (!PyLong_Check(tmp)) {

Py_DECREF(tmp);

PyErr_Format(PyExc_ValueError,

"elements of %s must be integers",

is_shape ? "shape" : "strides");

PyMem_Free(dest);

return NULL;

}

x = PyLong_AsSsize_t(tmp);

Py_DECREF(tmp);

if (PyErr_Occurred()) {

PyMem_Free(dest);

return NULL;

}

if (is_shape && x < 0) {

PyErr_Format(PyExc_ValueError,

"elements of shape must be integers >= 0");

PyMem_Free(dest);

return NULL;

}

dest[i] = x;

}

return dest;

}

static Py_ssize_t *

strides_from_shape(const ndbuf_t *ndbuf, int flags)

{

const Py_buffer *base = &ndbuf->base;

Py_ssize_t *s, i;

s = PyMem_Malloc(base->ndim * (sizeof *s));

if (s == NULL) {

PyErr_NoMemory();

return NULL;

}

if (flags & ND_FORTRAN) {

s[0] = base->itemsize;

for (i = 1; i < base->ndim; i++)

s[i] = s[i-1] * base->shape[i-1];

}

else {

s[base->ndim-1] = base->itemsize;

for (i = base->ndim-2; i >= 0; i--)

s[i] = s[i+1] * base->shape[i+1];

}

return s;

}

static int

verify_structure(Py_ssize_t len, Py_ssize_t itemsize, Py_ssize_t offset,

const Py_ssize_t *shape, const Py_ssize_t *strides,

Py_ssize_t ndim)

{

Py_ssize_t imin, imax;

Py_ssize_t n;

assert(ndim >= 0);

if (ndim == 0 && (offset < 0 || offset+itemsize > len))

goto invalid_combination;

for (n = 0; n < ndim; n++)

if (strides[n] % itemsize) {

PyErr_SetString(PyExc_ValueError,

"strides must be a multiple of itemsize");

return -1;

}

for (n = 0; n < ndim; n++)

if (shape[n] == 0)

return 0;

imin = imax = 0;

for (n = 0; n < ndim; n++)

if (strides[n] <= 0)

imin += (shape[n]-1) * strides[n];

else

imax += (shape[n]-1) * strides[n];

if (imin + offset < 0 || imax + offset + itemsize > len)

goto invalid_combination;

return 0;

invalid_combination:

PyErr_SetString(PyExc_ValueError,

"invalid combination of buffer, shape and strides");

return -1;

}