1/* PyByteArray (bytearray) implementation */
2
3#define PY_SSIZE_T_CLEAN
4#include "Python.h"
5#include "structmember.h"
6#include "bytes_methods.h"
7#include "bytesobject.h"
8#include "pystrhex.h"
9
10/*[clinic input]
11class bytearray "PyByteArrayObject *" "&PyByteArray_Type"
12[clinic start generated code]*/
13/*[clinic end generated code: output=da39a3ee5e6b4b0d input=5535b77c37a119e0]*/
14
15char _PyByteArray_empty_string[] = "";
16
17void
18PyByteArray_Fini(void)
19{
20}
21
22int
23PyByteArray_Init(void)
24{
25    return 1;
26}
27
28/* end nullbytes support */
29
30/* Helpers */
31
32static int
33_getbytevalue(PyObject* arg, int *value)
34{
35    long face_value;
36
37    if (PyLong_Check(arg)) {
38        face_value = PyLong_AsLong(arg);
39    } else {
40        PyObject *index = PyNumber_Index(arg);
41        if (index == NULL) {
42            PyErr_Format(PyExc_TypeError, "an integer is required");
43            *value = -1;
44            return 0;
45        }
46        face_value = PyLong_AsLong(index);
47        Py_DECREF(index);
48    }
49
50    if (face_value < 0 || face_value >= 256) {
51        /* this includes the OverflowError in case the long is too large */
52        PyErr_SetString(PyExc_ValueError, "byte must be in range(0, 256)");
53        *value = -1;
54        return 0;
55    }
56
57    *value = face_value;
58    return 1;
59}
60
61static int
62bytearray_getbuffer(PyByteArrayObject *obj, Py_buffer *view, int flags)
63{
64    void *ptr;
65    if (view == NULL) {
66        PyErr_SetString(PyExc_BufferError,
67            "bytearray_getbuffer: view==NULL argument is obsolete");
68        return -1;
69    }
70    ptr = (void *) PyByteArray_AS_STRING(obj);
71    /* cannot fail if view != NULL and readonly == 0 */
72    (void)PyBuffer_FillInfo(view, (PyObject*)obj, ptr, Py_SIZE(obj), 0, flags);
73    obj->ob_exports++;
74    return 0;
75}
76
77static void
78bytearray_releasebuffer(PyByteArrayObject *obj, Py_buffer *view)
79{
80    obj->ob_exports--;
81}
82
83static int
84_canresize(PyByteArrayObject *self)
85{
86    if (self->ob_exports > 0) {
87        PyErr_SetString(PyExc_BufferError,
88                "Existing exports of data: object cannot be re-sized");
89        return 0;
90    }
91    return 1;
92}
93
94#include "clinic/bytearrayobject.c.h"
95
96/* Direct API functions */
97
98PyObject *
99PyByteArray_FromObject(PyObject *input)
100{
101    return PyObject_CallFunctionObjArgs((PyObject *)&PyByteArray_Type,
102                                        input, NULL);
103}
104
105PyObject *
106PyByteArray_FromStringAndSize(const char *bytes, Py_ssize_t size)
107{
108    PyByteArrayObject *new;
109    Py_ssize_t alloc;
110
111    if (size < 0) {
112        PyErr_SetString(PyExc_SystemError,
113            "Negative size passed to PyByteArray_FromStringAndSize");
114        return NULL;
115    }
116
117    /* Prevent buffer overflow when setting alloc to size+1. */
118    if (size == PY_SSIZE_T_MAX) {
119        return PyErr_NoMemory();
120    }
121
122    new = PyObject_New(PyByteArrayObject, &PyByteArray_Type);
123    if (new == NULL)
124        return NULL;
125
126    if (size == 0) {
127        new->ob_bytes = NULL;
128        alloc = 0;
129    }
130    else {
131        alloc = size + 1;
132        new->ob_bytes = PyObject_Malloc(alloc);
133        if (new->ob_bytes == NULL) {
134            Py_DECREF(new);
135            return PyErr_NoMemory();
136        }
137        if (bytes != NULL && size > 0)
138            memcpy(new->ob_bytes, bytes, size);
139        new->ob_bytes[size] = '\0';  /* Trailing null byte */
140    }
141    Py_SIZE(new) = size;
142    new->ob_alloc = alloc;
143    new->ob_start = new->ob_bytes;
144    new->ob_exports = 0;
145
146    return (PyObject *)new;
147}
148
149Py_ssize_t
150PyByteArray_Size(PyObject *self)
151{
152    assert(self != NULL);
153    assert(PyByteArray_Check(self));
154
155    return PyByteArray_GET_SIZE(self);
156}
157
158char  *
159PyByteArray_AsString(PyObject *self)
160{
161    assert(self != NULL);
162    assert(PyByteArray_Check(self));
163
164    return PyByteArray_AS_STRING(self);
165}
166
167int
168PyByteArray_Resize(PyObject *self, Py_ssize_t requested_size)
169{
170    void *sval;
171    PyByteArrayObject *obj = ((PyByteArrayObject *)self);
172    /* All computations are done unsigned to avoid integer overflows
173       (see issue #22335). */
174    size_t alloc = (size_t) obj->ob_alloc;
175    size_t logical_offset = (size_t) (obj->ob_start - obj->ob_bytes);
176    size_t size = (size_t) requested_size;
177
178    assert(self != NULL);
179    assert(PyByteArray_Check(self));
180    assert(logical_offset <= alloc);
181    assert(requested_size >= 0);
182
183    if (requested_size == Py_SIZE(self)) {
184        return 0;
185    }
186    if (!_canresize(obj)) {
187        return -1;
188    }
189
190    if (size + logical_offset + 1 <= alloc) {
191        /* Current buffer is large enough to host the requested size,
192           decide on a strategy. */
193        if (size < alloc / 2) {
194            /* Major downsize; resize down to exact size */
195            alloc = size + 1;
196        }
197        else {
198            /* Minor downsize; quick exit */
199            Py_SIZE(self) = size;
200            PyByteArray_AS_STRING(self)[size] = '\0'; /* Trailing null */
201            return 0;
202        }
203    }
204    else {
205        /* Need growing, decide on a strategy */
206        if (size <= alloc * 1.125) {
207            /* Moderate upsize; overallocate similar to list_resize() */
208            alloc = size + (size >> 3) + (size < 9 ? 3 : 6);
209        }
210        else {
211            /* Major upsize; resize up to exact size */
212            alloc = size + 1;
213        }
214    }
215    if (alloc > PY_SSIZE_T_MAX) {
216        PyErr_NoMemory();
217        return -1;
218    }
219
220    if (logical_offset > 0) {
221        sval = PyObject_Malloc(alloc);
222        if (sval == NULL) {
223            PyErr_NoMemory();
224            return -1;
225        }
226        memcpy(sval, PyByteArray_AS_STRING(self),
227               Py_MIN(requested_size, Py_SIZE(self)));
228        PyObject_Free(obj->ob_bytes);
229    }
230    else {
231        sval = PyObject_Realloc(obj->ob_bytes, alloc);
232        if (sval == NULL) {
233            PyErr_NoMemory();
234            return -1;
235        }
236    }
237
238    obj->ob_bytes = obj->ob_start = sval;
239    Py_SIZE(self) = size;
240    obj->ob_alloc = alloc;
241    obj->ob_bytes[size] = '\0'; /* Trailing null byte */
242
243    return 0;
244}
245
246PyObject *
247PyByteArray_Concat(PyObject *a, PyObject *b)
248{
249    Py_buffer va, vb;
250    PyByteArrayObject *result = NULL;
251
252    va.len = -1;
253    vb.len = -1;
254    if (PyObject_GetBuffer(a, &va, PyBUF_SIMPLE) != 0 ||
255        PyObject_GetBuffer(b, &vb, PyBUF_SIMPLE) != 0) {
256            PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
257                         Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
258            goto done;
259    }
260
261    if (va.len > PY_SSIZE_T_MAX - vb.len) {
262        PyErr_NoMemory();
263        goto done;
264    }
265
266    result = (PyByteArrayObject *) \
267        PyByteArray_FromStringAndSize(NULL, va.len + vb.len);
268    if (result != NULL) {
269        memcpy(result->ob_bytes, va.buf, va.len);
270        memcpy(result->ob_bytes + va.len, vb.buf, vb.len);
271    }
272
273  done:
274    if (va.len != -1)
275        PyBuffer_Release(&va);
276    if (vb.len != -1)
277        PyBuffer_Release(&vb);
278    return (PyObject *)result;
279}
280
281/* Functions stuffed into the type object */
282
283static Py_ssize_t
284bytearray_length(PyByteArrayObject *self)
285{
286    return Py_SIZE(self);
287}
288
289static PyObject *
290bytearray_iconcat(PyByteArrayObject *self, PyObject *other)
291{
292    Py_ssize_t size;
293    Py_buffer vo;
294
295    if (PyObject_GetBuffer(other, &vo, PyBUF_SIMPLE) != 0) {
296        PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",
297                     Py_TYPE(other)->tp_name, Py_TYPE(self)->tp_name);
298        return NULL;
299    }
300
301    size = Py_SIZE(self);
302    if (size > PY_SSIZE_T_MAX - vo.len) {
303        PyBuffer_Release(&vo);
304        return PyErr_NoMemory();
305    }
306    if (PyByteArray_Resize((PyObject *)self, size + vo.len) < 0) {
307        PyBuffer_Release(&vo);
308        return NULL;
309    }
310    memcpy(PyByteArray_AS_STRING(self) + size, vo.buf, vo.len);
311    PyBuffer_Release(&vo);
312    Py_INCREF(self);
313    return (PyObject *)self;
314}
315
316static PyObject *
317bytearray_repeat(PyByteArrayObject *self, Py_ssize_t count)
318{
319    PyByteArrayObject *result;
320    Py_ssize_t mysize;
321    Py_ssize_t size;
322
323    if (count < 0)
324        count = 0;
325    mysize = Py_SIZE(self);
326    if (count > 0 && mysize > PY_SSIZE_T_MAX / count)
327        return PyErr_NoMemory();
328    size = mysize * count;
329    result = (PyByteArrayObject *)PyByteArray_FromStringAndSize(NULL, size);
330    if (result != NULL && size != 0) {
331        if (mysize == 1)
332            memset(result->ob_bytes, self->ob_bytes[0], size);
333        else {
334            Py_ssize_t i;
335            for (i = 0; i < count; i++)
336                memcpy(result->ob_bytes + i*mysize, self->ob_bytes, mysize);
337        }
338    }
339    return (PyObject *)result;
340}
341
342static PyObject *
343bytearray_irepeat(PyByteArrayObject *self, Py_ssize_t count)
344{
345    Py_ssize_t mysize;
346    Py_ssize_t size;
347    char *buf;
348
349    if (count < 0)
350        count = 0;
351    mysize = Py_SIZE(self);
352    if (count > 0 && mysize > PY_SSIZE_T_MAX / count)
353        return PyErr_NoMemory();
354    size = mysize * count;
355    if (PyByteArray_Resize((PyObject *)self, size) < 0)
356        return NULL;
357
358    buf = PyByteArray_AS_STRING(self);
359    if (mysize == 1)
360        memset(buf, buf[0], size);
361    else {
362        Py_ssize_t i;
363        for (i = 1; i < count; i++)
364            memcpy(buf + i*mysize, buf, mysize);
365    }
366
367    Py_INCREF(self);
368    return (PyObject *)self;
369}
370
371static PyObject *
372bytearray_getitem(PyByteArrayObject *self, Py_ssize_t i)
373{
374    if (i < 0)
375        i += Py_SIZE(self);
376    if (i < 0 || i >= Py_SIZE(self)) {
377        PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
378        return NULL;
379    }
380    return PyLong_FromLong((unsigned char)(PyByteArray_AS_STRING(self)[i]));
381}
382
383static PyObject *
384bytearray_subscript(PyByteArrayObject *self, PyObject *index)
385{
386    if (PyIndex_Check(index)) {
387        Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);
388
389        if (i == -1 && PyErr_Occurred())
390            return NULL;
391
392        if (i < 0)
393            i += PyByteArray_GET_SIZE(self);
394
395        if (i < 0 || i >= Py_SIZE(self)) {
396            PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
397            return NULL;
398        }
399        return PyLong_FromLong((unsigned char)(PyByteArray_AS_STRING(self)[i]));
400    }
401    else if (PySlice_Check(index)) {
402        Py_ssize_t start, stop, step, slicelength, cur, i;
403        if (PySlice_GetIndicesEx(index,
404                                 PyByteArray_GET_SIZE(self),
405                                 &start, &stop, &step, &slicelength) < 0) {
406            return NULL;
407        }
408
409        if (slicelength <= 0)
410            return PyByteArray_FromStringAndSize("", 0);
411        else if (step == 1) {
412            return PyByteArray_FromStringAndSize(
413                PyByteArray_AS_STRING(self) + start, slicelength);
414        }
415        else {
416            char *source_buf = PyByteArray_AS_STRING(self);
417            char *result_buf;
418            PyObject *result;
419
420            result = PyByteArray_FromStringAndSize(NULL, slicelength);
421            if (result == NULL)
422                return NULL;
423
424            result_buf = PyByteArray_AS_STRING(result);
425            for (cur = start, i = 0; i < slicelength;
426                 cur += step, i++) {
427                     result_buf[i] = source_buf[cur];
428            }
429            return result;
430        }
431    }
432    else {
433        PyErr_Format(PyExc_TypeError,
434                     "bytearray indices must be integers or slices, not %.200s",
435                     Py_TYPE(index)->tp_name);
436        return NULL;
437    }
438}
439
440static int
441bytearray_setslice_linear(PyByteArrayObject *self,
442                          Py_ssize_t lo, Py_ssize_t hi,
443                          char *bytes, Py_ssize_t bytes_len)
444{
445    Py_ssize_t avail = hi - lo;
446    char *buf = PyByteArray_AS_STRING(self);
447    Py_ssize_t growth = bytes_len - avail;
448    int res = 0;
449    assert(avail >= 0);
450
451    if (growth < 0) {
452        if (!_canresize(self))
453            return -1;
454
455        if (lo == 0) {
456            /* Shrink the buffer by advancing its logical start */
457            self->ob_start -= growth;
458            /*
459              0   lo               hi             old_size
460              |   |<----avail----->|<-----tail------>|
461              |      |<-bytes_len->|<-----tail------>|
462              0    new_lo         new_hi          new_size
463            */
464        }
465        else {
466            /*
467              0   lo               hi               old_size
468              |   |<----avail----->|<-----tomove------>|
469              |   |<-bytes_len->|<-----tomove------>|
470              0   lo         new_hi              new_size
471            */
472            memmove(buf + lo + bytes_len, buf + hi,
473                    Py_SIZE(self) - hi);
474        }
475        if (PyByteArray_Resize((PyObject *)self,
476                               Py_SIZE(self) + growth) < 0) {
477            /* Issue #19578: Handling the memory allocation failure here is
478               tricky here because the bytearray object has already been
479               modified. Depending on growth and lo, the behaviour is
480               different.
481
482               If growth < 0 and lo != 0, the operation is completed, but a
483               MemoryError is still raised and the memory block is not
484               shrunk. Otherwise, the bytearray is restored in its previous
485               state and a MemoryError is raised. */
486            if (lo == 0) {
487                self->ob_start += growth;
488                return -1;
489            }
490            /* memmove() removed bytes, the bytearray object cannot be
491               restored in its previous state. */
492            Py_SIZE(self) += growth;
493            res = -1;
494        }
495        buf = PyByteArray_AS_STRING(self);
496    }
497    else if (growth > 0) {
498        if (Py_SIZE(self) > (Py_ssize_t)PY_SSIZE_T_MAX - growth) {
499            PyErr_NoMemory();
500            return -1;
501        }
502
503        if (PyByteArray_Resize((PyObject *)self,
504                               Py_SIZE(self) + growth) < 0) {
505            return -1;
506        }
507        buf = PyByteArray_AS_STRING(self);
508        /* Make the place for the additional bytes */
509        /*
510          0   lo        hi               old_size
511          |   |<-avail->|<-----tomove------>|
512          |   |<---bytes_len-->|<-----tomove------>|
513          0   lo            new_hi              new_size
514         */
515        memmove(buf + lo + bytes_len, buf + hi,
516                Py_SIZE(self) - lo - bytes_len);
517    }
518
519    if (bytes_len > 0)
520        memcpy(buf + lo, bytes, bytes_len);
521    return res;
522}
523
524static int
525bytearray_setslice(PyByteArrayObject *self, Py_ssize_t lo, Py_ssize_t hi,
526               PyObject *values)
527{
528    Py_ssize_t needed;
529    void *bytes;
530    Py_buffer vbytes;
531    int res = 0;
532
533    vbytes.len = -1;
534    if (values == (PyObject *)self) {
535        /* Make a copy and call this function recursively */
536        int err;
537        values = PyByteArray_FromObject(values);
538        if (values == NULL)
539            return -1;
540        err = bytearray_setslice(self, lo, hi, values);
541        Py_DECREF(values);
542        return err;
543    }
544    if (values == NULL) {
545        /* del b[lo:hi] */
546        bytes = NULL;
547        needed = 0;
548    }
549    else {
550        if (PyObject_GetBuffer(values, &vbytes, PyBUF_SIMPLE) != 0) {
551            PyErr_Format(PyExc_TypeError,
552                         "can't set bytearray slice from %.100s",
553                         Py_TYPE(values)->tp_name);
554            return -1;
555        }
556        needed = vbytes.len;
557        bytes = vbytes.buf;
558    }
559
560    if (lo < 0)
561        lo = 0;
562    if (hi < lo)
563        hi = lo;
564    if (hi > Py_SIZE(self))
565        hi = Py_SIZE(self);
566
567    res = bytearray_setslice_linear(self, lo, hi, bytes, needed);
568    if (vbytes.len != -1)
569        PyBuffer_Release(&vbytes);
570    return res;
571}
572
573static int
574bytearray_setitem(PyByteArrayObject *self, Py_ssize_t i, PyObject *value)
575{
576    int ival;
577
578    if (i < 0)
579        i += Py_SIZE(self);
580
581    if (i < 0 || i >= Py_SIZE(self)) {
582        PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
583        return -1;
584    }
585
586    if (value == NULL)
587        return bytearray_setslice(self, i, i+1, NULL);
588
589    if (!_getbytevalue(value, &ival))
590        return -1;
591
592    PyByteArray_AS_STRING(self)[i] = ival;
593    return 0;
594}
595
596static int
597bytearray_ass_subscript(PyByteArrayObject *self, PyObject *index, PyObject *values)
598{
599    Py_ssize_t start, stop, step, slicelen, needed;
600    char *buf, *bytes;
601    buf = PyByteArray_AS_STRING(self);
602
603    if (PyIndex_Check(index)) {
604        Py_ssize_t i = PyNumber_AsSsize_t(index, PyExc_IndexError);
605
606        if (i == -1 && PyErr_Occurred())
607            return -1;
608
609        if (i < 0)
610            i += PyByteArray_GET_SIZE(self);
611
612        if (i < 0 || i >= Py_SIZE(self)) {
613            PyErr_SetString(PyExc_IndexError, "bytearray index out of range");
614            return -1;
615        }
616
617        if (values == NULL) {
618            /* Fall through to slice assignment */
619            start = i;
620            stop = i + 1;
621            step = 1;
622            slicelen = 1;
623        }
624        else {
625            int ival;
626            if (!_getbytevalue(values, &ival))
627                return -1;
628            buf[i] = (char)ival;
629            return 0;
630        }
631    }
632    else if (PySlice_Check(index)) {
633        if (PySlice_GetIndicesEx(index,
634                                 PyByteArray_GET_SIZE(self),
635                                 &start, &stop, &step, &slicelen) < 0) {
636            return -1;
637        }
638    }
639    else {
640        PyErr_Format(PyExc_TypeError,
641                     "bytearray indices must be integers or slices, not %.200s",
642                      Py_TYPE(index)->tp_name);
643        return -1;
644    }
645
646    if (values == NULL) {
647        bytes = NULL;
648        needed = 0;
649    }
650    else if (values == (PyObject *)self || !PyByteArray_Check(values)) {
651        int err;
652        if (PyNumber_Check(values) || PyUnicode_Check(values)) {
653            PyErr_SetString(PyExc_TypeError,
654                            "can assign only bytes, buffers, or iterables "
655                            "of ints in range(0, 256)");
656            return -1;
657        }
658        /* Make a copy and call this function recursively */
659        values = PyByteArray_FromObject(values);
660        if (values == NULL)
661            return -1;
662        err = bytearray_ass_subscript(self, index, values);
663        Py_DECREF(values);
664        return err;
665    }
666    else {
667        assert(PyByteArray_Check(values));
668        bytes = PyByteArray_AS_STRING(values);
669        needed = Py_SIZE(values);
670    }
671    /* Make sure b[5:2] = ... inserts before 5, not before 2. */
672    if ((step < 0 && start < stop) ||
673        (step > 0 && start > stop))
674        stop = start;
675    if (step == 1) {
676        return bytearray_setslice_linear(self, start, stop, bytes, needed);
677    }
678    else {
679        if (needed == 0) {
680            /* Delete slice */
681            size_t cur;
682            Py_ssize_t i;
683
684            if (!_canresize(self))
685                return -1;
686
687            if (slicelen == 0)
688                /* Nothing to do here. */
689                return 0;
690
691            if (step < 0) {
692                stop = start + 1;
693                start = stop + step * (slicelen - 1) - 1;
694                step = -step;
695            }
696            for (cur = start, i = 0;
697                 i < slicelen; cur += step, i++) {
698                Py_ssize_t lim = step - 1;
699
700                if (cur + step >= (size_t)PyByteArray_GET_SIZE(self))
701                    lim = PyByteArray_GET_SIZE(self) - cur - 1;
702
703                memmove(buf + cur - i,
704                        buf + cur + 1, lim);
705            }
706            /* Move the tail of the bytes, in one chunk */
707            cur = start + (size_t)slicelen*step;
708            if (cur < (size_t)PyByteArray_GET_SIZE(self)) {
709                memmove(buf + cur - slicelen,
710                        buf + cur,
711                        PyByteArray_GET_SIZE(self) - cur);
712            }
713            if (PyByteArray_Resize((PyObject *)self,
714                               PyByteArray_GET_SIZE(self) - slicelen) < 0)
715                return -1;
716
717            return 0;
718        }
719        else {
720            /* Assign slice */
721            Py_ssize_t i;
722            size_t cur;
723
724            if (needed != slicelen) {
725                PyErr_Format(PyExc_ValueError,
726                             "attempt to assign bytes of size %zd "
727                             "to extended slice of size %zd",
728                             needed, slicelen);
729                return -1;
730            }
731            for (cur = start, i = 0; i < slicelen; cur += step, i++)
732                buf[cur] = bytes[i];
733            return 0;
734        }
735    }
736}
737
738static int
739bytearray_init(PyByteArrayObject *self, PyObject *args, PyObject *kwds)
740{
741    static char *kwlist[] = {"source", "encoding", "errors", 0};
742    PyObject *arg = NULL;
743    const char *encoding = NULL;
744    const char *errors = NULL;
745    Py_ssize_t count;
746    PyObject *it;
747    PyObject *(*iternext)(PyObject *);
748
749    if (Py_SIZE(self) != 0) {
750        /* Empty previous contents (yes, do this first of all!) */
751        if (PyByteArray_Resize((PyObject *)self, 0) < 0)
752            return -1;
753    }
754
755    /* Parse arguments */
756    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oss:bytearray", kwlist,
757                                     &arg, &encoding, &errors))
758        return -1;
759
760    /* Make a quick exit if no first argument */
761    if (arg == NULL) {
762        if (encoding != NULL || errors != NULL) {
763            PyErr_SetString(PyExc_TypeError,
764                            "encoding or errors without sequence argument");
765            return -1;
766        }
767        return 0;
768    }
769
770    if (PyUnicode_Check(arg)) {
771        /* Encode via the codec registry */
772        PyObject *encoded, *new;
773        if (encoding == NULL) {
774            PyErr_SetString(PyExc_TypeError,
775                            "string argument without an encoding");
776            return -1;
777        }
778        encoded = PyUnicode_AsEncodedString(arg, encoding, errors);
779        if (encoded == NULL)
780            return -1;
781        assert(PyBytes_Check(encoded));
782        new = bytearray_iconcat(self, encoded);
783        Py_DECREF(encoded);
784        if (new == NULL)
785            return -1;
786        Py_DECREF(new);
787        return 0;
788    }
789
790    /* If it's not unicode, there can't be encoding or errors */
791    if (encoding != NULL || errors != NULL) {
792        PyErr_SetString(PyExc_TypeError,
793                        "encoding or errors without a string argument");
794        return -1;
795    }
796
797    /* Is it an int? */
798    if (PyIndex_Check(arg)) {
799        count = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
800        if (count == -1 && PyErr_Occurred()) {
801            if (PyErr_ExceptionMatches(PyExc_OverflowError))
802                return -1;
803            PyErr_Clear();  /* fall through */
804        }
805        else {
806            if (count < 0) {
807                PyErr_SetString(PyExc_ValueError, "negative count");
808                return -1;
809            }
810            if (count > 0) {
811                if (PyByteArray_Resize((PyObject *)self, count))
812                    return -1;
813                memset(PyByteArray_AS_STRING(self), 0, count);
814            }
815            return 0;
816        }
817    }
818
819    /* Use the buffer API */
820    if (PyObject_CheckBuffer(arg)) {
821        Py_ssize_t size;
822        Py_buffer view;
823        if (PyObject_GetBuffer(arg, &view, PyBUF_FULL_RO) < 0)
824            return -1;
825        size = view.len;
826        if (PyByteArray_Resize((PyObject *)self, size) < 0) goto fail;
827        if (PyBuffer_ToContiguous(PyByteArray_AS_STRING(self),
828            &view, size, 'C') < 0)
829            goto fail;
830        PyBuffer_Release(&view);
831        return 0;
832    fail:
833        PyBuffer_Release(&view);
834        return -1;
835    }
836
837    /* XXX Optimize this if the arguments is a list, tuple */
838
839    /* Get the iterator */
840    it = PyObject_GetIter(arg);
841    if (it == NULL)
842        return -1;
843    iternext = *Py_TYPE(it)->tp_iternext;
844
845    /* Run the iterator to exhaustion */
846    for (;;) {
847        PyObject *item;
848        int rc, value;
849
850        /* Get the next item */
851        item = iternext(it);
852        if (item == NULL) {
853            if (PyErr_Occurred()) {
854                if (!PyErr_ExceptionMatches(PyExc_StopIteration))
855                    goto error;
856                PyErr_Clear();
857            }
858            break;
859        }
860
861        /* Interpret it as an int (__index__) */
862        rc = _getbytevalue(item, &value);
863        Py_DECREF(item);
864        if (!rc)
865            goto error;
866
867        /* Append the byte */
868        if (Py_SIZE(self) + 1 < self->ob_alloc) {
869            Py_SIZE(self)++;
870            PyByteArray_AS_STRING(self)[Py_SIZE(self)] = '\0';
871        }
872        else if (PyByteArray_Resize((PyObject *)self, Py_SIZE(self)+1) < 0)
873            goto error;
874        PyByteArray_AS_STRING(self)[Py_SIZE(self)-1] = value;
875    }
876
877    /* Clean up and return success */
878    Py_DECREF(it);
879    return 0;
880
881 error:
882    /* Error handling when it != NULL */
883    Py_DECREF(it);
884    return -1;
885}
886
887/* Mostly copied from string_repr, but without the
888   "smart quote" functionality. */
889static PyObject *
890bytearray_repr(PyByteArrayObject *self)
891{
892    const char *quote_prefix = "bytearray(b";
893    const char *quote_postfix = ")";
894    Py_ssize_t length = Py_SIZE(self);
895    /* 15 == strlen(quote_prefix) + 2 + strlen(quote_postfix) + 1 */
896    size_t newsize;
897    PyObject *v;
898    Py_ssize_t i;
899    char *bytes;
900    char c;
901    char *p;
902    int quote;
903    char *test, *start;
904    char *buffer;
905
906    if (length > (PY_SSIZE_T_MAX - 15) / 4) {
907        PyErr_SetString(PyExc_OverflowError,
908            "bytearray object is too large to make repr");
909        return NULL;
910    }
911
912    newsize = 15 + length * 4;
913    buffer = PyObject_Malloc(newsize);
914    if (buffer == NULL) {
915        PyErr_NoMemory();
916        return NULL;
917    }
918
919    /* Figure out which quote to use; single is preferred */
920    quote = '\'';
921    start = PyByteArray_AS_STRING(self);
922    for (test = start; test < start+length; ++test) {
923        if (*test == '"') {
924            quote = '\''; /* back to single */
925            break;
926        }
927        else if (*test == '\'')
928            quote = '"';
929    }
930
931    p = buffer;
932    while (*quote_prefix)
933        *p++ = *quote_prefix++;
934    *p++ = quote;
935
936    bytes = PyByteArray_AS_STRING(self);
937    for (i = 0; i < length; i++) {
938        /* There's at least enough room for a hex escape
939           and a closing quote. */
940        assert(newsize - (p - buffer) >= 5);
941        c = bytes[i];
942        if (c == '\'' || c == '\\')
943            *p++ = '\\', *p++ = c;
944        else if (c == '\t')
945            *p++ = '\\', *p++ = 't';
946        else if (c == '\n')
947            *p++ = '\\', *p++ = 'n';
948        else if (c == '\r')
949            *p++ = '\\', *p++ = 'r';
950        else if (c == 0)
951            *p++ = '\\', *p++ = 'x', *p++ = '0', *p++ = '0';
952        else if (c < ' ' || c >= 0x7f) {
953            *p++ = '\\';
954            *p++ = 'x';
955            *p++ = Py_hexdigits[(c & 0xf0) >> 4];
956            *p++ = Py_hexdigits[c & 0xf];
957        }
958        else
959            *p++ = c;
960    }
961    assert(newsize - (p - buffer) >= 1);
962    *p++ = quote;
963    while (*quote_postfix) {
964       *p++ = *quote_postfix++;
965    }
966
967    v = PyUnicode_DecodeASCII(buffer, p - buffer, NULL);
968    PyObject_Free(buffer);
969    return v;
970}
971
972static PyObject *
973bytearray_str(PyObject *op)
974{
975        if (Py_BytesWarningFlag) {
976                if (PyErr_WarnEx(PyExc_BytesWarning,
977                                 "str() on a bytearray instance", 1))
978                        return NULL;
979        }
980        return bytearray_repr((PyByteArrayObject*)op);
981}
982
983static PyObject *
984bytearray_richcompare(PyObject *self, PyObject *other, int op)
985{
986    Py_ssize_t self_size, other_size;
987    Py_buffer self_bytes, other_bytes;
988    PyObject *res;
989    Py_ssize_t minsize;
990    int cmp, rc;
991
992    /* Bytes can be compared to anything that supports the (binary)
993       buffer API.  Except that a comparison with Unicode is always an
994       error, even if the comparison is for equality. */
995    rc = PyObject_IsInstance(self, (PyObject*)&PyUnicode_Type);
996    if (!rc)
997        rc = PyObject_IsInstance(other, (PyObject*)&PyUnicode_Type);
998    if (rc < 0)
999        return NULL;
1000    if (rc) {
1001        if (Py_BytesWarningFlag && (op == Py_EQ || op == Py_NE)) {
1002            if (PyErr_WarnEx(PyExc_BytesWarning,
1003                            "Comparison between bytearray and string", 1))
1004                return NULL;
1005        }
1006
1007        Py_RETURN_NOTIMPLEMENTED;
1008    }
1009
1010    if (PyObject_GetBuffer(self, &self_bytes, PyBUF_SIMPLE) != 0) {
1011        PyErr_Clear();
1012        Py_RETURN_NOTIMPLEMENTED;
1013    }
1014    self_size = self_bytes.len;
1015
1016    if (PyObject_GetBuffer(other, &other_bytes, PyBUF_SIMPLE) != 0) {
1017        PyErr_Clear();
1018        PyBuffer_Release(&self_bytes);
1019        Py_RETURN_NOTIMPLEMENTED;
1020    }
1021    other_size = other_bytes.len;
1022
1023    if (self_size != other_size && (op == Py_EQ || op == Py_NE)) {
1024        /* Shortcut: if the lengths differ, the objects differ */
1025        cmp = (op == Py_NE);
1026    }
1027    else {
1028        minsize = self_size;
1029        if (other_size < minsize)
1030            minsize = other_size;
1031
1032        cmp = memcmp(self_bytes.buf, other_bytes.buf, minsize);
1033        /* In ISO C, memcmp() guarantees to use unsigned bytes! */
1034
1035        if (cmp == 0) {
1036            if (self_size < other_size)
1037                cmp = -1;
1038            else if (self_size > other_size)
1039                cmp = 1;
1040        }
1041
1042        switch (op) {
1043        case Py_LT: cmp = cmp <  0; break;
1044        case Py_LE: cmp = cmp <= 0; break;
1045        case Py_EQ: cmp = cmp == 0; break;
1046        case Py_NE: cmp = cmp != 0; break;
1047        case Py_GT: cmp = cmp >  0; break;
1048        case Py_GE: cmp = cmp >= 0; break;
1049        }
1050    }
1051
1052    res = cmp ? Py_True : Py_False;
1053    PyBuffer_Release(&self_bytes);
1054    PyBuffer_Release(&other_bytes);
1055    Py_INCREF(res);
1056    return res;
1057}
1058
1059static void
1060bytearray_dealloc(PyByteArrayObject *self)
1061{
1062    if (self->ob_exports > 0) {
1063        PyErr_SetString(PyExc_SystemError,
1064                        "deallocated bytearray object has exported buffers");
1065        PyErr_Print();
1066    }
1067    if (self->ob_bytes != 0) {
1068        PyObject_Free(self->ob_bytes);
1069    }
1070    Py_TYPE(self)->tp_free((PyObject *)self);
1071}
1072
1073
1074/* -------------------------------------------------------------------- */
1075/* Methods */
1076
1077#define FASTSEARCH fastsearch
1078#define STRINGLIB(F) stringlib_##F
1079#define STRINGLIB_CHAR char
1080#define STRINGLIB_SIZEOF_CHAR 1
1081#define STRINGLIB_LEN PyByteArray_GET_SIZE
1082#define STRINGLIB_STR PyByteArray_AS_STRING
1083#define STRINGLIB_NEW PyByteArray_FromStringAndSize
1084#define STRINGLIB_ISSPACE Py_ISSPACE
1085#define STRINGLIB_ISLINEBREAK(x) ((x == '\n') || (x == '\r'))
1086#define STRINGLIB_CHECK_EXACT PyByteArray_CheckExact
1087#define STRINGLIB_MUTABLE 1
1088
1089#include "stringlib/fastsearch.h"
1090#include "stringlib/count.h"
1091#include "stringlib/find.h"
1092#include "stringlib/join.h"
1093#include "stringlib/partition.h"
1094#include "stringlib/split.h"
1095#include "stringlib/ctype.h"
1096#include "stringlib/transmogrify.h"
1097
1098
1099static PyObject *
1100bytearray_find(PyByteArrayObject *self, PyObject *args)
1101{
1102    return _Py_bytes_find(PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self), args);
1103}
1104
1105static PyObject *
1106bytearray_count(PyByteArrayObject *self, PyObject *args)
1107{
1108    return _Py_bytes_count(PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self), args);
1109}
1110
1111/*[clinic input]
1112bytearray.clear
1113
1114Remove all items from the bytearray.
1115[clinic start generated code]*/
1116
1117static PyObject *
1118bytearray_clear_impl(PyByteArrayObject *self)
1119/*[clinic end generated code: output=85c2fe6aede0956c input=ed6edae9de447ac4]*/
1120{
1121    if (PyByteArray_Resize((PyObject *)self, 0) < 0)
1122        return NULL;
1123    Py_RETURN_NONE;
1124}
1125
1126/*[clinic input]
1127bytearray.copy
1128
1129Return a copy of B.
1130[clinic start generated code]*/
1131
1132static PyObject *
1133bytearray_copy_impl(PyByteArrayObject *self)
1134/*[clinic end generated code: output=68cfbcfed484c132 input=6597b0c01bccaa9e]*/
1135{
1136    return PyByteArray_FromStringAndSize(PyByteArray_AS_STRING((PyObject *)self),
1137                                         PyByteArray_GET_SIZE(self));
1138}
1139
1140static PyObject *
1141bytearray_index(PyByteArrayObject *self, PyObject *args)
1142{
1143    return _Py_bytes_index(PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self), args);
1144}
1145
1146static PyObject *
1147bytearray_rfind(PyByteArrayObject *self, PyObject *args)
1148{
1149    return _Py_bytes_rfind(PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self), args);
1150}
1151
1152static PyObject *
1153bytearray_rindex(PyByteArrayObject *self, PyObject *args)
1154{
1155    return _Py_bytes_rindex(PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self), args);
1156}
1157
1158static int
1159bytearray_contains(PyObject *self, PyObject *arg)
1160{
1161    return _Py_bytes_contains(PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self), arg);
1162}
1163
1164static PyObject *
1165bytearray_startswith(PyByteArrayObject *self, PyObject *args)
1166{
1167    return _Py_bytes_startswith(PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self), args);
1168}
1169
1170static PyObject *
1171bytearray_endswith(PyByteArrayObject *self, PyObject *args)
1172{
1173    return _Py_bytes_endswith(PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self), args);
1174}
1175
1176
1177/*[clinic input]
1178bytearray.translate
1179
1180    table: object
1181        Translation table, which must be a bytes object of length 256.
1182    /
1183    delete as deletechars: object(c_default="NULL") = b''
1184
1185Return a copy with each character mapped by the given translation table.
1186
1187All characters occurring in the optional argument delete are removed.
1188The remaining characters are mapped through the given translation table.
1189[clinic start generated code]*/
1190
1191static PyObject *
1192bytearray_translate_impl(PyByteArrayObject *self, PyObject *table,
1193                         PyObject *deletechars)
1194/*[clinic end generated code: output=b6a8f01c2a74e446 input=cfff956d4d127a9b]*/
1195{
1196    char *input, *output;
1197    const char *table_chars;
1198    Py_ssize_t i, c;
1199    PyObject *input_obj = (PyObject*)self;
1200    const char *output_start;
1201    Py_ssize_t inlen;
1202    PyObject *result = NULL;
1203    int trans_table[256];
1204    Py_buffer vtable, vdel;
1205
1206    if (table == Py_None) {
1207        table_chars = NULL;
1208        table = NULL;
1209    } else if (PyObject_GetBuffer(table, &vtable, PyBUF_SIMPLE) != 0) {
1210        return NULL;
1211    } else {
1212        if (vtable.len != 256) {
1213            PyErr_SetString(PyExc_ValueError,
1214                            "translation table must be 256 characters long");
1215            PyBuffer_Release(&vtable);
1216            return NULL;
1217        }
1218        table_chars = (const char*)vtable.buf;
1219    }
1220
1221    if (deletechars != NULL) {
1222        if (PyObject_GetBuffer(deletechars, &vdel, PyBUF_SIMPLE) != 0) {
1223            if (table != NULL)
1224                PyBuffer_Release(&vtable);
1225            return NULL;
1226        }
1227    }
1228    else {
1229        vdel.buf = NULL;
1230        vdel.len = 0;
1231    }
1232
1233    inlen = PyByteArray_GET_SIZE(input_obj);
1234    result = PyByteArray_FromStringAndSize((char *)NULL, inlen);
1235    if (result == NULL)
1236        goto done;
1237    output_start = output = PyByteArray_AS_STRING(result);
1238    input = PyByteArray_AS_STRING(input_obj);
1239
1240    if (vdel.len == 0 && table_chars != NULL) {
1241        /* If no deletions are required, use faster code */
1242        for (i = inlen; --i >= 0; ) {
1243            c = Py_CHARMASK(*input++);
1244            *output++ = table_chars[c];
1245        }
1246        goto done;
1247    }
1248
1249    if (table_chars == NULL) {
1250        for (i = 0; i < 256; i++)
1251            trans_table[i] = Py_CHARMASK(i);
1252    } else {
1253        for (i = 0; i < 256; i++)
1254            trans_table[i] = Py_CHARMASK(table_chars[i]);
1255    }
1256
1257    for (i = 0; i < vdel.len; i++)
1258        trans_table[(int) Py_CHARMASK( ((unsigned char*)vdel.buf)[i] )] = -1;
1259
1260    for (i = inlen; --i >= 0; ) {
1261        c = Py_CHARMASK(*input++);
1262        if (trans_table[c] != -1)
1263            *output++ = (char)trans_table[c];
1264    }
1265    /* Fix the size of the resulting string */
1266    if (inlen > 0)
1267        if (PyByteArray_Resize(result, output - output_start) < 0) {
1268            Py_CLEAR(result);
1269            goto done;
1270        }
1271
1272done:
1273    if (table != NULL)
1274        PyBuffer_Release(&vtable);
1275    if (deletechars != NULL)
1276        PyBuffer_Release(&vdel);
1277    return result;
1278}
1279
1280
1281/*[clinic input]
1282
1283@staticmethod
1284bytearray.maketrans
1285
1286    frm: Py_buffer
1287    to: Py_buffer
1288    /
1289
1290Return a translation table useable for the bytes or bytearray translate method.
1291
1292The returned table will be one where each byte in frm is mapped to the byte at
1293the same position in to.
1294
1295The bytes objects frm and to must be of the same length.
1296[clinic start generated code]*/
1297
1298static PyObject *
1299bytearray_maketrans_impl(Py_buffer *frm, Py_buffer *to)
1300/*[clinic end generated code: output=1df267d99f56b15e input=5925a81d2fbbf151]*/
1301{
1302    return _Py_bytes_maketrans(frm, to);
1303}
1304
1305
1306/*[clinic input]
1307bytearray.replace
1308
1309    old: Py_buffer
1310    new: Py_buffer
1311    count: Py_ssize_t = -1
1312        Maximum number of occurrences to replace.
1313        -1 (the default value) means replace all occurrences.
1314    /
1315
1316Return a copy with all occurrences of substring old replaced by new.
1317
1318If the optional argument count is given, only the first count occurrences are
1319replaced.
1320[clinic start generated code]*/
1321
1322static PyObject *
1323bytearray_replace_impl(PyByteArrayObject *self, Py_buffer *old,
1324                       Py_buffer *new, Py_ssize_t count)
1325/*[clinic end generated code: output=d39884c4dc59412a input=aa379d988637c7fb]*/
1326{
1327    return stringlib_replace((PyObject *)self,
1328                             (const char *)old->buf, old->len,
1329                             (const char *)new->buf, new->len, count);
1330}
1331
1332/*[clinic input]
1333bytearray.split
1334
1335    sep: object = None
1336        The delimiter according which to split the bytearray.
1337        None (the default value) means split on ASCII whitespace characters
1338        (space, tab, return, newline, formfeed, vertical tab).
1339    maxsplit: Py_ssize_t = -1
1340        Maximum number of splits to do.
1341        -1 (the default value) means no limit.
1342
1343Return a list of the sections in the bytearray, using sep as the delimiter.
1344[clinic start generated code]*/
1345
1346static PyObject *
1347bytearray_split_impl(PyByteArrayObject *self, PyObject *sep,
1348                     Py_ssize_t maxsplit)
1349/*[clinic end generated code: output=833e2cf385d9a04d input=24f82669f41bf523]*/
1350{
1351    Py_ssize_t len = PyByteArray_GET_SIZE(self), n;
1352    const char *s = PyByteArray_AS_STRING(self), *sub;
1353    PyObject *list;
1354    Py_buffer vsub;
1355
1356    if (maxsplit < 0)
1357        maxsplit = PY_SSIZE_T_MAX;
1358
1359    if (sep == Py_None)
1360        return stringlib_split_whitespace((PyObject*) self, s, len, maxsplit);
1361
1362    if (PyObject_GetBuffer(sep, &vsub, PyBUF_SIMPLE) != 0)
1363        return NULL;
1364    sub = vsub.buf;
1365    n = vsub.len;
1366
1367    list = stringlib_split(
1368        (PyObject*) self, s, len, sub, n, maxsplit
1369        );
1370    PyBuffer_Release(&vsub);
1371    return list;
1372}
1373
1374/*[clinic input]
1375bytearray.partition
1376
1377    sep: object
1378    /
1379
1380Partition the bytearray into three parts using the given separator.
1381
1382This will search for the separator sep in the bytearray. If the separator is
1383found, returns a 3-tuple containing the part before the separator, the
1384separator itself, and the part after it.
1385
1386If the separator is not found, returns a 3-tuple containing the original
1387bytearray object and two empty bytearray objects.
1388[clinic start generated code]*/
1389
1390static PyObject *
1391bytearray_partition(PyByteArrayObject *self, PyObject *sep)
1392/*[clinic end generated code: output=45d2525ddd35f957 input=86f89223892b70b5]*/
1393{
1394    PyObject *bytesep, *result;
1395
1396    bytesep = PyByteArray_FromObject(sep);
1397    if (! bytesep)
1398        return NULL;
1399
1400    result = stringlib_partition(
1401            (PyObject*) self,
1402            PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self),
1403            bytesep,
1404            PyByteArray_AS_STRING(bytesep), PyByteArray_GET_SIZE(bytesep)
1405            );
1406
1407    Py_DECREF(bytesep);
1408    return result;
1409}
1410
1411/*[clinic input]
1412bytearray.rpartition
1413
1414    sep: object
1415    /
1416
1417Partition the bytes into three parts using the given separator.
1418
1419This will search for the separator sep in the bytearray, starting and the end.
1420If the separator is found, returns a 3-tuple containing the part before the
1421separator, the separator itself, and the part after it.
1422
1423If the separator is not found, returns a 3-tuple containing two empty bytearray
1424objects and the original bytearray object.
1425[clinic start generated code]*/
1426
1427static PyObject *
1428bytearray_rpartition(PyByteArrayObject *self, PyObject *sep)
1429/*[clinic end generated code: output=440de3c9426115e8 input=5f4094f2de87c8f3]*/
1430{
1431    PyObject *bytesep, *result;
1432
1433    bytesep = PyByteArray_FromObject(sep);
1434    if (! bytesep)
1435        return NULL;
1436
1437    result = stringlib_rpartition(
1438            (PyObject*) self,
1439            PyByteArray_AS_STRING(self), PyByteArray_GET_SIZE(self),
1440            bytesep,
1441            PyByteArray_AS_STRING(bytesep), PyByteArray_GET_SIZE(bytesep)
1442            );
1443
1444    Py_DECREF(bytesep);
1445    return result;
1446}
1447
1448/*[clinic input]
1449bytearray.rsplit = bytearray.split
1450
1451Return a list of the sections in the bytearray, using sep as the delimiter.
1452
1453Splitting is done starting at the end of the bytearray and working to the front.
1454[clinic start generated code]*/
1455
1456static PyObject *
1457bytearray_rsplit_impl(PyByteArrayObject *self, PyObject *sep,
1458                      Py_ssize_t maxsplit)
1459/*[clinic end generated code: output=a55e0b5a03cb6190 input=a68286e4dd692ffe]*/
1460{
1461    Py_ssize_t len = PyByteArray_GET_SIZE(self), n;
1462    const char *s = PyByteArray_AS_STRING(self), *sub;
1463    PyObject *list;
1464    Py_buffer vsub;
1465
1466    if (maxsplit < 0)
1467        maxsplit = PY_SSIZE_T_MAX;
1468
1469    if (sep == Py_None)
1470        return stringlib_rsplit_whitespace((PyObject*) self, s, len, maxsplit);
1471
1472    if (PyObject_GetBuffer(sep, &vsub, PyBUF_SIMPLE) != 0)
1473        return NULL;
1474    sub = vsub.buf;
1475    n = vsub.len;
1476
1477    list = stringlib_rsplit(
1478        (PyObject*) self, s, len, sub, n, maxsplit
1479        );
1480    PyBuffer_Release(&vsub);
1481    return list;
1482}
1483
1484/*[clinic input]
1485bytearray.reverse
1486
1487Reverse the order of the values in B in place.
1488[clinic start generated code]*/
1489
1490static PyObject *
1491bytearray_reverse_impl(PyByteArrayObject *self)
1492/*[clinic end generated code: output=9f7616f29ab309d3 input=543356319fc78557]*/
1493{
1494    char swap, *head, *tail;
1495    Py_ssize_t i, j, n = Py_SIZE(self);
1496
1497    j = n / 2;
1498    head = PyByteArray_AS_STRING(self);
1499    tail = head + n - 1;
1500    for (i = 0; i < j; i++) {
1501        swap = *head;
1502        *head++ = *tail;
1503        *tail-- = swap;
1504    }
1505
1506    Py_RETURN_NONE;
1507}
1508
1509
1510/*[python input]
1511class bytesvalue_converter(CConverter):
1512    type = 'int'
1513    converter = '_getbytevalue'
1514[python start generated code]*/
1515/*[python end generated code: output=da39a3ee5e6b4b0d input=29c2e7c26c212812]*/
1516
1517
1518/*[clinic input]
1519bytearray.insert
1520
1521    index: Py_ssize_t
1522        The index where the value is to be inserted.
1523    item: bytesvalue
1524        The item to be inserted.
1525    /
1526
1527Insert a single item into the bytearray before the given index.
1528[clinic start generated code]*/
1529
1530static PyObject *
1531bytearray_insert_impl(PyByteArrayObject *self, Py_ssize_t index, int item)
1532/*[clinic end generated code: output=76c775a70e7b07b7 input=b2b5d07e9de6c070]*/
1533{
1534    Py_ssize_t n = Py_SIZE(self);
1535    char *buf;
1536
1537    if (n == PY_SSIZE_T_MAX) {
1538        PyErr_SetString(PyExc_OverflowError,
1539                        "cannot add more objects to bytearray");
1540        return NULL;
1541    }
1542    if (PyByteArray_Resize((PyObject *)self, n + 1) < 0)
1543        return NULL;
1544    buf = PyByteArray_AS_STRING(self);
1545
1546    if (index < 0) {
1547        index += n;
1548        if (index < 0)
1549            index = 0;
1550    }
1551    if (index > n)
1552        index = n;
1553    memmove(buf + index + 1, buf + index, n - index);
1554    buf[index] = item;
1555
1556    Py_RETURN_NONE;
1557}
1558
1559/*[clinic input]
1560bytearray.append
1561
1562    item: bytesvalue
1563        The item to be appended.
1564    /
1565
1566Append a single item to the end of the bytearray.
1567[clinic start generated code]*/
1568
1569static PyObject *
1570bytearray_append_impl(PyByteArrayObject *self, int item)
1571/*[clinic end generated code: output=a154e19ed1886cb6 input=20d6bec3d1340593]*/
1572{
1573    Py_ssize_t n = Py_SIZE(self);
1574
1575    if (n == PY_SSIZE_T_MAX) {
1576        PyErr_SetString(PyExc_OverflowError,
1577                        "cannot add more objects to bytearray");
1578        return NULL;
1579    }
1580    if (PyByteArray_Resize((PyObject *)self, n + 1) < 0)
1581        return NULL;
1582
1583    PyByteArray_AS_STRING(self)[n] = item;
1584
1585    Py_RETURN_NONE;
1586}
1587
1588/*[clinic input]
1589bytearray.extend
1590
1591    iterable_of_ints: object
1592        The iterable of items to append.
1593    /
1594
1595Append all the items from the iterator or sequence to the end of the bytearray.
1596[clinic start generated code]*/
1597
1598static PyObject *
1599bytearray_extend(PyByteArrayObject *self, PyObject *iterable_of_ints)
1600/*[clinic end generated code: output=98155dbe249170b1 input=c617b3a93249ba28]*/
1601{
1602    PyObject *it, *item, *bytearray_obj;
1603    Py_ssize_t buf_size = 0, len = 0;
1604    int value;
1605    char *buf;
1606
1607    /* bytearray_setslice code only accepts something supporting PEP 3118. */
1608    if (PyObject_CheckBuffer(iterable_of_ints)) {
1609        if (bytearray_setslice(self, Py_SIZE(self), Py_SIZE(self), iterable_of_ints) == -1)
1610            return NULL;
1611
1612        Py_RETURN_NONE;
1613    }
1614
1615    it = PyObject_GetIter(iterable_of_ints);
1616    if (it == NULL)
1617        return NULL;
1618
1619    /* Try to determine the length of the argument. 32 is arbitrary. */
1620    buf_size = PyObject_LengthHint(iterable_of_ints, 32);
1621    if (buf_size == -1) {
1622        Py_DECREF(it);
1623        return NULL;
1624    }
1625
1626    bytearray_obj = PyByteArray_FromStringAndSize(NULL, buf_size);
1627    if (bytearray_obj == NULL) {
1628        Py_DECREF(it);
1629        return NULL;
1630    }
1631    buf = PyByteArray_AS_STRING(bytearray_obj);
1632
1633    while ((item = PyIter_Next(it)) != NULL) {
1634        if (! _getbytevalue(item, &value)) {
1635            Py_DECREF(item);
1636            Py_DECREF(it);
1637            Py_DECREF(bytearray_obj);
1638            return NULL;
1639        }
1640        buf[len++] = value;
1641        Py_DECREF(item);
1642
1643        if (len >= buf_size) {
1644            Py_ssize_t addition;
1645            if (len == PY_SSIZE_T_MAX) {
1646                Py_DECREF(it);
1647                Py_DECREF(bytearray_obj);
1648                return PyErr_NoMemory();
1649            }
1650            addition = len >> 1;
1651            if (addition > PY_SSIZE_T_MAX - len - 1)
1652                buf_size = PY_SSIZE_T_MAX;
1653            else
1654                buf_size = len + addition + 1;
1655            if (PyByteArray_Resize((PyObject *)bytearray_obj, buf_size) < 0) {
1656                Py_DECREF(it);
1657                Py_DECREF(bytearray_obj);
1658                return NULL;
1659            }
1660            /* Recompute the `buf' pointer, since the resizing operation may
1661               have invalidated it. */
1662            buf = PyByteArray_AS_STRING(bytearray_obj);
1663        }
1664    }
1665    Py_DECREF(it);
1666
1667    /* Resize down to exact size. */
1668    if (PyByteArray_Resize((PyObject *)bytearray_obj, len) < 0) {
1669        Py_DECREF(bytearray_obj);
1670        return NULL;
1671    }
1672
1673    if (bytearray_setslice(self, Py_SIZE(self), Py_SIZE(self), bytearray_obj) == -1) {
1674        Py_DECREF(bytearray_obj);
1675        return NULL;
1676    }
1677    Py_DECREF(bytearray_obj);
1678
1679    Py_RETURN_NONE;
1680}
1681
1682/*[clinic input]
1683bytearray.pop
1684
1685    index: Py_ssize_t = -1
1686        The index from where to remove the item.
1687        -1 (the default value) means remove the last item.
1688    /
1689
1690Remove and return a single item from B.
1691
1692If no index argument is given, will pop the last item.
1693[clinic start generated code]*/
1694
1695static PyObject *
1696bytearray_pop_impl(PyByteArrayObject *self, Py_ssize_t index)
1697/*[clinic end generated code: output=e0ccd401f8021da8 input=3591df2d06c0d237]*/
1698{
1699    int value;
1700    Py_ssize_t n = Py_SIZE(self);
1701    char *buf;
1702
1703    if (n == 0) {
1704        PyErr_SetString(PyExc_IndexError,
1705                        "pop from empty bytearray");
1706        return NULL;
1707    }
1708    if (index < 0)
1709        index += Py_SIZE(self);
1710    if (index < 0 || index >= Py_SIZE(self)) {
1711        PyErr_SetString(PyExc_IndexError, "pop index out of range");
1712        return NULL;
1713    }
1714    if (!_canresize(self))
1715        return NULL;
1716
1717    buf = PyByteArray_AS_STRING(self);
1718    value = buf[index];
1719    memmove(buf + index, buf + index + 1, n - index);
1720    if (PyByteArray_Resize((PyObject *)self, n - 1) < 0)
1721        return NULL;
1722
1723    return PyLong_FromLong((unsigned char)value);
1724}
1725
1726/*[clinic input]
1727bytearray.remove
1728
1729    value: bytesvalue
1730        The value to remove.
1731    /
1732
1733Remove the first occurrence of a value in the bytearray.
1734[clinic start generated code]*/
1735
1736static PyObject *
1737bytearray_remove_impl(PyByteArrayObject *self, int value)
1738/*[clinic end generated code: output=d659e37866709c13 input=121831240cd51ddf]*/
1739{
1740    Py_ssize_t where, n = Py_SIZE(self);
1741    char *buf = PyByteArray_AS_STRING(self);
1742
1743    where = stringlib_find_char(buf, n, value);
1744    if (where < 0) {
1745        PyErr_SetString(PyExc_ValueError, "value not found in bytearray");
1746        return NULL;
1747    }
1748    if (!_canresize(self))
1749        return NULL;
1750
1751    memmove(buf + where, buf + where + 1, n - where);
1752    if (PyByteArray_Resize((PyObject *)self, n - 1) < 0)
1753        return NULL;
1754
1755    Py_RETURN_NONE;
1756}
1757
1758/* XXX These two helpers could be optimized if argsize == 1 */
1759
1760static Py_ssize_t
1761lstrip_helper(const char *myptr, Py_ssize_t mysize,
1762              const void *argptr, Py_ssize_t argsize)
1763{
1764    Py_ssize_t i = 0;
1765    while (i < mysize && memchr(argptr, (unsigned char) myptr[i], argsize))
1766        i++;
1767    return i;
1768}
1769
1770static Py_ssize_t
1771rstrip_helper(const char *myptr, Py_ssize_t mysize,
1772              const void *argptr, Py_ssize_t argsize)
1773{
1774    Py_ssize_t i = mysize - 1;
1775    while (i >= 0 && memchr(argptr, (unsigned char) myptr[i], argsize))
1776        i--;
1777    return i + 1;
1778}
1779
1780/*[clinic input]
1781bytearray.strip
1782
1783    bytes: object = None
1784    /
1785
1786Strip leading and trailing bytes contained in the argument.
1787
1788If the argument is omitted or None, strip leading and trailing ASCII whitespace.
1789[clinic start generated code]*/
1790
1791static PyObject *
1792bytearray_strip_impl(PyByteArrayObject *self, PyObject *bytes)
1793/*[clinic end generated code: output=760412661a34ad5a input=ef7bb59b09c21d62]*/
1794{
1795    Py_ssize_t left, right, mysize, byteslen;
1796    char *myptr, *bytesptr;
1797    Py_buffer vbytes;
1798
1799    if (bytes == Py_None) {
1800        bytesptr = "\t\n\r\f\v ";
1801        byteslen = 6;
1802    }
1803    else {
1804        if (PyObject_GetBuffer(bytes, &vbytes, PyBUF_SIMPLE) != 0)
1805            return NULL;
1806        bytesptr = (char *) vbytes.buf;
1807        byteslen = vbytes.len;
1808    }
1809    myptr = PyByteArray_AS_STRING(self);
1810    mysize = Py_SIZE(self);
1811    left = lstrip_helper(myptr, mysize, bytesptr, byteslen);
1812    if (left == mysize)
1813        right = left;
1814    else
1815        right = rstrip_helper(myptr, mysize, bytesptr, byteslen);
1816    if (bytes != Py_None)
1817        PyBuffer_Release(&vbytes);
1818    return PyByteArray_FromStringAndSize(myptr + left, right - left);
1819}
1820
1821/*[clinic input]
1822bytearray.lstrip
1823
1824    bytes: object = None
1825    /
1826
1827Strip leading bytes contained in the argument.
1828
1829If the argument is omitted or None, strip leading ASCII whitespace.
1830[clinic start generated code]*/
1831
1832static PyObject *
1833bytearray_lstrip_impl(PyByteArrayObject *self, PyObject *bytes)
1834/*[clinic end generated code: output=d005c9d0ab909e66 input=80843f975dd7c480]*/
1835{
1836    Py_ssize_t left, right, mysize, byteslen;
1837    char *myptr, *bytesptr;
1838    Py_buffer vbytes;
1839
1840    if (bytes == Py_None) {
1841        bytesptr = "\t\n\r\f\v ";
1842        byteslen = 6;
1843    }
1844    else {
1845        if (PyObject_GetBuffer(bytes, &vbytes, PyBUF_SIMPLE) != 0)
1846            return NULL;
1847        bytesptr = (char *) vbytes.buf;
1848        byteslen = vbytes.len;
1849    }
1850    myptr = PyByteArray_AS_STRING(self);
1851    mysize = Py_SIZE(self);
1852    left = lstrip_helper(myptr, mysize, bytesptr, byteslen);
1853    right = mysize;
1854    if (bytes != Py_None)
1855        PyBuffer_Release(&vbytes);
1856    return PyByteArray_FromStringAndSize(myptr + left, right - left);
1857}
1858
1859/*[clinic input]
1860bytearray.rstrip
1861
1862    bytes: object = None
1863    /
1864
1865Strip trailing bytes contained in the argument.
1866
1867If the argument is omitted or None, strip trailing ASCII whitespace.
1868[clinic start generated code]*/
1869
1870static PyObject *
1871bytearray_rstrip_impl(PyByteArrayObject *self, PyObject *bytes)
1872/*[clinic end generated code: output=030e2fbd2f7276bd input=e728b994954cfd91]*/
1873{
1874    Py_ssize_t right, mysize, byteslen;
1875    char *myptr, *bytesptr;
1876    Py_buffer vbytes;
1877
1878    if (bytes == Py_None) {
1879        bytesptr = "\t\n\r\f\v ";
1880        byteslen = 6;
1881    }
1882    else {
1883        if (PyObject_GetBuffer(bytes, &vbytes, PyBUF_SIMPLE) != 0)
1884            return NULL;
1885        bytesptr = (char *) vbytes.buf;
1886        byteslen = vbytes.len;
1887    }
1888    myptr = PyByteArray_AS_STRING(self);
1889    mysize = Py_SIZE(self);
1890    right = rstrip_helper(myptr, mysize, bytesptr, byteslen);
1891    if (bytes != Py_None)
1892        PyBuffer_Release(&vbytes);
1893    return PyByteArray_FromStringAndSize(myptr, right);
1894}
1895
1896/*[clinic input]
1897bytearray.decode
1898
1899    encoding: str(c_default="NULL") = 'utf-8'
1900        The encoding with which to decode the bytearray.
1901    errors: str(c_default="NULL") = 'strict'
1902        The error handling scheme to use for the handling of decoding errors.
1903        The default is 'strict' meaning that decoding errors raise a
1904        UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
1905        as well as any other name registered with codecs.register_error that
1906        can handle UnicodeDecodeErrors.
1907
1908Decode the bytearray using the codec registered for encoding.
1909[clinic start generated code]*/
1910
1911static PyObject *
1912bytearray_decode_impl(PyByteArrayObject *self, const char *encoding,
1913                      const char *errors)
1914/*[clinic end generated code: output=f57d43f4a00b42c5 input=f28d8f903020257b]*/
1915{
1916    if (encoding == NULL)
1917        encoding = PyUnicode_GetDefaultEncoding();
1918    return PyUnicode_FromEncodedObject((PyObject*)self, encoding, errors);
1919}
1920
1921PyDoc_STRVAR(alloc_doc,
1922"B.__alloc__() -> int\n\
1923\n\
1924Return the number of bytes actually allocated.");
1925
1926static PyObject *
1927bytearray_alloc(PyByteArrayObject *self)
1928{
1929    return PyLong_FromSsize_t(self->ob_alloc);
1930}
1931
1932/*[clinic input]
1933bytearray.join
1934
1935    iterable_of_bytes: object
1936    /
1937
1938Concatenate any number of bytes/bytearray objects.
1939
1940The bytearray whose method is called is inserted in between each pair.
1941
1942The result is returned as a new bytearray object.
1943[clinic start generated code]*/
1944
1945static PyObject *
1946bytearray_join(PyByteArrayObject *self, PyObject *iterable_of_bytes)
1947/*[clinic end generated code: output=a8516370bf68ae08 input=aba6b1f9b30fcb8e]*/
1948{
1949    return stringlib_bytes_join((PyObject*)self, iterable_of_bytes);
1950}
1951
1952/*[clinic input]
1953bytearray.splitlines
1954
1955    keepends: int(c_default="0") = False
1956
1957Return a list of the lines in the bytearray, breaking at line boundaries.
1958
1959Line breaks are not included in the resulting list unless keepends is given and
1960true.
1961[clinic start generated code]*/
1962
1963static PyObject *
1964bytearray_splitlines_impl(PyByteArrayObject *self, int keepends)
1965/*[clinic end generated code: output=4223c94b895f6ad9 input=8ccade941e5ea0bd]*/
1966{
1967    return stringlib_splitlines(
1968        (PyObject*) self, PyByteArray_AS_STRING(self),
1969        PyByteArray_GET_SIZE(self), keepends
1970        );
1971}
1972
1973/*[clinic input]
1974@classmethod
1975bytearray.fromhex
1976
1977    string: unicode
1978    /
1979
1980Create a bytearray object from a string of hexadecimal numbers.
1981
1982Spaces between two numbers are accepted.
1983Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef')
1984[clinic start generated code]*/
1985
1986static PyObject *
1987bytearray_fromhex_impl(PyTypeObject *type, PyObject *string)
1988/*[clinic end generated code: output=8f0f0b6d30fb3ba0 input=f033a16d1fb21f48]*/
1989{
1990    PyObject *result = _PyBytes_FromHex(string, type == &PyByteArray_Type);
1991    if (type != &PyByteArray_Type && result != NULL) {
1992        Py_SETREF(result, PyObject_CallFunctionObjArgs((PyObject *)type,
1993                                                       result, NULL));
1994    }
1995    return result;
1996}
1997
1998PyDoc_STRVAR(hex__doc__,
1999"B.hex() -> string\n\
2000\n\
2001Create a string of hexadecimal numbers from a bytearray object.\n\
2002Example: bytearray([0xb9, 0x01, 0xef]).hex() -> 'b901ef'.");
2003
2004static PyObject *
2005bytearray_hex(PyBytesObject *self)
2006{
2007    char* argbuf = PyByteArray_AS_STRING(self);
2008    Py_ssize_t arglen = PyByteArray_GET_SIZE(self);
2009    return _Py_strhex(argbuf, arglen);
2010}
2011
2012static PyObject *
2013_common_reduce(PyByteArrayObject *self, int proto)
2014{
2015    PyObject *dict;
2016    _Py_IDENTIFIER(__dict__);
2017    char *buf;
2018
2019    dict = _PyObject_GetAttrId((PyObject *)self, &PyId___dict__);
2020    if (dict == NULL) {
2021        PyErr_Clear();
2022        dict = Py_None;
2023        Py_INCREF(dict);
2024    }
2025
2026    buf = PyByteArray_AS_STRING(self);
2027    if (proto < 3) {
2028        /* use str based reduction for backwards compatibility with Python 2.x */
2029        PyObject *latin1;
2030        if (Py_SIZE(self))
2031            latin1 = PyUnicode_DecodeLatin1(buf, Py_SIZE(self), NULL);
2032        else
2033            latin1 = PyUnicode_FromString("");
2034        return Py_BuildValue("(O(Ns)N)", Py_TYPE(self), latin1, "latin-1", dict);
2035    }
2036    else {
2037        /* use more efficient byte based reduction */
2038        if (Py_SIZE(self)) {
2039            return Py_BuildValue("(O(y#)N)", Py_TYPE(self), buf, Py_SIZE(self), dict);
2040        }
2041        else {
2042            return Py_BuildValue("(O()N)", Py_TYPE(self), dict);
2043        }
2044    }
2045}
2046
2047/*[clinic input]
2048bytearray.__reduce__ as bytearray_reduce
2049
2050Return state information for pickling.
2051[clinic start generated code]*/
2052
2053static PyObject *
2054bytearray_reduce_impl(PyByteArrayObject *self)
2055/*[clinic end generated code: output=52bf304086464cab input=44b5737ada62dd3f]*/
2056{
2057    return _common_reduce(self, 2);
2058}
2059
2060/*[clinic input]
2061bytearray.__reduce_ex__ as bytearray_reduce_ex
2062
2063    proto: int = 0
2064    /
2065
2066Return state information for pickling.
2067[clinic start generated code]*/
2068
2069static PyObject *
2070bytearray_reduce_ex_impl(PyByteArrayObject *self, int proto)
2071/*[clinic end generated code: output=52eac33377197520 input=f129bc1a1aa151ee]*/
2072{
2073    return _common_reduce(self, proto);
2074}
2075
2076/*[clinic input]
2077bytearray.__sizeof__ as bytearray_sizeof
2078
2079Returns the size of the bytearray object in memory, in bytes.
2080[clinic start generated code]*/
2081
2082static PyObject *
2083bytearray_sizeof_impl(PyByteArrayObject *self)
2084/*[clinic end generated code: output=738abdd17951c427 input=e27320fd98a4bc5a]*/
2085{
2086    Py_ssize_t res;
2087
2088    res = _PyObject_SIZE(Py_TYPE(self)) + self->ob_alloc * sizeof(char);
2089    return PyLong_FromSsize_t(res);
2090}
2091
2092static PySequenceMethods bytearray_as_sequence = {
2093    (lenfunc)bytearray_length,              /* sq_length */
2094    (binaryfunc)PyByteArray_Concat,         /* sq_concat */
2095    (ssizeargfunc)bytearray_repeat,         /* sq_repeat */
2096    (ssizeargfunc)bytearray_getitem,        /* sq_item */
2097    0,                                      /* sq_slice */
2098    (ssizeobjargproc)bytearray_setitem,     /* sq_ass_item */
2099    0,                                      /* sq_ass_slice */
2100    (objobjproc)bytearray_contains,         /* sq_contains */
2101    (binaryfunc)bytearray_iconcat,          /* sq_inplace_concat */
2102    (ssizeargfunc)bytearray_irepeat,        /* sq_inplace_repeat */
2103};
2104
2105static PyMappingMethods bytearray_as_mapping = {
2106    (lenfunc)bytearray_length,
2107    (binaryfunc)bytearray_subscript,
2108    (objobjargproc)bytearray_ass_subscript,
2109};
2110
2111static PyBufferProcs bytearray_as_buffer = {
2112    (getbufferproc)bytearray_getbuffer,
2113    (releasebufferproc)bytearray_releasebuffer,
2114};
2115
2116static PyMethodDef
2117bytearray_methods[] = {
2118    {"__alloc__", (PyCFunction)bytearray_alloc, METH_NOARGS, alloc_doc},
2119    BYTEARRAY_REDUCE_METHODDEF
2120    BYTEARRAY_REDUCE_EX_METHODDEF
2121    BYTEARRAY_SIZEOF_METHODDEF
2122    BYTEARRAY_APPEND_METHODDEF
2123    {"capitalize", (PyCFunction)stringlib_capitalize, METH_NOARGS,
2124     _Py_capitalize__doc__},
2125    {"center", (PyCFunction)stringlib_center, METH_VARARGS, _Py_center__doc__},
2126    BYTEARRAY_CLEAR_METHODDEF
2127    BYTEARRAY_COPY_METHODDEF
2128    {"count", (PyCFunction)bytearray_count, METH_VARARGS,
2129     _Py_count__doc__},
2130    BYTEARRAY_DECODE_METHODDEF
2131    {"endswith", (PyCFunction)bytearray_endswith, METH_VARARGS,
2132     _Py_endswith__doc__},
2133    {"expandtabs", (PyCFunction)stringlib_expandtabs, METH_VARARGS | METH_KEYWORDS,
2134     _Py_expandtabs__doc__},
2135    BYTEARRAY_EXTEND_METHODDEF
2136    {"find", (PyCFunction)bytearray_find, METH_VARARGS,
2137     _Py_find__doc__},
2138    BYTEARRAY_FROMHEX_METHODDEF
2139    {"hex", (PyCFunction)bytearray_hex, METH_NOARGS, hex__doc__},
2140    {"index", (PyCFunction)bytearray_index, METH_VARARGS, _Py_index__doc__},
2141    BYTEARRAY_INSERT_METHODDEF
2142    {"isalnum", (PyCFunction)stringlib_isalnum, METH_NOARGS,
2143     _Py_isalnum__doc__},
2144    {"isalpha", (PyCFunction)stringlib_isalpha, METH_NOARGS,
2145     _Py_isalpha__doc__},
2146    {"isdigit", (PyCFunction)stringlib_isdigit, METH_NOARGS,
2147     _Py_isdigit__doc__},
2148    {"islower", (PyCFunction)stringlib_islower, METH_NOARGS,
2149     _Py_islower__doc__},
2150    {"isspace", (PyCFunction)stringlib_isspace, METH_NOARGS,
2151     _Py_isspace__doc__},
2152    {"istitle", (PyCFunction)stringlib_istitle, METH_NOARGS,
2153     _Py_istitle__doc__},
2154    {"isupper", (PyCFunction)stringlib_isupper, METH_NOARGS,
2155     _Py_isupper__doc__},
2156    BYTEARRAY_JOIN_METHODDEF
2157    {"ljust", (PyCFunction)stringlib_ljust, METH_VARARGS, _Py_ljust__doc__},
2158    {"lower", (PyCFunction)stringlib_lower, METH_NOARGS, _Py_lower__doc__},
2159    BYTEARRAY_LSTRIP_METHODDEF
2160    BYTEARRAY_MAKETRANS_METHODDEF
2161    BYTEARRAY_PARTITION_METHODDEF
2162    BYTEARRAY_POP_METHODDEF
2163    BYTEARRAY_REMOVE_METHODDEF
2164    BYTEARRAY_REPLACE_METHODDEF
2165    BYTEARRAY_REVERSE_METHODDEF
2166    {"rfind", (PyCFunction)bytearray_rfind, METH_VARARGS, _Py_rfind__doc__},
2167    {"rindex", (PyCFunction)bytearray_rindex, METH_VARARGS, _Py_rindex__doc__},
2168    {"rjust", (PyCFunction)stringlib_rjust, METH_VARARGS, _Py_rjust__doc__},
2169    BYTEARRAY_RPARTITION_METHODDEF
2170    BYTEARRAY_RSPLIT_METHODDEF
2171    BYTEARRAY_RSTRIP_METHODDEF
2172    BYTEARRAY_SPLIT_METHODDEF
2173    BYTEARRAY_SPLITLINES_METHODDEF
2174    {"startswith", (PyCFunction)bytearray_startswith, METH_VARARGS ,
2175     _Py_startswith__doc__},
2176    BYTEARRAY_STRIP_METHODDEF
2177    {"swapcase", (PyCFunction)stringlib_swapcase, METH_NOARGS,
2178     _Py_swapcase__doc__},
2179    {"title", (PyCFunction)stringlib_title, METH_NOARGS, _Py_title__doc__},
2180    BYTEARRAY_TRANSLATE_METHODDEF
2181    {"upper", (PyCFunction)stringlib_upper, METH_NOARGS, _Py_upper__doc__},
2182    {"zfill", (PyCFunction)stringlib_zfill, METH_VARARGS, _Py_zfill__doc__},
2183    {NULL}
2184};
2185
2186static PyObject *
2187bytearray_mod(PyObject *v, PyObject *w)
2188{
2189    if (!PyByteArray_Check(v))
2190        Py_RETURN_NOTIMPLEMENTED;
2191    return _PyBytes_FormatEx(PyByteArray_AS_STRING(v), PyByteArray_GET_SIZE(v), w, 1);
2192}
2193
2194static PyNumberMethods bytearray_as_number = {
2195    0,              /*nb_add*/
2196    0,              /*nb_subtract*/
2197    0,              /*nb_multiply*/
2198    bytearray_mod,  /*nb_remainder*/
2199};
2200
2201PyDoc_STRVAR(bytearray_doc,
2202"bytearray(iterable_of_ints) -> bytearray\n\
2203bytearray(string, encoding[, errors]) -> bytearray\n\
2204bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer\n\
2205bytearray(int) -> bytes array of size given by the parameter initialized with null bytes\n\
2206bytearray() -> empty bytes array\n\
2207\n\
2208Construct a mutable bytearray object from:\n\
2209  - an iterable yielding integers in range(256)\n\
2210  - a text string encoded using the specified encoding\n\
2211  - a bytes or a buffer object\n\
2212  - any object implementing the buffer API.\n\
2213  - an integer");
2214
2215
2216static PyObject *bytearray_iter(PyObject *seq);
2217
2218PyTypeObject PyByteArray_Type = {
2219    PyVarObject_HEAD_INIT(&PyType_Type, 0)
2220    "bytearray",
2221    sizeof(PyByteArrayObject),
2222    0,
2223    (destructor)bytearray_dealloc,       /* tp_dealloc */
2224    0,                                  /* tp_print */
2225    0,                                  /* tp_getattr */
2226    0,                                  /* tp_setattr */
2227    0,                                  /* tp_reserved */
2228    (reprfunc)bytearray_repr,           /* tp_repr */
2229    &bytearray_as_number,               /* tp_as_number */
2230    &bytearray_as_sequence,             /* tp_as_sequence */
2231    &bytearray_as_mapping,              /* tp_as_mapping */
2232    0,                                  /* tp_hash */
2233    0,                                  /* tp_call */
2234    bytearray_str,                      /* tp_str */
2235    PyObject_GenericGetAttr,            /* tp_getattro */
2236    0,                                  /* tp_setattro */
2237    &bytearray_as_buffer,               /* tp_as_buffer */
2238    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
2239    bytearray_doc,                      /* tp_doc */
2240    0,                                  /* tp_traverse */
2241    0,                                  /* tp_clear */
2242    (richcmpfunc)bytearray_richcompare, /* tp_richcompare */
2243    0,                                  /* tp_weaklistoffset */
2244    bytearray_iter,                     /* tp_iter */
2245    0,                                  /* tp_iternext */
2246    bytearray_methods,                  /* tp_methods */
2247    0,                                  /* tp_members */
2248    0,                                  /* tp_getset */
2249    0,                                  /* tp_base */
2250    0,                                  /* tp_dict */
2251    0,                                  /* tp_descr_get */
2252    0,                                  /* tp_descr_set */
2253    0,                                  /* tp_dictoffset */
2254    (initproc)bytearray_init,           /* tp_init */
2255    PyType_GenericAlloc,                /* tp_alloc */
2256    PyType_GenericNew,                  /* tp_new */
2257    PyObject_Del,                       /* tp_free */
2258};
2259
2260/*********************** Bytes Iterator ****************************/
2261
2262typedef struct {
2263    PyObject_HEAD
2264    Py_ssize_t it_index;
2265    PyByteArrayObject *it_seq; /* Set to NULL when iterator is exhausted */
2266} bytesiterobject;
2267
2268static void
2269bytearrayiter_dealloc(bytesiterobject *it)
2270{
2271    _PyObject_GC_UNTRACK(it);
2272    Py_XDECREF(it->it_seq);
2273    PyObject_GC_Del(it);
2274}
2275
2276static int
2277bytearrayiter_traverse(bytesiterobject *it, visitproc visit, void *arg)
2278{
2279    Py_VISIT(it->it_seq);
2280    return 0;
2281}
2282
2283static PyObject *
2284bytearrayiter_next(bytesiterobject *it)
2285{
2286    PyByteArrayObject *seq;
2287    PyObject *item;
2288
2289    assert(it != NULL);
2290    seq = it->it_seq;
2291    if (seq == NULL)
2292        return NULL;
2293    assert(PyByteArray_Check(seq));
2294
2295    if (it->it_index < PyByteArray_GET_SIZE(seq)) {
2296        item = PyLong_FromLong(
2297            (unsigned char)PyByteArray_AS_STRING(seq)[it->it_index]);
2298        if (item != NULL)
2299            ++it->it_index;
2300        return item;
2301    }
2302
2303    it->it_seq = NULL;
2304    Py_DECREF(seq);
2305    return NULL;
2306}
2307
2308static PyObject *
2309bytearrayiter_length_hint(bytesiterobject *it)
2310{
2311    Py_ssize_t len = 0;
2312    if (it->it_seq) {
2313        len = PyByteArray_GET_SIZE(it->it_seq) - it->it_index;
2314        if (len < 0) {
2315            len = 0;
2316        }
2317    }
2318    return PyLong_FromSsize_t(len);
2319}
2320
2321PyDoc_STRVAR(length_hint_doc,
2322    "Private method returning an estimate of len(list(it)).");
2323
2324static PyObject *
2325bytearrayiter_reduce(bytesiterobject *it)
2326{
2327    if (it->it_seq != NULL) {
2328        return Py_BuildValue("N(O)n", _PyObject_GetBuiltin("iter"),
2329                             it->it_seq, it->it_index);
2330    } else {
2331        PyObject *u = PyUnicode_FromUnicode(NULL, 0);
2332        if (u == NULL)
2333            return NULL;
2334        return Py_BuildValue("N(N)", _PyObject_GetBuiltin("iter"), u);
2335    }
2336}
2337
2338static PyObject *
2339bytearrayiter_setstate(bytesiterobject *it, PyObject *state)
2340{
2341    Py_ssize_t index = PyLong_AsSsize_t(state);
2342    if (index == -1 && PyErr_Occurred())
2343        return NULL;
2344    if (it->it_seq != NULL) {
2345        if (index < 0)
2346            index = 0;
2347        else if (index > PyByteArray_GET_SIZE(it->it_seq))
2348            index = PyByteArray_GET_SIZE(it->it_seq); /* iterator exhausted */
2349        it->it_index = index;
2350    }
2351    Py_RETURN_NONE;
2352}
2353
2354PyDoc_STRVAR(setstate_doc, "Set state information for unpickling.");
2355
2356static PyMethodDef bytearrayiter_methods[] = {
2357    {"__length_hint__", (PyCFunction)bytearrayiter_length_hint, METH_NOARGS,
2358     length_hint_doc},
2359     {"__reduce__",      (PyCFunction)bytearrayiter_reduce, METH_NOARGS,
2360     bytearray_reduce__doc__},
2361    {"__setstate__",    (PyCFunction)bytearrayiter_setstate, METH_O,
2362     setstate_doc},
2363    {NULL, NULL} /* sentinel */
2364};
2365
2366PyTypeObject PyByteArrayIter_Type = {
2367    PyVarObject_HEAD_INIT(&PyType_Type, 0)
2368    "bytearray_iterator",              /* tp_name */
2369    sizeof(bytesiterobject),           /* tp_basicsize */
2370    0,                                 /* tp_itemsize */
2371    /* methods */
2372    (destructor)bytearrayiter_dealloc, /* tp_dealloc */
2373    0,                                 /* tp_print */
2374    0,                                 /* tp_getattr */
2375    0,                                 /* tp_setattr */
2376    0,                                 /* tp_reserved */
2377    0,                                 /* tp_repr */
2378    0,                                 /* tp_as_number */
2379    0,                                 /* tp_as_sequence */
2380    0,                                 /* tp_as_mapping */
2381    0,                                 /* tp_hash */
2382    0,                                 /* tp_call */
2383    0,                                 /* tp_str */
2384    PyObject_GenericGetAttr,           /* tp_getattro */
2385    0,                                 /* tp_setattro */
2386    0,                                 /* tp_as_buffer */
2387    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
2388    0,                                 /* tp_doc */
2389    (traverseproc)bytearrayiter_traverse,  /* tp_traverse */
2390    0,                                 /* tp_clear */
2391    0,                                 /* tp_richcompare */
2392    0,                                 /* tp_weaklistoffset */
2393    PyObject_SelfIter,                 /* tp_iter */
2394    (iternextfunc)bytearrayiter_next,  /* tp_iternext */
2395    bytearrayiter_methods,             /* tp_methods */
2396    0,
2397};
2398
2399static PyObject *
2400bytearray_iter(PyObject *seq)
2401{
2402    bytesiterobject *it;
2403
2404    if (!PyByteArray_Check(seq)) {
2405        PyErr_BadInternalCall();
2406        return NULL;
2407    }
2408    it = PyObject_GC_New(bytesiterobject, &PyByteArrayIter_Type);
2409    if (it == NULL)
2410        return NULL;
2411    it->it_index = 0;
2412    Py_INCREF(seq);
2413    it->it_seq = (PyByteArrayObject *)seq;
2414    _PyObject_GC_TRACK(it);
2415    return (PyObject *)it;
2416}
2417