third_party/cython/src/Cython/Utility/MemoryView_C.c

   1 ////////// MemviewSliceStruct.proto //////////
   2
   3 /* memoryview slice struct */
   4 struct {{memview_struct_name}};
   5
   6 typedef struct {
   7   struct {{memview_struct_name}} *memview;
   8   char *data;
   9   Py_ssize_t shape[{{max_dims}}];
  10   Py_ssize_t strides[{{max_dims}}];
  11   Py_ssize_t suboffsets[{{max_dims}}];
  12 } {{memviewslice_name}};
  13
  14
  15 /////////// Atomics.proto /////////////
  16
  17 #include <pythread.h>
  18
  19 #ifndef CYTHON_ATOMICS
  20     #define CYTHON_ATOMICS 1
  21 #endif
  22
  23 #define __pyx_atomic_int_type int
  24 // todo: Portland pgcc, maybe OS X's OSAtomicIncrement32,
  25 //       libatomic + autotools-like distutils support? Such a pain...
  26 #if CYTHON_ATOMICS && __GNUC__ >= 4 && (__GNUC_MINOR__ > 1 ||           \
  27                     (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL >= 2)) && \
  28                     !defined(__i386__)
  29     /* gcc >= 4.1.2 */
  30     #define __pyx_atomic_incr_aligned(value, lock) __sync_fetch_and_add(value, 1)
  31     #define __pyx_atomic_decr_aligned(value, lock) __sync_fetch_and_sub(value, 1)
  32
  33     #ifdef __PYX_DEBUG_ATOMICS
  34         #warning "Using GNU atomics"
  35     #endif
  36 #elif CYTHON_ATOMICS && MSC_VER
  37     /* msvc */
  38     #include <Windows.h>
  39     #define __pyx_atomic_int_type LONG
  40     #define __pyx_atomic_incr_aligned(value, lock) InterlockedIncrement(value)
  41     #define __pyx_atomic_decr_aligned(value, lock) InterlockedDecrement(value)
  42
  43     #ifdef __PYX_DEBUG_ATOMICS
  44         #warning "Using MSVC atomics"
  45     #endif
  46 #elif CYTHON_ATOMICS && (defined(__ICC) || defined(__INTEL_COMPILER)) && 0
  47     #define __pyx_atomic_incr_aligned(value, lock) _InterlockedIncrement(value)
  48     #define __pyx_atomic_decr_aligned(value, lock) _InterlockedDecrement(value)
  49
  50     #ifdef __PYX_DEBUG_ATOMICS
  51         #warning "Using Intel atomics"
  52     #endif
  53 #else
  54     #undef CYTHON_ATOMICS
  55     #define CYTHON_ATOMICS 0
  56
  57     #ifdef __PYX_DEBUG_ATOMICS
  58         #warning "Not using atomics"
  59     #endif
  60 #endif
  61
  62 typedef volatile __pyx_atomic_int_type __pyx_atomic_int;
  63
  64 #if CYTHON_ATOMICS
  65     #define __pyx_add_acquisition_count(memview) \
  66              __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
  67     #define __pyx_sub_acquisition_count(memview) \
  68             __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview), memview->lock)
  69 #else
  70     #define __pyx_add_acquisition_count(memview) \
  71             __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
  72     #define __pyx_sub_acquisition_count(memview) \
  73             __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock)
  74 #endif
  75
  76
  77 /////////////// ObjectToMemviewSlice.proto ///////////////
  78
  79 static CYTHON_INLINE {{memviewslice_name}} {{funcname}}(PyObject *);
  80
  81
  82 ////////// MemviewSliceInit.proto //////////
  83
  84 #define __Pyx_BUF_MAX_NDIMS %(BUF_MAX_NDIMS)d
  85
  86 #define __Pyx_MEMVIEW_DIRECT   1
  87 #define __Pyx_MEMVIEW_PTR      2
  88 #define __Pyx_MEMVIEW_FULL     4
  89 #define __Pyx_MEMVIEW_CONTIG   8
  90 #define __Pyx_MEMVIEW_STRIDED  16
  91 #define __Pyx_MEMVIEW_FOLLOW   32
  92
  93 #define __Pyx_IS_C_CONTIG 1
  94 #define __Pyx_IS_F_CONTIG 2
  95
  96 static int __Pyx_init_memviewslice(
  97                 struct __pyx_memoryview_obj *memview,
  98                 int ndim,
  99                 __Pyx_memviewslice *memviewslice,
 100                 int memview_is_new_reference);
 101
 102 static CYTHON_INLINE int __pyx_add_acquisition_count_locked(
 103     __pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
 104 static CYTHON_INLINE int __pyx_sub_acquisition_count_locked(
 105     __pyx_atomic_int *acquisition_count, PyThread_type_lock lock);
 106
 107 #define __pyx_get_slice_count_pointer(memview) (memview->acquisition_count_aligned_p)
 108 #define __pyx_get_slice_count(memview) (*__pyx_get_slice_count_pointer(memview))
 109 #define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__)
 110 #define __PYX_XDEC_MEMVIEW(slice, have_gil) __Pyx_XDEC_MEMVIEW(slice, have_gil, __LINE__)
 111 static CYTHON_INLINE void __Pyx_INC_MEMVIEW({{memviewslice_name}} *, int, int);
 112 static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW({{memviewslice_name}} *, int, int);
 113
 114
 115 /////////////// MemviewSliceIndex.proto ///////////////
 116
 117 static CYTHON_INLINE char *__pyx_memviewslice_index_full(
 118     const char *bufp, Py_ssize_t idx, Py_ssize_t stride, Py_ssize_t suboffset);
 119
 120
 121 /////////////// ObjectToMemviewSlice ///////////////
 122 //@requires: MemviewSliceValidateAndInit
 123
 124 static CYTHON_INLINE {{memviewslice_name}} {{funcname}}(PyObject *obj) {
 125     {{memviewslice_name}} result = {{memslice_init}};
 126     __Pyx_BufFmt_StackElem stack[{{struct_nesting_depth}}];
 127     int axes_specs[] = { {{axes_specs}} };
 128     int retcode;
 129
 130     if (obj == Py_None) {
 131         /* We don't bother to refcount None */
 132         result.memview = (struct __pyx_memoryview_obj *) Py_None;
 133         return result;
 134     }
 135
 136     retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, {{c_or_f_flag}},
 137                                                  {{buf_flag}}, {{ndim}},
 138                                                  &{{dtype_typeinfo}}, stack,
 139                                                  &result, obj);
 140
 141     if (unlikely(retcode == -1))
 142         goto __pyx_fail;
 143
 144     return result;
 145 __pyx_fail:
 146     result.memview = NULL;
 147     result.data = NULL;
 148     return result;
 149 }
 150
 151
 152 /////////////// MemviewSliceValidateAndInit.proto ///////////////
 153
 154 static int __Pyx_ValidateAndInit_memviewslice(
 155                 int *axes_specs,
 156                 int c_or_f_flag,
 157                 int buf_flags,
 158                 int ndim,
 159                 __Pyx_TypeInfo *dtype,
 160                 __Pyx_BufFmt_StackElem stack[],
 161                 __Pyx_memviewslice *memviewslice,
 162                 PyObject *original_obj);
 163
 164 /////////////// MemviewSliceValidateAndInit ///////////////
 165 //@requires: Buffer.c::TypeInfoCompare
 166
 167 static int
 168 __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec)
 169 {
 170     if (buf->shape[dim] <= 1)
 171         return 1;
 172
 173     if (buf->strides) {
 174         if (spec & __Pyx_MEMVIEW_CONTIG) {
 175             if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) {
 176                 if (buf->strides[dim] != sizeof(void *)) {
 177                     PyErr_Format(PyExc_ValueError,
 178                                  "Buffer is not indirectly contiguous "
 179                                  "in dimension %d.", dim);
 180                     goto fail;
 181                 }
 182             } else if (buf->strides[dim] != buf->itemsize) {
 183                 PyErr_SetString(PyExc_ValueError,
 184                                 "Buffer and memoryview are not contiguous "
 185                                 "in the same dimension.");
 186                 goto fail;
 187             }
 188         }
 189
 190         if (spec & __Pyx_MEMVIEW_FOLLOW) {
 191             Py_ssize_t stride = buf->strides[dim];
 192             if (stride < 0)
 193                 stride = -stride;
 194             if (stride < buf->itemsize) {
 195                 PyErr_SetString(PyExc_ValueError,
 196                                 "Buffer and memoryview are not contiguous "
 197                                 "in the same dimension.");
 198                 goto fail;
 199             }
 200         }
 201     } else {
 202         if (spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1) {
 203             PyErr_Format(PyExc_ValueError,
 204                          "C-contiguous buffer is not contiguous in "
 205                          "dimension %d", dim);
 206             goto fail;
 207         } else if (spec & (__Pyx_MEMVIEW_PTR)) {
 208             PyErr_Format(PyExc_ValueError,
 209                          "C-contiguous buffer is not indirect in "
 210                          "dimension %d", dim);
 211             goto fail;
 212         } else if (buf->suboffsets) {
 213             PyErr_SetString(PyExc_ValueError,
 214                             "Buffer exposes suboffsets but no strides");
 215             goto fail;
 216         }
 217     }
 218
 219     return 1;
 220 fail:
 221     return 0;
 222 }
 223
 224 static int
 225 __pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec)
 226 {
 227     // Todo: without PyBUF_INDIRECT we may not have suboffset information, i.e., the
 228     //       ptr may not be set to NULL but may be uninitialized?
 229     if (spec & __Pyx_MEMVIEW_DIRECT) {
 230         if (buf->suboffsets && buf->suboffsets[dim] >= 0) {
 231             PyErr_Format(PyExc_ValueError,
 232                          "Buffer not compatible with direct access "
 233                          "in dimension %d.", dim);
 234             goto fail;
 235         }
 236     }
 237
 238     if (spec & __Pyx_MEMVIEW_PTR) {
 239         if (!buf->suboffsets || (buf->suboffsets && buf->suboffsets[dim] < 0)) {
 240             PyErr_Format(PyExc_ValueError,
 241                          "Buffer is not indirectly accessible "
 242                          "in dimension %d.", dim);
 243             goto fail;
 244         }
 245     }
 246
 247     return 1;
 248 fail:
 249     return 0;
 250 }
 251
 252 static int
 253 __pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag)
 254 {
 255     int i;
 256
 257     if (c_or_f_flag & __Pyx_IS_F_CONTIG) {
 258         Py_ssize_t stride = 1;
 259         for (i = 0; i < ndim; i++) {
 260             if (stride * buf->itemsize != buf->strides[i] &&
 261                     buf->shape[i] > 1)
 262             {
 263                 PyErr_SetString(PyExc_ValueError,
 264                     "Buffer not fortran contiguous.");
 265                 goto fail;
 266             }
 267             stride = stride * buf->shape[i];
 268         }
 269     } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) {
 270         Py_ssize_t stride = 1;
 271         for (i = ndim - 1; i >- 1; i--) {
 272             if (stride * buf->itemsize != buf->strides[i] &&
 273                     buf->shape[i] > 1) {
 274                 PyErr_SetString(PyExc_ValueError,
 275                     "Buffer not C contiguous.");
 276                 goto fail;
 277             }
 278             stride = stride * buf->shape[i];
 279         }
 280     }
 281
 282     return 1;
 283 fail:
 284     return 0;
 285 }
 286
 287 static int __Pyx_ValidateAndInit_memviewslice(
 288                 int *axes_specs,
 289                 int c_or_f_flag,
 290                 int buf_flags,
 291                 int ndim,
 292                 __Pyx_TypeInfo *dtype,
 293                 __Pyx_BufFmt_StackElem stack[],
 294                 __Pyx_memviewslice *memviewslice,
 295                 PyObject *original_obj)
 296 {
 297     struct __pyx_memoryview_obj *memview, *new_memview;
 298     __Pyx_RefNannyDeclarations
 299     Py_buffer *buf;
 300     int i, spec = 0, retval = -1;
 301     __Pyx_BufFmt_Context ctx;
 302     int from_memoryview = __pyx_memoryview_check(original_obj);
 303
 304     __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0);
 305
 306     if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *)
 307                                                             original_obj)->typeinfo)) {
 308         /* We have a matching dtype, skip format parsing */
 309         memview = (struct __pyx_memoryview_obj *) original_obj;
 310         new_memview = NULL;
 311     } else {
 312         memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new(
 313                                             original_obj, buf_flags, 0, dtype);
 314         new_memview = memview;
 315         if (unlikely(!memview))
 316             goto fail;
 317     }
 318
 319     buf = &memview->view;
 320     if (buf->ndim != ndim) {
 321         PyErr_Format(PyExc_ValueError,
 322                 "Buffer has wrong number of dimensions (expected %d, got %d)",
 323                 ndim, buf->ndim);
 324         goto fail;
 325     }
 326
 327     if (new_memview) {
 328         __Pyx_BufFmt_Init(&ctx, stack, dtype);
 329         if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
 330     }
 331
 332     if ((unsigned) buf->itemsize != dtype->size) {
 333         PyErr_Format(PyExc_ValueError,
 334                      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) "
 335                      "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)",
 336                      buf->itemsize,
 337                      (buf->itemsize > 1) ? "s" : "",
 338                      dtype->name,
 339                      dtype->size,
 340                      (dtype->size > 1) ? "s" : "");
 341         goto fail;
 342     }
 343
 344     /* Check axes */
 345     for (i = 0; i < ndim; i++) {
 346         spec = axes_specs[i];
 347         if (!__pyx_check_strides(buf, i, ndim, spec))
 348             goto fail;
 349         if (!__pyx_check_suboffsets(buf, i, ndim, spec))
 350             goto fail;
 351     }
 352
 353     /* Check contiguity */
 354     if (buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))
 355         goto fail;
 356
 357     /* Initialize */
 358     if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice,
 359                                          new_memview != NULL) == -1)) {
 360         goto fail;
 361     }
 362
 363     retval = 0;
 364     goto no_fail;
 365
 366 fail:
 367     Py_XDECREF(new_memview);
 368     retval = -1;
 369
 370 no_fail:
 371     __Pyx_RefNannyFinishContext();
 372     return retval;
 373 }
 374
 375
 376 ////////// MemviewSliceInit //////////
 377
 378 static int
 379 __Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview,
 380                         int ndim,
 381                         {{memviewslice_name}} *memviewslice,
 382                         int memview_is_new_reference)
 383 {
 384     __Pyx_RefNannyDeclarations
 385     int i, retval=-1;
 386     Py_buffer *buf = &memview->view;
 387     __Pyx_RefNannySetupContext("init_memviewslice", 0);
 388
 389     if (!buf) {
 390         PyErr_SetString(PyExc_ValueError,
 391             "buf is NULL.");
 392         goto fail;
 393     } else if (memviewslice->memview || memviewslice->data) {
 394         PyErr_SetString(PyExc_ValueError,
 395             "memviewslice is already initialized!");
 396         goto fail;
 397     }
 398
 399     if (buf->strides) {
 400         for (i = 0; i < ndim; i++) {
 401             memviewslice->strides[i] = buf->strides[i];
 402         }
 403     } else {
 404         Py_ssize_t stride = buf->itemsize;
 405         for (i = ndim - 1; i >= 0; i--) {
 406             memviewslice->strides[i] = stride;
 407             stride *= buf->shape[i];
 408         }
 409     }
 410
 411     for (i = 0; i < ndim; i++) {
 412         memviewslice->shape[i]   = buf->shape[i];
 413         if (buf->suboffsets) {
 414             memviewslice->suboffsets[i] = buf->suboffsets[i];
 415         } else {
 416             memviewslice->suboffsets[i] = -1;
 417         }
 418     }
 419
 420     memviewslice->memview = memview;
 421     memviewslice->data = (char *)buf->buf;
 422     if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) {
 423         Py_INCREF(memview);
 424     }
 425     retval = 0;
 426     goto no_fail;
 427
 428 fail:
 429     /* Don't decref, the memoryview may be borrowed. Let the caller do the cleanup */
 430     /* __Pyx_XDECREF(memviewslice->memview); */
 431     memviewslice->memview = 0;
 432     memviewslice->data = 0;
 433     retval = -1;
 434 no_fail:
 435     __Pyx_RefNannyFinishContext();
 436     return retval;
 437 }
 438
 439
 440 static CYTHON_INLINE void __pyx_fatalerror(const char *fmt, ...) {
 441     va_list vargs;
 442     char msg[200];
 443
 444     va_start(vargs, fmt);
 445
 446 #ifdef HAVE_STDARG_PROTOTYPES
 447     va_start(vargs, fmt);
 448 #else
 449     va_start(vargs);
 450 #endif
 451
 452     vsnprintf(msg, 200, fmt, vargs);
 453     Py_FatalError(msg);
 454
 455     va_end(vargs);
 456 }
 457
 458 static CYTHON_INLINE int
 459 __pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
 460                                    PyThread_type_lock lock)
 461 {
 462     int result;
 463     PyThread_acquire_lock(lock, 1);
 464     result = (*acquisition_count)++;
 465     PyThread_release_lock(lock);
 466     return result;
 467 }
 468
 469 static CYTHON_INLINE int
 470 __pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count,
 471                                    PyThread_type_lock lock)
 472 {
 473     int result;
 474     PyThread_acquire_lock(lock, 1);
 475     result = (*acquisition_count)--;
 476     PyThread_release_lock(lock);
 477     return result;
 478 }
 479
 480
 481 static CYTHON_INLINE void
 482 __Pyx_INC_MEMVIEW({{memviewslice_name}} *memslice, int have_gil, int lineno)
 483 {
 484     int first_time;
 485     struct {{memview_struct_name}} *memview = memslice->memview;
 486     if (!memview || (PyObject *) memview == Py_None)
 487         return; /* allow uninitialized memoryview assignment */
 488
 489     if (__pyx_get_slice_count(memview) < 0)
 490         __pyx_fatalerror("Acquisition count is %d (line %d)",
 491                          __pyx_get_slice_count(memview), lineno);
 492
 493     first_time = __pyx_add_acquisition_count(memview) == 0;
 494
 495     if (first_time) {
 496         if (have_gil) {
 497             Py_INCREF((PyObject *) memview);
 498         } else {
 499             PyGILState_STATE _gilstate = PyGILState_Ensure();
 500             Py_INCREF((PyObject *) memview);
 501             PyGILState_Release(_gilstate);
 502         }
 503     }
 504 }
 505
 506 static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW({{memviewslice_name}} *memslice,
 507                                              int have_gil, int lineno) {
 508     int last_time;
 509     struct {{memview_struct_name}} *memview = memslice->memview;
 510
 511     if (!memview ) {
 512         return;
 513     } else if ((PyObject *) memview == Py_None) {
 514         memslice->memview = NULL;
 515         return;
 516     }
 517
 518     if (__pyx_get_slice_count(memview) <= 0)
 519         __pyx_fatalerror("Acquisition count is %d (line %d)",
 520                          __pyx_get_slice_count(memview), lineno);
 521
 522     last_time = __pyx_sub_acquisition_count(memview) == 1;
 523     memslice->data = NULL;
 524     if (last_time) {
 525         if (have_gil) {
 526             Py_CLEAR(memslice->memview);
 527         } else {
 528             PyGILState_STATE _gilstate = PyGILState_Ensure();
 529             Py_CLEAR(memslice->memview);
 530             PyGILState_Release(_gilstate);
 531         }
 532     } else {
 533         memslice->memview = NULL;
 534     }
 535 }
 536
 537
 538 ////////// MemviewSliceCopyTemplate.proto //////////
 539
 540 static {{memviewslice_name}}
 541 __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
 542                                  const char *mode, int ndim,
 543                                  size_t sizeof_dtype, int contig_flag,
 544                                  int dtype_is_object);
 545
 546
 547 ////////// MemviewSliceCopyTemplate //////////
 548
 549 static {{memviewslice_name}}
 550 __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs,
 551                                  const char *mode, int ndim,
 552                                  size_t sizeof_dtype, int contig_flag,
 553                                  int dtype_is_object)
 554 {
 555     __Pyx_RefNannyDeclarations
 556     int i;
 557     __Pyx_memviewslice new_mvs = {{memslice_init}};
 558     struct __pyx_memoryview_obj *from_memview = from_mvs->memview;
 559     Py_buffer *buf = &from_memview->view;
 560     PyObject *shape_tuple = NULL;
 561     PyObject *temp_int = NULL;
 562     struct __pyx_array_obj *array_obj = NULL;
 563     struct __pyx_memoryview_obj *memview_obj = NULL;
 564
 565     __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0);
 566
 567     for (i = 0; i < ndim; i++) {
 568         if (from_mvs->suboffsets[i] >= 0) {
 569             PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with "
 570                                            "indirect dimensions (axis %d)", i);
 571             goto fail;
 572         }
 573     }
 574
 575     shape_tuple = PyTuple_New(ndim);
 576     if (unlikely(!shape_tuple)) {
 577         goto fail;
 578     }
 579     __Pyx_GOTREF(shape_tuple);
 580
 581
 582     for(i = 0; i < ndim; i++) {
 583         temp_int = PyInt_FromSsize_t(from_mvs->shape[i]);
 584         if(unlikely(!temp_int)) {
 585             goto fail;
 586         } else {
 587             PyTuple_SET_ITEM(shape_tuple, i, temp_int);
 588             temp_int = NULL;
 589         }
 590     }
 591
 592     array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL);
 593     if (unlikely(!array_obj)) {
 594         goto fail;
 595     }
 596     __Pyx_GOTREF(array_obj);
 597
 598     memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new(
 599                                     (PyObject *) array_obj, contig_flag,
 600                                     dtype_is_object,
 601                                     from_mvs->memview->typeinfo);
 602     if (unlikely(!memview_obj))
 603         goto fail;
 604
 605     /* initialize new_mvs */
 606     if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0))
 607         goto fail;
 608
 609     if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim,
 610                                                 dtype_is_object) < 0))
 611         goto fail;
 612
 613     goto no_fail;
 614
 615 fail:
 616     __Pyx_XDECREF(new_mvs.memview);
 617     new_mvs.memview = NULL;
 618     new_mvs.data = NULL;
 619 no_fail:
 620     __Pyx_XDECREF(shape_tuple);
 621     __Pyx_XDECREF(temp_int);
 622     __Pyx_XDECREF(array_obj);
 623     __Pyx_RefNannyFinishContext();
 624     return new_mvs;
 625 }
 626
 627
 628 ////////// CopyContentsUtility.proto /////////
 629
 630 #define {{func_cname}}(slice) \
 631         __pyx_memoryview_copy_new_contig(&slice, "{{mode}}", {{ndim}},            \
 632                                          sizeof({{dtype_decl}}), {{contig_flag}}, \
 633                                          {{dtype_is_object}})
 634
 635
 636 ////////// OverlappingSlices.proto //////////
 637
 638 static int __pyx_slices_overlap({{memviewslice_name}} *slice1,
 639                                 {{memviewslice_name}} *slice2,
 640                                 int ndim, size_t itemsize);
 641
 642
 643 ////////// OverlappingSlices //////////
 644
 645 /* Based on numpy's core/src/multiarray/array_assign.c */
 646
 647 /* Gets a half-open range [start, end) which contains the array data */
 648 static void
 649 __pyx_get_array_memory_extents({{memviewslice_name}} *slice,
 650                                void **out_start, void **out_end,
 651                                int ndim, size_t itemsize)
 652 {
 653     char *start, *end;
 654     int i;
 655
 656     start = end = slice->data;
 657
 658     for (i = 0; i < ndim; i++) {
 659         Py_ssize_t stride = slice->strides[i];
 660         Py_ssize_t extent = slice->shape[i];
 661
 662         if (extent == 0) {
 663             *out_start = *out_end = start;
 664             return;
 665         } else {
 666             if (stride > 0)
 667                 end += stride * (extent - 1);
 668             else
 669                 start += stride * (extent - 1);
 670         }
 671     }
 672
 673     /* Return a half-open range */
 674     *out_start = start;
 675     *out_end = end + itemsize;
 676 }
 677
 678 /* Returns 1 if the arrays have overlapping data, 0 otherwise */
 679 static int
 680 __pyx_slices_overlap({{memviewslice_name}} *slice1,
 681                      {{memviewslice_name}} *slice2,
 682                      int ndim, size_t itemsize)
 683 {
 684     void *start1, *end1, *start2, *end2;
 685
 686     __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize);
 687     __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize);
 688
 689     return (start1 < end2) && (start2 < end1);
 690 }
 691
 692
 693 ////////// MemviewSliceIsCContig.proto //////////
 694
 695 #define __pyx_memviewslice_is_c_contig{{ndim}}(slice) \
 696         __pyx_memviewslice_is_contig(&slice, 'C', {{ndim}})
 697
 698
 699 ////////// MemviewSliceIsFContig.proto //////////
 700
 701 #define __pyx_memviewslice_is_f_contig{{ndim}}(slice) \
 702         __pyx_memviewslice_is_contig(&slice, 'F', {{ndim}})
 703
 704
 705 ////////// MemviewSliceIsContig.proto //////////
 706
 707 static int __pyx_memviewslice_is_contig(const {{memviewslice_name}} *mvs,
 708                                         char order, int ndim);
 709
 710
 711 ////////// MemviewSliceIsContig //////////
 712
 713 static int
 714 __pyx_memviewslice_is_contig(const {{memviewslice_name}} *mvs,
 715                              char order, int ndim)
 716 {
 717     int i, index, step, start;
 718     Py_ssize_t itemsize = mvs->memview->view.itemsize;
 719
 720     if (order == 'F') {
 721         step = 1;
 722         start = 0;
 723     } else {
 724         step = -1;
 725         start = ndim - 1;
 726     }
 727
 728     for (i = 0; i < ndim; i++) {
 729         index = start + step * i;
 730         if (mvs->suboffsets[index] >= 0 || mvs->strides[index] != itemsize)
 731             return 0;
 732
 733         itemsize *= mvs->shape[index];
 734     }
 735
 736     return 1;
 737 }
 738
 739
 740 /////////////// MemviewSliceIndex ///////////////
 741
 742 static CYTHON_INLINE char *
 743 __pyx_memviewslice_index_full(const char *bufp, Py_ssize_t idx,
 744                               Py_ssize_t stride, Py_ssize_t suboffset)
 745 {
 746     bufp = bufp + idx * stride;
 747     if (suboffset >= 0) {
 748         bufp = *((char **) bufp) + suboffset;
 749     }
 750     return (char *) bufp;
 751 }
 752
 753
 754 /////////////// MemviewDtypeToObject.proto ///////////////
 755
 756 {{if to_py_function}}
 757 static PyObject *{{get_function}}(const char *itemp); /* proto */
 758 {{endif}}
 759
 760 {{if from_py_function}}
 761 static int {{set_function}}(const char *itemp, PyObject *obj); /* proto */
 762 {{endif}}
 763
 764 /////////////// MemviewDtypeToObject ///////////////
 765
 766 {{#__pyx_memview_<dtype_name>_to_object}}
 767
 768 /* Convert a dtype to or from a Python object */
 769
 770 {{if to_py_function}}
 771 static PyObject *{{get_function}}(const char *itemp) {
 772     return (PyObject *) {{to_py_function}}(*({{dtype}} *) itemp);
 773 }
 774 {{endif}}
 775
 776 {{if from_py_function}}
 777 static int {{set_function}}(const char *itemp, PyObject *obj) {
 778     {{dtype}} value = {{from_py_function}}(obj);
 779     if ({{error_condition}})
 780         return 0;
 781     *({{dtype}} *) itemp = value;
 782     return 1;
 783 }
 784 {{endif}}
 785
 786
 787 /////////////// MemviewObjectToObject.proto ///////////////
 788
 789 /* Function callbacks (for memoryview object) for dtype object */
 790 static PyObject *{{get_function}}(const char *itemp); /* proto */
 791 static int {{set_function}}(const char *itemp, PyObject *obj); /* proto */
 792
 793
 794 /////////////// MemviewObjectToObject ///////////////
 795
 796 static PyObject *{{get_function}}(const char *itemp) {
 797     PyObject *result = *(PyObject **) itemp;
 798     Py_INCREF(result);
 799     return result;
 800 }
 801
 802 static int {{set_function}}(const char *itemp, PyObject *obj) {
 803     Py_INCREF(obj);
 804     Py_DECREF(*(PyObject **) itemp);
 805     *(PyObject **) itemp = obj;
 806     return 1;
 807 }
 808
 809 /////////// ToughSlice //////////
 810
 811 /* Dimension is indexed with 'start:stop:step' */
 812
 813 if (unlikely(__pyx_memoryview_slice_memviewslice(
 814     &{{dst}},
 815     {{src}}.shape[{{dim}}], {{src}}.strides[{{dim}}], {{src}}.suboffsets[{{dim}}],
 816     {{dim}},
 817     {{new_ndim}},
 818     &{{suboffset_dim}},
 819     {{start}},
 820     {{stop}},
 821     {{step}},
 822     {{int(have_start)}},
 823     {{int(have_stop)}},
 824     {{int(have_step)}},
 825     1) < 0))
 826 {
 827     {{error_goto}}
 828 }
 829
 830
 831 ////////// SimpleSlice //////////
 832
 833 /* Dimension is indexed with ':' only */
 834
 835 {{dst}}.shape[{{new_ndim}}] = {{src}}.shape[{{dim}}];
 836 {{dst}}.strides[{{new_ndim}}] = {{src}}.strides[{{dim}}];
 837
 838 {{if access == 'direct'}}
 839     {{dst}}.suboffsets[{{new_ndim}}] = -1;
 840 {{else}}
 841     {{dst}}.suboffsets[{{new_ndim}}] = {{src}}.suboffsets[{{dim}}];
 842     if ({{src}}.suboffsets[{{dim}}] >= 0)
 843         {{suboffset_dim}} = {{new_ndim}};
 844 {{endif}}
 845
 846
 847 ////////// SliceIndex //////////
 848
 849 // Dimension is indexed with an integer, we could use the ToughSlice
 850 // approach, but this is faster
 851
 852 {
 853     Py_ssize_t __pyx_tmp_idx = {{idx}};
 854     Py_ssize_t __pyx_tmp_shape = {{src}}.shape[{{dim}}];
 855     Py_ssize_t __pyx_tmp_stride = {{src}}.strides[{{dim}}];
 856     if ({{wraparound}} && (__pyx_tmp_idx < 0))
 857         __pyx_tmp_idx += __pyx_tmp_shape;
 858
 859     if ({{boundscheck}} && (__pyx_tmp_idx < 0 || __pyx_tmp_idx >= __pyx_tmp_shape)) {
 860         {{if not have_gil}}
 861             #ifdef WITH_THREAD
 862             PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();
 863             #endif
 864         {{endif}}
 865
 866         PyErr_SetString(PyExc_IndexError, "Index out of bounds (axis {{dim}})");
 867
 868         {{if not have_gil}}
 869             #ifdef WITH_THREAD
 870             PyGILState_Release(__pyx_gilstate_save);
 871             #endif
 872         {{endif}}
 873
 874         {{error_goto}}
 875     }
 876
 877     {{if all_dimensions_direct}}
 878         {{dst}}.data += __pyx_tmp_idx * __pyx_tmp_stride;
 879     {{else}}
 880         if ({{suboffset_dim}} < 0) {
 881             {{dst}}.data += __pyx_tmp_idx * __pyx_tmp_stride;
 882
 883             /* This dimension is the first dimension, or is preceded by    */
 884             /* direct or indirect dimensions that are indexed away.        */
 885             /* Hence suboffset_dim must be less than zero, and we can have */
 886             /* our data pointer refer to another block by dereferencing.   */
 887             /*   slice.data -> B -> C     becomes     slice.data -> C      */
 888
 889             {{if indirect}}
 890               {
 891                 Py_ssize_t __pyx_tmp_suboffset = {{src}}.suboffsets[{{dim}}];
 892
 893                 {{if generic}}
 894                     if (__pyx_tmp_suboffset >= 0)
 895                 {{endif}}
 896
 897                     {{dst}}.data = *((char **) {{dst}}.data) + __pyx_tmp_suboffset;
 898               }
 899             {{endif}}
 900
 901         } else {
 902             {{dst}}.suboffsets[{{suboffset_dim}}] += __pyx_tmp_idx * __pyx_tmp_stride;
 903
 904             /* Note: dimension can not be indirect, the compiler will have */
 905             /*       issued an error */
 906         }
 907
 908     {{endif}}
 909 }
 910
 911
 912 ////////// FillStrided1DScalar.proto //////////
 913
 914 static void
 915 __pyx_fill_slice_{{dtype_name}}({{type_decl}} *p, Py_ssize_t extent, Py_ssize_t stride,
 916                                 size_t itemsize, void *itemp);
 917
 918 ////////// FillStrided1DScalar //////////
 919
 920 /* Fill a slice with a scalar value. The dimension is direct and strided or contiguous */
 921 /* This can be used as a callback for the memoryview object to efficienty assign a scalar */
 922 /* Currently unused */
 923 static void
 924 __pyx_fill_slice_{{dtype_name}}({{type_decl}} *p, Py_ssize_t extent, Py_ssize_t stride,
 925                                 size_t itemsize, void *itemp)
 926 {
 927     Py_ssize_t i;
 928     {{type_decl}} item = *(({{type_decl}} *) itemp);
 929     {{type_decl}} *endp;
 930
 931     stride /= sizeof({{type_decl}});
 932     endp = p + stride * extent;
 933
 934     while (p < endp) {
 935         *p = item;
 936         p += stride;
 937     }
 938 }