#include "Python.h"

#include "pycore_abstract.h" // _PyIndex_Check()

#include "pycore_bytes_methods.h"

#include "pycore_bytesobject.h"

#include "pycore_ceval.h" // _PyEval_GetBuiltin()

#include "pycore_object.h" // _PyObject_GC_UNTRACK()

#include "pycore_strhex.h" // _Py_strhex_with_sep()

#include "pycore_long.h" // _PyLong_FromUnsignedChar()

#include "bytesobject.h"

char _PyByteArray_empty_string[] = "";

static int

_getbytevalue(PyObject* arg, int *value)

{

int overflow;

long face_value = PyLong_AsLongAndOverflow(arg, &overflow);

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

*value = -1;

return 0;

}

if (face_value < 0 || face_value >= 256) {

/* this includes an overflow in converting to C long */

PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");

*value = -1;

return 0;

}

*value = face_value;

return 1;

}

static int

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

{

void *ptr;

if (view == NULL) {

PyErr_SetString(PyExc_BufferError,

"bytearray_getbuffer: view==NULL argument is obsolete");

return -1;

}

ptr = (void *) PyByteArray_AS_STRING(obj);

/* cannot fail if view != NULL and readonly == 0 */

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

obj->ob_exports++;

return 0;

}

static void

bytearray_releasebuffer(PyByteArrayObject *obj, Py_buffer *view)

{

obj->ob_exports--;

assert(obj->ob_exports >= 0);

}

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;

}

#include "clinic/bytearrayobject.c.h"

PyObject *

PyByteArray_FromObject(PyObject *input)

{

return PyObject_CallOneArg((PyObject *)&PyByteArray_Type, input);

}

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;

}

/* Prevent buffer overflow when setting alloc to size+1. */

if (size == PY_SSIZE_T_MAX) {

return PyErr_NoMemory();

}

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 = PyObject_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_SET_SIZE(new, size);

new->ob_alloc = alloc;

new->ob_start = new->ob_bytes;

new->ob_exports = 0;

return (PyObject *)new;

}

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

}

PyByteArray_Resize(PyObject *self, Py_ssize_t requested_size)

{

void *sval;

PyByteArrayObject *obj = ((PyByteArrayObject *)self);

/* All computations are done unsigned to avoid integer overflows

size_t alloc = (size_t) obj->ob_alloc;

size_t logical_offset = (size_t) (obj->ob_start - obj->ob_bytes);

size_t size = (size_t) requested_size;

assert(self != NULL);

assert(PyByteArray_Check(self));

assert(logical_offset <= alloc);

assert(requested_size >= 0);

if (requested_size == Py_SIZE(self)) {

return 0;

}

if (!_canresize(obj)) {

return -1;

}

if (size + logical_offset + 1 <= alloc) {

/* Current buffer is large enough to host the requested size,

if (size < alloc / 2) {

/* Major downsize; resize down to exact size */

alloc = size + 1;

}

else {

/* Minor downsize; quick exit */

Py_SET_SIZE(self, size);

PyByteArray_AS_STRING(self)[size] = '\0'; /* Trailing null */

return 0;

}

}

else {

/* Need growing, decide on a strategy */

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;

}

}

if (alloc > PY_SSIZE_T_MAX) {

PyErr_NoMemory();

return -1;

}

if (logical_offset > 0) {

sval = PyObject_Malloc(alloc);

if (sval == NULL) {

PyErr_NoMemory();

return -1;

}

memcpy(sval, PyByteArray_AS_STRING(self),

Py_MIN((size_t)requested_size, (size_t)Py_SIZE(self)));

PyObject_Free(obj->ob_bytes);

}

else {

sval = PyObject_Realloc(obj->ob_bytes, alloc);

if (sval == NULL) {

PyErr_NoMemory();

return -1;

}

}

obj->ob_bytes = obj->ob_start = sval;

Py_SET_SIZE(self, size);

obj->ob_alloc = alloc;

obj->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 (PyObject_GetBuffer(a, &va, PyBUF_SIMPLE) != 0 ||

PyObject_GetBuffer(b, &vb, PyBUF_SIMPLE) != 0) {

PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",

Py_TYPE(b)->tp_name, Py_TYPE(a)->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);

// result->ob_bytes is NULL if result is an empty bytearray:

// if va.len + vb.len equals zero.

if (result != NULL && result->ob_bytes != 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;

}

static Py_ssize_t

bytearray_length(PyByteArrayObject *self)

{

return Py_SIZE(self);

}

static PyObject *

bytearray_iconcat(PyByteArrayObject *self, PyObject *other)

{

Py_ssize_t size;

Py_buffer vo;

if (PyObject_GetBuffer(other, &vo, PyBUF_SIMPLE) != 0) {

PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",

Py_TYPE(other)->tp_name, Py_TYPE(self)->tp_name);

return NULL;

}

size = Py_SIZE(self);

if (size > PY_SSIZE_T_MAX - vo.len) {

PyBuffer_Release(&vo);

return PyErr_NoMemory();

}

if (PyByteArray_Resize((PyObject *)self, size + vo.len) < 0) {

PyBuffer_Release(&vo);

return NULL;

}

memcpy(PyByteArray_AS_STRING(self) + size, vo.buf, vo.len);

PyBuffer_Release(&vo);

return Py_NewRef(self);

}

static PyObject *

bytearray_repeat(PyByteArrayObject *self, Py_ssize_t count)

{

if (count < 0)

count = 0;

const Py_ssize_t mysize = Py_SIZE(self);

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

return PyErr_NoMemory();

Py_ssize_t size = mysize * count;

PyByteArrayObject* result = (PyByteArrayObject *)PyByteArray_FromStringAndSize(NULL, size);

const char* buf = PyByteArray_AS_STRING(self);

if (result != NULL && size != 0) {

_PyBytes_Repeat(result->ob_bytes, size, buf, mysize);

}

return (PyObject *)result;

}

static PyObject *

bytearray_irepeat(PyByteArrayObject *self, Py_ssize_t count)

{

if (count < 0)

count = 0;

else if (count == 1) {

return Py_NewRef(self);

}

const Py_ssize_t mysize = Py_SIZE(self);

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

return PyErr_NoMemory();

const Py_ssize_t size = mysize * count;

if (PyByteArray_Resize((PyObject *)self, size) < 0)

return NULL;

char* buf = PyByteArray_AS_STRING(self);

_PyBytes_Repeat(buf, size, buf, mysize);

return Py_NewRef(self);

}

static PyObject *

bytearray_getitem(PyByteArrayObject *self, Py_ssize_t i)

{

if (i < 0 || i >= Py_SIZE(self)) {

PyErr_SetString(PyExc_IndexError, "bytearray index out of range");

return NULL;

}

return _PyLong_FromUnsignedChar((unsigned char)(self->ob_start[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 _PyLong_FromUnsignedChar((unsigned char)(self->ob_start[i]));

}

else if (PySlice_Check(index)) {

Py_ssize_t start, stop, step, slicelength, i;

size_t cur;

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(

PyByteArray_AS_STRING(self) + start, slicelength);

}

else {

char *source_buf = PyByteArray_AS_STRING(self);

char *result_buf;

PyObject *result;

result = PyByteArray_FromStringAndSize(NULL, slicelength);

if (result == NULL)

return NULL;

result_buf = PyByteArray_AS_STRING(result);

for (cur = start, i = 0; i < slicelength;

cur += step, i++) {

result_buf[i] = source_buf[cur];

}

return result;

}

}

else {

PyErr_Format(PyExc_TypeError,

"bytearray indices must be integers or slices, not %.200s",

Py_TYPE(index)->tp_name);

return NULL;

}

}

static int

bytearray_setslice_linear(PyByteArrayObject *self,

Py_ssize_t lo, Py_ssize_t hi,

char *bytes, Py_ssize_t bytes_len)

{

Py_ssize_t avail = hi - lo;

char *buf = PyByteArray_AS_STRING(self);

Py_ssize_t growth = bytes_len - avail;

int res = 0;

assert(avail >= 0);

if (growth < 0) {

if (!_canresize(self))

return -1;

if (lo == 0) {

/* Shrink the buffer by advancing its logical start */

self->ob_start -= growth;

/*

}

else {

/*

memmove(buf + lo + bytes_len, buf + hi,

Py_SIZE(self) - hi);

}

if (PyByteArray_Resize((PyObject *)self,

Py_SIZE(self) + growth) < 0) {

/* Issue #19578: Handling the memory allocation failure here is

if (lo == 0) {

self->ob_start += growth;

return -1;

}

/* memmove() removed bytes, the bytearray object cannot be

Py_SET_SIZE(self, Py_SIZE(self) + growth);

res = -1;

}

buf = PyByteArray_AS_STRING(self);

}

else if (growth > 0) {

if (Py_SIZE(self) > (Py_ssize_t)PY_SSIZE_T_MAX - growth) {

PyErr_NoMemory();

return -1;

}

if (PyByteArray_Resize((PyObject *)self,

Py_SIZE(self) + growth) < 0) {

return -1;

}

buf = PyByteArray_AS_STRING(self);

/* Make the place for the additional bytes */

/*

memmove(buf + lo + bytes_len, buf + hi,

Py_SIZE(self) - lo - bytes_len);

}

if (bytes_len > 0)

memcpy(buf + lo, bytes, bytes_len);

return res;

}

static int

bytearray_setslice(PyByteArrayObject *self, Py_ssize_t lo, Py_ssize_t hi,

PyObject *values)

{

Py_ssize_t 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 (PyObject_GetBuffer(values, &vbytes, PyBUF_SIMPLE) != 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);

res = bytearray_setslice_linear(self, lo, hi, bytes, needed);

if (vbytes.len != -1)

PyBuffer_Release(&vbytes);

return res;

}

static int

bytearray_setitem(PyByteArrayObject *self, Py_ssize_t i, PyObject *value)

{

int ival = -1;

// GH-91153: We need to do this *before* the size check, in case value has a

// nasty __index__ method that changes the size of the bytearray:

if (value && !_getbytevalue(value, &ival)) {

return -1;

}

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

}

assert(0 <= ival && ival < 256);

PyByteArray_AS_STRING(self)[i] = ival;

return 0;

}

static int

bytearray_ass_subscript(PyByteArrayObject *self, PyObject *index, PyObject *values)

{

Py_ssize_t start, stop, step, slicelen, needed;

char *buf, *bytes;

buf = PyByteArray_AS_STRING(self);

if (_PyIndex_Check(index)) {

Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);

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

return -1;

}

int ival = -1;

// GH-91153: We need to do this *before* the size check, in case values

// has a nasty __index__ method that changes the size of the bytearray:

if (values && !_getbytevalue(values, &ival)) {

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 {

assert(0 <= ival && ival < 256);

buf[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_Format(PyExc_TypeError,

"bytearray indices must be integers or slices, not %.200s",

Py_TYPE(index)->tp_name);

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

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

return bytearray_setslice_linear(self, start, stop, bytes, needed);

}

else {

if (needed == 0) {

/* Delete slice */

size_t cur;

Py_ssize_t i;

if (!_canresize(self))

return -1;

if (slicelen == 0)

/* Nothing to do here. */

return 0;

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(buf + cur - i,

buf + cur + 1, lim);

}

/* Move the tail of the bytes, in one chunk */

cur = start + (size_t)slicelen*step;

if (cur < (size_t)PyByteArray_GET_SIZE(self)) {

memmove(buf + cur - slicelen,

buf + 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 i;

size_t cur;

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

buf[cur] = bytes[i];

return 0;

}

}

}

static int

bytearray___init___impl(PyByteArrayObject *self, PyObject *arg,

const char *encoding, const char *errors)

{

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;

}

/* Make a quick exit if no first argument */

if (arg == NULL) {

if (encoding != NULL || errors != NULL) {

PyErr_SetString(PyExc_TypeError,

encoding != NULL ?

"encoding without a string argument" :

"errors without a string argument");

return -1;

}

return 0;

}

if (PyUnicode_Check(arg)) {

/* Encode via the codec registry */

PyObject *encoded, *new;

if (encoding == NULL) {

PyErr_SetString(PyExc_TypeError,

"string argument without an encoding");

return -1;

}

encoded = PyUnicode_AsEncodedString(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;

}

/* If it's not unicode, there can't be encoding or errors */

if (encoding != NULL || errors != NULL) {

PyErr_SetString(PyExc_TypeError,

encoding != NULL ?

"encoding without a string argument" :

"errors without a string argument");

return -1;

}

/* Is it an int? */

if (_PyIndex_Check(arg)) {

count = PyNumber_AsSsize_t(arg, PyExc_OverflowError);

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

if (!PyErr_ExceptionMatches(PyExc_TypeError))

return -1;

PyErr_Clear(); /* fall through */

}

else {

if (count < 0) {

PyErr_SetString(PyExc_ValueError, "negative count");

return -1;

}

if (count > 0) {

if (PyByteArray_Resize((PyObject *)self, count))

return -1;

memset(PyByteArray_AS_STRING(self), 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(PyByteArray_AS_STRING(self),

&view, size, 'C') < 0)

goto fail;

PyBuffer_Release(&view);

return 0;

fail:

PyBuffer_Release(&view);

return -1;

}

if (PyList_CheckExact(arg) || PyTuple_CheckExact(arg)) {

Py_ssize_t size = PySequence_Fast_GET_SIZE(arg);

if (PyByteArray_Resize((PyObject *)self, size) < 0) {

return -1;

}

PyObject **items = PySequence_Fast_ITEMS(arg);

char *s = PyByteArray_AS_STRING(self);

for (Py_ssize_t i = 0; i < size; i++) {

int value;

if (!PyLong_CheckExact(items[i])) {

/* Resize to 0 and go through slowpath */

if (Py_SIZE(self) != 0) {

if (PyByteArray_Resize((PyObject *)self, 0) < 0) {

return -1;

}

}

goto slowpath;

}

int rc = _getbytevalue(items[i], &value);

if (!rc) {

return -1;

}

s[i] = value;

}

return 0;

}

slowpath:

/* Get the iterator */

it = PyObject_GetIter(arg);

if (it == NULL) {

if (PyErr_ExceptionMatches(PyExc_TypeError)) {

PyErr_Format(PyExc_TypeError,

"cannot convert '%.200s' object to bytearray",

Py_TYPE(arg)->tp_name);

}

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_SET_SIZE(self, Py_SIZE(self) + 1);

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

}

else if (PyByteArray_Resize((PyObject *)self, Py_SIZE(self)+1) < 0)

goto error;

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

}

static PyObject *

bytearray_repr(PyByteArrayObject *self)

{

const char *className = _PyType_Name(Py_TYPE(self));

const char *quote_prefix = "(b";

const char *quote_postfix = ")";

Py_ssize_t length = Py_SIZE(self);

/* 6 == strlen(quote_prefix) + 2 + strlen(quote_postfix) + 1 */

Py_ssize_t newsize;

PyObject *v;

Py_ssize_t i;

char *bytes;

char c;

char *p;

int quote;

char *test, *start;

char *buffer;

newsize = strlen(className);

if (length > (PY_SSIZE_T_MAX - 6 - newsize) / 4) {

PyErr_SetString(PyExc_OverflowError,

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

return NULL;

}

newsize += 6 + length * 4;

buffer = PyObject_Malloc(newsize);

if (buffer == NULL) {

PyErr_NoMemory();

return NULL;

}

/* Figure out which quote to use; single is preferred */

quote = '\'';

start = PyByteArray_AS_STRING(self);

for (test = start; test < start+length; ++test) {

if (*test == '"') {

quote = '\''; /* back to single */

break;

}

else if (*test == '\'')

quote = '"';

}

p = buffer;

while (*className)

*p++ = *className++;

while (*quote_prefix)

*p++ = *quote_prefix++;

*p++ = quote;

bytes = PyByteArray_AS_STRING(self);

for (i = 0; i < length; i++) {

/* There's at least enough room for a hex escape

assert(newsize - (p - buffer) >= 5);

c = 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++ = Py_hexdigits[(c & 0xf0) >> 4];

*p++ = Py_hexdigits[c & 0xf];

}