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