#define PY_SSIZE_T_CLEAN

#include "Python.h"

#include "structmember.h"

#include "bytes_methods.h"

#include "bytesobject.h"

#include "pystrhex.h"

char _PyByteArray_empty_string[] = "";

PyByteArray_Fini(void)

{

}

PyByteArray_Init(void)

{

return 1;

}

static int

_getbytevalue(PyObject* arg, int *value)

{

long face_value;

if (PyLong_Check(arg)) {

face_value = PyLong_AsLong(arg);

} else {

PyObject *index = PyNumber_Index(arg);

if (index == NULL) {

PyErr_Format(PyExc_TypeError, "an integer is required");

*value = -1;

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

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

}

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

}

/* 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_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_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(requested_size, 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_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);

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;

}

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

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;

char *buf;

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 (PyByteArray_Resize((PyObject *)self, size) < 0)

return NULL;

buf = PyByteArray_AS_STRING(self);

if (mysize == 1)

memset(buf, buf[0], size);

else {

Py_ssize_t i;

for (i = 1; i < count; i++)

memcpy(buf + i*mysize, buf, 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 PyLong_FromLong((unsigned char)(PyByteArray_AS_STRING(self)[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_FromLong((unsigned char)(PyByteArray_AS_STRING(self)[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(

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

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;

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;

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;

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(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 (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 or 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_OverflowError))

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;

}

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

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 *quote_prefix = "bytearray(b";

const char *quote_postfix = ")";

Py_ssize_t length = Py_SIZE(self);

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

size_t newsize;

PyObject *v;

Py_ssize_t i;

char *bytes;

char c;

char *p;

int quote;

char *test, *start;

char *buffer;

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

PyErr_SetString(PyExc_OverflowError,

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

return NULL;

}

newsize = 15 + 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 (*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];

}

else

*p++ = c;

}

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

*p++ = quote;

while (*quote_postfix) {

*p++ = *quote_postfix++;

}

v = PyUnicode_DecodeASCII(buffer, p - buffer, NULL);

PyObject_Free(buffer);

return v;

}

static PyObject *

bytearray_str(PyObject *op)

{

if (Py_BytesWarningFlag) {

if (PyErr_WarnEx(PyExc_BytesWarning,

"str() on a bytearray instance", 1))

return NULL;

}

return bytearray_repr((PyByteArrayObject*)op);

}

static PyObject *

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

/* Bytes can be compared to anything that supports the (binary)

rc = PyObject_IsInstance(self, (PyObject*)&PyUnicode_Type);

if (!rc)

rc = PyObject_IsInstance(other, (PyObject*)&PyUnicode_Type);

if (rc < 0)

return NULL;

if (rc) {