/* PyBytes (bytearray) implementation */

#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#include "bytes_methods.h"

char _PyByteArray_empty_string[] = "";

void

PyByteArray_Fini(void)

{

}

int

PyByteArray_Init(void)

{

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 (_PyAnyInt_Check(arg)) {

face_value = PyLong_AsLong(arg);

}

else {

PyObject *index = PyNumber_Index(arg);

if (index == NULL) {

if (PyErr_ExceptionMatches(PyExc_TypeError)) {

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

bytearray_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 *)PyByteArray_AS_STRING(self);

return Py_SIZE(self);

}

static Py_ssize_t

bytearray_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 *)PyByteArray_AS_STRING(self);

return Py_SIZE(self);

}

static Py_ssize_t

bytearray_buffer_getsegcount(PyByteArrayObject *self, Py_ssize_t *lenp)

{

if ( lenp )

*lenp = Py_SIZE(self);

return 1;

}

static Py_ssize_t

bytearray_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 = PyByteArray_AS_STRING(self);

return Py_SIZE(self);

}

static int

bytearray_getbuffer(PyByteArrayObject *obj, Py_buffer *view, int flags)

{

int ret;

void *ptr;

if (view == NULL) {

obj->ob_exports++;

return 0;

}

ptr = (void *) PyByteArray_AS_STRING(obj);

ret = PyBuffer_FillInfo(view, (PyObject*)obj, ptr, Py_SIZE(obj), 0, flags);

if (ret >= 0) {

obj->ob_exports++;

}

return ret;

}

static void

bytearray_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);

}

static PyObject *

_PyByteArray_FromBufferObject(PyObject *obj)

{

PyObject *result;

Py_buffer view;

if (PyObject_GetBuffer(obj, &view, PyBUF_FULL_RO) < 0) {

return NULL;

}

result = PyByteArray_FromStringAndSize(NULL, view.len);

if (result != NULL &&

PyBuffer_ToContiguous(PyByteArray_AS_STRING(result),

&view, view.len, 'C') < 0)

{

Py_CLEAR(result);

}

PyBuffer_Release(&view);

return result;

}

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 && size > 0)

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_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;

}

if (va.len > PY_SSIZE_T_MAX - vb.len) {

PyErr_NoMemory();

goto done;

}

result = (PyByteArrayObject *) \

PyByteArray_FromStringAndSize(NULL, va.len + vb.len);

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

bytearray_length(PyByteArrayObject *self)

{

return Py_SIZE(self);

}

static PyObject *

bytearray_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);

if (mysize > PY_SSIZE_T_MAX - vo.len) {

PyBuffer_Release(&vo);

return PyErr_NoMemory();

}

size = mysize + vo.len;

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 *

bytearray_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);

if (count != 0 && mysize > PY_SSIZE_T_MAX / count)

return PyErr_NoMemory();

size = mysize * count;

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 *

bytearray_irepeat(PyByteArrayObject *self, Py_ssize_t count)

{

Py_ssize_t mysize;

Py_ssize_t size;

if (count < 0)

count = 0;

mysize = Py_SIZE(self);

if (count != 0 && mysize > PY_SSIZE_T_MAX / count)

return PyErr_NoMemory();

size = mysize * count;

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 *

bytearray_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 *

bytearray_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_Unpack(index, &start, &stop, &step) < 0) {

return NULL;

}

slicelength = _PySlice_AdjustIndices(PyByteArray_GET_SIZE(self),

&start, &stop, step);

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

bytearray_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_FromStringAndSize(PyByteArray_AS_STRING(values),

PyByteArray_GET_SIZE(values));

if (values == NULL)

return -1;

err = bytearray_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

bytearray_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 bytearray_setslice(self, i, i+1, NULL);

if (!_getbytevalue(value, &ival))

return -1;

self->ob_bytes[i] = ival;

return 0;

}

static int

bytearray_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_Unpack(index, &start, &stop, &step) < 0) {

return -1;

}

slicelen = _PySlice_AdjustIndices(PyByteArray_GET_SIZE(self), &start,

&stop, step);

}

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)) {

int err;

if (PyNumber_Check(values) || PyUnicode_Check(values)) {

PyErr_SetString(PyExc_TypeError,

"can assign only bytes, buffers, or iterables "

"of ints in range(0, 256)");

return -1;

}

/* Make a copy and call this function recursively */

values = PyByteArray_FromObject(values);

if (values == NULL)

return -1;

err = bytearray_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 */

size_t cur;

Py_ssize_t 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 >= (size_t)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 < (size_t)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

bytearray_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_EncodeText(arg, encoding, errors);

if (encoded == NULL)

return -1;

assert(PyBytes_Check(encoded));

}

else {

encoded = arg;

Py_INCREF(arg);

}

new = bytearray_iconcat(self, arg);

Py_DECREF(encoded);

if (new == NULL)

return -1;

Py_DECREF(new);

return 0;

}

#ifdef Py_USING_UNICODE

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_EncodeText(arg, encoding, errors);

if (encoded == NULL)

return -1;

assert(PyBytes_Check(encoded));

new = bytearray_iconcat(self, encoded);

Py_DECREF(encoded);

if (new == NULL)

return -1;

Py_DECREF(new);

return 0;

}

#endif

/* 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_OverflowError);

if (count == -1 && PyErr_Occurred()) {

if (!PyErr_ExceptionMatches(PyExc_TypeError))

return -1;

PyErr_Clear();

}

else if (count < 0) {

PyErr_SetString(PyExc_ValueError, "negative count");

return -1;

}

else {

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) + 1 < self->ob_alloc) {

Py_SIZE(self)++;

PyByteArray_AS_STRING(self)[Py_SIZE(self)] = '\0';

}

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 *

bytearray_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;

PyObject *v;

if (length > (PY_SSIZE_T_MAX - 14) / 4) {

PyErr_SetString(PyExc_OverflowError,

"bytearray object is too large to make repr");

return NULL;

}

newsize = 14 + 4 * length;

v = PyString_FromStringAndSize(NULL, newsize);

if (v == NULL) {

return NULL;

}

else {

register Py_ssize_t i;

register char c;

register char *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 = PyString_AS_STRING(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 - PyString_AS_STRING(v)) >= 5);

c = self->ob_bytes[i];

if (c == '\'' || c == '\\')

*p++ = '\\', *p++ = c;

else if (c == '\t')

*p++ = '\\', *p++ = 't';

else if (c == '\n')