static PyObject * mmap_write_method(mmap_object *self, PyObject *args) { Py_buffer data; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "y*:write", &data)) return(NULL); if (!is_writable(self)) { PyBuffer_Release(&data); return NULL; } if (self->pos > self->size || self->size - self->pos < data.len) { PyBuffer_Release(&data); PyErr_SetString(PyExc_ValueError, "data out of range"); return NULL; } memcpy(&self->data[self->pos], data.buf, data.len); self->pos += data.len; PyBuffer_Release(&data); return PyLong_FromSsize_t(data.len); }
static PyObject * mmap_write_method(mmap_object *self, PyObject *args) { Py_buffer data; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, "y*:write", &data)) return(NULL); if (!is_writable(self)) { PyBuffer_Release(&data); return NULL; } if ((self->pos + data.len) > self->size) { PyErr_SetString(PyExc_ValueError, "data out of range"); PyBuffer_Release(&data); return NULL; } memcpy(self->data + self->pos, data.buf, data.len); self->pos = self->pos + data.len; PyBuffer_Release(&data); Py_INCREF(Py_None); return Py_None; }
NUITKA_MAY_BE_UNUSED static bool BYTES_ADD_INCREMENTAL(PyObject **operand1, PyObject *operand2) { assert(PyBytes_CheckExact(*operand1)); assert(PyBytes_CheckExact(operand2)); // Buffer Py_buffer wb; wb.len = -1; if (PyObject_GetBuffer(operand2, &wb, PyBUF_SIMPLE) != 0) { PyErr_Format(PyExc_TypeError, "can't concat %s to %s", Py_TYPE(operand2)->tp_name, Py_TYPE(*operand1)->tp_name); return false; } Py_ssize_t oldsize = PyBytes_GET_SIZE(*operand1); if (oldsize > PY_SSIZE_T_MAX - wb.len) { PyErr_NoMemory(); PyBuffer_Release(&wb); return false; } if (_PyBytes_Resize(operand1, oldsize + wb.len) < 0) { PyBuffer_Release(&wb); return false; } memcpy(PyBytes_AS_STRING(*operand1) + oldsize, wb.buf, wb.len); PyBuffer_Release(&wb); return true; }
static IDProperty *idp_from_PySequence(const char *name, PyObject *ob) { Py_buffer buffer; bool use_buffer = false; if (PyObject_CheckBuffer(ob)) { PyObject_GetBuffer(ob, &buffer, PyBUF_SIMPLE | PyBUF_FORMAT); char format = *buffer.format; if (ELEM(format, 'i', 'f', 'd')) { use_buffer = true; } else { PyBuffer_Release(&buffer); } } if (use_buffer) { IDProperty *prop = idp_from_PySequence_Buffer(name, &buffer); PyBuffer_Release(&buffer); return prop; } else { PyObject *ob_seq_fast = PySequence_Fast(ob, "py -> idprop"); if (ob_seq_fast != NULL) { IDProperty *prop = idp_from_PySequence_Fast(name, ob_seq_fast); Py_DECREF(ob_seq_fast); return prop; } else { return NULL; } } }
static PyObject * Stream_func_try_write(Stream *self, PyObject *args) { int err; uv_buf_t buf; Py_buffer view; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, PYUV_BYTES"*:try_write", &view)) { return NULL; } buf = uv_buf_init(view.buf, view.len); err = uv_try_write((uv_stream_t *)UV_HANDLE(self), &buf, 1); if (err < 0) { RAISE_STREAM_EXCEPTION(err, UV_HANDLE(self)); PyBuffer_Release(&view); return NULL; } PyBuffer_Release(&view); return PyInt_FromLong((long)err); }
static PyObject *Sponge_decrypt(PyObject *obj, PyObject *args) { SpongeObject *self = (SpongeObject *)obj; PyObject *res; PyObject *dataobj; void *resdata; Py_buffer buf; if (!PyArg_ParseTuple(args, "O", &dataobj)) return NULL; if (!get_buffer(dataobj, &buf)) return NULL; /* allocate result object */ res = PyBytes_FromStringAndSize(NULL, buf.len); if (!res) { PyBuffer_Release(&buf); return NULL; } /* get internal buffer */ resdata = PyBytes_AsString(res); if (!resdata) { PyBuffer_Release(&buf); Py_CLEAR(res); return NULL; } keccak_decrypt(&self->md, resdata, buf.buf, buf.len); PyBuffer_Release(&buf); return res; }
/* double avg(double*, int) */ static PyObject* py_avg(PyObject* self, PyObject* args) { PyObject* bufobj; Py_buffer view; double result; if (!PyArg_ParseTuple(args, "O", &bufobj)) { return NULL; } if (PyObject_GetBuffer(bufobj, &view, PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) == -1) { return NULL; } if (view.ndim != 1) { PyErr_SetString(PyExc_TypeError, "Expected a 1-dimensional array"); PyBuffer_Release(&view); return NULL; } if (strcmp(view.format, "d") != 0) { PyErr_SetString(PyExc_TypeError, "Expected an array of doubles"); PyBuffer_Release(&view); return NULL; } result = avg(view.buf, view.shape[0]); PyBuffer_Release(&view); return Py_BuildValue("d", result); }
/* int primes_c(int, int *) */ static PyObject *py_primes_c(PyObject *self, PyObject *args) { int howmany; PyObject *bufobj; Py_buffer view; double result; /* Get the howmany param and the passed Python object (int and Object) */ if (!PyArg_ParseTuple(args, "iO", &howmany, &bufobj)) { return NULL; } /* Attempt to extract buffer information from it */ if (PyObject_GetBuffer(bufobj, &view, PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) == -1) { return NULL; } if (view.ndim != 1) { PyErr_SetString(PyExc_TypeError, "Expected a 1-dimensional array"); PyBuffer_Release(&view); return NULL; } /* Check the type of items in the array */ if (strcmp(view.format, "i") != 0) { PyErr_SetString(PyExc_TypeError, "Expected an array of int"); PyBuffer_Release(&view); return NULL; } /* Pass the raw buffer to the C function */ result = primes_c(howmany, view.buf); /* Indicate we're done working with the buffer */ PyBuffer_Release(&view); return Py_BuildValue("i", result); }
static PyObject *verify(RSAObject *self, PyObject *args) { Py_buffer digest, signature; int result = 0; PyObject *result_obj = NULL; #if PY_MAJOR_VERSION >= 3 if (!PyArg_ParseTuple(args, "y*y*:verify", &digest, &signature)) return NULL; #else if (!PyArg_ParseTuple(args, "s*s*:verify", &digest, &signature)) return NULL; #endif if (digest.len != SHA_DIGEST_LENGTH) { PyErr_Format(PyExc_ValueError, "digest should be %i bytes", SHA_DIGEST_LENGTH); goto cleanup; } result = RSA_verify(NID_sha1, digest.buf, digest.len, signature.buf, signature.len, self->rsa); result_obj = PyBool_FromLong(result); cleanup: PyBuffer_Release(&digest); PyBuffer_Release(&signature); return result_obj; }
static PyObject *convert(PyObject *self, PyObject *args) { Py_buffer inBuf, outBuf; short row, col, r, g, b, w, h, rd, gd, bd; unsigned char *rgbPtr, *yPtr, y; signed char *uPtr, *vPtr, u, v; if(!PyArg_ParseTuple(args, "s*s*hh", &inBuf, &outBuf, &w, &h)) return NULL; if(w & 31) w += 32 - (w & 31); // Round up width to multiple of 32 if(h & 15) h += 16 - (h & 15); // Round up height to multiple of 16 rgbPtr = outBuf.buf; yPtr = inBuf.buf; uPtr = (signed char *)&yPtr[w * h]; vPtr = &uPtr[(w * h) >> 2]; w >>= 1; // 2 columns processed per iteration for(row=0; row<h; row++) { for(col=0; col<w; col++) { // U, V (and RGB deltas) updated on even columns u = uPtr[col] - 128; v = vPtr[col] - 128; rd = (359 * v) >> 8; gd = ((183 * v) + (88 * u)) >> 8; bd = (454 * u) >> 8; // Even column y = *yPtr++; r = y + rd; g = y - gd; b = y + bd; *rgbPtr++ = (r > 255) ? 255 : (r < 0) ? 0 : r; *rgbPtr++ = (g > 255) ? 255 : (g < 0) ? 0 : g; *rgbPtr++ = (b > 255) ? 255 : (b < 0) ? 0 : b; // Odd column y = *yPtr++; r = y + rd; g = y - gd; b = y + bd; *rgbPtr++ = (r > 255) ? 255 : (r < 0) ? 0 : r; *rgbPtr++ = (g > 255) ? 255 : (g < 0) ? 0 : g; *rgbPtr++ = (b > 255) ? 255 : (b < 0) ? 0 : b; } if(row & 1) { uPtr += w; vPtr += w; } } PyBuffer_Release(&inBuf); PyBuffer_Release(&outBuf); Py_INCREF(Py_None); return Py_None; }
static PyObject * Billiard_read(PyObject *self, PyObject *args) { int fd; Py_buffer view; Py_ssize_t buflen, recvlen = 0; char *buf = NULL; Py_ssize_t n = 0; if (!PyArg_ParseTuple(args, "iw*|n", &fd, &view, &recvlen)) return NULL; buflen = view.len; buf = view.buf; if (recvlen < 0) { PyBuffer_Release(&view); PyErr_SetString(PyExc_ValueError, "negative len for read"); return NULL; } if (recvlen == 0) { recvlen = buflen; } if (buflen < recvlen) { PyBuffer_Release(&view); PyErr_SetString(PyExc_ValueError, "Buffer too small for requested bytes"); return NULL; } if (buflen < 0 || buflen == 0) { errno = EINVAL; goto bail; } // Requires Python 2.7 //if (!_PyVerify_fd(fd)) goto bail; Py_BEGIN_ALLOW_THREADS n = read(fd, buf, recvlen); Py_END_ALLOW_THREADS if (n < 0) goto bail; PyBuffer_Release(&view); return PyInt_FromSsize_t(n); bail: PyBuffer_Release(&view); return PyErr_SetFromErrno(PyExc_OSError); }
/* * TODO: note the definition of the py_calc_z_ser() function. * (no code change required) */ static PyObject *py_calc_z_ser(PyObject *self, PyObject *args) { PyObject *q, *output; int len_q, maxiter, result = 0; Py_buffer q_buffer, output_buffer; /* Get the arguments: two arrays (two Objects) and two int */ if (!PyArg_ParseTuple(args, "OOii", &q, &output, &len_q, &maxiter)) { return NULL; } /* Attempt to extract buffer information from q */ if (PyObject_GetBuffer(q, &q_buffer, PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) == -1) { return NULL; } if (q_buffer.ndim != 1) { PyErr_SetString(PyExc_TypeError, "First arg must be a 1-dimensional array of complex"); PyBuffer_Release(&q_buffer); return NULL; } /* Attempt to extract buffer information from output_buffer */ if (PyObject_GetBuffer(output, &output_buffer, PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) == -1) { return NULL; } if (output_buffer.ndim != 1) { PyErr_SetString(PyExc_TypeError, "Second arg must be a 1-dimensional array of int"); PyBuffer_Release(&output_buffer); return NULL; } /* Check the type of items in the array */ if (strcmp(output_buffer.format, "i") != 0) { PyErr_SetString(PyExc_TypeError, "Second arg must be an array of int"); PyBuffer_Release(&output_buffer); return NULL; } /* Pass the raw buffers to the C function */ result = calc_z_ser(q_buffer.buf, output_buffer.buf, len_q, maxiter); /* Indicate we're done working with the buffers */ PyBuffer_Release(&q_buffer); PyBuffer_Release(&output_buffer); return Py_BuildValue("i", result); }
static PyObject * mmap_gfind(mmap_object *self, PyObject *args, int reverse) { Py_ssize_t start = self->pos; Py_ssize_t end = self->size; Py_buffer view; CHECK_VALID(NULL); if (!PyArg_ParseTuple(args, reverse ? "y*|nn:rfind" : "y*|nn:find", &view, &start, &end)) { return NULL; } else { const char *p, *start_p, *end_p; int sign = reverse ? -1 : 1; const char *needle = view.buf; Py_ssize_t len = view.len; if (start < 0) start += self->size; if (start < 0) start = 0; else if (start > self->size) start = self->size; if (end < 0) end += self->size; if (end < 0) end = 0; else if (end > self->size) end = self->size; start_p = self->data + start; end_p = self->data + end; for (p = (reverse ? end_p - len : start_p); (p >= start_p) && (p + len <= end_p); p += sign) { Py_ssize_t i; for (i = 0; i < len && needle[i] == p[i]; ++i) /* nothing */; if (i == len) { PyBuffer_Release(&view); return PyLong_FromSsize_t(p - self->data); } } PyBuffer_Release(&view); return PyLong_FromLong(-1); } }
static int DCStaticTriangleMeshShapeInit(DCStaticTriangleMeshShape *self, PyObject *args, PyObject *kwds) { DKObject<DKStaticTriangleMeshShape> shape = NULL; if (self->shape == NULL) { Py_buffer vertexBuffer, indexBuffer; int use16bit = 0; int rebuildIndex = 1; float welding = 0.0f; char* kwlist[] = { "vertexBuffer", "indexBuffer", "use16bitIndex", "rebuildIndex", "weldingThreshold", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwds, "y*y*|ppf", kwlist, &vertexBuffer, &indexBuffer, &use16bit, &rebuildIndex, &welding)) return -1; DKVector3* vertices = reinterpret_cast<DKVector3*>(vertexBuffer.buf); size_t numVerts = vertexBuffer.len / sizeof(DKVector3); if (use16bit) { unsigned int* indices = reinterpret_cast<unsigned int*>(indexBuffer.buf); size_t numIndices = indexBuffer.len / sizeof(unsigned int); if (numVerts > 0 && numIndices > 0) { shape = DKOBJECT_NEW DKStaticTriangleMeshShape(vertices, numVerts, indices, numIndices, DKAABox(), rebuildIndex != 0, welding); } } else { unsigned int* indices = reinterpret_cast<unsigned int*>(indexBuffer.buf); size_t numIndices = indexBuffer.len / sizeof(unsigned int); if (numVerts > 0 && numIndices > 0) { shape = DKOBJECT_NEW DKStaticTriangleMeshShape(vertices, numVerts, indices, numIndices, DKAABox(), rebuildIndex != 0, welding); } } PyBuffer_Release(&vertexBuffer); PyBuffer_Release(&indexBuffer); if (shape == NULL) { PyErr_SetString(PyExc_ValueError, "invalid argument."); return -1; } self->shape = shape; } self->base.shape = self->shape; return DCConcaveShapeTypeObject()->tp_init((PyObject*)self, args, kwds); }
static PyObject * PyBlosc_decompress(PyObject *self, PyObject *args) { Py_buffer view; PyObject *result_str; void *input, *output; size_t nbytes, cbytes; char *format; /* Accept some kind of input */ #if PY_MAJOR_VERSION <= 2 /* s* : bytes like object including unicode and anything that supports * the buffer interface */ format = "s*:decompress"; #elif PY_MAJOR_VERSION >= 3 /* y* :bytes like object EXCLUDING unicode and anything that supports * the buffer interface. This is the recommended way to accept binary * data in Python 3. */ format = "y*:decompress"; #endif if (!PyArg_ParseTuple(args, format, &view)) return NULL; cbytes = view.len; input = view.buf; /* fetch the uncompressed size into nbytes */ if (!get_nbytes(input, cbytes, &nbytes)){ PyBuffer_Release(&view); return NULL; } /* Book memory for the result */ if (!(result_str = PyBytes_FromStringAndSize(NULL, (Py_ssize_t)nbytes))){ PyBuffer_Release(&view); return NULL; } output = PyBytes_AS_STRING(result_str); /* do decompression */ if (!decompress_helper(input, nbytes, output)){ Py_XDECREF(result_str); PyBuffer_Release(&view); return NULL; } PyBuffer_Release(&view); return result_str; }
static void DataTransferRequest_dealloc(DataTransferRequest *self) { if (self->dtd) { if (self->ttype & SRC_ISMEM) PyBuffer_Release(&self->src.mem); if (self->ttype & DST_ISMEM) PyBuffer_Release(&self->dst.mem); Py_DECREF(self->py_src); Py_DECREF(self->py_dst); Py_DECREF(self->opaque); Py_DECREF(self->dtd); } free(self->tmpbuf); Py_TYPE(self)->tp_free((PyObject*)self); }
static PyObject * PyBlosc_compress(PyObject *self, PyObject *args) { Py_buffer view; PyObject *output; void *input; size_t nbytes, typesize; int clevel, shuffle; char *cname; const char *format; /* Accept some kind of input followed by * typesize, clevel, shuffle and cname */ #if PY_MAJOR_VERSION <= 2 /* s* : bytes like object including unicode and anything that supports * the buffer interface */ format = "s*niis:compress"; #elif PY_MAJOR_VERSION >= 3 /* y* :bytes like object EXCLUDING unicode and anything that supports * the buffer interface. This is the recommended way to accept binary * data in Python 3. */ format = "y*niis:compress"; #endif if (!PyArg_ParseTuple(args, format , &view, &typesize, &clevel, &shuffle, &cname)) return NULL; nbytes = view.len; input = view.buf; output = compress_helper(input, nbytes, typesize, clevel, shuffle, cname); PyBuffer_Release(&view); return output; }
// Takes one argument: a contiguous buffer object. Modifies it in place. static PyObject * _convert_argb2rgba(PyObject *self, PyObject *args) { PyObject *ret = NULL; Py_buffer view; if (!PyArg_ParseTuple(args, "s*", &view)) return NULL; if (!PyBuffer_IsContiguous(&view, 'A')) { PyErr_SetString(PyExc_ValueError, "Argument is not contiguous"); goto DONE; } if (view.readonly) { PyErr_SetString(PyExc_ValueError, "Argument is not writable"); goto DONE; } if (view.len % 4) { PyErr_SetString(PyExc_ValueError, "Argument has invalid size"); goto DONE; } Py_BEGIN_ALLOW_THREADS argb2rgba(view.buf, view.len); Py_END_ALLOW_THREADS Py_INCREF(Py_None); ret = Py_None; DONE: PyBuffer_Release(&view); return ret; }
static PyObject * memory_bio_write(PySSLMemoryBIO *self, PyObject *args) { PyObject *Pret = NULL; Py_buffer buf; int nbytes; buf.buf = NULL; if (!PyArg_ParseTuple(args, BUF_FMT ":write", &buf)) RETURN_ERROR(NULL); if (buf.len > INT_MAX) RETURN_ERROR("string longer than %d bytes", INT_MAX); if (self->eof_written) RETURN_ERROR("cannot write() after write_eof()"); nbytes = BIO_write(self->bio, buf.buf, buf.len); if (nbytes < 0) RETURN_ERROR("BIO_write() failed"); Pret = PyLong_FromLong(nbytes); error: if (buf.buf != NULL) PyBuffer_Release(&buf); return Pret; }
/* * Factory */ static PyObject * PyMemorySimpleView_FromObject(PyObject *base) { PyMemorySimpleViewObject *mview = NULL; Py_buffer view; if (Py_TYPE(base)->tp_as_buffer == NULL || Py_TYPE(base)->tp_as_buffer->bf_getbuffer == NULL) { PyErr_SetString(PyExc_TypeError, "cannot make memory view because object does " "not have the buffer interface"); return NULL; } memset(&view, 0, sizeof(Py_buffer)); if (PyObject_GetBuffer(base, &view, PyBUF_FULL_RO) < 0) return NULL; mview = (PyMemorySimpleViewObject *) PyObject_GC_New(PyMemorySimpleViewObject, &PyMemorySimpleView_Type); if (mview == NULL) { PyBuffer_Release(&view); return NULL; } memcpy(&mview->view, &view, sizeof(Py_buffer)); mview->base = base; Py_INCREF(base); PyObject_GC_Track(mview); return (PyObject *)mview; }
static PyObject * Stream_func_write(Stream *self, PyObject *args) { uv_buf_t buf; stream_write_ctx *ctx; Py_buffer *view; PyObject *callback = Py_None; RAISE_IF_HANDLE_NOT_INITIALIZED(self, NULL); RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); ctx = PyMem_Malloc(sizeof *ctx); if (!ctx) { PyErr_NoMemory(); return NULL; } view = &ctx->view[0]; if (!PyArg_ParseTuple(args, PYUV_BYTES"*|O:write", view, &callback)) { PyMem_Free(ctx); return NULL; } if (callback != Py_None && !PyCallable_Check(callback)) { PyBuffer_Release(view); PyMem_Free(ctx); PyErr_SetString(PyExc_TypeError, "a callable or None is required"); return NULL; } buf = uv_buf_init(view->buf, view->len); return pyuv_stream_write(self, ctx, view, &buf, 1, callback, NULL); }
static PyObject * buffer_release_buffer(BufferObject *self) { int flags = self->flags; Py_buffer *view_p = self->view_p; if ((flags & BUFOBJ_FILLED) && (flags & BUFOBJ_MUTABLE)) { self->flags = BUFOBJ_FILLED; /* Guard against reentrant calls */ PyBuffer_Release(view_p); self->flags = BUFOBJ_MUTABLE; if (flags & BUFOBJ_MEMFREE) { self->view_p = 0; PyMem_Free(view_p); } else { view_p->obj = 0; view_p->buf = 0; view_p->len = 0; view_p->itemsize = 0; view_p->readonly = 1; view_p->format = 0; view_p->ndim = 0; view_p->shape = 0; view_p->strides = 0; view_p->suboffsets = 0; view_p->internal = 0; } } Py_RETURN_NONE; }
static PyObject * Pipe_func_write2(Pipe *self, PyObject *args) { Py_buffer pbuf; PyObject *callback, *send_handle; callback = Py_None; RAISE_IF_HANDLE_CLOSED(self, PyExc_HandleClosedError, NULL); if (!PyArg_ParseTuple(args, "s*O|O:write2", &pbuf, &send_handle, &callback)) { return NULL; } if (!PyObject_TypeCheck(send_handle, &TCPType) && !PyObject_TypeCheck(send_handle, &PipeType)) { PyErr_SetString(PyExc_TypeError, "Only TCP and Pipe objects are supported for write2"); return NULL; } if (callback != Py_None && !PyCallable_Check(callback)) { PyBuffer_Release(&pbuf); PyErr_SetString(PyExc_TypeError, "a callable or None is required"); return NULL; } return pyuv_stream_write((Stream *)self, pbuf, callback, send_handle); }
/*NUMPY_API * Get buffer chunk from object * * this function takes a Python object which exposes the (single-segment) * buffer interface and returns a pointer to the data segment * * You should increment the reference count by one of buf->base * if you will hang on to a reference * * You only get a borrowed reference to the object. Do not free the * memory... */ NPY_NO_EXPORT int PyArray_BufferConverter(PyObject *obj, PyArray_Chunk *buf) { #if defined(NPY_PY3K) Py_buffer view; #else Py_ssize_t buflen; #endif buf->ptr = NULL; buf->flags = NPY_ARRAY_BEHAVED; buf->base = NULL; if (obj == Py_None) { return NPY_SUCCEED; } #if defined(NPY_PY3K) if (PyObject_GetBuffer(obj, &view, PyBUF_ANY_CONTIGUOUS|PyBUF_WRITABLE) != 0) { PyErr_Clear(); buf->flags &= ~NPY_ARRAY_WRITEABLE; if (PyObject_GetBuffer(obj, &view, PyBUF_ANY_CONTIGUOUS) != 0) { return NPY_FAIL; } } buf->ptr = view.buf; buf->len = (npy_intp) view.len; /* * XXX: PyObject_AsWriteBuffer does also this, but it is unsafe, as there is * no strict guarantee that the buffer sticks around after being released. */ PyBuffer_Release(&view); /* Point to the base of the buffer object if present */ if (PyMemoryView_Check(obj)) { buf->base = PyMemoryView_GET_BASE(obj); } #else if (PyObject_AsWriteBuffer(obj, &(buf->ptr), &buflen) < 0) { PyErr_Clear(); buf->flags &= ~NPY_ARRAY_WRITEABLE; if (PyObject_AsReadBuffer(obj, (const void **)&(buf->ptr), &buflen) < 0) { return NPY_FAIL; } } buf->len = (npy_intp) buflen; /* Point to the base of the buffer object if present */ if (PyBuffer_Check(obj)) { buf->base = ((PyArray_Chunk *)obj)->base; } #endif if (buf->base == NULL) { buf->base = obj; } return NPY_SUCCEED; }
static void mapping_destroy_buffer(Imaging im) { ImagingBufferInstance* buffer = (ImagingBufferInstance*) im; PyBuffer_Release(&buffer->view); Py_XDECREF(buffer->target); }
static int memorysimpleview_clear(PyMemorySimpleViewObject *self) { Py_CLEAR(self->base); PyBuffer_Release(&self->view); self->view.obj = NULL; return 0; }
static void cleanup_buffer(PyObject *self) { Py_buffer *ptr = (Py_buffer *)PyCapsule_GetPointer(self, GETARGS_CAPSULE_NAME_CLEANUP_BUFFER); if (ptr) { PyBuffer_Release(ptr); } }
static INLINE int pyseq2uvbuf(PyObject *seq, Py_buffer **rviews, uv_buf_t **rbufs, int *rbuf_count) { int i, j, buf_count; uv_buf_t *uv_bufs = NULL; Py_buffer *views = NULL; PyObject *data_fast = NULL; i = 0; *rviews = NULL; *rbufs = NULL; *rbuf_count = 0; if ((data_fast = PySequence_Fast(seq, "argument 1 must be an iterable")) == NULL) { goto error; } buf_count = PySequence_Fast_GET_SIZE(data_fast); if (buf_count > INT_MAX) { PyErr_SetString(PyExc_ValueError, "argument 1 is too long"); goto error; } if (buf_count == 0) { PyErr_SetString(PyExc_ValueError, "argument 1 is empty"); goto error; } uv_bufs = PyMem_Malloc(sizeof *uv_bufs * buf_count); views = PyMem_Malloc(sizeof *views * buf_count); if (!uv_bufs || !views) { PyErr_NoMemory(); goto error; } for (i = 0; i < buf_count; i++) { if (!PyArg_Parse(PySequence_Fast_GET_ITEM(data_fast, i), PYUV_BYTES"*;argument 1 must be an iterable of buffer-compatible objects", &views[i])) { goto error; } uv_bufs[i].base = views[i].buf; uv_bufs[i].len = views[i].len; } *rviews = views; *rbufs = uv_bufs; *rbuf_count = buf_count; Py_XDECREF(data_fast); return 0; error: for (j = 0; j < i; j++) { PyBuffer_Release(&views[j]); } PyMem_Free(views); PyMem_Free(uv_bufs); Py_XDECREF(data_fast); return -1; }
NPY_NO_EXPORT npy_bool _IsWriteable(PyArrayObject *ap) { PyObject *base=PyArray_BASE(ap); #if defined(NPY_PY3K) Py_buffer view; #else void *dummy; Py_ssize_t n; #endif /* If we own our own data, then no-problem */ if ((base == NULL) || (PyArray_FLAGS(ap) & NPY_ARRAY_OWNDATA)) { return NPY_TRUE; } /* * Get to the final base object * If it is a writeable array, then return TRUE * If we can find an array object * or a writeable buffer object as the final base object * or a string object (for pickling support memory savings). * - this last could be removed if a proper pickleable * buffer was added to Python. * * MW: I think it would better to disallow switching from READONLY * to WRITEABLE like this... */ while(PyArray_Check(base)) { if (PyArray_CHKFLAGS((PyArrayObject *)base, NPY_ARRAY_OWNDATA)) { return (npy_bool) (PyArray_ISWRITEABLE((PyArrayObject *)base)); } base = PyArray_BASE((PyArrayObject *)base); } /* * here so pickle support works seamlessly * and unpickled array can be set and reset writeable * -- could be abused -- */ if (PyString_Check(base)) { return NPY_TRUE; } #if defined(NPY_PY3K) if (PyObject_GetBuffer(base, &view, PyBUF_WRITABLE|PyBUF_SIMPLE) < 0) { PyErr_Clear(); return NPY_FALSE; } PyBuffer_Release(&view); #else if (PyObject_AsWriteBuffer(base, &dummy, &n) < 0) { PyErr_Clear(); return NPY_FALSE; } #endif return NPY_TRUE; }
static PyObject * I_close(Iobject *self, PyObject *unused) { PyBuffer_Release(&self->pbuf); self->buf = NULL; self->pos = self->string_size = 0; Py_INCREF(Py_None); return Py_None; }