/* Return 1 if the getbuffer function is available, otherwise
return 0 */
- PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, PyBuffer *view,
+ PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view,
int flags);
/* This is a C-API version of the getbuffer function call. It checks
*/
- PyAPI_FUNC(void) PyObject_ReleaseBuffer(PyObject *obj, PyBuffer *view);
+ PyAPI_FUNC(void) PyObject_ReleaseBuffer(PyObject *obj, Py_buffer *view);
/* C-API version of the releasebuffer function call. It
buffer
*/
- PyAPI_FUNC(void *) PyBuffer_GetPointer(PyBuffer *view, Py_ssize_t *indices);
+ PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices);
/* Get the memory area pointed to by the indices for the buffer given.
Note that view->ndim is the assumed size of indices
- PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, PyBuffer *view,
+ PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view,
Py_ssize_t len, char fort);
- PyAPI_FUNC(int) PyBuffer_FromContiguous(PyBuffer *view, void *buf,
+ PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf,
Py_ssize_t len, char fort);
/* Copy the data from the src buffer to the buffer of destination
*/
- PyAPI_FUNC(int) PyBuffer_IsContiguous(PyBuffer *view, char fortran);
+ PyAPI_FUNC(int) PyBuffer_IsContiguous(Py_buffer *view, char fortran);
PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims,
per element.
*/
- PyAPI_FUNC(int) PyBuffer_FillInfo(PyBuffer *view, void *buf,
+ PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, void *buf,
Py_ssize_t len, int readonly,
int flags);
typedef struct {
PyObject_HEAD
PyObject *base;
- PyBuffer view;
+ Py_buffer view;
} PyMemoryViewObject;
PyAPI_FUNC(PyObject *) PyMemoryView_FromObject(PyObject *base);
-PyAPI_FUNC(PyObject *) PyMemoryView_FromMemory(PyBuffer *info);
+PyAPI_FUNC(PyObject *) PyMemoryView_FromMemory(Py_buffer *info);
/* create new if bufptr is NULL
will be a new bytesobject in base */
Py_ssize_t *strides;
Py_ssize_t *suboffsets;
void *internal;
-} PyBuffer;
+} Py_buffer;
-typedef int (*getbufferproc)(PyObject *, PyBuffer *, int);
-typedef void (*releasebufferproc)(PyObject *, PyBuffer *);
+typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
+typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
/* Flags for getting buffers */
#define PyBUF_SIMPLE 0
char *ptr;
Py_ssize_t size;
int rel = 0;
- PyBuffer view;
+ Py_buffer view;
if (PyBuffer_Check(value)) {
if (PyObject_GetBuffer(value, &view, PyBUF_SIMPLE) < 0)
{ NULL },
};
-static int CData_GetBuffer(PyObject *_self, PyBuffer *view, int flags)
+static int CData_GetBuffer(PyObject *_self, Py_buffer *view, int flags)
{
CDataObject *self = (CDataObject *)_self;
return PyBuffer_FillInfo(view, self->b_ptr, self->b_size, 0, flags);
EVP_update(EVPobject *self, PyObject *args)
{
PyObject *obj;
- PyBuffer view;
+ Py_buffer view;
if (!PyArg_ParseTuple(args, "O:update", &obj))
return NULL;
static char *kwlist[] = {"name", "string", NULL};
PyObject *name_obj = NULL;
PyObject *data_obj = NULL;
- PyBuffer view;
+ Py_buffer view;
char *nameStr;
const EVP_MD *digest;
static char *kwlist[] = {"name", "string", NULL};
PyObject *name_obj = NULL;
PyObject *data_obj = NULL;
- PyBuffer view = { 0 };
+ Py_buffer view = { 0 };
PyObject *ret_obj;
char *name;
const EVP_MD *digest;
EVP_new_ ## NAME (PyObject *self, PyObject *args) \
{ \
PyObject *data_obj = NULL; \
- PyBuffer view = { 0 }; \
+ Py_buffer view = { 0 }; \
PyObject *ret_obj; \
\
if (!PyArg_ParseTuple(args, "|O:" #NAME , &data_obj)) { \
Py_ssize_t size, bytes;
int charsize;
void* ptr;
- PyBuffer view;
+ Py_buffer view;
/* get pointer to string buffer */
view.len = -1;
static int
-array_buffer_getbuf(arrayobject *self, PyBuffer *view, int flags)
+array_buffer_getbuf(arrayobject *self, Py_buffer *view, int flags)
{
if ((flags & PyBUF_CHARACTER)) {
PyErr_SetString(PyExc_TypeError,
}
static void
-array_buffer_relbuf(arrayobject *self, PyBuffer *view)
+array_buffer_relbuf(arrayobject *self, Py_buffer *view)
{
self->ob_exports--;
}
/* Functions for treating an mmap'ed file as a buffer */
static int
-mmap_buffer_getbuf(mmap_object *self, PyBuffer *view, int flags)
+mmap_buffer_getbuf(mmap_object *self, Py_buffer *view, int flags)
{
CHECK_VALID(-1);
if (PyBuffer_FillInfo(view, self->data, self->size,
}
static void
-mmap_buffer_releasebuf(mmap_object *self, PyBuffer *view)
+mmap_buffer_releasebuf(mmap_object *self, Py_buffer *view)
{
self->exports--;
}
Py_ssize_t *buffer_len)
{
PyBufferProcs *pb;
- PyBuffer view;
+ Py_buffer view;
if (obj == NULL || buffer == NULL || buffer_len == NULL) {
null_error();
Py_ssize_t *buffer_len)
{
PyBufferProcs *pb;
- PyBuffer view;
+ Py_buffer view;
if (obj == NULL || buffer == NULL || buffer_len == NULL) {
null_error();
Py_ssize_t *buffer_len)
{
PyBufferProcs *pb;
- PyBuffer view;
+ Py_buffer view;
if (obj == NULL || buffer == NULL || buffer_len == NULL) {
null_error();
/* Buffer C-API for Python 3.0 */
int
-PyObject_GetBuffer(PyObject *obj, PyBuffer *view, int flags)
+PyObject_GetBuffer(PyObject *obj, Py_buffer *view, int flags)
{
if (!PyObject_CheckBuffer(obj)) {
PyErr_SetString(PyExc_TypeError,
}
void
-PyObject_ReleaseBuffer(PyObject *obj, PyBuffer *view)
+PyObject_ReleaseBuffer(PyObject *obj, Py_buffer *view)
{
if (obj->ob_type->tp_as_buffer != NULL &&
obj->ob_type->tp_as_buffer->bf_releasebuffer != NULL) {
static int
-_IsFortranContiguous(PyBuffer *view)
+_IsFortranContiguous(Py_buffer *view)
{
Py_ssize_t sd, dim;
int i;
}
static int
-_IsCContiguous(PyBuffer *view)
+_IsCContiguous(Py_buffer *view)
{
Py_ssize_t sd, dim;
int i;
}
int
-PyBuffer_IsContiguous(PyBuffer *view, char fort)
+PyBuffer_IsContiguous(Py_buffer *view, char fort)
{
if (view->suboffsets != NULL) return 0;
void*
-PyBuffer_GetPointer(PyBuffer *view, Py_ssize_t *indices)
+PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices)
{
char* pointer;
int i;
*/
int
-PyBuffer_ToContiguous(void *buf, PyBuffer *view, Py_ssize_t len, char fort)
+PyBuffer_ToContiguous(void *buf, Py_buffer *view, Py_ssize_t len, char fort)
{
int k;
void (*addone)(int, Py_ssize_t *, Py_ssize_t *);
}
int
-PyBuffer_FromContiguous(PyBuffer *view, void *buf, Py_ssize_t len, char fort)
+PyBuffer_FromContiguous(Py_buffer *view, void *buf, Py_ssize_t len, char fort)
{
int k;
void (*addone)(int, Py_ssize_t *, Py_ssize_t *);
int PyObject_CopyData(PyObject *dest, PyObject *src)
{
- PyBuffer view_dest, view_src;
+ Py_buffer view_dest, view_src;
int k;
Py_ssize_t *indices, elements;
char *dptr, *sptr;
}
int
-PyBuffer_FillInfo(PyBuffer *view, void *buf, Py_ssize_t len,
+PyBuffer_FillInfo(Py_buffer *view, void *buf, Py_ssize_t len,
int readonly, int flags)
{
if (view == NULL) return 0;
static int
-get_buf(PyBufferObject *self, PyBuffer *view, int flags)
+get_buf(PyBufferObject *self, Py_buffer *view, int flags)
{
if (self->b_base == NULL) {
view->buf = self->b_ptr;
view->len = self->b_size;
+ view->readonly = 0;
}
else {
Py_ssize_t count, offset;
static int
-buffer_getbuf(PyBufferObject *self, PyBuffer *view, int flags)
+buffer_getbuf(PyBufferObject *self, Py_buffer *view, int flags)
{
if (view == NULL) return 0;
if (!get_buf(self, view, flags))
static void
-buffer_releasebuf(PyBufferObject *self, PyBuffer *view)
+buffer_releasebuf(PyBufferObject *self, Py_buffer *view)
{
/* No-op if there is no self->b_base */
if (self->b_base != NULL) {
}
static int
-get_bufx(PyObject *obj, PyBuffer *view, int flags)
+get_bufx(PyObject *obj, Py_buffer *view, int flags)
{
PyBufferProcs *bp;
void *p1, *p2;
Py_ssize_t len1, len2, min_len;
int cmp, ok;
- PyBuffer v1, v2;
+ Py_buffer v1, v2;
ok = 1;
if (!get_bufx(self, &v1, PyBUF_SIMPLE))
static long
buffer_hash(PyBufferObject *self)
{
- PyBuffer view;
+ Py_buffer view;
register Py_ssize_t len;
register unsigned char *p;
register long x;
static PyObject *
buffer_str(PyBufferObject *self)
{
- PyBuffer view;
+ Py_buffer view;
PyObject *res;
if (!get_buf(self, &view, PyBUF_SIMPLE))
static Py_ssize_t
buffer_length(PyBufferObject *self)
{
- PyBuffer view;
+ Py_buffer view;
if (!get_buf(self, &view, PyBUF_SIMPLE))
return -1;
PyBufferProcs *pb = other->ob_type->tp_as_buffer;
char *p;
PyObject *ob;
- PyBuffer view, view2;
+ Py_buffer view, view2;
if (pb == NULL ||
pb->bf_getbuffer == NULL)
{
PyObject *ob;
register char *p;
- PyBuffer view;
+ Py_buffer view;
if (count < 0)
count = 0;
static PyObject *
buffer_item(PyBufferObject *self, Py_ssize_t idx)
{
- PyBuffer view;
+ Py_buffer view;
PyObject *ob;
if (!get_buf(self, &view, PyBUF_SIMPLE))
static PyObject *
buffer_subscript(PyBufferObject *self, PyObject *item)
{
- PyBuffer view;
+ Py_buffer view;
PyObject *ob;
if (!get_buf(self, &view, PyBUF_SIMPLE))
buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other)
{
PyBufferProcs *pb;
- PyBuffer view, view2;
+ Py_buffer view, view2;
if (!get_buf(self, &view, PyBUF_SIMPLE))
return -1;
static int
buffer_ass_subscript(PyBufferObject *self, PyObject *item, PyObject *value)
{
- PyBuffer v1;
+ Py_buffer v1;
if (!get_buf(self, &v1, PyBUF_SIMPLE))
return -1;
}
else if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength;
- PyBuffer v2;
+ Py_buffer v2;
PyBufferProcs *pb;
if (PySlice_GetIndicesEx((PySliceObject *)item, v1.len,
}
static int
-bytes_getbuffer(PyBytesObject *obj, PyBuffer *view, int flags)
+bytes_getbuffer(PyBytesObject *obj, Py_buffer *view, int flags)
{
int ret;
void *ptr;
}
static void
-bytes_releasebuffer(PyBytesObject *obj, PyBuffer *view)
+bytes_releasebuffer(PyBytesObject *obj, Py_buffer *view)
{
obj->ob_exports--;
}
static Py_ssize_t
-_getbuffer(PyObject *obj, PyBuffer *view)
+_getbuffer(PyObject *obj, Py_buffer *view)
{
PyBufferProcs *buffer = Py_Type(obj)->tp_as_buffer;
PyBytes_Concat(PyObject *a, PyObject *b)
{
Py_ssize_t size;
- PyBuffer va, vb;
+ Py_buffer va, vb;
PyBytesObject *result;
va.len = -1;
{
Py_ssize_t mysize;
Py_ssize_t size;
- PyBuffer vo;
+ Py_buffer vo;
if (_getbuffer(other, &vo) < 0) {
PyErr_Format(PyExc_TypeError, "can't concat bytes to %.100s",
{
Py_ssize_t avail, needed;
void *bytes;
- PyBuffer vbytes;
+ Py_buffer vbytes;
int res = 0;
vbytes.len = -1;
/* Use the modern buffer interface */
if (PyObject_CheckBuffer(arg)) {
Py_ssize_t size;
- PyBuffer view;
+ Py_buffer view;
if (PyObject_GetBuffer(arg, &view, PyBUF_FULL_RO) < 0)
return -1;
size = view.len;
bytes_richcompare(PyObject *self, PyObject *other, int op)
{
Py_ssize_t self_size, other_size;
- PyBuffer self_bytes, other_bytes;
+ Py_buffer self_bytes, other_bytes;
PyObject *res;
Py_ssize_t minsize;
int cmp;
bytes_find_internal(PyBytesObject *self, PyObject *args, int dir)
{
PyObject *subobj;
- PyBuffer subbuf;
+ Py_buffer subbuf;
Py_ssize_t start=0, end=PY_SSIZE_T_MAX;
Py_ssize_t res;
{
Py_ssize_t count = -1;
PyObject *from, *to, *res;
- PyBuffer vfrom, vto;
+ Py_buffer vfrom, vto;
if (!PyArg_ParseTuple(args, "OO|n:replace", &from, &to, &count))
return NULL;
Py_ssize_t maxsplit = -1, count = 0;
const char *s = PyBytes_AS_STRING(self), *sub;
PyObject *list, *str, *subobj = Py_None;
- PyBuffer vsub;
+ Py_buffer vsub;
#ifdef USE_FAST
Py_ssize_t pos;
#endif
Py_ssize_t maxsplit = -1, count = 0;
const char *s = PyBytes_AS_STRING(self), *sub;
PyObject *list, *str, *subobj = Py_None;
- PyBuffer vsub;
+ Py_buffer vsub;
if (!PyArg_ParseTuple(args, "|On:rsplit", &subobj, &maxsplit))
return NULL;
Py_ssize_t left, right, mysize, argsize;
void *myptr, *argptr;
PyObject *arg = Py_None;
- PyBuffer varg;
+ Py_buffer varg;
if (!PyArg_ParseTuple(args, "|O:strip", &arg))
return NULL;
if (arg == Py_None) {
Py_ssize_t left, right, mysize, argsize;
void *myptr, *argptr;
PyObject *arg = Py_None;
- PyBuffer varg;
+ Py_buffer varg;
if (!PyArg_ParseTuple(args, "|O:lstrip", &arg))
return NULL;
if (arg == Py_None) {
Py_ssize_t left, right, mysize, argsize;
void *myptr, *argptr;
PyObject *arg = Py_None;
- PyBuffer varg;
+ Py_buffer varg;
if (!PyArg_ParseTuple(args, "|O:rstrip", &arg))
return NULL;
if (arg == Py_None) {
#include "Python.h"
static int
-memory_getbuf(PyMemoryViewObject *self, PyBuffer *view, int flags)
+memory_getbuf(PyMemoryViewObject *self, Py_buffer *view, int flags)
{
if (view != NULL)
- memcpy(view, &(self->view), sizeof(PyBuffer));
+ *view = self->view;
return self->base->ob_type->tp_as_buffer->bf_getbuffer(self->base,
NULL, PyBUF_FULL);
}
static void
-memory_releasebuf(PyMemoryViewObject *self, PyBuffer *view)
+memory_releasebuf(PyMemoryViewObject *self, Py_buffer *view)
{
PyObject_ReleaseBuffer(self->base, NULL);
}
Create a new memoryview object which references the given object.");
PyObject *
-PyMemoryView_FromMemory(PyBuffer *info)
+PyMemoryView_FromMemory(Py_buffer *info)
{
- /* XXX(nnorwitz): need to implement something here? */
- PyErr_SetString(PyExc_NotImplementedError, "need to implement");
- return NULL;
+ PyMemoryViewObject *mview;
+
+ mview = (PyMemoryViewObject *)PyObject_New(PyMemoryViewObject,
+ &PyMemoryView_Type);
+ if (mview == NULL) return NULL;
+ mview->base = NULL;
+ mview->view = *info;
+ return (PyObject *)mview;
}
PyObject *
void _add_one_to_index_C(int nd, Py_ssize_t *index, Py_ssize_t *shape);
static int
-_indirect_copy_nd(char *dest, PyBuffer *view, char fort)
+_indirect_copy_nd(char *dest, Py_buffer *view, char fort)
{
Py_ssize_t *indices;
int k;
{
PyMemoryViewObject *mem;
PyObject *bytes;
- PyBuffer *view;
+ Py_buffer *view;
int flags;
char *dest;
/* return a shadowed memory-view object */
view->buf = dest;
mem->base = PyTuple_Pack(2, obj, bytes);
- /* XXX(nnorwitz): need to verify alloc was successful. */
Py_DECREF(bytes);
+ if (mem->base == NULL) {
+ PyObject_ReleaseBuffer(obj, view);
+ return NULL;
+ }
}
else {
PyObject_ReleaseBuffer(obj, view);
static PyObject *
memory_tobytes(PyMemoryViewObject *mem, PyObject *noargs)
{
- /* Create new Bytes object for data */
return PyBytes_FromObject((PyObject *)mem);
}
static PyObject *
memory_tolist(PyMemoryViewObject *mem, PyObject *noargs)
{
+ /* This should construct a (nested) list of unpacked objects
+ possibly using the struct module.
+ */
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
static PyObject *
memory_str(PyMemoryViewObject *self)
{
- PyBuffer view;
+ Py_buffer view;
PyObject *res;
if (PyObject_GetBuffer((PyObject *)self, &view, PyBUF_FULL) < 0)
static Py_ssize_t
memory_length(PyMemoryViewObject *self)
{
- PyBuffer view;
+ Py_buffer view;
if (PyObject_GetBuffer((PyObject *)self, &view, PyBUF_FULL) < 0)
return -1;
return view.len;
}
+/*
+ mem[obj] returns a bytes object holding the data for one element if
+ obj fully indexes the memory view or another memory-view object
+ if it does not.
+
+ 0-d memory-view objects can be referenced using ... or () but
+ not with anything else.
+ */
static PyObject *
memory_subscript(PyMemoryViewObject *self, PyObject *key)
{
+ Py_buffer *view;
+ view = &(self->view);
+
+ if (view->ndim == 0) {
+ if (key == Py_Ellipsis ||
+ (PyTuple_Check(key) && PyTuple_GET_SIZE(key)==0)) {
+ Py_INCREF(self);
+ return (PyObject *)self;
+ }
+ else {
+ PyErr_SetString(PyExc_IndexError, "invalid indexing of 0-dim memory");
+ return NULL;
+ }
+ }
+ if (PyIndex_Check(key)) {
+ Py_ssize_t result;
+ result = PyNumber_AsSsize_t(key, NULL);
+ if (result == -1 && PyErr_Occurred())
+ return NULL;
+ if (view->ndim == 1) {
+ /* Return a bytes object */
+ char *ptr;
+ ptr = (char *)view->buf;
+ if (view->strides == NULL)
+ ptr += view->itemsize * result;
+ else
+ ptr += view->strides[0] * result;
+ if (view->suboffsets != NULL && view->suboffsets[0] >= 0) {
+ ptr = *((char **)ptr) + view->suboffsets[0];
+ }
+ return PyBytes_FromStringAndSize(ptr, view->itemsize);
+ }
+ else {
+ /* Return a new memory-view object */
+ Py_buffer newview;
+ PyMemoryView_FromMemory(&newview);
+ }
+ }
+
+
+
Py_INCREF(Py_NotImplemented);
return Py_NotImplemented;
}
}
static int
-string_buffer_getbuffer(PyStringObject *self, PyBuffer *view, int flags)
+string_buffer_getbuffer(PyStringObject *self, Py_buffer *view, int flags)
{
return PyBuffer_FillInfo(view, (void *)self->ob_sval, Py_Size(self), 0, flags);
}
static int
-unicode_buffer_getbuffer(PyUnicodeObject *self, PyBuffer *view, int flags)
+unicode_buffer_getbuffer(PyUnicodeObject *self, Py_buffer *view, int flags)
{
if (flags & PyBUF_CHARACTER) {
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
int count;
int temp=-1;
- PyBuffer view;
+ Py_buffer view;
if (pb == NULL ||
pb->bf_getbuffer == NULL ||
char **p = va_arg(*p_va, char **);
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
int count;
- PyBuffer view;
+ Py_buffer view;
if (*format++ != '#')
return converterr(
{
PyBufferProcs *pb = arg->ob_type->tp_as_buffer;
Py_ssize_t count;
- PyBuffer view;
+ Py_buffer view;
*errmsg = NULL;
*p = NULL;
/* Write unknown buffer-style objects as a string */
char *s;
PyBufferProcs *pb = v->ob_type->tp_as_buffer;
- PyBuffer view;
+ Py_buffer view;
if ((*pb->bf_getbuffer)(v, &view, PyBUF_SIMPLE) != 0) {
w_byte(TYPE_UNKNOWN, p);
p->error = 1;
projects / python / commitdiff