1 /* PyBytes (bytearray) implementation */
3 #define PY_SSIZE_T_CLEAN
5 #include "structmember.h"
6 #include "bytes_methods.h"
8 static PyByteArrayObject
*nullbytes
= NULL
;
11 PyByteArray_Fini(void)
17 PyByteArray_Init(void)
19 nullbytes
= PyObject_New(PyByteArrayObject
, &PyByteArray_Type
);
20 if (nullbytes
== NULL
)
22 nullbytes
->ob_bytes
= NULL
;
23 Py_SIZE(nullbytes
) = nullbytes
->ob_alloc
= 0;
24 nullbytes
->ob_exports
= 0;
28 /* end nullbytes support */
33 _getbytevalue(PyObject
* arg
, int *value
)
37 if (PyBytes_CheckExact(arg
)) {
38 if (Py_SIZE(arg
) != 1) {
39 PyErr_SetString(PyExc_ValueError
, "string must be of size 1");
42 *value
= Py_CHARMASK(((PyBytesObject
*)arg
)->ob_sval
[0]);
45 else if (PyInt_Check(arg
) || PyLong_Check(arg
)) {
46 face_value
= PyLong_AsLong(arg
);
49 PyObject
*index
= PyNumber_Index(arg
);
51 PyErr_Format(PyExc_TypeError
,
52 "an integer or string of size 1 is required");
55 face_value
= PyLong_AsLong(index
);
59 if (face_value
< 0 || face_value
>= 256) {
60 /* this includes the OverflowError in case the long is too large */
61 PyErr_SetString(PyExc_ValueError
, "byte must be in range(0, 256)");
70 bytearray_buffer_getreadbuf(PyByteArrayObject
*self
, Py_ssize_t index
, const void **ptr
)
73 PyErr_SetString(PyExc_SystemError
,
74 "accessing non-existent bytes segment");
77 *ptr
= (void *)self
->ob_bytes
;
82 bytearray_buffer_getwritebuf(PyByteArrayObject
*self
, Py_ssize_t index
, const void **ptr
)
85 PyErr_SetString(PyExc_SystemError
,
86 "accessing non-existent bytes segment");
89 *ptr
= (void *)self
->ob_bytes
;
94 bytearray_buffer_getsegcount(PyByteArrayObject
*self
, Py_ssize_t
*lenp
)
97 *lenp
= Py_SIZE(self
);
102 bytearray_buffer_getcharbuf(PyByteArrayObject
*self
, Py_ssize_t index
, const char **ptr
)
105 PyErr_SetString(PyExc_SystemError
,
106 "accessing non-existent bytes segment");
109 *ptr
= self
->ob_bytes
;
110 return Py_SIZE(self
);
114 bytearray_getbuffer(PyByteArrayObject
*obj
, Py_buffer
*view
, int flags
)
122 if (obj
->ob_bytes
== NULL
)
126 ret
= PyBuffer_FillInfo(view
, (PyObject
*)obj
, ptr
, Py_SIZE(obj
), 0, flags
);
134 bytearray_releasebuffer(PyByteArrayObject
*obj
, Py_buffer
*view
)
140 _getbuffer(PyObject
*obj
, Py_buffer
*view
)
142 PyBufferProcs
*buffer
= Py_TYPE(obj
)->tp_as_buffer
;
144 if (buffer
== NULL
|| buffer
->bf_getbuffer
== NULL
)
146 PyErr_Format(PyExc_TypeError
,
147 "Type %.100s doesn't support the buffer API",
148 Py_TYPE(obj
)->tp_name
);
152 if (buffer
->bf_getbuffer(obj
, view
, PyBUF_SIMPLE
) < 0)
158 _canresize(PyByteArrayObject
*self
)
160 if (self
->ob_exports
> 0) {
161 PyErr_SetString(PyExc_BufferError
,
162 "Existing exports of data: object cannot be re-sized");
168 /* Direct API functions */
171 PyByteArray_FromObject(PyObject
*input
)
173 return PyObject_CallFunctionObjArgs((PyObject
*)&PyByteArray_Type
,
178 PyByteArray_FromStringAndSize(const char *bytes
, Py_ssize_t size
)
180 PyByteArrayObject
*new;
184 PyErr_SetString(PyExc_SystemError
,
185 "Negative size passed to PyByteArray_FromStringAndSize");
189 new = PyObject_New(PyByteArrayObject
, &PyByteArray_Type
);
194 new->ob_bytes
= NULL
;
199 new->ob_bytes
= PyMem_Malloc(alloc
);
200 if (new->ob_bytes
== NULL
) {
202 return PyErr_NoMemory();
205 memcpy(new->ob_bytes
, bytes
, size
);
206 new->ob_bytes
[size
] = '\0'; /* Trailing null byte */
209 new->ob_alloc
= alloc
;
212 return (PyObject
*)new;
216 PyByteArray_Size(PyObject
*self
)
218 assert(self
!= NULL
);
219 assert(PyByteArray_Check(self
));
221 return PyByteArray_GET_SIZE(self
);
225 PyByteArray_AsString(PyObject
*self
)
227 assert(self
!= NULL
);
228 assert(PyByteArray_Check(self
));
230 return PyByteArray_AS_STRING(self
);
234 PyByteArray_Resize(PyObject
*self
, Py_ssize_t size
)
237 Py_ssize_t alloc
= ((PyByteArrayObject
*)self
)->ob_alloc
;
239 assert(self
!= NULL
);
240 assert(PyByteArray_Check(self
));
243 if (size
== Py_SIZE(self
)) {
246 if (!_canresize((PyByteArrayObject
*)self
)) {
250 if (size
< alloc
/ 2) {
251 /* Major downsize; resize down to exact size */
254 else if (size
< alloc
) {
255 /* Within allocated size; quick exit */
256 Py_SIZE(self
) = size
;
257 ((PyByteArrayObject
*)self
)->ob_bytes
[size
] = '\0'; /* Trailing null */
260 else if (size
<= alloc
* 1.125) {
261 /* Moderate upsize; overallocate similar to list_resize() */
262 alloc
= size
+ (size
>> 3) + (size
< 9 ? 3 : 6);
265 /* Major upsize; resize up to exact size */
269 sval
= PyMem_Realloc(((PyByteArrayObject
*)self
)->ob_bytes
, alloc
);
275 ((PyByteArrayObject
*)self
)->ob_bytes
= sval
;
276 Py_SIZE(self
) = size
;
277 ((PyByteArrayObject
*)self
)->ob_alloc
= alloc
;
278 ((PyByteArrayObject
*)self
)->ob_bytes
[size
] = '\0'; /* Trailing null byte */
284 PyByteArray_Concat(PyObject
*a
, PyObject
*b
)
288 PyByteArrayObject
*result
= NULL
;
292 if (_getbuffer(a
, &va
) < 0 ||
293 _getbuffer(b
, &vb
) < 0) {
294 PyErr_Format(PyExc_TypeError
, "can't concat %.100s to %.100s",
295 Py_TYPE(a
)->tp_name
, Py_TYPE(b
)->tp_name
);
299 size
= va
.len
+ vb
.len
;
305 result
= (PyByteArrayObject
*) PyByteArray_FromStringAndSize(NULL
, size
);
306 if (result
!= NULL
) {
307 memcpy(result
->ob_bytes
, va
.buf
, va
.len
);
308 memcpy(result
->ob_bytes
+ va
.len
, vb
.buf
, vb
.len
);
313 PyBuffer_Release(&va
);
315 PyBuffer_Release(&vb
);
316 return (PyObject
*)result
;
319 /* Functions stuffed into the type object */
322 bytearray_length(PyByteArrayObject
*self
)
324 return Py_SIZE(self
);
328 bytearray_iconcat(PyByteArrayObject
*self
, PyObject
*other
)
334 if (_getbuffer(other
, &vo
) < 0) {
335 PyErr_Format(PyExc_TypeError
, "can't concat %.100s to %.100s",
336 Py_TYPE(other
)->tp_name
, Py_TYPE(self
)->tp_name
);
340 mysize
= Py_SIZE(self
);
341 size
= mysize
+ vo
.len
;
343 PyBuffer_Release(&vo
);
344 return PyErr_NoMemory();
346 if (size
< self
->ob_alloc
) {
347 Py_SIZE(self
) = size
;
348 self
->ob_bytes
[Py_SIZE(self
)] = '\0'; /* Trailing null byte */
350 else if (PyByteArray_Resize((PyObject
*)self
, size
) < 0) {
351 PyBuffer_Release(&vo
);
354 memcpy(self
->ob_bytes
+ mysize
, vo
.buf
, vo
.len
);
355 PyBuffer_Release(&vo
);
357 return (PyObject
*)self
;
361 bytearray_repeat(PyByteArrayObject
*self
, Py_ssize_t count
)
363 PyByteArrayObject
*result
;
369 mysize
= Py_SIZE(self
);
370 size
= mysize
* count
;
371 if (count
!= 0 && size
/ count
!= mysize
)
372 return PyErr_NoMemory();
373 result
= (PyByteArrayObject
*)PyByteArray_FromStringAndSize(NULL
, size
);
374 if (result
!= NULL
&& size
!= 0) {
376 memset(result
->ob_bytes
, self
->ob_bytes
[0], size
);
379 for (i
= 0; i
< count
; i
++)
380 memcpy(result
->ob_bytes
+ i
*mysize
, self
->ob_bytes
, mysize
);
383 return (PyObject
*)result
;
387 bytearray_irepeat(PyByteArrayObject
*self
, Py_ssize_t count
)
394 mysize
= Py_SIZE(self
);
395 size
= mysize
* count
;
396 if (count
!= 0 && size
/ count
!= mysize
)
397 return PyErr_NoMemory();
398 if (size
< self
->ob_alloc
) {
399 Py_SIZE(self
) = size
;
400 self
->ob_bytes
[Py_SIZE(self
)] = '\0'; /* Trailing null byte */
402 else if (PyByteArray_Resize((PyObject
*)self
, size
) < 0)
406 memset(self
->ob_bytes
, self
->ob_bytes
[0], size
);
409 for (i
= 1; i
< count
; i
++)
410 memcpy(self
->ob_bytes
+ i
*mysize
, self
->ob_bytes
, mysize
);
414 return (PyObject
*)self
;
418 bytearray_getitem(PyByteArrayObject
*self
, Py_ssize_t i
)
422 if (i
< 0 || i
>= Py_SIZE(self
)) {
423 PyErr_SetString(PyExc_IndexError
, "bytearray index out of range");
426 return PyInt_FromLong((unsigned char)(self
->ob_bytes
[i
]));
430 bytearray_subscript(PyByteArrayObject
*self
, PyObject
*index
)
432 if (PyIndex_Check(index
)) {
433 Py_ssize_t i
= PyNumber_AsSsize_t(index
, PyExc_IndexError
);
435 if (i
== -1 && PyErr_Occurred())
439 i
+= PyByteArray_GET_SIZE(self
);
441 if (i
< 0 || i
>= Py_SIZE(self
)) {
442 PyErr_SetString(PyExc_IndexError
, "bytearray index out of range");
445 return PyInt_FromLong((unsigned char)(self
->ob_bytes
[i
]));
447 else if (PySlice_Check(index
)) {
448 Py_ssize_t start
, stop
, step
, slicelength
, cur
, i
;
449 if (PySlice_GetIndicesEx((PySliceObject
*)index
,
450 PyByteArray_GET_SIZE(self
),
451 &start
, &stop
, &step
, &slicelength
) < 0) {
455 if (slicelength
<= 0)
456 return PyByteArray_FromStringAndSize("", 0);
457 else if (step
== 1) {
458 return PyByteArray_FromStringAndSize(self
->ob_bytes
+ start
,
462 char *source_buf
= PyByteArray_AS_STRING(self
);
463 char *result_buf
= (char *)PyMem_Malloc(slicelength
);
466 if (result_buf
== NULL
)
467 return PyErr_NoMemory();
469 for (cur
= start
, i
= 0; i
< slicelength
;
471 result_buf
[i
] = source_buf
[cur
];
473 result
= PyByteArray_FromStringAndSize(result_buf
, slicelength
);
474 PyMem_Free(result_buf
);
479 PyErr_SetString(PyExc_TypeError
, "bytearray indices must be integers");
485 bytearray_setslice(PyByteArrayObject
*self
, Py_ssize_t lo
, Py_ssize_t hi
,
488 Py_ssize_t avail
, needed
;
494 if (values
== (PyObject
*)self
) {
495 /* Make a copy and call this function recursively */
497 values
= PyByteArray_FromObject(values
);
500 err
= bytearray_setslice(self
, lo
, hi
, values
);
504 if (values
== NULL
) {
510 if (_getbuffer(values
, &vbytes
) < 0) {
511 PyErr_Format(PyExc_TypeError
,
512 "can't set bytearray slice from %.100s",
513 Py_TYPE(values
)->tp_name
);
524 if (hi
> Py_SIZE(self
))
531 if (avail
!= needed
) {
532 if (avail
> needed
) {
533 if (!_canresize(self
)) {
539 | |<----avail----->|<-----tomove------>|
540 | |<-needed->|<-----tomove------>|
543 memmove(self
->ob_bytes
+ lo
+ needed
, self
->ob_bytes
+ hi
,
546 /* XXX(nnorwitz): need to verify this can't overflow! */
547 if (PyByteArray_Resize((PyObject
*)self
,
548 Py_SIZE(self
) + needed
- avail
) < 0) {
552 if (avail
< needed
) {
555 | |<-avail->|<-----tomove------>|
556 | |<----needed---->|<-----tomove------>|
559 memmove(self
->ob_bytes
+ lo
+ needed
, self
->ob_bytes
+ hi
,
560 Py_SIZE(self
) - lo
- needed
);
565 memcpy(self
->ob_bytes
+ lo
, bytes
, needed
);
569 if (vbytes
.len
!= -1)
570 PyBuffer_Release(&vbytes
);
575 bytearray_setitem(PyByteArrayObject
*self
, Py_ssize_t i
, PyObject
*value
)
582 if (i
< 0 || i
>= Py_SIZE(self
)) {
583 PyErr_SetString(PyExc_IndexError
, "bytearray index out of range");
588 return bytearray_setslice(self
, i
, i
+1, NULL
);
590 if (!_getbytevalue(value
, &ival
))
593 self
->ob_bytes
[i
] = ival
;
598 bytearray_ass_subscript(PyByteArrayObject
*self
, PyObject
*index
, PyObject
*values
)
600 Py_ssize_t start
, stop
, step
, slicelen
, needed
;
603 if (PyIndex_Check(index
)) {
604 Py_ssize_t i
= PyNumber_AsSsize_t(index
, PyExc_IndexError
);
606 if (i
== -1 && PyErr_Occurred())
610 i
+= PyByteArray_GET_SIZE(self
);
612 if (i
< 0 || i
>= Py_SIZE(self
)) {
613 PyErr_SetString(PyExc_IndexError
, "bytearray index out of range");
617 if (values
== NULL
) {
618 /* Fall through to slice assignment */
626 if (!_getbytevalue(values
, &ival
))
628 self
->ob_bytes
[i
] = (char)ival
;
632 else if (PySlice_Check(index
)) {
633 if (PySlice_GetIndicesEx((PySliceObject
*)index
,
634 PyByteArray_GET_SIZE(self
),
635 &start
, &stop
, &step
, &slicelen
) < 0) {
640 PyErr_SetString(PyExc_TypeError
, "bytearray indices must be integer");
644 if (values
== NULL
) {
648 else if (values
== (PyObject
*)self
|| !PyByteArray_Check(values
)) {
649 /* Make a copy an call this function recursively */
651 values
= PyByteArray_FromObject(values
);
654 err
= bytearray_ass_subscript(self
, index
, values
);
659 assert(PyByteArray_Check(values
));
660 bytes
= ((PyByteArrayObject
*)values
)->ob_bytes
;
661 needed
= Py_SIZE(values
);
663 /* Make sure b[5:2] = ... inserts before 5, not before 2. */
664 if ((step
< 0 && start
< stop
) ||
665 (step
> 0 && start
> stop
))
668 if (slicelen
!= needed
) {
669 if (!_canresize(self
))
671 if (slicelen
> needed
) {
673 0 start stop old_size
674 | |<---slicelen--->|<-----tomove------>|
675 | |<-needed->|<-----tomove------>|
678 memmove(self
->ob_bytes
+ start
+ needed
, self
->ob_bytes
+ stop
,
679 Py_SIZE(self
) - stop
);
681 if (PyByteArray_Resize((PyObject
*)self
,
682 Py_SIZE(self
) + needed
- slicelen
) < 0)
684 if (slicelen
< needed
) {
687 | |<-avail->|<-----tomove------>|
688 | |<----needed---->|<-----tomove------>|
691 memmove(self
->ob_bytes
+ start
+ needed
, self
->ob_bytes
+ stop
,
692 Py_SIZE(self
) - start
- needed
);
697 memcpy(self
->ob_bytes
+ start
, bytes
, needed
);
706 if (!_canresize(self
))
710 start
= stop
+ step
* (slicelen
- 1) - 1;
713 for (cur
= start
, i
= 0;
714 i
< slicelen
; cur
+= step
, i
++) {
715 Py_ssize_t lim
= step
- 1;
717 if (cur
+ step
>= PyByteArray_GET_SIZE(self
))
718 lim
= PyByteArray_GET_SIZE(self
) - cur
- 1;
720 memmove(self
->ob_bytes
+ cur
- i
,
721 self
->ob_bytes
+ cur
+ 1, lim
);
723 /* Move the tail of the bytes, in one chunk */
724 cur
= start
+ slicelen
*step
;
725 if (cur
< PyByteArray_GET_SIZE(self
)) {
726 memmove(self
->ob_bytes
+ cur
- slicelen
,
727 self
->ob_bytes
+ cur
,
728 PyByteArray_GET_SIZE(self
) - cur
);
730 if (PyByteArray_Resize((PyObject
*)self
,
731 PyByteArray_GET_SIZE(self
) - slicelen
) < 0)
740 if (needed
!= slicelen
) {
741 PyErr_Format(PyExc_ValueError
,
742 "attempt to assign bytes of size %zd "
743 "to extended slice of size %zd",
747 for (cur
= start
, i
= 0; i
< slicelen
; cur
+= step
, i
++)
748 self
->ob_bytes
[cur
] = bytes
[i
];
755 bytearray_init(PyByteArrayObject
*self
, PyObject
*args
, PyObject
*kwds
)
757 static char *kwlist
[] = {"source", "encoding", "errors", 0};
758 PyObject
*arg
= NULL
;
759 const char *encoding
= NULL
;
760 const char *errors
= NULL
;
763 PyObject
*(*iternext
)(PyObject
*);
765 if (Py_SIZE(self
) != 0) {
766 /* Empty previous contents (yes, do this first of all!) */
767 if (PyByteArray_Resize((PyObject
*)self
, 0) < 0)
771 /* Parse arguments */
772 if (!PyArg_ParseTupleAndKeywords(args
, kwds
, "|Oss:bytearray", kwlist
,
773 &arg
, &encoding
, &errors
))
776 /* Make a quick exit if no first argument */
778 if (encoding
!= NULL
|| errors
!= NULL
) {
779 PyErr_SetString(PyExc_TypeError
,
780 "encoding or errors without sequence argument");
786 if (PyBytes_Check(arg
)) {
787 PyObject
*new, *encoded
;
788 if (encoding
!= NULL
) {
789 encoded
= PyCodec_Encode(arg
, encoding
, errors
);
792 assert(PyBytes_Check(encoded
));
798 new = bytearray_iconcat(self
, arg
);
806 #ifdef Py_USING_UNICODE
807 if (PyUnicode_Check(arg
)) {
808 /* Encode via the codec registry */
809 PyObject
*encoded
, *new;
810 if (encoding
== NULL
) {
811 PyErr_SetString(PyExc_TypeError
,
812 "unicode argument without an encoding");
815 encoded
= PyCodec_Encode(arg
, encoding
, errors
);
818 assert(PyBytes_Check(encoded
));
819 new = bytearray_iconcat(self
, encoded
);
828 /* If it's not unicode, there can't be encoding or errors */
829 if (encoding
!= NULL
|| errors
!= NULL
) {
830 PyErr_SetString(PyExc_TypeError
,
831 "encoding or errors without a string argument");
836 count
= PyNumber_AsSsize_t(arg
, PyExc_ValueError
);
837 if (count
== -1 && PyErr_Occurred())
841 PyErr_SetString(PyExc_ValueError
, "negative count");
845 if (PyByteArray_Resize((PyObject
*)self
, count
))
847 memset(self
->ob_bytes
, 0, count
);
852 /* Use the buffer API */
853 if (PyObject_CheckBuffer(arg
)) {
856 if (PyObject_GetBuffer(arg
, &view
, PyBUF_FULL_RO
) < 0)
859 if (PyByteArray_Resize((PyObject
*)self
, size
) < 0) goto fail
;
860 if (PyBuffer_ToContiguous(self
->ob_bytes
, &view
, size
, 'C') < 0)
862 PyBuffer_Release(&view
);
865 PyBuffer_Release(&view
);
869 /* XXX Optimize this if the arguments is a list, tuple */
871 /* Get the iterator */
872 it
= PyObject_GetIter(arg
);
875 iternext
= *Py_TYPE(it
)->tp_iternext
;
877 /* Run the iterator to exhaustion */
882 /* Get the next item */
885 if (PyErr_Occurred()) {
886 if (!PyErr_ExceptionMatches(PyExc_StopIteration
))
893 /* Interpret it as an int (__index__) */
894 rc
= _getbytevalue(item
, &value
);
899 /* Append the byte */
900 if (Py_SIZE(self
) < self
->ob_alloc
)
902 else if (PyByteArray_Resize((PyObject
*)self
, Py_SIZE(self
)+1) < 0)
904 self
->ob_bytes
[Py_SIZE(self
)-1] = value
;
907 /* Clean up and return success */
912 /* Error handling when it != NULL */
917 /* Mostly copied from string_repr, but without the
918 "smart quote" functionality. */
920 bytearray_repr(PyByteArrayObject
*self
)
922 static const char *hexdigits
= "0123456789abcdef";
923 const char *quote_prefix
= "bytearray(b";
924 const char *quote_postfix
= ")";
925 Py_ssize_t length
= Py_SIZE(self
);
926 /* 14 == strlen(quote_prefix) + 2 + strlen(quote_postfix) */
927 size_t newsize
= 14 + 4 * length
;
929 if (newsize
> PY_SSIZE_T_MAX
|| newsize
/ 4 - 3 != length
) {
930 PyErr_SetString(PyExc_OverflowError
,
931 "bytearray object is too large to make repr");
934 v
= PyString_FromStringAndSize(NULL
, newsize
);
939 register Py_ssize_t i
;
944 /* Figure out which quote to use; single is preferred */
948 start
= PyByteArray_AS_STRING(self
);
949 for (test
= start
; test
< start
+length
; ++test
) {
951 quote
= '\''; /* back to single */
954 else if (*test
== '\'')
961 p
= PyString_AS_STRING(v
);
962 while (*quote_prefix
)
963 *p
++ = *quote_prefix
++;
966 for (i
= 0; i
< length
; i
++) {
967 /* There's at least enough room for a hex escape
968 and a closing quote. */
969 assert(newsize
- (p
- PyString_AS_STRING(v
)) >= 5);
970 c
= self
->ob_bytes
[i
];
971 if (c
== '\'' || c
== '\\')
972 *p
++ = '\\', *p
++ = c
;
974 *p
++ = '\\', *p
++ = 't';
976 *p
++ = '\\', *p
++ = 'n';
978 *p
++ = '\\', *p
++ = 'r';
980 *p
++ = '\\', *p
++ = 'x', *p
++ = '0', *p
++ = '0';
981 else if (c
< ' ' || c
>= 0x7f) {
984 *p
++ = hexdigits
[(c
& 0xf0) >> 4];
985 *p
++ = hexdigits
[c
& 0xf];
990 assert(newsize
- (p
- PyString_AS_STRING(v
)) >= 1);
992 while (*quote_postfix
) {
993 *p
++ = *quote_postfix
++;
996 if (_PyString_Resize(&v
, (p
- PyString_AS_STRING(v
)))) {
1005 bytearray_str(PyObject
*op
)
1008 if (Py_BytesWarningFlag
) {
1009 if (PyErr_WarnEx(PyExc_BytesWarning
,
1010 "str() on a bytearray instance", 1))
1013 return bytearray_repr((PyByteArrayObject
*)op
);
1015 return PyBytes_FromStringAndSize(((PyByteArrayObject
*)op
)->ob_bytes
, Py_SIZE(op
));
1019 bytearray_richcompare(PyObject
*self
, PyObject
*other
, int op
)
1021 Py_ssize_t self_size
, other_size
;
1022 Py_buffer self_bytes
, other_bytes
;
1027 /* Bytes can be compared to anything that supports the (binary)
1028 buffer API. Except that a comparison with Unicode is always an
1029 error, even if the comparison is for equality. */
1030 #ifdef Py_USING_UNICODE
1031 if (PyObject_IsInstance(self
, (PyObject
*)&PyUnicode_Type
) ||
1032 PyObject_IsInstance(other
, (PyObject
*)&PyUnicode_Type
)) {
1033 if (Py_BytesWarningFlag
&& op
== Py_EQ
) {
1034 if (PyErr_WarnEx(PyExc_BytesWarning
,
1035 "Comparison between bytearray and string", 1))
1039 Py_INCREF(Py_NotImplemented
);
1040 return Py_NotImplemented
;
1044 self_size
= _getbuffer(self
, &self_bytes
);
1045 if (self_size
< 0) {
1047 Py_INCREF(Py_NotImplemented
);
1048 return Py_NotImplemented
;
1051 other_size
= _getbuffer(other
, &other_bytes
);
1052 if (other_size
< 0) {
1054 PyBuffer_Release(&self_bytes
);
1055 Py_INCREF(Py_NotImplemented
);
1056 return Py_NotImplemented
;
1059 if (self_size
!= other_size
&& (op
== Py_EQ
|| op
== Py_NE
)) {
1060 /* Shortcut: if the lengths differ, the objects differ */
1061 cmp
= (op
== Py_NE
);
1064 minsize
= self_size
;
1065 if (other_size
< minsize
)
1066 minsize
= other_size
;
1068 cmp
= memcmp(self_bytes
.buf
, other_bytes
.buf
, minsize
);
1069 /* In ISO C, memcmp() guarantees to use unsigned bytes! */
1072 if (self_size
< other_size
)
1074 else if (self_size
> other_size
)
1079 case Py_LT
: cmp
= cmp
< 0; break;
1080 case Py_LE
: cmp
= cmp
<= 0; break;
1081 case Py_EQ
: cmp
= cmp
== 0; break;
1082 case Py_NE
: cmp
= cmp
!= 0; break;
1083 case Py_GT
: cmp
= cmp
> 0; break;
1084 case Py_GE
: cmp
= cmp
>= 0; break;
1088 res
= cmp
? Py_True
: Py_False
;
1089 PyBuffer_Release(&self_bytes
);
1090 PyBuffer_Release(&other_bytes
);
1096 bytearray_dealloc(PyByteArrayObject
*self
)
1098 if (self
->ob_exports
> 0) {
1099 PyErr_SetString(PyExc_SystemError
,
1100 "deallocated bytearray object has exported buffers");
1103 if (self
->ob_bytes
!= 0) {
1104 PyMem_Free(self
->ob_bytes
);
1106 Py_TYPE(self
)->tp_free((PyObject
*)self
);
1110 /* -------------------------------------------------------------------- */
1113 #define STRINGLIB_CHAR char
1114 #define STRINGLIB_LEN PyByteArray_GET_SIZE
1115 #define STRINGLIB_STR PyByteArray_AS_STRING
1116 #define STRINGLIB_NEW PyByteArray_FromStringAndSize
1117 #define STRINGLIB_EMPTY nullbytes
1118 #define STRINGLIB_ISSPACE Py_ISSPACE
1119 #define STRINGLIB_ISLINEBREAK(x) ((x == '\n') || (x == '\r'))
1120 #define STRINGLIB_CHECK_EXACT PyByteArray_CheckExact
1121 #define STRINGLIB_MUTABLE 1
1123 #include "stringlib/fastsearch.h"
1124 #include "stringlib/count.h"
1125 #include "stringlib/find.h"
1126 #include "stringlib/partition.h"
1127 #include "stringlib/split.h"
1128 #include "stringlib/ctype.h"
1129 #include "stringlib/transmogrify.h"
1132 /* The following Py_LOCAL_INLINE and Py_LOCAL functions
1133 were copied from the old char* style string object. */
1135 /* helper macro to fixup start/end slice values */
1136 #define ADJUST_INDICES(start, end, len) \
1139 else if (end < 0) { \
1150 Py_LOCAL_INLINE(Py_ssize_t
)
1151 bytearray_find_internal(PyByteArrayObject
*self
, PyObject
*args
, int dir
)
1155 Py_ssize_t start
=0, end
=PY_SSIZE_T_MAX
;
1158 if (!PyArg_ParseTuple(args
, "O|O&O&:find/rfind/index/rindex", &subobj
,
1159 _PyEval_SliceIndex
, &start
, _PyEval_SliceIndex
, &end
))
1161 if (_getbuffer(subobj
, &subbuf
) < 0)
1164 res
= stringlib_find_slice(
1165 PyByteArray_AS_STRING(self
), PyByteArray_GET_SIZE(self
),
1166 subbuf
.buf
, subbuf
.len
, start
, end
);
1168 res
= stringlib_rfind_slice(
1169 PyByteArray_AS_STRING(self
), PyByteArray_GET_SIZE(self
),
1170 subbuf
.buf
, subbuf
.len
, start
, end
);
1171 PyBuffer_Release(&subbuf
);
1175 PyDoc_STRVAR(find__doc__
,
1176 "B.find(sub [,start [,end]]) -> int\n\
1178 Return the lowest index in B where subsection sub is found,\n\
1179 such that sub is contained within s[start,end]. Optional\n\
1180 arguments start and end are interpreted as in slice notation.\n\
1182 Return -1 on failure.");
1185 bytearray_find(PyByteArrayObject
*self
, PyObject
*args
)
1187 Py_ssize_t result
= bytearray_find_internal(self
, args
, +1);
1190 return PyInt_FromSsize_t(result
);
1193 PyDoc_STRVAR(count__doc__
,
1194 "B.count(sub [,start [,end]]) -> int\n\
1196 Return the number of non-overlapping occurrences of subsection sub in\n\
1197 bytes B[start:end]. Optional arguments start and end are interpreted\n\
1198 as in slice notation.");
1201 bytearray_count(PyByteArrayObject
*self
, PyObject
*args
)
1204 const char *str
= PyByteArray_AS_STRING(self
);
1205 Py_ssize_t start
= 0, end
= PY_SSIZE_T_MAX
;
1207 PyObject
*count_obj
;
1209 if (!PyArg_ParseTuple(args
, "O|O&O&:count", &sub_obj
,
1210 _PyEval_SliceIndex
, &start
, _PyEval_SliceIndex
, &end
))
1213 if (_getbuffer(sub_obj
, &vsub
) < 0)
1216 ADJUST_INDICES(start
, end
, PyByteArray_GET_SIZE(self
));
1218 count_obj
= PyInt_FromSsize_t(
1219 stringlib_count(str
+ start
, end
- start
, vsub
.buf
, vsub
.len
, PY_SSIZE_T_MAX
)
1221 PyBuffer_Release(&vsub
);
1226 PyDoc_STRVAR(index__doc__
,
1227 "B.index(sub [,start [,end]]) -> int\n\
1229 Like B.find() but raise ValueError when the subsection is not found.");
1232 bytearray_index(PyByteArrayObject
*self
, PyObject
*args
)
1234 Py_ssize_t result
= bytearray_find_internal(self
, args
, +1);
1238 PyErr_SetString(PyExc_ValueError
,
1239 "subsection not found");
1242 return PyInt_FromSsize_t(result
);
1246 PyDoc_STRVAR(rfind__doc__
,
1247 "B.rfind(sub [,start [,end]]) -> int\n\
1249 Return the highest index in B where subsection sub is found,\n\
1250 such that sub is contained within s[start,end]. Optional\n\
1251 arguments start and end are interpreted as in slice notation.\n\
1253 Return -1 on failure.");
1256 bytearray_rfind(PyByteArrayObject
*self
, PyObject
*args
)
1258 Py_ssize_t result
= bytearray_find_internal(self
, args
, -1);
1261 return PyInt_FromSsize_t(result
);
1265 PyDoc_STRVAR(rindex__doc__
,
1266 "B.rindex(sub [,start [,end]]) -> int\n\
1268 Like B.rfind() but raise ValueError when the subsection is not found.");
1271 bytearray_rindex(PyByteArrayObject
*self
, PyObject
*args
)
1273 Py_ssize_t result
= bytearray_find_internal(self
, args
, -1);
1277 PyErr_SetString(PyExc_ValueError
,
1278 "subsection not found");
1281 return PyInt_FromSsize_t(result
);
1286 bytearray_contains(PyObject
*self
, PyObject
*arg
)
1288 Py_ssize_t ival
= PyNumber_AsSsize_t(arg
, PyExc_ValueError
);
1289 if (ival
== -1 && PyErr_Occurred()) {
1293 if (_getbuffer(arg
, &varg
) < 0)
1295 pos
= stringlib_find(PyByteArray_AS_STRING(self
), Py_SIZE(self
),
1296 varg
.buf
, varg
.len
, 0);
1297 PyBuffer_Release(&varg
);
1300 if (ival
< 0 || ival
>= 256) {
1301 PyErr_SetString(PyExc_ValueError
, "byte must be in range(0, 256)");
1305 return memchr(PyByteArray_AS_STRING(self
), ival
, Py_SIZE(self
)) != NULL
;
1309 /* Matches the end (direction >= 0) or start (direction < 0) of self
1310 * against substr, using the start and end arguments. Returns
1311 * -1 on error, 0 if not found and 1 if found.
1314 _bytearray_tailmatch(PyByteArrayObject
*self
, PyObject
*substr
, Py_ssize_t start
,
1315 Py_ssize_t end
, int direction
)
1317 Py_ssize_t len
= PyByteArray_GET_SIZE(self
);
1322 str
= PyByteArray_AS_STRING(self
);
1324 if (_getbuffer(substr
, &vsubstr
) < 0)
1327 ADJUST_INDICES(start
, end
, len
);
1329 if (direction
< 0) {
1331 if (start
+vsubstr
.len
> len
) {
1336 if (end
-start
< vsubstr
.len
|| start
> len
) {
1340 if (end
-vsubstr
.len
> start
)
1341 start
= end
- vsubstr
.len
;
1343 if (end
-start
>= vsubstr
.len
)
1344 rv
= ! memcmp(str
+start
, vsubstr
.buf
, vsubstr
.len
);
1347 PyBuffer_Release(&vsubstr
);
1352 PyDoc_STRVAR(startswith__doc__
,
1353 "B.startswith(prefix [,start [,end]]) -> bool\n\
1355 Return True if B starts with the specified prefix, False otherwise.\n\
1356 With optional start, test B beginning at that position.\n\
1357 With optional end, stop comparing B at that position.\n\
1358 prefix can also be a tuple of strings to try.");
1361 bytearray_startswith(PyByteArrayObject
*self
, PyObject
*args
)
1363 Py_ssize_t start
= 0;
1364 Py_ssize_t end
= PY_SSIZE_T_MAX
;
1368 if (!PyArg_ParseTuple(args
, "O|O&O&:startswith", &subobj
,
1369 _PyEval_SliceIndex
, &start
, _PyEval_SliceIndex
, &end
))
1371 if (PyTuple_Check(subobj
)) {
1373 for (i
= 0; i
< PyTuple_GET_SIZE(subobj
); i
++) {
1374 result
= _bytearray_tailmatch(self
,
1375 PyTuple_GET_ITEM(subobj
, i
),
1385 result
= _bytearray_tailmatch(self
, subobj
, start
, end
, -1);
1389 return PyBool_FromLong(result
);
1392 PyDoc_STRVAR(endswith__doc__
,
1393 "B.endswith(suffix [,start [,end]]) -> bool\n\
1395 Return True if B ends with the specified suffix, False otherwise.\n\
1396 With optional start, test B beginning at that position.\n\
1397 With optional end, stop comparing B at that position.\n\
1398 suffix can also be a tuple of strings to try.");
1401 bytearray_endswith(PyByteArrayObject
*self
, PyObject
*args
)
1403 Py_ssize_t start
= 0;
1404 Py_ssize_t end
= PY_SSIZE_T_MAX
;
1408 if (!PyArg_ParseTuple(args
, "O|O&O&:endswith", &subobj
,
1409 _PyEval_SliceIndex
, &start
, _PyEval_SliceIndex
, &end
))
1411 if (PyTuple_Check(subobj
)) {
1413 for (i
= 0; i
< PyTuple_GET_SIZE(subobj
); i
++) {
1414 result
= _bytearray_tailmatch(self
,
1415 PyTuple_GET_ITEM(subobj
, i
),
1425 result
= _bytearray_tailmatch(self
, subobj
, start
, end
, +1);
1429 return PyBool_FromLong(result
);
1433 PyDoc_STRVAR(translate__doc__
,
1434 "B.translate(table[, deletechars]) -> bytearray\n\
1436 Return a copy of B, where all characters occurring in the\n\
1437 optional argument deletechars are removed, and the remaining\n\
1438 characters have been mapped through the given translation\n\
1439 table, which must be a bytes object of length 256.");
1442 bytearray_translate(PyByteArrayObject
*self
, PyObject
*args
)
1444 register char *input
, *output
;
1445 register const char *table
;
1446 register Py_ssize_t i
, c
;
1447 PyObject
*input_obj
= (PyObject
*)self
;
1448 const char *output_start
;
1450 PyObject
*result
= NULL
;
1451 int trans_table
[256];
1452 PyObject
*tableobj
= NULL
, *delobj
= NULL
;
1453 Py_buffer vtable
, vdel
;
1455 if (!PyArg_UnpackTuple(args
, "translate", 1, 2,
1456 &tableobj
, &delobj
))
1459 if (tableobj
== Py_None
) {
1462 } else if (_getbuffer(tableobj
, &vtable
) < 0) {
1465 if (vtable
.len
!= 256) {
1466 PyErr_SetString(PyExc_ValueError
,
1467 "translation table must be 256 characters long");
1468 PyBuffer_Release(&vtable
);
1471 table
= (const char*)vtable
.buf
;
1474 if (delobj
!= NULL
) {
1475 if (_getbuffer(delobj
, &vdel
) < 0) {
1476 if (tableobj
!= NULL
)
1477 PyBuffer_Release(&vtable
);
1486 inlen
= PyByteArray_GET_SIZE(input_obj
);
1487 result
= PyByteArray_FromStringAndSize((char *)NULL
, inlen
);
1490 output_start
= output
= PyByteArray_AsString(result
);
1491 input
= PyByteArray_AS_STRING(input_obj
);
1493 if (vdel
.len
== 0 && table
!= NULL
) {
1494 /* If no deletions are required, use faster code */
1495 for (i
= inlen
; --i
>= 0; ) {
1496 c
= Py_CHARMASK(*input
++);
1497 *output
++ = table
[c
];
1502 if (table
== NULL
) {
1503 for (i
= 0; i
< 256; i
++)
1504 trans_table
[i
] = Py_CHARMASK(i
);
1506 for (i
= 0; i
< 256; i
++)
1507 trans_table
[i
] = Py_CHARMASK(table
[i
]);
1510 for (i
= 0; i
< vdel
.len
; i
++)
1511 trans_table
[(int) Py_CHARMASK( ((unsigned char*)vdel
.buf
)[i
] )] = -1;
1513 for (i
= inlen
; --i
>= 0; ) {
1514 c
= Py_CHARMASK(*input
++);
1515 if (trans_table
[c
] != -1)
1516 if (Py_CHARMASK(*output
++ = (char)trans_table
[c
]) == c
)
1519 /* Fix the size of the resulting string */
1521 PyByteArray_Resize(result
, output
- output_start
);
1524 if (tableobj
!= NULL
)
1525 PyBuffer_Release(&vtable
);
1527 PyBuffer_Release(&vdel
);
1532 /* find and count characters and substrings */
1534 #define findchar(target, target_len, c) \
1535 ((char *)memchr((const void *)(target), c, target_len))
1538 /* Bytes ops must return a string, create a copy */
1539 Py_LOCAL(PyByteArrayObject
*)
1540 return_self(PyByteArrayObject
*self
)
1542 return (PyByteArrayObject
*)PyByteArray_FromStringAndSize(
1543 PyByteArray_AS_STRING(self
),
1544 PyByteArray_GET_SIZE(self
));
1547 Py_LOCAL_INLINE(Py_ssize_t
)
1548 countchar(const char *target
, Py_ssize_t target_len
, char c
, Py_ssize_t maxcount
)
1551 const char *start
=target
;
1552 const char *end
=target
+target_len
;
1554 while ( (start
=findchar(start
, end
-start
, c
)) != NULL
) {
1556 if (count
>= maxcount
)
1564 /* Algorithms for different cases of string replacement */
1566 /* len(self)>=1, from="", len(to)>=1, maxcount>=1 */
1567 Py_LOCAL(PyByteArrayObject
*)
1568 replace_interleave(PyByteArrayObject
*self
,
1569 const char *to_s
, Py_ssize_t to_len
,
1570 Py_ssize_t maxcount
)
1572 char *self_s
, *result_s
;
1573 Py_ssize_t self_len
, result_len
;
1574 Py_ssize_t count
, i
, product
;
1575 PyByteArrayObject
*result
;
1577 self_len
= PyByteArray_GET_SIZE(self
);
1579 /* 1 at the end plus 1 after every character */
1581 if (maxcount
< count
)
1584 /* Check for overflow */
1585 /* result_len = count * to_len + self_len; */
1586 product
= count
* to_len
;
1587 if (product
/ to_len
!= count
) {
1588 PyErr_SetString(PyExc_OverflowError
,
1589 "replace string is too long");
1592 result_len
= product
+ self_len
;
1593 if (result_len
< 0) {
1594 PyErr_SetString(PyExc_OverflowError
,
1595 "replace string is too long");
1599 if (! (result
= (PyByteArrayObject
*)
1600 PyByteArray_FromStringAndSize(NULL
, result_len
)) )
1603 self_s
= PyByteArray_AS_STRING(self
);
1604 result_s
= PyByteArray_AS_STRING(result
);
1606 /* TODO: special case single character, which doesn't need memcpy */
1608 /* Lay the first one down (guaranteed this will occur) */
1609 Py_MEMCPY(result_s
, to_s
, to_len
);
1613 for (i
=0; i
<count
; i
++) {
1614 *result_s
++ = *self_s
++;
1615 Py_MEMCPY(result_s
, to_s
, to_len
);
1619 /* Copy the rest of the original string */
1620 Py_MEMCPY(result_s
, self_s
, self_len
-i
);
1625 /* Special case for deleting a single character */
1626 /* len(self)>=1, len(from)==1, to="", maxcount>=1 */
1627 Py_LOCAL(PyByteArrayObject
*)
1628 replace_delete_single_character(PyByteArrayObject
*self
,
1629 char from_c
, Py_ssize_t maxcount
)
1631 char *self_s
, *result_s
;
1632 char *start
, *next
, *end
;
1633 Py_ssize_t self_len
, result_len
;
1635 PyByteArrayObject
*result
;
1637 self_len
= PyByteArray_GET_SIZE(self
);
1638 self_s
= PyByteArray_AS_STRING(self
);
1640 count
= countchar(self_s
, self_len
, from_c
, maxcount
);
1642 return return_self(self
);
1645 result_len
= self_len
- count
; /* from_len == 1 */
1646 assert(result_len
>=0);
1648 if ( (result
= (PyByteArrayObject
*)
1649 PyByteArray_FromStringAndSize(NULL
, result_len
)) == NULL
)
1651 result_s
= PyByteArray_AS_STRING(result
);
1654 end
= self_s
+ self_len
;
1655 while (count
-- > 0) {
1656 next
= findchar(start
, end
-start
, from_c
);
1659 Py_MEMCPY(result_s
, start
, next
-start
);
1660 result_s
+= (next
-start
);
1663 Py_MEMCPY(result_s
, start
, end
-start
);
1668 /* len(self)>=1, len(from)>=2, to="", maxcount>=1 */
1670 Py_LOCAL(PyByteArrayObject
*)
1671 replace_delete_substring(PyByteArrayObject
*self
,
1672 const char *from_s
, Py_ssize_t from_len
,
1673 Py_ssize_t maxcount
)
1675 char *self_s
, *result_s
;
1676 char *start
, *next
, *end
;
1677 Py_ssize_t self_len
, result_len
;
1678 Py_ssize_t count
, offset
;
1679 PyByteArrayObject
*result
;
1681 self_len
= PyByteArray_GET_SIZE(self
);
1682 self_s
= PyByteArray_AS_STRING(self
);
1684 count
= stringlib_count(self_s
, self_len
,
1690 return return_self(self
);
1693 result_len
= self_len
- (count
* from_len
);
1694 assert (result_len
>=0);
1696 if ( (result
= (PyByteArrayObject
*)
1697 PyByteArray_FromStringAndSize(NULL
, result_len
)) == NULL
)
1700 result_s
= PyByteArray_AS_STRING(result
);
1703 end
= self_s
+ self_len
;
1704 while (count
-- > 0) {
1705 offset
= stringlib_find(start
, end
-start
,
1710 next
= start
+ offset
;
1712 Py_MEMCPY(result_s
, start
, next
-start
);
1714 result_s
+= (next
-start
);
1715 start
= next
+from_len
;
1717 Py_MEMCPY(result_s
, start
, end
-start
);
1721 /* len(self)>=1, len(from)==len(to)==1, maxcount>=1 */
1722 Py_LOCAL(PyByteArrayObject
*)
1723 replace_single_character_in_place(PyByteArrayObject
*self
,
1724 char from_c
, char to_c
,
1725 Py_ssize_t maxcount
)
1727 char *self_s
, *result_s
, *start
, *end
, *next
;
1728 Py_ssize_t self_len
;
1729 PyByteArrayObject
*result
;
1731 /* The result string will be the same size */
1732 self_s
= PyByteArray_AS_STRING(self
);
1733 self_len
= PyByteArray_GET_SIZE(self
);
1735 next
= findchar(self_s
, self_len
, from_c
);
1738 /* No matches; return the original bytes */
1739 return return_self(self
);
1742 /* Need to make a new bytes */
1743 result
= (PyByteArrayObject
*) PyByteArray_FromStringAndSize(NULL
, self_len
);
1746 result_s
= PyByteArray_AS_STRING(result
);
1747 Py_MEMCPY(result_s
, self_s
, self_len
);
1749 /* change everything in-place, starting with this one */
1750 start
= result_s
+ (next
-self_s
);
1753 end
= result_s
+ self_len
;
1755 while (--maxcount
> 0) {
1756 next
= findchar(start
, end
-start
, from_c
);
1766 /* len(self)>=1, len(from)==len(to)>=2, maxcount>=1 */
1767 Py_LOCAL(PyByteArrayObject
*)
1768 replace_substring_in_place(PyByteArrayObject
*self
,
1769 const char *from_s
, Py_ssize_t from_len
,
1770 const char *to_s
, Py_ssize_t to_len
,
1771 Py_ssize_t maxcount
)
1773 char *result_s
, *start
, *end
;
1775 Py_ssize_t self_len
, offset
;
1776 PyByteArrayObject
*result
;
1778 /* The result bytes will be the same size */
1780 self_s
= PyByteArray_AS_STRING(self
);
1781 self_len
= PyByteArray_GET_SIZE(self
);
1783 offset
= stringlib_find(self_s
, self_len
,
1787 /* No matches; return the original bytes */
1788 return return_self(self
);
1791 /* Need to make a new bytes */
1792 result
= (PyByteArrayObject
*) PyByteArray_FromStringAndSize(NULL
, self_len
);
1795 result_s
= PyByteArray_AS_STRING(result
);
1796 Py_MEMCPY(result_s
, self_s
, self_len
);
1798 /* change everything in-place, starting with this one */
1799 start
= result_s
+ offset
;
1800 Py_MEMCPY(start
, to_s
, from_len
);
1802 end
= result_s
+ self_len
;
1804 while ( --maxcount
> 0) {
1805 offset
= stringlib_find(start
, end
-start
,
1810 Py_MEMCPY(start
+offset
, to_s
, from_len
);
1811 start
+= offset
+from_len
;
1817 /* len(self)>=1, len(from)==1, len(to)>=2, maxcount>=1 */
1818 Py_LOCAL(PyByteArrayObject
*)
1819 replace_single_character(PyByteArrayObject
*self
,
1821 const char *to_s
, Py_ssize_t to_len
,
1822 Py_ssize_t maxcount
)
1824 char *self_s
, *result_s
;
1825 char *start
, *next
, *end
;
1826 Py_ssize_t self_len
, result_len
;
1827 Py_ssize_t count
, product
;
1828 PyByteArrayObject
*result
;
1830 self_s
= PyByteArray_AS_STRING(self
);
1831 self_len
= PyByteArray_GET_SIZE(self
);
1833 count
= countchar(self_s
, self_len
, from_c
, maxcount
);
1835 /* no matches, return unchanged */
1836 return return_self(self
);
1839 /* use the difference between current and new, hence the "-1" */
1840 /* result_len = self_len + count * (to_len-1) */
1841 product
= count
* (to_len
-1);
1842 if (product
/ (to_len
-1) != count
) {
1843 PyErr_SetString(PyExc_OverflowError
, "replace bytes is too long");
1846 result_len
= self_len
+ product
;
1847 if (result_len
< 0) {
1848 PyErr_SetString(PyExc_OverflowError
, "replace bytes is too long");
1852 if ( (result
= (PyByteArrayObject
*)
1853 PyByteArray_FromStringAndSize(NULL
, result_len
)) == NULL
)
1855 result_s
= PyByteArray_AS_STRING(result
);
1858 end
= self_s
+ self_len
;
1859 while (count
-- > 0) {
1860 next
= findchar(start
, end
-start
, from_c
);
1864 if (next
== start
) {
1865 /* replace with the 'to' */
1866 Py_MEMCPY(result_s
, to_s
, to_len
);
1870 /* copy the unchanged old then the 'to' */
1871 Py_MEMCPY(result_s
, start
, next
-start
);
1872 result_s
+= (next
-start
);
1873 Py_MEMCPY(result_s
, to_s
, to_len
);
1878 /* Copy the remainder of the remaining bytes */
1879 Py_MEMCPY(result_s
, start
, end
-start
);
1884 /* len(self)>=1, len(from)>=2, len(to)>=2, maxcount>=1 */
1885 Py_LOCAL(PyByteArrayObject
*)
1886 replace_substring(PyByteArrayObject
*self
,
1887 const char *from_s
, Py_ssize_t from_len
,
1888 const char *to_s
, Py_ssize_t to_len
,
1889 Py_ssize_t maxcount
)
1891 char *self_s
, *result_s
;
1892 char *start
, *next
, *end
;
1893 Py_ssize_t self_len
, result_len
;
1894 Py_ssize_t count
, offset
, product
;
1895 PyByteArrayObject
*result
;
1897 self_s
= PyByteArray_AS_STRING(self
);
1898 self_len
= PyByteArray_GET_SIZE(self
);
1900 count
= stringlib_count(self_s
, self_len
,
1905 /* no matches, return unchanged */
1906 return return_self(self
);
1909 /* Check for overflow */
1910 /* result_len = self_len + count * (to_len-from_len) */
1911 product
= count
* (to_len
-from_len
);
1912 if (product
/ (to_len
-from_len
) != count
) {
1913 PyErr_SetString(PyExc_OverflowError
, "replace bytes is too long");
1916 result_len
= self_len
+ product
;
1917 if (result_len
< 0) {
1918 PyErr_SetString(PyExc_OverflowError
, "replace bytes is too long");
1922 if ( (result
= (PyByteArrayObject
*)
1923 PyByteArray_FromStringAndSize(NULL
, result_len
)) == NULL
)
1925 result_s
= PyByteArray_AS_STRING(result
);
1928 end
= self_s
+ self_len
;
1929 while (count
-- > 0) {
1930 offset
= stringlib_find(start
, end
-start
,
1935 next
= start
+offset
;
1936 if (next
== start
) {
1937 /* replace with the 'to' */
1938 Py_MEMCPY(result_s
, to_s
, to_len
);
1942 /* copy the unchanged old then the 'to' */
1943 Py_MEMCPY(result_s
, start
, next
-start
);
1944 result_s
+= (next
-start
);
1945 Py_MEMCPY(result_s
, to_s
, to_len
);
1947 start
= next
+from_len
;
1950 /* Copy the remainder of the remaining bytes */
1951 Py_MEMCPY(result_s
, start
, end
-start
);
1957 Py_LOCAL(PyByteArrayObject
*)
1958 replace(PyByteArrayObject
*self
,
1959 const char *from_s
, Py_ssize_t from_len
,
1960 const char *to_s
, Py_ssize_t to_len
,
1961 Py_ssize_t maxcount
)
1964 maxcount
= PY_SSIZE_T_MAX
;
1965 } else if (maxcount
== 0 || PyByteArray_GET_SIZE(self
) == 0) {
1966 /* nothing to do; return the original bytes */
1967 return return_self(self
);
1970 if (maxcount
== 0 ||
1971 (from_len
== 0 && to_len
== 0)) {
1972 /* nothing to do; return the original bytes */
1973 return return_self(self
);
1976 /* Handle zero-length special cases */
1978 if (from_len
== 0) {
1979 /* insert the 'to' bytes everywhere. */
1980 /* >>> "Python".replace("", ".") */
1981 /* '.P.y.t.h.o.n.' */
1982 return replace_interleave(self
, to_s
, to_len
, maxcount
);
1985 /* Except for "".replace("", "A") == "A" there is no way beyond this */
1986 /* point for an empty self bytes to generate a non-empty bytes */
1987 /* Special case so the remaining code always gets a non-empty bytes */
1988 if (PyByteArray_GET_SIZE(self
) == 0) {
1989 return return_self(self
);
1993 /* delete all occurances of 'from' bytes */
1994 if (from_len
== 1) {
1995 return replace_delete_single_character(
1996 self
, from_s
[0], maxcount
);
1998 return replace_delete_substring(self
, from_s
, from_len
, maxcount
);
2002 /* Handle special case where both bytes have the same length */
2004 if (from_len
== to_len
) {
2005 if (from_len
== 1) {
2006 return replace_single_character_in_place(
2012 return replace_substring_in_place(
2013 self
, from_s
, from_len
, to_s
, to_len
, maxcount
);
2017 /* Otherwise use the more generic algorithms */
2018 if (from_len
== 1) {
2019 return replace_single_character(self
, from_s
[0],
2020 to_s
, to_len
, maxcount
);
2022 /* len('from')>=2, len('to')>=1 */
2023 return replace_substring(self
, from_s
, from_len
, to_s
, to_len
, maxcount
);
2028 PyDoc_STRVAR(replace__doc__
,
2029 "B.replace(old, new[, count]) -> bytes\n\
2031 Return a copy of B with all occurrences of subsection\n\
2032 old replaced by new. If the optional argument count is\n\
2033 given, only the first count occurrences are replaced.");
2036 bytearray_replace(PyByteArrayObject
*self
, PyObject
*args
)
2038 Py_ssize_t count
= -1;
2039 PyObject
*from
, *to
, *res
;
2040 Py_buffer vfrom
, vto
;
2042 if (!PyArg_ParseTuple(args
, "OO|n:replace", &from
, &to
, &count
))
2045 if (_getbuffer(from
, &vfrom
) < 0)
2047 if (_getbuffer(to
, &vto
) < 0) {
2048 PyBuffer_Release(&vfrom
);
2052 res
= (PyObject
*)replace((PyByteArrayObject
*) self
,
2053 vfrom
.buf
, vfrom
.len
,
2054 vto
.buf
, vto
.len
, count
);
2056 PyBuffer_Release(&vfrom
);
2057 PyBuffer_Release(&vto
);
2061 PyDoc_STRVAR(split__doc__
,
2062 "B.split([sep[, maxsplit]]) -> list of bytearray\n\
2064 Return a list of the sections in B, using sep as the delimiter.\n\
2065 If sep is not given, B is split on ASCII whitespace characters\n\
2066 (space, tab, return, newline, formfeed, vertical tab).\n\
2067 If maxsplit is given, at most maxsplit splits are done.");
2070 bytearray_split(PyByteArrayObject
*self
, PyObject
*args
)
2072 Py_ssize_t len
= PyByteArray_GET_SIZE(self
), n
;
2073 Py_ssize_t maxsplit
= -1;
2074 const char *s
= PyByteArray_AS_STRING(self
), *sub
;
2075 PyObject
*list
, *subobj
= Py_None
;
2078 if (!PyArg_ParseTuple(args
, "|On:split", &subobj
, &maxsplit
))
2081 maxsplit
= PY_SSIZE_T_MAX
;
2083 if (subobj
== Py_None
)
2084 return stringlib_split_whitespace((PyObject
*) self
, s
, len
, maxsplit
);
2086 if (_getbuffer(subobj
, &vsub
) < 0)
2091 list
= stringlib_split(
2092 (PyObject
*) self
, s
, len
, sub
, n
, maxsplit
2094 PyBuffer_Release(&vsub
);
2098 PyDoc_STRVAR(partition__doc__
,
2099 "B.partition(sep) -> (head, sep, tail)\n\
2101 Searches for the separator sep in B, and returns the part before it,\n\
2102 the separator itself, and the part after it. If the separator is not\n\
2103 found, returns B and two empty bytearray objects.");
2106 bytearray_partition(PyByteArrayObject
*self
, PyObject
*sep_obj
)
2108 PyObject
*bytesep
, *result
;
2110 bytesep
= PyByteArray_FromObject(sep_obj
);
2114 result
= stringlib_partition(
2116 PyByteArray_AS_STRING(self
), PyByteArray_GET_SIZE(self
),
2118 PyByteArray_AS_STRING(bytesep
), PyByteArray_GET_SIZE(bytesep
)
2125 PyDoc_STRVAR(rpartition__doc__
,
2126 "B.rpartition(sep) -> (tail, sep, head)\n\
2128 Searches for the separator sep in B, starting at the end of B,\n\
2129 and returns the part before it, the separator itself, and the\n\
2130 part after it. If the separator is not found, returns two empty\n\
2131 bytearray objects and B.");
2134 bytearray_rpartition(PyByteArrayObject
*self
, PyObject
*sep_obj
)
2136 PyObject
*bytesep
, *result
;
2138 bytesep
= PyByteArray_FromObject(sep_obj
);
2142 result
= stringlib_rpartition(
2144 PyByteArray_AS_STRING(self
), PyByteArray_GET_SIZE(self
),
2146 PyByteArray_AS_STRING(bytesep
), PyByteArray_GET_SIZE(bytesep
)
2153 PyDoc_STRVAR(rsplit__doc__
,
2154 "B.rsplit(sep[, maxsplit]) -> list of bytearray\n\
2156 Return a list of the sections in B, using sep as the delimiter,\n\
2157 starting at the end of B and working to the front.\n\
2158 If sep is not given, B is split on ASCII whitespace characters\n\
2159 (space, tab, return, newline, formfeed, vertical tab).\n\
2160 If maxsplit is given, at most maxsplit splits are done.");
2163 bytearray_rsplit(PyByteArrayObject
*self
, PyObject
*args
)
2165 Py_ssize_t len
= PyByteArray_GET_SIZE(self
), n
;
2166 Py_ssize_t maxsplit
= -1;
2167 const char *s
= PyByteArray_AS_STRING(self
), *sub
;
2168 PyObject
*list
, *subobj
= Py_None
;
2171 if (!PyArg_ParseTuple(args
, "|On:rsplit", &subobj
, &maxsplit
))
2174 maxsplit
= PY_SSIZE_T_MAX
;
2176 if (subobj
== Py_None
)
2177 return stringlib_rsplit_whitespace((PyObject
*) self
, s
, len
, maxsplit
);
2179 if (_getbuffer(subobj
, &vsub
) < 0)
2184 list
= stringlib_rsplit(
2185 (PyObject
*) self
, s
, len
, sub
, n
, maxsplit
2187 PyBuffer_Release(&vsub
);
2191 PyDoc_STRVAR(reverse__doc__
,
2192 "B.reverse() -> None\n\
2194 Reverse the order of the values in B in place.");
2196 bytearray_reverse(PyByteArrayObject
*self
, PyObject
*unused
)
2198 char swap
, *head
, *tail
;
2199 Py_ssize_t i
, j
, n
= Py_SIZE(self
);
2202 head
= self
->ob_bytes
;
2203 tail
= head
+ n
- 1;
2204 for (i
= 0; i
< j
; i
++) {
2213 PyDoc_STRVAR(insert__doc__
,
2214 "B.insert(index, int) -> None\n\
2216 Insert a single item into the bytearray before the given index.");
2218 bytearray_insert(PyByteArrayObject
*self
, PyObject
*args
)
2222 Py_ssize_t where
, n
= Py_SIZE(self
);
2224 if (!PyArg_ParseTuple(args
, "nO:insert", &where
, &value
))
2227 if (n
== PY_SSIZE_T_MAX
) {
2228 PyErr_SetString(PyExc_OverflowError
,
2229 "cannot add more objects to bytearray");
2232 if (!_getbytevalue(value
, &ival
))
2234 if (PyByteArray_Resize((PyObject
*)self
, n
+ 1) < 0)
2244 memmove(self
->ob_bytes
+ where
+ 1, self
->ob_bytes
+ where
, n
- where
);
2245 self
->ob_bytes
[where
] = ival
;
2250 PyDoc_STRVAR(append__doc__
,
2251 "B.append(int) -> None\n\
2253 Append a single item to the end of B.");
2255 bytearray_append(PyByteArrayObject
*self
, PyObject
*arg
)
2258 Py_ssize_t n
= Py_SIZE(self
);
2260 if (! _getbytevalue(arg
, &value
))
2262 if (n
== PY_SSIZE_T_MAX
) {
2263 PyErr_SetString(PyExc_OverflowError
,
2264 "cannot add more objects to bytearray");
2267 if (PyByteArray_Resize((PyObject
*)self
, n
+ 1) < 0)
2270 self
->ob_bytes
[n
] = value
;
2275 PyDoc_STRVAR(extend__doc__
,
2276 "B.extend(iterable int) -> None\n\
2278 Append all the elements from the iterator or sequence to the\n\
2281 bytearray_extend(PyByteArrayObject
*self
, PyObject
*arg
)
2283 PyObject
*it
, *item
, *bytearray_obj
;
2284 Py_ssize_t buf_size
= 0, len
= 0;
2288 /* bytearray_setslice code only accepts something supporting PEP 3118. */
2289 if (PyObject_CheckBuffer(arg
)) {
2290 if (bytearray_setslice(self
, Py_SIZE(self
), Py_SIZE(self
), arg
) == -1)
2296 it
= PyObject_GetIter(arg
);
2300 /* Try to determine the length of the argument. 32 is abitrary. */
2301 buf_size
= _PyObject_LengthHint(arg
, 32);
2302 if (buf_size
== -1) {
2307 bytearray_obj
= PyByteArray_FromStringAndSize(NULL
, buf_size
);
2308 if (bytearray_obj
== NULL
)
2310 buf
= PyByteArray_AS_STRING(bytearray_obj
);
2312 while ((item
= PyIter_Next(it
)) != NULL
) {
2313 if (! _getbytevalue(item
, &value
)) {
2316 Py_DECREF(bytearray_obj
);
2322 if (len
>= buf_size
) {
2323 buf_size
= len
+ (len
>> 1) + 1;
2324 if (PyByteArray_Resize((PyObject
*)bytearray_obj
, buf_size
) < 0) {
2326 Py_DECREF(bytearray_obj
);
2329 /* Recompute the `buf' pointer, since the resizing operation may
2330 have invalidated it. */
2331 buf
= PyByteArray_AS_STRING(bytearray_obj
);
2336 /* Resize down to exact size. */
2337 if (PyByteArray_Resize((PyObject
*)bytearray_obj
, len
) < 0) {
2338 Py_DECREF(bytearray_obj
);
2342 if (bytearray_setslice(self
, Py_SIZE(self
), Py_SIZE(self
), bytearray_obj
) == -1)
2344 Py_DECREF(bytearray_obj
);
2349 PyDoc_STRVAR(pop__doc__
,
2350 "B.pop([index]) -> int\n\
2352 Remove and return a single item from B. If no index\n\
2353 argument is given, will pop the last value.");
2355 bytearray_pop(PyByteArrayObject
*self
, PyObject
*args
)
2358 Py_ssize_t where
= -1, n
= Py_SIZE(self
);
2360 if (!PyArg_ParseTuple(args
, "|n:pop", &where
))
2364 PyErr_SetString(PyExc_OverflowError
,
2365 "cannot pop an empty bytearray");
2369 where
+= Py_SIZE(self
);
2370 if (where
< 0 || where
>= Py_SIZE(self
)) {
2371 PyErr_SetString(PyExc_IndexError
, "pop index out of range");
2374 if (!_canresize(self
))
2377 value
= self
->ob_bytes
[where
];
2378 memmove(self
->ob_bytes
+ where
, self
->ob_bytes
+ where
+ 1, n
- where
);
2379 if (PyByteArray_Resize((PyObject
*)self
, n
- 1) < 0)
2382 return PyInt_FromLong((unsigned char)value
);
2385 PyDoc_STRVAR(remove__doc__
,
2386 "B.remove(int) -> None\n\
2388 Remove the first occurance of a value in B.");
2390 bytearray_remove(PyByteArrayObject
*self
, PyObject
*arg
)
2393 Py_ssize_t where
, n
= Py_SIZE(self
);
2395 if (! _getbytevalue(arg
, &value
))
2398 for (where
= 0; where
< n
; where
++) {
2399 if (self
->ob_bytes
[where
] == value
)
2403 PyErr_SetString(PyExc_ValueError
, "value not found in bytearray");
2406 if (!_canresize(self
))
2409 memmove(self
->ob_bytes
+ where
, self
->ob_bytes
+ where
+ 1, n
- where
);
2410 if (PyByteArray_Resize((PyObject
*)self
, n
- 1) < 0)
2416 /* XXX These two helpers could be optimized if argsize == 1 */
2419 lstrip_helper(unsigned char *myptr
, Py_ssize_t mysize
,
2420 void *argptr
, Py_ssize_t argsize
)
2423 while (i
< mysize
&& memchr(argptr
, myptr
[i
], argsize
))
2429 rstrip_helper(unsigned char *myptr
, Py_ssize_t mysize
,
2430 void *argptr
, Py_ssize_t argsize
)
2432 Py_ssize_t i
= mysize
- 1;
2433 while (i
>= 0 && memchr(argptr
, myptr
[i
], argsize
))
2438 PyDoc_STRVAR(strip__doc__
,
2439 "B.strip([bytes]) -> bytearray\n\
2441 Strip leading and trailing bytes contained in the argument.\n\
2442 If the argument is omitted, strip ASCII whitespace.");
2444 bytearray_strip(PyByteArrayObject
*self
, PyObject
*args
)
2446 Py_ssize_t left
, right
, mysize
, argsize
;
2447 void *myptr
, *argptr
;
2448 PyObject
*arg
= Py_None
;
2450 if (!PyArg_ParseTuple(args
, "|O:strip", &arg
))
2452 if (arg
== Py_None
) {
2453 argptr
= "\t\n\r\f\v ";
2457 if (_getbuffer(arg
, &varg
) < 0)
2462 myptr
= self
->ob_bytes
;
2463 mysize
= Py_SIZE(self
);
2464 left
= lstrip_helper(myptr
, mysize
, argptr
, argsize
);
2468 right
= rstrip_helper(myptr
, mysize
, argptr
, argsize
);
2470 PyBuffer_Release(&varg
);
2471 return PyByteArray_FromStringAndSize(self
->ob_bytes
+ left
, right
- left
);
2474 PyDoc_STRVAR(lstrip__doc__
,
2475 "B.lstrip([bytes]) -> bytearray\n\
2477 Strip leading bytes contained in the argument.\n\
2478 If the argument is omitted, strip leading ASCII whitespace.");
2480 bytearray_lstrip(PyByteArrayObject
*self
, PyObject
*args
)
2482 Py_ssize_t left
, right
, mysize
, argsize
;
2483 void *myptr
, *argptr
;
2484 PyObject
*arg
= Py_None
;
2486 if (!PyArg_ParseTuple(args
, "|O:lstrip", &arg
))
2488 if (arg
== Py_None
) {
2489 argptr
= "\t\n\r\f\v ";
2493 if (_getbuffer(arg
, &varg
) < 0)
2498 myptr
= self
->ob_bytes
;
2499 mysize
= Py_SIZE(self
);
2500 left
= lstrip_helper(myptr
, mysize
, argptr
, argsize
);
2503 PyBuffer_Release(&varg
);
2504 return PyByteArray_FromStringAndSize(self
->ob_bytes
+ left
, right
- left
);
2507 PyDoc_STRVAR(rstrip__doc__
,
2508 "B.rstrip([bytes]) -> bytearray\n\
2510 Strip trailing bytes contained in the argument.\n\
2511 If the argument is omitted, strip trailing ASCII whitespace.");
2513 bytearray_rstrip(PyByteArrayObject
*self
, PyObject
*args
)
2515 Py_ssize_t left
, right
, mysize
, argsize
;
2516 void *myptr
, *argptr
;
2517 PyObject
*arg
= Py_None
;
2519 if (!PyArg_ParseTuple(args
, "|O:rstrip", &arg
))
2521 if (arg
== Py_None
) {
2522 argptr
= "\t\n\r\f\v ";
2526 if (_getbuffer(arg
, &varg
) < 0)
2531 myptr
= self
->ob_bytes
;
2532 mysize
= Py_SIZE(self
);
2534 right
= rstrip_helper(myptr
, mysize
, argptr
, argsize
);
2536 PyBuffer_Release(&varg
);
2537 return PyByteArray_FromStringAndSize(self
->ob_bytes
+ left
, right
- left
);
2540 PyDoc_STRVAR(decode_doc
,
2541 "B.decode([encoding[, errors]]) -> unicode object.\n\
2543 Decodes B using the codec registered for encoding. encoding defaults\n\
2544 to the default encoding. errors may be given to set a different error\n\
2545 handling scheme. Default is 'strict' meaning that encoding errors raise\n\
2546 a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'\n\
2547 as well as any other name registered with codecs.register_error that is\n\
2548 able to handle UnicodeDecodeErrors.");
2551 bytearray_decode(PyObject
*self
, PyObject
*args
, PyObject
*kwargs
)
2553 const char *encoding
= NULL
;
2554 const char *errors
= NULL
;
2555 static char *kwlist
[] = {"encoding", "errors", 0};
2557 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "|ss:decode", kwlist
, &encoding
, &errors
))
2559 if (encoding
== NULL
) {
2560 #ifdef Py_USING_UNICODE
2561 encoding
= PyUnicode_GetDefaultEncoding();
2563 PyErr_SetString(PyExc_ValueError
, "no encoding specified");
2567 return PyCodec_Decode(self
, encoding
, errors
);
2570 PyDoc_STRVAR(alloc_doc
,
2571 "B.__alloc__() -> int\n\
2573 Returns the number of bytes actually allocated.");
2576 bytearray_alloc(PyByteArrayObject
*self
)
2578 return PyInt_FromSsize_t(self
->ob_alloc
);
2581 PyDoc_STRVAR(join_doc
,
2582 "B.join(iterable_of_bytes) -> bytes\n\
2584 Concatenates any number of bytearray objects, with B in between each pair.");
2587 bytearray_join(PyByteArrayObject
*self
, PyObject
*it
)
2590 Py_ssize_t mysize
= Py_SIZE(self
);
2594 Py_ssize_t totalsize
= 0;
2598 seq
= PySequence_Fast(it
, "can only join an iterable");
2601 n
= PySequence_Fast_GET_SIZE(seq
);
2602 items
= PySequence_Fast_ITEMS(seq
);
2604 /* Compute the total size, and check that they are all bytes */
2605 /* XXX Shouldn't we use _getbuffer() on these items instead? */
2606 for (i
= 0; i
< n
; i
++) {
2607 PyObject
*obj
= items
[i
];
2608 if (!PyByteArray_Check(obj
) && !PyBytes_Check(obj
)) {
2609 PyErr_Format(PyExc_TypeError
,
2610 "can only join an iterable of bytes "
2611 "(item %ld has type '%.100s')",
2612 /* XXX %ld isn't right on Win64 */
2613 (long)i
, Py_TYPE(obj
)->tp_name
);
2617 totalsize
+= mysize
;
2618 totalsize
+= Py_SIZE(obj
);
2619 if (totalsize
< 0) {
2625 /* Allocate the result, and copy the bytes */
2626 result
= PyByteArray_FromStringAndSize(NULL
, totalsize
);
2629 dest
= PyByteArray_AS_STRING(result
);
2630 for (i
= 0; i
< n
; i
++) {
2631 PyObject
*obj
= items
[i
];
2632 Py_ssize_t size
= Py_SIZE(obj
);
2634 if (PyByteArray_Check(obj
))
2635 buf
= PyByteArray_AS_STRING(obj
);
2637 buf
= PyBytes_AS_STRING(obj
);
2639 memcpy(dest
, self
->ob_bytes
, mysize
);
2642 memcpy(dest
, buf
, size
);
2650 /* Error handling */
2656 PyDoc_STRVAR(splitlines__doc__
,
2657 "B.splitlines([keepends]) -> list of lines\n\
2659 Return a list of the lines in B, breaking at line boundaries.\n\
2660 Line breaks are not included in the resulting list unless keepends\n\
2661 is given and true.");
2664 bytearray_splitlines(PyObject
*self
, PyObject
*args
)
2668 if (!PyArg_ParseTuple(args
, "|i:splitlines", &keepends
))
2671 return stringlib_splitlines(
2672 (PyObject
*) self
, PyByteArray_AS_STRING(self
),
2673 PyByteArray_GET_SIZE(self
), keepends
2677 PyDoc_STRVAR(fromhex_doc
,
2678 "bytearray.fromhex(string) -> bytearray\n\
2680 Create a bytearray object from a string of hexadecimal numbers.\n\
2681 Spaces between two numbers are accepted.\n\
2682 Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef').");
2685 hex_digit_to_int(char c
)
2692 if (c
>= 'a' && c
<= 'f')
2693 return c
- 'a' + 10;
2699 bytearray_fromhex(PyObject
*cls
, PyObject
*args
)
2704 Py_ssize_t hexlen
, byteslen
, i
, j
;
2707 if (!PyArg_ParseTuple(args
, "s#:fromhex", &hex
, &hexlen
))
2709 byteslen
= hexlen
/2; /* This overestimates if there are spaces */
2710 newbytes
= PyByteArray_FromStringAndSize(NULL
, byteslen
);
2713 buf
= PyByteArray_AS_STRING(newbytes
);
2714 for (i
= j
= 0; i
< hexlen
; i
+= 2) {
2715 /* skip over spaces in the input */
2716 while (hex
[i
] == ' ')
2720 top
= hex_digit_to_int(hex
[i
]);
2721 bot
= hex_digit_to_int(hex
[i
+1]);
2722 if (top
== -1 || bot
== -1) {
2723 PyErr_Format(PyExc_ValueError
,
2724 "non-hexadecimal number found in "
2725 "fromhex() arg at position %zd", i
);
2728 buf
[j
++] = (top
<< 4) + bot
;
2730 if (PyByteArray_Resize(newbytes
, j
) < 0)
2735 Py_DECREF(newbytes
);
2739 PyDoc_STRVAR(reduce_doc
, "Return state information for pickling.");
2742 bytearray_reduce(PyByteArrayObject
*self
)
2744 PyObject
*latin1
, *dict
;
2746 #ifdef Py_USING_UNICODE
2747 latin1
= PyUnicode_DecodeLatin1(self
->ob_bytes
,
2748 Py_SIZE(self
), NULL
);
2750 latin1
= PyString_FromStringAndSize(self
->ob_bytes
, Py_SIZE(self
));
2753 #ifdef Py_USING_UNICODE
2754 latin1
= PyUnicode_FromString("");
2756 latin1
= PyString_FromString("");
2759 dict
= PyObject_GetAttrString((PyObject
*)self
, "__dict__");
2766 return Py_BuildValue("(O(Ns)N)", Py_TYPE(self
), latin1
, "latin-1", dict
);
2769 PyDoc_STRVAR(sizeof_doc
,
2770 "B.__sizeof__() -> int\n\
2772 Returns the size of B in memory, in bytes");
2774 bytearray_sizeof(PyByteArrayObject
*self
)
2778 res
= sizeof(PyByteArrayObject
) + self
->ob_alloc
* sizeof(char);
2779 return PyInt_FromSsize_t(res
);
2782 static PySequenceMethods bytearray_as_sequence
= {
2783 (lenfunc
)bytearray_length
, /* sq_length */
2784 (binaryfunc
)PyByteArray_Concat
, /* sq_concat */
2785 (ssizeargfunc
)bytearray_repeat
, /* sq_repeat */
2786 (ssizeargfunc
)bytearray_getitem
, /* sq_item */
2788 (ssizeobjargproc
)bytearray_setitem
, /* sq_ass_item */
2789 0, /* sq_ass_slice */
2790 (objobjproc
)bytearray_contains
, /* sq_contains */
2791 (binaryfunc
)bytearray_iconcat
, /* sq_inplace_concat */
2792 (ssizeargfunc
)bytearray_irepeat
, /* sq_inplace_repeat */
2795 static PyMappingMethods bytearray_as_mapping
= {
2796 (lenfunc
)bytearray_length
,
2797 (binaryfunc
)bytearray_subscript
,
2798 (objobjargproc
)bytearray_ass_subscript
,
2801 static PyBufferProcs bytearray_as_buffer
= {
2802 (readbufferproc
)bytearray_buffer_getreadbuf
,
2803 (writebufferproc
)bytearray_buffer_getwritebuf
,
2804 (segcountproc
)bytearray_buffer_getsegcount
,
2805 (charbufferproc
)bytearray_buffer_getcharbuf
,
2806 (getbufferproc
)bytearray_getbuffer
,
2807 (releasebufferproc
)bytearray_releasebuffer
,
2811 bytearray_methods
[] = {
2812 {"__alloc__", (PyCFunction
)bytearray_alloc
, METH_NOARGS
, alloc_doc
},
2813 {"__reduce__", (PyCFunction
)bytearray_reduce
, METH_NOARGS
, reduce_doc
},
2814 {"__sizeof__", (PyCFunction
)bytearray_sizeof
, METH_NOARGS
, sizeof_doc
},
2815 {"append", (PyCFunction
)bytearray_append
, METH_O
, append__doc__
},
2816 {"capitalize", (PyCFunction
)stringlib_capitalize
, METH_NOARGS
,
2817 _Py_capitalize__doc__
},
2818 {"center", (PyCFunction
)stringlib_center
, METH_VARARGS
, center__doc__
},
2819 {"count", (PyCFunction
)bytearray_count
, METH_VARARGS
, count__doc__
},
2820 {"decode", (PyCFunction
)bytearray_decode
, METH_VARARGS
| METH_KEYWORDS
, decode_doc
},
2821 {"endswith", (PyCFunction
)bytearray_endswith
, METH_VARARGS
, endswith__doc__
},
2822 {"expandtabs", (PyCFunction
)stringlib_expandtabs
, METH_VARARGS
,
2824 {"extend", (PyCFunction
)bytearray_extend
, METH_O
, extend__doc__
},
2825 {"find", (PyCFunction
)bytearray_find
, METH_VARARGS
, find__doc__
},
2826 {"fromhex", (PyCFunction
)bytearray_fromhex
, METH_VARARGS
|METH_CLASS
,
2828 {"index", (PyCFunction
)bytearray_index
, METH_VARARGS
, index__doc__
},
2829 {"insert", (PyCFunction
)bytearray_insert
, METH_VARARGS
, insert__doc__
},
2830 {"isalnum", (PyCFunction
)stringlib_isalnum
, METH_NOARGS
,
2831 _Py_isalnum__doc__
},
2832 {"isalpha", (PyCFunction
)stringlib_isalpha
, METH_NOARGS
,
2833 _Py_isalpha__doc__
},
2834 {"isdigit", (PyCFunction
)stringlib_isdigit
, METH_NOARGS
,
2835 _Py_isdigit__doc__
},
2836 {"islower", (PyCFunction
)stringlib_islower
, METH_NOARGS
,
2837 _Py_islower__doc__
},
2838 {"isspace", (PyCFunction
)stringlib_isspace
, METH_NOARGS
,
2839 _Py_isspace__doc__
},
2840 {"istitle", (PyCFunction
)stringlib_istitle
, METH_NOARGS
,
2841 _Py_istitle__doc__
},
2842 {"isupper", (PyCFunction
)stringlib_isupper
, METH_NOARGS
,
2843 _Py_isupper__doc__
},
2844 {"join", (PyCFunction
)bytearray_join
, METH_O
, join_doc
},
2845 {"ljust", (PyCFunction
)stringlib_ljust
, METH_VARARGS
, ljust__doc__
},
2846 {"lower", (PyCFunction
)stringlib_lower
, METH_NOARGS
, _Py_lower__doc__
},
2847 {"lstrip", (PyCFunction
)bytearray_lstrip
, METH_VARARGS
, lstrip__doc__
},
2848 {"partition", (PyCFunction
)bytearray_partition
, METH_O
, partition__doc__
},
2849 {"pop", (PyCFunction
)bytearray_pop
, METH_VARARGS
, pop__doc__
},
2850 {"remove", (PyCFunction
)bytearray_remove
, METH_O
, remove__doc__
},
2851 {"replace", (PyCFunction
)bytearray_replace
, METH_VARARGS
, replace__doc__
},
2852 {"reverse", (PyCFunction
)bytearray_reverse
, METH_NOARGS
, reverse__doc__
},
2853 {"rfind", (PyCFunction
)bytearray_rfind
, METH_VARARGS
, rfind__doc__
},
2854 {"rindex", (PyCFunction
)bytearray_rindex
, METH_VARARGS
, rindex__doc__
},
2855 {"rjust", (PyCFunction
)stringlib_rjust
, METH_VARARGS
, rjust__doc__
},
2856 {"rpartition", (PyCFunction
)bytearray_rpartition
, METH_O
, rpartition__doc__
},
2857 {"rsplit", (PyCFunction
)bytearray_rsplit
, METH_VARARGS
, rsplit__doc__
},
2858 {"rstrip", (PyCFunction
)bytearray_rstrip
, METH_VARARGS
, rstrip__doc__
},
2859 {"split", (PyCFunction
)bytearray_split
, METH_VARARGS
, split__doc__
},
2860 {"splitlines", (PyCFunction
)bytearray_splitlines
, METH_VARARGS
,
2862 {"startswith", (PyCFunction
)bytearray_startswith
, METH_VARARGS
,
2864 {"strip", (PyCFunction
)bytearray_strip
, METH_VARARGS
, strip__doc__
},
2865 {"swapcase", (PyCFunction
)stringlib_swapcase
, METH_NOARGS
,
2866 _Py_swapcase__doc__
},
2867 {"title", (PyCFunction
)stringlib_title
, METH_NOARGS
, _Py_title__doc__
},
2868 {"translate", (PyCFunction
)bytearray_translate
, METH_VARARGS
,
2870 {"upper", (PyCFunction
)stringlib_upper
, METH_NOARGS
, _Py_upper__doc__
},
2871 {"zfill", (PyCFunction
)stringlib_zfill
, METH_VARARGS
, zfill__doc__
},
2875 PyDoc_STRVAR(bytearray_doc
,
2876 "bytearray(iterable_of_ints) -> bytearray.\n\
2877 bytearray(string, encoding[, errors]) -> bytearray.\n\
2878 bytearray(bytes_or_bytearray) -> mutable copy of bytes_or_bytearray.\n\
2879 bytearray(memory_view) -> bytearray.\n\
2881 Construct an mutable bytearray object from:\n\
2882 - an iterable yielding integers in range(256)\n\
2883 - a text string encoded using the specified encoding\n\
2884 - a bytes or a bytearray object\n\
2885 - any object implementing the buffer API.\n\
2887 bytearray(int) -> bytearray.\n\
2889 Construct a zero-initialized bytearray of the given length.");
2892 static PyObject
*bytearray_iter(PyObject
*seq
);
2894 PyTypeObject PyByteArray_Type
= {
2895 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
2897 sizeof(PyByteArrayObject
),
2899 (destructor
)bytearray_dealloc
, /* tp_dealloc */
2904 (reprfunc
)bytearray_repr
, /* tp_repr */
2905 0, /* tp_as_number */
2906 &bytearray_as_sequence
, /* tp_as_sequence */
2907 &bytearray_as_mapping
, /* tp_as_mapping */
2910 bytearray_str
, /* tp_str */
2911 PyObject_GenericGetAttr
, /* tp_getattro */
2912 0, /* tp_setattro */
2913 &bytearray_as_buffer
, /* tp_as_buffer */
2914 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
|
2915 Py_TPFLAGS_HAVE_NEWBUFFER
, /* tp_flags */
2916 bytearray_doc
, /* tp_doc */
2917 0, /* tp_traverse */
2919 (richcmpfunc
)bytearray_richcompare
, /* tp_richcompare */
2920 0, /* tp_weaklistoffset */
2921 bytearray_iter
, /* tp_iter */
2922 0, /* tp_iternext */
2923 bytearray_methods
, /* tp_methods */
2928 0, /* tp_descr_get */
2929 0, /* tp_descr_set */
2930 0, /* tp_dictoffset */
2931 (initproc
)bytearray_init
, /* tp_init */
2932 PyType_GenericAlloc
, /* tp_alloc */
2933 PyType_GenericNew
, /* tp_new */
2934 PyObject_Del
, /* tp_free */
2937 /*********************** Bytes Iterator ****************************/
2941 Py_ssize_t it_index
;
2942 PyByteArrayObject
*it_seq
; /* Set to NULL when iterator is exhausted */
2946 bytearrayiter_dealloc(bytesiterobject
*it
)
2948 _PyObject_GC_UNTRACK(it
);
2949 Py_XDECREF(it
->it_seq
);
2950 PyObject_GC_Del(it
);
2954 bytearrayiter_traverse(bytesiterobject
*it
, visitproc visit
, void *arg
)
2956 Py_VISIT(it
->it_seq
);
2961 bytearrayiter_next(bytesiterobject
*it
)
2963 PyByteArrayObject
*seq
;
2970 assert(PyByteArray_Check(seq
));
2972 if (it
->it_index
< PyByteArray_GET_SIZE(seq
)) {
2973 item
= PyInt_FromLong(
2974 (unsigned char)seq
->ob_bytes
[it
->it_index
]);
2986 bytesarrayiter_length_hint(bytesiterobject
*it
)
2990 len
= PyByteArray_GET_SIZE(it
->it_seq
) - it
->it_index
;
2991 return PyInt_FromSsize_t(len
);
2994 PyDoc_STRVAR(length_hint_doc
,
2995 "Private method returning an estimate of len(list(it)).");
2997 static PyMethodDef bytearrayiter_methods
[] = {
2998 {"__length_hint__", (PyCFunction
)bytesarrayiter_length_hint
, METH_NOARGS
,
3000 {NULL
, NULL
} /* sentinel */
3003 PyTypeObject PyByteArrayIter_Type
= {
3004 PyVarObject_HEAD_INIT(&PyType_Type
, 0)
3005 "bytearray_iterator", /* tp_name */
3006 sizeof(bytesiterobject
), /* tp_basicsize */
3007 0, /* tp_itemsize */
3009 (destructor
)bytearrayiter_dealloc
, /* tp_dealloc */
3015 0, /* tp_as_number */
3016 0, /* tp_as_sequence */
3017 0, /* tp_as_mapping */
3021 PyObject_GenericGetAttr
, /* tp_getattro */
3022 0, /* tp_setattro */
3023 0, /* tp_as_buffer */
3024 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_GC
, /* tp_flags */
3026 (traverseproc
)bytearrayiter_traverse
, /* tp_traverse */
3028 0, /* tp_richcompare */
3029 0, /* tp_weaklistoffset */
3030 PyObject_SelfIter
, /* tp_iter */
3031 (iternextfunc
)bytearrayiter_next
, /* tp_iternext */
3032 bytearrayiter_methods
, /* tp_methods */
3037 bytearray_iter(PyObject
*seq
)
3039 bytesiterobject
*it
;
3041 if (!PyByteArray_Check(seq
)) {
3042 PyErr_BadInternalCall();
3045 it
= PyObject_GC_New(bytesiterobject
, &PyByteArrayIter_Type
);
3050 it
->it_seq
= (PyByteArrayObject
*)seq
;
3051 _PyObject_GC_TRACK(it
);
3052 return (PyObject
*)it
;