MemoryView.pyx 46.8 KB
Newer Older
1
#################### View.MemoryView ####################
2

3 4
# This utility provides cython.array and cython.view.memoryview

5 6 7
from __future__ import absolute_import

cimport cython
8

9
# from cpython cimport ...
10
cdef extern from "Python.h":
11
    int PyIndex_Check(object)
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
    object PyLong_FromVoidPtr(void *)

cdef extern from "pythread.h":
    ctypedef void *PyThread_type_lock

    PyThread_type_lock PyThread_allocate_lock()
    void PyThread_free_lock(PyThread_type_lock)
    int PyThread_acquire_lock(PyThread_type_lock, int mode) nogil
    void PyThread_release_lock(PyThread_type_lock) nogil

cdef extern from "string.h":
    void *memset(void *b, int c, size_t len)

cdef extern from *:
    int __Pyx_GetBuffer(object, Py_buffer *, int) except -1
    void __Pyx_ReleaseBuffer(Py_buffer *)

    ctypedef struct PyObject
30
    ctypedef Py_ssize_t Py_intptr_t
31 32 33
    void Py_INCREF(PyObject *)
    void Py_DECREF(PyObject *)

34 35 36
    void* PyMem_Malloc(size_t n)
    void PyMem_Free(void *p)

37 38 39
    cdef struct __pyx_memoryview "__pyx_memoryview_obj":
        Py_buffer view
        PyObject *obj
40
        __Pyx_TypeInfo *typeinfo
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

    ctypedef struct {{memviewslice_name}}:
        __pyx_memoryview *memview
        char *data
        Py_ssize_t shape[{{max_dims}}]
        Py_ssize_t strides[{{max_dims}}]
        Py_ssize_t suboffsets[{{max_dims}}]

    void __PYX_INC_MEMVIEW({{memviewslice_name}} *memslice, int have_gil)
    void __PYX_XDEC_MEMVIEW({{memviewslice_name}} *memslice, int have_gil)

    ctypedef struct __pyx_buffer "Py_buffer":
        PyObject *obj

    PyObject *Py_None
56 57 58 59 60

    cdef enum:
        PyBUF_C_CONTIGUOUS,
        PyBUF_F_CONTIGUOUS,
        PyBUF_ANY_CONTIGUOUS
61
        PyBUF_FORMAT
62
        PyBUF_WRITABLE
63 64 65
        PyBUF_STRIDES
        PyBUF_INDIRECT
        PyBUF_RECORDS
66

67 68 69
    ctypedef struct __Pyx_TypeInfo:
        pass

70 71 72
    cdef object capsule "__pyx_capsule_create" (void *p, char *sig)
    cdef int __pyx_array_getbuffer(PyObject *obj, Py_buffer view, int flags)
    cdef int __pyx_memoryview_getbuffer(PyObject *obj, Py_buffer view, int flags)
73

74 75 76 77 78 79 80 81
cdef extern from *:
    ctypedef int __pyx_atomic_int
    {{memviewslice_name}} slice_copy_contig "__pyx_memoryview_copy_new_contig"(
                                 __Pyx_memviewslice *from_mvs,
                                 char *mode, int ndim,
                                 size_t sizeof_dtype, int contig_flag,
                                 bint dtype_is_object) nogil except *
    bint slice_is_contig "__pyx_memviewslice_is_contig" (
82
                            {{memviewslice_name}} mvs, char order, int ndim) nogil
83 84 85
    bint slices_overlap "__pyx_slices_overlap" ({{memviewslice_name}} *slice1,
                                                {{memviewslice_name}} *slice2,
                                                int ndim, size_t itemsize) nogil
86

87

88 89 90 91 92
cdef extern from "stdlib.h":
    void *malloc(size_t) nogil
    void free(void *) nogil
    void *memcpy(void *dest, void *src, size_t n) nogil

93

94 95


96 97 98 99
#
### cython.array class
#

100 101 102 103 104 105 106 107
@cname("__pyx_array")
cdef class array:

    cdef:
        char *data
        Py_ssize_t len
        char *format
        int ndim
108 109
        Py_ssize_t *_shape
        Py_ssize_t *_strides
110
        Py_ssize_t itemsize
Stefan Behnel's avatar
Stefan Behnel committed
111
        unicode mode  # FIXME: this should have been a simple 'char'
112
        bytes _format
113
        void (*callback_free_data)(void *data)
114
        # cdef object _memview
115
        cdef bint free_data
116
        cdef bint dtype_is_object
117

118
    def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None,
119
                  mode="c", bint allocate_buffer=True):
120

121
        cdef int idx
122
        cdef Py_ssize_t i, dim
123 124
        cdef PyObject **p

125
        self.ndim = <int> len(shape)
126 127 128 129 130
        self.itemsize = itemsize

        if not self.ndim:
            raise ValueError("Empty shape tuple for cython.array")

131
        if itemsize <= 0:
132 133
            raise ValueError("itemsize <= 0 for cython.array")

134 135
        if not isinstance(format, bytes):
            format = format.encode('ASCII')
136
        self._format = format  # keep a reference to the byte string
137 138
        self.format = self._format

139
        # use single malloc() for both shape and strides
140
        self._shape = <Py_ssize_t *> PyMem_Malloc(sizeof(Py_ssize_t)*self.ndim*2)
141
        self._strides = self._shape + self.ndim
142

143 144
        if not self._shape:
            raise MemoryError("unable to allocate shape and strides.")
145 146

        # cdef Py_ssize_t dim, stride
147
        for idx, dim in enumerate(shape):
148
            if dim <= 0:
149
                raise ValueError("Invalid shape in axis %d: %d." % (idx, dim))
150
            self._shape[idx] = dim
151

152 153
        cdef char order
        if mode == 'fortran':
154
            order = b'F'
Stefan Behnel's avatar
Stefan Behnel committed
155
            self.mode = u'fortran'
156 157
        elif mode == 'c':
            order = b'C'
158
            self.mode = u'c'
159 160
        else:
            raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode)
161 162 163

        self.len = fill_contig_strides_array(self._shape, self._strides,
                                             itemsize, self.ndim, order)
164

165
        self.free_data = allocate_buffer
166
        self.dtype_is_object = format == b'O'
167
        if allocate_buffer:
168 169 170
            # use malloc() for backwards compatibility
            # in case external code wants to change the data pointer
            self.data = <char *>malloc(self.len)
171 172 173
            if not self.data:
                raise MemoryError("unable to allocate array data.")

174 175 176 177 178
            if self.dtype_is_object:
                p = <PyObject **> self.data
                for i in range(self.len / itemsize):
                    p[i] = Py_None
                    Py_INCREF(Py_None)
179

180
    @cname('getbuffer')
181 182
    def __getbuffer__(self, Py_buffer *info, int flags):
        cdef int bufmode = -1
183
        if self.mode == u"c":
184
            bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
185
        elif self.mode == u"fortran":
186 187 188 189 190 191
            bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS
        if not (flags & bufmode):
            raise ValueError("Can only create a buffer that is contiguous in memory.")
        info.buf = self.data
        info.len = self.len
        info.ndim = self.ndim
192 193
        info.shape = self._shape
        info.strides = self._strides
194 195
        info.suboffsets = NULL
        info.itemsize = self.itemsize
196
        info.readonly = 0
197 198 199 200 201 202

        if flags & PyBUF_FORMAT:
            info.format = self.format
        else:
            info.format = NULL

203 204
        info.obj = self

205 206
    __pyx_getbuffer = capsule(<void *> &__pyx_array_getbuffer, "getbuffer(obj, view, flags)")

207
    def __dealloc__(array self):
208 209
        if self.callback_free_data != NULL:
            self.callback_free_data(self.data)
210
        elif self.free_data:
211 212 213
            if self.dtype_is_object:
                refcount_objects_in_slice(self.data, self._shape,
                                          self._strides, self.ndim, False)
214
            free(self.data)
215
        PyMem_Free(self._shape)
216

217
    property memview:
218
        @cname('get_memview')
219
        def __get__(self):
220
            # Make this a property as 'self.data' may be set after instantiation
221
            flags =  PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE
222
            return  memoryview(self, flags, self.dtype_is_object)
223 224 225 226


    def __getattr__(self, attr):
        return getattr(self.memview, attr)
227

228 229 230 231 232
    def __getitem__(self, item):
        return self.memview[item]

    def __setitem__(self, item, value):
        self.memview[item] = value
233 234


235
@cname("__pyx_array_new")
236 237
cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format,
                          char *mode, char *buf):
238
    cdef array result
239

240 241 242
    if buf == NULL:
        result = array(shape, itemsize, format, mode.decode('ASCII'))
    else:
243 244
        result = array(shape, itemsize, format, mode.decode('ASCII'),
                       allocate_buffer=False)
245 246 247
        result.data = buf

    return result
248

249

250 251 252
#
### Memoryview constants and cython.view.memoryview class
#
253

254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
# Disable generic_contiguous, as it makes trouble verifying contiguity:
#   - 'contiguous' or '::1' means the dimension is contiguous with dtype
#   - 'indirect_contiguous' means a contiguous list of pointers
#   - dtype contiguous must be contiguous in the first or last dimension
#     from the start, or from the dimension following the last indirect dimension
#
#   e.g.
#           int[::indirect_contiguous, ::contiguous, :]
#
#   is valid (list of pointers to 2d fortran-contiguous array), but
#
#           int[::generic_contiguous, ::contiguous, :]
#
#   would mean you'd have assert dimension 0 to be indirect (and pointer contiguous) at runtime.
#   So it doesn't bring any performance benefit, and it's only confusing.

270 271 272 273 274 275 276 277
@cname('__pyx_MemviewEnum')
cdef class Enum(object):
    cdef object name
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return self.name

278 279 280
cdef generic = Enum("<strided and direct or indirect>")
cdef strided = Enum("<strided and direct>") # default
cdef indirect = Enum("<strided and indirect>")
281 282
# Disable generic_contiguous, as it is a troublemaker
#cdef generic_contiguous = Enum("<contiguous and direct or indirect>")
283 284
cdef contiguous = Enum("<contiguous and direct>")
cdef indirect_contiguous = Enum("<contiguous and indirect>")
285

286
# 'follow' is implied when the first or last axis is ::1
287

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302

@cname('__pyx_align_pointer')
cdef void *align_pointer(void *memory, size_t alignment) nogil:
    "Align pointer memory on a given boundary"
    cdef Py_intptr_t aligned_p = <Py_intptr_t> memory
    cdef size_t offset

    with cython.cdivision(True):
        offset = aligned_p % alignment

    if offset > 0:
        aligned_p += alignment - offset

    return <void *> aligned_p

303 304 305 306
@cname('__pyx_memoryview')
cdef class memoryview(object):

    cdef object obj
307 308
    cdef object _size
    cdef object _array_interface
309
    cdef PyThread_type_lock lock
310 311 312 313
    # the following array will contain a single __pyx_atomic int with
    # suitable alignment
    cdef __pyx_atomic_int acquisition_count[2]
    cdef __pyx_atomic_int *acquisition_count_aligned_p
314
    cdef Py_buffer view
315
    cdef int flags
316
    cdef bint dtype_is_object
317
    cdef __Pyx_TypeInfo *typeinfo
318

319
    def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False):
320
        self.obj = obj
321
        self.flags = flags
322 323
        if type(self) is memoryview or obj is not None:
            __Pyx_GetBuffer(obj, &self.view, flags)
Mark Florisson's avatar
Mark Florisson committed
324 325
            if <PyObject *> self.view.obj == NULL:
                (<__pyx_buffer *> &self.view).obj = Py_None
326
                Py_INCREF(Py_None)
327

328 329 330 331
        self.lock = PyThread_allocate_lock()
        if self.lock == NULL:
            raise MemoryError

332 333 334 335 336
        if flags & PyBUF_FORMAT:
            self.dtype_is_object = self.view.format == b'O'
        else:
            self.dtype_is_object = dtype_is_object

337 338
        self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer(
                  <void *> &self.acquisition_count[0], sizeof(__pyx_atomic_int))
339
        self.typeinfo = NULL
340

341
    def __dealloc__(memoryview self):
342 343 344
        if self.obj is not None:
            __Pyx_ReleaseBuffer(&self.view)

345 346
        if self.lock != NULL:
            PyThread_free_lock(self.lock)
347

348 349
    cdef char *get_item_pointer(memoryview self, object index) except NULL:
        cdef Py_ssize_t dim
350
        cdef char *itemp = <char *> self.view.buf
351

352 353
        for dim, idx in enumerate(index):
            itemp = pybuffer_index(&self.view, itemp, idx, dim)
354 355

        return itemp
356

357
    #@cname('__pyx_memoryview_getitem')
358
    def __getitem__(memoryview self, object index):
359 360 361
        if index is Ellipsis:
            return self

362
        have_slices, indices = _unellipsify(index, self.view.ndim)
363 364 365

        cdef char *itemp
        if have_slices:
366
            return memview_slice(self, indices)
367
        else:
368
            itemp = self.get_item_pointer(indices)
369
            return self.convert_item_to_object(itemp)
370 371

    def __setitem__(memoryview self, object index, object value):
372
        have_slices, index = _unellipsify(index, self.view.ndim)
373

374
        if have_slices:
375 376
            obj = self.is_slice(value)
            if obj:
377
                self.setitem_slice_assignment(self[index], obj)
378
            else:
379
                self.setitem_slice_assign_scalar(self[index], value)
380 381 382 383 384 385
        else:
            self.setitem_indexed(index, value)

    cdef is_slice(self, obj):
        if not isinstance(obj, memoryview):
            try:
386 387
                obj = memoryview(obj, self.flags|PyBUF_ANY_CONTIGUOUS,
                                 self.dtype_is_object)
388 389 390 391 392
            except TypeError:
                return None

        return obj

393
    cdef setitem_slice_assignment(self, dst, src):
394 395 396
        cdef {{memviewslice_name}} dst_slice
        cdef {{memviewslice_name}} src_slice

397 398
        memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0],
                                 get_slice_from_memview(dst, &dst_slice)[0],
399
                                 src.ndim, dst.ndim, self.dtype_is_object)
400

401
    cdef setitem_slice_assign_scalar(self, memoryview dst, value):
402 403 404 405
        cdef int array[128]
        cdef void *tmp = NULL
        cdef void *item

Robert Bradshaw's avatar
Robert Bradshaw committed
406 407
        cdef {{memviewslice_name}} *dst_slice
        cdef {{memviewslice_name}} tmp_slice
408 409
        dst_slice = get_slice_from_memview(dst, &tmp_slice)

410
        if <size_t>self.view.itemsize > sizeof(array):
411
            tmp = PyMem_Malloc(self.view.itemsize)
412 413 414 415 416 417
            if tmp == NULL:
                raise MemoryError
            item = tmp
        else:
            item = <void *> array

418 419 420 421
        try:
            if self.dtype_is_object:
                (<PyObject **> item)[0] = <PyObject *> value
            else:
422
                self.assign_item_from_object(<char *> item, value)
423 424 425 426 427 428 429 430

            # It would be easy to support indirect dimensions, but it's easier
            # to disallow :)
            if self.view.suboffsets != NULL:
                assert_direct_dimensions(self.view.suboffsets, self.view.ndim)
            slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize,
                                item, self.dtype_is_object)
        finally:
431
            PyMem_Free(tmp)
432 433

    cdef setitem_indexed(self, index, value):
434 435 436 437 438 439 440 441
        cdef char *itemp = self.get_item_pointer(index)
        self.assign_item_from_object(itemp, value)

    cdef convert_item_to_object(self, char *itemp):
        """Only used if instantiated manually by the user, or if Cython doesn't
        know how to convert the type"""
        import struct
        cdef bytes bytesitem
442 443
        # Do a manual and complete check here instead of this easy hack
        bytesitem = itemp[:self.view.itemsize]
444 445 446 447 448 449 450 451
        try:
            result = struct.unpack(self.view.format, bytesitem)
        except struct.error:
            raise ValueError("Unable to convert item to object")
        else:
            if len(self.view.format) == 1:
                return result[0]
            return result
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467

    cdef assign_item_from_object(self, char *itemp, object value):
        """Only used if instantiated manually by the user, or if Cython doesn't
        know how to convert the type"""
        import struct
        cdef char c
        cdef bytes bytesvalue
        cdef Py_ssize_t i

        if isinstance(value, tuple):
            bytesvalue = struct.pack(self.view.format, *value)
        else:
            bytesvalue = struct.pack(self.view.format, value)

        for i, c in enumerate(bytesvalue):
            itemp[i] = c
468

469
    @cname('getbuffer')
470
    def __getbuffer__(self, Py_buffer *info, int flags):
471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
        if flags & PyBUF_STRIDES:
            info.shape = self.view.shape
        else:
            info.shape = NULL

        if flags & PyBUF_STRIDES:
            info.strides = self.view.strides
        else:
            info.strides = NULL

        if flags & PyBUF_INDIRECT:
            info.suboffsets = self.view.suboffsets
        else:
            info.suboffsets = NULL

        if flags & PyBUF_FORMAT:
            info.format = self.view.format
        else:
            info.format = NULL

        info.buf = self.view.buf
        info.ndim = self.view.ndim
        info.itemsize = self.view.itemsize
        info.len = self.view.len
        info.readonly = 0
496 497
        info.obj = self

498 499
    __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")

500
    # Some properties that have the same sematics as in NumPy
501 502 503
    property T:
        @cname('__pyx_memoryview_transpose')
        def __get__(self):
504 505
            cdef _memoryviewslice result = memoryview_copy(self)
            transpose_memslice(&result.from_slice)
506 507
            return result

508 509
    property base:
        @cname('__pyx_memoryview__get__base')
510 511 512
        def __get__(self):
            return self.obj

513 514 515
    property shape:
        @cname('__pyx_memoryview_get_shape')
        def __get__(self):
516
            return tuple([length for length in self.view.shape[:self.view.ndim]])
517 518 519 520

    property strides:
        @cname('__pyx_memoryview_get_strides')
        def __get__(self):
521 522 523 524
            if self.view.strides == NULL:
                # Note: we always ask for strides, so if this is not set it's a bug
                raise ValueError("Buffer view does not expose strides")

525
            return tuple([stride for stride in self.view.strides[:self.view.ndim]])
526 527 528 529

    property suboffsets:
        @cname('__pyx_memoryview_get_suboffsets')
        def __get__(self):
530
            if self.view.suboffsets == NULL:
531
                return (-1,) * self.view.ndim
532

533
            return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]])
534

535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555
    property ndim:
        @cname('__pyx_memoryview_get_ndim')
        def __get__(self):
            return self.view.ndim

    property itemsize:
        @cname('__pyx_memoryview_get_itemsize')
        def __get__(self):
            return self.view.itemsize

    property nbytes:
        @cname('__pyx_memoryview_get_nbytes')
        def __get__(self):
            return self.size * self.view.itemsize

    property size:
        @cname('__pyx_memoryview_get_size')
        def __get__(self):
            if self._size is None:
                result = 1

556
                for length in self.view.shape[:self.view.ndim]:
557 558 559 560 561 562 563 564 565 566 567 568
                    result *= length

                self._size = result

            return self._size

    def __len__(self):
        if self.view.ndim >= 1:
            return self.view.shape[0]

        return 0

569
    def __repr__(self):
570 571
        return "<MemoryView of %r at 0x%x>" % (self.base.__class__.__name__,
                                               id(self))
572

573
    def __str__(self):
574
        return "<MemoryView of %r object>" % (self.base.__class__.__name__,)
575

576 577
    # Support the same attributes as memoryview slices
    def is_c_contig(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
578 579
        cdef {{memviewslice_name}} *mslice
        cdef {{memviewslice_name}} tmp
580
        mslice = get_slice_from_memview(self, &tmp)
581
        return slice_is_contig(mslice[0], 'C', self.view.ndim)
582 583

    def is_f_contig(self):
Robert Bradshaw's avatar
Robert Bradshaw committed
584 585
        cdef {{memviewslice_name}} *mslice
        cdef {{memviewslice_name}} tmp
586
        mslice = get_slice_from_memview(self, &tmp)
587
        return slice_is_contig(mslice[0], 'F', self.view.ndim)
588 589 590 591

    def copy(self):
        cdef {{memviewslice_name}} mslice
        cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS
592

593 594 595
        slice_copy(self, &mslice)
        mslice = slice_copy_contig(&mslice, "c", self.view.ndim,
                                   self.view.itemsize,
596 597 598
                                   flags|PyBUF_C_CONTIGUOUS,
                                   self.dtype_is_object)

599 600 601 602 603
        return memoryview_copy_from_slice(self, &mslice)

    def copy_fortran(self):
        cdef {{memviewslice_name}} src, dst
        cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS
604

605 606 607
        slice_copy(self, &src)
        dst = slice_copy_contig(&src, "fortran", self.view.ndim,
                                self.view.itemsize,
608 609 610
                                flags|PyBUF_F_CONTIGUOUS,
                                self.dtype_is_object)

611 612
        return memoryview_copy_from_slice(self, &dst)

613 614

@cname('__pyx_memoryview_new')
615 616 617 618 619 620
cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo):
    cdef memoryview result = memoryview(o, flags, dtype_is_object)
    result.typeinfo = typeinfo
    return result

@cname('__pyx_memoryview_check')
621
cdef inline bint memoryview_check(object o):
622
    return isinstance(o, memoryview)
623

624
cdef tuple _unellipsify(object index, int ndim):
625 626 627 628
    """
    Replace all ellipses with full slices and fill incomplete indices with
    full slices.
    """
629 630 631 632 633 634 635 636 637 638 639
    if not isinstance(index, tuple):
        tup = (index,)
    else:
        tup = index

    result = []
    have_slices = False
    seen_ellipsis = False
    for idx, item in enumerate(tup):
        if item is Ellipsis:
            if not seen_ellipsis:
640
                result.extend([slice(None)] * (ndim - len(tup) + 1))
641
                seen_ellipsis = True
642 643 644 645
            else:
                result.append(slice(None))
            have_slices = True
        else:
646 647 648
            if not isinstance(item, slice) and not PyIndex_Check(item):
                raise TypeError("Cannot index with type '%s'" % type(item))

649
            have_slices = have_slices or isinstance(item, slice)
650 651
            result.append(item)

652 653 654 655
    nslices = ndim - len(result)
    if nslices:
        result.extend([slice(None)] * nslices)

656
    return have_slices or nslices, tuple(result)
657

658
cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim):
659 660
    for suboffset in suboffsets[:ndim]:
        if suboffset >= 0:
661 662
            raise ValueError("Indirect dimensions not supported")

663 664 665
#
### Slicing a memoryview
#
666

667 668 669
@cname('__pyx_memview_slice')
cdef memoryview memview_slice(memoryview memview, object indices):
    cdef int new_ndim = 0, suboffset_dim = -1, dim
670
    cdef bint negative_step
Mark Florisson's avatar
Mark Florisson committed
671
    cdef {{memviewslice_name}} src, dst
672
    cdef {{memviewslice_name}} *p_src
673

Mark Florisson's avatar
Mark Florisson committed
674 675 676 677
    # dst is copied by value in memoryview_fromslice -- initialize it
    # src is never copied
    memset(&dst, 0, sizeof(dst))

678
    cdef _memoryviewslice memviewsliceobj
679

680 681 682 683 684 685
    assert memview.view.ndim > 0

    if isinstance(memview, _memoryviewslice):
        memviewsliceobj = memview
        p_src = &memviewsliceobj.from_slice
    else:
686
        slice_copy(memview, &src)
687 688 689 690 691 692 693 694 695
        p_src = &src

    # Note: don't use variable src at this point
    # SubNote: we should be able to declare variables in blocks...

    # memoryview_fromslice() will inc our dst slice
    dst.memview = p_src.memview
    dst.data = p_src.data

696 697 698 699 700 701 702 703
    # Put everything in temps to avoid this bloody warning:
    # "Argument evaluation order in C function call is undefined and
    #  may not be as expected"
    cdef {{memviewslice_name}} *p_dst = &dst
    cdef int *p_suboffset_dim = &suboffset_dim
    cdef Py_ssize_t start, stop, step
    cdef bint have_start, have_stop, have_step

704
    for dim, index in enumerate(indices):
705
        if PyIndex_Check(index):
706 707 708 709 710 711
            slice_memviewslice(
                p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
                dim, new_ndim, p_suboffset_dim,
                index, 0, 0, # start, stop, step
                0, 0, 0, # have_{start,stop,step}
                False)
712 713 714 715 716
        elif index is None:
            p_dst.shape[new_ndim] = 1
            p_dst.strides[new_ndim] = 0
            p_dst.suboffsets[new_ndim] = -1
            new_ndim += 1
717
        else:
718 719 720 721 722 723 724 725
            start = index.start or 0
            stop = index.stop or 0
            step = index.step or 0

            have_start = index.start is not None
            have_stop = index.stop is not None
            have_step = index.step is not None

726 727 728 729 730 731
            slice_memviewslice(
                p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim],
                dim, new_ndim, p_suboffset_dim,
                start, stop, step,
                have_start, have_stop, have_step,
                True)
732 733
            new_ndim += 1

734
    if isinstance(memview, _memoryviewslice):
735
        return memoryview_fromslice(dst, new_ndim,
736
                                    memviewsliceobj.to_object_func,
737 738
                                    memviewsliceobj.to_dtype_func,
                                    memview.dtype_is_object)
739
    else:
740
        return memoryview_fromslice(dst, new_ndim, NULL, NULL,
741
                                    memview.dtype_is_object)
742

743

744 745 746
#
### Slicing in a single dimension of a memoryviewslice
#
747

748 749
cdef extern from "stdlib.h":
    void abort() nogil
Mark Florisson's avatar
Mark Florisson committed
750
    void printf(char *s, ...) nogil
751 752 753 754 755 756 757 758 759 760 761 762 763 764

cdef extern from "stdio.h":
    ctypedef struct FILE
    FILE *stderr
    int fputs(char *s, FILE *stream)

cdef extern from "pystate.h":
    void PyThreadState_Get() nogil

    # These are not actually nogil, but we check for the GIL before calling them
    void PyErr_SetString(PyObject *type, char *msg) nogil
    PyObject *PyErr_Format(PyObject *exc, char *msg, ...) nogil

@cname('__pyx_memoryview_slice_memviewslice')
765 766 767 768 769 770 771
cdef int slice_memviewslice(
        {{memviewslice_name}} *dst,
        Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset,
        int dim, int new_ndim, int *suboffset_dim,
        Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step,
        int have_start, int have_stop, int have_step,
        bint is_slice) nogil except -1:
772 773 774 775 776 777 778 779 780
    """
    Create a new slice dst given slice src.

    dim             - the current src dimension (indexing will make dimensions
                                                 disappear)
    new_dim         - the new dst dimension
    suboffset_dim   - pointer to a single int initialized to -1 to keep track of
                      where slicing offsets should be added
    """
781

782 783
    cdef Py_ssize_t new_shape
    cdef bint negative_step
784 785 786 787 788 789

    if not is_slice:
        # index is a normal integer-like index
        if start < 0:
            start += shape
        if not 0 <= start < shape:
790
            _err_dim(IndexError, "Index out of bounds (axis %d)", dim)
791 792 793 794 795
    else:
        # index is a slice
        negative_step = have_step != 0 and step < 0

        if have_step and step == 0:
796
            _err_dim(ValueError, "Step may not be zero (axis %d)", dim)
797 798 799

        # check our bounds and set defaults
        if have_start:
800 801 802 803 804
            if start < 0:
                start += shape
                if start < 0:
                    start = 0
            elif start >= shape:
805 806 807 808 809 810
                if negative_step:
                    start = shape - 1
                else:
                    start = shape
        else:
            if negative_step:
811
                start = shape - 1
812 813
            else:
                start = 0
814

815
        if have_stop:
816 817 818 819 820 821
            if stop < 0:
                stop += shape
                if stop < 0:
                    stop = 0
            elif stop > shape:
                stop = shape
822 823 824 825 826
        else:
            if negative_step:
                stop = -1
            else:
                stop = shape
827

828 829
        if not have_step:
            step = 1
830

831 832 833
        # len = ceil( (stop - start) / step )
        with cython.cdivision(True):
            new_shape = (stop - start) // step
834

835
            if (stop - start) - step * new_shape:
836
                new_shape += 1
837

838 839
        if new_shape < 0:
            new_shape = 0
840

841 842 843 844
        # shape/strides/suboffsets
        dst.strides[new_ndim] = stride * step
        dst.shape[new_ndim] = new_shape
        dst.suboffsets[new_ndim] = suboffset
845

846 847 848
    # Add the slicing or idexing offsets to the right suboffset or base data *
    if suboffset_dim[0] < 0:
        dst.data += start * stride
849
    else:
850 851 852 853
        dst.suboffsets[suboffset_dim[0]] += start * stride

    if suboffset >= 0:
        if not is_slice:
854 855 856
            if new_ndim == 0:
                dst.data = (<char **> dst.data)[0] + suboffset
            else:
857 858
                _err_dim(IndexError, "All dimensions preceding dimension %d "
                                     "must be indexed and not sliced", dim)
859 860
        else:
            suboffset_dim[0] = new_ndim
861

862
    return 0
863 864 865 866

#
### Index a memoryview
#
867
@cname('__pyx_pybuffer_index')
868
cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index,
869
                          Py_ssize_t dim) except NULL:
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896
    cdef Py_ssize_t shape, stride, suboffset = -1
    cdef Py_ssize_t itemsize = view.itemsize
    cdef char *resultp

    if view.ndim == 0:
        shape = view.len / itemsize
        stride = itemsize
    else:
        shape = view.shape[dim]
        stride = view.strides[dim]
        if view.suboffsets != NULL:
            suboffset = view.suboffsets[dim]

    if index < 0:
        index += view.shape[dim]
        if index < 0:
            raise IndexError("Out of bounds on buffer access (axis %d)" % dim)

    if index >= shape:
        raise IndexError("Out of bounds on buffer access (axis %d)" % dim)

    resultp = bufp + index * stride
    if suboffset >= 0:
        resultp = (<char **> resultp)[0] + suboffset

    return resultp

897 898 899 900
#
### Transposing a memoryviewslice
#
@cname('__pyx_memslice_transpose')
Mark Florisson's avatar
Mark Florisson committed
901
cdef int transpose_memslice({{memviewslice_name}} *memslice) nogil except 0:
902 903 904 905 906 907 908 909 910 911 912 913 914
    cdef int ndim = memslice.memview.view.ndim

    cdef Py_ssize_t *shape = memslice.shape
    cdef Py_ssize_t *strides = memslice.strides

    # reverse strides and shape
    cdef int i, j
    for i in range(ndim / 2):
        j = ndim - 1 - i
        strides[i], strides[j] = strides[j], strides[i]
        shape[i], shape[j] = shape[j], shape[i]

        if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0:
915
            _err(ValueError, "Cannot transpose memoryview with indirect dimensions")
916 917 918

    return 1

919 920 921
#
### Creating new memoryview objects from slices and memoryviews
#
922 923
@cname('__pyx_memoryviewslice')
cdef class _memoryviewslice(memoryview):
924
    "Internal class for passing memoryview slices to Python"
925 926 927

    # We need this to keep our shape/strides/suboffset pointers valid
    cdef {{memviewslice_name}} from_slice
928
    # We need this only to print it's class' name
929
    cdef object from_object
930

931 932 933
    cdef object (*to_object_func)(char *)
    cdef int (*to_dtype_func)(char *, object) except 0

934
    def __dealloc__(self):
935
        __PYX_XDEC_MEMVIEW(&self.from_slice, 1)
936

937 938
    cdef convert_item_to_object(self, char *itemp):
        if self.to_object_func != NULL:
939
            return self.to_object_func(itemp)
940
        else:
941
            return memoryview.convert_item_to_object(self, itemp)
942 943 944 945 946 947 948

    cdef assign_item_from_object(self, char *itemp, object value):
        if self.to_dtype_func != NULL:
            self.to_dtype_func(itemp, value)
        else:
            memoryview.assign_item_from_object(self, itemp, value)

949 950
    property base:
        @cname('__pyx_memoryviewslice__get__base')
951 952
        def __get__(self):
            return self.from_object
953

954 955 956
    __pyx_getbuffer = capsule(<void *> &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)")


957
@cname('__pyx_memoryview_fromslice')
958
cdef memoryview_fromslice({{memviewslice_name}} memviewslice,
959 960
                          int ndim,
                          object (*to_object_func)(char *),
961 962
                          int (*to_dtype_func)(char *, object) except 0,
                          bint dtype_is_object):
963

964 965
    cdef _memoryviewslice result

966 967 968
    if <PyObject *> memviewslice.memview == Py_None:
        return None

969 970
    # assert 0 < ndim <= memviewslice.memview.view.ndim, (
    #                 ndim, memviewslice.memview.view.ndim)
971

972
    result = _memoryviewslice(None, 0, dtype_is_object)
973

974 975
    result.from_slice = memviewslice
    __PYX_INC_MEMVIEW(&memviewslice, 1)
976

977
    result.from_object = (<memoryview> memviewslice.memview).base
978
    result.typeinfo = memviewslice.memview.typeinfo
979

980
    result.view = memviewslice.memview.view
981
    result.view.buf = <void *> memviewslice.data
982
    result.view.ndim = ndim
Mark Florisson's avatar
Mark Florisson committed
983
    (<__pyx_buffer *> &result.view).obj = Py_None
984
    Py_INCREF(Py_None)
985

986 987
    result.flags = PyBUF_RECORDS

988 989
    result.view.shape = <Py_ssize_t *> result.from_slice.shape
    result.view.strides = <Py_ssize_t *> result.from_slice.strides
990 991

    # only set suboffsets if actually used, otherwise set to NULL to improve compatibility
992
    result.view.suboffsets = NULL
993 994
    for suboffset in result.from_slice.suboffsets[:ndim]:
        if suboffset >= 0:
995 996
            result.view.suboffsets = <Py_ssize_t *> result.from_slice.suboffsets
            break
997 998

    result.view.len = result.view.itemsize
Stefan Behnel's avatar
Stefan Behnel committed
999 1000
    for length in result.view.shape[:ndim]:
        result.view.len *= length
1001

1002
    result.to_object_func = to_object_func
1003
    result.to_dtype_func = to_dtype_func
1004 1005 1006

    return result

1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
@cname('__pyx_memoryview_get_slice_from_memoryview')
cdef {{memviewslice_name}} *get_slice_from_memview(memoryview memview,
                                                   {{memviewslice_name}} *mslice):
    cdef _memoryviewslice obj
    if isinstance(memview, _memoryviewslice):
        obj = memview
        return &obj.from_slice
    else:
        slice_copy(memview, mslice)
        return mslice

1018 1019
@cname('__pyx_memoryview_slice_copy')
cdef void slice_copy(memoryview memview, {{memviewslice_name}} *dst):
1020
    cdef int dim
Robert Bradshaw's avatar
Robert Bradshaw committed
1021
    cdef (Py_ssize_t*) shape, strides, suboffsets
1022 1023 1024 1025

    shape = memview.view.shape
    strides = memview.view.strides
    suboffsets = memview.view.suboffsets
1026 1027 1028 1029 1030

    dst.memview = <__pyx_memoryview *> memview
    dst.data = <char *> memview.view.buf

    for dim in range(memview.view.ndim):
1031 1032
        dst.shape[dim] = shape[dim]
        dst.strides[dim] = strides[dim]
1033
        dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1
1034

1035
@cname('__pyx_memoryview_copy_object')
1036
cdef memoryview_copy(memoryview memview):
1037
    "Create a new memoryview object"
1038
    cdef {{memviewslice_name}} memviewslice
1039 1040 1041 1042 1043 1044 1045 1046
    slice_copy(memview, &memviewslice)
    return memoryview_copy_from_slice(memview, &memviewslice)

@cname('__pyx_memoryview_copy_object_from_slice')
cdef memoryview_copy_from_slice(memoryview memview, {{memviewslice_name}} *memviewslice):
    """
    Create a new memoryview object from a given memoryview object and slice.
    """
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
    cdef object (*to_object_func)(char *)
    cdef int (*to_dtype_func)(char *, object) except 0

    if isinstance(memview, _memoryviewslice):
        to_object_func = (<_memoryviewslice> memview).to_object_func
        to_dtype_func = (<_memoryviewslice> memview).to_dtype_func
    else:
        to_object_func = NULL
        to_dtype_func = NULL

1057
    return memoryview_fromslice(memviewslice[0], memview.view.ndim,
1058 1059
                                to_object_func, to_dtype_func,
                                memview.dtype_is_object)
1060

1061

1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079
#
### Copy the contents of a memoryview slices
#
cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil:
    if arg < 0:
        return -arg
    else:
        return arg

@cname('__pyx_get_best_slice_order')
cdef char get_best_order({{memviewslice_name}} *mslice, int ndim) nogil:
    """
    Figure out the best memory access order for a given slice.
    """
    cdef int i
    cdef Py_ssize_t c_stride = 0
    cdef Py_ssize_t f_stride = 0

1080
    for i in range(ndim - 1, -1, -1):
1081 1082
        if mslice.shape[i] > 1:
            c_stride = mslice.strides[i]
1083
            break
1084 1085 1086 1087

    for i in range(ndim):
        if mslice.shape[i] > 1:
            f_stride = mslice.strides[i]
1088
            break
1089 1090 1091 1092 1093 1094

    if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride):
        return 'C'
    else:
        return 'F'

1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106
@cython.cdivision(True)
cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides,
                                   char *dst_data, Py_ssize_t *dst_strides,
                                   Py_ssize_t *src_shape, Py_ssize_t *dst_shape,
                                   int ndim, size_t itemsize) nogil:
    # Note: src_extent is 1 if we're broadcasting
    # dst_extent always >= src_extent as we don't do reductions
    cdef Py_ssize_t i
    cdef Py_ssize_t src_extent = src_shape[0]
    cdef Py_ssize_t dst_extent = dst_shape[0]
    cdef Py_ssize_t src_stride = src_strides[0]
    cdef Py_ssize_t dst_stride = dst_strides[0]
1107 1108

    if ndim == 1:
1109 1110 1111 1112 1113 1114 1115 1116
       if (src_stride > 0 and dst_stride > 0 and
           <size_t> src_stride == itemsize == <size_t> dst_stride):
           memcpy(dst_data, src_data, itemsize * dst_extent)
       else:
           for i in range(dst_extent):
               memcpy(dst_data, src_data, itemsize)
               src_data += src_stride
               dst_data += dst_stride
1117
    else:
1118 1119 1120 1121 1122 1123 1124
        for i in range(dst_extent):
            _copy_strided_to_strided(src_data, src_strides + 1,
                                     dst_data, dst_strides + 1,
                                     src_shape + 1, dst_shape + 1,
                                     ndim - 1, itemsize)
            src_data += src_stride
            dst_data += dst_stride
1125 1126 1127 1128 1129

cdef void copy_strided_to_strided({{memviewslice_name}} *src,
                                  {{memviewslice_name}} *dst,
                                  int ndim, size_t itemsize) nogil:
    _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides,
1130
                             src.shape, dst.shape, ndim, itemsize)
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142

@cname('__pyx_memoryview_slice_get_size')
cdef Py_ssize_t slice_get_size({{memviewslice_name}} *src, int ndim) nogil:
    "Return the size of the memory occupied by the slice in number of bytes"
    cdef int i
    cdef Py_ssize_t size = src.memview.view.itemsize

    for i in range(ndim):
        size *= src.shape[i]

    return size

1143 1144 1145 1146
@cname('__pyx_fill_contig_strides_array')
cdef Py_ssize_t fill_contig_strides_array(
                Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride,
                int ndim, char order) nogil:
1147 1148 1149 1150
    """
    Fill the strides array for a slice with C or F contiguous strides.
    This is like PyBuffer_FillContiguousStrides, but compatible with py < 2.6
    """
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
    cdef int idx

    if order == 'F':
        for idx in range(ndim):
            strides[idx] = stride
            stride = stride * shape[idx]
    else:
        for idx in range(ndim - 1, -1, -1):
            strides[idx] = stride
            stride = stride * shape[idx]

    return stride

1164
@cname('__pyx_memoryview_copy_data_to_temp')
1165 1166 1167 1168
cdef void *copy_data_to_temp({{memviewslice_name}} *src,
                             {{memviewslice_name}} *tmpslice,
                             char order,
                             int ndim) nogil except NULL:
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
    """
    Copy a direct slice to temporary contiguous memory. The caller should free
    the result when done.
    """
    cdef int i
    cdef void *result

    cdef size_t itemsize = src.memview.view.itemsize
    cdef size_t size = slice_get_size(src, ndim)

    result = malloc(size)
    if not result:
1181
        _err(MemoryError, NULL)
1182

1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
    # tmpslice[0] = src
    tmpslice.data = <char *> result
    tmpslice.memview = src.memview
    for i in range(ndim):
        tmpslice.shape[i] = src.shape[i]
        tmpslice.suboffsets[i] = -1

    fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize,
                              ndim, order)

    # We need to broadcast strides again
    for i in range(ndim):
        if tmpslice.shape[i] == 1:
            tmpslice.strides[i] = 0

1198
    if slice_is_contig(src[0], order, ndim):
1199 1200
        memcpy(result, src.data, size)
    else:
1201 1202
        copy_strided_to_strided(src, tmpslice, ndim, itemsize)

1203 1204
    return result

1205 1206 1207 1208 1209 1210 1211 1212 1213 1214
# Use 'with gil' functions and avoid 'with gil' blocks, as the code within the blocks
# has temporaries that need the GIL to clean up
@cname('__pyx_memoryview_err_extents')
cdef int _err_extents(int i, Py_ssize_t extent1,
                             Py_ssize_t extent2) except -1 with gil:
    raise ValueError("got differing extents in dimension %d (got %d and %d)" %
                                                        (i, extent1, extent2))

@cname('__pyx_memoryview_err_dim')
cdef int _err_dim(object error, char *msg, int dim) except -1 with gil:
1215
    raise error(msg.decode('ascii') % dim)
1216 1217 1218 1219

@cname('__pyx_memoryview_err')
cdef int _err(object error, char *msg) except -1 with gil:
    if msg != NULL:
1220
        raise error(msg.decode('ascii'))
1221 1222 1223
    else:
        raise error

1224
@cname('__pyx_memoryview_copy_contents')
1225 1226
cdef int memoryview_copy_contents({{memviewslice_name}} src,
                                  {{memviewslice_name}} dst,
1227 1228
                                  int src_ndim, int dst_ndim,
                                  bint dtype_is_object) nogil except -1:
1229 1230 1231 1232
    """
    Copy memory from slice src to slice dst.
    Check for overlapping memory and verify the shapes.
    """
1233
    cdef void *tmpdata = NULL
1234
    cdef size_t itemsize = src.memview.view.itemsize
1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
    cdef int i
    cdef char order = get_best_order(&src, src_ndim)
    cdef bint broadcasting = False
    cdef bint direct_copy = False
    cdef {{memviewslice_name}} tmp

    if src_ndim < dst_ndim:
        broadcast_leading(&src, src_ndim, dst_ndim)
    elif dst_ndim < src_ndim:
        broadcast_leading(&dst, dst_ndim, src_ndim)

    cdef int ndim = max(src_ndim, dst_ndim)
1247 1248 1249

    for i in range(ndim):
        if src.shape[i] != dst.shape[i]:
1250 1251 1252 1253
            if src.shape[i] == 1:
                broadcasting = True
                src.strides[i] = 0
            else:
1254
                _err_extents(i, dst.shape[i], src.shape[i])
1255 1256

        if src.suboffsets[i] >= 0:
1257
            _err_dim(ValueError, "Dimension %d is not direct", i)
1258

1259
    if slices_overlap(&src, &dst, ndim, itemsize):
1260
        # slices overlap, copy to temp, copy temp to dst
1261
        if not slice_is_contig(src, order, ndim):
1262 1263 1264 1265 1266 1267 1268 1269
            order = get_best_order(&dst, ndim)

        tmpdata = copy_data_to_temp(&src, &tmp, order, ndim)
        src = tmp

    if not broadcasting:
        # See if both slices have equal contiguity, in that case perform a
        # direct copy. This only works when we are not broadcasting.
1270 1271 1272 1273
        if slice_is_contig(src, 'C', ndim):
            direct_copy = slice_is_contig(dst, 'C', ndim)
        elif slice_is_contig(src, 'F', ndim):
            direct_copy = slice_is_contig(dst, 'F', ndim)
1274 1275 1276

        if direct_copy:
            # Contiguous slices with same order
1277
            refcount_copying(&dst, dtype_is_object, ndim, False)
1278
            memcpy(dst.data, src.data, slice_get_size(&src, ndim))
1279
            refcount_copying(&dst, dtype_is_object, ndim, True)
1280
            free(tmpdata)
1281 1282 1283
            return 0

    if order == 'F' == get_best_order(&dst, ndim):
1284 1285
        # see if both slices have Fortran order, transpose them to match our
        # C-style indexing order
1286 1287
        transpose_memslice(&src)
        transpose_memslice(&dst)
1288

1289
    refcount_copying(&dst, dtype_is_object, ndim, False)
1290
    copy_strided_to_strided(&src, &dst, ndim, itemsize)
1291 1292
    refcount_copying(&dst, dtype_is_object, ndim, True)

1293
    free(tmpdata)
1294 1295
    return 0

1296
@cname('__pyx_memoryview_broadcast_leading')
1297
cdef void broadcast_leading({{memviewslice_name}} *mslice,
1298 1299
                            int ndim,
                            int ndim_other) nogil:
1300
    cdef int i
1301
    cdef int offset = ndim_other - ndim
1302 1303

    for i in range(ndim - 1, -1, -1):
1304 1305 1306
        mslice.shape[i + offset] = mslice.shape[i]
        mslice.strides[i + offset] = mslice.strides[i]
        mslice.suboffsets[i + offset] = mslice.suboffsets[i]
1307 1308

    for i in range(offset):
1309 1310 1311
        mslice.shape[i] = 1
        mslice.strides[i] = mslice.strides[0]
        mslice.suboffsets[i] = -1
1312

1313 1314 1315 1316 1317
#
### Take care of refcounting the objects in slices. Do this seperately from any copying,
### to minimize acquiring the GIL
#

1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
@cname('__pyx_memoryview_refcount_copying')
cdef void refcount_copying({{memviewslice_name}} *dst, bint dtype_is_object,
                           int ndim, bint inc) nogil:
    # incref or decref the objects in the destination slice if the dtype is
    # object
    if dtype_is_object:
        refcount_objects_in_slice_with_gil(dst.data, dst.shape,
                                           dst.strides, ndim, inc)

@cname('__pyx_memoryview_refcount_objects_in_slice_with_gil')
cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape,
                                             Py_ssize_t *strides, int ndim,
                                             bint inc) with gil:
    refcount_objects_in_slice(data, shape, strides, ndim, inc)

@cname('__pyx_memoryview_refcount_objects_in_slice')
cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape,
                                    Py_ssize_t *strides, int ndim, bint inc):
    cdef Py_ssize_t i

    for i in range(shape[0]):
        if ndim == 1:
            if inc:
                Py_INCREF((<PyObject **> data)[0])
            else:
                Py_DECREF((<PyObject **> data)[0])
        else:
            refcount_objects_in_slice(data, shape + 1, strides + 1,
                                      ndim - 1, inc)

        data += strides[0]

1350 1351 1352 1353 1354 1355 1356 1357
#
### Scalar to slice assignment
#
@cname('__pyx_memoryview_slice_assign_scalar')
cdef void slice_assign_scalar({{memviewslice_name}} *dst, int ndim,
                              size_t itemsize, void *item,
                              bint dtype_is_object) nogil:
    refcount_copying(dst, dtype_is_object, ndim, False)
1358 1359
    _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim,
                         itemsize, item)
1360 1361
    refcount_copying(dst, dtype_is_object, ndim, True)

1362

1363 1364 1365 1366 1367
@cname('__pyx_memoryview__slice_assign_scalar')
cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape,
                              Py_ssize_t *strides, int ndim,
                              size_t itemsize, void *item) nogil:
    cdef Py_ssize_t i
1368 1369
    cdef Py_ssize_t stride = strides[0]
    cdef Py_ssize_t extent = shape[0]
1370

1371 1372
    if ndim == 1:
        for i in range(extent):
1373
            memcpy(data, item, itemsize)
1374 1375 1376
            data += stride
    else:
        for i in range(extent):
1377 1378
            _slice_assign_scalar(data, shape + 1, strides + 1,
                                ndim - 1, itemsize, item)
1379
            data += stride
1380

1381

1382 1383 1384
############### BufferFormatFromTypeInfo ###############
cdef extern from *:
    ctypedef struct __Pyx_StructField
1385

1386 1387 1388 1389
    cdef enum:
        __PYX_BUF_FLAGS_PACKED_STRUCT
        __PYX_BUF_FLAGS_INTEGER_COMPLEX

1390 1391 1392 1393
    ctypedef struct __Pyx_TypeInfo:
      char* name
      __Pyx_StructField* fields
      size_t size
1394 1395
      size_t arraysize[8]
      int ndim
1396 1397
      char typegroup
      char is_unsigned
1398
      int flags
1399

1400 1401 1402 1403
    ctypedef struct __Pyx_StructField:
      __Pyx_TypeInfo* type
      char* name
      size_t offset
1404

1405 1406 1407
    ctypedef struct __Pyx_BufFmt_StackElem:
      __Pyx_StructField* field
      size_t parent_offset
1408

1409 1410 1411
    #ctypedef struct __Pyx_BufFmt_Context:
    #  __Pyx_StructField root
      __Pyx_BufFmt_StackElem* head
1412

1413 1414
    struct __pyx_typeinfo_string:
        char string[3]
1415

1416
    __pyx_typeinfo_string __Pyx_TypeInfoToFormat(__Pyx_TypeInfo *)
1417 1418


1419
@cname('__pyx_format_from_typeinfo')
1420
cdef bytes format_from_typeinfo(__Pyx_TypeInfo *type):
1421 1422
    cdef __Pyx_StructField *field
    cdef __pyx_typeinfo_string fmt
1423
    cdef bytes part, result
1424

1425 1426
    if type.typegroup == 'S':
        assert type.fields != NULL and type.fields.type != NULL
1427

1428
        if type.flags & __PYX_BUF_FLAGS_PACKED_STRUCT:
1429
            alignment = b'^'
1430
        else:
1431
            alignment = b''
1432

1433
        parts = [b"T{"]
1434
        field = type.fields
1435

1436
        while field.type:
1437 1438
            part = format_from_typeinfo(field.type)
            parts.append(part + b':' + field.name + b':')
1439 1440
            field += 1

1441
        result = alignment.join(parts) + b'}'
1442 1443
    else:
        fmt = __Pyx_TypeInfoToFormat(type)
1444
        if type.arraysize[0]:
1445 1446
            extents = [unicode(type.arraysize[i]) for i in range(type.ndim)]
            result = (u"(%s)" % u','.join(extents)).encode('ascii') + fmt.string
1447
        else:
1448
            result = fmt.string
1449

1450
    return result