/* PyByteArray (bytearray) implementation */

#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_critical_section.h"

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

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

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

#include "pycore_pyatomic_ft_wrappers.h"

#include "bytesobject.h"

/*[clinic input]

class bytearray "PyByteArrayObject *" "&PyByteArray_Type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=5535b77c37a119e0]*/

/* Max number of bytes a bytearray can contain */

#define PyByteArray_SIZE_MAX ((Py_ssize_t)(PY_SSIZE_T_MAX - _PyBytesObject_SIZE))

/* Helpers */

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 void

bytearray_reinit_from_bytes(PyByteArrayObject *self, Py_ssize_t size,

Py_ssize_t alloc) {

self->ob_bytes = self->ob_start = PyBytes_AS_STRING(self->ob_bytes_object);

Py_SET_SIZE(self, size);

FT_ATOMIC_STORE_SSIZE_RELAXED(self->ob_alloc, alloc);

}

static int

bytearray_getbuffer_lock_held(PyObject *self, Py_buffer *view, int flags)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

PyByteArrayObject *obj = _PyByteArray_CAST(self);

if (view == NULL) {

PyErr_SetString(PyExc_BufferError,

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

return -1;

}

void *ptr = (void *) PyByteArray_AS_STRING(obj);

if (PyBuffer_FillInfo(view, (PyObject*)obj, ptr, Py_SIZE(obj), 0, flags) < 0) {

return -1;

}

obj->ob_exports++;

return 0;

}

static int

bytearray_getbuffer(PyObject *self, Py_buffer *view, int flags)

{

int ret;

Py_BEGIN_CRITICAL_SECTION(self);

ret = bytearray_getbuffer_lock_held(self, view, flags);

Py_END_CRITICAL_SECTION();

return ret;

}

static void

bytearray_releasebuffer(PyObject *self, Py_buffer *view)

{

Py_BEGIN_CRITICAL_SECTION(self);

PyByteArrayObject *obj = _PyByteArray_CAST(self);

obj->ob_exports--;

assert(obj->ob_exports >= 0);

Py_END_CRITICAL_SECTION();

}

typedef PyObject* (*_ba_bytes_op)(const char *buf, Py_ssize_t len,

PyObject *sub, Py_ssize_t start,

Py_ssize_t end);

static PyObject *

_bytearray_with_buffer(PyByteArrayObject *self, _ba_bytes_op op, PyObject *sub,

Py_ssize_t start, Py_ssize_t end)

{

PyObject *res;

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

/* Increase exports to prevent bytearray storage from changing during op. */

self->ob_exports++;

res = op(PyByteArray_AS_STRING(self), Py_SIZE(self), sub, start, end);

self->ob_exports--;

return res;

}

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"

/* Direct API functions */

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;

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;

}

/* Fill values used in bytearray_dealloc.

In an optimized build the memory isn't zeroed and ob_exports would be

uninitialized when when PyBytes_FromStringAndSize errored leading to

intermittent test failures. */

new->ob_exports = 0;

/* Optimization: size=0 bytearray should not allocate space

PyBytes_FromStringAndSize returns the empty bytes global when size=0 so

no allocation occurs. */

new->ob_bytes_object = PyBytes_FromStringAndSize(NULL, size);

if (new->ob_bytes_object == NULL) {

Py_DECREF(new);

return NULL;

}

bytearray_reinit_from_bytes(new, size, size);

if (bytes != NULL && size > 0) {

memcpy(new->ob_bytes, bytes, size);

}

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

}

static int

bytearray_resize_lock_held(PyObject *self, Py_ssize_t requested_size)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

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

/* All computations are done unsigned to avoid integer overflows

(see issue #22335). */

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

if (requested_size < 0) {

PyErr_Format(PyExc_ValueError,

"Can only resize to positive sizes, got %zd", requested_size);

return -1;

}

if (requested_size == Py_SIZE(self)) {

return 0;

}

if (!_canresize(obj)) {

return -1;

}

if (size + logical_offset <= alloc) {

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

decide on a strategy. */

if (size < alloc / 2) {

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

alloc = size;

}

else {

/* Minor downsize; quick exit */

Py_SET_SIZE(self, size);

/* Add mid-buffer null; end provided by bytes. */

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;

}

}

if (alloc > PyByteArray_SIZE_MAX) {

PyErr_NoMemory();

return -1;

}

/* Re-align data to the start of the allocation. */

if (logical_offset > 0) {

/* optimization tradeoff: This is faster than a new allocation when

the number of bytes being removed in a resize is small; for large

size changes it may be better to just make a new bytes object as

_PyBytes_Resize will do a malloc + memcpy internally. */

memmove(obj->ob_bytes, obj->ob_start,

Py_MIN(requested_size, Py_SIZE(self)));

}

int ret = _PyBytes_Resize(&obj->ob_bytes_object, alloc);

if (ret == -1) {

obj->ob_bytes_object = Py_GetConstant(Py_CONSTANT_EMPTY_BYTES);

size = alloc = 0;

}

bytearray_reinit_from_bytes(obj, size, alloc);

if (alloc != size) {

/* Add mid-buffer null; end provided by bytes. */

obj->ob_bytes[size] = '\0';

}

return ret;

}

int

PyByteArray_Resize(PyObject *self, Py_ssize_t requested_size)

{

int ret;

Py_BEGIN_CRITICAL_SECTION(self);

ret = bytearray_resize_lock_held(self, requested_size);

Py_END_CRITICAL_SECTION();

return ret;

}

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

}

/* Functions stuffed into the type object */

static Py_ssize_t

bytearray_length(PyObject *op)

{

return PyByteArray_GET_SIZE(op);

}

static PyObject *

bytearray_iconcat_lock_held(PyObject *op, PyObject *other)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

PyByteArrayObject *self = _PyByteArray_CAST(op);

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;

}

Py_ssize_t size = Py_SIZE(self);

if (size > PyByteArray_SIZE_MAX - vo.len) {

PyBuffer_Release(&vo);

return PyErr_NoMemory();

}

if (bytearray_resize_lock_held((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_iconcat(PyObject *op, PyObject *other)

{

PyObject *ret;

Py_BEGIN_CRITICAL_SECTION(op);

ret = bytearray_iconcat_lock_held(op, other);

Py_END_CRITICAL_SECTION();

return ret;

}

static PyObject *

bytearray_repeat_lock_held(PyObject *op, Py_ssize_t count)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

PyByteArrayObject *self = _PyByteArray_CAST(op);

if (count < 0) {

count = 0;

}

const Py_ssize_t mysize = Py_SIZE(self);

if (count > 0 && mysize > PyByteArray_SIZE_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_repeat(PyObject *op, Py_ssize_t count)

{

PyObject *ret;

Py_BEGIN_CRITICAL_SECTION(op);

ret = bytearray_repeat_lock_held(op, count);

Py_END_CRITICAL_SECTION();

return ret;

}

static PyObject *

bytearray_irepeat_lock_held(PyObject *op, Py_ssize_t count)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

PyByteArrayObject *self = _PyByteArray_CAST(op);

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 > PyByteArray_SIZE_MAX / count) {

return PyErr_NoMemory();

}

const Py_ssize_t size = mysize * count;

if (bytearray_resize_lock_held((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_irepeat(PyObject *op, Py_ssize_t count)

{

PyObject *ret;

Py_BEGIN_CRITICAL_SECTION(op);

ret = bytearray_irepeat_lock_held(op, count);

Py_END_CRITICAL_SECTION();

return ret;

}

static PyObject *

bytearray_getitem_lock_held(PyObject *op, Py_ssize_t i)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

PyByteArrayObject *self = _PyByteArray_CAST(op);

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_getitem(PyObject *op, Py_ssize_t i)

{

PyObject *ret;

Py_BEGIN_CRITICAL_SECTION(op);

ret = bytearray_getitem_lock_held(op, i);

Py_END_CRITICAL_SECTION();

return ret;

}

static PyObject *

bytearray_subscript_lock_held(PyObject *op, PyObject *index)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

PyByteArrayObject *self = _PyByteArray_CAST(op);

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

bytearray_subscript(PyObject *op, PyObject *index)

{

PyObject *ret;

Py_BEGIN_CRITICAL_SECTION(op);

ret = bytearray_subscript_lock_held(op, index);

Py_END_CRITICAL_SECTION();

return ret;

}

static int

bytearray_setslice_linear(PyByteArrayObject *self,

Py_ssize_t lo, Py_ssize_t hi,

char *bytes, Py_ssize_t bytes_len)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(self);

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;

/*

0 lo hi old_size

| |<----avail----->|<-----tail------>|

| |<-bytes_len->|<-----tail------>|

0 new_lo new_hi new_size

*/

}

else {

/*

0 lo hi old_size

| |<----avail----->|<-----tomove------>|

| |<-bytes_len->|<-----tomove------>|

0 lo new_hi new_size

*/

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

Py_SIZE(self) - hi);

}

if (bytearray_resize_lock_held((PyObject *)self,

Py_SIZE(self) + growth) < 0) {

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

tricky here because the bytearray object has already been

modified. Depending on growth and lo, the behaviour is

different.

If growth < 0 and lo != 0, the operation is completed, but a

MemoryError is still raised and the memory block is not

shrunk. Otherwise, the bytearray is restored in its previous

state and a MemoryError is raised. */

if (lo == 0) {

self->ob_start += growth;

return -1;

}

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

restored in its previous state. */

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

res = -1;

}

buf = PyByteArray_AS_STRING(self);

}

else if (growth > 0) {

if (Py_SIZE(self) > PyByteArray_SIZE_MAX - growth) {

PyErr_NoMemory();

return -1;

}

if (bytearray_resize_lock_held((PyObject *)self,

Py_SIZE(self) + growth) < 0) {

return -1;

}

buf = PyByteArray_AS_STRING(self);

/* Make the place for the additional bytes */

/*

0 lo hi old_size

| |<-avail->|<-----tomove------>|

| |<---bytes_len-->|<-----tomove------>|

0 lo new_hi new_size

*/

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

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_lock_held(PyObject *op, Py_ssize_t i, PyObject *value)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

PyByteArrayObject *self = _PyByteArray_CAST(op);

// 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:

int ival = -1;

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_setitem(PyObject *op, Py_ssize_t i, PyObject *value)

{

int ret;

Py_BEGIN_CRITICAL_SECTION(op);

ret = bytearray_setitem_lock_held(op, i, value);

Py_END_CRITICAL_SECTION();

return ret;

}

static int

bytearray_ass_subscript_lock_held(PyObject *op, PyObject *index, PyObject *values)

{

_Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(op);

PyByteArrayObject *self = _PyByteArray_CAST(op);

Py_ssize_t start, stop, step, slicelen;

// Do not store a reference to the internal buffer since

// index.__index__() or _getbytevalue() may alter 'self'.

// See https://github.com/python/cpython/issues/91153.

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

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

}

char *bytes;

Py_ssize_t needed;

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_lock_held((PyObject*)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;

char *buf = PyByteArray_AS_STRING(self);

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 (bytearray_resize_lock_held((PyObject *)self,

PyByteArray_GET_SIZE(self) - slicelen) < 0)

return -1;

return 0;

}

else {

/* Assign slice */

Py_ssize_t i;

size_t cur;

char *buf = PyByteArray_AS_STRING(self);

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_ass_subscript(PyObject *op, PyObject *index, PyObject *values)

{

int ret;

if (values != NULL && PyByteArray_Check(values)) {

Py_BEGIN_CRITICAL_SECTION2(op, values);

ret = bytearray_ass_subscript_lock_held(op, index, values);

Py_END_CRITICAL_SECTION2();

}

else {

Py_BEGIN_CRITICAL_SECTION(op);

ret = bytearray_ass_subscript_lock_held(op, index, values);

Py_END_CRITICAL_SECTION();

}

return ret;

}

/*[clinic input]

bytearray.__init__

source as arg: object = NULL

encoding: str = NULL

errors: str = NULL

[clinic start generated code]*/

static int

bytearray___init___impl(PyByteArrayObject *self, PyObject *arg,

const char *encoding, const char *errors)

/*[clinic end generated code: output=4ce1304649c2f8b3 input=1141a7122eefd7b9]*/

{

Py_ssize_t count;

PyObject *it;

PyObject *(*iternext)(PyObject *);

/* First __init__; set ob_bytes_object so ob_bytes is always non-null. */

if (self->ob_bytes_object == NULL) {

self->ob_bytes_object = Py_GetConstant(Py_CONSTANT_EMPTY_BYTES);

bytearray_reinit_from_bytes(self, 0, 0);

self->ob_exports = 0;

}

if (Py_SIZE(self) != 0) {

/* Empty previous contents (yes, do this first of all!) */

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

return -1;

}

/* Should be caused by first init or the resize to 0. */

assert(self->ob_bytes_object == Py_GetConstantBorrowed(Py_CONSTANT_EMPTY_BYTES));

assert(self->ob_exports == 0);

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

/* Most encodes return a new unique bytes, just use it as buffer. */

if (_PyObject_IsUniquelyReferenced(encoded)

&& PyBytes_CheckExact(encoded))

{

Py_ssize_t size = Py_SIZE(encoded);

self->ob_bytes_object = encoded;

bytearray_reinit_from_bytes(self, size, size);

return 0;

}

new = bytearray_iconcat((PyObject*)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 {