cpython/Objects/bufferobject.c

/* Buffer object implementation */

#include "Python.h"


typedef struct {
	PyObject_HEAD
	PyObject *b_base;
	void *b_ptr;
	Py_ssize_t b_size;
	Py_ssize_t b_offset;
	int b_readonly;
	long b_hash;
} PyBufferObject;


static int
get_buf(PyBufferObject *self, PyBuffer *view, int flags)
{
	if (self->b_base == NULL) {
		view->buf = self->b_ptr;
		view->len = self->b_size;
	}
	else {
		Py_ssize_t count, offset;
		PyBufferProcs *bp = self->b_base->ob_type->tp_as_buffer;
                if ((*bp->bf_getbuffer)(self->b_base, view, flags) < 0)
                        return 0;
                count = view->len;
		/* apply constraints to the start/end */
		if (self->b_offset > count)
			offset = count;
		else
			offset = self->b_offset;
                view->buf = (char*)view->buf + offset;
		if (self->b_size == Py_END_OF_BUFFER)
			view->len = count;
		else
			view->len = self->b_size;
		if (offset + view->len > count)
			view->len = count - offset;
	}
	return 1;
}


static int
buffer_getbuf(PyBufferObject *self, PyBuffer *view, int flags)
{
        if (view == NULL) return 0;
        if (!get_buf(self, view, flags))
                return -1;
        return PyBuffer_FillInfo(view, view->buf, view->len, self->b_readonly,
                                 flags);
}


static void
buffer_releasebuf(PyBufferObject *self, PyBuffer *view) 
{
        /* No-op if there is no self->b_base */
	if (self->b_base != NULL) {
		PyBufferProcs *bp = self->b_base->ob_type->tp_as_buffer;
                if (bp->bf_releasebuffer != NULL) {
                        (*bp->bf_releasebuffer)(self->b_base, view);
                }
        }
}

static PyObject *
buffer_from_memory(PyObject *base, Py_ssize_t size, Py_ssize_t offset,
                   void *ptr, int readonly)
{
	PyBufferObject * b;

	if (size < 0 && size != Py_END_OF_BUFFER) {
		PyErr_SetString(PyExc_ValueError,
				"size must be zero or positive");
		return NULL;
	}
	if (offset < 0) {
		PyErr_SetString(PyExc_ValueError,
				"offset must be zero or positive");
		return NULL;
	}

	b = PyObject_NEW(PyBufferObject, &PyBuffer_Type);
	if (b == NULL)
		return NULL;

	Py_XINCREF(base);
	b->b_base = base;
	b->b_ptr = ptr;
	b->b_size = size;
	b->b_offset = offset;
	b->b_readonly = readonly;
	b->b_hash = -1;

	return (PyObject *) b;
}

static PyObject *
buffer_from_object(PyObject *base, Py_ssize_t size, Py_ssize_t offset,
                   int readonly)
{
	if (offset < 0) {
		PyErr_SetString(PyExc_ValueError,
				"offset must be zero or positive");
		return NULL;
	}
	if (PyBuffer_Check(base) && (((PyBufferObject *)base)->b_base)) {
		/* another buffer, refer to the base object */
		PyBufferObject *b = (PyBufferObject *)base;
		if (b->b_size != Py_END_OF_BUFFER) {
			Py_ssize_t base_size = b->b_size - offset;
			if (base_size < 0)
				base_size = 0;
			if (size == Py_END_OF_BUFFER || size > base_size)
				size = base_size;
		}
		offset += b->b_offset;
		base = b->b_base;
	}
	return buffer_from_memory(base, size, offset, NULL, readonly);
}


PyObject *
PyBuffer_FromObject(PyObject *base, Py_ssize_t offset, Py_ssize_t size)
{
	PyBufferProcs *pb = base->ob_type->tp_as_buffer;

	if (pb == NULL ||
            pb->bf_getbuffer == NULL) {
                PyErr_SetString(PyExc_TypeError, "buffer object expected");
		return NULL;
	}

	return buffer_from_object(base, size, offset, 1);
}

PyObject *
PyBuffer_FromReadWriteObject(PyObject *base, Py_ssize_t offset,
                             Py_ssize_t size)
{
	PyBufferProcs *pb = base->ob_type->tp_as_buffer;

	if (pb == NULL ||
            pb->bf_getbuffer == NULL) {
		PyErr_SetString(PyExc_TypeError, "buffer object expected");
		return NULL;
	}

	return buffer_from_object(base, size,  offset, 0);
}

PyObject *
PyBuffer_FromMemory(void *ptr, Py_ssize_t size)
{
	return buffer_from_memory(NULL, size, 0, ptr, 1);
}

PyObject *
PyBuffer_FromReadWriteMemory(void *ptr, Py_ssize_t size)
{
	return buffer_from_memory(NULL, size, 0, ptr, 0);
}

PyObject *
PyBuffer_New(Py_ssize_t size)
{
	PyObject *o;
	PyBufferObject * b;

	if (size < 0) {
		PyErr_SetString(PyExc_ValueError,
				"size must be zero or positive");
		return NULL;
	}
	/* XXX: check for overflow in multiply */
	/* Inline PyObject_New */
	o = (PyObject *)PyObject_MALLOC(sizeof(*b) + size);
	if (o == NULL)
		return PyErr_NoMemory();
	b = (PyBufferObject *) PyObject_INIT(o, &PyBuffer_Type);

	b->b_base = NULL;
	b->b_ptr = (void *)(b + 1);
	b->b_size = size;
	b->b_offset = 0;
	b->b_readonly = 0;
	b->b_hash = -1;

	return o;
}

/* Methods */

static PyObject *
buffer_new(PyTypeObject *type, PyObject *args, PyObject *kw)
{
	PyObject *ob;
	Py_ssize_t offset = 0;
	Py_ssize_t size = Py_END_OF_BUFFER;

	if (!_PyArg_NoKeywords("buffer()", kw))
		return NULL;

	if (!PyArg_ParseTuple(args, "O|nn:buffer", &ob, &offset, &size))
	    return NULL;
	return PyBuffer_FromObject(ob, offset, size);
}

PyDoc_STRVAR(buffer_doc,
"buffer(object [, offset[, size]])\n\
\n\
Create a new buffer object which references the given object.\n\
The buffer will reference a slice of the target object from the\n\
start of the object (or at the specified offset). The slice will\n\
extend to the end of the target object (or with the specified size).");


static void
buffer_dealloc(PyBufferObject *self)
{
	Py_XDECREF(self->b_base);
	PyObject_DEL(self);
}

static int
get_bufx(PyObject *obj, PyBuffer *view, int flags)
{
	PyBufferProcs *bp;

	if (PyBuffer_Check(obj)) {
		if (!get_buf((PyBufferObject *)obj, view, flags)) {
			PyErr_Clear();
			return 0;
		}
		else
			return 1;
	}
	bp = obj->ob_type->tp_as_buffer;
	if (bp == NULL ||
	    bp->bf_getbuffer == NULL)
		return 0;
	if ((*bp->bf_getbuffer)(obj, view, PyBUF_SIMPLE) < 0)
		return 0;
        return 1;
}

static PyObject *
buffer_richcompare(PyObject *self, PyObject *other, int op)
{
	void *p1, *p2;
	Py_ssize_t len1, len2, min_len;
	int cmp, ok;
        PyBuffer v1, v2;

	ok = 1;
	if (!get_bufx(self, &v1, PyBUF_SIMPLE))
		ok = 0;
	if (!get_bufx(other, &v2, PyBUF_SIMPLE)) {
                if (ok) PyObject_ReleaseBuffer((PyObject *)self, &v1);
		ok = 0;
        }
	if (!ok) {
		/* If we can't get the buffers,
		   == and != are still defined
		   (and the objects are unequal) */
		PyObject *result;
		if (op == Py_EQ)
			result = Py_False;
		else if (op == Py_NE)
			result = Py_True;
		else
			result = Py_NotImplemented;
		Py_INCREF(result);
		return result;
	}
        len1 = v1.len;
        len2 = v2.len;
        p1 = v1.buf;
        p2 = v2.buf;
	min_len = (len1 < len2) ? len1 : len2;
	cmp = memcmp(p1, p2, min_len);
	if (cmp == 0)
		cmp = (len1 < len2) ? -1 :
		      (len1 > len2) ? 1 : 0;
        PyObject_ReleaseBuffer((PyObject *)self, &v1);
        PyObject_ReleaseBuffer(other, &v2);
	return Py_CmpToRich(op, cmp);
}

static PyObject *
buffer_repr(PyBufferObject *self)
{
	const char *status = self->b_readonly ? "read-only" : "read-write";

	if (self->b_base == NULL)
		return PyUnicode_FromFormat(
                                "<%s buffer ptr %p, size %zd at %p>",
                                status,
                                self->b_ptr,
                                self->b_size,
                                self);
	else
		return PyUnicode_FromFormat(
			"<%s buffer for %p, size %zd, offset %zd at %p>",
			status,
			self->b_base,
			self->b_size,
			self->b_offset,
			self);
}

static long
buffer_hash(PyBufferObject *self)
{
        PyBuffer view;
	register Py_ssize_t len;
	register unsigned char *p;
	register long x;

	if (self->b_hash != -1)
		return self->b_hash;

        if (!get_buf(self, &view, PyBUF_SIMPLE))
		return -1;
        if (!(self->b_readonly)) {
                PyErr_SetString(PyExc_TypeError,
                                "writable buffers are not hashable");
                PyObject_ReleaseBuffer((PyObject *)self, &view);
		return -1;
	}
                
	p = (unsigned char *) view.buf;
	len = view.len;
	x = *p << 7;
	while (--len >= 0)
		x = (1000003*x) ^ *p++;
	x ^= view.len;
	if (x == -1)
		x = -2;
	self->b_hash = x;
        PyObject_ReleaseBuffer((PyObject *)self, &view);
	return x;
}

static PyObject *
buffer_str(PyBufferObject *self)
{
        PyBuffer view;
        PyObject *res;

	if (!get_buf(self, &view, PyBUF_SIMPLE))
		return NULL;
	res = PyString_FromStringAndSize((const char *)view.buf, view.len);
        PyObject_ReleaseBuffer((PyObject *)self, &view);
        return res;
}

/* Sequence methods */

static Py_ssize_t
buffer_length(PyBufferObject *self)
{
        PyBuffer view;

	if (!get_buf(self, &view, PyBUF_SIMPLE))
		return -1;
        PyObject_ReleaseBuffer((PyObject *)self, &view);
	return view.len;
}

static PyObject *
buffer_concat(PyBufferObject *self, PyObject *other)
{
	PyBufferProcs *pb = other->ob_type->tp_as_buffer;
	char *p;
	PyObject *ob;
        PyBuffer view, view2;

	if (pb == NULL ||
            pb->bf_getbuffer == NULL)
	{
		PyErr_BadArgument();
		return NULL;
	}

 	if (!get_buf(self, &view, PyBUF_SIMPLE))
 		return NULL;
 
	/* optimize special case */
        /* XXX bad idea type-wise */
	if (view.len == 0) {
                PyObject_ReleaseBuffer((PyObject *)self, &view);
                Py_INCREF(other);
                return other;
	}

        if (PyObject_GetBuffer((PyObject *)other, &view2, PyBUF_SIMPLE) < 0) {
                PyObject_ReleaseBuffer((PyObject *)self, &view);
                return NULL;
        }

	/* XXX(nnorwitz): need to check for overflow! */
 	ob = PyBytes_FromStringAndSize(NULL, view.len+view2.len);
	if (ob == NULL) {
                PyObject_ReleaseBuffer((PyObject *)self, &view);
                PyObject_ReleaseBuffer(other, &view2);
		return NULL;
        }
 	p = PyBytes_AS_STRING(ob);
 	memcpy(p, view.buf, view.len);
 	memcpy(p + view.len, view2.buf, view2.len);

        PyObject_ReleaseBuffer((PyObject *)self, &view);
        PyObject_ReleaseBuffer(other, &view2);
        return ob;
}

static PyObject *
buffer_repeat(PyBufferObject *self, Py_ssize_t count)
{
	PyObject *ob;
	register char *p;
        PyBuffer view;

	if (count < 0)
		count = 0;
	if (!get_buf(self, &view, PyBUF_SIMPLE))
		return NULL;
	/* XXX(nnorwitz): need to check for overflow! */
	ob = PyBytes_FromStringAndSize(NULL, view.len * count);
	if (ob == NULL)
		return NULL;

	p = PyBytes_AS_STRING(ob);
	while (count--) {
	    memcpy(p, view.buf, view.len);
	    p += view.len;
	}

        PyObject_ReleaseBuffer((PyObject *)self, &view);
	return ob;
}

static PyObject *
buffer_item(PyBufferObject *self, Py_ssize_t idx)
{
        PyBuffer view;
        PyObject *ob;

	if (!get_buf(self, &view, PyBUF_SIMPLE))
		return NULL;
	if (idx < 0 || idx >= view.len) {
		PyErr_SetString(PyExc_IndexError, "buffer index out of range");
		return NULL;
	}
	ob = PyBytes_FromStringAndSize((char *)view.buf + idx, 1);
        PyObject_ReleaseBuffer((PyObject *)self, &view);
        return ob;
}

static PyObject *
buffer_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right)
{
        PyObject *ob;
        PyBuffer view;
	if (!get_buf(self, &view, PyBUF_SIMPLE))
		return NULL;
	if (left < 0)
		left = 0;
	if (right < 0)
		right = 0;
	if (right > view.len)
		right = view.len;
	if (right < left)
		right = left;
	/* XXX(nnorwitz): is it possible to access unitialized memory? */
	ob = PyBytes_FromStringAndSize((char *)view.buf + left,
                                       right - left);
        PyObject_ReleaseBuffer((PyObject *)self, &view);
        return ob;
}

static PyObject *
buffer_subscript(PyBufferObject *self, PyObject *item)
{
	PyBuffer view;
	PyObject *ob;
	
	if (!get_buf(self, &view, PyBUF_SIMPLE))
		return NULL;
	if (PyIndex_Check(item)) {
		Py_ssize_t idx = PyNumber_AsSsize_t(item, PyExc_IndexError);

		if (idx == -1 && PyErr_Occurred())
			return NULL;
		if (idx < 0)
			idx += view.len;
		if (idx < 0 || idx >= view.len) {
			PyErr_SetString(PyExc_IndexError,
					"buffer index out of range");
			return NULL;
		}
		ob = PyBytes_FromStringAndSize((char *)view.buf + idx, 1);
		PyObject_ReleaseBuffer((PyObject *)self, &view);
		return ob;
	}
	else if (PySlice_Check(item)) {
		Py_ssize_t start, stop, step, slicelength, cur, i;

		if (PySlice_GetIndicesEx((PySliceObject*)item, view.len,
				 &start, &stop, &step, &slicelength) < 0) {
			PyObject_ReleaseBuffer((PyObject *)self, &view);
			return NULL;
		}

		if (slicelength <= 0) {
			PyObject_ReleaseBuffer((PyObject *)self, &view);
			return PyBytes_FromStringAndSize("", 0);
		}
		else if (step == 1) {
			ob = PyBytes_FromStringAndSize((char *)view.buf +
							start, stop - start);
			PyObject_ReleaseBuffer((PyObject *)self, &view);
			return ob;
		}
		else {
			char *source_buf = (char *)view.buf;
			char *result_buf = (char *)PyMem_Malloc(slicelength);

			if (result_buf == NULL)
				return PyErr_NoMemory();

			for (cur = start, i = 0; i < slicelength;
			     cur += step, i++) {
				result_buf[i] = source_buf[cur];
			}

			ob = PyBytes_FromStringAndSize(result_buf,
						       slicelength);
			PyMem_Free(result_buf);
			PyObject_ReleaseBuffer((PyObject *)self, &view);
			return ob;
		}
	}
	else {
		PyErr_SetString(PyExc_TypeError,
				"sequence index must be integer");
		return NULL;
	}
}

static int
buffer_ass_item(PyBufferObject *self, Py_ssize_t idx, PyObject *other)
{
	PyBufferProcs *pb;
        PyBuffer view, view2;

	if (!get_buf(self, &view, PyBUF_SIMPLE))
		return -1;
        
	if (self->b_readonly || view.readonly) {
		PyErr_SetString(PyExc_TypeError,
				"buffer is read-only");
                PyObject_ReleaseBuffer((PyObject *)self, &view);
		return -1;
	}

	if (idx < 0 || idx >= view.len) {
                PyObject_ReleaseBuffer((PyObject *)self, &view);
		PyErr_SetString(PyExc_IndexError,
				"buffer assignment index out of range");
		return -1;
	}

	pb = other ? other->ob_type->tp_as_buffer : NULL;
	if (pb == NULL ||
            pb->bf_getbuffer == NULL) {
		PyErr_BadArgument();
                PyObject_ReleaseBuffer((PyObject *)self, &view);
		return -1;
	}
        
        if (PyObject_GetBuffer(other, &view2, PyBUF_SIMPLE) < 0) {
                PyObject_ReleaseBuffer((PyObject *)self, &view);
                return -1;
        }
	if (view.len != 1) {
                PyObject_ReleaseBuffer((PyObject *)self, &view);
                PyObject_ReleaseBuffer(other, &view2);
		PyErr_SetString(PyExc_TypeError,
				"right operand must be a single byte");
		return -1;
	}

	((char *)(view.buf))[idx] = *((char *)(view2.buf));
        PyObject_ReleaseBuffer((PyObject *)self, &view);
        PyObject_ReleaseBuffer(other, &view2);
	return 0;
}

static int
buffer_ass_slice(PyBufferObject *self, Py_ssize_t left, Py_ssize_t right,
                 PyObject *other)
{
	PyBufferProcs *pb;
        PyBuffer v1, v2;
	Py_ssize_t slice_len;

	pb = other ? other->ob_type->tp_as_buffer : NULL;
	if (pb == NULL ||
            pb->bf_getbuffer == NULL) {
		PyErr_BadArgument();
		return -1;
	}
	if (!get_buf(self, &v1, PyBUF_SIMPLE))
                return -1;

	if (self->b_readonly || v1.readonly) {
		PyErr_SetString(PyExc_TypeError,
				"buffer is read-only");
                PyObject_ReleaseBuffer((PyObject *)self, &v1);
		return -1;
	}

        if ((*pb->bf_getbuffer)(other, &v2, PyBUF_SIMPLE) < 0) {
                PyObject_ReleaseBuffer((PyObject *)self, &v1);
                return -1;
        }

	if (left < 0)
		left = 0;
	else if (left > v1.len)
		left = v1.len;
	if (right < left)
		right = left;
	else if (right > v1.len)
		right = v1.len;
	slice_len = right - left;

	if (v2.len != slice_len) {
		PyErr_SetString(
			PyExc_TypeError,
			"right operand length must match slice length");
                PyObject_ReleaseBuffer((PyObject *)self, &v1);
                PyObject_ReleaseBuffer(other, &v2);
		return -1;
	}

	if (slice_len)
	    memcpy((char *)v1.buf + left, v2.buf, slice_len);

        PyObject_ReleaseBuffer((PyObject *)self, &v1);
        PyObject_ReleaseBuffer(other, &v2);        
	return 0;
}

static int
buffer_ass_subscript(PyBufferObject *self, PyObject *item, PyObject *value)
{
	PyBuffer v1;

	if (!get_buf(self, &v1, PyBUF_SIMPLE))
		return -1;
	if (self->b_readonly || v1.readonly) {
		PyErr_SetString(PyExc_TypeError,
				"buffer is read-only");
		PyObject_ReleaseBuffer((PyObject *)self, &v1);
		return -1;
	}
	if (PyIndex_Check(item)) {
		Py_ssize_t idx = PyNumber_AsSsize_t(item, PyExc_IndexError);
		if (idx == -1 && PyErr_Occurred())
			return -1;
		if (idx < 0)
			idx += v1.len;
		PyObject_ReleaseBuffer((PyObject *)self, &v1);
		return buffer_ass_item(self, idx, value);
	}
	else if (PySlice_Check(item)) {
		Py_ssize_t start, stop, step, slicelength;
		PyBuffer v2;
		PyBufferProcs *pb;
		
		if (PySlice_GetIndicesEx((PySliceObject *)item, v1.len,
				&start, &stop, &step, &slicelength) < 0) {
			PyObject_ReleaseBuffer((PyObject *)self, &v1);
			return -1;
		}

		pb = value ? value->ob_type->tp_as_buffer : NULL;
		if (pb == NULL ||
		    pb->bf_getbuffer == NULL) {
		    	PyObject_ReleaseBuffer((PyObject *)self, &v1);
			PyErr_BadArgument();
			return -1;
		}
		if ((*pb->bf_getbuffer)(value, &v2, PyBUF_SIMPLE) < 0) {
			PyObject_ReleaseBuffer((PyObject *)self, &v1);
			return -1;
		}

		if (v2.len != slicelength) {
			PyObject_ReleaseBuffer((PyObject *)self, &v1);
			PyObject_ReleaseBuffer(value, &v2);
			PyErr_SetString(PyExc_TypeError, "right operand"
					" length must match slice length");
			return -1;
		}

		if (slicelength == 0)
			/* nothing to do */;
		else if (step == 1)
			memcpy((char *)v1.buf + start, v2.buf, slicelength);
		else {
			Py_ssize_t cur, i;
			
			for (cur = start, i = 0; i < slicelength;
			     cur += step, i++) {
				((char *)v1.buf)[cur] = ((char *)v2.buf)[i];
			}
		}
		PyObject_ReleaseBuffer((PyObject *)self, &v1);
		PyObject_ReleaseBuffer(value, &v2);
		return 0;
	} else {
		PyErr_SetString(PyExc_TypeError,
				"buffer indices must be integers");
		PyObject_ReleaseBuffer((PyObject *)self, &v1);
		return -1;
	}
}

/* Buffer methods */

static PySequenceMethods buffer_as_sequence = {
	(lenfunc)buffer_length, /*sq_length*/
	(binaryfunc)buffer_concat, /*sq_concat*/
	(ssizeargfunc)buffer_repeat, /*sq_repeat*/
	(ssizeargfunc)buffer_item, /*sq_item*/
	(ssizessizeargfunc)buffer_slice, /*sq_slice*/
	(ssizeobjargproc)buffer_ass_item, /*sq_ass_item*/
	(ssizessizeobjargproc)buffer_ass_slice, /*sq_ass_slice*/
};

static PyMappingMethods buffer_as_mapping = {
	(lenfunc)buffer_length,
	(binaryfunc)buffer_subscript,
	(objobjargproc)buffer_ass_subscript,
};

static PyBufferProcs buffer_as_buffer = {
	(getbufferproc)buffer_getbuf,
        (releasebufferproc)buffer_releasebuf,
};

PyTypeObject PyBuffer_Type = {
	PyVarObject_HEAD_INIT(&PyType_Type, 0)
	"buffer",
	sizeof(PyBufferObject),
	0,
	(destructor)buffer_dealloc, 		/* tp_dealloc */
	0,					/* tp_print */
	0,					/* tp_getattr */
	0,					/* tp_setattr */
	0,					/* tp_compare */
	(reprfunc)buffer_repr,			/* tp_repr */
	0,					/* tp_as_number */
	&buffer_as_sequence,			/* tp_as_sequence */
	&buffer_as_mapping,			/* tp_as_mapping */
	(hashfunc)buffer_hash,			/* tp_hash */
	0,					/* tp_call */
	(reprfunc)buffer_str,			/* tp_str */
	PyObject_GenericGetAttr,		/* tp_getattro */
	0,					/* tp_setattro */
	&buffer_as_buffer,			/* tp_as_buffer */
	Py_TPFLAGS_DEFAULT,			/* tp_flags */
	buffer_doc,				/* tp_doc */
	0,					/* tp_traverse */
	0,					/* tp_clear */
	buffer_richcompare,			/* tp_richcompare */
	0,					/* tp_weaklistoffset */
	0,					/* tp_iter */
	0,					/* tp_iternext */
	0,					/* tp_methods */	
	0,					/* tp_members */
	0,					/* tp_getset */
	0,					/* tp_base */
	0,					/* tp_dict */
	0,					/* tp_descr_get */
	0,					/* tp_descr_set */
	0,					/* tp_dictoffset */
	0,					/* tp_init */
	0,					/* tp_alloc */
	buffer_new,				/* tp_new */
};