Branch data Line data Source code
1 : : /* C Extension module to test all aspects of PEP-3118.
2 : : Written by Stefan Krah. */
3 : :
4 : :
5 : : #define PY_SSIZE_T_CLEAN
6 : :
7 : : #include "Python.h"
8 : :
9 : :
10 : : /* struct module */
11 : : static PyObject *structmodule = NULL;
12 : : static PyObject *Struct = NULL;
13 : : static PyObject *calcsize = NULL;
14 : :
15 : : /* cache simple format string */
16 : : static const char *simple_fmt = "B";
17 : : static PyObject *simple_format = NULL;
18 : : #define SIMPLE_FORMAT(fmt) (fmt == NULL || strcmp(fmt, "B") == 0)
19 : : #define FIX_FORMAT(fmt) (fmt == NULL ? "B" : fmt)
20 : :
21 : :
22 : : /**************************************************************************/
23 : : /* NDArray Object */
24 : : /**************************************************************************/
25 : :
26 : : static PyTypeObject NDArray_Type;
27 : : #define NDArray_Check(v) Py_IS_TYPE(v, &NDArray_Type)
28 : :
29 : : #define CHECK_LIST_OR_TUPLE(v) \
30 : : if (!PyList_Check(v) && !PyTuple_Check(v)) { \
31 : : PyErr_SetString(PyExc_TypeError, \
32 : : #v " must be a list or a tuple"); \
33 : : return NULL; \
34 : : } \
35 : :
36 : : #define PyMem_XFree(v) \
37 : : do { if (v) PyMem_Free(v); } while (0)
38 : :
39 : : /* Maximum number of dimensions. */
40 : : #define ND_MAX_NDIM (2 * PyBUF_MAX_NDIM)
41 : :
42 : : /* Check for the presence of suboffsets in the first dimension. */
43 : : #define HAVE_PTR(suboffsets) (suboffsets && suboffsets[0] >= 0)
44 : : /* Adjust ptr if suboffsets are present. */
45 : : #define ADJUST_PTR(ptr, suboffsets) \
46 : : (HAVE_PTR(suboffsets) ? *((char**)ptr) + suboffsets[0] : ptr)
47 : :
48 : : /* Default: NumPy style (strides), read-only, no var-export, C-style layout */
49 : : #define ND_DEFAULT 0x000
50 : : /* User configurable flags for the ndarray */
51 : : #define ND_VAREXPORT 0x001 /* change layout while buffers are exported */
52 : : /* User configurable flags for each base buffer */
53 : : #define ND_WRITABLE 0x002 /* mark base buffer as writable */
54 : : #define ND_FORTRAN 0x004 /* Fortran contiguous layout */
55 : : #define ND_SCALAR 0x008 /* scalar: ndim = 0 */
56 : : #define ND_PIL 0x010 /* convert to PIL-style array (suboffsets) */
57 : : #define ND_REDIRECT 0x020 /* redirect buffer requests */
58 : : #define ND_GETBUF_FAIL 0x040 /* trigger getbuffer failure */
59 : : #define ND_GETBUF_UNDEFINED 0x080 /* undefined view.obj */
60 : : /* Internal flags for the base buffer */
61 : : #define ND_C 0x100 /* C contiguous layout (default) */
62 : : #define ND_OWN_ARRAYS 0x200 /* consumer owns arrays */
63 : :
64 : : /* ndarray properties */
65 : : #define ND_IS_CONSUMER(nd) \
66 : : (((NDArrayObject *)nd)->head == &((NDArrayObject *)nd)->staticbuf)
67 : :
68 : : /* ndbuf->flags properties */
69 : : #define ND_C_CONTIGUOUS(flags) (!!(flags&(ND_SCALAR|ND_C)))
70 : : #define ND_FORTRAN_CONTIGUOUS(flags) (!!(flags&(ND_SCALAR|ND_FORTRAN)))
71 : : #define ND_ANY_CONTIGUOUS(flags) (!!(flags&(ND_SCALAR|ND_C|ND_FORTRAN)))
72 : :
73 : : /* getbuffer() requests */
74 : : #define REQ_INDIRECT(flags) ((flags&PyBUF_INDIRECT) == PyBUF_INDIRECT)
75 : : #define REQ_C_CONTIGUOUS(flags) ((flags&PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS)
76 : : #define REQ_F_CONTIGUOUS(flags) ((flags&PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS)
77 : : #define REQ_ANY_CONTIGUOUS(flags) ((flags&PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS)
78 : : #define REQ_STRIDES(flags) ((flags&PyBUF_STRIDES) == PyBUF_STRIDES)
79 : : #define REQ_SHAPE(flags) ((flags&PyBUF_ND) == PyBUF_ND)
80 : : #define REQ_WRITABLE(flags) (flags&PyBUF_WRITABLE)
81 : : #define REQ_FORMAT(flags) (flags&PyBUF_FORMAT)
82 : :
83 : :
84 : : /* Single node of a list of base buffers. The list is needed to implement
85 : : changes in memory layout while exported buffers are active. */
86 : : static PyTypeObject NDArray_Type;
87 : :
88 : : struct ndbuf;
89 : : typedef struct ndbuf {
90 : : struct ndbuf *next;
91 : : struct ndbuf *prev;
92 : : Py_ssize_t len; /* length of data */
93 : : Py_ssize_t offset; /* start of the array relative to data */
94 : : char *data; /* raw data */
95 : : int flags; /* capabilities of the base buffer */
96 : : Py_ssize_t exports; /* number of exports */
97 : : Py_buffer base; /* base buffer */
98 : : } ndbuf_t;
99 : :
100 : : typedef struct {
101 : : PyObject_HEAD
102 : : int flags; /* ndarray flags */
103 : : ndbuf_t staticbuf; /* static buffer for re-exporting mode */
104 : : ndbuf_t *head; /* currently active base buffer */
105 : : } NDArrayObject;
106 : :
107 : :
108 : : static ndbuf_t *
109 : 149943 : ndbuf_new(Py_ssize_t nitems, Py_ssize_t itemsize, Py_ssize_t offset, int flags)
110 : : {
111 : : ndbuf_t *ndbuf;
112 : : Py_buffer *base;
113 : : Py_ssize_t len;
114 : :
115 : 149943 : len = nitems * itemsize;
116 [ + + ]: 149943 : if (offset % itemsize) {
117 : 3 : PyErr_SetString(PyExc_ValueError,
118 : : "offset must be a multiple of itemsize");
119 : 3 : return NULL;
120 : : }
121 [ + + + + ]: 149940 : if (offset < 0 || offset+itemsize > len) {
122 : 126 : PyErr_SetString(PyExc_ValueError, "offset out of bounds");
123 : 126 : return NULL;
124 : : }
125 : :
126 : 149814 : ndbuf = PyMem_Malloc(sizeof *ndbuf);
127 [ - + ]: 149814 : if (ndbuf == NULL) {
128 : : PyErr_NoMemory();
129 : 0 : return NULL;
130 : : }
131 : :
132 : 149814 : ndbuf->next = NULL;
133 : 149814 : ndbuf->prev = NULL;
134 : 149814 : ndbuf->len = len;
135 : 149814 : ndbuf->offset= offset;
136 : :
137 : 149814 : ndbuf->data = PyMem_Malloc(len);
138 [ - + ]: 149814 : if (ndbuf->data == NULL) {
139 : : PyErr_NoMemory();
140 : 0 : PyMem_Free(ndbuf);
141 : 0 : return NULL;
142 : : }
143 : :
144 : 149814 : ndbuf->flags = flags;
145 : 149814 : ndbuf->exports = 0;
146 : :
147 : 149814 : base = &ndbuf->base;
148 : 149814 : base->obj = NULL;
149 : 149814 : base->buf = ndbuf->data;
150 : 149814 : base->len = len;
151 : 149814 : base->itemsize = 1;
152 : 149814 : base->readonly = 0;
153 : 149814 : base->format = NULL;
154 : 149814 : base->ndim = 1;
155 : 149814 : base->shape = NULL;
156 : 149814 : base->strides = NULL;
157 : 149814 : base->suboffsets = NULL;
158 : 149814 : base->internal = ndbuf;
159 : :
160 : 149814 : return ndbuf;
161 : : }
162 : :
163 : : static void
164 : 149814 : ndbuf_free(ndbuf_t *ndbuf)
165 : : {
166 : 149814 : Py_buffer *base = &ndbuf->base;
167 : :
168 [ + - ]: 149814 : PyMem_XFree(ndbuf->data);
169 [ + + ]: 149814 : PyMem_XFree(base->format);
170 [ + + ]: 149814 : PyMem_XFree(base->shape);
171 [ + + ]: 149814 : PyMem_XFree(base->strides);
172 [ + + ]: 149814 : PyMem_XFree(base->suboffsets);
173 : :
174 : 149814 : PyMem_Free(ndbuf);
175 : 149814 : }
176 : :
177 : : static void
178 : 149731 : ndbuf_push(NDArrayObject *nd, ndbuf_t *elt)
179 : : {
180 : 149731 : elt->next = nd->head;
181 [ + + ]: 149731 : if (nd->head) nd->head->prev = elt;
182 : 149731 : nd->head = elt;
183 : 149731 : elt->prev = NULL;
184 : 149731 : }
185 : :
186 : : static void
187 : 149731 : ndbuf_delete(NDArrayObject *nd, ndbuf_t *elt)
188 : : {
189 [ + + ]: 149731 : if (elt->prev)
190 : 4 : elt->prev->next = elt->next;
191 : : else
192 : 149727 : nd->head = elt->next;
193 : :
194 [ + + ]: 149731 : if (elt->next)
195 : 5 : elt->next->prev = elt->prev;
196 : :
197 : 149731 : ndbuf_free(elt);
198 : 149731 : }
199 : :
200 : : static void
201 : 149727 : ndbuf_pop(NDArrayObject *nd)
202 : : {
203 : 149727 : ndbuf_delete(nd, nd->head);
204 : 149727 : }
205 : :
206 : :
207 : : static PyObject *
208 : 204249 : ndarray_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
209 : : {
210 : : NDArrayObject *nd;
211 : :
212 : 204249 : nd = PyObject_New(NDArrayObject, &NDArray_Type);
213 [ - + ]: 204249 : if (nd == NULL)
214 : 0 : return NULL;
215 : :
216 : 204249 : nd->flags = 0;
217 : 204249 : nd->head = NULL;
218 : 204249 : return (PyObject *)nd;
219 : : }
220 : :
221 : : static void
222 : 204249 : ndarray_dealloc(NDArrayObject *self)
223 : : {
224 [ + + ]: 204249 : if (self->head) {
225 [ + + ]: 175843 : if (ND_IS_CONSUMER(self)) {
226 : 26118 : Py_buffer *base = &self->head->base;
227 [ + + ]: 26118 : if (self->head->flags & ND_OWN_ARRAYS) {
228 [ + - ]: 10333 : PyMem_XFree(base->shape);
229 [ + - ]: 10333 : PyMem_XFree(base->strides);
230 [ + + ]: 10333 : PyMem_XFree(base->suboffsets);
231 : : }
232 : 26118 : PyBuffer_Release(base);
233 : : }
234 : : else {
235 [ + + ]: 299450 : while (self->head)
236 : 149725 : ndbuf_pop(self);
237 : : }
238 : : }
239 : 204249 : PyObject_Free(self);
240 : 204249 : }
241 : :
242 : : static int
243 : 54321 : ndarray_init_staticbuf(PyObject *exporter, NDArrayObject *nd, int flags)
244 : : {
245 : 54321 : Py_buffer *base = &nd->staticbuf.base;
246 : :
247 [ + + ]: 54321 : if (PyObject_GetBuffer(exporter, base, flags) < 0)
248 : 28203 : return -1;
249 : :
250 : 26118 : nd->head = &nd->staticbuf;
251 : :
252 : 26118 : nd->head->next = NULL;
253 : 26118 : nd->head->prev = NULL;
254 : 26118 : nd->head->len = -1;
255 : 26118 : nd->head->offset = -1;
256 : 26118 : nd->head->data = NULL;
257 : :
258 [ + + ]: 26118 : nd->head->flags = base->readonly ? 0 : ND_WRITABLE;
259 : 26118 : nd->head->exports = 0;
260 : :
261 : 26118 : return 0;
262 : : }
263 : :
264 : : static void
265 : 26109 : init_flags(ndbuf_t *ndbuf)
266 : : {
267 [ + + ]: 26109 : if (ndbuf->base.ndim == 0)
268 : 1217 : ndbuf->flags |= ND_SCALAR;
269 [ + + ]: 26109 : if (ndbuf->base.suboffsets)
270 : 8191 : ndbuf->flags |= ND_PIL;
271 [ + + ]: 26109 : if (PyBuffer_IsContiguous(&ndbuf->base, 'C'))
272 : 11605 : ndbuf->flags |= ND_C;
273 [ + + ]: 26109 : if (PyBuffer_IsContiguous(&ndbuf->base, 'F'))
274 : 11154 : ndbuf->flags |= ND_FORTRAN;
275 : 26109 : }
276 : :
277 : :
278 : : /****************************************************************************/
279 : : /* Buffer/List conversions */
280 : : /****************************************************************************/
281 : :
282 : : static Py_ssize_t *strides_from_shape(const ndbuf_t *, int flags);
283 : :
284 : : /* Get number of members in a struct: see issue #12740 */
285 : : typedef struct {
286 : : PyObject_HEAD
287 : : Py_ssize_t s_size;
288 : : Py_ssize_t s_len;
289 : : } PyPartialStructObject;
290 : :
291 : : static Py_ssize_t
292 : 151110 : get_nmemb(PyObject *s)
293 : : {
294 : 151110 : return ((PyPartialStructObject *)s)->s_len;
295 : : }
296 : :
297 : : /* Pack all items into the buffer of 'obj'. The 'format' parameter must be
298 : : in struct module syntax. For standard C types, a single item is an integer.
299 : : For compound types, a single item is a tuple of integers. */
300 : : static int
301 : 149814 : pack_from_list(PyObject *obj, PyObject *items, PyObject *format,
302 : : Py_ssize_t itemsize)
303 : : {
304 : : PyObject *structobj, *pack_into;
305 : : PyObject *args, *offset;
306 : : PyObject *item, *tmp;
307 : : Py_ssize_t nitems; /* number of items */
308 : : Py_ssize_t nmemb; /* number of members in a single item */
309 : : Py_ssize_t i, j;
310 : 149814 : int ret = 0;
311 : :
312 : : assert(PyObject_CheckBuffer(obj));
313 : : assert(PyList_Check(items) || PyTuple_Check(items));
314 : :
315 : 149814 : structobj = PyObject_CallFunctionObjArgs(Struct, format, NULL);
316 [ - + ]: 149814 : if (structobj == NULL)
317 : 0 : return -1;
318 : :
319 [ + + ]: 149814 : nitems = PySequence_Fast_GET_SIZE(items);
320 : 149814 : nmemb = get_nmemb(structobj);
321 : : assert(nmemb >= 1);
322 : :
323 : 149814 : pack_into = PyObject_GetAttrString(structobj, "pack_into");
324 [ - + ]: 149814 : if (pack_into == NULL) {
325 : 0 : Py_DECREF(structobj);
326 : 0 : return -1;
327 : : }
328 : :
329 : : /* nmemb >= 1 */
330 : 149814 : args = PyTuple_New(2 + nmemb);
331 [ - + ]: 149814 : if (args == NULL) {
332 : 0 : Py_DECREF(pack_into);
333 : 0 : Py_DECREF(structobj);
334 : 0 : return -1;
335 : : }
336 : :
337 : 149814 : offset = NULL;
338 [ + + ]: 2095792 : for (i = 0; i < nitems; i++) {
339 : : /* Loop invariant: args[j] are borrowed references or NULL. */
340 : 1945990 : PyTuple_SET_ITEM(args, 0, obj);
341 [ + + ]: 6120783 : for (j = 1; j < 2+nmemb; j++)
342 : 4174793 : PyTuple_SET_ITEM(args, j, NULL);
343 : :
344 : 1945990 : Py_XDECREF(offset);
345 : 1945990 : offset = PyLong_FromSsize_t(i*itemsize);
346 [ - + ]: 1945990 : if (offset == NULL) {
347 : 0 : ret = -1;
348 : 0 : break;
349 : : }
350 : 1945990 : PyTuple_SET_ITEM(args, 1, offset);
351 : :
352 [ + + ]: 1945990 : item = PySequence_Fast_GET_ITEM(items, i);
353 [ + + + + : 2306540 : if ((PyBytes_Check(item) || PyLong_Check(item) ||
+ + ]
354 [ + + ]: 2144871 : PyFloat_Check(item)) && nmemb == 1) {
355 : 1784318 : PyTuple_SET_ITEM(args, 2, item);
356 : : }
357 [ + + + + : 323338 : else if ((PyList_Check(item) || PyTuple_Check(item)) &&
+ + ]
358 : 161666 : PySequence_Length(item) == nmemb) {
359 [ + + ]: 606136 : for (j = 0; j < nmemb; j++) {
360 [ + + ]: 444473 : tmp = PySequence_Fast_GET_ITEM(item, j);
361 : 444473 : PyTuple_SET_ITEM(args, 2+j, tmp);
362 : : }
363 : : }
364 : : else {
365 : 9 : PyErr_SetString(PyExc_ValueError,
366 : : "mismatch between initializer element and format string");
367 : 9 : ret = -1;
368 : 9 : break;
369 : : }
370 : :
371 : 1945981 : tmp = PyObject_CallObject(pack_into, args);
372 [ + + ]: 1945981 : if (tmp == NULL) {
373 : 3 : ret = -1;
374 : 3 : break;
375 : : }
376 : 1945978 : Py_DECREF(tmp);
377 : : }
378 : :
379 : 149814 : Py_INCREF(obj); /* args[0] */
380 : : /* args[1]: offset is either NULL or should be dealloc'd */
381 [ + + ]: 328179 : for (i = 2; i < 2+nmemb; i++) {
382 : 178365 : tmp = PyTuple_GET_ITEM(args, i);
383 : 178365 : Py_XINCREF(tmp);
384 : : }
385 : 149814 : Py_DECREF(args);
386 : :
387 : 149814 : Py_DECREF(pack_into);
388 : 149814 : Py_DECREF(structobj);
389 : 149814 : return ret;
390 : :
391 : : }
392 : :
393 : : /* Pack single element */
394 : : static int
395 : 1296 : pack_single(char *ptr, PyObject *item, const char *fmt, Py_ssize_t itemsize)
396 : : {
397 : 1296 : PyObject *structobj = NULL, *pack_into = NULL, *args = NULL;
398 : 1296 : PyObject *format = NULL, *mview = NULL, *zero = NULL;
399 : : Py_ssize_t i, nmemb;
400 : 1296 : int ret = -1;
401 : : PyObject *x;
402 : :
403 [ - + ]: 1296 : if (fmt == NULL) fmt = "B";
404 : :
405 : 1296 : format = PyUnicode_FromString(fmt);
406 [ - + ]: 1296 : if (format == NULL)
407 : 0 : goto out;
408 : :
409 : 1296 : structobj = PyObject_CallFunctionObjArgs(Struct, format, NULL);
410 [ - + ]: 1296 : if (structobj == NULL)
411 : 0 : goto out;
412 : :
413 : 1296 : nmemb = get_nmemb(structobj);
414 : : assert(nmemb >= 1);
415 : :
416 : 1296 : mview = PyMemoryView_FromMemory(ptr, itemsize, PyBUF_WRITE);
417 [ - + ]: 1296 : if (mview == NULL)
418 : 0 : goto out;
419 : :
420 : 1296 : zero = PyLong_FromLong(0);
421 [ - + ]: 1296 : if (zero == NULL)
422 : 0 : goto out;
423 : :
424 : 1296 : pack_into = PyObject_GetAttrString(structobj, "pack_into");
425 [ - + ]: 1296 : if (pack_into == NULL)
426 : 0 : goto out;
427 : :
428 : 1296 : args = PyTuple_New(2+nmemb);
429 [ - + ]: 1296 : if (args == NULL)
430 : 0 : goto out;
431 : :
432 : 1296 : PyTuple_SET_ITEM(args, 0, mview);
433 : 1296 : PyTuple_SET_ITEM(args, 1, zero);
434 : :
435 [ + + + + : 2082 : if ((PyBytes_Check(item) || PyLong_Check(item) ||
+ + ]
436 [ + + ]: 1390 : PyFloat_Check(item)) && nmemb == 1) {
437 : 603 : PyTuple_SET_ITEM(args, 2, item);
438 : : }
439 [ + - + + : 1385 : else if ((PyList_Check(item) || PyTuple_Check(item)) &&
+ + ]
440 : 692 : PySequence_Length(item) == nmemb) {
441 [ + + ]: 2597 : for (i = 0; i < nmemb; i++) {
442 [ - + ]: 1906 : x = PySequence_Fast_GET_ITEM(item, i);
443 : 1906 : PyTuple_SET_ITEM(args, 2+i, x);
444 : : }
445 : : }
446 : : else {
447 : 2 : PyErr_SetString(PyExc_ValueError,
448 : : "mismatch between initializer element and format string");
449 : 2 : goto args_out;
450 : : }
451 : :
452 : 1294 : x = PyObject_CallObject(pack_into, args);
453 [ + + ]: 1294 : if (x != NULL) {
454 : 1292 : Py_DECREF(x);
455 : 1292 : ret = 0;
456 : : }
457 : :
458 : :
459 : 2 : args_out:
460 [ + + ]: 6400 : for (i = 0; i < 2+nmemb; i++)
461 : 5104 : Py_XINCREF(PyTuple_GET_ITEM(args, i));
462 : 1296 : Py_XDECREF(args);
463 : 1296 : out:
464 : 1296 : Py_XDECREF(pack_into);
465 : 1296 : Py_XDECREF(zero);
466 : 1296 : Py_XDECREF(mview);
467 : 1296 : Py_XDECREF(structobj);
468 : 1296 : Py_XDECREF(format);
469 : 1296 : return ret;
470 : : }
471 : :
472 : : static void
473 : 26830 : copy_rec(const Py_ssize_t *shape, Py_ssize_t ndim, Py_ssize_t itemsize,
474 : : char *dptr, const Py_ssize_t *dstrides, const Py_ssize_t *dsuboffsets,
475 : : char *sptr, const Py_ssize_t *sstrides, const Py_ssize_t *ssuboffsets,
476 : : char *mem)
477 : : {
478 : : Py_ssize_t i;
479 : :
480 : : assert(ndim >= 1);
481 : :
482 [ + + ]: 26830 : if (ndim == 1) {
483 [ + + + + : 20623 : if (!HAVE_PTR(dsuboffsets) && !HAVE_PTR(ssuboffsets) &&
+ + + + ]
484 [ + + + + ]: 17973 : dstrides[0] == itemsize && sstrides[0] == itemsize) {
485 : 4636 : memmove(dptr, sptr, shape[0] * itemsize);
486 : : }
487 : : else {
488 : : char *p;
489 : : assert(mem != NULL);
490 [ + + ]: 95694 : for (i=0, p=mem; i<shape[0]; p+=itemsize, sptr+=sstrides[0], i++) {
491 [ + + + + ]: 79707 : char *xsptr = ADJUST_PTR(sptr, ssuboffsets);
492 : 79707 : memcpy(p, xsptr, itemsize);
493 : : }
494 [ + + ]: 95694 : for (i=0, p=mem; i<shape[0]; p+=itemsize, dptr+=dstrides[0], i++) {
495 [ + + + + ]: 79707 : char *xdptr = ADJUST_PTR(dptr, dsuboffsets);
496 : 79707 : memcpy(xdptr, p, itemsize);
497 : : }
498 : : }
499 : 20623 : return;
500 : : }
501 : :
502 [ + + ]: 20225 : for (i = 0; i < shape[0]; dptr+=dstrides[0], sptr+=sstrides[0], i++) {
503 [ + + + + ]: 14018 : char *xdptr = ADJUST_PTR(dptr, dsuboffsets);
504 [ + + + + ]: 14018 : char *xsptr = ADJUST_PTR(sptr, ssuboffsets);
505 : :
506 [ + + + + ]: 14018 : copy_rec(shape+1, ndim-1, itemsize,
507 : : xdptr, dstrides+1, dsuboffsets ? dsuboffsets+1 : NULL,
508 : : xsptr, sstrides+1, ssuboffsets ? ssuboffsets+1 : NULL,
509 : : mem);
510 : : }
511 : : }
512 : :
513 : : static int
514 : 16442 : cmp_structure(Py_buffer *dest, Py_buffer *src)
515 : : {
516 : : Py_ssize_t i;
517 : :
518 [ + + + + : 16442 : if (strcmp(FIX_FORMAT(dest->format), FIX_FORMAT(src->format)) != 0 ||
+ + ]
519 [ + - ]: 16440 : dest->itemsize != src->itemsize ||
520 [ + + ]: 16440 : dest->ndim != src->ndim)
521 : 3 : return -1;
522 : :
523 [ + + ]: 35097 : for (i = 0; i < dest->ndim; i++) {
524 [ + + ]: 22351 : if (dest->shape[i] != src->shape[i])
525 : 3627 : return -1;
526 [ + + ]: 18724 : if (dest->shape[i] == 0)
527 : 66 : break;
528 : : }
529 : :
530 : 12812 : return 0;
531 : : }
532 : :
533 : : /* Copy src to dest. Both buffers must have the same format, itemsize,
534 : : ndim and shape. Copying is atomic, the function never fails with
535 : : a partial copy. */
536 : : static int
537 : 16442 : copy_buffer(Py_buffer *dest, Py_buffer *src)
538 : : {
539 : 16442 : char *mem = NULL;
540 : :
541 : : assert(dest->ndim > 0);
542 : :
543 [ + + ]: 16442 : if (cmp_structure(dest, src) < 0) {
544 : 3630 : PyErr_SetString(PyExc_ValueError,
545 : : "ndarray assignment: lvalue and rvalue have different structures");
546 : 3630 : return -1;
547 : : }
548 : :
549 [ + + + + ]: 12812 : if ((dest->suboffsets && dest->suboffsets[dest->ndim-1] >= 0) ||
550 [ + + + + ]: 12290 : (src->suboffsets && src->suboffsets[src->ndim-1] >= 0) ||
551 [ + + ]: 10162 : dest->strides[dest->ndim-1] != dest->itemsize ||
552 [ + + ]: 9849 : src->strides[src->ndim-1] != src->itemsize) {
553 : 10666 : mem = PyMem_Malloc(dest->shape[dest->ndim-1] * dest->itemsize);
554 [ - + ]: 10666 : if (mem == NULL) {
555 : : PyErr_NoMemory();
556 : 0 : return -1;
557 : : }
558 : : }
559 : :
560 : 12812 : copy_rec(dest->shape, dest->ndim, dest->itemsize,
561 : 12812 : dest->buf, dest->strides, dest->suboffsets,
562 : 12812 : src->buf, src->strides, src->suboffsets,
563 : : mem);
564 : :
565 [ + + ]: 12812 : PyMem_XFree(mem);
566 : 12812 : return 0;
567 : : }
568 : :
569 : :
570 : : /* Unpack single element */
571 : : static PyObject *
572 : 94183 : unpack_single(char *ptr, const char *fmt, Py_ssize_t itemsize)
573 : : {
574 : : PyObject *x, *unpack_from, *mview;
575 : :
576 [ + + ]: 94183 : if (fmt == NULL) {
577 : 20 : fmt = "B";
578 : 20 : itemsize = 1;
579 : : }
580 : :
581 : 94183 : unpack_from = PyObject_GetAttrString(structmodule, "unpack_from");
582 [ - + ]: 94183 : if (unpack_from == NULL)
583 : 0 : return NULL;
584 : :
585 : 94183 : mview = PyMemoryView_FromMemory(ptr, itemsize, PyBUF_READ);
586 [ - + ]: 94183 : if (mview == NULL) {
587 : 0 : Py_DECREF(unpack_from);
588 : 0 : return NULL;
589 : : }
590 : :
591 : 94183 : x = PyObject_CallFunction(unpack_from, "sO", fmt, mview);
592 : 94183 : Py_DECREF(unpack_from);
593 : 94183 : Py_DECREF(mview);
594 [ - + ]: 94183 : if (x == NULL)
595 : 0 : return NULL;
596 : :
597 [ + + ]: 94183 : if (PyTuple_GET_SIZE(x) == 1) {
598 : 82120 : PyObject *tmp = PyTuple_GET_ITEM(x, 0);
599 : 82120 : Py_INCREF(tmp);
600 : 82120 : Py_DECREF(x);
601 : 82120 : return tmp;
602 : : }
603 : :
604 : 12063 : return x;
605 : : }
606 : :
607 : : /* Unpack a multi-dimensional matrix into a nested list. Return a scalar
608 : : for ndim = 0. */
609 : : static PyObject *
610 : 1157966 : unpack_rec(PyObject *unpack_from, char *ptr, PyObject *mview, char *item,
611 : : const Py_ssize_t *shape, const Py_ssize_t *strides,
612 : : const Py_ssize_t *suboffsets, Py_ssize_t ndim, Py_ssize_t itemsize)
613 : : {
614 : : PyObject *lst, *x;
615 : : Py_ssize_t i;
616 : :
617 : : assert(ndim >= 0);
618 : : assert(shape != NULL);
619 : : assert(strides != NULL);
620 : :
621 [ + + ]: 1157966 : if (ndim == 0) {
622 : 933059 : memcpy(item, ptr, itemsize);
623 : 933059 : x = PyObject_CallFunctionObjArgs(unpack_from, mview, NULL);
624 [ - + ]: 933059 : if (x == NULL)
625 : 0 : return NULL;
626 [ + + ]: 933059 : if (PyTuple_GET_SIZE(x) == 1) {
627 : 918324 : PyObject *tmp = PyTuple_GET_ITEM(x, 0);
628 : 918324 : Py_INCREF(tmp);
629 : 918324 : Py_DECREF(x);
630 : 918324 : return tmp;
631 : : }
632 : 14735 : return x;
633 : : }
634 : :
635 : 224907 : lst = PyList_New(shape[0]);
636 [ - + ]: 224907 : if (lst == NULL)
637 : 0 : return NULL;
638 : :
639 [ + + ]: 1330202 : for (i = 0; i < shape[0]; ptr+=strides[0], i++) {
640 [ + + + + ]: 1105295 : char *nextptr = ADJUST_PTR(ptr, suboffsets);
641 : :
642 [ + + ]: 1105295 : x = unpack_rec(unpack_from, nextptr, mview, item,
643 : : shape+1, strides+1, suboffsets ? suboffsets+1 : NULL,
644 : : ndim-1, itemsize);
645 [ - + ]: 1105295 : if (x == NULL) {
646 : 0 : Py_DECREF(lst);
647 : 0 : return NULL;
648 : : }
649 : :
650 : 1105295 : PyList_SET_ITEM(lst, i, x);
651 : : }
652 : :
653 : 224907 : return lst;
654 : : }
655 : :
656 : :
657 : : static PyObject *
658 : 52672 : ndarray_as_list(NDArrayObject *nd)
659 : : {
660 : 52672 : PyObject *structobj = NULL, *unpack_from = NULL;
661 : 52672 : PyObject *lst = NULL, *mview = NULL;
662 : 52672 : Py_buffer *base = &nd->head->base;
663 : 52672 : Py_ssize_t *shape = base->shape;
664 : 52672 : Py_ssize_t *strides = base->strides;
665 : : Py_ssize_t simple_shape[1];
666 : : Py_ssize_t simple_strides[1];
667 : 52672 : char *item = NULL;
668 : : PyObject *format;
669 : 52672 : char *fmt = base->format;
670 : :
671 : 52672 : base = &nd->head->base;
672 : :
673 [ + + ]: 52672 : if (fmt == NULL) {
674 : 1 : PyErr_SetString(PyExc_ValueError,
675 : : "ndarray: tolist() does not support format=NULL, use "
676 : : "tobytes()");
677 : 1 : return NULL;
678 : : }
679 [ + + ]: 52671 : if (shape == NULL) {
680 : : assert(ND_C_CONTIGUOUS(nd->head->flags));
681 : : assert(base->strides == NULL);
682 : : assert(base->ndim <= 1);
683 : 3082 : shape = simple_shape;
684 : 3082 : shape[0] = base->len;
685 : 3082 : strides = simple_strides;
686 : 3082 : strides[0] = base->itemsize;
687 : : }
688 [ + + ]: 49589 : else if (strides == NULL) {
689 : : assert(ND_C_CONTIGUOUS(nd->head->flags));
690 : 513 : strides = strides_from_shape(nd->head, 0);
691 [ - + ]: 513 : if (strides == NULL)
692 : 0 : return NULL;
693 : : }
694 : :
695 : 52671 : format = PyUnicode_FromString(fmt);
696 [ - + ]: 52671 : if (format == NULL)
697 : 0 : goto out;
698 : :
699 : 52671 : structobj = PyObject_CallFunctionObjArgs(Struct, format, NULL);
700 : 52671 : Py_DECREF(format);
701 [ - + ]: 52671 : if (structobj == NULL)
702 : 0 : goto out;
703 : :
704 : 52671 : unpack_from = PyObject_GetAttrString(structobj, "unpack_from");
705 [ - + ]: 52671 : if (unpack_from == NULL)
706 : 0 : goto out;
707 : :
708 : 52671 : item = PyMem_Malloc(base->itemsize);
709 [ - + ]: 52671 : if (item == NULL) {
710 : : PyErr_NoMemory();
711 : 0 : goto out;
712 : : }
713 : :
714 : 52671 : mview = PyMemoryView_FromMemory(item, base->itemsize, PyBUF_WRITE);
715 [ - + ]: 52671 : if (mview == NULL)
716 : 0 : goto out;
717 : :
718 : 52671 : lst = unpack_rec(unpack_from, base->buf, mview, item,
719 : 52671 : shape, strides, base->suboffsets,
720 : 52671 : base->ndim, base->itemsize);
721 : :
722 : 52671 : out:
723 : 52671 : Py_XDECREF(mview);
724 [ + - ]: 52671 : PyMem_XFree(item);
725 : 52671 : Py_XDECREF(unpack_from);
726 : 52671 : Py_XDECREF(structobj);
727 [ + + + + ]: 52671 : if (strides != base->strides && strides != simple_strides)
728 [ + - ]: 513 : PyMem_XFree(strides);
729 : :
730 : 52671 : return lst;
731 : : }
732 : :
733 : :
734 : : /****************************************************************************/
735 : : /* Initialize ndbuf */
736 : : /****************************************************************************/
737 : :
738 : : /*
739 : : State of a new ndbuf during initialization. 'OK' means that initialization
740 : : is complete. 'PTR' means that a pointer has been initialized, but the
741 : : state of the memory is still undefined and ndbuf->offset is disregarded.
742 : :
743 : : +-----------------+-----------+-------------+----------------+
744 : : | | ndbuf_new | init_simple | init_structure |
745 : : +-----------------+-----------+-------------+----------------+
746 : : | next | OK (NULL) | OK | OK |
747 : : +-----------------+-----------+-------------+----------------+
748 : : | prev | OK (NULL) | OK | OK |
749 : : +-----------------+-----------+-------------+----------------+
750 : : | len | OK | OK | OK |
751 : : +-----------------+-----------+-------------+----------------+
752 : : | offset | OK | OK | OK |
753 : : +-----------------+-----------+-------------+----------------+
754 : : | data | PTR | OK | OK |
755 : : +-----------------+-----------+-------------+----------------+
756 : : | flags | user | user | OK |
757 : : +-----------------+-----------+-------------+----------------+
758 : : | exports | OK (0) | OK | OK |
759 : : +-----------------+-----------+-------------+----------------+
760 : : | base.obj | OK (NULL) | OK | OK |
761 : : +-----------------+-----------+-------------+----------------+
762 : : | base.buf | PTR | PTR | OK |
763 : : +-----------------+-----------+-------------+----------------+
764 : : | base.len | len(data) | len(data) | OK |
765 : : +-----------------+-----------+-------------+----------------+
766 : : | base.itemsize | 1 | OK | OK |
767 : : +-----------------+-----------+-------------+----------------+
768 : : | base.readonly | 0 | OK | OK |
769 : : +-----------------+-----------+-------------+----------------+
770 : : | base.format | NULL | OK | OK |
771 : : +-----------------+-----------+-------------+----------------+
772 : : | base.ndim | 1 | 1 | OK |
773 : : +-----------------+-----------+-------------+----------------+
774 : : | base.shape | NULL | NULL | OK |
775 : : +-----------------+-----------+-------------+----------------+
776 : : | base.strides | NULL | NULL | OK |
777 : : +-----------------+-----------+-------------+----------------+
778 : : | base.suboffsets | NULL | NULL | OK |
779 : : +-----------------+-----------+-------------+----------------+
780 : : | base.internal | OK | OK | OK |
781 : : +-----------------+-----------+-------------+----------------+
782 : :
783 : : */
784 : :
785 : : static Py_ssize_t
786 : 149958 : get_itemsize(PyObject *format)
787 : : {
788 : : PyObject *tmp;
789 : : Py_ssize_t itemsize;
790 : :
791 : 149958 : tmp = PyObject_CallFunctionObjArgs(calcsize, format, NULL);
792 [ + + ]: 149958 : if (tmp == NULL)
793 : 6 : return -1;
794 : 149952 : itemsize = PyLong_AsSsize_t(tmp);
795 : 149952 : Py_DECREF(tmp);
796 : :
797 : 149952 : return itemsize;
798 : : }
799 : :
800 : : static char *
801 : 149802 : get_format(PyObject *format)
802 : : {
803 : : PyObject *tmp;
804 : : char *fmt;
805 : :
806 : 149802 : tmp = PyUnicode_AsASCIIString(format);
807 [ - + ]: 149802 : if (tmp == NULL)
808 : 0 : return NULL;
809 : 149802 : fmt = PyMem_Malloc(PyBytes_GET_SIZE(tmp)+1);
810 [ - + ]: 149802 : if (fmt == NULL) {
811 : : PyErr_NoMemory();
812 : 0 : Py_DECREF(tmp);
813 : 0 : return NULL;
814 : : }
815 : 149802 : strcpy(fmt, PyBytes_AS_STRING(tmp));
816 : 149802 : Py_DECREF(tmp);
817 : :
818 : 149802 : return fmt;
819 : : }
820 : :
821 : : static int
822 : 149814 : init_simple(ndbuf_t *ndbuf, PyObject *items, PyObject *format,
823 : : Py_ssize_t itemsize)
824 : : {
825 : : PyObject *mview;
826 : 149814 : Py_buffer *base = &ndbuf->base;
827 : : int ret;
828 : :
829 : 149814 : mview = PyMemoryView_FromBuffer(base);
830 [ - + ]: 149814 : if (mview == NULL)
831 : 0 : return -1;
832 : :
833 : 149814 : ret = pack_from_list(mview, items, format, itemsize);
834 : 149814 : Py_DECREF(mview);
835 [ + + ]: 149814 : if (ret < 0)
836 : 12 : return -1;
837 : :
838 : 149802 : base->readonly = !(ndbuf->flags & ND_WRITABLE);
839 : 149802 : base->itemsize = itemsize;
840 : 149802 : base->format = get_format(format);
841 [ - + ]: 149802 : if (base->format == NULL)
842 : 0 : return -1;
843 : :
844 : 149802 : return 0;
845 : : }
846 : :
847 : : static Py_ssize_t *
848 : 150830 : seq_as_ssize_array(PyObject *seq, Py_ssize_t len, int is_shape)
849 : : {
850 : : Py_ssize_t *dest;
851 : : Py_ssize_t x, i;
852 : :
853 : : /* ndim = len <= ND_MAX_NDIM, so PyMem_New() is actually not needed. */
854 [ + - ]: 150830 : dest = PyMem_New(Py_ssize_t, len);
855 [ - + ]: 150830 : if (dest == NULL) {
856 : : PyErr_NoMemory();
857 : 0 : return NULL;
858 : : }
859 : :
860 [ + + ]: 385826 : for (i = 0; i < len; i++) {
861 [ + + ]: 235011 : PyObject *tmp = PySequence_Fast_GET_ITEM(seq, i);
862 [ + + ]: 235011 : if (!PyLong_Check(tmp)) {
863 [ + + ]: 6 : PyErr_Format(PyExc_ValueError,
864 : : "elements of %s must be integers",
865 : : is_shape ? "shape" : "strides");
866 : 6 : PyMem_Free(dest);
867 : 6 : return NULL;
868 : : }
869 : 235005 : x = PyLong_AsSsize_t(tmp);
870 [ + + ]: 235005 : if (PyErr_Occurred()) {
871 : 6 : PyMem_Free(dest);
872 : 6 : return NULL;
873 : : }
874 [ + + + + ]: 234999 : if (is_shape && x < 0) {
875 : 3 : PyErr_Format(PyExc_ValueError,
876 : : "elements of shape must be integers >= 0");
877 : 3 : PyMem_Free(dest);
878 : 3 : return NULL;
879 : : }
880 : 234996 : dest[i] = x;
881 : : }
882 : :
883 : 150815 : return dest;
884 : : }
885 : :
886 : : static Py_ssize_t *
887 : 156650 : strides_from_shape(const ndbuf_t *ndbuf, int flags)
888 : : {
889 : 156650 : const Py_buffer *base = &ndbuf->base;
890 : : Py_ssize_t *s, i;
891 : :
892 : 156650 : s = PyMem_Malloc(base->ndim * (sizeof *s));
893 [ - + ]: 156650 : if (s == NULL) {
894 : : PyErr_NoMemory();
895 : 0 : return NULL;
896 : : }
897 : :
898 [ + + ]: 156650 : if (flags & ND_FORTRAN) {
899 : 50161 : s[0] = base->itemsize;
900 [ + + ]: 85539 : for (i = 1; i < base->ndim; i++)
901 : 35378 : s[i] = s[i-1] * base->shape[i-1];
902 : : }
903 : : else {
904 : 106489 : s[base->ndim-1] = base->itemsize;
905 [ + + ]: 158885 : for (i = base->ndim-2; i >= 0; i--)
906 : 52396 : s[i] = s[i+1] * base->shape[i+1];
907 : : }
908 : :
909 : 156650 : return s;
910 : : }
911 : :
912 : : /* Bounds check:
913 : :
914 : : len := complete length of allocated memory
915 : : offset := start of the array
916 : :
917 : : A single array element is indexed by:
918 : :
919 : : i = indices[0] * strides[0] + indices[1] * strides[1] + ...
920 : :
921 : : imin is reached when all indices[n] combined with positive strides are 0
922 : : and all indices combined with negative strides are shape[n]-1, which is
923 : : the maximum index for the nth dimension.
924 : :
925 : : imax is reached when all indices[n] combined with negative strides are 0
926 : : and all indices combined with positive strides are shape[n]-1.
927 : : */
928 : : static int
929 : 147713 : verify_structure(Py_ssize_t len, Py_ssize_t itemsize, Py_ssize_t offset,
930 : : const Py_ssize_t *shape, const Py_ssize_t *strides,
931 : : Py_ssize_t ndim)
932 : : {
933 : : Py_ssize_t imin, imax;
934 : : Py_ssize_t n;
935 : :
936 : : assert(ndim >= 0);
937 : :
938 [ - + - - : 147713 : if (ndim == 0 && (offset < 0 || offset+itemsize > len))
- - ]
939 : 0 : goto invalid_combination;
940 : :
941 [ + + ]: 378283 : for (n = 0; n < ndim; n++)
942 [ + + ]: 230573 : if (strides[n] % itemsize) {
943 : 3 : PyErr_SetString(PyExc_ValueError,
944 : : "strides must be a multiple of itemsize");
945 : 3 : return -1;
946 : : }
947 : :
948 [ + + ]: 378212 : for (n = 0; n < ndim; n++)
949 [ + + ]: 230543 : if (shape[n] == 0)
950 : 41 : return 0;
951 : :
952 : 147669 : imin = imax = 0;
953 [ + + ]: 378142 : for (n = 0; n < ndim; n++)
954 [ + + ]: 230473 : if (strides[n] <= 0)
955 : 1986 : imin += (shape[n]-1) * strides[n];
956 : : else
957 : 228487 : imax += (shape[n]-1) * strides[n];
958 : :
959 [ + + + + ]: 147669 : if (imin + offset < 0 || imax + offset + itemsize > len)
960 : 50 : goto invalid_combination;
961 : :
962 : 147619 : return 0;
963 : :
964 : :
965 : 50 : invalid_combination:
966 : 50 : PyErr_SetString(PyExc_ValueError,
967 : : "invalid combination of buffer, shape and strides");
968 : 50 : return -1;
969 : : }
970 : :
971 : : /*
972 : : Convert a NumPy-style array to an array using suboffsets to stride in
973 : : the first dimension. Requirements: ndim > 0.
974 : :
975 : : Contiguous example
976 : : ==================
977 : :
978 : : Input:
979 : : ------
980 : : shape = {2, 2, 3};
981 : : strides = {6, 3, 1};
982 : : suboffsets = NULL;
983 : : data = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
984 : : buf = &data[0]
985 : :
986 : : Output:
987 : : -------
988 : : shape = {2, 2, 3};
989 : : strides = {sizeof(char *), 3, 1};
990 : : suboffsets = {0, -1, -1};
991 : : data = {p1, p2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
992 : : | | ^ ^
993 : : `---'---' |
994 : : | |
995 : : `---------------------'
996 : : buf = &data[0]
997 : :
998 : : So, in the example the input resembles the three-dimensional array
999 : : char v[2][2][3], while the output resembles an array of two pointers
1000 : : to two-dimensional arrays: char (*v[2])[2][3].
1001 : :
1002 : :
1003 : : Non-contiguous example:
1004 : : =======================
1005 : :
1006 : : Input (with offset and negative strides):
1007 : : -----------------------------------------
1008 : : shape = {2, 2, 3};
1009 : : strides = {-6, 3, -1};
1010 : : offset = 8
1011 : : suboffsets = NULL;
1012 : : data = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
1013 : :
1014 : : Output:
1015 : : -------
1016 : : shape = {2, 2, 3};
1017 : : strides = {-sizeof(char *), 3, -1};
1018 : : suboffsets = {2, -1, -1};
1019 : : newdata = {p1, p2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
1020 : : | | ^ ^ ^ ^
1021 : : `---'---' | | `- p2+suboffsets[0]
1022 : : | `-----------|--- p1+suboffsets[0]
1023 : : `---------------------'
1024 : : buf = &newdata[1] # striding backwards over the pointers.
1025 : :
1026 : : suboffsets[0] is the same as the offset that one would specify if
1027 : : the two {2, 3} subarrays were created directly, hence the name.
1028 : : */
1029 : : static int
1030 : 6182 : init_suboffsets(ndbuf_t *ndbuf)
1031 : : {
1032 : 6182 : Py_buffer *base = &ndbuf->base;
1033 : : Py_ssize_t start, step;
1034 : : Py_ssize_t imin, suboffset0;
1035 : : Py_ssize_t addsize;
1036 : : Py_ssize_t n;
1037 : : char *data;
1038 : :
1039 : : assert(base->ndim > 0);
1040 : : assert(base->suboffsets == NULL);
1041 : :
1042 : : /* Allocate new data with additional space for shape[0] pointers. */
1043 : 6182 : addsize = base->shape[0] * (sizeof (char *));
1044 : :
1045 : : /* Align array start to a multiple of 8. */
1046 : 6182 : addsize = 8 * ((addsize + 7) / 8);
1047 : :
1048 : 6182 : data = PyMem_Malloc(ndbuf->len + addsize);
1049 [ - + ]: 6182 : if (data == NULL) {
1050 : : PyErr_NoMemory();
1051 : 0 : return -1;
1052 : : }
1053 : :
1054 : 6182 : memcpy(data + addsize, ndbuf->data, ndbuf->len);
1055 : :
1056 : 6182 : PyMem_Free(ndbuf->data);
1057 : 6182 : ndbuf->data = data;
1058 : 6182 : ndbuf->len += addsize;
1059 : 6182 : base->buf = ndbuf->data;
1060 : :
1061 : : /* imin: minimum index of the input array relative to ndbuf->offset.
1062 : : suboffset0: offset for each sub-array of the output. This is the
1063 : : same as calculating -imin' for a sub-array of ndim-1. */
1064 : 6182 : imin = suboffset0 = 0;
1065 [ + + ]: 12953 : for (n = 0; n < base->ndim; n++) {
1066 [ + + ]: 6783 : if (base->shape[n] == 0)
1067 : 12 : break;
1068 [ + + ]: 6771 : if (base->strides[n] <= 0) {
1069 : 960 : Py_ssize_t x = (base->shape[n]-1) * base->strides[n];
1070 : 960 : imin += x;
1071 [ + + ]: 960 : suboffset0 += (n >= 1) ? -x : 0;
1072 : : }
1073 : : }
1074 : :
1075 : : /* Initialize the array of pointers to the sub-arrays. */
1076 : 6182 : start = addsize + ndbuf->offset + imin;
1077 : 6182 : step = base->strides[0] < 0 ? -base->strides[0] : base->strides[0];
1078 : :
1079 [ + + ]: 42416 : for (n = 0; n < base->shape[0]; n++)
1080 : 36234 : ((char **)base->buf)[n] = (char *)base->buf + start + n*step;
1081 : :
1082 : : /* Initialize suboffsets. */
1083 : 6182 : base->suboffsets = PyMem_Malloc(base->ndim * (sizeof *base->suboffsets));
1084 [ - + ]: 6182 : if (base->suboffsets == NULL) {
1085 : : PyErr_NoMemory();
1086 : 0 : return -1;
1087 : : }
1088 : 6182 : base->suboffsets[0] = suboffset0;
1089 [ + + ]: 6789 : for (n = 1; n < base->ndim; n++)
1090 : 607 : base->suboffsets[n] = -1;
1091 : :
1092 : : /* Adjust strides for the first (zeroth) dimension. */
1093 [ + + ]: 6182 : if (base->strides[0] >= 0) {
1094 : 5481 : base->strides[0] = sizeof(char *);
1095 : : }
1096 : : else {
1097 : : /* Striding backwards. */
1098 : 701 : base->strides[0] = -(Py_ssize_t)sizeof(char *);
1099 [ + + ]: 701 : if (base->shape[0] > 0)
1100 : 699 : base->buf = (char *)base->buf + (base->shape[0]-1) * sizeof(char *);
1101 : : }
1102 : :
1103 : 6182 : ndbuf->flags &= ~(ND_C|ND_FORTRAN);
1104 : 6182 : ndbuf->offset = 0;
1105 : 6182 : return 0;
1106 : : }
1107 : :
1108 : : static void
1109 : 157984 : init_len(Py_buffer *base)
1110 : : {
1111 : : Py_ssize_t i;
1112 : :
1113 : 157984 : base->len = 1;
1114 [ + + ]: 399864 : for (i = 0; i < base->ndim; i++)
1115 : 241880 : base->len *= base->shape[i];
1116 : 157984 : base->len *= base->itemsize;
1117 : 157984 : }
1118 : :
1119 : : static int
1120 : 149802 : init_structure(ndbuf_t *ndbuf, PyObject *shape, PyObject *strides,
1121 : : Py_ssize_t ndim)
1122 : : {
1123 : 149802 : Py_buffer *base = &ndbuf->base;
1124 : :
1125 : 149802 : base->ndim = (int)ndim;
1126 [ + + ]: 149802 : if (ndim == 0) {
1127 [ + + ]: 2074 : if (ndbuf->flags & ND_PIL) {
1128 : 3 : PyErr_SetString(PyExc_TypeError,
1129 : : "ndim = 0 cannot be used in conjunction with ND_PIL");
1130 : 3 : return -1;
1131 : : }
1132 : 2071 : ndbuf->flags |= (ND_SCALAR|ND_C|ND_FORTRAN);
1133 : 2071 : return 0;
1134 : : }
1135 : :
1136 : : /* shape */
1137 : 147728 : base->shape = seq_as_ssize_array(shape, ndim, 1);
1138 [ + + ]: 147728 : if (base->shape == NULL)
1139 : 9 : return -1;
1140 : :
1141 : : /* strides */
1142 [ + + ]: 147719 : if (strides) {
1143 : 3102 : base->strides = seq_as_ssize_array(strides, ndim, 0);
1144 : : }
1145 : : else {
1146 : 144617 : base->strides = strides_from_shape(ndbuf, ndbuf->flags);
1147 : : }
1148 [ + + ]: 147719 : if (base->strides == NULL)
1149 : 6 : return -1;
1150 [ + + ]: 147713 : if (verify_structure(base->len, base->itemsize, ndbuf->offset,
1151 : 147713 : base->shape, base->strides, ndim) < 0)
1152 : 53 : return -1;
1153 : :
1154 : : /* buf */
1155 : 147660 : base->buf = ndbuf->data + ndbuf->offset;
1156 : :
1157 : : /* len */
1158 : 147660 : init_len(base);
1159 : :
1160 : : /* ndbuf->flags */
1161 [ + + ]: 147660 : if (PyBuffer_IsContiguous(base, 'C'))
1162 : 133525 : ndbuf->flags |= ND_C;
1163 [ + + ]: 147660 : if (PyBuffer_IsContiguous(base, 'F'))
1164 : 122230 : ndbuf->flags |= ND_FORTRAN;
1165 : :
1166 : :
1167 : : /* convert numpy array to suboffset representation */
1168 [ + + ]: 147660 : if (ndbuf->flags & ND_PIL) {
1169 : : /* modifies base->buf, base->strides and base->suboffsets **/
1170 : 6182 : return init_suboffsets(ndbuf);
1171 : : }
1172 : :
1173 : 141478 : return 0;
1174 : : }
1175 : :
1176 : : static ndbuf_t *
1177 : 149973 : init_ndbuf(PyObject *items, PyObject *shape, PyObject *strides,
1178 : : Py_ssize_t offset, PyObject *format, int flags)
1179 : : {
1180 : : ndbuf_t *ndbuf;
1181 : : Py_ssize_t ndim;
1182 : : Py_ssize_t nitems;
1183 : : Py_ssize_t itemsize;
1184 : :
1185 : : /* ndim = len(shape) */
1186 [ + + + + ]: 149973 : CHECK_LIST_OR_TUPLE(shape)
1187 [ + + ]: 149970 : ndim = PySequence_Fast_GET_SIZE(shape);
1188 [ + + ]: 149970 : if (ndim > ND_MAX_NDIM) {
1189 : 3 : PyErr_Format(PyExc_ValueError,
1190 : : "ndim must not exceed %d", ND_MAX_NDIM);
1191 : 3 : return NULL;
1192 : : }
1193 : :
1194 : : /* len(strides) = len(shape) */
1195 [ + + ]: 149967 : if (strides) {
1196 [ + + + + ]: 3356 : CHECK_LIST_OR_TUPLE(strides)
1197 [ + + + + ]: 3353 : if (PySequence_Fast_GET_SIZE(strides) == 0)
1198 : 161 : strides = NULL;
1199 [ + + ]: 3192 : else if (flags & ND_FORTRAN) {
1200 : 3 : PyErr_SetString(PyExc_TypeError,
1201 : : "ND_FORTRAN cannot be used together with strides");
1202 : 3 : return NULL;
1203 : : }
1204 [ + + + + ]: 3189 : else if (PySequence_Fast_GET_SIZE(strides) != ndim) {
1205 : 3 : PyErr_SetString(PyExc_ValueError,
1206 : : "len(shape) != len(strides)");
1207 : 3 : return NULL;
1208 : : }
1209 : : }
1210 : :
1211 : : /* itemsize */
1212 : 149958 : itemsize = get_itemsize(format);
1213 [ + + ]: 149958 : if (itemsize <= 0) {
1214 [ + + ]: 9 : if (itemsize == 0) {
1215 : 3 : PyErr_SetString(PyExc_ValueError,
1216 : : "itemsize must not be zero");
1217 : : }
1218 : 9 : return NULL;
1219 : : }
1220 : :
1221 : : /* convert scalar to list */
1222 [ + + ]: 149949 : if (ndim == 0) {
1223 : 2116 : items = Py_BuildValue("(O)", items);
1224 [ - + ]: 2116 : if (items == NULL)
1225 : 0 : return NULL;
1226 : : }
1227 : : else {
1228 [ + + + + ]: 147833 : CHECK_LIST_OR_TUPLE(items)
1229 : 147830 : Py_INCREF(items);
1230 : : }
1231 : :
1232 : : /* number of items */
1233 [ + + ]: 149946 : nitems = PySequence_Fast_GET_SIZE(items);
1234 [ + + ]: 149946 : if (nitems == 0) {
1235 : 3 : PyErr_SetString(PyExc_ValueError,
1236 : : "initializer list or tuple must not be empty");
1237 : 3 : Py_DECREF(items);
1238 : 3 : return NULL;
1239 : : }
1240 : :
1241 : 149943 : ndbuf = ndbuf_new(nitems, itemsize, offset, flags);
1242 [ + + ]: 149943 : if (ndbuf == NULL) {
1243 : 129 : Py_DECREF(items);
1244 : 129 : return NULL;
1245 : : }
1246 : :
1247 : :
1248 [ + + ]: 149814 : if (init_simple(ndbuf, items, format, itemsize) < 0)
1249 : 12 : goto error;
1250 [ + + ]: 149802 : if (init_structure(ndbuf, shape, strides, ndim) < 0)
1251 : 71 : goto error;
1252 : :
1253 : 149731 : Py_DECREF(items);
1254 : 149731 : return ndbuf;
1255 : :
1256 : 83 : error:
1257 : 83 : Py_DECREF(items);
1258 : 83 : ndbuf_free(ndbuf);
1259 : 83 : return NULL;
1260 : : }
1261 : :
1262 : : /* initialize and push a new base onto the linked list */
1263 : : static int
1264 : 149973 : ndarray_push_base(NDArrayObject *nd, PyObject *items,
1265 : : PyObject *shape, PyObject *strides,
1266 : : Py_ssize_t offset, PyObject *format, int flags)
1267 : : {
1268 : : ndbuf_t *ndbuf;
1269 : :
1270 : 149973 : ndbuf = init_ndbuf(items, shape, strides, offset, format, flags);
1271 [ + + ]: 149973 : if (ndbuf == NULL)
1272 : 242 : return -1;
1273 : :
1274 : 149731 : ndbuf_push(nd, ndbuf);
1275 : 149731 : return 0;
1276 : : }
1277 : :
1278 : : #define PyBUF_UNUSED 0x10000
1279 : : static int
1280 : 192394 : ndarray_init(PyObject *self, PyObject *args, PyObject *kwds)
1281 : : {
1282 : 192394 : NDArrayObject *nd = (NDArrayObject *)self;
1283 : : static char *kwlist[] = {
1284 : : "obj", "shape", "strides", "offset", "format", "flags", "getbuf", NULL
1285 : : };
1286 : 192394 : PyObject *v = NULL; /* initializer: scalar, list, tuple or base object */
1287 : 192394 : PyObject *shape = NULL; /* size of each dimension */
1288 : 192394 : PyObject *strides = NULL; /* number of bytes to the next elt in each dim */
1289 : 192394 : Py_ssize_t offset = 0; /* buffer offset */
1290 : 192394 : PyObject *format = simple_format; /* struct module specifier: "B" */
1291 : 192394 : int flags = ND_DEFAULT; /* base buffer and ndarray flags */
1292 : :
1293 : 192394 : int getbuf = PyBUF_UNUSED; /* re-exporter: getbuffer request flags */
1294 : :
1295 : :
1296 [ + + ]: 192394 : if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OOnOii", kwlist,
1297 : : &v, &shape, &strides, &offset, &format, &flags, &getbuf))
1298 : 3 : return -1;
1299 : :
1300 : : /* NDArrayObject is re-exporter */
1301 [ + + + + ]: 192391 : if (PyObject_CheckBuffer(v) && shape == NULL) {
1302 [ + - + - : 42467 : if (strides || offset || format != simple_format ||
+ + ]
1303 [ + + - + ]: 42466 : !(flags == ND_DEFAULT || flags == ND_REDIRECT)) {
1304 : 1 : PyErr_SetString(PyExc_TypeError,
1305 : : "construction from exporter object only takes 'obj', 'getbuf' "
1306 : : "and 'flags' arguments");
1307 : 1 : return -1;
1308 : : }
1309 : :
1310 [ + + ]: 42466 : getbuf = (getbuf == PyBUF_UNUSED) ? PyBUF_FULL_RO : getbuf;
1311 : :
1312 [ + + ]: 42466 : if (ndarray_init_staticbuf(v, nd, getbuf) < 0)
1313 : 28201 : return -1;
1314 : :
1315 : 14265 : init_flags(nd->head);
1316 : 14265 : nd->head->flags |= flags;
1317 : :
1318 : 14265 : return 0;
1319 : : }
1320 : :
1321 : : /* NDArrayObject is the original base object. */
1322 [ + + ]: 149924 : if (getbuf != PyBUF_UNUSED) {
1323 : 1 : PyErr_SetString(PyExc_TypeError,
1324 : : "getbuf argument only valid for construction from exporter "
1325 : : "object");
1326 : 1 : return -1;
1327 : : }
1328 [ + + ]: 149923 : if (shape == NULL) {
1329 : 4 : PyErr_SetString(PyExc_TypeError,
1330 : : "shape is a required argument when constructing from "
1331 : : "list, tuple or scalar");
1332 : 4 : return -1;
1333 : : }
1334 : :
1335 [ + + ]: 149919 : if (flags & ND_VAREXPORT) {
1336 : 4 : nd->flags |= ND_VAREXPORT;
1337 : 4 : flags &= ~ND_VAREXPORT;
1338 : : }
1339 : :
1340 : : /* Initialize and push the first base buffer onto the linked list. */
1341 : 149919 : return ndarray_push_base(nd, v, shape, strides, offset, format, flags);
1342 : : }
1343 : :
1344 : : /* Push an additional base onto the linked list. */
1345 : : static PyObject *
1346 : 75 : ndarray_push(PyObject *self, PyObject *args, PyObject *kwds)
1347 : : {
1348 : 75 : NDArrayObject *nd = (NDArrayObject *)self;
1349 : : static char *kwlist[] = {
1350 : : "items", "shape", "strides", "offset", "format", "flags", NULL
1351 : : };
1352 : 75 : PyObject *items = NULL; /* initializer: scalar, list or tuple */
1353 : 75 : PyObject *shape = NULL; /* size of each dimension */
1354 : 75 : PyObject *strides = NULL; /* number of bytes to the next elt in each dim */
1355 : 75 : PyObject *format = simple_format; /* struct module specifier: "B" */
1356 : 75 : Py_ssize_t offset = 0; /* buffer offset */
1357 : 75 : int flags = ND_DEFAULT; /* base buffer flags */
1358 : :
1359 [ + + ]: 75 : if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO|OnOi", kwlist,
1360 : : &items, &shape, &strides, &offset, &format, &flags))
1361 : 18 : return NULL;
1362 : :
1363 [ + + ]: 57 : if (flags & ND_VAREXPORT) {
1364 : 1 : PyErr_SetString(PyExc_ValueError,
1365 : : "ND_VAREXPORT flag can only be used during object creation");
1366 : 1 : return NULL;
1367 : : }
1368 [ + + ]: 56 : if (ND_IS_CONSUMER(nd)) {
1369 : 1 : PyErr_SetString(PyExc_BufferError,
1370 : : "structure of re-exporting object is immutable");
1371 : 1 : return NULL;
1372 : : }
1373 [ + + + + ]: 55 : if (!(nd->flags&ND_VAREXPORT) && nd->head->exports > 0) {
1374 : 1 : PyErr_Format(PyExc_BufferError,
1375 : : "cannot change structure: %zd exported buffer%s",
1376 [ + - ]: 2 : nd->head->exports, nd->head->exports==1 ? "" : "s");
1377 : 1 : return NULL;
1378 : : }
1379 : :
1380 [ + + ]: 54 : if (ndarray_push_base(nd, items, shape, strides,
1381 : : offset, format, flags) < 0)
1382 : 48 : return NULL;
1383 : 6 : Py_RETURN_NONE;
1384 : : }
1385 : :
1386 : : /* Pop a base from the linked list (if possible). */
1387 : : static PyObject *
1388 : 6 : ndarray_pop(PyObject *self, PyObject *dummy)
1389 : : {
1390 : 6 : NDArrayObject *nd = (NDArrayObject *)self;
1391 [ + + ]: 6 : if (ND_IS_CONSUMER(nd)) {
1392 : 1 : PyErr_SetString(PyExc_BufferError,
1393 : : "structure of re-exporting object is immutable");
1394 : 1 : return NULL;
1395 : : }
1396 [ + + ]: 5 : if (nd->head->exports > 0) {
1397 : 1 : PyErr_Format(PyExc_BufferError,
1398 : : "cannot change structure: %zd exported buffer%s",
1399 [ + - ]: 2 : nd->head->exports, nd->head->exports==1 ? "" : "s");
1400 : 1 : return NULL;
1401 : : }
1402 [ + + ]: 4 : if (nd->head->next == NULL) {
1403 : 2 : PyErr_SetString(PyExc_BufferError,
1404 : : "list only has a single base");
1405 : 2 : return NULL;
1406 : : }
1407 : :
1408 : 2 : ndbuf_pop(nd);
1409 : 2 : Py_RETURN_NONE;
1410 : : }
1411 : :
1412 : : /**************************************************************************/
1413 : : /* getbuffer */
1414 : : /**************************************************************************/
1415 : :
1416 : : static int
1417 : 678565 : ndarray_getbuf(NDArrayObject *self, Py_buffer *view, int flags)
1418 : : {
1419 : 678565 : ndbuf_t *ndbuf = self->head;
1420 : 678565 : Py_buffer *base = &ndbuf->base;
1421 : 678565 : int baseflags = ndbuf->flags;
1422 : :
1423 : : /* redirect mode */
1424 [ + + + + ]: 678565 : if (base->obj != NULL && (baseflags&ND_REDIRECT)) {
1425 : 23 : return PyObject_GetBuffer(base->obj, view, flags);
1426 : : }
1427 : :
1428 : : /* start with complete information */
1429 : 678542 : *view = *base;
1430 : 678542 : view->obj = NULL;
1431 : :
1432 : : /* reconstruct format */
1433 [ + + ]: 678542 : if (view->format == NULL)
1434 : 11 : view->format = "B";
1435 : :
1436 [ + + ]: 678542 : if (base->ndim != 0 &&
1437 [ + + + + ]: 668019 : ((REQ_SHAPE(flags) && base->shape == NULL) ||
1438 [ + + + + ]: 668013 : (REQ_STRIDES(flags) && base->strides == NULL))) {
1439 : : /* The ndarray is a re-exporter that has been created without full
1440 : : information for testing purposes. In this particular case the
1441 : : ndarray is not a PEP-3118 compliant buffer provider. */
1442 : 1046 : PyErr_SetString(PyExc_BufferError,
1443 : : "re-exporter does not provide format, shape or strides");
1444 : 1046 : return -1;
1445 : : }
1446 : :
1447 [ + + ]: 677496 : if (baseflags & ND_GETBUF_FAIL) {
1448 : 3 : PyErr_SetString(PyExc_BufferError,
1449 : : "ND_GETBUF_FAIL: forced test exception");
1450 [ + + ]: 3 : if (baseflags & ND_GETBUF_UNDEFINED)
1451 : 1 : view->obj = (PyObject *)0x1; /* wrong but permitted in <= 3.2 */
1452 : 3 : return -1;
1453 : : }
1454 : :
1455 [ + + + + ]: 677493 : if (REQ_WRITABLE(flags) && base->readonly) {
1456 : 6689 : PyErr_SetString(PyExc_BufferError,
1457 : : "ndarray is not writable");
1458 : 6689 : return -1;
1459 : : }
1460 [ + + ]: 670804 : if (!REQ_FORMAT(flags)) {
1461 : : /* NULL indicates that the buffer's data type has been cast to 'B'.
1462 : : view->itemsize is the _previous_ itemsize. If shape is present,
1463 : : the equality product(shape) * itemsize = len still holds at this
1464 : : point. The equality calcsize(format) = itemsize does _not_ hold
1465 : : from here on! */
1466 : 6569 : view->format = NULL;
1467 : : }
1468 : :
1469 [ + + + + ]: 670804 : if (REQ_C_CONTIGUOUS(flags) && !ND_C_CONTIGUOUS(baseflags)) {
1470 : 816 : PyErr_SetString(PyExc_BufferError,
1471 : : "ndarray is not C-contiguous");
1472 : 816 : return -1;
1473 : : }
1474 [ + + + + ]: 669988 : if (REQ_F_CONTIGUOUS(flags) && !ND_FORTRAN_CONTIGUOUS(baseflags)) {
1475 : 816 : PyErr_SetString(PyExc_BufferError,
1476 : : "ndarray is not Fortran contiguous");
1477 : 816 : return -1;
1478 : : }
1479 [ + + + + ]: 669172 : if (REQ_ANY_CONTIGUOUS(flags) && !ND_ANY_CONTIGUOUS(baseflags)) {
1480 : 792 : PyErr_SetString(PyExc_BufferError,
1481 : : "ndarray is not contiguous");
1482 : 792 : return -1;
1483 : : }
1484 [ + + + + ]: 668380 : if (!REQ_INDIRECT(flags) && (baseflags & ND_PIL)) {
1485 : 3456 : PyErr_SetString(PyExc_BufferError,
1486 : : "ndarray cannot be represented without suboffsets");
1487 : 3456 : return -1;
1488 : : }
1489 [ + + ]: 664924 : if (!REQ_STRIDES(flags)) {
1490 [ + + ]: 3356 : if (!ND_C_CONTIGUOUS(baseflags)) {
1491 : 1426 : PyErr_SetString(PyExc_BufferError,
1492 : : "ndarray is not C-contiguous");
1493 : 1426 : return -1;
1494 : : }
1495 : 1930 : view->strides = NULL;
1496 : : }
1497 [ + + ]: 663498 : if (!REQ_SHAPE(flags)) {
1498 : : /* PyBUF_SIMPLE or PyBUF_WRITABLE: at this point buf is C-contiguous,
1499 : : so base->buf = ndbuf->data. */
1500 [ + + ]: 1109 : if (view->format != NULL) {
1501 : : /* PyBUF_SIMPLE|PyBUF_FORMAT and PyBUF_WRITABLE|PyBUF_FORMAT do
1502 : : not make sense. */
1503 : 120 : PyErr_Format(PyExc_BufferError,
1504 : : "ndarray: cannot cast to unsigned bytes if the format flag "
1505 : : "is present");
1506 : 120 : return -1;
1507 : : }
1508 : : /* product(shape) * itemsize = len and calcsize(format) = itemsize
1509 : : do _not_ hold from here on! */
1510 : 989 : view->ndim = 1;
1511 : 989 : view->shape = NULL;
1512 : : }
1513 : :
1514 : : /* Ascertain that the new buffer has the same contiguity as the exporter */
1515 [ + - ]: 663378 : if (ND_C_CONTIGUOUS(baseflags) != PyBuffer_IsContiguous(view, 'C') ||
1516 : : /* skip cast to 1-d */
1517 [ + + + + : 1313567 : (view->format != NULL && view->shape != NULL &&
+ - ]
1518 : 650189 : ND_FORTRAN_CONTIGUOUS(baseflags) != PyBuffer_IsContiguous(view, 'F')) ||
1519 : : /* cast to 1-d */
1520 [ + + + + : 664612 : (view->format == NULL && view->shape == NULL &&
- + ]
1521 : 1234 : !PyBuffer_IsContiguous(view, 'F'))) {
1522 : 0 : PyErr_SetString(PyExc_BufferError,
1523 : : "ndarray: contiguity mismatch in getbuf()");
1524 : 0 : return -1;
1525 : : }
1526 : :
1527 : 663378 : view->obj = (PyObject *)self;
1528 : 663378 : Py_INCREF(view->obj);
1529 : 663378 : self->head->exports++;
1530 : :
1531 : 663378 : return 0;
1532 : : }
1533 : :
1534 : : static void
1535 : 663378 : ndarray_releasebuf(NDArrayObject *self, Py_buffer *view)
1536 : : {
1537 [ + + ]: 663378 : if (!ND_IS_CONSUMER(self)) {
1538 : 252336 : ndbuf_t *ndbuf = view->internal;
1539 [ + + + + ]: 252336 : if (--ndbuf->exports == 0 && ndbuf != self->head)
1540 : 4 : ndbuf_delete(self, ndbuf);
1541 : : }
1542 : 663378 : }
1543 : :
1544 : : static PyBufferProcs ndarray_as_buffer = {
1545 : : (getbufferproc)ndarray_getbuf, /* bf_getbuffer */
1546 : : (releasebufferproc)ndarray_releasebuf /* bf_releasebuffer */
1547 : : };
1548 : :
1549 : :
1550 : : /**************************************************************************/
1551 : : /* indexing/slicing */
1552 : : /**************************************************************************/
1553 : :
1554 : : static char *
1555 : 8421 : ptr_from_index(Py_buffer *base, Py_ssize_t index)
1556 : : {
1557 : : char *ptr;
1558 : : Py_ssize_t nitems; /* items in the first dimension */
1559 : :
1560 [ + + ]: 8421 : if (base->shape)
1561 : 8411 : nitems = base->shape[0];
1562 : : else {
1563 : : assert(base->ndim == 1 && SIMPLE_FORMAT(base->format));
1564 : 10 : nitems = base->len;
1565 : : }
1566 : :
1567 [ + + ]: 8421 : if (index < 0) {
1568 : 2910 : index += nitems;
1569 : : }
1570 [ + + + + ]: 8421 : if (index < 0 || index >= nitems) {
1571 : 455 : PyErr_SetString(PyExc_IndexError, "index out of bounds");
1572 : 455 : return NULL;
1573 : : }
1574 : :
1575 : 7966 : ptr = (char *)base->buf;
1576 : :
1577 [ + + ]: 7966 : if (base->strides == NULL)
1578 : 931 : ptr += base->itemsize * index;
1579 : : else
1580 : 7035 : ptr += base->strides[0] * index;
1581 : :
1582 [ + + + + ]: 7966 : ptr = ADJUST_PTR(ptr, base->suboffsets);
1583 : :
1584 : 7966 : return ptr;
1585 : : }
1586 : :
1587 : : static PyObject *
1588 : 6949 : ndarray_item(NDArrayObject *self, Py_ssize_t index)
1589 : : {
1590 : 6949 : ndbuf_t *ndbuf = self->head;
1591 : 6949 : Py_buffer *base = &ndbuf->base;
1592 : : char *ptr;
1593 : :
1594 [ + + ]: 6949 : if (base->ndim == 0) {
1595 : 1 : PyErr_SetString(PyExc_TypeError, "invalid indexing of scalar");
1596 : 1 : return NULL;
1597 : : }
1598 : :
1599 : 6948 : ptr = ptr_from_index(base, index);
1600 [ + + ]: 6948 : if (ptr == NULL)
1601 : 273 : return NULL;
1602 : :
1603 [ + + ]: 6675 : if (base->ndim == 1) {
1604 : 5154 : return unpack_single(ptr, base->format, base->itemsize);
1605 : : }
1606 : : else {
1607 : : NDArrayObject *nd;
1608 : : Py_buffer *subview;
1609 : :
1610 : 1521 : nd = (NDArrayObject *)ndarray_new(&NDArray_Type, NULL, NULL);
1611 [ - + ]: 1521 : if (nd == NULL)
1612 : 0 : return NULL;
1613 : :
1614 [ + + ]: 1521 : if (ndarray_init_staticbuf((PyObject *)self, nd, PyBUF_FULL_RO) < 0) {
1615 : 1 : Py_DECREF(nd);
1616 : 1 : return NULL;
1617 : : }
1618 : :
1619 : 1520 : subview = &nd->staticbuf.base;
1620 : :
1621 : 1520 : subview->buf = ptr;
1622 : 1520 : subview->len /= subview->shape[0];
1623 : :
1624 : 1520 : subview->ndim--;
1625 : 1520 : subview->shape++;
1626 [ + - ]: 1520 : if (subview->strides) subview->strides++;
1627 [ + + ]: 1520 : if (subview->suboffsets) subview->suboffsets++;
1628 : :
1629 : 1520 : init_flags(&nd->staticbuf);
1630 : :
1631 : 1520 : return (PyObject *)nd;
1632 : : }
1633 : : }
1634 : :
1635 : : /*
1636 : : For each dimension, we get valid (start, stop, step, slicelength) quadruples
1637 : : from PySlice_GetIndicesEx().
1638 : :
1639 : : Slicing NumPy arrays
1640 : : ====================
1641 : :
1642 : : A pointer to an element in a NumPy array is defined by:
1643 : :
1644 : : ptr = (char *)buf + indices[0] * strides[0] +
1645 : : ... +
1646 : : indices[ndim-1] * strides[ndim-1]
1647 : :
1648 : : Adjust buf:
1649 : : -----------
1650 : : Adding start[n] for each dimension effectively adds the constant:
1651 : :
1652 : : c = start[0] * strides[0] + ... + start[ndim-1] * strides[ndim-1]
1653 : :
1654 : : Therefore init_slice() adds all start[n] directly to buf.
1655 : :
1656 : : Adjust shape:
1657 : : -------------
1658 : : Obviously shape[n] = slicelength[n]
1659 : :
1660 : : Adjust strides:
1661 : : ---------------
1662 : : In the original array, the next element in a dimension is reached
1663 : : by adding strides[n] to the pointer. In the sliced array, elements
1664 : : may be skipped, so the next element is reached by adding:
1665 : :
1666 : : strides[n] * step[n]
1667 : :
1668 : : Slicing PIL arrays
1669 : : ==================
1670 : :
1671 : : Layout:
1672 : : -------
1673 : : In the first (zeroth) dimension, PIL arrays have an array of pointers
1674 : : to sub-arrays of ndim-1. Striding in the first dimension is done by
1675 : : getting the index of the nth pointer, dereference it and then add a
1676 : : suboffset to it. The arrays pointed to can best be seen a regular
1677 : : NumPy arrays.
1678 : :
1679 : : Adjust buf:
1680 : : -----------
1681 : : In the original array, buf points to a location (usually the start)
1682 : : in the array of pointers. For the sliced array, start[0] can be
1683 : : added to buf in the same manner as for NumPy arrays.
1684 : :
1685 : : Adjust suboffsets:
1686 : : ------------------
1687 : : Due to the dereferencing step in the addressing scheme, it is not
1688 : : possible to adjust buf for higher dimensions. Recall that the
1689 : : sub-arrays pointed to are regular NumPy arrays, so for each of
1690 : : those arrays adding start[n] effectively adds the constant:
1691 : :
1692 : : c = start[1] * strides[1] + ... + start[ndim-1] * strides[ndim-1]
1693 : :
1694 : : This constant is added to suboffsets[0]. suboffsets[0] in turn is
1695 : : added to each pointer right after dereferencing.
1696 : :
1697 : : Adjust shape and strides:
1698 : : -------------------------
1699 : : Shape and strides are not influenced by the dereferencing step, so
1700 : : they are adjusted in the same manner as for NumPy arrays.
1701 : :
1702 : : Multiple levels of suboffsets
1703 : : =============================
1704 : :
1705 : : For a construct like an array of pointers to array of pointers to
1706 : : sub-arrays of ndim-2:
1707 : :
1708 : : suboffsets[0] = start[1] * strides[1]
1709 : : suboffsets[1] = start[2] * strides[2] + ...
1710 : : */
1711 : : static int
1712 : 11170 : init_slice(Py_buffer *base, PyObject *key, int dim)
1713 : : {
1714 : : Py_ssize_t start, stop, step, slicelength;
1715 : :
1716 [ + + ]: 11170 : if (PySlice_Unpack(key, &start, &stop, &step) < 0) {
1717 : 6 : return -1;
1718 : : }
1719 : 11164 : slicelength = PySlice_AdjustIndices(base->shape[dim], &start, &stop, step);
1720 : :
1721 : :
1722 [ + + + + ]: 11164 : if (base->suboffsets == NULL || dim == 0) {
1723 : 10733 : adjust_buf:
1724 : 10763 : base->buf = (char *)base->buf + base->strides[dim] * start;
1725 : : }
1726 : : else {
1727 : 431 : Py_ssize_t n = dim-1;
1728 [ + + + + ]: 626 : while (n >= 0 && base->suboffsets[n] < 0)
1729 : 195 : n--;
1730 [ + + ]: 431 : if (n < 0)
1731 : 30 : goto adjust_buf; /* all suboffsets are negative */
1732 : 401 : base->suboffsets[n] = base->suboffsets[n] + base->strides[dim] * start;
1733 : : }
1734 : 11164 : base->shape[dim] = slicelength;
1735 : 11164 : base->strides[dim] = base->strides[dim] * step;
1736 : :
1737 : 11164 : return 0;
1738 : : }
1739 : :
1740 : : static int
1741 : 10333 : copy_structure(Py_buffer *base)
1742 : : {
1743 : 10333 : Py_ssize_t *shape = NULL, *strides = NULL, *suboffsets = NULL;
1744 : : Py_ssize_t i;
1745 : :
1746 : 10333 : shape = PyMem_Malloc(base->ndim * (sizeof *shape));
1747 : 10333 : strides = PyMem_Malloc(base->ndim * (sizeof *strides));
1748 [ + - - + ]: 10333 : if (shape == NULL || strides == NULL)
1749 : 0 : goto err_nomem;
1750 : :
1751 : 10333 : suboffsets = NULL;
1752 [ + + ]: 10333 : if (base->suboffsets) {
1753 : 5143 : suboffsets = PyMem_Malloc(base->ndim * (sizeof *suboffsets));
1754 [ - + ]: 5143 : if (suboffsets == NULL)
1755 : 0 : goto err_nomem;
1756 : : }
1757 : :
1758 [ + + ]: 21776 : for (i = 0; i < base->ndim; i++) {
1759 : 11443 : shape[i] = base->shape[i];
1760 : 11443 : strides[i] = base->strides[i];
1761 [ + + ]: 11443 : if (suboffsets)
1762 : 5633 : suboffsets[i] = base->suboffsets[i];
1763 : : }
1764 : :
1765 : 10333 : base->shape = shape;
1766 : 10333 : base->strides = strides;
1767 : 10333 : base->suboffsets = suboffsets;
1768 : :
1769 : 10333 : return 0;
1770 : :
1771 : 0 : err_nomem:
1772 : : PyErr_NoMemory();
1773 [ # # ]: 0 : PyMem_XFree(shape);
1774 [ # # ]: 0 : PyMem_XFree(strides);
1775 [ # # ]: 0 : PyMem_XFree(suboffsets);
1776 : 0 : return -1;
1777 : : }
1778 : :
1779 : : static PyObject *
1780 : 15394 : ndarray_subscript(NDArrayObject *self, PyObject *key)
1781 : : {
1782 : : NDArrayObject *nd;
1783 : : ndbuf_t *ndbuf;
1784 : 15394 : Py_buffer *base = &self->head->base;
1785 : :
1786 [ + + ]: 15394 : if (base->ndim == 0) {
1787 [ + + + - ]: 6 : if (PyTuple_Check(key) && PyTuple_GET_SIZE(key) == 0) {
1788 : 4 : return unpack_single(base->buf, base->format, base->itemsize);
1789 : : }
1790 [ + + ]: 2 : else if (key == Py_Ellipsis) {
1791 : 1 : Py_INCREF(self);
1792 : 1 : return (PyObject *)self;
1793 : : }
1794 : : else {
1795 : 1 : PyErr_SetString(PyExc_TypeError, "invalid indexing of scalar");
1796 : 1 : return NULL;
1797 : : }
1798 : : }
1799 [ + + ]: 15388 : if (PyIndex_Check(key)) {
1800 : 5054 : Py_ssize_t index = PyLong_AsSsize_t(key);
1801 [ + + + + ]: 5054 : if (index == -1 && PyErr_Occurred())
1802 : 1 : return NULL;
1803 : 5053 : return ndarray_item(self, index);
1804 : : }
1805 : :
1806 : 10334 : nd = (NDArrayObject *)ndarray_new(&NDArray_Type, NULL, NULL);
1807 [ - + ]: 10334 : if (nd == NULL)
1808 : 0 : return NULL;
1809 : :
1810 : : /* new ndarray is a consumer */
1811 [ + + ]: 10334 : if (ndarray_init_staticbuf((PyObject *)self, nd, PyBUF_FULL_RO) < 0) {
1812 : 1 : Py_DECREF(nd);
1813 : 1 : return NULL;
1814 : : }
1815 : :
1816 : : /* copy shape, strides and suboffsets */
1817 : 10333 : ndbuf = nd->head;
1818 : 10333 : base = &ndbuf->base;
1819 [ - + ]: 10333 : if (copy_structure(base) < 0) {
1820 : 0 : Py_DECREF(nd);
1821 : 0 : return NULL;
1822 : : }
1823 : 10333 : ndbuf->flags |= ND_OWN_ARRAYS;
1824 : :
1825 [ + + ]: 10333 : if (PySlice_Check(key)) {
1826 : : /* one-dimensional slice */
1827 [ + + ]: 9549 : if (init_slice(base, key, 0) < 0)
1828 : 1 : goto err_occurred;
1829 : : }
1830 [ + + ]: 784 : else if (PyTuple_Check(key)) {
1831 : : /* multi-dimensional slice */
1832 : 783 : PyObject *tuple = key;
1833 : : Py_ssize_t i, n;
1834 : :
1835 : 783 : n = PyTuple_GET_SIZE(tuple);
1836 [ + + ]: 2399 : for (i = 0; i < n; i++) {
1837 : 1623 : key = PyTuple_GET_ITEM(tuple, i);
1838 [ + + ]: 1623 : if (!PySlice_Check(key))
1839 : 2 : goto type_error;
1840 [ + + ]: 1621 : if (init_slice(base, key, (int)i) < 0)
1841 : 5 : goto err_occurred;
1842 : : }
1843 : : }
1844 : : else {
1845 : 1 : goto type_error;
1846 : : }
1847 : :
1848 : 10324 : init_len(base);
1849 : 10324 : init_flags(ndbuf);
1850 : :
1851 : 10324 : return (PyObject *)nd;
1852 : :
1853 : :
1854 : 3 : type_error:
1855 : 3 : PyErr_Format(PyExc_TypeError,
1856 : : "cannot index memory using \"%.200s\"",
1857 : 3 : Py_TYPE(key)->tp_name);
1858 : 9 : err_occurred:
1859 : 9 : Py_DECREF(nd);
1860 : 9 : return NULL;
1861 : : }
1862 : :
1863 : :
1864 : : static int
1865 : 6406 : ndarray_ass_subscript(NDArrayObject *self, PyObject *key, PyObject *value)
1866 : : {
1867 : : NDArrayObject *nd;
1868 : 6406 : Py_buffer *dest = &self->head->base;
1869 : : Py_buffer src;
1870 : : char *ptr;
1871 : : Py_ssize_t index;
1872 : 6406 : int ret = -1;
1873 : :
1874 [ + + ]: 6406 : if (dest->readonly) {
1875 : 1 : PyErr_SetString(PyExc_TypeError, "ndarray is not writable");
1876 : 1 : return -1;
1877 : : }
1878 [ + + ]: 6405 : if (value == NULL) {
1879 : 1 : PyErr_SetString(PyExc_TypeError, "ndarray data cannot be deleted");
1880 : 1 : return -1;
1881 : : }
1882 [ + + ]: 6404 : if (dest->ndim == 0) {
1883 [ + + + + ]: 11 : if (key == Py_Ellipsis ||
1884 [ + - ]: 9 : (PyTuple_Check(key) && PyTuple_GET_SIZE(key) == 0)) {
1885 : 5 : ptr = (char *)dest->buf;
1886 : 5 : return pack_single(ptr, value, dest->format, dest->itemsize);
1887 : : }
1888 : : else {
1889 : 1 : PyErr_SetString(PyExc_TypeError, "invalid indexing of scalar");
1890 : 1 : return -1;
1891 : : }
1892 : : }
1893 [ + + + + ]: 6398 : if (dest->ndim == 1 && PyIndex_Check(key)) {
1894 : : /* rvalue must be a single item */
1895 : 1474 : index = PyLong_AsSsize_t(key);
1896 [ + + + + ]: 1474 : if (index == -1 && PyErr_Occurred())
1897 : 1 : return -1;
1898 : : else {
1899 : 1473 : ptr = ptr_from_index(dest, index);
1900 [ + + ]: 1473 : if (ptr == NULL)
1901 : 182 : return -1;
1902 : : }
1903 : 1291 : return pack_single(ptr, value, dest->format, dest->itemsize);
1904 : : }
1905 : :
1906 : : /* rvalue must be an exporter */
1907 [ + + ]: 4924 : if (PyObject_GetBuffer(value, &src, PyBUF_FULL_RO) == -1)
1908 : 2 : return -1;
1909 : :
1910 : 4922 : nd = (NDArrayObject *)ndarray_subscript(self, key);
1911 [ + - ]: 4922 : if (nd != NULL) {
1912 : 4922 : dest = &nd->head->base;
1913 : 4922 : ret = copy_buffer(dest, &src);
1914 : 4922 : Py_DECREF(nd);
1915 : : }
1916 : :
1917 : 4922 : PyBuffer_Release(&src);
1918 : 4922 : return ret;
1919 : : }
1920 : :
1921 : : static PyObject *
1922 : 4823 : slice_indices(PyObject *self, PyObject *args)
1923 : : {
1924 : : PyObject *ret, *key, *tmp;
1925 : : Py_ssize_t s[4]; /* start, stop, step, slicelength */
1926 : : Py_ssize_t i, len;
1927 : :
1928 [ + + ]: 4823 : if (!PyArg_ParseTuple(args, "On", &key, &len)) {
1929 : 1 : return NULL;
1930 : : }
1931 [ + + ]: 4822 : if (!PySlice_Check(key)) {
1932 : 1 : PyErr_SetString(PyExc_TypeError,
1933 : : "first argument must be a slice object");
1934 : 1 : return NULL;
1935 : : }
1936 [ + + ]: 4821 : if (PySlice_Unpack(key, &s[0], &s[1], &s[2]) < 0) {
1937 : 1 : return NULL;
1938 : : }
1939 : 4820 : s[3] = PySlice_AdjustIndices(len, &s[0], &s[1], s[2]);
1940 : :
1941 : 4820 : ret = PyTuple_New(4);
1942 [ - + ]: 4820 : if (ret == NULL)
1943 : 0 : return NULL;
1944 : :
1945 [ + + ]: 24100 : for (i = 0; i < 4; i++) {
1946 : 19280 : tmp = PyLong_FromSsize_t(s[i]);
1947 [ - + ]: 19280 : if (tmp == NULL)
1948 : 0 : goto error;
1949 : 19280 : PyTuple_SET_ITEM(ret, i, tmp);
1950 : : }
1951 : :
1952 : 4820 : return ret;
1953 : :
1954 : 0 : error:
1955 : 0 : Py_DECREF(ret);
1956 : 0 : return NULL;
1957 : : }
1958 : :
1959 : :
1960 : : static PyMappingMethods ndarray_as_mapping = {
1961 : : NULL, /* mp_length */
1962 : : (binaryfunc)ndarray_subscript, /* mp_subscript */
1963 : : (objobjargproc)ndarray_ass_subscript /* mp_ass_subscript */
1964 : : };
1965 : :
1966 : : static PySequenceMethods ndarray_as_sequence = {
1967 : : 0, /* sq_length */
1968 : : 0, /* sq_concat */
1969 : : 0, /* sq_repeat */
1970 : : (ssizeargfunc)ndarray_item, /* sq_item */
1971 : : };
1972 : :
1973 : :
1974 : : /**************************************************************************/
1975 : : /* getters */
1976 : : /**************************************************************************/
1977 : :
1978 : : static PyObject *
1979 : 112256 : ssize_array_as_tuple(Py_ssize_t *array, Py_ssize_t len)
1980 : : {
1981 : : PyObject *tuple, *x;
1982 : : Py_ssize_t i;
1983 : :
1984 [ + + ]: 112256 : if (array == NULL)
1985 : 37555 : return PyTuple_New(0);
1986 : :
1987 : 74701 : tuple = PyTuple_New(len);
1988 [ - + ]: 74701 : if (tuple == NULL)
1989 : 0 : return NULL;
1990 : :
1991 [ + + ]: 200903 : for (i = 0; i < len; i++) {
1992 : 126202 : x = PyLong_FromSsize_t(array[i]);
1993 [ - + ]: 126202 : if (x == NULL) {
1994 : 0 : Py_DECREF(tuple);
1995 : 0 : return NULL;
1996 : : }
1997 : 126202 : PyTuple_SET_ITEM(tuple, i, x);
1998 : : }
1999 : :
2000 : 74701 : return tuple;
2001 : : }
2002 : :
2003 : : static PyObject *
2004 : 1 : ndarray_get_flags(NDArrayObject *self, void *closure)
2005 : : {
2006 : 1 : return PyLong_FromLong(self->head->flags);
2007 : : }
2008 : :
2009 : : static PyObject *
2010 : 1 : ndarray_get_offset(NDArrayObject *self, void *closure)
2011 : : {
2012 : 1 : ndbuf_t *ndbuf = self->head;
2013 : 1 : return PyLong_FromSsize_t(ndbuf->offset);
2014 : : }
2015 : :
2016 : : static PyObject *
2017 : 15991 : ndarray_get_obj(NDArrayObject *self, void *closure)
2018 : : {
2019 : 15991 : Py_buffer *base = &self->head->base;
2020 : :
2021 [ + + ]: 15991 : if (base->obj == NULL) {
2022 : 1931 : Py_RETURN_NONE;
2023 : : }
2024 : 14060 : Py_INCREF(base->obj);
2025 : 14060 : return base->obj;
2026 : : }
2027 : :
2028 : : static PyObject *
2029 : 22102 : ndarray_get_nbytes(NDArrayObject *self, void *closure)
2030 : : {
2031 : 22102 : Py_buffer *base = &self->head->base;
2032 : 22102 : return PyLong_FromSsize_t(base->len);
2033 : : }
2034 : :
2035 : : static PyObject *
2036 : 41621 : ndarray_get_readonly(NDArrayObject *self, void *closure)
2037 : : {
2038 : 41621 : Py_buffer *base = &self->head->base;
2039 : 41621 : return PyBool_FromLong(base->readonly);
2040 : : }
2041 : :
2042 : : static PyObject *
2043 : 23187 : ndarray_get_itemsize(NDArrayObject *self, void *closure)
2044 : : {
2045 : 23187 : Py_buffer *base = &self->head->base;
2046 : 23187 : return PyLong_FromSsize_t(base->itemsize);
2047 : : }
2048 : :
2049 : : static PyObject *
2050 : 23868 : ndarray_get_format(NDArrayObject *self, void *closure)
2051 : : {
2052 : 23868 : Py_buffer *base = &self->head->base;
2053 [ + + ]: 23868 : const char *fmt = base->format ? base->format : "";
2054 : 23868 : return PyUnicode_FromString(fmt);
2055 : : }
2056 : :
2057 : : static PyObject *
2058 : 23708 : ndarray_get_ndim(NDArrayObject *self, void *closure)
2059 : : {
2060 : 23708 : Py_buffer *base = &self->head->base;
2061 : 23708 : return PyLong_FromSsize_t(base->ndim);
2062 : : }
2063 : :
2064 : : static PyObject *
2065 : 30838 : ndarray_get_shape(NDArrayObject *self, void *closure)
2066 : : {
2067 : 30838 : Py_buffer *base = &self->head->base;
2068 : 30838 : return ssize_array_as_tuple(base->shape, base->ndim);
2069 : : }
2070 : :
2071 : : static PyObject *
2072 : 40271 : ndarray_get_strides(NDArrayObject *self, void *closure)
2073 : : {
2074 : 40271 : Py_buffer *base = &self->head->base;
2075 : 40271 : return ssize_array_as_tuple(base->strides, base->ndim);
2076 : : }
2077 : :
2078 : : static PyObject *
2079 : 41147 : ndarray_get_suboffsets(NDArrayObject *self, void *closure)
2080 : : {
2081 : 41147 : Py_buffer *base = &self->head->base;
2082 : 41147 : return ssize_array_as_tuple(base->suboffsets, base->ndim);
2083 : : }
2084 : :
2085 : : static PyObject *
2086 : 3604 : ndarray_c_contig(PyObject *self, PyObject *dummy)
2087 : : {
2088 : 3604 : NDArrayObject *nd = (NDArrayObject *)self;
2089 : 3604 : int ret = PyBuffer_IsContiguous(&nd->head->base, 'C');
2090 : :
2091 [ - + ]: 3604 : if (ret != ND_C_CONTIGUOUS(nd->head->flags)) {
2092 : 0 : PyErr_SetString(PyExc_RuntimeError,
2093 : : "results from PyBuffer_IsContiguous() and flags differ");
2094 : 0 : return NULL;
2095 : : }
2096 : 3604 : return PyBool_FromLong(ret);
2097 : : }
2098 : :
2099 : : static PyObject *
2100 : 1060 : ndarray_fortran_contig(PyObject *self, PyObject *dummy)
2101 : : {
2102 : 1060 : NDArrayObject *nd = (NDArrayObject *)self;
2103 : 1060 : int ret = PyBuffer_IsContiguous(&nd->head->base, 'F');
2104 : :
2105 [ - + ]: 1060 : if (ret != ND_FORTRAN_CONTIGUOUS(nd->head->flags)) {
2106 : 0 : PyErr_SetString(PyExc_RuntimeError,
2107 : : "results from PyBuffer_IsContiguous() and flags differ");
2108 : 0 : return NULL;
2109 : : }
2110 : 1060 : return PyBool_FromLong(ret);
2111 : : }
2112 : :
2113 : : static PyObject *
2114 : 1345 : ndarray_contig(PyObject *self, PyObject *dummy)
2115 : : {
2116 : 1345 : NDArrayObject *nd = (NDArrayObject *)self;
2117 : 1345 : int ret = PyBuffer_IsContiguous(&nd->head->base, 'A');
2118 : :
2119 [ - + ]: 1345 : if (ret != ND_ANY_CONTIGUOUS(nd->head->flags)) {
2120 : 0 : PyErr_SetString(PyExc_RuntimeError,
2121 : : "results from PyBuffer_IsContiguous() and flags differ");
2122 : 0 : return NULL;
2123 : : }
2124 : 1345 : return PyBool_FromLong(ret);
2125 : : }
2126 : :
2127 : :
2128 : : static PyGetSetDef ndarray_getset [] =
2129 : : {
2130 : : /* ndbuf */
2131 : : { "flags", (getter)ndarray_get_flags, NULL, NULL, NULL},
2132 : : { "offset", (getter)ndarray_get_offset, NULL, NULL, NULL},
2133 : : /* ndbuf.base */
2134 : : { "obj", (getter)ndarray_get_obj, NULL, NULL, NULL},
2135 : : { "nbytes", (getter)ndarray_get_nbytes, NULL, NULL, NULL},
2136 : : { "readonly", (getter)ndarray_get_readonly, NULL, NULL, NULL},
2137 : : { "itemsize", (getter)ndarray_get_itemsize, NULL, NULL, NULL},
2138 : : { "format", (getter)ndarray_get_format, NULL, NULL, NULL},
2139 : : { "ndim", (getter)ndarray_get_ndim, NULL, NULL, NULL},
2140 : : { "shape", (getter)ndarray_get_shape, NULL, NULL, NULL},
2141 : : { "strides", (getter)ndarray_get_strides, NULL, NULL, NULL},
2142 : : { "suboffsets", (getter)ndarray_get_suboffsets, NULL, NULL, NULL},
2143 : : { "c_contiguous", (getter)ndarray_c_contig, NULL, NULL, NULL},
2144 : : { "f_contiguous", (getter)ndarray_fortran_contig, NULL, NULL, NULL},
2145 : : { "contiguous", (getter)ndarray_contig, NULL, NULL, NULL},
2146 : : {NULL}
2147 : : };
2148 : :
2149 : : static PyObject *
2150 : 52672 : ndarray_tolist(PyObject *self, PyObject *dummy)
2151 : : {
2152 : 52672 : return ndarray_as_list((NDArrayObject *)self);
2153 : : }
2154 : :
2155 : : static PyObject *
2156 : 26504 : ndarray_tobytes(PyObject *self, PyObject *dummy)
2157 : : {
2158 : 26504 : ndbuf_t *ndbuf = ((NDArrayObject *)self)->head;
2159 : 26504 : Py_buffer *src = &ndbuf->base;
2160 : : Py_buffer dest;
2161 : 26504 : PyObject *ret = NULL;
2162 : : char *mem;
2163 : :
2164 [ + + ]: 26504 : if (ND_C_CONTIGUOUS(ndbuf->flags))
2165 : 14984 : return PyBytes_FromStringAndSize(src->buf, src->len);
2166 : :
2167 : : assert(src->shape != NULL);
2168 : : assert(src->strides != NULL);
2169 : : assert(src->ndim > 0);
2170 : :
2171 : 11520 : mem = PyMem_Malloc(src->len);
2172 [ - + ]: 11520 : if (mem == NULL) {
2173 : : PyErr_NoMemory();
2174 : 0 : return NULL;
2175 : : }
2176 : :
2177 : 11520 : dest = *src;
2178 : 11520 : dest.buf = mem;
2179 : 11520 : dest.suboffsets = NULL;
2180 : 11520 : dest.strides = strides_from_shape(ndbuf, 0);
2181 [ - + ]: 11520 : if (dest.strides == NULL)
2182 : 0 : goto out;
2183 [ - + ]: 11520 : if (copy_buffer(&dest, src) < 0)
2184 : 0 : goto out;
2185 : :
2186 : 11520 : ret = PyBytes_FromStringAndSize(mem, src->len);
2187 : :
2188 : 11520 : out:
2189 [ + - ]: 11520 : PyMem_XFree(dest.strides);
2190 : 11520 : PyMem_Free(mem);
2191 : 11520 : return ret;
2192 : : }
2193 : :
2194 : : /* add redundant (negative) suboffsets for testing */
2195 : : static PyObject *
2196 : 4 : ndarray_add_suboffsets(PyObject *self, PyObject *dummy)
2197 : : {
2198 : 4 : NDArrayObject *nd = (NDArrayObject *)self;
2199 : 4 : Py_buffer *base = &nd->head->base;
2200 : : Py_ssize_t i;
2201 : :
2202 [ + + ]: 4 : if (base->suboffsets != NULL) {
2203 : 1 : PyErr_SetString(PyExc_TypeError,
2204 : : "cannot add suboffsets to PIL-style array");
2205 : 1 : return NULL;
2206 : : }
2207 [ + + ]: 3 : if (base->strides == NULL) {
2208 : 1 : PyErr_SetString(PyExc_TypeError,
2209 : : "cannot add suboffsets to array without strides");
2210 : 1 : return NULL;
2211 : : }
2212 : :
2213 : 2 : base->suboffsets = PyMem_Malloc(base->ndim * (sizeof *base->suboffsets));
2214 [ - + ]: 2 : if (base->suboffsets == NULL) {
2215 : : PyErr_NoMemory();
2216 : 0 : return NULL;
2217 : : }
2218 : :
2219 [ + + ]: 10 : for (i = 0; i < base->ndim; i++)
2220 : 8 : base->suboffsets[i] = -1;
2221 : :
2222 : 2 : nd->head->flags &= ~(ND_C|ND_FORTRAN);
2223 : :
2224 : 2 : Py_RETURN_NONE;
2225 : : }
2226 : :
2227 : : /* Test PyMemoryView_FromBuffer(): return a memoryview from a static buffer.
2228 : : Obviously this is fragile and only one such view may be active at any
2229 : : time. Never use anything like this in real code! */
2230 : : static char *infobuf = NULL;
2231 : : static PyObject *
2232 : 26 : ndarray_memoryview_from_buffer(PyObject *self, PyObject *dummy)
2233 : : {
2234 : 26 : const NDArrayObject *nd = (NDArrayObject *)self;
2235 : 26 : const Py_buffer *view = &nd->head->base;
2236 : : const ndbuf_t *ndbuf;
2237 : : static char format[ND_MAX_NDIM+1];
2238 : : static Py_ssize_t shape[ND_MAX_NDIM];
2239 : : static Py_ssize_t strides[ND_MAX_NDIM];
2240 : : static Py_ssize_t suboffsets[ND_MAX_NDIM];
2241 : : static Py_buffer info;
2242 : : char *p;
2243 : :
2244 [ + + ]: 26 : if (!ND_IS_CONSUMER(nd))
2245 : 5 : ndbuf = nd->head; /* self is ndarray/original exporter */
2246 [ + - + + ]: 21 : else if (NDArray_Check(view->obj) && !ND_IS_CONSUMER(view->obj))
2247 : : /* self is ndarray and consumer from ndarray/original exporter */
2248 : 20 : ndbuf = ((NDArrayObject *)view->obj)->head;
2249 : : else {
2250 : 1 : PyErr_SetString(PyExc_TypeError,
2251 : : "memoryview_from_buffer(): ndarray must be original exporter or "
2252 : : "consumer from ndarray/original exporter");
2253 : 1 : return NULL;
2254 : : }
2255 : :
2256 : 25 : info = *view;
2257 : 25 : p = PyMem_Realloc(infobuf, ndbuf->len);
2258 [ - + ]: 25 : if (p == NULL) {
2259 : 0 : PyMem_Free(infobuf);
2260 : : PyErr_NoMemory();
2261 : 0 : infobuf = NULL;
2262 : 0 : return NULL;
2263 : : }
2264 : : else {
2265 : 25 : infobuf = p;
2266 : : }
2267 : : /* copy the complete raw data */
2268 : 25 : memcpy(infobuf, ndbuf->data, ndbuf->len);
2269 : 25 : info.buf = infobuf + ((char *)view->buf - ndbuf->data);
2270 : :
2271 [ + + ]: 25 : if (view->format) {
2272 [ + + ]: 22 : if (strlen(view->format) > ND_MAX_NDIM) {
2273 : 1 : PyErr_Format(PyExc_TypeError,
2274 : : "memoryview_from_buffer: format is limited to %d characters",
2275 : : ND_MAX_NDIM);
2276 : 1 : return NULL;
2277 : : }
2278 : 21 : strcpy(format, view->format);
2279 : 21 : info.format = format;
2280 : : }
2281 [ - + ]: 24 : if (view->ndim > ND_MAX_NDIM) {
2282 : 0 : PyErr_Format(PyExc_TypeError,
2283 : : "memoryview_from_buffer: ndim is limited to %d", ND_MAX_NDIM);
2284 : 0 : return NULL;
2285 : : }
2286 [ + + ]: 24 : if (view->shape) {
2287 : 20 : memcpy(shape, view->shape, view->ndim * sizeof(Py_ssize_t));
2288 : 20 : info.shape = shape;
2289 : : }
2290 [ + + ]: 24 : if (view->strides) {
2291 : 4 : memcpy(strides, view->strides, view->ndim * sizeof(Py_ssize_t));
2292 : 4 : info.strides = strides;
2293 : : }
2294 [ + + ]: 24 : if (view->suboffsets) {
2295 : 1 : memcpy(suboffsets, view->suboffsets, view->ndim * sizeof(Py_ssize_t));
2296 : 1 : info.suboffsets = suboffsets;
2297 : : }
2298 : :
2299 : 24 : return PyMemoryView_FromBuffer(&info);
2300 : : }
2301 : :
2302 : : /* Get a single item from bufobj at the location specified by seq.
2303 : : seq is a list or tuple of indices. The purpose of this function
2304 : : is to check other functions against PyBuffer_GetPointer(). */
2305 : : static PyObject *
2306 : 89544 : get_pointer(PyObject *self, PyObject *args)
2307 : : {
2308 : 89544 : PyObject *ret = NULL, *bufobj, *seq;
2309 : : Py_buffer view;
2310 : : Py_ssize_t indices[ND_MAX_NDIM];
2311 : : Py_ssize_t i;
2312 : : void *ptr;
2313 : :
2314 [ - + ]: 89544 : if (!PyArg_ParseTuple(args, "OO", &bufobj, &seq)) {
2315 : 0 : return NULL;
2316 : : }
2317 : :
2318 [ + + + + ]: 89544 : CHECK_LIST_OR_TUPLE(seq);
2319 [ + + ]: 89543 : if (PyObject_GetBuffer(bufobj, &view, PyBUF_FULL_RO) < 0)
2320 : 513 : return NULL;
2321 : :
2322 [ - + ]: 89030 : if (view.ndim > ND_MAX_NDIM) {
2323 : 0 : PyErr_Format(PyExc_ValueError,
2324 : : "get_pointer(): ndim > %d", ND_MAX_NDIM);
2325 : 0 : goto out;
2326 : : }
2327 [ + + + + ]: 89030 : if (PySequence_Fast_GET_SIZE(seq) != view.ndim) {
2328 : 2 : PyErr_SetString(PyExc_ValueError,
2329 : : "get_pointer(): len(indices) != ndim");
2330 : 2 : goto out;
2331 : : }
2332 : :
2333 [ + + ]: 246951 : for (i = 0; i < view.ndim; i++) {
2334 [ + + ]: 157926 : PyObject *x = PySequence_Fast_GET_ITEM(seq, i);
2335 : 157926 : indices[i] = PyLong_AsSsize_t(x);
2336 [ + + ]: 157926 : if (PyErr_Occurred())
2337 : 1 : goto out;
2338 [ + + + + ]: 157925 : if (indices[i] < 0 || indices[i] >= view.shape[i]) {
2339 : 2 : PyErr_Format(PyExc_ValueError,
2340 : : "get_pointer(): invalid index %zd at position %zd",
2341 : : indices[i], i);
2342 : 2 : goto out;
2343 : : }
2344 : : }
2345 : :
2346 : 89025 : ptr = PyBuffer_GetPointer(&view, indices);
2347 : 89025 : ret = unpack_single(ptr, view.format, view.itemsize);
2348 : :
2349 : 89030 : out:
2350 : 89030 : PyBuffer_Release(&view);
2351 : 89030 : return ret;
2352 : : }
2353 : :
2354 : : static PyObject *
2355 : 73 : get_sizeof_void_p(PyObject *self, PyObject *Py_UNUSED(ignored))
2356 : : {
2357 : 73 : return PyLong_FromSize_t(sizeof(void *));
2358 : : }
2359 : :
2360 : : static char
2361 : 206184 : get_ascii_order(PyObject *order)
2362 : : {
2363 : : PyObject *ascii_order;
2364 : : char ord;
2365 : :
2366 [ + + ]: 206184 : if (!PyUnicode_Check(order)) {
2367 : 2 : PyErr_SetString(PyExc_TypeError,
2368 : : "order must be a string");
2369 : 2 : return CHAR_MAX;
2370 : : }
2371 : :
2372 : 206182 : ascii_order = PyUnicode_AsASCIIString(order);
2373 [ + + ]: 206182 : if (ascii_order == NULL) {
2374 : 1 : return CHAR_MAX;
2375 : : }
2376 : :
2377 : 206181 : ord = PyBytes_AS_STRING(ascii_order)[0];
2378 : 206181 : Py_DECREF(ascii_order);
2379 : :
2380 [ + + + + : 206181 : if (ord != 'C' && ord != 'F' && ord != 'A') {
+ + ]
2381 : 1 : PyErr_SetString(PyExc_ValueError,
2382 : : "invalid order, must be C, F or A");
2383 : 1 : return CHAR_MAX;
2384 : : }
2385 : :
2386 : 206180 : return ord;
2387 : : }
2388 : :
2389 : : /* Get a contiguous memoryview. */
2390 : : static PyObject *
2391 : 34066 : get_contiguous(PyObject *self, PyObject *args)
2392 : : {
2393 : : PyObject *obj;
2394 : : PyObject *buffertype;
2395 : : PyObject *order;
2396 : : long type;
2397 : : char ord;
2398 : :
2399 [ + + ]: 34066 : if (!PyArg_ParseTuple(args, "OOO", &obj, &buffertype, &order)) {
2400 : 1 : return NULL;
2401 : : }
2402 : :
2403 [ + + ]: 34065 : if (!PyLong_Check(buffertype)) {
2404 : 1 : PyErr_SetString(PyExc_TypeError,
2405 : : "buffertype must be PyBUF_READ or PyBUF_WRITE");
2406 : 1 : return NULL;
2407 : : }
2408 : :
2409 : 34064 : type = PyLong_AsLong(buffertype);
2410 [ + + + - ]: 34064 : if (type == -1 && PyErr_Occurred()) {
2411 : 1 : return NULL;
2412 : : }
2413 [ + + + + ]: 34063 : if (type != PyBUF_READ && type != PyBUF_WRITE) {
2414 : 1 : PyErr_SetString(PyExc_ValueError,
2415 : : "invalid buffer type");
2416 : 1 : return NULL;
2417 : : }
2418 : :
2419 : 34062 : ord = get_ascii_order(order);
2420 [ + + ]: 34062 : if (ord == CHAR_MAX)
2421 : 3 : return NULL;
2422 : :
2423 : 34059 : return PyMemoryView_GetContiguous(obj, (int)type, ord);
2424 : : }
2425 : :
2426 : : /* PyBuffer_ToContiguous() */
2427 : : static PyObject *
2428 : 94581 : py_buffer_to_contiguous(PyObject *self, PyObject *args)
2429 : : {
2430 : : PyObject *obj;
2431 : : PyObject *order;
2432 : 94581 : PyObject *ret = NULL;
2433 : : int flags;
2434 : : char ord;
2435 : : Py_buffer view;
2436 : 94581 : char *buf = NULL;
2437 : :
2438 [ - + ]: 94581 : if (!PyArg_ParseTuple(args, "OOi", &obj, &order, &flags)) {
2439 : 0 : return NULL;
2440 : : }
2441 : :
2442 [ + + ]: 94581 : if (PyObject_GetBuffer(obj, &view, flags) < 0) {
2443 : 19 : return NULL;
2444 : : }
2445 : :
2446 : 94562 : ord = get_ascii_order(order);
2447 [ - + ]: 94562 : if (ord == CHAR_MAX) {
2448 : 0 : goto out;
2449 : : }
2450 : :
2451 : 94562 : buf = PyMem_Malloc(view.len);
2452 [ - + ]: 94562 : if (buf == NULL) {
2453 : : PyErr_NoMemory();
2454 : 0 : goto out;
2455 : : }
2456 : :
2457 [ - + ]: 94562 : if (PyBuffer_ToContiguous(buf, &view, view.len, ord) < 0) {
2458 : 0 : goto out;
2459 : : }
2460 : :
2461 : 94562 : ret = PyBytes_FromStringAndSize(buf, view.len);
2462 : :
2463 : 94562 : out:
2464 : 94562 : PyBuffer_Release(&view);
2465 [ + - ]: 94562 : PyMem_XFree(buf);
2466 : 94562 : return ret;
2467 : : }
2468 : :
2469 : : static int
2470 : 34015 : fmtcmp(const char *fmt1, const char *fmt2)
2471 : : {
2472 [ - + ]: 34015 : if (fmt1 == NULL) {
2473 [ # # # # ]: 0 : return fmt2 == NULL || strcmp(fmt2, "B") == 0;
2474 : : }
2475 [ - + ]: 34015 : if (fmt2 == NULL) {
2476 [ # # # # ]: 0 : return fmt1 == NULL || strcmp(fmt1, "B") == 0;
2477 : : }
2478 : 34015 : return strcmp(fmt1, fmt2) == 0;
2479 : : }
2480 : :
2481 : : static int
2482 : 62833 : arraycmp(const Py_ssize_t *a1, const Py_ssize_t *a2, const Py_ssize_t *shape,
2483 : : Py_ssize_t ndim)
2484 : : {
2485 : : Py_ssize_t i;
2486 : :
2487 : :
2488 [ + + ]: 164665 : for (i = 0; i < ndim; i++) {
2489 [ + + + + ]: 101833 : if (shape && shape[i] <= 1) {
2490 : : /* strides can differ if the dimension is less than 2 */
2491 : 11261 : continue;
2492 : : }
2493 [ + + ]: 90572 : if (a1[i] != a2[i]) {
2494 : 1 : return 0;
2495 : : }
2496 : : }
2497 : :
2498 : 62832 : return 1;
2499 : : }
2500 : :
2501 : : /* Compare two contiguous buffers for physical equality. */
2502 : : static PyObject *
2503 : 34018 : cmp_contig(PyObject *self, PyObject *args)
2504 : : {
2505 : : PyObject *b1, *b2; /* buffer objects */
2506 : : Py_buffer v1, v2;
2507 : : PyObject *ret;
2508 : 34018 : int equal = 0;
2509 : :
2510 [ + + ]: 34018 : if (!PyArg_ParseTuple(args, "OO", &b1, &b2)) {
2511 : 1 : return NULL;
2512 : : }
2513 : :
2514 [ + + ]: 34017 : if (PyObject_GetBuffer(b1, &v1, PyBUF_FULL_RO) < 0) {
2515 : 1 : PyErr_SetString(PyExc_TypeError,
2516 : : "cmp_contig: first argument does not implement the buffer "
2517 : : "protocol");
2518 : 1 : return NULL;
2519 : : }
2520 [ + + ]: 34016 : if (PyObject_GetBuffer(b2, &v2, PyBUF_FULL_RO) < 0) {
2521 : 1 : PyErr_SetString(PyExc_TypeError,
2522 : : "cmp_contig: second argument does not implement the buffer "
2523 : : "protocol");
2524 : 1 : PyBuffer_Release(&v1);
2525 : 1 : return NULL;
2526 : : }
2527 : :
2528 [ + + - + : 37041 : if (!(PyBuffer_IsContiguous(&v1, 'C')&&PyBuffer_IsContiguous(&v2, 'C')) &&
+ - ]
2529 [ - + ]: 6052 : !(PyBuffer_IsContiguous(&v1, 'F')&&PyBuffer_IsContiguous(&v2, 'F'))) {
2530 : 0 : goto result;
2531 : : }
2532 : :
2533 : : /* readonly may differ if created from non-contiguous */
2534 [ + - ]: 34015 : if (v1.len != v2.len ||
2535 [ + - ]: 34015 : v1.itemsize != v2.itemsize ||
2536 [ + - + - ]: 68030 : v1.ndim != v2.ndim ||
2537 : 34015 : !fmtcmp(v1.format, v2.format) ||
2538 [ + - ]: 34015 : !!v1.shape != !!v2.shape ||
2539 [ + - ]: 34015 : !!v1.strides != !!v2.strides ||
2540 [ - + ]: 34015 : !!v1.suboffsets != !!v2.suboffsets) {
2541 : 0 : goto result;
2542 : : }
2543 : :
2544 [ + + + + ]: 34015 : if ((v1.shape && !arraycmp(v1.shape, v2.shape, NULL, v1.ndim)) ||
2545 [ + + + - ]: 34014 : (v1.strides && !arraycmp(v1.strides, v2.strides, v1.shape, v1.ndim)) ||
2546 [ - + - - ]: 34014 : (v1.suboffsets && !arraycmp(v1.suboffsets, v2.suboffsets, NULL,
2547 : 0 : v1.ndim))) {
2548 : 1 : goto result;
2549 : : }
2550 : :
2551 [ + + ]: 34014 : if (memcmp((char *)v1.buf, (char *)v2.buf, v1.len) != 0) {
2552 : 1 : goto result;
2553 : : }
2554 : :
2555 : 34013 : equal = 1;
2556 : :
2557 : 34015 : result:
2558 : 34015 : PyBuffer_Release(&v1);
2559 : 34015 : PyBuffer_Release(&v2);
2560 : :
2561 [ + + ]: 34015 : ret = equal ? Py_True : Py_False;
2562 : 34015 : Py_INCREF(ret);
2563 : 34015 : return ret;
2564 : : }
2565 : :
2566 : : static PyObject *
2567 : 77561 : is_contiguous(PyObject *self, PyObject *args)
2568 : : {
2569 : : PyObject *obj;
2570 : : PyObject *order;
2571 : 77561 : PyObject *ret = NULL;
2572 : : Py_buffer view, *base;
2573 : : char ord;
2574 : :
2575 [ + + ]: 77561 : if (!PyArg_ParseTuple(args, "OO", &obj, &order)) {
2576 : 1 : return NULL;
2577 : : }
2578 : :
2579 : 77560 : ord = get_ascii_order(order);
2580 [ + + ]: 77560 : if (ord == CHAR_MAX) {
2581 : 1 : return NULL;
2582 : : }
2583 : :
2584 [ + + ]: 77559 : if (NDArray_Check(obj)) {
2585 : : /* Skip the buffer protocol to check simple etc. buffers directly. */
2586 : 75920 : base = &((NDArrayObject *)obj)->head->base;
2587 [ + + ]: 75920 : ret = PyBuffer_IsContiguous(base, ord) ? Py_True : Py_False;
2588 : : }
2589 : : else {
2590 [ + + ]: 1639 : if (PyObject_GetBuffer(obj, &view, PyBUF_FULL_RO) < 0) {
2591 : 1 : PyErr_SetString(PyExc_TypeError,
2592 : : "is_contiguous: object does not implement the buffer "
2593 : : "protocol");
2594 : 1 : return NULL;
2595 : : }
2596 [ + + ]: 1638 : ret = PyBuffer_IsContiguous(&view, ord) ? Py_True : Py_False;
2597 : 1638 : PyBuffer_Release(&view);
2598 : : }
2599 : :
2600 : 77558 : Py_INCREF(ret);
2601 : 77558 : return ret;
2602 : : }
2603 : :
2604 : : static Py_hash_t
2605 : 20 : ndarray_hash(PyObject *self)
2606 : : {
2607 : 20 : const NDArrayObject *nd = (NDArrayObject *)self;
2608 : 20 : const Py_buffer *view = &nd->head->base;
2609 : : PyObject *bytes;
2610 : : Py_hash_t hash;
2611 : :
2612 [ + + ]: 20 : if (!view->readonly) {
2613 : 1 : PyErr_SetString(PyExc_ValueError,
2614 : : "cannot hash writable ndarray object");
2615 : 1 : return -1;
2616 : : }
2617 [ + + - + ]: 19 : if (view->obj != NULL && PyObject_Hash(view->obj) == -1) {
2618 : 0 : return -1;
2619 : : }
2620 : :
2621 : 19 : bytes = ndarray_tobytes(self, NULL);
2622 [ - + ]: 19 : if (bytes == NULL) {
2623 : 0 : return -1;
2624 : : }
2625 : :
2626 : 19 : hash = PyObject_Hash(bytes);
2627 : 19 : Py_DECREF(bytes);
2628 : 19 : return hash;
2629 : : }
2630 : :
2631 : :
2632 : : static PyMethodDef ndarray_methods [] =
2633 : : {
2634 : : { "tolist", ndarray_tolist, METH_NOARGS, NULL },
2635 : : { "tobytes", ndarray_tobytes, METH_NOARGS, NULL },
2636 : : { "push", _PyCFunction_CAST(ndarray_push), METH_VARARGS|METH_KEYWORDS, NULL },
2637 : : { "pop", ndarray_pop, METH_NOARGS, NULL },
2638 : : { "add_suboffsets", ndarray_add_suboffsets, METH_NOARGS, NULL },
2639 : : { "memoryview_from_buffer", ndarray_memoryview_from_buffer, METH_NOARGS, NULL },
2640 : : {NULL}
2641 : : };
2642 : :
2643 : : static PyTypeObject NDArray_Type = {
2644 : : PyVarObject_HEAD_INIT(NULL, 0)
2645 : : "ndarray", /* Name of this type */
2646 : : sizeof(NDArrayObject), /* Basic object size */
2647 : : 0, /* Item size for varobject */
2648 : : (destructor)ndarray_dealloc, /* tp_dealloc */
2649 : : 0, /* tp_vectorcall_offset */
2650 : : 0, /* tp_getattr */
2651 : : 0, /* tp_setattr */
2652 : : 0, /* tp_as_async */
2653 : : 0, /* tp_repr */
2654 : : 0, /* tp_as_number */
2655 : : &ndarray_as_sequence, /* tp_as_sequence */
2656 : : &ndarray_as_mapping, /* tp_as_mapping */
2657 : : (hashfunc)ndarray_hash, /* tp_hash */
2658 : : 0, /* tp_call */
2659 : : 0, /* tp_str */
2660 : : PyObject_GenericGetAttr, /* tp_getattro */
2661 : : 0, /* tp_setattro */
2662 : : &ndarray_as_buffer, /* tp_as_buffer */
2663 : : Py_TPFLAGS_DEFAULT, /* tp_flags */
2664 : : 0, /* tp_doc */
2665 : : 0, /* tp_traverse */
2666 : : 0, /* tp_clear */
2667 : : 0, /* tp_richcompare */
2668 : : 0, /* tp_weaklistoffset */
2669 : : 0, /* tp_iter */
2670 : : 0, /* tp_iternext */
2671 : : ndarray_methods, /* tp_methods */
2672 : : 0, /* tp_members */
2673 : : ndarray_getset, /* tp_getset */
2674 : : 0, /* tp_base */
2675 : : 0, /* tp_dict */
2676 : : 0, /* tp_descr_get */
2677 : : 0, /* tp_descr_set */
2678 : : 0, /* tp_dictoffset */
2679 : : ndarray_init, /* tp_init */
2680 : : 0, /* tp_alloc */
2681 : : ndarray_new, /* tp_new */
2682 : : };
2683 : :
2684 : : /**************************************************************************/
2685 : : /* StaticArray Object */
2686 : : /**************************************************************************/
2687 : :
2688 : : static PyTypeObject StaticArray_Type;
2689 : :
2690 : : typedef struct {
2691 : : PyObject_HEAD
2692 : : int legacy_mode; /* if true, use the view.obj==NULL hack */
2693 : : } StaticArrayObject;
2694 : :
2695 : : static char static_mem[12] = {0,1,2,3,4,5,6,7,8,9,10,11};
2696 : : static Py_ssize_t static_shape[1] = {12};
2697 : : static Py_ssize_t static_strides[1] = {1};
2698 : : static Py_buffer static_buffer = {
2699 : : static_mem, /* buf */
2700 : : NULL, /* obj */
2701 : : 12, /* len */
2702 : : 1, /* itemsize */
2703 : : 1, /* readonly */
2704 : : 1, /* ndim */
2705 : : "B", /* format */
2706 : : static_shape, /* shape */
2707 : : static_strides, /* strides */
2708 : : NULL, /* suboffsets */
2709 : : NULL /* internal */
2710 : : };
2711 : :
2712 : : static PyObject *
2713 : 9 : staticarray_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2714 : : {
2715 : 9 : return (PyObject *)PyObject_New(StaticArrayObject, &StaticArray_Type);
2716 : : }
2717 : :
2718 : : static int
2719 : 9 : staticarray_init(PyObject *self, PyObject *args, PyObject *kwds)
2720 : : {
2721 : 9 : StaticArrayObject *a = (StaticArrayObject *)self;
2722 : : static char *kwlist[] = {
2723 : : "legacy_mode", NULL
2724 : : };
2725 : 9 : PyObject *legacy_mode = Py_False;
2726 : :
2727 [ + + ]: 9 : if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &legacy_mode))
2728 : 1 : return -1;
2729 : :
2730 : 8 : a->legacy_mode = (legacy_mode != Py_False);
2731 : 8 : return 0;
2732 : : }
2733 : :
2734 : : static void
2735 : 9 : staticarray_dealloc(StaticArrayObject *self)
2736 : : {
2737 : 9 : PyObject_Free(self);
2738 : 9 : }
2739 : :
2740 : : /* Return a buffer for a PyBUF_FULL_RO request. Flags are not checked,
2741 : : which makes this object a non-compliant exporter! */
2742 : : static int
2743 : 10 : staticarray_getbuf(StaticArrayObject *self, Py_buffer *view, int flags)
2744 : : {
2745 : 10 : *view = static_buffer;
2746 : :
2747 [ + + ]: 10 : if (self->legacy_mode) {
2748 : 4 : view->obj = NULL; /* Don't use this in new code. */
2749 : : }
2750 : : else {
2751 : 6 : view->obj = (PyObject *)self;
2752 : 6 : Py_INCREF(view->obj);
2753 : : }
2754 : :
2755 : 10 : return 0;
2756 : : }
2757 : :
2758 : : static PyBufferProcs staticarray_as_buffer = {
2759 : : (getbufferproc)staticarray_getbuf, /* bf_getbuffer */
2760 : : NULL, /* bf_releasebuffer */
2761 : : };
2762 : :
2763 : : static PyTypeObject StaticArray_Type = {
2764 : : PyVarObject_HEAD_INIT(NULL, 0)
2765 : : "staticarray", /* Name of this type */
2766 : : sizeof(StaticArrayObject), /* Basic object size */
2767 : : 0, /* Item size for varobject */
2768 : : (destructor)staticarray_dealloc, /* tp_dealloc */
2769 : : 0, /* tp_vectorcall_offset */
2770 : : 0, /* tp_getattr */
2771 : : 0, /* tp_setattr */
2772 : : 0, /* tp_as_async */
2773 : : 0, /* tp_repr */
2774 : : 0, /* tp_as_number */
2775 : : 0, /* tp_as_sequence */
2776 : : 0, /* tp_as_mapping */
2777 : : 0, /* tp_hash */
2778 : : 0, /* tp_call */
2779 : : 0, /* tp_str */
2780 : : 0, /* tp_getattro */
2781 : : 0, /* tp_setattro */
2782 : : &staticarray_as_buffer, /* tp_as_buffer */
2783 : : Py_TPFLAGS_DEFAULT, /* tp_flags */
2784 : : 0, /* tp_doc */
2785 : : 0, /* tp_traverse */
2786 : : 0, /* tp_clear */
2787 : : 0, /* tp_richcompare */
2788 : : 0, /* tp_weaklistoffset */
2789 : : 0, /* tp_iter */
2790 : : 0, /* tp_iternext */
2791 : : 0, /* tp_methods */
2792 : : 0, /* tp_members */
2793 : : 0, /* tp_getset */
2794 : : 0, /* tp_base */
2795 : : 0, /* tp_dict */
2796 : : 0, /* tp_descr_get */
2797 : : 0, /* tp_descr_set */
2798 : : 0, /* tp_dictoffset */
2799 : : staticarray_init, /* tp_init */
2800 : : 0, /* tp_alloc */
2801 : : staticarray_new, /* tp_new */
2802 : : };
2803 : :
2804 : :
2805 : : static struct PyMethodDef _testbuffer_functions[] = {
2806 : : {"slice_indices", slice_indices, METH_VARARGS, NULL},
2807 : : {"get_pointer", get_pointer, METH_VARARGS, NULL},
2808 : : {"get_sizeof_void_p", get_sizeof_void_p, METH_NOARGS, NULL},
2809 : : {"get_contiguous", get_contiguous, METH_VARARGS, NULL},
2810 : : {"py_buffer_to_contiguous", py_buffer_to_contiguous, METH_VARARGS, NULL},
2811 : : {"is_contiguous", is_contiguous, METH_VARARGS, NULL},
2812 : : {"cmp_contig", cmp_contig, METH_VARARGS, NULL},
2813 : : {NULL, NULL}
2814 : : };
2815 : :
2816 : : static struct PyModuleDef _testbuffermodule = {
2817 : : PyModuleDef_HEAD_INIT,
2818 : : "_testbuffer",
2819 : : NULL,
2820 : : -1,
2821 : : _testbuffer_functions,
2822 : : NULL,
2823 : : NULL,
2824 : : NULL,
2825 : : NULL
2826 : : };
2827 : :
2828 : :
2829 : : PyMODINIT_FUNC
2830 : 8 : PyInit__testbuffer(void)
2831 : : {
2832 : : PyObject *m;
2833 : :
2834 : 8 : m = PyModule_Create(&_testbuffermodule);
2835 [ - + ]: 8 : if (m == NULL)
2836 : 0 : return NULL;
2837 : :
2838 : 8 : Py_SET_TYPE(&NDArray_Type, &PyType_Type);
2839 : 8 : Py_INCREF(&NDArray_Type);
2840 : 8 : PyModule_AddObject(m, "ndarray", (PyObject *)&NDArray_Type);
2841 : :
2842 : 8 : Py_SET_TYPE(&StaticArray_Type, &PyType_Type);
2843 : 8 : Py_INCREF(&StaticArray_Type);
2844 : 8 : PyModule_AddObject(m, "staticarray", (PyObject *)&StaticArray_Type);
2845 : :
2846 : 8 : structmodule = PyImport_ImportModule("struct");
2847 [ - + ]: 8 : if (structmodule == NULL)
2848 : 0 : return NULL;
2849 : :
2850 : 8 : Struct = PyObject_GetAttrString(structmodule, "Struct");
2851 : 8 : calcsize = PyObject_GetAttrString(structmodule, "calcsize");
2852 [ + - - + ]: 8 : if (Struct == NULL || calcsize == NULL)
2853 : 0 : return NULL;
2854 : :
2855 : 8 : simple_format = PyUnicode_FromString(simple_fmt);
2856 [ - + ]: 8 : if (simple_format == NULL)
2857 : 0 : return NULL;
2858 : :
2859 : 8 : PyModule_AddIntMacro(m, ND_MAX_NDIM);
2860 : 8 : PyModule_AddIntMacro(m, ND_VAREXPORT);
2861 : 8 : PyModule_AddIntMacro(m, ND_WRITABLE);
2862 : 8 : PyModule_AddIntMacro(m, ND_FORTRAN);
2863 : 8 : PyModule_AddIntMacro(m, ND_SCALAR);
2864 : 8 : PyModule_AddIntMacro(m, ND_PIL);
2865 : 8 : PyModule_AddIntMacro(m, ND_GETBUF_FAIL);
2866 : 8 : PyModule_AddIntMacro(m, ND_GETBUF_UNDEFINED);
2867 : 8 : PyModule_AddIntMacro(m, ND_REDIRECT);
2868 : :
2869 : 8 : PyModule_AddIntMacro(m, PyBUF_SIMPLE);
2870 : 8 : PyModule_AddIntMacro(m, PyBUF_WRITABLE);
2871 : 8 : PyModule_AddIntMacro(m, PyBUF_FORMAT);
2872 : 8 : PyModule_AddIntMacro(m, PyBUF_ND);
2873 : 8 : PyModule_AddIntMacro(m, PyBUF_STRIDES);
2874 : 8 : PyModule_AddIntMacro(m, PyBUF_INDIRECT);
2875 : 8 : PyModule_AddIntMacro(m, PyBUF_C_CONTIGUOUS);
2876 : 8 : PyModule_AddIntMacro(m, PyBUF_F_CONTIGUOUS);
2877 : 8 : PyModule_AddIntMacro(m, PyBUF_ANY_CONTIGUOUS);
2878 : 8 : PyModule_AddIntMacro(m, PyBUF_FULL);
2879 : 8 : PyModule_AddIntMacro(m, PyBUF_FULL_RO);
2880 : 8 : PyModule_AddIntMacro(m, PyBUF_RECORDS);
2881 : 8 : PyModule_AddIntMacro(m, PyBUF_RECORDS_RO);
2882 : 8 : PyModule_AddIntMacro(m, PyBUF_STRIDED);
2883 : 8 : PyModule_AddIntMacro(m, PyBUF_STRIDED_RO);
2884 : 8 : PyModule_AddIntMacro(m, PyBUF_CONTIG);
2885 : 8 : PyModule_AddIntMacro(m, PyBUF_CONTIG_RO);
2886 : :
2887 : 8 : PyModule_AddIntMacro(m, PyBUF_READ);
2888 : 8 : PyModule_AddIntMacro(m, PyBUF_WRITE);
2889 : :
2890 : 8 : return m;
2891 : : }
2892 : :
2893 : :
2894 : :
|
