1 /* Array object implementation */ 2 3 /* An array is a uniform list -- all items have the same type. 4 The item type is restricted to simple C types like int or float */ 5 6 #define PY_SSIZE_T_CLEAN 7 #include "Python.h" 8 #include "structmember.h" 9 10 #ifdef STDC_HEADERS 11 #include <stddef.h> 12 #else /* !STDC_HEADERS */ 13 #ifdef HAVE_SYS_TYPES_H 14 #include <sys/types.h> /* For size_t */ 15 #endif /* HAVE_SYS_TYPES_H */ 16 #endif /* !STDC_HEADERS */ 17 18 /*[clinic input] 19 module array 20 [clinic start generated code]*/ 21 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=7d1b8d7f5958fd83]*/ 22 23 struct arrayobject; /* Forward */ 24 25 /* All possible arraydescr values are defined in the vector "descriptors" 26 * below. That's defined later because the appropriate get and set 27 * functions aren't visible yet. 28 */ 29 struct arraydescr { 30 char typecode; 31 int itemsize; 32 PyObject * (*getitem)(struct arrayobject *, Py_ssize_t); 33 int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *); 34 const char *formats; 35 int is_integer_type; 36 int is_signed; 37 }; 38 39 typedef struct arrayobject { 40 PyObject_VAR_HEAD 41 char *ob_item; 42 Py_ssize_t allocated; 43 const struct arraydescr *ob_descr; 44 PyObject *weakreflist; /* List of weak references */ 45 int ob_exports; /* Number of exported buffers */ 46 } arrayobject; 47 48 static PyTypeObject Arraytype; 49 50 typedef struct { 51 PyObject_HEAD 52 Py_ssize_t index; 53 arrayobject *ao; 54 PyObject* (*getitem)(struct arrayobject *, Py_ssize_t); 55 } arrayiterobject; 56 57 static PyTypeObject PyArrayIter_Type; 58 59 #define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type) 60 61 enum machine_format_code { 62 UNKNOWN_FORMAT = -1, 63 /* UNKNOWN_FORMAT is used to indicate that the machine format for an 64 * array type code cannot be interpreted. When this occurs, a list of 65 * Python objects is used to represent the content of the array 66 * instead of using the memory content of the array directly. In that 67 * case, the array_reconstructor mechanism is bypassed completely, and 68 * the standard array constructor is used instead. 69 * 70 * This is will most likely occur when the machine doesn't use IEEE 71 * floating-point numbers. 72 */ 73 74 UNSIGNED_INT8 = 0, 75 SIGNED_INT8 = 1, 76 UNSIGNED_INT16_LE = 2, 77 UNSIGNED_INT16_BE = 3, 78 SIGNED_INT16_LE = 4, 79 SIGNED_INT16_BE = 5, 80 UNSIGNED_INT32_LE = 6, 81 UNSIGNED_INT32_BE = 7, 82 SIGNED_INT32_LE = 8, 83 SIGNED_INT32_BE = 9, 84 UNSIGNED_INT64_LE = 10, 85 UNSIGNED_INT64_BE = 11, 86 SIGNED_INT64_LE = 12, 87 SIGNED_INT64_BE = 13, 88 IEEE_754_FLOAT_LE = 14, 89 IEEE_754_FLOAT_BE = 15, 90 IEEE_754_DOUBLE_LE = 16, 91 IEEE_754_DOUBLE_BE = 17, 92 UTF16_LE = 18, 93 UTF16_BE = 19, 94 UTF32_LE = 20, 95 UTF32_BE = 21 96 }; 97 #define MACHINE_FORMAT_CODE_MIN 0 98 #define MACHINE_FORMAT_CODE_MAX 21 99 100 101 /* 102 * Must come after arrayobject, arrayiterobject, 103 * and enum machine_code_type definitions. 104 */ 105 #include "clinic/arraymodule.c.h" 106 107 #define array_Check(op) PyObject_TypeCheck(op, &Arraytype) 108 #define array_CheckExact(op) (Py_TYPE(op) == &Arraytype) 109 110 static int 111 array_resize(arrayobject *self, Py_ssize_t newsize) 112 { 113 char *items; 114 size_t _new_size; 115 116 if (self->ob_exports > 0 && newsize != Py_SIZE(self)) { 117 PyErr_SetString(PyExc_BufferError, 118 "cannot resize an array that is exporting buffers"); 119 return -1; 120 } 121 122 /* Bypass realloc() when a previous overallocation is large enough 123 to accommodate the newsize. If the newsize is 16 smaller than the 124 current size, then proceed with the realloc() to shrink the array. 125 */ 126 127 if (self->allocated >= newsize && 128 Py_SIZE(self) < newsize + 16 && 129 self->ob_item != NULL) { 130 Py_SIZE(self) = newsize; 131 return 0; 132 } 133 134 if (newsize == 0) { 135 PyMem_FREE(self->ob_item); 136 self->ob_item = NULL; 137 Py_SIZE(self) = 0; 138 self->allocated = 0; 139 return 0; 140 } 141 142 /* This over-allocates proportional to the array size, making room 143 * for additional growth. The over-allocation is mild, but is 144 * enough to give linear-time amortized behavior over a long 145 * sequence of appends() in the presence of a poorly-performing 146 * system realloc(). 147 * The growth pattern is: 0, 4, 8, 16, 25, 34, 46, 56, 67, 79, ... 148 * Note, the pattern starts out the same as for lists but then 149 * grows at a smaller rate so that larger arrays only overallocate 150 * by about 1/16th -- this is done because arrays are presumed to be more 151 * memory critical. 152 */ 153 154 _new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize; 155 items = self->ob_item; 156 /* XXX The following multiplication and division does not optimize away 157 like it does for lists since the size is not known at compile time */ 158 if (_new_size <= ((~(size_t)0) / self->ob_descr->itemsize)) 159 PyMem_RESIZE(items, char, (_new_size * self->ob_descr->itemsize)); 160 else 161 items = NULL; 162 if (items == NULL) { 163 PyErr_NoMemory(); 164 return -1; 165 } 166 self->ob_item = items; 167 Py_SIZE(self) = newsize; 168 self->allocated = _new_size; 169 return 0; 170 } 171 172 /**************************************************************************** 173 Get and Set functions for each type. 174 A Get function takes an arrayobject* and an integer index, returning the 175 array value at that index wrapped in an appropriate PyObject*. 176 A Set function takes an arrayobject, integer index, and PyObject*; sets 177 the array value at that index to the raw C data extracted from the PyObject*, 178 and returns 0 if successful, else nonzero on failure (PyObject* not of an 179 appropriate type or value). 180 Note that the basic Get and Set functions do NOT check that the index is 181 in bounds; that's the responsibility of the caller. 182 ****************************************************************************/ 183 184 static PyObject * 185 b_getitem(arrayobject *ap, Py_ssize_t i) 186 { 187 long x = ((char *)ap->ob_item)[i]; 188 if (x >= 128) 189 x -= 256; 190 return PyLong_FromLong(x); 191 } 192 193 static int 194 b_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 195 { 196 short x; 197 /* PyArg_Parse's 'b' formatter is for an unsigned char, therefore 198 must use the next size up that is signed ('h') and manually do 199 the overflow checking */ 200 if (!PyArg_Parse(v, "h;array item must be integer", &x)) 201 return -1; 202 else if (x < -128) { 203 PyErr_SetString(PyExc_OverflowError, 204 "signed char is less than minimum"); 205 return -1; 206 } 207 else if (x > 127) { 208 PyErr_SetString(PyExc_OverflowError, 209 "signed char is greater than maximum"); 210 return -1; 211 } 212 if (i >= 0) 213 ((char *)ap->ob_item)[i] = (char)x; 214 return 0; 215 } 216 217 static PyObject * 218 BB_getitem(arrayobject *ap, Py_ssize_t i) 219 { 220 long x = ((unsigned char *)ap->ob_item)[i]; 221 return PyLong_FromLong(x); 222 } 223 224 static int 225 BB_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 226 { 227 unsigned char x; 228 /* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */ 229 if (!PyArg_Parse(v, "b;array item must be integer", &x)) 230 return -1; 231 if (i >= 0) 232 ((char *)ap->ob_item)[i] = x; 233 return 0; 234 } 235 236 static PyObject * 237 u_getitem(arrayobject *ap, Py_ssize_t i) 238 { 239 return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1); 240 } 241 242 static int 243 u_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 244 { 245 Py_UNICODE *p; 246 Py_ssize_t len; 247 248 if (!PyArg_Parse(v, "u#;array item must be unicode character", &p, &len)) 249 return -1; 250 if (len != 1) { 251 PyErr_SetString(PyExc_TypeError, 252 "array item must be unicode character"); 253 return -1; 254 } 255 if (i >= 0) 256 ((Py_UNICODE *)ap->ob_item)[i] = p[0]; 257 return 0; 258 } 259 260 261 static PyObject * 262 h_getitem(arrayobject *ap, Py_ssize_t i) 263 { 264 return PyLong_FromLong((long) ((short *)ap->ob_item)[i]); 265 } 266 267 268 static int 269 h_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 270 { 271 short x; 272 /* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */ 273 if (!PyArg_Parse(v, "h;array item must be integer", &x)) 274 return -1; 275 if (i >= 0) 276 ((short *)ap->ob_item)[i] = x; 277 return 0; 278 } 279 280 static PyObject * 281 HH_getitem(arrayobject *ap, Py_ssize_t i) 282 { 283 return PyLong_FromLong((long) ((unsigned short *)ap->ob_item)[i]); 284 } 285 286 static int 287 HH_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 288 { 289 int x; 290 /* PyArg_Parse's 'h' formatter is for a signed short, therefore 291 must use the next size up and manually do the overflow checking */ 292 if (!PyArg_Parse(v, "i;array item must be integer", &x)) 293 return -1; 294 else if (x < 0) { 295 PyErr_SetString(PyExc_OverflowError, 296 "unsigned short is less than minimum"); 297 return -1; 298 } 299 else if (x > USHRT_MAX) { 300 PyErr_SetString(PyExc_OverflowError, 301 "unsigned short is greater than maximum"); 302 return -1; 303 } 304 if (i >= 0) 305 ((short *)ap->ob_item)[i] = (short)x; 306 return 0; 307 } 308 309 static PyObject * 310 i_getitem(arrayobject *ap, Py_ssize_t i) 311 { 312 return PyLong_FromLong((long) ((int *)ap->ob_item)[i]); 313 } 314 315 static int 316 i_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 317 { 318 int x; 319 /* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */ 320 if (!PyArg_Parse(v, "i;array item must be integer", &x)) 321 return -1; 322 if (i >= 0) 323 ((int *)ap->ob_item)[i] = x; 324 return 0; 325 } 326 327 static PyObject * 328 II_getitem(arrayobject *ap, Py_ssize_t i) 329 { 330 return PyLong_FromUnsignedLong( 331 (unsigned long) ((unsigned int *)ap->ob_item)[i]); 332 } 333 334 static int 335 II_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 336 { 337 unsigned long x; 338 if (PyLong_Check(v)) { 339 x = PyLong_AsUnsignedLong(v); 340 if (x == (unsigned long) -1 && PyErr_Occurred()) 341 return -1; 342 } 343 else { 344 long y; 345 if (!PyArg_Parse(v, "l;array item must be integer", &y)) 346 return -1; 347 if (y < 0) { 348 PyErr_SetString(PyExc_OverflowError, 349 "unsigned int is less than minimum"); 350 return -1; 351 } 352 x = (unsigned long)y; 353 354 } 355 if (x > UINT_MAX) { 356 PyErr_SetString(PyExc_OverflowError, 357 "unsigned int is greater than maximum"); 358 return -1; 359 } 360 361 if (i >= 0) 362 ((unsigned int *)ap->ob_item)[i] = (unsigned int)x; 363 return 0; 364 } 365 366 static PyObject * 367 l_getitem(arrayobject *ap, Py_ssize_t i) 368 { 369 return PyLong_FromLong(((long *)ap->ob_item)[i]); 370 } 371 372 static int 373 l_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 374 { 375 long x; 376 if (!PyArg_Parse(v, "l;array item must be integer", &x)) 377 return -1; 378 if (i >= 0) 379 ((long *)ap->ob_item)[i] = x; 380 return 0; 381 } 382 383 static PyObject * 384 LL_getitem(arrayobject *ap, Py_ssize_t i) 385 { 386 return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]); 387 } 388 389 static int 390 LL_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 391 { 392 unsigned long x; 393 if (PyLong_Check(v)) { 394 x = PyLong_AsUnsignedLong(v); 395 if (x == (unsigned long) -1 && PyErr_Occurred()) 396 return -1; 397 } 398 else { 399 long y; 400 if (!PyArg_Parse(v, "l;array item must be integer", &y)) 401 return -1; 402 if (y < 0) { 403 PyErr_SetString(PyExc_OverflowError, 404 "unsigned long is less than minimum"); 405 return -1; 406 } 407 x = (unsigned long)y; 408 409 } 410 if (x > ULONG_MAX) { 411 PyErr_SetString(PyExc_OverflowError, 412 "unsigned long is greater than maximum"); 413 return -1; 414 } 415 416 if (i >= 0) 417 ((unsigned long *)ap->ob_item)[i] = x; 418 return 0; 419 } 420 421 static PyObject * 422 q_getitem(arrayobject *ap, Py_ssize_t i) 423 { 424 return PyLong_FromLongLong(((long long *)ap->ob_item)[i]); 425 } 426 427 static int 428 q_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 429 { 430 long long x; 431 if (!PyArg_Parse(v, "L;array item must be integer", &x)) 432 return -1; 433 if (i >= 0) 434 ((long long *)ap->ob_item)[i] = x; 435 return 0; 436 } 437 438 static PyObject * 439 QQ_getitem(arrayobject *ap, Py_ssize_t i) 440 { 441 return PyLong_FromUnsignedLongLong( 442 ((unsigned long long *)ap->ob_item)[i]); 443 } 444 445 static int 446 QQ_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 447 { 448 unsigned long long x; 449 if (PyLong_Check(v)) { 450 x = PyLong_AsUnsignedLongLong(v); 451 if (x == (unsigned long long) -1 && PyErr_Occurred()) 452 return -1; 453 } 454 else { 455 long long y; 456 if (!PyArg_Parse(v, "L;array item must be integer", &y)) 457 return -1; 458 if (y < 0) { 459 PyErr_SetString(PyExc_OverflowError, 460 "unsigned long long is less than minimum"); 461 return -1; 462 } 463 x = (unsigned long long)y; 464 } 465 466 if (i >= 0) 467 ((unsigned long long *)ap->ob_item)[i] = x; 468 return 0; 469 } 470 471 static PyObject * 472 f_getitem(arrayobject *ap, Py_ssize_t i) 473 { 474 return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]); 475 } 476 477 static int 478 f_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 479 { 480 float x; 481 if (!PyArg_Parse(v, "f;array item must be float", &x)) 482 return -1; 483 if (i >= 0) 484 ((float *)ap->ob_item)[i] = x; 485 return 0; 486 } 487 488 static PyObject * 489 d_getitem(arrayobject *ap, Py_ssize_t i) 490 { 491 return PyFloat_FromDouble(((double *)ap->ob_item)[i]); 492 } 493 494 static int 495 d_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 496 { 497 double x; 498 if (!PyArg_Parse(v, "d;array item must be float", &x)) 499 return -1; 500 if (i >= 0) 501 ((double *)ap->ob_item)[i] = x; 502 return 0; 503 } 504 505 506 /* Description of types. 507 * 508 * Don't forget to update typecode_to_mformat_code() if you add a new 509 * typecode. 510 */ 511 static const struct arraydescr descriptors[] = { 512 {'b', 1, b_getitem, b_setitem, "b", 1, 1}, 513 {'B', 1, BB_getitem, BB_setitem, "B", 1, 0}, 514 {'u', sizeof(Py_UNICODE), u_getitem, u_setitem, "u", 0, 0}, 515 {'h', sizeof(short), h_getitem, h_setitem, "h", 1, 1}, 516 {'H', sizeof(short), HH_getitem, HH_setitem, "H", 1, 0}, 517 {'i', sizeof(int), i_getitem, i_setitem, "i", 1, 1}, 518 {'I', sizeof(int), II_getitem, II_setitem, "I", 1, 0}, 519 {'l', sizeof(long), l_getitem, l_setitem, "l", 1, 1}, 520 {'L', sizeof(long), LL_getitem, LL_setitem, "L", 1, 0}, 521 {'q', sizeof(long long), q_getitem, q_setitem, "q", 1, 1}, 522 {'Q', sizeof(long long), QQ_getitem, QQ_setitem, "Q", 1, 0}, 523 {'f', sizeof(float), f_getitem, f_setitem, "f", 0, 0}, 524 {'d', sizeof(double), d_getitem, d_setitem, "d", 0, 0}, 525 {'\0', 0, 0, 0, 0, 0, 0} /* Sentinel */ 526 }; 527 528 /**************************************************************************** 529 Implementations of array object methods. 530 ****************************************************************************/ 531 /*[clinic input] 532 class array.array "arrayobject *" "&Arraytype" 533 [clinic start generated code]*/ 534 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=ad43d37e942a8854]*/ 535 536 static PyObject * 537 newarrayobject(PyTypeObject *type, Py_ssize_t size, const struct arraydescr *descr) 538 { 539 arrayobject *op; 540 size_t nbytes; 541 542 if (size < 0) { 543 PyErr_BadInternalCall(); 544 return NULL; 545 } 546 547 /* Check for overflow */ 548 if (size > PY_SSIZE_T_MAX / descr->itemsize) { 549 return PyErr_NoMemory(); 550 } 551 nbytes = size * descr->itemsize; 552 op = (arrayobject *) type->tp_alloc(type, 0); 553 if (op == NULL) { 554 return NULL; 555 } 556 op->ob_descr = descr; 557 op->allocated = size; 558 op->weakreflist = NULL; 559 Py_SIZE(op) = size; 560 if (size <= 0) { 561 op->ob_item = NULL; 562 } 563 else { 564 op->ob_item = PyMem_NEW(char, nbytes); 565 if (op->ob_item == NULL) { 566 Py_DECREF(op); 567 return PyErr_NoMemory(); 568 } 569 } 570 op->ob_exports = 0; 571 return (PyObject *) op; 572 } 573 574 static PyObject * 575 getarrayitem(PyObject *op, Py_ssize_t i) 576 { 577 arrayobject *ap; 578 assert(array_Check(op)); 579 ap = (arrayobject *)op; 580 assert(i>=0 && i<Py_SIZE(ap)); 581 return (*ap->ob_descr->getitem)(ap, i); 582 } 583 584 static int 585 ins1(arrayobject *self, Py_ssize_t where, PyObject *v) 586 { 587 char *items; 588 Py_ssize_t n = Py_SIZE(self); 589 if (v == NULL) { 590 PyErr_BadInternalCall(); 591 return -1; 592 } 593 if ((*self->ob_descr->setitem)(self, -1, v) < 0) 594 return -1; 595 596 if (array_resize(self, n+1) == -1) 597 return -1; 598 items = self->ob_item; 599 if (where < 0) { 600 where += n; 601 if (where < 0) 602 where = 0; 603 } 604 if (where > n) 605 where = n; 606 /* appends don't need to call memmove() */ 607 if (where != n) 608 memmove(items + (where+1)*self->ob_descr->itemsize, 609 items + where*self->ob_descr->itemsize, 610 (n-where)*self->ob_descr->itemsize); 611 return (*self->ob_descr->setitem)(self, where, v); 612 } 613 614 /* Methods */ 615 616 static void 617 array_dealloc(arrayobject *op) 618 { 619 if (op->weakreflist != NULL) 620 PyObject_ClearWeakRefs((PyObject *) op); 621 if (op->ob_item != NULL) 622 PyMem_DEL(op->ob_item); 623 Py_TYPE(op)->tp_free((PyObject *)op); 624 } 625 626 static PyObject * 627 array_richcompare(PyObject *v, PyObject *w, int op) 628 { 629 arrayobject *va, *wa; 630 PyObject *vi = NULL; 631 PyObject *wi = NULL; 632 Py_ssize_t i, k; 633 PyObject *res; 634 635 if (!array_Check(v) || !array_Check(w)) 636 Py_RETURN_NOTIMPLEMENTED; 637 638 va = (arrayobject *)v; 639 wa = (arrayobject *)w; 640 641 if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ || op == Py_NE)) { 642 /* Shortcut: if the lengths differ, the arrays differ */ 643 if (op == Py_EQ) 644 res = Py_False; 645 else 646 res = Py_True; 647 Py_INCREF(res); 648 return res; 649 } 650 651 /* Search for the first index where items are different */ 652 k = 1; 653 for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) { 654 vi = getarrayitem(v, i); 655 wi = getarrayitem(w, i); 656 if (vi == NULL || wi == NULL) { 657 Py_XDECREF(vi); 658 Py_XDECREF(wi); 659 return NULL; 660 } 661 k = PyObject_RichCompareBool(vi, wi, Py_EQ); 662 if (k == 0) 663 break; /* Keeping vi and wi alive! */ 664 Py_DECREF(vi); 665 Py_DECREF(wi); 666 if (k < 0) 667 return NULL; 668 } 669 670 if (k) { 671 /* No more items to compare -- compare sizes */ 672 Py_ssize_t vs = Py_SIZE(va); 673 Py_ssize_t ws = Py_SIZE(wa); 674 int cmp; 675 switch (op) { 676 case Py_LT: cmp = vs < ws; break; 677 case Py_LE: cmp = vs <= ws; break; 678 case Py_EQ: cmp = vs == ws; break; 679 case Py_NE: cmp = vs != ws; break; 680 case Py_GT: cmp = vs > ws; break; 681 case Py_GE: cmp = vs >= ws; break; 682 default: return NULL; /* cannot happen */ 683 } 684 if (cmp) 685 res = Py_True; 686 else 687 res = Py_False; 688 Py_INCREF(res); 689 return res; 690 } 691 692 /* We have an item that differs. First, shortcuts for EQ/NE */ 693 if (op == Py_EQ) { 694 Py_INCREF(Py_False); 695 res = Py_False; 696 } 697 else if (op == Py_NE) { 698 Py_INCREF(Py_True); 699 res = Py_True; 700 } 701 else { 702 /* Compare the final item again using the proper operator */ 703 res = PyObject_RichCompare(vi, wi, op); 704 } 705 Py_DECREF(vi); 706 Py_DECREF(wi); 707 return res; 708 } 709 710 static Py_ssize_t 711 array_length(arrayobject *a) 712 { 713 return Py_SIZE(a); 714 } 715 716 static PyObject * 717 array_item(arrayobject *a, Py_ssize_t i) 718 { 719 if (i < 0 || i >= Py_SIZE(a)) { 720 PyErr_SetString(PyExc_IndexError, "array index out of range"); 721 return NULL; 722 } 723 return getarrayitem((PyObject *)a, i); 724 } 725 726 static PyObject * 727 array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh) 728 { 729 arrayobject *np; 730 if (ilow < 0) 731 ilow = 0; 732 else if (ilow > Py_SIZE(a)) 733 ilow = Py_SIZE(a); 734 if (ihigh < 0) 735 ihigh = 0; 736 if (ihigh < ilow) 737 ihigh = ilow; 738 else if (ihigh > Py_SIZE(a)) 739 ihigh = Py_SIZE(a); 740 np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr); 741 if (np == NULL) 742 return NULL; 743 if (ihigh > ilow) { 744 memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize, 745 (ihigh-ilow) * a->ob_descr->itemsize); 746 } 747 return (PyObject *)np; 748 } 749 750 751 /*[clinic input] 752 array.array.__copy__ 753 754 Return a copy of the array. 755 [clinic start generated code]*/ 756 757 static PyObject * 758 array_array___copy___impl(arrayobject *self) 759 /*[clinic end generated code: output=dec7c3f925d9619e input=ad1ee5b086965f09]*/ 760 { 761 return array_slice(self, 0, Py_SIZE(self)); 762 } 763 764 /*[clinic input] 765 array.array.__deepcopy__ 766 767 unused: object 768 / 769 770 Return a copy of the array. 771 [clinic start generated code]*/ 772 773 static PyObject * 774 array_array___deepcopy__(arrayobject *self, PyObject *unused) 775 /*[clinic end generated code: output=1ec748d8e14a9faa input=2405ecb4933748c4]*/ 776 { 777 return array_array___copy___impl(self); 778 } 779 780 static PyObject * 781 array_concat(arrayobject *a, PyObject *bb) 782 { 783 Py_ssize_t size; 784 arrayobject *np; 785 if (!array_Check(bb)) { 786 PyErr_Format(PyExc_TypeError, 787 "can only append array (not \"%.200s\") to array", 788 Py_TYPE(bb)->tp_name); 789 return NULL; 790 } 791 #define b ((arrayobject *)bb) 792 if (a->ob_descr != b->ob_descr) { 793 PyErr_BadArgument(); 794 return NULL; 795 } 796 if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) { 797 return PyErr_NoMemory(); 798 } 799 size = Py_SIZE(a) + Py_SIZE(b); 800 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr); 801 if (np == NULL) { 802 return NULL; 803 } 804 if (Py_SIZE(a) > 0) { 805 memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize); 806 } 807 if (Py_SIZE(b) > 0) { 808 memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize, 809 b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize); 810 } 811 return (PyObject *)np; 812 #undef b 813 } 814 815 static PyObject * 816 array_repeat(arrayobject *a, Py_ssize_t n) 817 { 818 Py_ssize_t size; 819 arrayobject *np; 820 Py_ssize_t oldbytes, newbytes; 821 if (n < 0) 822 n = 0; 823 if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) { 824 return PyErr_NoMemory(); 825 } 826 size = Py_SIZE(a) * n; 827 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr); 828 if (np == NULL) 829 return NULL; 830 if (size == 0) 831 return (PyObject *)np; 832 oldbytes = Py_SIZE(a) * a->ob_descr->itemsize; 833 newbytes = oldbytes * n; 834 /* this follows the code in unicode_repeat */ 835 if (oldbytes == 1) { 836 memset(np->ob_item, a->ob_item[0], newbytes); 837 } else { 838 Py_ssize_t done = oldbytes; 839 memcpy(np->ob_item, a->ob_item, oldbytes); 840 while (done < newbytes) { 841 Py_ssize_t ncopy = (done <= newbytes-done) ? done : newbytes-done; 842 memcpy(np->ob_item+done, np->ob_item, ncopy); 843 done += ncopy; 844 } 845 } 846 return (PyObject *)np; 847 } 848 849 static int 850 array_del_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh) 851 { 852 char *item; 853 Py_ssize_t d; /* Change in size */ 854 if (ilow < 0) 855 ilow = 0; 856 else if (ilow > Py_SIZE(a)) 857 ilow = Py_SIZE(a); 858 if (ihigh < 0) 859 ihigh = 0; 860 if (ihigh < ilow) 861 ihigh = ilow; 862 else if (ihigh > Py_SIZE(a)) 863 ihigh = Py_SIZE(a); 864 item = a->ob_item; 865 d = ihigh-ilow; 866 /* Issue #4509: If the array has exported buffers and the slice 867 assignment would change the size of the array, fail early to make 868 sure we don't modify it. */ 869 if (d != 0 && a->ob_exports > 0) { 870 PyErr_SetString(PyExc_BufferError, 871 "cannot resize an array that is exporting buffers"); 872 return -1; 873 } 874 if (d > 0) { /* Delete d items */ 875 memmove(item + (ihigh-d)*a->ob_descr->itemsize, 876 item + ihigh*a->ob_descr->itemsize, 877 (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize); 878 if (array_resize(a, Py_SIZE(a) - d) == -1) 879 return -1; 880 } 881 return 0; 882 } 883 884 static int 885 array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v) 886 { 887 if (i < 0 || i >= Py_SIZE(a)) { 888 PyErr_SetString(PyExc_IndexError, 889 "array assignment index out of range"); 890 return -1; 891 } 892 if (v == NULL) 893 return array_del_slice(a, i, i+1); 894 return (*a->ob_descr->setitem)(a, i, v); 895 } 896 897 static int 898 setarrayitem(PyObject *a, Py_ssize_t i, PyObject *v) 899 { 900 assert(array_Check(a)); 901 return array_ass_item((arrayobject *)a, i, v); 902 } 903 904 static int 905 array_iter_extend(arrayobject *self, PyObject *bb) 906 { 907 PyObject *it, *v; 908 909 it = PyObject_GetIter(bb); 910 if (it == NULL) 911 return -1; 912 913 while ((v = PyIter_Next(it)) != NULL) { 914 if (ins1(self, Py_SIZE(self), v) != 0) { 915 Py_DECREF(v); 916 Py_DECREF(it); 917 return -1; 918 } 919 Py_DECREF(v); 920 } 921 Py_DECREF(it); 922 if (PyErr_Occurred()) 923 return -1; 924 return 0; 925 } 926 927 static int 928 array_do_extend(arrayobject *self, PyObject *bb) 929 { 930 Py_ssize_t size, oldsize, bbsize; 931 932 if (!array_Check(bb)) 933 return array_iter_extend(self, bb); 934 #define b ((arrayobject *)bb) 935 if (self->ob_descr != b->ob_descr) { 936 PyErr_SetString(PyExc_TypeError, 937 "can only extend with array of same kind"); 938 return -1; 939 } 940 if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) || 941 ((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) { 942 PyErr_NoMemory(); 943 return -1; 944 } 945 oldsize = Py_SIZE(self); 946 /* Get the size of bb before resizing the array since bb could be self. */ 947 bbsize = Py_SIZE(bb); 948 size = oldsize + Py_SIZE(b); 949 if (array_resize(self, size) == -1) 950 return -1; 951 if (bbsize > 0) { 952 memcpy(self->ob_item + oldsize * self->ob_descr->itemsize, 953 b->ob_item, bbsize * b->ob_descr->itemsize); 954 } 955 956 return 0; 957 #undef b 958 } 959 960 static PyObject * 961 array_inplace_concat(arrayobject *self, PyObject *bb) 962 { 963 if (!array_Check(bb)) { 964 PyErr_Format(PyExc_TypeError, 965 "can only extend array with array (not \"%.200s\")", 966 Py_TYPE(bb)->tp_name); 967 return NULL; 968 } 969 if (array_do_extend(self, bb) == -1) 970 return NULL; 971 Py_INCREF(self); 972 return (PyObject *)self; 973 } 974 975 static PyObject * 976 array_inplace_repeat(arrayobject *self, Py_ssize_t n) 977 { 978 char *items, *p; 979 Py_ssize_t size, i; 980 981 if (Py_SIZE(self) > 0) { 982 if (n < 0) 983 n = 0; 984 if ((self->ob_descr->itemsize != 0) && 985 (Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) { 986 return PyErr_NoMemory(); 987 } 988 size = Py_SIZE(self) * self->ob_descr->itemsize; 989 if (n > 0 && size > PY_SSIZE_T_MAX / n) { 990 return PyErr_NoMemory(); 991 } 992 if (array_resize(self, n * Py_SIZE(self)) == -1) 993 return NULL; 994 items = p = self->ob_item; 995 for (i = 1; i < n; i++) { 996 p += size; 997 memcpy(p, items, size); 998 } 999 } 1000 Py_INCREF(self); 1001 return (PyObject *)self; 1002 } 1003 1004 1005 static PyObject * 1006 ins(arrayobject *self, Py_ssize_t where, PyObject *v) 1007 { 1008 if (ins1(self, where, v) != 0) 1009 return NULL; 1010 Py_INCREF(Py_None); 1011 return Py_None; 1012 } 1013 1014 /*[clinic input] 1015 array.array.count 1016 1017 v: object 1018 / 1019 1020 Return number of occurrences of v in the array. 1021 [clinic start generated code]*/ 1022 1023 static PyObject * 1024 array_array_count(arrayobject *self, PyObject *v) 1025 /*[clinic end generated code: output=3dd3624bf7135a3a input=d9bce9d65e39d1f5]*/ 1026 { 1027 Py_ssize_t count = 0; 1028 Py_ssize_t i; 1029 1030 for (i = 0; i < Py_SIZE(self); i++) { 1031 PyObject *selfi; 1032 int cmp; 1033 1034 selfi = getarrayitem((PyObject *)self, i); 1035 if (selfi == NULL) 1036 return NULL; 1037 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ); 1038 Py_DECREF(selfi); 1039 if (cmp > 0) 1040 count++; 1041 else if (cmp < 0) 1042 return NULL; 1043 } 1044 return PyLong_FromSsize_t(count); 1045 } 1046 1047 1048 /*[clinic input] 1049 array.array.index 1050 1051 v: object 1052 / 1053 1054 Return index of first occurrence of v in the array. 1055 [clinic start generated code]*/ 1056 1057 static PyObject * 1058 array_array_index(arrayobject *self, PyObject *v) 1059 /*[clinic end generated code: output=d48498d325602167 input=cf619898c6649d08]*/ 1060 { 1061 Py_ssize_t i; 1062 1063 for (i = 0; i < Py_SIZE(self); i++) { 1064 PyObject *selfi; 1065 int cmp; 1066 1067 selfi = getarrayitem((PyObject *)self, i); 1068 if (selfi == NULL) 1069 return NULL; 1070 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ); 1071 Py_DECREF(selfi); 1072 if (cmp > 0) { 1073 return PyLong_FromLong((long)i); 1074 } 1075 else if (cmp < 0) 1076 return NULL; 1077 } 1078 PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list"); 1079 return NULL; 1080 } 1081 1082 static int 1083 array_contains(arrayobject *self, PyObject *v) 1084 { 1085 Py_ssize_t i; 1086 int cmp; 1087 1088 for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) { 1089 PyObject *selfi = getarrayitem((PyObject *)self, i); 1090 if (selfi == NULL) 1091 return -1; 1092 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ); 1093 Py_DECREF(selfi); 1094 } 1095 return cmp; 1096 } 1097 1098 /*[clinic input] 1099 array.array.remove 1100 1101 v: object 1102 / 1103 1104 Remove the first occurrence of v in the array. 1105 [clinic start generated code]*/ 1106 1107 static PyObject * 1108 array_array_remove(arrayobject *self, PyObject *v) 1109 /*[clinic end generated code: output=bef06be9fdf9dceb input=0b1e5aed25590027]*/ 1110 { 1111 int i; 1112 1113 for (i = 0; i < Py_SIZE(self); i++) { 1114 PyObject *selfi; 1115 int cmp; 1116 1117 selfi = getarrayitem((PyObject *)self,i); 1118 if (selfi == NULL) 1119 return NULL; 1120 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ); 1121 Py_DECREF(selfi); 1122 if (cmp > 0) { 1123 if (array_del_slice(self, i, i+1) != 0) 1124 return NULL; 1125 Py_INCREF(Py_None); 1126 return Py_None; 1127 } 1128 else if (cmp < 0) 1129 return NULL; 1130 } 1131 PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list"); 1132 return NULL; 1133 } 1134 1135 /*[clinic input] 1136 array.array.pop 1137 1138 i: Py_ssize_t = -1 1139 / 1140 1141 Return the i-th element and delete it from the array. 1142 1143 i defaults to -1. 1144 [clinic start generated code]*/ 1145 1146 static PyObject * 1147 array_array_pop_impl(arrayobject *self, Py_ssize_t i) 1148 /*[clinic end generated code: output=bc1f0c54fe5308e4 input=8e5feb4c1a11cd44]*/ 1149 { 1150 PyObject *v; 1151 1152 if (Py_SIZE(self) == 0) { 1153 /* Special-case most common failure cause */ 1154 PyErr_SetString(PyExc_IndexError, "pop from empty array"); 1155 return NULL; 1156 } 1157 if (i < 0) 1158 i += Py_SIZE(self); 1159 if (i < 0 || i >= Py_SIZE(self)) { 1160 PyErr_SetString(PyExc_IndexError, "pop index out of range"); 1161 return NULL; 1162 } 1163 v = getarrayitem((PyObject *)self, i); 1164 if (v == NULL) 1165 return NULL; 1166 if (array_del_slice(self, i, i+1) != 0) { 1167 Py_DECREF(v); 1168 return NULL; 1169 } 1170 return v; 1171 } 1172 1173 /*[clinic input] 1174 array.array.extend 1175 1176 bb: object 1177 / 1178 1179 Append items to the end of the array. 1180 [clinic start generated code]*/ 1181 1182 static PyObject * 1183 array_array_extend(arrayobject *self, PyObject *bb) 1184 /*[clinic end generated code: output=bbddbc8e8bef871d input=43be86aba5c31e44]*/ 1185 { 1186 if (array_do_extend(self, bb) == -1) 1187 return NULL; 1188 Py_INCREF(Py_None); 1189 return Py_None; 1190 } 1191 1192 /*[clinic input] 1193 array.array.insert 1194 1195 i: Py_ssize_t 1196 v: object 1197 / 1198 1199 Insert a new item v into the array before position i. 1200 [clinic start generated code]*/ 1201 1202 static PyObject * 1203 array_array_insert_impl(arrayobject *self, Py_ssize_t i, PyObject *v) 1204 /*[clinic end generated code: output=5a3648e278348564 input=5577d1b4383e9313]*/ 1205 { 1206 return ins(self, i, v); 1207 } 1208 1209 /*[clinic input] 1210 array.array.buffer_info 1211 1212 Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array's contents. 1213 1214 The length should be multiplied by the itemsize attribute to calculate 1215 the buffer length in bytes. 1216 [clinic start generated code]*/ 1217 1218 static PyObject * 1219 array_array_buffer_info_impl(arrayobject *self) 1220 /*[clinic end generated code: output=9b2a4ec3ae7e98e7 input=a58bae5c6e1ac6a6]*/ 1221 { 1222 PyObject *retval = NULL, *v; 1223 1224 retval = PyTuple_New(2); 1225 if (!retval) 1226 return NULL; 1227 1228 v = PyLong_FromVoidPtr(self->ob_item); 1229 if (v == NULL) { 1230 Py_DECREF(retval); 1231 return NULL; 1232 } 1233 PyTuple_SET_ITEM(retval, 0, v); 1234 1235 v = PyLong_FromSsize_t(Py_SIZE(self)); 1236 if (v == NULL) { 1237 Py_DECREF(retval); 1238 return NULL; 1239 } 1240 PyTuple_SET_ITEM(retval, 1, v); 1241 1242 return retval; 1243 } 1244 1245 /*[clinic input] 1246 array.array.append 1247 1248 v: object 1249 / 1250 1251 Append new value v to the end of the array. 1252 [clinic start generated code]*/ 1253 1254 static PyObject * 1255 array_array_append(arrayobject *self, PyObject *v) 1256 /*[clinic end generated code: output=745a0669bf8db0e2 input=0b98d9d78e78f0fa]*/ 1257 { 1258 return ins(self, Py_SIZE(self), v); 1259 } 1260 1261 /*[clinic input] 1262 array.array.byteswap 1263 1264 Byteswap all items of the array. 1265 1266 If the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is 1267 raised. 1268 [clinic start generated code]*/ 1269 1270 static PyObject * 1271 array_array_byteswap_impl(arrayobject *self) 1272 /*[clinic end generated code: output=5f8236cbdf0d90b5 input=6a85591b950a0186]*/ 1273 { 1274 char *p; 1275 Py_ssize_t i; 1276 1277 switch (self->ob_descr->itemsize) { 1278 case 1: 1279 break; 1280 case 2: 1281 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) { 1282 char p0 = p[0]; 1283 p[0] = p[1]; 1284 p[1] = p0; 1285 } 1286 break; 1287 case 4: 1288 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) { 1289 char p0 = p[0]; 1290 char p1 = p[1]; 1291 p[0] = p[3]; 1292 p[1] = p[2]; 1293 p[2] = p1; 1294 p[3] = p0; 1295 } 1296 break; 1297 case 8: 1298 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) { 1299 char p0 = p[0]; 1300 char p1 = p[1]; 1301 char p2 = p[2]; 1302 char p3 = p[3]; 1303 p[0] = p[7]; 1304 p[1] = p[6]; 1305 p[2] = p[5]; 1306 p[3] = p[4]; 1307 p[4] = p3; 1308 p[5] = p2; 1309 p[6] = p1; 1310 p[7] = p0; 1311 } 1312 break; 1313 default: 1314 PyErr_SetString(PyExc_RuntimeError, 1315 "don't know how to byteswap this array type"); 1316 return NULL; 1317 } 1318 Py_INCREF(Py_None); 1319 return Py_None; 1320 } 1321 1322 /*[clinic input] 1323 array.array.reverse 1324 1325 Reverse the order of the items in the array. 1326 [clinic start generated code]*/ 1327 1328 static PyObject * 1329 array_array_reverse_impl(arrayobject *self) 1330 /*[clinic end generated code: output=c04868b36f6f4089 input=cd904f01b27d966a]*/ 1331 { 1332 Py_ssize_t itemsize = self->ob_descr->itemsize; 1333 char *p, *q; 1334 /* little buffer to hold items while swapping */ 1335 char tmp[256]; /* 8 is probably enough -- but why skimp */ 1336 assert((size_t)itemsize <= sizeof(tmp)); 1337 1338 if (Py_SIZE(self) > 1) { 1339 for (p = self->ob_item, 1340 q = self->ob_item + (Py_SIZE(self) - 1)*itemsize; 1341 p < q; 1342 p += itemsize, q -= itemsize) { 1343 /* memory areas guaranteed disjoint, so memcpy 1344 * is safe (& memmove may be slower). 1345 */ 1346 memcpy(tmp, p, itemsize); 1347 memcpy(p, q, itemsize); 1348 memcpy(q, tmp, itemsize); 1349 } 1350 } 1351 1352 Py_INCREF(Py_None); 1353 return Py_None; 1354 } 1355 1356 /*[clinic input] 1357 array.array.fromfile 1358 1359 f: object 1360 n: Py_ssize_t 1361 / 1362 1363 Read n objects from the file object f and append them to the end of the array. 1364 [clinic start generated code]*/ 1365 1366 static PyObject * 1367 array_array_fromfile_impl(arrayobject *self, PyObject *f, Py_ssize_t n) 1368 /*[clinic end generated code: output=ec9f600e10f53510 input=e188afe8e58adf40]*/ 1369 { 1370 PyObject *b, *res; 1371 Py_ssize_t itemsize = self->ob_descr->itemsize; 1372 Py_ssize_t nbytes; 1373 _Py_IDENTIFIER(read); 1374 int not_enough_bytes; 1375 1376 if (n < 0) { 1377 PyErr_SetString(PyExc_ValueError, "negative count"); 1378 return NULL; 1379 } 1380 if (n > PY_SSIZE_T_MAX / itemsize) { 1381 PyErr_NoMemory(); 1382 return NULL; 1383 } 1384 nbytes = n * itemsize; 1385 1386 b = _PyObject_CallMethodId(f, &PyId_read, "n", nbytes); 1387 if (b == NULL) 1388 return NULL; 1389 1390 if (!PyBytes_Check(b)) { 1391 PyErr_SetString(PyExc_TypeError, 1392 "read() didn't return bytes"); 1393 Py_DECREF(b); 1394 return NULL; 1395 } 1396 1397 not_enough_bytes = (PyBytes_GET_SIZE(b) != nbytes); 1398 1399 res = array_array_frombytes(self, b); 1400 Py_DECREF(b); 1401 if (res == NULL) 1402 return NULL; 1403 1404 if (not_enough_bytes) { 1405 PyErr_SetString(PyExc_EOFError, 1406 "read() didn't return enough bytes"); 1407 Py_DECREF(res); 1408 return NULL; 1409 } 1410 1411 return res; 1412 } 1413 1414 /*[clinic input] 1415 array.array.tofile 1416 1417 f: object 1418 / 1419 1420 Write all items (as machine values) to the file object f. 1421 [clinic start generated code]*/ 1422 1423 static PyObject * 1424 array_array_tofile(arrayobject *self, PyObject *f) 1425 /*[clinic end generated code: output=3a2cfa8128df0777 input=b0669a484aab0831]*/ 1426 { 1427 Py_ssize_t nbytes = Py_SIZE(self) * self->ob_descr->itemsize; 1428 /* Write 64K blocks at a time */ 1429 /* XXX Make the block size settable */ 1430 int BLOCKSIZE = 64*1024; 1431 Py_ssize_t nblocks = (nbytes + BLOCKSIZE - 1) / BLOCKSIZE; 1432 Py_ssize_t i; 1433 1434 if (Py_SIZE(self) == 0) 1435 goto done; 1436 1437 for (i = 0; i < nblocks; i++) { 1438 char* ptr = self->ob_item + i*BLOCKSIZE; 1439 Py_ssize_t size = BLOCKSIZE; 1440 PyObject *bytes, *res; 1441 _Py_IDENTIFIER(write); 1442 1443 if (i*BLOCKSIZE + size > nbytes) 1444 size = nbytes - i*BLOCKSIZE; 1445 bytes = PyBytes_FromStringAndSize(ptr, size); 1446 if (bytes == NULL) 1447 return NULL; 1448 res = _PyObject_CallMethodId(f, &PyId_write, "O", bytes); 1449 Py_DECREF(bytes); 1450 if (res == NULL) 1451 return NULL; 1452 Py_DECREF(res); /* drop write result */ 1453 } 1454 1455 done: 1456 Py_INCREF(Py_None); 1457 return Py_None; 1458 } 1459 1460 /*[clinic input] 1461 array.array.fromlist 1462 1463 list: object 1464 / 1465 1466 Append items to array from list. 1467 [clinic start generated code]*/ 1468 1469 static PyObject * 1470 array_array_fromlist(arrayobject *self, PyObject *list) 1471 /*[clinic end generated code: output=26411c2d228a3e3f input=be2605a96c49680f]*/ 1472 { 1473 Py_ssize_t n; 1474 1475 if (!PyList_Check(list)) { 1476 PyErr_SetString(PyExc_TypeError, "arg must be list"); 1477 return NULL; 1478 } 1479 n = PyList_Size(list); 1480 if (n > 0) { 1481 Py_ssize_t i, old_size; 1482 old_size = Py_SIZE(self); 1483 if (array_resize(self, old_size + n) == -1) 1484 return NULL; 1485 for (i = 0; i < n; i++) { 1486 PyObject *v = PyList_GetItem(list, i); 1487 if ((*self->ob_descr->setitem)(self, 1488 Py_SIZE(self) - n + i, v) != 0) { 1489 array_resize(self, old_size); 1490 return NULL; 1491 } 1492 } 1493 } 1494 Py_INCREF(Py_None); 1495 return Py_None; 1496 } 1497 1498 /*[clinic input] 1499 array.array.tolist 1500 1501 Convert array to an ordinary list with the same items. 1502 [clinic start generated code]*/ 1503 1504 static PyObject * 1505 array_array_tolist_impl(arrayobject *self) 1506 /*[clinic end generated code: output=00b60cc9eab8ef89 input=a8d7784a94f86b53]*/ 1507 { 1508 PyObject *list = PyList_New(Py_SIZE(self)); 1509 Py_ssize_t i; 1510 1511 if (list == NULL) 1512 return NULL; 1513 for (i = 0; i < Py_SIZE(self); i++) { 1514 PyObject *v = getarrayitem((PyObject *)self, i); 1515 if (v == NULL) 1516 goto error; 1517 if (PyList_SetItem(list, i, v) < 0) 1518 goto error; 1519 } 1520 return list; 1521 1522 error: 1523 Py_DECREF(list); 1524 return NULL; 1525 } 1526 1527 static PyObject * 1528 frombytes(arrayobject *self, Py_buffer *buffer) 1529 { 1530 int itemsize = self->ob_descr->itemsize; 1531 Py_ssize_t n; 1532 if (buffer->itemsize != 1) { 1533 PyBuffer_Release(buffer); 1534 PyErr_SetString(PyExc_TypeError, "a bytes-like object is required"); 1535 return NULL; 1536 } 1537 n = buffer->len; 1538 if (n % itemsize != 0) { 1539 PyBuffer_Release(buffer); 1540 PyErr_SetString(PyExc_ValueError, 1541 "bytes length not a multiple of item size"); 1542 return NULL; 1543 } 1544 n = n / itemsize; 1545 if (n > 0) { 1546 Py_ssize_t old_size = Py_SIZE(self); 1547 if ((n > PY_SSIZE_T_MAX - old_size) || 1548 ((old_size + n) > PY_SSIZE_T_MAX / itemsize)) { 1549 PyBuffer_Release(buffer); 1550 return PyErr_NoMemory(); 1551 } 1552 if (array_resize(self, old_size + n) == -1) { 1553 PyBuffer_Release(buffer); 1554 return NULL; 1555 } 1556 memcpy(self->ob_item + old_size * itemsize, 1557 buffer->buf, n * itemsize); 1558 } 1559 PyBuffer_Release(buffer); 1560 Py_INCREF(Py_None); 1561 return Py_None; 1562 } 1563 1564 /*[clinic input] 1565 array.array.fromstring 1566 1567 buffer: Py_buffer(accept={str, buffer}) 1568 / 1569 1570 Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method). 1571 1572 This method is deprecated. Use frombytes instead. 1573 [clinic start generated code]*/ 1574 1575 static PyObject * 1576 array_array_fromstring_impl(arrayobject *self, Py_buffer *buffer) 1577 /*[clinic end generated code: output=31c4baa779df84ce input=a3341a512e11d773]*/ 1578 { 1579 if (PyErr_WarnEx(PyExc_DeprecationWarning, 1580 "fromstring() is deprecated. Use frombytes() instead.", 2) != 0) 1581 return NULL; 1582 return frombytes(self, buffer); 1583 } 1584 1585 /*[clinic input] 1586 array.array.frombytes 1587 1588 buffer: Py_buffer 1589 / 1590 1591 Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method). 1592 [clinic start generated code]*/ 1593 1594 static PyObject * 1595 array_array_frombytes_impl(arrayobject *self, Py_buffer *buffer) 1596 /*[clinic end generated code: output=d9842c8f7510a516 input=2bbf2b53ebfcc988]*/ 1597 { 1598 return frombytes(self, buffer); 1599 } 1600 1601 /*[clinic input] 1602 array.array.tobytes 1603 1604 Convert the array to an array of machine values and return the bytes representation. 1605 [clinic start generated code]*/ 1606 1607 static PyObject * 1608 array_array_tobytes_impl(arrayobject *self) 1609 /*[clinic end generated code: output=87318e4edcdc2bb6 input=90ee495f96de34f5]*/ 1610 { 1611 if (Py_SIZE(self) <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) { 1612 return PyBytes_FromStringAndSize(self->ob_item, 1613 Py_SIZE(self) * self->ob_descr->itemsize); 1614 } else { 1615 return PyErr_NoMemory(); 1616 } 1617 } 1618 1619 /*[clinic input] 1620 array.array.tostring 1621 1622 Convert the array to an array of machine values and return the bytes representation. 1623 1624 This method is deprecated. Use tobytes instead. 1625 [clinic start generated code]*/ 1626 1627 static PyObject * 1628 array_array_tostring_impl(arrayobject *self) 1629 /*[clinic end generated code: output=7d6bd92745a2c8f3 input=b6c0ddee7b30457e]*/ 1630 { 1631 if (PyErr_WarnEx(PyExc_DeprecationWarning, 1632 "tostring() is deprecated. Use tobytes() instead.", 2) != 0) 1633 return NULL; 1634 return array_array_tobytes_impl(self); 1635 } 1636 1637 /*[clinic input] 1638 array.array.fromunicode 1639 1640 ustr: Py_UNICODE(zeroes=True) 1641 / 1642 1643 Extends this array with data from the unicode string ustr. 1644 1645 The array must be a unicode type array; otherwise a ValueError is raised. 1646 Use array.frombytes(ustr.encode(...)) to append Unicode data to an array of 1647 some other type. 1648 [clinic start generated code]*/ 1649 1650 static PyObject * 1651 array_array_fromunicode_impl(arrayobject *self, Py_UNICODE *ustr, 1652 Py_ssize_clean_t ustr_length) 1653 /*[clinic end generated code: output=ebb72fc16975e06d input=150f00566ffbca6e]*/ 1654 { 1655 char typecode; 1656 1657 typecode = self->ob_descr->typecode; 1658 if (typecode != 'u') { 1659 PyErr_SetString(PyExc_ValueError, 1660 "fromunicode() may only be called on " 1661 "unicode type arrays"); 1662 return NULL; 1663 } 1664 if (ustr_length > 0) { 1665 Py_ssize_t old_size = Py_SIZE(self); 1666 if (array_resize(self, old_size + ustr_length) == -1) 1667 return NULL; 1668 memcpy(self->ob_item + old_size * sizeof(Py_UNICODE), 1669 ustr, ustr_length * sizeof(Py_UNICODE)); 1670 } 1671 1672 Py_RETURN_NONE; 1673 } 1674 1675 /*[clinic input] 1676 array.array.tounicode 1677 1678 Extends this array with data from the unicode string ustr. 1679 1680 Convert the array to a unicode string. The array must be a unicode type array; 1681 otherwise a ValueError is raised. Use array.tobytes().decode() to obtain a 1682 unicode string from an array of some other type. 1683 [clinic start generated code]*/ 1684 1685 static PyObject * 1686 array_array_tounicode_impl(arrayobject *self) 1687 /*[clinic end generated code: output=08e442378336e1ef input=127242eebe70b66d]*/ 1688 { 1689 char typecode; 1690 typecode = self->ob_descr->typecode; 1691 if (typecode != 'u') { 1692 PyErr_SetString(PyExc_ValueError, 1693 "tounicode() may only be called on unicode type arrays"); 1694 return NULL; 1695 } 1696 return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self)); 1697 } 1698 1699 /*[clinic input] 1700 array.array.__sizeof__ 1701 1702 Size of the array in memory, in bytes. 1703 [clinic start generated code]*/ 1704 1705 static PyObject * 1706 array_array___sizeof___impl(arrayobject *self) 1707 /*[clinic end generated code: output=d8e1c61ebbe3eaed input=805586565bf2b3c6]*/ 1708 { 1709 Py_ssize_t res; 1710 res = _PyObject_SIZE(Py_TYPE(self)) + self->allocated * self->ob_descr->itemsize; 1711 return PyLong_FromSsize_t(res); 1712 } 1713 1714 1715 /*********************** Pickling support ************************/ 1716 1717 static const struct mformatdescr { 1718 size_t size; 1719 int is_signed; 1720 int is_big_endian; 1721 } mformat_descriptors[] = { 1722 {1, 0, 0}, /* 0: UNSIGNED_INT8 */ 1723 {1, 1, 0}, /* 1: SIGNED_INT8 */ 1724 {2, 0, 0}, /* 2: UNSIGNED_INT16_LE */ 1725 {2, 0, 1}, /* 3: UNSIGNED_INT16_BE */ 1726 {2, 1, 0}, /* 4: SIGNED_INT16_LE */ 1727 {2, 1, 1}, /* 5: SIGNED_INT16_BE */ 1728 {4, 0, 0}, /* 6: UNSIGNED_INT32_LE */ 1729 {4, 0, 1}, /* 7: UNSIGNED_INT32_BE */ 1730 {4, 1, 0}, /* 8: SIGNED_INT32_LE */ 1731 {4, 1, 1}, /* 9: SIGNED_INT32_BE */ 1732 {8, 0, 0}, /* 10: UNSIGNED_INT64_LE */ 1733 {8, 0, 1}, /* 11: UNSIGNED_INT64_BE */ 1734 {8, 1, 0}, /* 12: SIGNED_INT64_LE */ 1735 {8, 1, 1}, /* 13: SIGNED_INT64_BE */ 1736 {4, 0, 0}, /* 14: IEEE_754_FLOAT_LE */ 1737 {4, 0, 1}, /* 15: IEEE_754_FLOAT_BE */ 1738 {8, 0, 0}, /* 16: IEEE_754_DOUBLE_LE */ 1739 {8, 0, 1}, /* 17: IEEE_754_DOUBLE_BE */ 1740 {4, 0, 0}, /* 18: UTF16_LE */ 1741 {4, 0, 1}, /* 19: UTF16_BE */ 1742 {8, 0, 0}, /* 20: UTF32_LE */ 1743 {8, 0, 1} /* 21: UTF32_BE */ 1744 }; 1745 1746 1747 /* 1748 * Internal: This function is used to find the machine format of a given 1749 * array type code. This returns UNKNOWN_FORMAT when the machine format cannot 1750 * be found. 1751 */ 1752 static enum machine_format_code 1753 typecode_to_mformat_code(char typecode) 1754 { 1755 const int is_big_endian = PY_BIG_ENDIAN; 1756 1757 size_t intsize; 1758 int is_signed; 1759 1760 switch (typecode) { 1761 case 'b': 1762 return SIGNED_INT8; 1763 case 'B': 1764 return UNSIGNED_INT8; 1765 1766 case 'u': 1767 if (sizeof(Py_UNICODE) == 2) { 1768 return UTF16_LE + is_big_endian; 1769 } 1770 if (sizeof(Py_UNICODE) == 4) { 1771 return UTF32_LE + is_big_endian; 1772 } 1773 return UNKNOWN_FORMAT; 1774 1775 case 'f': 1776 if (sizeof(float) == 4) { 1777 const float y = 16711938.0; 1778 if (memcmp(&y, "\x4b\x7f\x01\x02", 4) == 0) 1779 return IEEE_754_FLOAT_BE; 1780 if (memcmp(&y, "\x02\x01\x7f\x4b", 4) == 0) 1781 return IEEE_754_FLOAT_LE; 1782 } 1783 return UNKNOWN_FORMAT; 1784 1785 case 'd': 1786 if (sizeof(double) == 8) { 1787 const double x = 9006104071832581.0; 1788 if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0) 1789 return IEEE_754_DOUBLE_BE; 1790 if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0) 1791 return IEEE_754_DOUBLE_LE; 1792 } 1793 return UNKNOWN_FORMAT; 1794 1795 /* Integers */ 1796 case 'h': 1797 intsize = sizeof(short); 1798 is_signed = 1; 1799 break; 1800 case 'H': 1801 intsize = sizeof(short); 1802 is_signed = 0; 1803 break; 1804 case 'i': 1805 intsize = sizeof(int); 1806 is_signed = 1; 1807 break; 1808 case 'I': 1809 intsize = sizeof(int); 1810 is_signed = 0; 1811 break; 1812 case 'l': 1813 intsize = sizeof(long); 1814 is_signed = 1; 1815 break; 1816 case 'L': 1817 intsize = sizeof(long); 1818 is_signed = 0; 1819 break; 1820 case 'q': 1821 intsize = sizeof(long long); 1822 is_signed = 1; 1823 break; 1824 case 'Q': 1825 intsize = sizeof(long long); 1826 is_signed = 0; 1827 break; 1828 default: 1829 return UNKNOWN_FORMAT; 1830 } 1831 switch (intsize) { 1832 case 2: 1833 return UNSIGNED_INT16_LE + is_big_endian + (2 * is_signed); 1834 case 4: 1835 return UNSIGNED_INT32_LE + is_big_endian + (2 * is_signed); 1836 case 8: 1837 return UNSIGNED_INT64_LE + is_big_endian + (2 * is_signed); 1838 default: 1839 return UNKNOWN_FORMAT; 1840 } 1841 } 1842 1843 /* Forward declaration. */ 1844 static PyObject *array_new(PyTypeObject *type, PyObject *args, PyObject *kwds); 1845 1846 /* 1847 * Internal: This function wraps the array constructor--i.e., array_new()--to 1848 * allow the creation of array objects from C code without having to deal 1849 * directly the tuple argument of array_new(). The typecode argument is a 1850 * Unicode character value, like 'i' or 'f' for example, representing an array 1851 * type code. The items argument is a bytes or a list object from which 1852 * contains the initial value of the array. 1853 * 1854 * On success, this functions returns the array object created. Otherwise, 1855 * NULL is returned to indicate a failure. 1856 */ 1857 static PyObject * 1858 make_array(PyTypeObject *arraytype, char typecode, PyObject *items) 1859 { 1860 PyObject *new_args; 1861 PyObject *array_obj; 1862 PyObject *typecode_obj; 1863 1864 assert(arraytype != NULL); 1865 assert(items != NULL); 1866 1867 typecode_obj = PyUnicode_FromOrdinal(typecode); 1868 if (typecode_obj == NULL) 1869 return NULL; 1870 1871 new_args = PyTuple_New(2); 1872 if (new_args == NULL) 1873 return NULL; 1874 Py_INCREF(items); 1875 PyTuple_SET_ITEM(new_args, 0, typecode_obj); 1876 PyTuple_SET_ITEM(new_args, 1, items); 1877 1878 array_obj = array_new(arraytype, new_args, NULL); 1879 Py_DECREF(new_args); 1880 if (array_obj == NULL) 1881 return NULL; 1882 1883 return array_obj; 1884 } 1885 1886 /* 1887 * This functions is a special constructor used when unpickling an array. It 1888 * provides a portable way to rebuild an array from its memory representation. 1889 */ 1890 /*[clinic input] 1891 array._array_reconstructor 1892 1893 arraytype: object(type="PyTypeObject *") 1894 typecode: int(accept={str}) 1895 mformat_code: int(type="enum machine_format_code") 1896 items: object 1897 / 1898 1899 Internal. Used for pickling support. 1900 [clinic start generated code]*/ 1901 1902 static PyObject * 1903 array__array_reconstructor_impl(PyObject *module, PyTypeObject *arraytype, 1904 int typecode, 1905 enum machine_format_code mformat_code, 1906 PyObject *items) 1907 /*[clinic end generated code: output=e05263141ba28365 input=2464dc8f4c7736b5]*/ 1908 { 1909 PyObject *converted_items; 1910 PyObject *result; 1911 const struct arraydescr *descr; 1912 1913 if (!PyType_Check(arraytype)) { 1914 PyErr_Format(PyExc_TypeError, 1915 "first argument must a type object, not %.200s", 1916 Py_TYPE(arraytype)->tp_name); 1917 return NULL; 1918 } 1919 if (!PyType_IsSubtype(arraytype, &Arraytype)) { 1920 PyErr_Format(PyExc_TypeError, 1921 "%.200s is not a subtype of %.200s", 1922 arraytype->tp_name, Arraytype.tp_name); 1923 return NULL; 1924 } 1925 for (descr = descriptors; descr->typecode != '\0'; descr++) { 1926 if ((int)descr->typecode == typecode) 1927 break; 1928 } 1929 if (descr->typecode == '\0') { 1930 PyErr_SetString(PyExc_ValueError, 1931 "second argument must be a valid type code"); 1932 return NULL; 1933 } 1934 if (mformat_code < MACHINE_FORMAT_CODE_MIN || 1935 mformat_code > MACHINE_FORMAT_CODE_MAX) { 1936 PyErr_SetString(PyExc_ValueError, 1937 "third argument must be a valid machine format code."); 1938 return NULL; 1939 } 1940 if (!PyBytes_Check(items)) { 1941 PyErr_Format(PyExc_TypeError, 1942 "fourth argument should be bytes, not %.200s", 1943 Py_TYPE(items)->tp_name); 1944 return NULL; 1945 } 1946 1947 /* Fast path: No decoding has to be done. */ 1948 if (mformat_code == typecode_to_mformat_code((char)typecode) || 1949 mformat_code == UNKNOWN_FORMAT) { 1950 return make_array(arraytype, (char)typecode, items); 1951 } 1952 1953 /* Slow path: Decode the byte string according to the given machine 1954 * format code. This occurs when the computer unpickling the array 1955 * object is architecturally different from the one that pickled the 1956 * array. 1957 */ 1958 if (Py_SIZE(items) % mformat_descriptors[mformat_code].size != 0) { 1959 PyErr_SetString(PyExc_ValueError, 1960 "string length not a multiple of item size"); 1961 return NULL; 1962 } 1963 switch (mformat_code) { 1964 case IEEE_754_FLOAT_LE: 1965 case IEEE_754_FLOAT_BE: { 1966 int i; 1967 int le = (mformat_code == IEEE_754_FLOAT_LE) ? 1 : 0; 1968 Py_ssize_t itemcount = Py_SIZE(items) / 4; 1969 const unsigned char *memstr = 1970 (unsigned char *)PyBytes_AS_STRING(items); 1971 1972 converted_items = PyList_New(itemcount); 1973 if (converted_items == NULL) 1974 return NULL; 1975 for (i = 0; i < itemcount; i++) { 1976 PyObject *pyfloat = PyFloat_FromDouble( 1977 _PyFloat_Unpack4(&memstr[i * 4], le)); 1978 if (pyfloat == NULL) { 1979 Py_DECREF(converted_items); 1980 return NULL; 1981 } 1982 PyList_SET_ITEM(converted_items, i, pyfloat); 1983 } 1984 break; 1985 } 1986 case IEEE_754_DOUBLE_LE: 1987 case IEEE_754_DOUBLE_BE: { 1988 int i; 1989 int le = (mformat_code == IEEE_754_DOUBLE_LE) ? 1 : 0; 1990 Py_ssize_t itemcount = Py_SIZE(items) / 8; 1991 const unsigned char *memstr = 1992 (unsigned char *)PyBytes_AS_STRING(items); 1993 1994 converted_items = PyList_New(itemcount); 1995 if (converted_items == NULL) 1996 return NULL; 1997 for (i = 0; i < itemcount; i++) { 1998 PyObject *pyfloat = PyFloat_FromDouble( 1999 _PyFloat_Unpack8(&memstr[i * 8], le)); 2000 if (pyfloat == NULL) { 2001 Py_DECREF(converted_items); 2002 return NULL; 2003 } 2004 PyList_SET_ITEM(converted_items, i, pyfloat); 2005 } 2006 break; 2007 } 2008 case UTF16_LE: 2009 case UTF16_BE: { 2010 int byteorder = (mformat_code == UTF16_LE) ? -1 : 1; 2011 converted_items = PyUnicode_DecodeUTF16( 2012 PyBytes_AS_STRING(items), Py_SIZE(items), 2013 "strict", &byteorder); 2014 if (converted_items == NULL) 2015 return NULL; 2016 break; 2017 } 2018 case UTF32_LE: 2019 case UTF32_BE: { 2020 int byteorder = (mformat_code == UTF32_LE) ? -1 : 1; 2021 converted_items = PyUnicode_DecodeUTF32( 2022 PyBytes_AS_STRING(items), Py_SIZE(items), 2023 "strict", &byteorder); 2024 if (converted_items == NULL) 2025 return NULL; 2026 break; 2027 } 2028 2029 case UNSIGNED_INT8: 2030 case SIGNED_INT8: 2031 case UNSIGNED_INT16_LE: 2032 case UNSIGNED_INT16_BE: 2033 case SIGNED_INT16_LE: 2034 case SIGNED_INT16_BE: 2035 case UNSIGNED_INT32_LE: 2036 case UNSIGNED_INT32_BE: 2037 case SIGNED_INT32_LE: 2038 case SIGNED_INT32_BE: 2039 case UNSIGNED_INT64_LE: 2040 case UNSIGNED_INT64_BE: 2041 case SIGNED_INT64_LE: 2042 case SIGNED_INT64_BE: { 2043 int i; 2044 const struct mformatdescr mf_descr = 2045 mformat_descriptors[mformat_code]; 2046 Py_ssize_t itemcount = Py_SIZE(items) / mf_descr.size; 2047 const unsigned char *memstr = 2048 (unsigned char *)PyBytes_AS_STRING(items); 2049 const struct arraydescr *descr; 2050 2051 /* If possible, try to pack array's items using a data type 2052 * that fits better. This may result in an array with narrower 2053 * or wider elements. 2054 * 2055 * For example, if a 32-bit machine pickles an L-code array of 2056 * unsigned longs, then the array will be unpickled by 64-bit 2057 * machine as an I-code array of unsigned ints. 2058 * 2059 * XXX: Is it possible to write a unit test for this? 2060 */ 2061 for (descr = descriptors; descr->typecode != '\0'; descr++) { 2062 if (descr->is_integer_type && 2063 (size_t)descr->itemsize == mf_descr.size && 2064 descr->is_signed == mf_descr.is_signed) 2065 typecode = descr->typecode; 2066 } 2067 2068 converted_items = PyList_New(itemcount); 2069 if (converted_items == NULL) 2070 return NULL; 2071 for (i = 0; i < itemcount; i++) { 2072 PyObject *pylong; 2073 2074 pylong = _PyLong_FromByteArray( 2075 &memstr[i * mf_descr.size], 2076 mf_descr.size, 2077 !mf_descr.is_big_endian, 2078 mf_descr.is_signed); 2079 if (pylong == NULL) { 2080 Py_DECREF(converted_items); 2081 return NULL; 2082 } 2083 PyList_SET_ITEM(converted_items, i, pylong); 2084 } 2085 break; 2086 } 2087 case UNKNOWN_FORMAT: 2088 /* Impossible, but needed to shut up GCC about the unhandled 2089 * enumeration value. 2090 */ 2091 default: 2092 PyErr_BadArgument(); 2093 return NULL; 2094 } 2095 2096 result = make_array(arraytype, (char)typecode, converted_items); 2097 Py_DECREF(converted_items); 2098 return result; 2099 } 2100 2101 /*[clinic input] 2102 array.array.__reduce_ex__ 2103 2104 value: object 2105 / 2106 2107 Return state information for pickling. 2108 [clinic start generated code]*/ 2109 2110 static PyObject * 2111 array_array___reduce_ex__(arrayobject *self, PyObject *value) 2112 /*[clinic end generated code: output=051e0a6175d0eddb input=c36c3f85de7df6cd]*/ 2113 { 2114 PyObject *dict; 2115 PyObject *result; 2116 PyObject *array_str; 2117 int typecode = self->ob_descr->typecode; 2118 int mformat_code; 2119 static PyObject *array_reconstructor = NULL; 2120 long protocol; 2121 _Py_IDENTIFIER(_array_reconstructor); 2122 _Py_IDENTIFIER(__dict__); 2123 2124 if (array_reconstructor == NULL) { 2125 PyObject *array_module = PyImport_ImportModule("array"); 2126 if (array_module == NULL) 2127 return NULL; 2128 array_reconstructor = _PyObject_GetAttrId( 2129 array_module, 2130 &PyId__array_reconstructor); 2131 Py_DECREF(array_module); 2132 if (array_reconstructor == NULL) 2133 return NULL; 2134 } 2135 2136 if (!PyLong_Check(value)) { 2137 PyErr_SetString(PyExc_TypeError, 2138 "__reduce_ex__ argument should an integer"); 2139 return NULL; 2140 } 2141 protocol = PyLong_AsLong(value); 2142 if (protocol == -1 && PyErr_Occurred()) 2143 return NULL; 2144 2145 dict = _PyObject_GetAttrId((PyObject *)self, &PyId___dict__); 2146 if (dict == NULL) { 2147 if (!PyErr_ExceptionMatches(PyExc_AttributeError)) 2148 return NULL; 2149 PyErr_Clear(); 2150 dict = Py_None; 2151 Py_INCREF(dict); 2152 } 2153 2154 mformat_code = typecode_to_mformat_code(typecode); 2155 if (mformat_code == UNKNOWN_FORMAT || protocol < 3) { 2156 /* Convert the array to a list if we got something weird 2157 * (e.g., non-IEEE floats), or we are pickling the array using 2158 * a Python 2.x compatible protocol. 2159 * 2160 * It is necessary to use a list representation for Python 2.x 2161 * compatible pickle protocol, since Python 2's str objects 2162 * are unpickled as unicode by Python 3. Thus it is impossible 2163 * to make arrays unpicklable by Python 3 by using their memory 2164 * representation, unless we resort to ugly hacks such as 2165 * coercing unicode objects to bytes in array_reconstructor. 2166 */ 2167 PyObject *list; 2168 list = array_array_tolist_impl(self); 2169 if (list == NULL) { 2170 Py_DECREF(dict); 2171 return NULL; 2172 } 2173 result = Py_BuildValue( 2174 "O(CO)O", Py_TYPE(self), typecode, list, dict); 2175 Py_DECREF(list); 2176 Py_DECREF(dict); 2177 return result; 2178 } 2179 2180 array_str = array_array_tobytes_impl(self); 2181 if (array_str == NULL) { 2182 Py_DECREF(dict); 2183 return NULL; 2184 } 2185 result = Py_BuildValue( 2186 "O(OCiN)O", array_reconstructor, Py_TYPE(self), typecode, 2187 mformat_code, array_str, dict); 2188 Py_DECREF(dict); 2189 return result; 2190 } 2191 2192 static PyObject * 2193 array_get_typecode(arrayobject *a, void *closure) 2194 { 2195 char typecode = a->ob_descr->typecode; 2196 return PyUnicode_FromOrdinal(typecode); 2197 } 2198 2199 static PyObject * 2200 array_get_itemsize(arrayobject *a, void *closure) 2201 { 2202 return PyLong_FromLong((long)a->ob_descr->itemsize); 2203 } 2204 2205 static PyGetSetDef array_getsets [] = { 2206 {"typecode", (getter) array_get_typecode, NULL, 2207 "the typecode character used to create the array"}, 2208 {"itemsize", (getter) array_get_itemsize, NULL, 2209 "the size, in bytes, of one array item"}, 2210 {NULL} 2211 }; 2212 2213 static PyMethodDef array_methods[] = { 2214 ARRAY_ARRAY_APPEND_METHODDEF 2215 ARRAY_ARRAY_BUFFER_INFO_METHODDEF 2216 ARRAY_ARRAY_BYTESWAP_METHODDEF 2217 ARRAY_ARRAY___COPY___METHODDEF 2218 ARRAY_ARRAY_COUNT_METHODDEF 2219 ARRAY_ARRAY___DEEPCOPY___METHODDEF 2220 ARRAY_ARRAY_EXTEND_METHODDEF 2221 ARRAY_ARRAY_FROMFILE_METHODDEF 2222 ARRAY_ARRAY_FROMLIST_METHODDEF 2223 ARRAY_ARRAY_FROMSTRING_METHODDEF 2224 ARRAY_ARRAY_FROMBYTES_METHODDEF 2225 ARRAY_ARRAY_FROMUNICODE_METHODDEF 2226 ARRAY_ARRAY_INDEX_METHODDEF 2227 ARRAY_ARRAY_INSERT_METHODDEF 2228 ARRAY_ARRAY_POP_METHODDEF 2229 ARRAY_ARRAY___REDUCE_EX___METHODDEF 2230 ARRAY_ARRAY_REMOVE_METHODDEF 2231 ARRAY_ARRAY_REVERSE_METHODDEF 2232 ARRAY_ARRAY_TOFILE_METHODDEF 2233 ARRAY_ARRAY_TOLIST_METHODDEF 2234 ARRAY_ARRAY_TOSTRING_METHODDEF 2235 ARRAY_ARRAY_TOBYTES_METHODDEF 2236 ARRAY_ARRAY_TOUNICODE_METHODDEF 2237 ARRAY_ARRAY___SIZEOF___METHODDEF 2238 {NULL, NULL} /* sentinel */ 2239 }; 2240 2241 static PyObject * 2242 array_repr(arrayobject *a) 2243 { 2244 char typecode; 2245 PyObject *s, *v = NULL; 2246 Py_ssize_t len; 2247 2248 len = Py_SIZE(a); 2249 typecode = a->ob_descr->typecode; 2250 if (len == 0) { 2251 return PyUnicode_FromFormat("array('%c')", (int)typecode); 2252 } 2253 if (typecode == 'u') { 2254 v = array_array_tounicode_impl(a); 2255 } else { 2256 v = array_array_tolist_impl(a); 2257 } 2258 if (v == NULL) 2259 return NULL; 2260 2261 s = PyUnicode_FromFormat("array('%c', %R)", (int)typecode, v); 2262 Py_DECREF(v); 2263 return s; 2264 } 2265 2266 static PyObject* 2267 array_subscr(arrayobject* self, PyObject* item) 2268 { 2269 if (PyIndex_Check(item)) { 2270 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); 2271 if (i==-1 && PyErr_Occurred()) { 2272 return NULL; 2273 } 2274 if (i < 0) 2275 i += Py_SIZE(self); 2276 return array_item(self, i); 2277 } 2278 else if (PySlice_Check(item)) { 2279 Py_ssize_t start, stop, step, slicelength, cur, i; 2280 PyObject* result; 2281 arrayobject* ar; 2282 int itemsize = self->ob_descr->itemsize; 2283 2284 if (PySlice_GetIndicesEx(item, Py_SIZE(self), 2285 &start, &stop, &step, &slicelength) < 0) { 2286 return NULL; 2287 } 2288 2289 if (slicelength <= 0) { 2290 return newarrayobject(&Arraytype, 0, self->ob_descr); 2291 } 2292 else if (step == 1) { 2293 PyObject *result = newarrayobject(&Arraytype, 2294 slicelength, self->ob_descr); 2295 if (result == NULL) 2296 return NULL; 2297 memcpy(((arrayobject *)result)->ob_item, 2298 self->ob_item + start * itemsize, 2299 slicelength * itemsize); 2300 return result; 2301 } 2302 else { 2303 result = newarrayobject(&Arraytype, slicelength, self->ob_descr); 2304 if (!result) return NULL; 2305 2306 ar = (arrayobject*)result; 2307 2308 for (cur = start, i = 0; i < slicelength; 2309 cur += step, i++) { 2310 memcpy(ar->ob_item + i*itemsize, 2311 self->ob_item + cur*itemsize, 2312 itemsize); 2313 } 2314 2315 return result; 2316 } 2317 } 2318 else { 2319 PyErr_SetString(PyExc_TypeError, 2320 "array indices must be integers"); 2321 return NULL; 2322 } 2323 } 2324 2325 static int 2326 array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value) 2327 { 2328 Py_ssize_t start, stop, step, slicelength, needed; 2329 arrayobject* other; 2330 int itemsize; 2331 2332 if (PyIndex_Check(item)) { 2333 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); 2334 2335 if (i == -1 && PyErr_Occurred()) 2336 return -1; 2337 if (i < 0) 2338 i += Py_SIZE(self); 2339 if (i < 0 || i >= Py_SIZE(self)) { 2340 PyErr_SetString(PyExc_IndexError, 2341 "array assignment index out of range"); 2342 return -1; 2343 } 2344 if (value == NULL) { 2345 /* Fall through to slice assignment */ 2346 start = i; 2347 stop = i + 1; 2348 step = 1; 2349 slicelength = 1; 2350 } 2351 else 2352 return (*self->ob_descr->setitem)(self, i, value); 2353 } 2354 else if (PySlice_Check(item)) { 2355 if (PySlice_GetIndicesEx(item, 2356 Py_SIZE(self), &start, &stop, 2357 &step, &slicelength) < 0) { 2358 return -1; 2359 } 2360 } 2361 else { 2362 PyErr_SetString(PyExc_TypeError, 2363 "array indices must be integer"); 2364 return -1; 2365 } 2366 if (value == NULL) { 2367 other = NULL; 2368 needed = 0; 2369 } 2370 else if (array_Check(value)) { 2371 other = (arrayobject *)value; 2372 needed = Py_SIZE(other); 2373 if (self == other) { 2374 /* Special case "self[i:j] = self" -- copy self first */ 2375 int ret; 2376 value = array_slice(other, 0, needed); 2377 if (value == NULL) 2378 return -1; 2379 ret = array_ass_subscr(self, item, value); 2380 Py_DECREF(value); 2381 return ret; 2382 } 2383 if (other->ob_descr != self->ob_descr) { 2384 PyErr_BadArgument(); 2385 return -1; 2386 } 2387 } 2388 else { 2389 PyErr_Format(PyExc_TypeError, 2390 "can only assign array (not \"%.200s\") to array slice", 2391 Py_TYPE(value)->tp_name); 2392 return -1; 2393 } 2394 itemsize = self->ob_descr->itemsize; 2395 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */ 2396 if ((step > 0 && stop < start) || 2397 (step < 0 && stop > start)) 2398 stop = start; 2399 2400 /* Issue #4509: If the array has exported buffers and the slice 2401 assignment would change the size of the array, fail early to make 2402 sure we don't modify it. */ 2403 if ((needed == 0 || slicelength != needed) && self->ob_exports > 0) { 2404 PyErr_SetString(PyExc_BufferError, 2405 "cannot resize an array that is exporting buffers"); 2406 return -1; 2407 } 2408 2409 if (step == 1) { 2410 if (slicelength > needed) { 2411 memmove(self->ob_item + (start + needed) * itemsize, 2412 self->ob_item + stop * itemsize, 2413 (Py_SIZE(self) - stop) * itemsize); 2414 if (array_resize(self, Py_SIZE(self) + 2415 needed - slicelength) < 0) 2416 return -1; 2417 } 2418 else if (slicelength < needed) { 2419 if (array_resize(self, Py_SIZE(self) + 2420 needed - slicelength) < 0) 2421 return -1; 2422 memmove(self->ob_item + (start + needed) * itemsize, 2423 self->ob_item + stop * itemsize, 2424 (Py_SIZE(self) - start - needed) * itemsize); 2425 } 2426 if (needed > 0) 2427 memcpy(self->ob_item + start * itemsize, 2428 other->ob_item, needed * itemsize); 2429 return 0; 2430 } 2431 else if (needed == 0) { 2432 /* Delete slice */ 2433 size_t cur; 2434 Py_ssize_t i; 2435 2436 if (step < 0) { 2437 stop = start + 1; 2438 start = stop + step * (slicelength - 1) - 1; 2439 step = -step; 2440 } 2441 for (cur = start, i = 0; i < slicelength; 2442 cur += step, i++) { 2443 Py_ssize_t lim = step - 1; 2444 2445 if (cur + step >= (size_t)Py_SIZE(self)) 2446 lim = Py_SIZE(self) - cur - 1; 2447 memmove(self->ob_item + (cur - i) * itemsize, 2448 self->ob_item + (cur + 1) * itemsize, 2449 lim * itemsize); 2450 } 2451 cur = start + (size_t)slicelength * step; 2452 if (cur < (size_t)Py_SIZE(self)) { 2453 memmove(self->ob_item + (cur-slicelength) * itemsize, 2454 self->ob_item + cur * itemsize, 2455 (Py_SIZE(self) - cur) * itemsize); 2456 } 2457 if (array_resize(self, Py_SIZE(self) - slicelength) < 0) 2458 return -1; 2459 return 0; 2460 } 2461 else { 2462 Py_ssize_t cur, i; 2463 2464 if (needed != slicelength) { 2465 PyErr_Format(PyExc_ValueError, 2466 "attempt to assign array of size %zd " 2467 "to extended slice of size %zd", 2468 needed, slicelength); 2469 return -1; 2470 } 2471 for (cur = start, i = 0; i < slicelength; 2472 cur += step, i++) { 2473 memcpy(self->ob_item + cur * itemsize, 2474 other->ob_item + i * itemsize, 2475 itemsize); 2476 } 2477 return 0; 2478 } 2479 } 2480 2481 static PyMappingMethods array_as_mapping = { 2482 (lenfunc)array_length, 2483 (binaryfunc)array_subscr, 2484 (objobjargproc)array_ass_subscr 2485 }; 2486 2487 static const void *emptybuf = ""; 2488 2489 2490 static int 2491 array_buffer_getbuf(arrayobject *self, Py_buffer *view, int flags) 2492 { 2493 if (view == NULL) { 2494 PyErr_SetString(PyExc_BufferError, 2495 "array_buffer_getbuf: view==NULL argument is obsolete"); 2496 return -1; 2497 } 2498 2499 view->buf = (void *)self->ob_item; 2500 view->obj = (PyObject*)self; 2501 Py_INCREF(self); 2502 if (view->buf == NULL) 2503 view->buf = (void *)emptybuf; 2504 view->len = (Py_SIZE(self)) * self->ob_descr->itemsize; 2505 view->readonly = 0; 2506 view->ndim = 1; 2507 view->itemsize = self->ob_descr->itemsize; 2508 view->suboffsets = NULL; 2509 view->shape = NULL; 2510 if ((flags & PyBUF_ND)==PyBUF_ND) { 2511 view->shape = &((Py_SIZE(self))); 2512 } 2513 view->strides = NULL; 2514 if ((flags & PyBUF_STRIDES)==PyBUF_STRIDES) 2515 view->strides = &(view->itemsize); 2516 view->format = NULL; 2517 view->internal = NULL; 2518 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) { 2519 view->format = (char *)self->ob_descr->formats; 2520 #ifdef Py_UNICODE_WIDE 2521 if (self->ob_descr->typecode == 'u') { 2522 view->format = "w"; 2523 } 2524 #endif 2525 } 2526 2527 self->ob_exports++; 2528 return 0; 2529 } 2530 2531 static void 2532 array_buffer_relbuf(arrayobject *self, Py_buffer *view) 2533 { 2534 self->ob_exports--; 2535 } 2536 2537 static PySequenceMethods array_as_sequence = { 2538 (lenfunc)array_length, /*sq_length*/ 2539 (binaryfunc)array_concat, /*sq_concat*/ 2540 (ssizeargfunc)array_repeat, /*sq_repeat*/ 2541 (ssizeargfunc)array_item, /*sq_item*/ 2542 0, /*sq_slice*/ 2543 (ssizeobjargproc)array_ass_item, /*sq_ass_item*/ 2544 0, /*sq_ass_slice*/ 2545 (objobjproc)array_contains, /*sq_contains*/ 2546 (binaryfunc)array_inplace_concat, /*sq_inplace_concat*/ 2547 (ssizeargfunc)array_inplace_repeat /*sq_inplace_repeat*/ 2548 }; 2549 2550 static PyBufferProcs array_as_buffer = { 2551 (getbufferproc)array_buffer_getbuf, 2552 (releasebufferproc)array_buffer_relbuf 2553 }; 2554 2555 static PyObject * 2556 array_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 2557 { 2558 int c; 2559 PyObject *initial = NULL, *it = NULL; 2560 const struct arraydescr *descr; 2561 2562 if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds)) 2563 return NULL; 2564 2565 if (!PyArg_ParseTuple(args, "C|O:array", &c, &initial)) 2566 return NULL; 2567 2568 if (initial && c != 'u') { 2569 if (PyUnicode_Check(initial)) { 2570 PyErr_Format(PyExc_TypeError, "cannot use a str to initialize " 2571 "an array with typecode '%c'", c); 2572 return NULL; 2573 } 2574 else if (array_Check(initial) && 2575 ((arrayobject*)initial)->ob_descr->typecode == 'u') { 2576 PyErr_Format(PyExc_TypeError, "cannot use a unicode array to " 2577 "initialize an array with typecode '%c'", c); 2578 return NULL; 2579 } 2580 } 2581 2582 if (!(initial == NULL || PyList_Check(initial) 2583 || PyByteArray_Check(initial) 2584 || PyBytes_Check(initial) 2585 || PyTuple_Check(initial) 2586 || ((c=='u') && PyUnicode_Check(initial)) 2587 || (array_Check(initial) 2588 && c == ((arrayobject*)initial)->ob_descr->typecode))) { 2589 it = PyObject_GetIter(initial); 2590 if (it == NULL) 2591 return NULL; 2592 /* We set initial to NULL so that the subsequent code 2593 will create an empty array of the appropriate type 2594 and afterwards we can use array_iter_extend to populate 2595 the array. 2596 */ 2597 initial = NULL; 2598 } 2599 for (descr = descriptors; descr->typecode != '\0'; descr++) { 2600 if (descr->typecode == c) { 2601 PyObject *a; 2602 Py_ssize_t len; 2603 2604 if (initial == NULL) 2605 len = 0; 2606 else if (PyList_Check(initial)) 2607 len = PyList_GET_SIZE(initial); 2608 else if (PyTuple_Check(initial) || array_Check(initial)) 2609 len = Py_SIZE(initial); 2610 else 2611 len = 0; 2612 2613 a = newarrayobject(type, len, descr); 2614 if (a == NULL) 2615 return NULL; 2616 2617 if (len > 0 && !array_Check(initial)) { 2618 Py_ssize_t i; 2619 for (i = 0; i < len; i++) { 2620 PyObject *v = 2621 PySequence_GetItem(initial, i); 2622 if (v == NULL) { 2623 Py_DECREF(a); 2624 return NULL; 2625 } 2626 if (setarrayitem(a, i, v) != 0) { 2627 Py_DECREF(v); 2628 Py_DECREF(a); 2629 return NULL; 2630 } 2631 Py_DECREF(v); 2632 } 2633 } 2634 else if (initial != NULL && (PyByteArray_Check(initial) || 2635 PyBytes_Check(initial))) { 2636 PyObject *v; 2637 v = array_array_frombytes((arrayobject *)a, 2638 initial); 2639 if (v == NULL) { 2640 Py_DECREF(a); 2641 return NULL; 2642 } 2643 Py_DECREF(v); 2644 } 2645 else if (initial != NULL && PyUnicode_Check(initial)) { 2646 Py_UNICODE *ustr; 2647 Py_ssize_t n; 2648 2649 ustr = PyUnicode_AsUnicode(initial); 2650 if (ustr == NULL) { 2651 PyErr_NoMemory(); 2652 Py_DECREF(a); 2653 return NULL; 2654 } 2655 2656 n = PyUnicode_GET_DATA_SIZE(initial); 2657 if (n > 0) { 2658 arrayobject *self = (arrayobject *)a; 2659 char *item = self->ob_item; 2660 item = (char *)PyMem_Realloc(item, n); 2661 if (item == NULL) { 2662 PyErr_NoMemory(); 2663 Py_DECREF(a); 2664 return NULL; 2665 } 2666 self->ob_item = item; 2667 Py_SIZE(self) = n / sizeof(Py_UNICODE); 2668 memcpy(item, ustr, n); 2669 self->allocated = Py_SIZE(self); 2670 } 2671 } 2672 else if (initial != NULL && array_Check(initial) && len > 0) { 2673 arrayobject *self = (arrayobject *)a; 2674 arrayobject *other = (arrayobject *)initial; 2675 memcpy(self->ob_item, other->ob_item, len * other->ob_descr->itemsize); 2676 } 2677 if (it != NULL) { 2678 if (array_iter_extend((arrayobject *)a, it) == -1) { 2679 Py_DECREF(it); 2680 Py_DECREF(a); 2681 return NULL; 2682 } 2683 Py_DECREF(it); 2684 } 2685 return a; 2686 } 2687 } 2688 PyErr_SetString(PyExc_ValueError, 2689 "bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)"); 2690 return NULL; 2691 } 2692 2693 2694 PyDoc_STRVAR(module_doc, 2695 "This module defines an object type which can efficiently represent\n\ 2696 an array of basic values: characters, integers, floating point\n\ 2697 numbers. Arrays are sequence types and behave very much like lists,\n\ 2698 except that the type of objects stored in them is constrained.\n"); 2699 2700 PyDoc_STRVAR(arraytype_doc, 2701 "array(typecode [, initializer]) -> array\n\ 2702 \n\ 2703 Return a new array whose items are restricted by typecode, and\n\ 2704 initialized from the optional initializer value, which must be a list,\n\ 2705 string or iterable over elements of the appropriate type.\n\ 2706 \n\ 2707 Arrays represent basic values and behave very much like lists, except\n\ 2708 the type of objects stored in them is constrained. The type is specified\n\ 2709 at object creation time by using a type code, which is a single character.\n\ 2710 The following type codes are defined:\n\ 2711 \n\ 2712 Type code C Type Minimum size in bytes \n\ 2713 'b' signed integer 1 \n\ 2714 'B' unsigned integer 1 \n\ 2715 'u' Unicode character 2 (see note) \n\ 2716 'h' signed integer 2 \n\ 2717 'H' unsigned integer 2 \n\ 2718 'i' signed integer 2 \n\ 2719 'I' unsigned integer 2 \n\ 2720 'l' signed integer 4 \n\ 2721 'L' unsigned integer 4 \n\ 2722 'q' signed integer 8 (see note) \n\ 2723 'Q' unsigned integer 8 (see note) \n\ 2724 'f' floating point 4 \n\ 2725 'd' floating point 8 \n\ 2726 \n\ 2727 NOTE: The 'u' typecode corresponds to Python's unicode character. On \n\ 2728 narrow builds this is 2-bytes on wide builds this is 4-bytes.\n\ 2729 \n\ 2730 NOTE: The 'q' and 'Q' type codes are only available if the platform \n\ 2731 C compiler used to build Python supports 'long long', or, on Windows, \n\ 2732 '__int64'.\n\ 2733 \n\ 2734 Methods:\n\ 2735 \n\ 2736 append() -- append a new item to the end of the array\n\ 2737 buffer_info() -- return information giving the current memory info\n\ 2738 byteswap() -- byteswap all the items of the array\n\ 2739 count() -- return number of occurrences of an object\n\ 2740 extend() -- extend array by appending multiple elements from an iterable\n\ 2741 fromfile() -- read items from a file object\n\ 2742 fromlist() -- append items from the list\n\ 2743 frombytes() -- append items from the string\n\ 2744 index() -- return index of first occurrence of an object\n\ 2745 insert() -- insert a new item into the array at a provided position\n\ 2746 pop() -- remove and return item (default last)\n\ 2747 remove() -- remove first occurrence of an object\n\ 2748 reverse() -- reverse the order of the items in the array\n\ 2749 tofile() -- write all items to a file object\n\ 2750 tolist() -- return the array converted to an ordinary list\n\ 2751 tobytes() -- return the array converted to a string\n\ 2752 \n\ 2753 Attributes:\n\ 2754 \n\ 2755 typecode -- the typecode character used to create the array\n\ 2756 itemsize -- the length in bytes of one array item\n\ 2757 "); 2758 2759 static PyObject *array_iter(arrayobject *ao); 2760 2761 static PyTypeObject Arraytype = { 2762 PyVarObject_HEAD_INIT(NULL, 0) 2763 "array.array", 2764 sizeof(arrayobject), 2765 0, 2766 (destructor)array_dealloc, /* tp_dealloc */ 2767 0, /* tp_print */ 2768 0, /* tp_getattr */ 2769 0, /* tp_setattr */ 2770 0, /* tp_reserved */ 2771 (reprfunc)array_repr, /* tp_repr */ 2772 0, /* tp_as_number*/ 2773 &array_as_sequence, /* tp_as_sequence*/ 2774 &array_as_mapping, /* tp_as_mapping*/ 2775 0, /* tp_hash */ 2776 0, /* tp_call */ 2777 0, /* tp_str */ 2778 PyObject_GenericGetAttr, /* tp_getattro */ 2779 0, /* tp_setattro */ 2780 &array_as_buffer, /* tp_as_buffer*/ 2781 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ 2782 arraytype_doc, /* tp_doc */ 2783 0, /* tp_traverse */ 2784 0, /* tp_clear */ 2785 array_richcompare, /* tp_richcompare */ 2786 offsetof(arrayobject, weakreflist), /* tp_weaklistoffset */ 2787 (getiterfunc)array_iter, /* tp_iter */ 2788 0, /* tp_iternext */ 2789 array_methods, /* tp_methods */ 2790 0, /* tp_members */ 2791 array_getsets, /* tp_getset */ 2792 0, /* tp_base */ 2793 0, /* tp_dict */ 2794 0, /* tp_descr_get */ 2795 0, /* tp_descr_set */ 2796 0, /* tp_dictoffset */ 2797 0, /* tp_init */ 2798 PyType_GenericAlloc, /* tp_alloc */ 2799 array_new, /* tp_new */ 2800 PyObject_Del, /* tp_free */ 2801 }; 2802 2803 2804 /*********************** Array Iterator **************************/ 2805 2806 /*[clinic input] 2807 class array.arrayiterator "arrayiterobject *" "&PyArrayIter_Type" 2808 [clinic start generated code]*/ 2809 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=5aefd2d74d8c8e30]*/ 2810 2811 static PyObject * 2812 array_iter(arrayobject *ao) 2813 { 2814 arrayiterobject *it; 2815 2816 if (!array_Check(ao)) { 2817 PyErr_BadInternalCall(); 2818 return NULL; 2819 } 2820 2821 it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type); 2822 if (it == NULL) 2823 return NULL; 2824 2825 Py_INCREF(ao); 2826 it->ao = ao; 2827 it->index = 0; 2828 it->getitem = ao->ob_descr->getitem; 2829 PyObject_GC_Track(it); 2830 return (PyObject *)it; 2831 } 2832 2833 static PyObject * 2834 arrayiter_next(arrayiterobject *it) 2835 { 2836 arrayobject *ao; 2837 2838 assert(it != NULL); 2839 assert(PyArrayIter_Check(it)); 2840 ao = it->ao; 2841 if (ao == NULL) { 2842 return NULL; 2843 } 2844 assert(array_Check(ao)); 2845 if (it->index < Py_SIZE(ao)) { 2846 return (*it->getitem)(ao, it->index++); 2847 } 2848 it->ao = NULL; 2849 Py_DECREF(ao); 2850 return NULL; 2851 } 2852 2853 static void 2854 arrayiter_dealloc(arrayiterobject *it) 2855 { 2856 PyObject_GC_UnTrack(it); 2857 Py_XDECREF(it->ao); 2858 PyObject_GC_Del(it); 2859 } 2860 2861 static int 2862 arrayiter_traverse(arrayiterobject *it, visitproc visit, void *arg) 2863 { 2864 Py_VISIT(it->ao); 2865 return 0; 2866 } 2867 2868 /*[clinic input] 2869 array.arrayiterator.__reduce__ 2870 2871 Return state information for pickling. 2872 [clinic start generated code]*/ 2873 2874 static PyObject * 2875 array_arrayiterator___reduce___impl(arrayiterobject *self) 2876 /*[clinic end generated code: output=7898a52e8e66e016 input=a062ea1e9951417a]*/ 2877 { 2878 PyObject *func = _PyObject_GetBuiltin("iter"); 2879 if (self->ao == NULL) { 2880 return Py_BuildValue("N(())", func); 2881 } 2882 return Py_BuildValue("N(O)n", func, self->ao, self->index); 2883 } 2884 2885 /*[clinic input] 2886 array.arrayiterator.__setstate__ 2887 2888 state: object 2889 / 2890 2891 Set state information for unpickling. 2892 [clinic start generated code]*/ 2893 2894 static PyObject * 2895 array_arrayiterator___setstate__(arrayiterobject *self, PyObject *state) 2896 /*[clinic end generated code: output=397da9904e443cbe input=f47d5ceda19e787b]*/ 2897 { 2898 Py_ssize_t index = PyLong_AsSsize_t(state); 2899 if (index == -1 && PyErr_Occurred()) 2900 return NULL; 2901 if (index < 0) 2902 index = 0; 2903 else if (index > Py_SIZE(self->ao)) 2904 index = Py_SIZE(self->ao); /* iterator exhausted */ 2905 self->index = index; 2906 Py_RETURN_NONE; 2907 } 2908 2909 static PyMethodDef arrayiter_methods[] = { 2910 ARRAY_ARRAYITERATOR___REDUCE___METHODDEF 2911 ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF 2912 {NULL, NULL} /* sentinel */ 2913 }; 2914 2915 static PyTypeObject PyArrayIter_Type = { 2916 PyVarObject_HEAD_INIT(NULL, 0) 2917 "arrayiterator", /* tp_name */ 2918 sizeof(arrayiterobject), /* tp_basicsize */ 2919 0, /* tp_itemsize */ 2920 /* methods */ 2921 (destructor)arrayiter_dealloc, /* tp_dealloc */ 2922 0, /* tp_print */ 2923 0, /* tp_getattr */ 2924 0, /* tp_setattr */ 2925 0, /* tp_reserved */ 2926 0, /* tp_repr */ 2927 0, /* tp_as_number */ 2928 0, /* tp_as_sequence */ 2929 0, /* tp_as_mapping */ 2930 0, /* tp_hash */ 2931 0, /* tp_call */ 2932 0, /* tp_str */ 2933 PyObject_GenericGetAttr, /* tp_getattro */ 2934 0, /* tp_setattro */ 2935 0, /* tp_as_buffer */ 2936 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ 2937 0, /* tp_doc */ 2938 (traverseproc)arrayiter_traverse, /* tp_traverse */ 2939 0, /* tp_clear */ 2940 0, /* tp_richcompare */ 2941 0, /* tp_weaklistoffset */ 2942 PyObject_SelfIter, /* tp_iter */ 2943 (iternextfunc)arrayiter_next, /* tp_iternext */ 2944 arrayiter_methods, /* tp_methods */ 2945 }; 2946 2947 2948 /*********************** Install Module **************************/ 2949 2950 /* No functions in array module. */ 2951 static PyMethodDef a_methods[] = { 2952 ARRAY__ARRAY_RECONSTRUCTOR_METHODDEF 2953 {NULL, NULL, 0, NULL} /* Sentinel */ 2954 }; 2955 2956 static int 2957 array_modexec(PyObject *m) 2958 { 2959 char buffer[Py_ARRAY_LENGTH(descriptors)], *p; 2960 PyObject *typecodes; 2961 Py_ssize_t size = 0; 2962 const struct arraydescr *descr; 2963 2964 if (PyType_Ready(&Arraytype) < 0) 2965 return -1; 2966 Py_TYPE(&PyArrayIter_Type) = &PyType_Type; 2967 2968 Py_INCREF((PyObject *)&Arraytype); 2969 PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype); 2970 Py_INCREF((PyObject *)&Arraytype); 2971 PyModule_AddObject(m, "array", (PyObject *)&Arraytype); 2972 2973 for (descr=descriptors; descr->typecode != '\0'; descr++) { 2974 size++; 2975 } 2976 2977 p = buffer; 2978 for (descr = descriptors; descr->typecode != '\0'; descr++) { 2979 *p++ = (char)descr->typecode; 2980 } 2981 typecodes = PyUnicode_DecodeASCII(buffer, p - buffer, NULL); 2982 2983 PyModule_AddObject(m, "typecodes", typecodes); 2984 2985 if (PyErr_Occurred()) { 2986 Py_DECREF(m); 2987 m = NULL; 2988 } 2989 return 0; 2990 } 2991 2992 static PyModuleDef_Slot arrayslots[] = { 2993 {Py_mod_exec, array_modexec}, 2994 {0, NULL} 2995 }; 2996 2997 2998 static struct PyModuleDef arraymodule = { 2999 PyModuleDef_HEAD_INIT, 3000 "array", 3001 module_doc, 3002 0, 3003 a_methods, 3004 arrayslots, 3005 NULL, 3006 NULL, 3007 NULL 3008 }; 3009 3010 3011 PyMODINIT_FUNC 3012 PyInit_array(void) 3013 { 3014 return PyModuleDef_Init(&arraymodule); 3015 } 3016
