/*

* Memoryview object implementation

* --------------------------------

*

* This implementation is a complete rewrite contributed by Stefan Krah in

* Python 3.3. Substantial credit goes to Antoine Pitrou (who had already

* fortified and rewritten the previous implementation) and Nick Coghlan

* (who came up with the idea of the ManagedBuffer) for analyzing the complex

* ownership rules.

*

*/

#include "Python.h"

#include "pycore_abstract.h" // _PyIndex_Check()

#include "pycore_memoryobject.h" // _PyManagedBuffer_Type

#include "pycore_object.h" // _PyObject_GC_UNTRACK()

#include "pycore_strhex.h" // _Py_strhex_with_sep()

#include <stddef.h> // offsetof()

/*[clinic input]

class memoryview "PyMemoryViewObject *" "&PyMemoryView_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=e2e49d2192835219]*/

#include "clinic/memoryobject.c.h"

/****************************************************************************/

/* ManagedBuffer Object */

/****************************************************************************/

/*

ManagedBuffer Object:

---------------------

The purpose of this object is to facilitate the handling of chained

memoryviews that have the same underlying exporting object. PEP-3118

allows the underlying object to change while a view is exported. This

could lead to unexpected results when constructing a new memoryview

from an existing memoryview.

Rather than repeatedly redirecting buffer requests to the original base

object, all chained memoryviews use a single buffer snapshot. This

snapshot is generated by the constructor _PyManagedBuffer_FromObject().

Ownership rules:

----------------

The master buffer inside a managed buffer is filled in by the original

base object. shape, strides, suboffsets and format are read-only for

all consumers.

A memoryview's buffer is a private copy of the exporter's buffer. shape,

strides and suboffsets belong to the memoryview and are thus writable.

If a memoryview itself exports several buffers via memory_getbuf(), all

buffer copies share shape, strides and suboffsets. In this case, the

arrays are NOT writable.

Reference count assumptions:

----------------------------

The 'obj' member of a Py_buffer must either be NULL or refer to the

exporting base object. In the Python codebase, all getbufferprocs

return a new reference to view.obj (example: bytes_buffer_getbuffer()).

PyBuffer_Release() decrements view.obj (if non-NULL), so the

releasebufferprocs must NOT decrement view.obj.

*/

static inline _PyManagedBufferObject *

mbuf_alloc(void)

{

_PyManagedBufferObject *mbuf;

mbuf = (_PyManagedBufferObject *)

PyObject_GC_New(_PyManagedBufferObject, &_PyManagedBuffer_Type);

if (mbuf == NULL)

return NULL;

mbuf->flags = 0;

mbuf->exports = 0;

mbuf->master.obj = NULL;

_PyObject_GC_TRACK(mbuf);

return mbuf;

}

static PyObject *

_PyManagedBuffer_FromObject(PyObject *base, int flags)

{

_PyManagedBufferObject *mbuf;

mbuf = mbuf_alloc();

if (mbuf == NULL)

return NULL;

if (PyObject_GetBuffer(base, &mbuf->master, flags) < 0) {

mbuf->master.obj = NULL;

Py_DECREF(mbuf);

return NULL;

}

return (PyObject *)mbuf;

}

static void

mbuf_release(_PyManagedBufferObject *self)

{

if (self->flags&_Py_MANAGED_BUFFER_RELEASED)

return;

self->flags |= _Py_MANAGED_BUFFER_RELEASED;

/* PyBuffer_Release() decrements master->obj and sets it to NULL. */

_PyObject_GC_UNTRACK(self);

PyBuffer_Release(&self->master);

}

static void

mbuf_dealloc(PyObject *_self)

{

_PyManagedBufferObject *self = (_PyManagedBufferObject *)_self;

assert(self->exports == 0);

mbuf_release(self);

if (self->flags&_Py_MANAGED_BUFFER_FREE_FORMAT)

PyMem_Free(self->master.format);

PyObject_GC_Del(self);

}

static int

mbuf_traverse(PyObject *_self, visitproc visit, void *arg)

{

_PyManagedBufferObject *self = (_PyManagedBufferObject *)_self;

Py_VISIT(self->master.obj);

return 0;

}

static int

mbuf_clear(PyObject *_self)

{

_PyManagedBufferObject *self = (_PyManagedBufferObject *)_self;

assert(self->exports >= 0);

mbuf_release(self);

return 0;

}

PyTypeObject _PyManagedBuffer_Type = {

PyVarObject_HEAD_INIT(&PyType_Type, 0)

"managedbuffer",

sizeof(_PyManagedBufferObject),

0,

mbuf_dealloc, /* tp_dealloc */

0, /* tp_vectorcall_offset */

0, /* tp_getattr */

0, /* tp_setattr */

0, /* tp_as_async */

0, /* tp_repr */

0, /* tp_as_number */

0, /* tp_as_sequence */

0, /* tp_as_mapping */

0, /* tp_hash */

0, /* tp_call */

0, /* tp_str */

PyObject_GenericGetAttr, /* tp_getattro */

0, /* tp_setattro */

0, /* tp_as_buffer */

Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */

0, /* tp_doc */

mbuf_traverse, /* tp_traverse */

mbuf_clear /* tp_clear */

};

/****************************************************************************/

/* MemoryView Object */

/****************************************************************************/

/* In the process of breaking reference cycles mbuf_release() can be

called before memory_release(). */

#define BASE_INACCESSIBLE(mv) \

(((PyMemoryViewObject *)mv)->flags&_Py_MEMORYVIEW_RELEASED || \

((PyMemoryViewObject *)mv)->mbuf->flags&_Py_MANAGED_BUFFER_RELEASED)

#define CHECK_RELEASED(mv) \

if (BASE_INACCESSIBLE(mv)) { \

PyErr_SetString(PyExc_ValueError, \

"operation forbidden on released memoryview object"); \

return NULL; \

}

#define CHECK_RELEASED_INT(mv) \

if (BASE_INACCESSIBLE(mv)) { \

PyErr_SetString(PyExc_ValueError, \

"operation forbidden on released memoryview object"); \

return -1; \

}

#define CHECK_RESTRICTED(mv) \

if (((PyMemoryViewObject *)(mv))->flags & _Py_MEMORYVIEW_RESTRICTED) { \

PyErr_SetString(PyExc_ValueError, \

"cannot create new view on restricted memoryview"); \

return NULL; \

}

#define CHECK_RESTRICTED_INT(mv) \

if (((PyMemoryViewObject *)(mv))->flags & _Py_MEMORYVIEW_RESTRICTED) { \

PyErr_SetString(PyExc_ValueError, \

"cannot create new view on restricted memoryview"); \

return -1; \

}

/* See gh-92888. These macros signal that we need to check the memoryview

again due to possible read after frees. */

#define CHECK_RELEASED_AGAIN(mv) CHECK_RELEASED(mv)

#define CHECK_RELEASED_INT_AGAIN(mv) CHECK_RELEASED_INT(mv)

#define CHECK_LIST_OR_TUPLE(v) \

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

PyErr_SetString(PyExc_TypeError, \

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

return NULL; \

}

#define VIEW_ADDR(mv) (&((PyMemoryViewObject *)mv)->view)

/* Check for the presence of suboffsets in the first dimension. */

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

/* Adjust ptr if suboffsets are present. */

#define ADJUST_PTR(ptr, suboffsets, dim) \

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

/* Memoryview buffer properties */

#define MV_C_CONTIGUOUS(flags) (flags&(_Py_MEMORYVIEW_SCALAR|_Py_MEMORYVIEW_C))

#define MV_F_CONTIGUOUS(flags) \

(flags&(_Py_MEMORYVIEW_SCALAR|_Py_MEMORYVIEW_FORTRAN))

#define MV_ANY_CONTIGUOUS(flags) \

(flags&(_Py_MEMORYVIEW_SCALAR|_Py_MEMORYVIEW_C|_Py_MEMORYVIEW_FORTRAN))

/* Fast contiguity test. Caller must ensure suboffsets==NULL and ndim==1. */

#define MV_CONTIGUOUS_NDIM1(view) \

((view)->shape[0] == 1 || (view)->strides[0] == (view)->itemsize)

/* getbuffer() requests */

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

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

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

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

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

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

#define REQ_WRITABLE(flags) (flags&PyBUF_WRITABLE)

#define REQ_FORMAT(flags) (flags&PyBUF_FORMAT)

/**************************************************************************/

/* Copy memoryview buffers */

/**************************************************************************/

/* The functions in this section take a source and a destination buffer

with the same logical structure: format, itemsize, ndim and shape

are identical, with ndim > 0.

NOTE: All buffers are assumed to have PyBUF_FULL information, which

is the case for memoryviews! */

/* Assumptions: ndim >= 1. The macro tests for a corner case that should

perhaps be explicitly forbidden in the PEP. */

#define HAVE_SUBOFFSETS_IN_LAST_DIM(view) \

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

static inline int

last_dim_is_contiguous(const Py_buffer *dest, const Py_buffer *src)

{

assert(dest->ndim > 0 && src->ndim > 0);

return (!HAVE_SUBOFFSETS_IN_LAST_DIM(dest) &&

!HAVE_SUBOFFSETS_IN_LAST_DIM(src) &&

dest->strides[dest->ndim-1] == dest->itemsize &&

src->strides[src->ndim-1] == src->itemsize);

}

/* This is not a general function for determining format equivalence.

It is used in copy_single() and copy_buffer() to weed out non-matching

formats. Skipping the '@' character is specifically used in slice

assignments, where the lvalue is already known to have a single character

format. This is a performance hack that could be rewritten (if properly

benchmarked). */

static inline int

equiv_format(const Py_buffer *dest, const Py_buffer *src)

{

const char *dfmt, *sfmt;

assert(dest->format && src->format);

dfmt = dest->format[0] == '@' ? dest->format+1 : dest->format;

sfmt = src->format[0] == '@' ? src->format+1 : src->format;

if (strcmp(dfmt, sfmt) != 0 ||

dest->itemsize != src->itemsize) {

return 0;

}

return 1;

}

/* Two shapes are equivalent if they are either equal or identical up

to a zero element at the same position. For example, in NumPy arrays

the shapes [1, 0, 5] and [1, 0, 7] are equivalent. */

static inline int

equiv_shape(const Py_buffer *dest, const Py_buffer *src)

{

int i;

if (dest->ndim != src->ndim)

return 0;

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

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

return 0;

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

break;

}

return 1;

}

/* Check that the logical structure of the destination and source buffers

is identical. */

static int

equiv_structure(const Py_buffer *dest, const Py_buffer *src)

{

if (!equiv_format(dest, src) ||

!equiv_shape(dest, src)) {

PyErr_SetString(PyExc_ValueError,

"memoryview assignment: lvalue and rvalue have different "

"structures");

return 0;

}

return 1;

}

/* Base case for recursive multi-dimensional copying. Contiguous arrays are

copied with very little overhead. Assumptions: ndim == 1, mem == NULL or

sizeof(mem) == shape[0] * itemsize. */

static void

copy_base(const Py_ssize_t *shape, Py_ssize_t itemsize,

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

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

char *mem)

{

if (mem == NULL) { /* contiguous */

Py_ssize_t size = shape[0] * itemsize;

if (dptr + size < sptr || sptr + size < dptr)

memcpy(dptr, sptr, size); /* no overlapping */

else

memmove(dptr, sptr, size);

}

else {

char *p;

Py_ssize_t i;

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

char *xsptr = ADJUST_PTR(sptr, ssuboffsets, 0);

memcpy(p, xsptr, itemsize);

}

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

char *xdptr = ADJUST_PTR(dptr, dsuboffsets, 0);

memcpy(xdptr, p, itemsize);

}

}

}

/* Recursively copy a source buffer to a destination buffer. The two buffers

have the same ndim, shape and itemsize. */

static void

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

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

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

char *mem)

{

Py_ssize_t i;

assert(ndim >= 1);

if (ndim == 1) {

copy_base(shape, itemsize,

dptr, dstrides, dsuboffsets,

sptr, sstrides, ssuboffsets,

mem);

return;

}

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

char *xdptr = ADJUST_PTR(dptr, dsuboffsets, 0);

char *xsptr = ADJUST_PTR(sptr, ssuboffsets, 0);

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

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

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

mem);

}

}

/* Faster copying of one-dimensional arrays. */

static int

copy_single(PyMemoryViewObject *self, const Py_buffer *dest, const Py_buffer *src)

{

CHECK_RELEASED_INT_AGAIN(self);

char *mem = NULL;

assert(dest->ndim == 1);

if (!equiv_structure(dest, src))

return -1;

if (!last_dim_is_contiguous(dest, src)) {

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

if (mem == NULL) {

PyErr_NoMemory();

return -1;

}

}

copy_base(dest->shape, dest->itemsize,

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

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

mem);

if (mem)

PyMem_Free(mem);

return 0;

}

/* Recursively copy src to dest. Both buffers must have the same basic

structure. Copying is atomic, the function never fails with a partial

copy. */

static int

copy_buffer(const Py_buffer *dest, const Py_buffer *src)

{

char *mem = NULL;

assert(dest->ndim > 0);

if (!equiv_structure(dest, src))

return -1;

if (!last_dim_is_contiguous(dest, src)) {

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

if (mem == NULL) {

PyErr_NoMemory();

return -1;

}

}

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

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

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

mem);

if (mem)

PyMem_Free(mem);

return 0;

}

/* Initialize strides for a C-contiguous array. */

static inline void

init_strides_from_shape(Py_buffer *view)

{

Py_ssize_t i;

assert(view->ndim > 0);

view->strides[view->ndim-1] = view->itemsize;

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

view->strides[i] = view->strides[i+1] * view->shape[i+1];

}

/* Initialize strides for a Fortran-contiguous array. */

static inline void

init_fortran_strides_from_shape(Py_buffer *view)

{

Py_ssize_t i;

assert(view->ndim > 0);

view->strides[0] = view->itemsize;

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

view->strides[i] = view->strides[i-1] * view->shape[i-1];

}

/* Copy src to a contiguous representation. order is one of 'C', 'F' (Fortran)

or 'A' (Any). Assumptions: src has PyBUF_FULL information, src->ndim >= 1,

len(mem) == src->len. */

static int

buffer_to_contiguous(char *mem, const Py_buffer *src, char order)

{

Py_buffer dest;

Py_ssize_t *strides;

int ret;

assert(src->ndim >= 1);

assert(src->shape != NULL);

assert(src->strides != NULL);

strides = PyMem_Malloc(src->ndim * (sizeof *src->strides));

if (strides == NULL) {

PyErr_NoMemory();

return -1;

}

/* initialize dest */

dest = *src;

dest.buf = mem;

/* shape is constant and shared: the logical representation of the

array is unaltered. */

/* The physical representation determined by strides (and possibly

suboffsets) may change. */

dest.strides = strides;

if (order == 'C' || order == 'A') {

init_strides_from_shape(&dest);

}

else {

init_fortran_strides_from_shape(&dest);

}

dest.suboffsets = NULL;

ret = copy_buffer(&dest, src);

PyMem_Free(strides);

return ret;

}

/****************************************************************************/

/* Constructors */

/****************************************************************************/

/* Initialize values that are shared with the managed buffer. */

static inline void

init_shared_values(Py_buffer *dest, const Py_buffer *src)

{

dest->obj = src->obj;

dest->buf = src->buf;

dest->len = src->len;

dest->itemsize = src->itemsize;

dest->readonly = src->readonly;

dest->format = src->format ? src->format : "B";

dest->internal = src->internal;

}

/* Copy shape and strides. Reconstruct missing values. */

static void

init_shape_strides(Py_buffer *dest, const Py_buffer *src)

{

Py_ssize_t i;

if (src->ndim == 0) {

dest->shape = NULL;

dest->strides = NULL;

return;

}

if (src->ndim == 1) {

dest->shape[0] = src->shape ? src->shape[0] : src->len / src->itemsize;

dest->strides[0] = src->strides ? src->strides[0] : src->itemsize;

return;

}

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

dest->shape[i] = src->shape[i];

if (src->strides) {

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

dest->strides[i] = src->strides[i];

}

else {

init_strides_from_shape(dest);

}

}

static inline void

init_suboffsets(Py_buffer *dest, const Py_buffer *src)

{

Py_ssize_t i;

if (src->suboffsets == NULL) {

dest->suboffsets = NULL;

return;

}

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

dest->suboffsets[i] = src->suboffsets[i];

}

/* len = product(shape) * itemsize */

static inline void

init_len(Py_buffer *view)

{

Py_ssize_t i, len;

len = 1;

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

len *= view->shape[i];

len *= view->itemsize;

view->len = len;

}

/* Initialize memoryview buffer properties. */

static void

init_flags(PyMemoryViewObject *mv)

{

const Py_buffer *view = &mv->view;

int flags = 0;

switch (view->ndim) {

case 0:

flags |= (_Py_MEMORYVIEW_SCALAR|_Py_MEMORYVIEW_C|

_Py_MEMORYVIEW_FORTRAN);

break;

case 1:

if (MV_CONTIGUOUS_NDIM1(view))

flags |= (_Py_MEMORYVIEW_C|_Py_MEMORYVIEW_FORTRAN);

break;

default:

if (PyBuffer_IsContiguous(view, 'C'))

flags |= _Py_MEMORYVIEW_C;

if (PyBuffer_IsContiguous(view, 'F'))

flags |= _Py_MEMORYVIEW_FORTRAN;

break;

}

if (view->suboffsets) {

flags |= _Py_MEMORYVIEW_PIL;

flags &= ~(_Py_MEMORYVIEW_C|_Py_MEMORYVIEW_FORTRAN);

}

mv->flags = flags;

}

/* Allocate a new memoryview and perform basic initialization. New memoryviews

are exclusively created through the mbuf_add functions. */

static inline PyMemoryViewObject *

memory_alloc(int ndim)

{

PyMemoryViewObject *mv;

mv = (PyMemoryViewObject *)

PyObject_GC_NewVar(PyMemoryViewObject, &PyMemoryView_Type, 3*ndim);

if (mv == NULL)

return NULL;

mv->mbuf = NULL;

mv->hash = -1;

mv->flags = 0;

mv->exports = 0;

mv->view.ndim = ndim;

mv->view.shape = mv->ob_array;

mv->view.strides = mv->ob_array + ndim;

mv->view.suboffsets = mv->ob_array + 2 * ndim;

mv->weakreflist = NULL;

_PyObject_GC_TRACK(mv);

return mv;

}

/*

Return a new memoryview that is registered with mbuf. If src is NULL,

use mbuf->master as the underlying buffer. Otherwise, use src.

The new memoryview has full buffer information: shape and strides

are always present, suboffsets as needed. Arrays are copied to

the memoryview's ob_array field.

*/

static PyObject *

mbuf_add_view(_PyManagedBufferObject *mbuf, const Py_buffer *src)

{

PyMemoryViewObject *mv;

Py_buffer *dest;

if (src == NULL)

src = &mbuf->master;

if (src->ndim > PyBUF_MAX_NDIM) {

PyErr_SetString(PyExc_ValueError,

"memoryview: number of dimensions must not exceed "

Py_STRINGIFY(PyBUF_MAX_NDIM));

return NULL;

}

mv = memory_alloc(src->ndim);

if (mv == NULL)

return NULL;

dest = &mv->view;

init_shared_values(dest, src);

init_shape_strides(dest, src);

init_suboffsets(dest, src);

init_flags(mv);

mv->mbuf = (_PyManagedBufferObject*)Py_NewRef(mbuf);

mbuf->exports++;

return (PyObject *)mv;

}

/* Register an incomplete view: shape, strides, suboffsets and flags still

need to be initialized. Use 'ndim' instead of src->ndim to determine the

size of the memoryview's ob_array.

Assumption: ndim <= PyBUF_MAX_NDIM. */

static PyObject *

mbuf_add_incomplete_view(_PyManagedBufferObject *mbuf, const Py_buffer *src,

int ndim)

{

PyMemoryViewObject *mv;

Py_buffer *dest;

if (src == NULL)

src = &mbuf->master;

assert(ndim <= PyBUF_MAX_NDIM);

mv = memory_alloc(ndim);

if (mv == NULL)

return NULL;

dest = &mv->view;

init_shared_values(dest, src);

mv->mbuf = (_PyManagedBufferObject*)Py_NewRef(mbuf);

mbuf->exports++;

return (PyObject *)mv;

}

/* Expose a raw memory area as a view of contiguous bytes. flags can be

PyBUF_READ or PyBUF_WRITE. view->format is set to "B" (unsigned bytes).

The memoryview has complete buffer information. */

PyObject *

PyMemoryView_FromMemory(char *mem, Py_ssize_t size, int flags)

{

_PyManagedBufferObject *mbuf;

PyObject *mv;

int readonly;

assert(mem != NULL);

assert(flags == PyBUF_READ || flags == PyBUF_WRITE);

mbuf = mbuf_alloc();

if (mbuf == NULL)

return NULL;

readonly = (flags == PyBUF_WRITE) ? 0 : 1;

(void)PyBuffer_FillInfo(&mbuf->master, NULL, mem, size, readonly,

PyBUF_FULL_RO);

mv = mbuf_add_view(mbuf, NULL);

Py_DECREF(mbuf);

return mv;

}

/* Create a memoryview from a given Py_buffer. For simple byte views,

PyMemoryView_FromMemory() should be used instead.

This function is the only entry point that can create a master buffer

without full information. Because of this fact init_shape_strides()

must be able to reconstruct missing values. */

PyObject *

PyMemoryView_FromBuffer(const Py_buffer *info)

{

_PyManagedBufferObject *mbuf;

PyObject *mv;

if (info->buf == NULL) {

PyErr_SetString(PyExc_ValueError,

"PyMemoryView_FromBuffer(): info->buf must not be NULL");

return NULL;

}

mbuf = mbuf_alloc();

if (mbuf == NULL)

return NULL;

/* info->obj is either NULL or a borrowed reference. This reference

should not be decremented in PyBuffer_Release(). */

mbuf->master = *info;

mbuf->master.obj = NULL;

mv = mbuf_add_view(mbuf, NULL);

Py_DECREF(mbuf);

return mv;

}

/* Create a memoryview from an object that implements the buffer protocol,

using the given flags.

If the object is a memoryview, the new memoryview must be registered

with the same managed buffer. Otherwise, a new managed buffer is created. */

static PyObject *

PyMemoryView_FromObjectAndFlags(PyObject *v, int flags)

{

_PyManagedBufferObject *mbuf;

if (PyMemoryView_Check(v)) {

PyMemoryViewObject *mv = (PyMemoryViewObject *)v;

CHECK_RELEASED(mv);

CHECK_RESTRICTED(mv);

return mbuf_add_view(mv->mbuf, &mv->view);

}

else if (PyObject_CheckBuffer(v)) {

PyObject *ret;

mbuf = (_PyManagedBufferObject *)_PyManagedBuffer_FromObject(v, flags);

if (mbuf == NULL)

return NULL;

ret = mbuf_add_view(mbuf, NULL);

Py_DECREF(mbuf);

return ret;

}

PyErr_Format(PyExc_TypeError,

"memoryview: a bytes-like object is required, not '%.200s'",

Py_TYPE(v)->tp_name);

return NULL;

}

/* Create a memoryview from an object that implements the buffer protocol,

using the given flags.

If the object is a memoryview, the new memoryview must be registered

with the same managed buffer. Otherwise, a new managed buffer is created. */

PyObject *

_PyMemoryView_FromBufferProc(PyObject *v, int flags, getbufferproc bufferproc)

{

_PyManagedBufferObject *mbuf = mbuf_alloc();

if (mbuf == NULL)

return NULL;

int res = bufferproc(v, &mbuf->master, flags);

if (res < 0) {

mbuf->master.obj = NULL;

Py_DECREF(mbuf);

return NULL;

}

PyObject *ret = mbuf_add_view(mbuf, NULL);

Py_DECREF(mbuf);

return ret;

}

/* Create a memoryview from an object that implements the buffer protocol.

If the object is a memoryview, the new memoryview must be registered

with the same managed buffer. Otherwise, a new managed buffer is created. */

PyObject *

PyMemoryView_FromObject(PyObject *v)

{

return PyMemoryView_FromObjectAndFlags(v, PyBUF_FULL_RO);

}

/* Copy the format string from a base object that might vanish. */

static int

mbuf_copy_format(_PyManagedBufferObject *mbuf, const char *fmt)

{

if (fmt != NULL) {

char *cp = PyMem_Malloc(strlen(fmt)+1);

if (cp == NULL) {

PyErr_NoMemory();

return -1;

}

mbuf->master.format = strcpy(cp, fmt);

mbuf->flags |= _Py_MANAGED_BUFFER_FREE_FORMAT;

}

return 0;

}

/*

Return a memoryview that is based on a contiguous copy of src.

Assumptions: src has PyBUF_FULL_RO information, src->ndim > 0.

Ownership rules:

1) As usual, the returned memoryview has a private copy

of src->shape, src->strides and src->suboffsets.

2) src->format is copied to the master buffer and released

in mbuf_dealloc(). The releasebufferproc of the bytes

object is NULL, so it does not matter that mbuf_release()

passes the altered format pointer to PyBuffer_Release().

*/

static PyObject *

memory_from_contiguous_copy(const Py_buffer *src, char order)

{

_PyManagedBufferObject *mbuf;

PyMemoryViewObject *mv;

PyObject *bytes;

Py_buffer *dest;

int i;

assert(src->ndim > 0);

assert(src->shape != NULL);

bytes = PyBytes_FromStringAndSize(NULL, src->len);

if (bytes == NULL)

return NULL;

mbuf = (_PyManagedBufferObject *)_PyManagedBuffer_FromObject(bytes, PyBUF_FULL_RO);

Py_DECREF(bytes);

if (mbuf == NULL)

return NULL;

if (mbuf_copy_format(mbuf, src->format) < 0) {

Py_DECREF(mbuf);

return NULL;

}

mv = (PyMemoryViewObject *)mbuf_add_incomplete_view(mbuf, NULL, src->ndim);

Py_DECREF(mbuf);

if (mv == NULL)

return NULL;

dest = &mv->view;

/* shared values are initialized correctly except for itemsize */

dest->itemsize = src->itemsize;

/* shape and strides */

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

dest->shape[i] = src->shape[i];

}

if (order == 'C' || order == 'A') {

init_strides_from_shape(dest);

}

else {

init_fortran_strides_from_shape(dest);

}

/* suboffsets */

dest->suboffsets = NULL;

/* flags */

init_flags(mv);

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

Py_DECREF(mv);

return NULL;

}

return (PyObject *)mv;

}

/*

Return a new memoryview object based on a contiguous exporter with

buffertype={PyBUF_READ, PyBUF_WRITE} and order={'C', 'F'ortran, or 'A'ny}.

The logical structure of the input and output buffers is the same

(i.e. tolist(input) == tolist(output)), but the physical layout in

memory can be explicitly chosen.

As usual, if buffertype=PyBUF_WRITE, the exporter's buffer must be writable,

otherwise it may be writable or read-only.

If the exporter is already contiguous with the desired target order,

the memoryview will be directly based on the exporter.

Otherwise, if the buffertype is PyBUF_READ, the memoryview will be

based on a new bytes object. If order={'C', 'A'ny}, use 'C' order,

'F'ortran order otherwise.

*/

PyObject *

PyMemoryView_GetContiguous(PyObject *obj, int buffertype, char order)

{

PyMemoryViewObject *mv;

PyObject *ret;

Py_buffer *view;

assert(buffertype == PyBUF_READ || buffertype == PyBUF_WRITE);

assert(order == 'C' || order == 'F' || order == 'A');

mv = (PyMemoryViewObject *)PyMemoryView_FromObject(obj);

if (mv == NULL)

return NULL;

view = &mv->view;

if (buffertype == PyBUF_WRITE && view->readonly) {

PyErr_SetString(PyExc_BufferError,

"underlying buffer is not writable");

Py_DECREF(mv);

return NULL;

}

if (PyBuffer_IsContiguous(view, order))

return (PyObject *)mv;

if (buffertype == PyBUF_WRITE) {

PyErr_SetString(PyExc_BufferError,

"writable contiguous buffer requested "

"for a non-contiguous object.");

Py_DECREF(mv);

return NULL;

}

ret = memory_from_contiguous_copy(view, order);

Py_DECREF(mv);

return ret;