/Objects/bytearrayobject.c
http://unladen-swallow.googlecode.com/ · C · 3401 lines · 2820 code · 418 blank · 163 comment · 726 complexity · 2faea443ce28295f6ab8b550d9026b22 MD5 · raw file
Large files are truncated click here to view the full file
- /* PyBytes (bytearray) implementation */
- #define PY_SSIZE_T_CLEAN
- #include "Python.h"
- #include "structmember.h"
- #include "bytes_methods.h"
- static PyByteArrayObject *nullbytes = NULL;
- void
- PyByteArray_Fini(void)
- {
- Py_CLEAR(nullbytes);
- }
- int
- PyByteArray_Init(void)
- {
- nullbytes = PyObject_New(PyByteArrayObject, &PyByteArray_Type);
- if (nullbytes == NULL)
- return 0;
- nullbytes->ob_bytes = NULL;
- Py_SIZE(nullbytes) = nullbytes->ob_alloc = 0;
- nullbytes->ob_exports = 0;
- return 1;
- }
- /* end nullbytes support */
- /* Helpers */
- static int
- _getbytevalue(PyObject* arg, int *value)
- {
- long face_value;
- if (PyBytes_CheckExact(arg)) {
- if (Py_SIZE(arg) != 1) {
- PyErr_SetString(PyExc_ValueError, "string must be of size 1");
- return 0;
- }
- *value = Py_CHARMASK(((PyBytesObject*)arg)->ob_sval[0]);
- return 1;
- }
- else if (PyInt_Check(arg) || PyLong_Check(arg)) {
- face_value = PyLong_AsLong(arg);
- }
- else {
- PyObject *index = PyNumber_Index(arg);
- if (index == NULL) {
- PyErr_Format(PyExc_TypeError,
- "an integer or string of size 1 is required");
- return 0;
- }
- face_value = PyLong_AsLong(index);
- Py_DECREF(index);
- }
- if (face_value < 0 || face_value >= 256) {
- /* this includes the OverflowError in case the long is too large */
- PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
- return 0;
- }
- *value = face_value;
- return 1;
- }
- static Py_ssize_t
- bytes_buffer_getreadbuf(PyByteArrayObject *self, Py_ssize_t index, const void **ptr)
- {
- if ( index != 0 ) {
- PyErr_SetString(PyExc_SystemError,
- "accessing non-existent bytes segment");
- return -1;
- }
- *ptr = (void *)self->ob_bytes;
- return Py_SIZE(self);
- }
- static Py_ssize_t
- bytes_buffer_getwritebuf(PyByteArrayObject *self, Py_ssize_t index, const void **ptr)
- {
- if ( index != 0 ) {
- PyErr_SetString(PyExc_SystemError,
- "accessing non-existent bytes segment");
- return -1;
- }
- *ptr = (void *)self->ob_bytes;
- return Py_SIZE(self);
- }
- static Py_ssize_t
- bytes_buffer_getsegcount(PyByteArrayObject *self, Py_ssize_t *lenp)
- {
- if ( lenp )
- *lenp = Py_SIZE(self);
- return 1;
- }
- static Py_ssize_t
- bytes_buffer_getcharbuf(PyByteArrayObject *self, Py_ssize_t index, const char **ptr)
- {
- if ( index != 0 ) {
- PyErr_SetString(PyExc_SystemError,
- "accessing non-existent bytes segment");
- return -1;
- }
- *ptr = self->ob_bytes;
- return Py_SIZE(self);
- }
- static int
- bytes_getbuffer(PyByteArrayObject *obj, Py_buffer *view, int flags)
- {
- int ret;
- void *ptr;
- if (view == NULL) {
- obj->ob_exports++;
- return 0;
- }
- if (obj->ob_bytes == NULL)
- ptr = "";
- else
- ptr = obj->ob_bytes;
- ret = PyBuffer_FillInfo(view, (PyObject*)obj, ptr, Py_SIZE(obj), 0, flags);
- if (ret >= 0) {
- obj->ob_exports++;
- }
- return ret;
- }
- static void
- bytes_releasebuffer(PyByteArrayObject *obj, Py_buffer *view)
- {
- obj->ob_exports--;
- }
- static Py_ssize_t
- _getbuffer(PyObject *obj, Py_buffer *view)
- {
- PyBufferProcs *buffer = Py_TYPE(obj)->tp_as_buffer;
- if (buffer == NULL || buffer->bf_getbuffer == NULL)
- {
- PyErr_Format(PyExc_TypeError,
- "Type %.100s doesn't support the buffer API",
- Py_TYPE(obj)->tp_name);
- return -1;
- }
- if (buffer->bf_getbuffer(obj, view, PyBUF_SIMPLE) < 0)
- return -1;
- return view->len;
- }
- static int
- _canresize(PyByteArrayObject *self)
- {
- if (self->ob_exports > 0) {
- PyErr_SetString(PyExc_BufferError,
- "Existing exports of data: object cannot be re-sized");
- return 0;
- }
- return 1;
- }
- /* Direct API functions */
- PyObject *
- PyByteArray_FromObject(PyObject *input)
- {
- return PyObject_CallFunctionObjArgs((PyObject *)&PyByteArray_Type,
- input, NULL);
- }
- PyObject *
- PyByteArray_FromStringAndSize(const char *bytes, Py_ssize_t size)
- {
- PyByteArrayObject *new;
- Py_ssize_t alloc;
- if (size < 0) {
- PyErr_SetString(PyExc_SystemError,
- "Negative size passed to PyByteArray_FromStringAndSize");
- return NULL;
- }
- new = PyObject_New(PyByteArrayObject, &PyByteArray_Type);
- if (new == NULL)
- return NULL;
- if (size == 0) {
- new->ob_bytes = NULL;
- alloc = 0;
- }
- else {
- alloc = size + 1;
- new->ob_bytes = PyMem_Malloc(alloc);
- if (new->ob_bytes == NULL) {
- Py_DECREF(new);
- return PyErr_NoMemory();
- }
- if (bytes != NULL)
- memcpy(new->ob_bytes, bytes, size);
- new->ob_bytes[size] = '\0'; /* Trailing null byte */
- }
- Py_SIZE(new) = size;
- new->ob_alloc = alloc;
- new->ob_exports = 0;
- return (PyObject *)new;
- }
- Py_ssize_t
- PyByteArray_Size(PyObject *self)
- {
- assert(self != NULL);
- assert(PyByteArray_Check(self));
- return PyByteArray_GET_SIZE(self);
- }
- char *
- PyByteArray_AsString(PyObject *self)
- {
- assert(self != NULL);
- assert(PyByteArray_Check(self));
- return PyByteArray_AS_STRING(self);
- }
- int
- PyByteArray_Resize(PyObject *self, Py_ssize_t size)
- {
- void *sval;
- Py_ssize_t alloc = ((PyByteArrayObject *)self)->ob_alloc;
- assert(self != NULL);
- assert(PyByteArray_Check(self));
- assert(size >= 0);
- if (size == Py_SIZE(self)) {
- return 0;
- }
- if (!_canresize((PyByteArrayObject *)self)) {
- return -1;
- }
- if (size < alloc / 2) {
- /* Major downsize; resize down to exact size */
- alloc = size + 1;
- }
- else if (size < alloc) {
- /* Within allocated size; quick exit */
- Py_SIZE(self) = size;
- ((PyByteArrayObject *)self)->ob_bytes[size] = '\0'; /* Trailing null */
- return 0;
- }
- else if (size <= alloc * 1.125) {
- /* Moderate upsize; overallocate similar to list_resize() */
- alloc = size + (size >> 3) + (size < 9 ? 3 : 6);
- }
- else {
- /* Major upsize; resize up to exact size */
- alloc = size + 1;
- }
- sval = PyMem_Realloc(((PyByteArrayObject *)self)->ob_bytes, alloc);
- if (sval == NULL) {
- PyErr_NoMemory();
- return -1;
- }
- ((PyByteArrayObject *)self)->ob_bytes = sval;
- Py_SIZE(self) = size;
- ((PyByteArrayObject *)self)->ob_alloc = alloc;
- ((PyByteArrayObject *)self)->ob_bytes[size] = '\0'; /* Trailing null byte */
- return 0;
- }
- PyObject *
- PyByteArray_Concat(PyObject *a, PyObject *b)
- {
- Py_ssize_t size;
- Py_buffer va, vb;
- PyByteArrayObject *result = NULL;
- va.len = -1;
- vb.len = -1;
- if (_getbuffer(a, &va) < 0 ||
- _getbuffer(b, &vb) < 0) {
- PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
- Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
- goto done;
- }
- size = va.len + vb.len;
- if (size < 0) {
- return PyErr_NoMemory();
- goto done;
- }
- result = (PyByteArrayObject *) PyByteArray_FromStringAndSize(NULL, size);
- if (result != NULL) {
- memcpy(result->ob_bytes, va.buf, va.len);
- memcpy(result->ob_bytes + va.len, vb.buf, vb.len);
- }
- done:
- if (va.len != -1)
- PyBuffer_Release(&va);
- if (vb.len != -1)
- PyBuffer_Release(&vb);
- return (PyObject *)result;
- }
- /* Functions stuffed into the type object */
- static Py_ssize_t
- bytes_length(PyByteArrayObject *self)
- {
- return Py_SIZE(self);
- }
- static PyObject *
- bytes_iconcat(PyByteArrayObject *self, PyObject *other)
- {
- Py_ssize_t mysize;
- Py_ssize_t size;
- Py_buffer vo;
- if (_getbuffer(other, &vo) < 0) {
- PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
- Py_TYPE(other)->tp_name, Py_TYPE(self)->tp_name);
- return NULL;
- }
- mysize = Py_SIZE(self);
- size = mysize + vo.len;
- if (size < 0) {
- PyBuffer_Release(&vo);
- return PyErr_NoMemory();
- }
- if (size < self->ob_alloc) {
- Py_SIZE(self) = size;
- self->ob_bytes[Py_SIZE(self)] = '\0'; /* Trailing null byte */
- }
- else if (PyByteArray_Resize((PyObject *)self, size) < 0) {
- PyBuffer_Release(&vo);
- return NULL;
- }
- memcpy(self->ob_bytes + mysize, vo.buf, vo.len);
- PyBuffer_Release(&vo);
- Py_INCREF(self);
- return (PyObject *)self;
- }
- static PyObject *
- bytes_repeat(PyByteArrayObject *self, Py_ssize_t count)
- {
- PyByteArrayObject *result;
- Py_ssize_t mysize;
- Py_ssize_t size;
- if (count < 0)
- count = 0;
- mysize = Py_SIZE(self);
- size = mysize * count;
- if (count != 0 && size / count != mysize)
- return PyErr_NoMemory();
- result = (PyByteArrayObject *)PyByteArray_FromStringAndSize(NULL, size);
- if (result != NULL && size != 0) {
- if (mysize == 1)
- memset(result->ob_bytes, self->ob_bytes[0], size);
- else {
- Py_ssize_t i;
- for (i = 0; i < count; i++)
- memcpy(result->ob_bytes + i*mysize, self->ob_bytes, mysize);
- }
- }
- return (PyObject *)result;
- }
- static PyObject *
- bytes_irepeat(PyByteArrayObject *self, Py_ssize_t count)
- {
- Py_ssize_t mysize;
- Py_ssize_t size;
- if (count < 0)
- count = 0;
- mysize = Py_SIZE(self);
- size = mysize * count;
- if (count != 0 && size / count != mysize)
- return PyErr_NoMemory();
- if (size < self->ob_alloc) {
- Py_SIZE(self) = size;
- self->ob_bytes[Py_SIZE(self)] = '\0'; /* Trailing null byte */
- }
- else if (PyByteArray_Resize((PyObject *)self, size) < 0)
- return NULL;
- if (mysize == 1)
- memset(self->ob_bytes, self->ob_bytes[0], size);
- else {
- Py_ssize_t i;
- for (i = 1; i < count; i++)
- memcpy(self->ob_bytes + i*mysize, self->ob_bytes, mysize);
- }
- Py_INCREF(self);
- return (PyObject *)self;
- }
- static PyObject *
- bytes_getitem(PyByteArrayObject *self, Py_ssize_t i)
- {
- if (i < 0)
- i += Py_SIZE(self);
- if (i < 0 || i >= Py_SIZE(self)) {
- PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
- return NULL;
- }
- return PyInt_FromLong((unsigned char)(self->ob_bytes[i]));
- }
- static PyObject *
- bytes_subscript(PyByteArrayObject *self, PyObject *index)
- {
- if (PyIndex_Check(index)) {
- Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);
- if (i == -1 && PyErr_Occurred())
- return NULL;
- if (i < 0)
- i += PyByteArray_GET_SIZE(self);
- if (i < 0 || i >= Py_SIZE(self)) {
- PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
- return NULL;
- }
- return PyInt_FromLong((unsigned char)(self->ob_bytes[i]));
- }
- else if (PySlice_Check(index)) {
- Py_ssize_t start, stop, step, slicelength, cur, i;
- if (PySlice_GetIndicesEx((PySliceObject *)index,
- PyByteArray_GET_SIZE(self),
- &start, &stop, &step, &slicelength) < 0) {
- return NULL;
- }
- if (slicelength <= 0)
- return PyByteArray_FromStringAndSize("", 0);
- else if (step == 1) {
- return PyByteArray_FromStringAndSize(self->ob_bytes + start,
- slicelength);
- }
- else {
- char *source_buf = PyByteArray_AS_STRING(self);
- char *result_buf = (char *)PyMem_Malloc(slicelength);
- PyObject *result;
- if (result_buf == NULL)
- return PyErr_NoMemory();
- for (cur = start, i = 0; i < slicelength;
- cur += step, i++) {
- result_buf[i] = source_buf[cur];
- }
- result = PyByteArray_FromStringAndSize(result_buf, slicelength);
- PyMem_Free(result_buf);
- return result;
- }
- }
- else {
- PyErr_SetString(PyExc_TypeError, "bytearray indices must be integers");
- return NULL;
- }
- }
- static int
- bytes_setslice(PyByteArrayObject *self, Py_ssize_t lo, Py_ssize_t hi,
- PyObject *values)
- {
- Py_ssize_t avail, needed;
- void *bytes;
- Py_buffer vbytes;
- int res = 0;
- vbytes.len = -1;
- if (values == (PyObject *)self) {
- /* Make a copy and call this function recursively */
- int err;
- values = PyByteArray_FromObject(values);
- if (values == NULL)
- return -1;
- err = bytes_setslice(self, lo, hi, values);
- Py_DECREF(values);
- return err;
- }
- if (values == NULL) {
- /* del b[lo:hi] */
- bytes = NULL;
- needed = 0;
- }
- else {
- if (_getbuffer(values, &vbytes) < 0) {
- PyErr_Format(PyExc_TypeError,
- "can't set bytearray slice from %.100s",
- Py_TYPE(values)->tp_name);
- return -1;
- }
- needed = vbytes.len;
- bytes = vbytes.buf;
- }
- if (lo < 0)
- lo = 0;
- if (hi < lo)
- hi = lo;
- if (hi > Py_SIZE(self))
- hi = Py_SIZE(self);
- avail = hi - lo;
- if (avail < 0)
- lo = hi = avail = 0;
- if (avail != needed) {
- if (avail > needed) {
- if (!_canresize(self)) {
- res = -1;
- goto finish;
- }
- /*
- 0 lo hi old_size
- | |<----avail----->|<-----tomove------>|
- | |<-needed->|<-----tomove------>|
- 0 lo new_hi new_size
- */
- memmove(self->ob_bytes + lo + needed, self->ob_bytes + hi,
- Py_SIZE(self) - hi);
- }
- /* XXX(nnorwitz): need to verify this can't overflow! */
- if (PyByteArray_Resize((PyObject *)self,
- Py_SIZE(self) + needed - avail) < 0) {
- res = -1;
- goto finish;
- }
- if (avail < needed) {
- /*
- 0 lo hi old_size
- | |<-avail->|<-----tomove------>|
- | |<----needed---->|<-----tomove------>|
- 0 lo new_hi new_size
- */
- memmove(self->ob_bytes + lo + needed, self->ob_bytes + hi,
- Py_SIZE(self) - lo - needed);
- }
- }
- if (needed > 0)
- memcpy(self->ob_bytes + lo, bytes, needed);
- finish:
- if (vbytes.len != -1)
- PyBuffer_Release(&vbytes);
- return res;
- }
- static int
- bytes_setitem(PyByteArrayObject *self, Py_ssize_t i, PyObject *value)
- {
- int ival;
- if (i < 0)
- i += Py_SIZE(self);
- if (i < 0 || i >= Py_SIZE(self)) {
- PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
- return -1;
- }
- if (value == NULL)
- return bytes_setslice(self, i, i+1, NULL);
- if (!_getbytevalue(value, &ival))
- return -1;
- self->ob_bytes[i] = ival;
- return 0;
- }
- static int
- bytes_ass_subscript(PyByteArrayObject *self, PyObject *index, PyObject *values)
- {
- Py_ssize_t start, stop, step, slicelen, needed;
- char *bytes;
- if (PyIndex_Check(index)) {
- Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);
- if (i == -1 && PyErr_Occurred())
- return -1;
- if (i < 0)
- i += PyByteArray_GET_SIZE(self);
- if (i < 0 || i >= Py_SIZE(self)) {
- PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
- return -1;
- }
- if (values == NULL) {
- /* Fall through to slice assignment */
- start = i;
- stop = i + 1;
- step = 1;
- slicelen = 1;
- }
- else {
- int ival;
- if (!_getbytevalue(values, &ival))
- return -1;
- self->ob_bytes[i] = (char)ival;
- return 0;
- }
- }
- else if (PySlice_Check(index)) {
- if (PySlice_GetIndicesEx((PySliceObject *)index,
- PyByteArray_GET_SIZE(self),
- &start, &stop, &step, &slicelen) < 0) {
- return -1;
- }
- }
- else {
- PyErr_SetString(PyExc_TypeError, "bytearray indices must be integer");
- return -1;
- }
- if (values == NULL) {
- bytes = NULL;
- needed = 0;
- }
- else if (values == (PyObject *)self || !PyByteArray_Check(values)) {
- /* Make a copy an call this function recursively */
- int err;
- values = PyByteArray_FromObject(values);
- if (values == NULL)
- return -1;
- err = bytes_ass_subscript(self, index, values);
- Py_DECREF(values);
- return err;
- }
- else {
- assert(PyByteArray_Check(values));
- bytes = ((PyByteArrayObject *)values)->ob_bytes;
- needed = Py_SIZE(values);
- }
- /* Make sure b[5:2] = ... inserts before 5, not before 2. */
- if ((step < 0 && start < stop) ||
- (step > 0 && start > stop))
- stop = start;
- if (step == 1) {
- if (slicelen != needed) {
- if (!_canresize(self))
- return -1;
- if (slicelen > needed) {
- /*
- 0 start stop old_size
- | |<---slicelen--->|<-----tomove------>|
- | |<-needed->|<-----tomove------>|
- 0 lo new_hi new_size
- */
- memmove(self->ob_bytes + start + needed, self->ob_bytes + stop,
- Py_SIZE(self) - stop);
- }
- if (PyByteArray_Resize((PyObject *)self,
- Py_SIZE(self) + needed - slicelen) < 0)
- return -1;
- if (slicelen < needed) {
- /*
- 0 lo hi old_size
- | |<-avail->|<-----tomove------>|
- | |<----needed---->|<-----tomove------>|
- 0 lo new_hi new_size
- */
- memmove(self->ob_bytes + start + needed, self->ob_bytes + stop,
- Py_SIZE(self) - start - needed);
- }
- }
- if (needed > 0)
- memcpy(self->ob_bytes + start, bytes, needed);
- return 0;
- }
- else {
- if (needed == 0) {
- /* Delete slice */
- Py_ssize_t cur, i;
- if (!_canresize(self))
- return -1;
- if (step < 0) {
- stop = start + 1;
- start = stop + step * (slicelen - 1) - 1;
- step = -step;
- }
- for (cur = start, i = 0;
- i < slicelen; cur += step, i++) {
- Py_ssize_t lim = step - 1;
- if (cur + step >= PyByteArray_GET_SIZE(self))
- lim = PyByteArray_GET_SIZE(self) - cur - 1;
- memmove(self->ob_bytes + cur - i,
- self->ob_bytes + cur + 1, lim);
- }
- /* Move the tail of the bytes, in one chunk */
- cur = start + slicelen*step;
- if (cur < PyByteArray_GET_SIZE(self)) {
- memmove(self->ob_bytes + cur - slicelen,
- self->ob_bytes + cur,
- PyByteArray_GET_SIZE(self) - cur);
- }
- if (PyByteArray_Resize((PyObject *)self,
- PyByteArray_GET_SIZE(self) - slicelen) < 0)
- return -1;
- return 0;
- }
- else {
- /* Assign slice */
- Py_ssize_t cur, i;
- if (needed != slicelen) {
- PyErr_Format(PyExc_ValueError,
- "attempt to assign bytes of size %zd "
- "to extended slice of size %zd",
- needed, slicelen);
- return -1;
- }
- for (cur = start, i = 0; i < slicelen; cur += step, i++)
- self->ob_bytes[cur] = bytes[i];
- return 0;
- }
- }
- }
- static int
- bytes_init(PyByteArrayObject *self, PyObject *args, PyObject *kwds)
- {
- static char *kwlist[] = {"source", "encoding", "errors", 0};
- PyObject *arg = NULL;
- const char *encoding = NULL;
- const char *errors = NULL;
- Py_ssize_t count;
- PyObject *it;
- PyObject *(*iternext)(PyObject *);
- if (Py_SIZE(self) != 0) {
- /* Empty previous contents (yes, do this first of all!) */
- if (PyByteArray_Resize((PyObject *)self, 0) < 0)
- return -1;
- }
- /* Parse arguments */
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oss:bytearray", kwlist,
- &arg, &encoding, &errors))
- return -1;
- /* Make a quick exit if no first argument */
- if (arg == NULL) {
- if (encoding != NULL || errors != NULL) {
- PyErr_SetString(PyExc_TypeError,
- "encoding or errors without sequence argument");
- return -1;
- }
- return 0;
- }
- if (PyBytes_Check(arg)) {
- PyObject *new, *encoded;
- if (encoding != NULL) {
- encoded = PyCodec_Encode(arg, encoding, errors);
- if (encoded == NULL)
- return -1;
- assert(PyBytes_Check(encoded));
- }
- else {
- encoded = arg;
- Py_INCREF(arg);
- }
- new = bytes_iconcat(self, arg);
- Py_DECREF(encoded);
- if (new == NULL)
- return -1;
- Py_DECREF(new);
- return 0;
- }
- if (PyUnicode_Check(arg)) {
- /* Encode via the codec registry */
- PyObject *encoded, *new;
- if (encoding == NULL) {
- PyErr_SetString(PyExc_TypeError,
- "unicode argument without an encoding");
- return -1;
- }
- encoded = PyCodec_Encode(arg, encoding, errors);
- if (encoded == NULL)
- return -1;
- assert(PyBytes_Check(encoded));
- new = bytes_iconcat(self, encoded);
- Py_DECREF(encoded);
- if (new == NULL)
- return -1;
- Py_DECREF(new);
- return 0;
- }
- /* If it's not unicode, there can't be encoding or errors */
- if (encoding != NULL || errors != NULL) {
- PyErr_SetString(PyExc_TypeError,
- "encoding or errors without a string argument");
- return -1;
- }
- /* Is it an int? */
- count = PyNumber_AsSsize_t(arg, PyExc_ValueError);
- if (count == -1 && PyErr_Occurred())
- PyErr_Clear();
- else {
- if (count < 0) {
- PyErr_SetString(PyExc_ValueError, "negative count");
- return -1;
- }
- if (count > 0) {
- if (PyByteArray_Resize((PyObject *)self, count))
- return -1;
- memset(self->ob_bytes, 0, count);
- }
- return 0;
- }
- /* Use the buffer API */
- if (PyObject_CheckBuffer(arg)) {
- Py_ssize_t size;
- Py_buffer view;
- if (PyObject_GetBuffer(arg, &view, PyBUF_FULL_RO) < 0)
- return -1;
- size = view.len;
- if (PyByteArray_Resize((PyObject *)self, size) < 0) goto fail;
- if (PyBuffer_ToContiguous(self->ob_bytes, &view, size, 'C') < 0)
- goto fail;
- PyBuffer_Release(&view);
- return 0;
- fail:
- PyBuffer_Release(&view);
- return -1;
- }
- /* XXX Optimize this if the arguments is a list, tuple */
- /* Get the iterator */
- it = PyObject_GetIter(arg);
- if (it == NULL)
- return -1;
- iternext = *Py_TYPE(it)->tp_iternext;
- /* Run the iterator to exhaustion */
- for (;;) {
- PyObject *item;
- int rc, value;
- /* Get the next item */
- item = iternext(it);
- if (item == NULL) {
- if (PyErr_Occurred()) {
- if (!PyErr_ExceptionMatches(PyExc_StopIteration))
- goto error;
- PyErr_Clear();
- }
- break;
- }
- /* Interpret it as an int (__index__) */
- rc = _getbytevalue(item, &value);
- Py_DECREF(item);
- if (!rc)
- goto error;
- /* Append the byte */
- if (Py_SIZE(self) < self->ob_alloc)
- Py_SIZE(self)++;
- else if (PyByteArray_Resize((PyObject *)self, Py_SIZE(self)+1) < 0)
- goto error;
- self->ob_bytes[Py_SIZE(self)-1] = value;
- }
- /* Clean up and return success */
- Py_DECREF(it);
- return 0;
- error:
- /* Error handling when it != NULL */
- Py_DECREF(it);
- return -1;
- }
- /* Mostly copied from string_repr, but without the
- "smart quote" functionality. */
- static PyObject *
- bytes_repr(PyByteArrayObject *self)
- {
- static const char *hexdigits = "0123456789abcdef";
- const char *quote_prefix = "bytearray(b";
- const char *quote_postfix = ")";
- Py_ssize_t length = Py_SIZE(self);
- /* 14 == strlen(quote_prefix) + 2 + strlen(quote_postfix) */
- size_t newsize = 14 + 4 * length;
- PyObject *v;
- if (newsize > PY_SSIZE_T_MAX || newsize / 4 - 3 != length) {
- PyErr_SetString(PyExc_OverflowError,
- "bytearray object is too large to make repr");
- return NULL;
- }
- v = PyUnicode_FromUnicode(NULL, newsize);
- if (v == NULL) {
- return NULL;
- }
- else {
- register Py_ssize_t i;
- register Py_UNICODE c;
- register Py_UNICODE *p;
- int quote;
- /* Figure out which quote to use; single is preferred */
- quote = '\'';
- {
- char *test, *start;
- start = PyByteArray_AS_STRING(self);
- for (test = start; test < start+length; ++test) {
- if (*test == '"') {
- quote = '\''; /* back to single */
- goto decided;
- }
- else if (*test == '\'')
- quote = '"';
- }
- decided:
- ;
- }
- p = PyUnicode_AS_UNICODE(v);
- while (*quote_prefix)
- *p++ = *quote_prefix++;
- *p++ = quote;
- for (i = 0; i < length; i++) {
- /* There's at least enough room for a hex escape
- and a closing quote. */
- assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 5);
- c = self->ob_bytes[i];
- if (c == '\'' || c == '\\')
- *p++ = '\\', *p++ = c;
- else if (c == '\t')
- *p++ = '\\', *p++ = 't';
- else if (c == '\n')
- *p++ = '\\', *p++ = 'n';
- else if (c == '\r')
- *p++ = '\\', *p++ = 'r';
- else if (c == 0)
- *p++ = '\\', *p++ = 'x', *p++ = '0', *p++ = '0';
- else if (c < ' ' || c >= 0x7f) {
- *p++ = '\\';
- *p++ = 'x';
- *p++ = hexdigits[(c & 0xf0) >> 4];
- *p++ = hexdigits[c & 0xf];
- }
- else
- *p++ = c;
- }
- assert(newsize - (p - PyUnicode_AS_UNICODE(v)) >= 1);
- *p++ = quote;
- while (*quote_postfix) {
- *p++ = *quote_postfix++;
- }
- *p = '\0';
- if (PyUnicode_Resize(&v, (p - PyUnicode_AS_UNICODE(v)))) {
- Py_DECREF(v);
- return NULL;
- }
- return v;
- }
- }
- static PyObject *
- bytes_str(PyObject *op)
- {
- #if 0
- if (Py_BytesWarningFlag) {
- if (PyErr_WarnEx(PyExc_BytesWarning,
- "str() on a bytearray instance", 1))
- return NULL;
- }
- return bytes_repr((PyByteArrayObject*)op);
- #endif
- return PyBytes_FromStringAndSize(((PyByteArrayObject*)op)->ob_bytes, Py_SIZE(op));
- }
- static PyObject *
- bytes_richcompare(PyObject *self, PyObject *other, int op)
- {
- Py_ssize_t self_size, other_size;
- Py_buffer self_bytes, other_bytes;
- PyObject *res;
- Py_ssize_t minsize;
- int cmp;
- /* Bytes can be compared to anything that supports the (binary)
- buffer API. Except that a comparison with Unicode is always an
- error, even if the comparison is for equality. */
- if (PyObject_IsInstance(self, (PyObject*)&PyUnicode_Type) ||
- PyObject_IsInstance(other, (PyObject*)&PyUnicode_Type)) {
- if (Py_BytesWarningFlag && op == Py_EQ) {
- if (PyErr_WarnEx(PyExc_BytesWarning,
- "Comparsion between bytearray and string", 1))
- return NULL;
- }
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
- }
- self_size = _getbuffer(self, &self_bytes);
- if (self_size < 0) {
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
- }
- other_size = _getbuffer(other, &other_bytes);
- if (other_size < 0) {
- PyErr_Clear();
- PyBuffer_Release(&self_bytes);
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
- }
- if (self_size != other_size && (op == Py_EQ || op == Py_NE)) {
- /* Shortcut: if the lengths differ, the objects differ */
- cmp = (op == Py_NE);
- }
- else {
- minsize = self_size;
- if (other_size < minsize)
- minsize = other_size;
- cmp = memcmp(self_bytes.buf, other_bytes.buf, minsize);
- /* In ISO C, memcmp() guarantees to use unsigned bytes! */
- if (cmp == 0) {
- if (self_size < other_size)
- cmp = -1;
- else if (self_size > other_size)
- cmp = 1;
- }
- switch (op) {
- case Py_LT: cmp = cmp < 0; break;
- case Py_LE: cmp = cmp <= 0; break;
- case Py_EQ: cmp = cmp == 0; break;
- case Py_NE: cmp = cmp != 0; break;
- case Py_GT: cmp = cmp > 0; break;
- case Py_GE: cmp = cmp >= 0; break;
- }
- }
- res = cmp ? Py_True : Py_False;
- PyBuffer_Release(&self_bytes);
- PyBuffer_Release(&other_bytes);
- Py_INCREF(res);
- return res;
- }
- static void
- bytes_dealloc(PyByteArrayObject *self)
- {
- if (self->ob_exports > 0) {
- PyErr_SetString(PyExc_SystemError,
- "deallocated bytearray object has exported buffers");
- PyErr_Print();
- }
- if (self->ob_bytes != 0) {
- PyMem_Free(self->ob_bytes);
- }
- Py_TYPE(self)->tp_free((PyObject *)self);
- }
- /* -------------------------------------------------------------------- */
- /* Methods */
- #define STRINGLIB_CHAR char
- #define STRINGLIB_CMP memcmp
- #define STRINGLIB_LEN PyByteArray_GET_SIZE
- #define STRINGLIB_STR PyByteArray_AS_STRING
- #define STRINGLIB_NEW PyByteArray_FromStringAndSize
- #define STRINGLIB_EMPTY nullbytes
- #define STRINGLIB_CHECK_EXACT PyByteArray_CheckExact
- #define STRINGLIB_MUTABLE 1
- #define FROM_BYTEARRAY 1
- #include "stringlib/fastsearch.h"
- #include "stringlib/count.h"
- #include "stringlib/find.h"
- #include "stringlib/partition.h"
- #include "stringlib/ctype.h"
- #include "stringlib/transmogrify.h"
- /* The following Py_LOCAL_INLINE and Py_LOCAL functions
- were copied from the old char* style string object. */
- Py_LOCAL_INLINE(void)
- _adjust_indices(Py_ssize_t *start, Py_ssize_t *end, Py_ssize_t len)
- {
- if (*end > len)
- *end = len;
- else if (*end < 0)
- *end += len;
- if (*end < 0)
- *end = 0;
- if (*start < 0)
- *start += len;
- if (*start < 0)
- *start = 0;
- }
- Py_LOCAL_INLINE(Py_ssize_t)
- bytes_find_internal(PyByteArrayObject *self, PyObject *args, int dir)
- {
- PyObject *subobj;
- Py_buffer subbuf;
- Py_ssize_t start=0, end=PY_SSIZE_T_MAX;
- Py_ssize_t res;
- if (!PyArg_ParseTuple(args, "O|O&O&:find/rfind/index/rindex", &subobj,
- _PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
- return -2;
- if (_getbuffer(subobj, &subbuf) < 0)
- return -2;
- if (dir > 0)
- res = stringlib_find_slice(
- PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self),
- subbuf.buf, subbuf.len, start, end);
- else
- res = stringlib_rfind_slice(
- PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self),
- subbuf.buf, subbuf.len, start, end);
- PyBuffer_Release(&subbuf);
- return res;
- }
- PyDoc_STRVAR(find__doc__,
- "B.find(sub [,start [,end]]) -> int\n\
- \n\
- Return the lowest index in B where subsection sub is found,\n\
- such that sub is contained within s[start,end]. Optional\n\
- arguments start and end are interpreted as in slice notation.\n\
- \n\
- Return -1 on failure.");
- static PyObject *
- bytes_find(PyByteArrayObject *self, PyObject *args)
- {
- Py_ssize_t result = bytes_find_internal(self, args, +1);
- if (result == -2)
- return NULL;
- return PyInt_FromSsize_t(result);
- }
- PyDoc_STRVAR(count__doc__,
- "B.count(sub [,start [,end]]) -> int\n\
- \n\
- Return the number of non-overlapping occurrences of subsection sub in\n\
- bytes B[start:end]. Optional arguments start and end are interpreted\n\
- as in slice notation.");
- static PyObject *
- bytes_count(PyByteArrayObject *self, PyObject *args)
- {
- PyObject *sub_obj;
- const char *str = PyByteArray_AS_STRING(self);
- Py_ssize_t start = 0, end = PY_SSIZE_T_MAX;
- Py_buffer vsub;
- PyObject *count_obj;
- if (!PyArg_ParseTuple(args, "O|O&O&:count", &sub_obj,
- _PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
- return NULL;
- if (_getbuffer(sub_obj, &vsub) < 0)
- return NULL;
- _adjust_indices(&start, &end, PyByteArray_GET_SIZE(self));
- count_obj = PyInt_FromSsize_t(
- stringlib_count(str + start, end - start, vsub.buf, vsub.len)
- );
- PyBuffer_Release(&vsub);
- return count_obj;
- }
- PyDoc_STRVAR(index__doc__,
- "B.index(sub [,start [,end]]) -> int\n\
- \n\
- Like B.find() but raise ValueError when the subsection is not found.");
- static PyObject *
- bytes_index(PyByteArrayObject *self, PyObject *args)
- {
- Py_ssize_t result = bytes_find_internal(self, args, +1);
- if (result == -2)
- return NULL;
- if (result == -1) {
- PyErr_SetString(PyExc_ValueError,
- "subsection not found");
- return NULL;
- }
- return PyInt_FromSsize_t(result);
- }
- PyDoc_STRVAR(rfind__doc__,
- "B.rfind(sub [,start [,end]]) -> int\n\
- \n\
- Return the highest index in B where subsection sub is found,\n\
- such that sub is contained within s[start,end]. Optional\n\
- arguments start and end are interpreted as in slice notation.\n\
- \n\
- Return -1 on failure.");
- static PyObject *
- bytes_rfind(PyByteArrayObject *self, PyObject *args)
- {
- Py_ssize_t result = bytes_find_internal(self, args, -1);
- if (result == -2)
- return NULL;
- return PyInt_FromSsize_t(result);
- }
- PyDoc_STRVAR(rindex__doc__,
- "B.rindex(sub [,start [,end]]) -> int\n\
- \n\
- Like B.rfind() but raise ValueError when the subsection is not found.");
- static PyObject *
- bytes_rindex(PyByteArrayObject *self, PyObject *args)
- {
- Py_ssize_t result = bytes_find_internal(self, args, -1);
- if (result == -2)
- return NULL;
- if (result == -1) {
- PyErr_SetString(PyExc_ValueError,
- "subsection not found");
- return NULL;
- }
- return PyInt_FromSsize_t(result);
- }
- static int
- bytes_contains(PyObject *self, PyObject *arg)
- {
- Py_ssize_t ival = PyNumber_AsSsize_t(arg, PyExc_ValueError);
- if (ival == -1 && PyErr_Occurred()) {
- Py_buffer varg;
- int pos;
- PyErr_Clear();
- if (_getbuffer(arg, &varg) < 0)
- return -1;
- pos = stringlib_find(PyByteArray_AS_STRING(self), Py_SIZE(self),
- varg.buf, varg.len, 0);
- PyBuffer_Release(&varg);
- return pos >= 0;
- }
- if (ival < 0 || ival >= 256) {
- PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
- return -1;
- }
- return memchr(PyByteArray_AS_STRING(self), ival, Py_SIZE(self)) != NULL;
- }
- /* Matches the end (direction >= 0) or start (direction < 0) of self
- * against substr, using the start and end arguments. Returns
- * -1 on error, 0 if not found and 1 if found.
- */
- Py_LOCAL(int)
- _bytes_tailmatch(PyByteArrayObject *self, PyObject *substr, Py_ssize_t start,
- Py_ssize_t end, int direction)
- {
- Py_ssize_t len = PyByteArray_GET_SIZE(self);
- const char* str;
- Py_buffer vsubstr;
- int rv = 0;
- str = PyByteArray_AS_STRING(self);
- if (_getbuffer(substr, &vsubstr) < 0)
- return -1;
- _adjust_indices(&start, &end, len);
- if (direction < 0) {
- /* startswith */
- if (start+vsubstr.len > len) {
- goto done;
- }
- } else {
- /* endswith */
- if (end-start < vsubstr.len || start > len) {
- goto done;
- }
- if (end-vsubstr.len > start)
- start = end - vsubstr.len;
- }
- if (end-start >= vsubstr.len)
- rv = ! memcmp(str+start, vsubstr.buf, vsubstr.len);
- done:
- PyBuffer_Release(&vsubstr);
- return rv;
- }
- PyDoc_STRVAR(startswith__doc__,
- "B.startswith(prefix [,start [,end]]) -> bool\n\
- \n\
- Return True if B starts with the specified prefix, False otherwise.\n\
- With optional start, test B beginning at that position.\n\
- With optional end, stop comparing B at that position.\n\
- prefix can also be a tuple of strings to try.");
- static PyObject *
- bytes_startswith(PyByteArrayObject *self, PyObject *args)
- {
- Py_ssize_t start = 0;
- Py_ssize_t end = PY_SSIZE_T_MAX;
- PyObject *subobj;
- int result;
- if (!PyArg_ParseTuple(args, "O|O&O&:startswith", &subobj,
- _PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
- return NULL;
- if (PyTuple_Check(subobj)) {
- Py_ssize_t i;
- for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
- result = _bytes_tailmatch(self,
- PyTuple_GET_ITEM(subobj, i),
- start, end, -1);
- if (result == -1)
- return NULL;
- else if (result) {
- Py_RETURN_TRUE;
- }
- }
- Py_RETURN_FALSE;
- }
- result = _bytes_tailmatch(self, subobj, start, end, -1);
- if (result == -1)
- return NULL;
- else
- return PyBool_FromLong(result);
- }
- PyDoc_STRVAR(endswith__doc__,
- "B.endswith(suffix [,start [,end]]) -> bool\n\
- \n\
- Return True if B ends with the specified suffix, False otherwise.\n\
- With optional start, test B beginning at that position.\n\
- With optional end, stop comparing B at that position.\n\
- suffix can also be a tuple of strings to try.");
- static PyObject *
- bytes_endswith(PyByteArrayObject *self, PyObject *args)
- {
- Py_ssize_t start = 0;
- Py_ssize_t end = PY_SSIZE_T_MAX;
- PyObject *subobj;
- int result;
- if (!PyArg_ParseTuple(args, "O|O&O&:endswith", &subobj,
- _PyEval_SliceIndex, &start, _PyEval_SliceIndex, &end))
- return NULL;
- if (PyTuple_Check(subobj)) {
- Py_ssize_t i;
- for (i = 0; i < PyTuple_GET_SIZE(subobj); i++) {
- result = _bytes_tailmatch(self,
- PyTuple_GET_ITEM(subobj, i),
- start, end, +1);
- if (result == -1)
- return NULL;
- else if (result) {
- Py_RETURN_TRUE;
- }
- }
- Py_RETURN_FALSE;
- }
- result = _bytes_tailmatch(self, subobj, start, end, +1);
- if (result == -1)
- return NULL;
- else
- return PyBool_FromLong(result);
- }
- PyDoc_STRVAR(translate__doc__,
- "B.translate(table[, deletechars]) -> bytearray\n\
- \n\
- Return a copy of B, where all characters occurring in the\n\
- optional argument deletechars are removed, and the remaining\n\
- characters have been mapped through the given translation\n\
- table, which must be a bytes object of length 256.");
- static PyObject *
- bytes_translate(PyByteArrayObject *self, PyObject *args)
- {
- register char *input, *output;
- register const char *table;
- register Py_ssize_t i, c;
- PyObject *input_obj = (PyObject*)self;
- const char *output_start;
- Py_ssize_t inlen;
- PyObject *result;
- int trans_table[256];
- PyObject *tableobj, *delobj = NULL;
- Py_buffer vtable, vdel;
- if (!PyArg_UnpackTuple(args, "translate", 1, 2,
- &tableobj, &delobj))
- return NULL;
- if (_getbuffer(tableobj, &vtable) < 0)
- return NULL;
- if (vtable.len != 256) {
- PyErr_SetString(PyExc_ValueError,
- "translation table must be 256 characters long");
- PyBuffer_Release(&vtable);
- return NULL;
- }
- if (delobj != NULL) {
- if (_getbuffer(delobj, &vdel) < 0) {
- PyBuffer_Release(&vtable);
- return NULL;
- }
- }
- else {
- vdel.buf = NULL;
- vdel.len = 0;
- }
- table = (const char *)vtable.buf;
- inlen = PyByteArray_GET_SIZE(input_obj);
- result = PyByteArray_FromStringAndSize((char *)NULL, inlen);
- if (result == NULL)
- goto done;
- output_start = output = PyByteArray_AsString(result);
- input = PyByteArray_AS_STRING(input_obj);
- if (vdel.len == 0) {
- /* If no deletions are required, use faster code */
- for (i = inlen; --i >= 0; ) {
- c = Py_CHARMASK(*input++);
- *output++ = table[c];
- }
- goto done;
- }
-
- for (i = 0; i < 256; i++)
- trans_table[i] = Py_CHARMASK(table[i]);
- for (i = 0; i < vdel.len; i++)
- trans_table[(int) Py_CHARMASK( ((unsigned char*)vdel.buf)[i] )] = -1;
- for (i = inlen; --i >= 0; ) {
- c = Py_CHARMASK(*input++);
- if (trans_table[c] != -1)
- if (Py_CHARMASK(*output++ = (char)trans_table[c]) == c)
- continue;
- }
- /* Fix the size of the resulting string */
- if (inlen > 0)
- PyByteArray_Resize(result, output - output_start);
- done:
- PyBuffer_Release(&vtable);
- if (delobj != NULL)
- PyBuffer_Release(&vdel);
- return result;
- }
- #define FORWARD 1
- #define REVERSE -1
- /* find and count characters and substrings */
- #define findchar(target, target_len, c) \
- ((char *)memchr((const void *)(target), c, target_len))
- /* Don't call if length < 2 */
- #define Py_STRING_MATCH(target, offset, pattern, length) \
- (target[offset] == pattern[0] && \
- target[offset+length-1] == pattern[length-1] && \
- !memcmp(target+offset+1, pattern+1, length-2) )
- /* Bytes ops must return a string, create a copy */
- Py_LOCAL(PyByteArrayObject *)
- return_self(PyByteArrayObject *self)
- {
- return (PyByteArrayObject *)PyByteArray_FromStringAndSize(
- PyByteArray_AS_STRING(self),
- PyByteArray_GET_SIZE(self));
- }
- Py_LOCAL_INLINE(Py_ssize_t)
- countchar(const char *target, Py_ssize_t target_len, char c, Py_ssize_t maxcount)
- {
- Py_ssize_t count=0;
- const char *start=target;
- const char *end=target+target_len;
- while ( (start=findchar(start, end-start, c)) != NULL ) {
- count++;
- if (count >= maxcount)
- break;
- start += 1;
- }
- return count;
- }
- Py_LOCAL(Py_ssize_t)
- findstring(const char *target, Py_ssize_t target_len,
- const char *pattern, Py_ssize_t pattern_len,
- Py_ssize_t start,
- Py_ssize_t end,
- int direction)
- {
- if (start < 0) {
- start += target_len;
- if (start < 0)
- start = 0;
- }
- if (end > target_len) {
- end = target_len;
- } else if (end < 0) {
- end += target_len;
- if (end < 0)
- end = 0;
- }
- /* zero-length substrings always match at the first attempt */
- if (pattern_len == 0)
- return (direction > 0) ? start : end;
- end -= pattern_len;
- if (direction < 0) {
- for (; end >= start; end--)
- if (Py_STRING_MATCH(target, end, pattern, pattern_len))
- return end;
- } else {
- for (; start <= end; start++)
- if (Py_STRING_MATCH(target, start, pattern, pattern_len))
- return start;
- }
- return -1;
- }
- Py_LOCAL_INLINE(Py_ssize_t)
- countstring(const char *target, Py_ssize_t target_len,
- const char *pattern, Py_ssize_t pattern_len,
- Py_ssize_t start,
- Py_ssize_t end,
- int direction, Py_ssize_t maxcount)
- {
- Py_ssize_t count=0;
- if (start < 0) {
- start += target_len;
- if (start < 0)
- start = 0;
- }
- if (end > target_len) {
- end = target_len;
- } else if (end < 0) {
- end += target_len;
- if (end < 0)
- end = 0;
- }
- /* zero-length substrings match everywhere */
- if (pattern_len == 0 || maxcount == 0) {
- if (target_len+1 < maxcount)
- return target_len+1;
- return maxcount;
- }
- end -= pattern_len;
- if (direction < 0) {
- for (; (end >= start); end--)
- if (Py_STRING_MATCH(target, end, pattern, pattern_len)) {
- count++;
- if (--maxcount <= 0) break;
- end -= pattern_len-1;
- }
- } else {
- for (; (start <= end); start++)
- if (Py_STRING_MATCH(target, start, pattern, pattern_len)) {
- count++;
- if (--maxcount <= 0)
- break;
- start += pattern_len-1;
- }
- }
- return count;
- }
- /* Algorithms for different cases of string replacement */
- /* len(self)>=1, from="", len(to)>=1, maxcount>=1 */
- Py_LOCAL(PyByteArrayObject *)
- replace_interleave(PyByteArrayObject *self,
- const char *to_s, Py_ssize_t to_len,
- Py_ssize_t maxcount)
- {
- char *self_s, *result_s;
- Py_ssize_t self_len, result_len;
- Py_ssize_t count, i, product;
- PyByteArrayObject *result;
- self_len = PyByteArray_GET_SIZE(self);
- /* 1 at the end plus 1 after every character */
- count = self_len+1;
- if (maxcount < count)
- count = maxcount;
- /* Check for overflow */
- /* result_len = count * to_len + self_len; */
- product = count * to_len;
- if (product / to_len != count) {
- PyErr_SetString(PyExc_OverflowError,
- "replace string is too long");
- return NULL;
- }
- result_len = product + self_len;
- if (result_len < 0) {
- PyErr_SetString(PyExc_OverflowError,
- "replace string is too long");
- return NULL;
- }
- if (! (result = (PyByteArrayObject *)
- PyByteArray_FromStringAndSize(NULL, result_len)) )
- return NULL;
- self_s = PyByteArray_AS_STRING(self);
- result_s = PyByteArray_AS_STRING(result);
- /* TODO: special case single character, which doesn't need memcpy */
- /* Lay the first one down (guaranteed this will occur) */
- Py_MEMCPY(result_s, to_s, to_len);
- result_s += to_len;
- count -= 1;
- for (i=0; i<count; i++) {
- *result_s++ = *self_s++;
- Py_MEMCPY(result_s, to_s, to_len);
- result_s += to_len;
- }
- /* Copy the rest of the original string */
- Py_MEMCPY(result_s, self_s, self_len-i);
- return result;
- }
- /* Special case for deleting a single character */
- /* len(self)>=1, len(from)==1, to="", maxcount>=1 */
- Py_LOCAL(PyByteArrayObject *)
- replace_delete_single_character(PyByteArrayObject *self,
- char from_c, Py_ssize_t maxcount)
- {
- char *self_s, *result_s;
- char *start, *next, *end;
- Py_ssize_t self_len, result_len;
- Py_ssize_t count;
- PyByteArrayObject *result;
- self_len = PyByteArray_GET_SIZE(self);
- self_s = PyByteArray_AS_STRING(self);
- count = countchar(self_s, self_len, from_c, maxcount);
- if (count == 0) {
- return return_self(self);
- }
- result_len = self_len - count; /* from_len == 1 */
- assert(result_len>=0);
- if ( (result = (PyByteArrayObject *)
- PyByteArray_FromStringAndSize(NULL, result_len)) == NULL)
- return NULL;
- result_s = PyByteArray_AS_STRING(result);
- start = self_s;
- end = self_s + self_len;
- while (count-- > 0) {
- next = findchar(start, end-start, from_c);
- if (next == NULL)
- break;
- Py_MEMCPY(result_s, start, next-start);
- result_s += (next-start);
- start = next+1;
- }
- Py_MEMCPY(result_s, start, end-start);
- return result;
- }
- /* len(self)>=1, len(from)>=2, to="", maxcount>=1 */
- Py_LOCAL(PyByteArrayObject *)
- replace_delete_substring(PyByteArrayObject *self,
- const char *from_s, Py_ssize_t from_len,
- Py_ssize_t maxcount)
- {
- char *self_s, *result_s;
- char *start, *next, *end;
- Py_ssize_t self_len, result_len;
- Py_ssize_t count, offset;
- PyByteArrayObject *result;
- self_len = PyByteArray_GET_SIZE(self);
- self_s = PyByteArray_AS_STRING(self);
- count = countstring(self_s, self_len,
- from_s, from_len,
- 0, self_len, 1,
- maxcount);
- if (count == 0) {
- /* no matches */
- return return_self(self);
- }
- result_len = self_len - (count * from_len);
- assert (result_len>=0);
- if ( (result = (PyByteArrayObject *)
- PyByteArray_FromStringAndSize(NULL, result_len)) == NULL )
- return NULL;
- result_s = PyByteArray_AS_STRING(result);
- start = self_s;
- end = self_s + self_len;
- while (count-- > 0) {
- offset = findstring(start, end-start,
- from_s, from_len,
- 0, end-start, FORWARD);
- if (offset == -1)
- break;
- next = start + offset;
- Py_MEMCPY(result_s, start, next-start);
- r…