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 18struct arrayobject; /* Forward */ 19 20/* All possible arraydescr values are defined in the vector "descriptors" 21 * below. That's defined later because the appropriate get and set 22 * functions aren't visible yet. 23 */ 24struct arraydescr { 25 int typecode; 26 int itemsize; 27 PyObject * (*getitem)(struct arrayobject *, Py_ssize_t); 28 int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *); 29}; 30 31typedef struct arrayobject { 32 PyObject_VAR_HEAD 33 char *ob_item; 34 Py_ssize_t allocated; 35 struct arraydescr *ob_descr; 36 PyObject *weakreflist; /* List of weak references */ 37} arrayobject; 38 39static PyTypeObject Arraytype; 40 41#define array_Check(op) PyObject_TypeCheck(op, &Arraytype) 42#define array_CheckExact(op) (Py_TYPE(op) == &Arraytype) 43 44static int 45array_resize(arrayobject *self, Py_ssize_t newsize) 46{ 47 char *items; 48 size_t _new_size; 49 50 /* Bypass realloc() when a previous overallocation is large enough 51 to accommodate the newsize. If the newsize is 16 smaller than the 52 current size, then proceed with the realloc() to shrink the list. 53 */ 54 55 if (self->allocated >= newsize && 56 Py_SIZE(self) < newsize + 16 && 57 self->ob_item != NULL) { 58 Py_SIZE(self) = newsize; 59 return 0; 60 } 61 62 /* This over-allocates proportional to the array size, making room 63 * for additional growth. The over-allocation is mild, but is 64 * enough to give linear-time amortized behavior over a long 65 * sequence of appends() in the presence of a poorly-performing 66 * system realloc(). 67 * The growth pattern is: 0, 4, 8, 16, 25, 34, 46, 56, 67, 79, ... 68 * Note, the pattern starts out the same as for lists but then 69 * grows at a smaller rate so that larger arrays only overallocate 70 * by about 1/16th -- this is done because arrays are presumed to be more 71 * memory critical. 72 */ 73 74 _new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize; 75 items = self->ob_item; 76 /* XXX The following multiplication and division does not optimize away 77 like it does for lists since the size is not known at compile time */ 78 if (_new_size <= ((~(size_t)0) / self->ob_descr->itemsize)) 79 PyMem_RESIZE(items, char, (_new_size * self->ob_descr->itemsize)); 80 else 81 items = NULL; 82 if (items == NULL) { 83 PyErr_NoMemory(); 84 return -1; 85 } 86 self->ob_item = items; 87 Py_SIZE(self) = newsize; 88 self->allocated = _new_size; 89 return 0; 90} 91 92/**************************************************************************** 93Get and Set functions for each type. 94A Get function takes an arrayobject* and an integer index, returning the 95array value at that index wrapped in an appropriate PyObject*. 96A Set function takes an arrayobject, integer index, and PyObject*; sets 97the array value at that index to the raw C data extracted from the PyObject*, 98and returns 0 if successful, else nonzero on failure (PyObject* not of an 99appropriate type or value). 100Note that the basic Get and Set functions do NOT check that the index is 101in bounds; that's the responsibility of the caller. 102****************************************************************************/ 103 104static PyObject * 105c_getitem(arrayobject *ap, Py_ssize_t i) 106{ 107 return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1); 108} 109 110static int 111c_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 112{ 113 char x; 114 if (!PyArg_Parse(v, "c;array item must be char", &x)) 115 return -1; 116 if (i >= 0) 117 ((char *)ap->ob_item)[i] = x; 118 return 0; 119} 120 121static PyObject * 122b_getitem(arrayobject *ap, Py_ssize_t i) 123{ 124 long x = ((char *)ap->ob_item)[i]; 125 if (x >= 128) 126 x -= 256; 127 return PyInt_FromLong(x); 128} 129 130static int 131b_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 132{ 133 short x; 134 /* PyArg_Parse's 'b' formatter is for an unsigned char, therefore 135 must use the next size up that is signed ('h') and manually do 136 the overflow checking */ 137 if (!PyArg_Parse(v, "h;array item must be integer", &x)) 138 return -1; 139 else if (x < -128) { 140 PyErr_SetString(PyExc_OverflowError, 141 "signed char is less than minimum"); 142 return -1; 143 } 144 else if (x > 127) { 145 PyErr_SetString(PyExc_OverflowError, 146 "signed char is greater than maximum"); 147 return -1; 148 } 149 if (i >= 0) 150 ((char *)ap->ob_item)[i] = (char)x; 151 return 0; 152} 153 154static PyObject * 155BB_getitem(arrayobject *ap, Py_ssize_t i) 156{ 157 long x = ((unsigned char *)ap->ob_item)[i]; 158 return PyInt_FromLong(x); 159} 160 161static int 162BB_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 163{ 164 unsigned char x; 165 /* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */ 166 if (!PyArg_Parse(v, "b;array item must be integer", &x)) 167 return -1; 168 if (i >= 0) 169 ((char *)ap->ob_item)[i] = x; 170 return 0; 171} 172 173#ifdef Py_USING_UNICODE 174static PyObject * 175u_getitem(arrayobject *ap, Py_ssize_t i) 176{ 177 return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1); 178} 179 180static int 181u_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 182{ 183 Py_UNICODE *p; 184 Py_ssize_t len; 185 186 if (!PyArg_Parse(v, "u#;array item must be unicode character", &p, &len)) 187 return -1; 188 if (len != 1) { 189 PyErr_SetString(PyExc_TypeError, 190 "array item must be unicode character"); 191 return -1; 192 } 193 if (i >= 0) 194 ((Py_UNICODE *)ap->ob_item)[i] = p[0]; 195 return 0; 196} 197#endif 198 199static PyObject * 200h_getitem(arrayobject *ap, Py_ssize_t i) 201{ 202 return PyInt_FromLong((long) ((short *)ap->ob_item)[i]); 203} 204 205static int 206h_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 207{ 208 short x; 209 /* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */ 210 if (!PyArg_Parse(v, "h;array item must be integer", &x)) 211 return -1; 212 if (i >= 0) 213 ((short *)ap->ob_item)[i] = x; 214 return 0; 215} 216 217static PyObject * 218HH_getitem(arrayobject *ap, Py_ssize_t i) 219{ 220 return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]); 221} 222 223static int 224HH_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 225{ 226 int x; 227 /* PyArg_Parse's 'h' formatter is for a signed short, therefore 228 must use the next size up and manually do the overflow checking */ 229 if (!PyArg_Parse(v, "i;array item must be integer", &x)) 230 return -1; 231 else if (x < 0) { 232 PyErr_SetString(PyExc_OverflowError, 233 "unsigned short is less than minimum"); 234 return -1; 235 } 236 else if (x > USHRT_MAX) { 237 PyErr_SetString(PyExc_OverflowError, 238 "unsigned short is greater than maximum"); 239 return -1; 240 } 241 if (i >= 0) 242 ((short *)ap->ob_item)[i] = (short)x; 243 return 0; 244} 245 246static PyObject * 247i_getitem(arrayobject *ap, Py_ssize_t i) 248{ 249 return PyInt_FromLong((long) ((int *)ap->ob_item)[i]); 250} 251 252static int 253i_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 254{ 255 int x; 256 /* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */ 257 if (!PyArg_Parse(v, "i;array item must be integer", &x)) 258 return -1; 259 if (i >= 0) 260 ((int *)ap->ob_item)[i] = x; 261 return 0; 262} 263 264static PyObject * 265II_getitem(arrayobject *ap, Py_ssize_t i) 266{ 267 return PyLong_FromUnsignedLong( 268 (unsigned long) ((unsigned int *)ap->ob_item)[i]); 269} 270 271static int 272II_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 273{ 274 unsigned long x; 275 if (PyLong_Check(v)) { 276 x = PyLong_AsUnsignedLong(v); 277 if (x == (unsigned long) -1 && PyErr_Occurred()) 278 return -1; 279 } 280 else { 281 long y; 282 if (!PyArg_Parse(v, "l;array item must be integer", &y)) 283 return -1; 284 if (y < 0) { 285 PyErr_SetString(PyExc_OverflowError, 286 "unsigned int is less than minimum"); 287 return -1; 288 } 289 x = (unsigned long)y; 290 291 } 292 if (x > UINT_MAX) { 293 PyErr_SetString(PyExc_OverflowError, 294 "unsigned int is greater than maximum"); 295 return -1; 296 } 297 298 if (i >= 0) 299 ((unsigned int *)ap->ob_item)[i] = (unsigned int)x; 300 return 0; 301} 302 303static PyObject * 304l_getitem(arrayobject *ap, Py_ssize_t i) 305{ 306 return PyInt_FromLong(((long *)ap->ob_item)[i]); 307} 308 309static int 310l_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 311{ 312 long x; 313 if (!PyArg_Parse(v, "l;array item must be integer", &x)) 314 return -1; 315 if (i >= 0) 316 ((long *)ap->ob_item)[i] = x; 317 return 0; 318} 319 320static PyObject * 321LL_getitem(arrayobject *ap, Py_ssize_t i) 322{ 323 return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]); 324} 325 326static int 327LL_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 328{ 329 unsigned long x; 330 if (PyLong_Check(v)) { 331 x = PyLong_AsUnsignedLong(v); 332 if (x == (unsigned long) -1 && PyErr_Occurred()) 333 return -1; 334 } 335 else { 336 long y; 337 if (!PyArg_Parse(v, "l;array item must be integer", &y)) 338 return -1; 339 if (y < 0) { 340 PyErr_SetString(PyExc_OverflowError, 341 "unsigned long is less than minimum"); 342 return -1; 343 } 344 x = (unsigned long)y; 345 346 } 347 if (x > ULONG_MAX) { 348 PyErr_SetString(PyExc_OverflowError, 349 "unsigned long is greater than maximum"); 350 return -1; 351 } 352 353 if (i >= 0) 354 ((unsigned long *)ap->ob_item)[i] = x; 355 return 0; 356} 357 358static PyObject * 359f_getitem(arrayobject *ap, Py_ssize_t i) 360{ 361 return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]); 362} 363 364static int 365f_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 366{ 367 float x; 368 if (!PyArg_Parse(v, "f;array item must be float", &x)) 369 return -1; 370 if (i >= 0) 371 ((float *)ap->ob_item)[i] = x; 372 return 0; 373} 374 375static PyObject * 376d_getitem(arrayobject *ap, Py_ssize_t i) 377{ 378 return PyFloat_FromDouble(((double *)ap->ob_item)[i]); 379} 380 381static int 382d_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v) 383{ 384 double x; 385 if (!PyArg_Parse(v, "d;array item must be float", &x)) 386 return -1; 387 if (i >= 0) 388 ((double *)ap->ob_item)[i] = x; 389 return 0; 390} 391 392/* Description of types */ 393static struct arraydescr descriptors[] = { 394 {'c', sizeof(char), c_getitem, c_setitem}, 395 {'b', sizeof(char), b_getitem, b_setitem}, 396 {'B', sizeof(char), BB_getitem, BB_setitem}, 397#ifdef Py_USING_UNICODE 398 {'u', sizeof(Py_UNICODE), u_getitem, u_setitem}, 399#endif 400 {'h', sizeof(short), h_getitem, h_setitem}, 401 {'H', sizeof(short), HH_getitem, HH_setitem}, 402 {'i', sizeof(int), i_getitem, i_setitem}, 403 {'I', sizeof(int), II_getitem, II_setitem}, 404 {'l', sizeof(long), l_getitem, l_setitem}, 405 {'L', sizeof(long), LL_getitem, LL_setitem}, 406 {'f', sizeof(float), f_getitem, f_setitem}, 407 {'d', sizeof(double), d_getitem, d_setitem}, 408 {'\0', 0, 0, 0} /* Sentinel */ 409}; 410 411/**************************************************************************** 412Implementations of array object methods. 413****************************************************************************/ 414 415static PyObject * 416newarrayobject(PyTypeObject *type, Py_ssize_t size, struct arraydescr *descr) 417{ 418 arrayobject *op; 419 size_t nbytes; 420 421 if (size < 0) { 422 PyErr_BadInternalCall(); 423 return NULL; 424 } 425 426 nbytes = size * descr->itemsize; 427 /* Check for overflow */ 428 if (nbytes / descr->itemsize != (size_t)size) { 429 return PyErr_NoMemory(); 430 } 431 op = (arrayobject *) type->tp_alloc(type, 0); 432 if (op == NULL) { 433 return NULL; 434 } 435 op->ob_descr = descr; 436 op->allocated = size; 437 op->weakreflist = NULL; 438 Py_SIZE(op) = size; 439 if (size <= 0) { 440 op->ob_item = NULL; 441 } 442 else { 443 op->ob_item = PyMem_NEW(char, nbytes); 444 if (op->ob_item == NULL) { 445 Py_DECREF(op); 446 return PyErr_NoMemory(); 447 } 448 } 449 return (PyObject *) op; 450} 451 452static PyObject * 453getarrayitem(PyObject *op, Py_ssize_t i) 454{ 455 register arrayobject *ap; 456 assert(array_Check(op)); 457 ap = (arrayobject *)op; 458 assert(i>=0 && i<Py_SIZE(ap)); 459 return (*ap->ob_descr->getitem)(ap, i); 460} 461 462static int 463ins1(arrayobject *self, Py_ssize_t where, PyObject *v) 464{ 465 char *items; 466 Py_ssize_t n = Py_SIZE(self); 467 if (v == NULL) { 468 PyErr_BadInternalCall(); 469 return -1; 470 } 471 if ((*self->ob_descr->setitem)(self, -1, v) < 0) 472 return -1; 473 474 if (array_resize(self, n+1) == -1) 475 return -1; 476 items = self->ob_item; 477 if (where < 0) { 478 where += n; 479 if (where < 0) 480 where = 0; 481 } 482 if (where > n) 483 where = n; 484 /* appends don't need to call memmove() */ 485 if (where != n) 486 memmove(items + (where+1)*self->ob_descr->itemsize, 487 items + where*self->ob_descr->itemsize, 488 (n-where)*self->ob_descr->itemsize); 489 return (*self->ob_descr->setitem)(self, where, v); 490} 491 492/* Methods */ 493 494static void 495array_dealloc(arrayobject *op) 496{ 497 if (op->weakreflist != NULL) 498 PyObject_ClearWeakRefs((PyObject *) op); 499 if (op->ob_item != NULL) 500 PyMem_DEL(op->ob_item); 501 Py_TYPE(op)->tp_free((PyObject *)op); 502} 503 504static PyObject * 505array_richcompare(PyObject *v, PyObject *w, int op) 506{ 507 arrayobject *va, *wa; 508 PyObject *vi = NULL; 509 PyObject *wi = NULL; 510 Py_ssize_t i, k; 511 PyObject *res; 512 513 if (!array_Check(v) || !array_Check(w)) { 514 Py_INCREF(Py_NotImplemented); 515 return Py_NotImplemented; 516 } 517 518 va = (arrayobject *)v; 519 wa = (arrayobject *)w; 520 521 if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ || op == Py_NE)) { 522 /* Shortcut: if the lengths differ, the arrays differ */ 523 if (op == Py_EQ) 524 res = Py_False; 525 else 526 res = Py_True; 527 Py_INCREF(res); 528 return res; 529 } 530 531 /* Search for the first index where items are different */ 532 k = 1; 533 for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) { 534 vi = getarrayitem(v, i); 535 wi = getarrayitem(w, i); 536 if (vi == NULL || wi == NULL) { 537 Py_XDECREF(vi); 538 Py_XDECREF(wi); 539 return NULL; 540 } 541 k = PyObject_RichCompareBool(vi, wi, Py_EQ); 542 if (k == 0) 543 break; /* Keeping vi and wi alive! */ 544 Py_DECREF(vi); 545 Py_DECREF(wi); 546 if (k < 0) 547 return NULL; 548 } 549 550 if (k) { 551 /* No more items to compare -- compare sizes */ 552 Py_ssize_t vs = Py_SIZE(va); 553 Py_ssize_t ws = Py_SIZE(wa); 554 int cmp; 555 switch (op) { 556 case Py_LT: cmp = vs < ws; break; 557 case Py_LE: cmp = vs <= ws; break; 558 case Py_EQ: cmp = vs == ws; break; 559 case Py_NE: cmp = vs != ws; break; 560 case Py_GT: cmp = vs > ws; break; 561 case Py_GE: cmp = vs >= ws; break; 562 default: return NULL; /* cannot happen */ 563 } 564 if (cmp) 565 res = Py_True; 566 else 567 res = Py_False; 568 Py_INCREF(res); 569 return res; 570 } 571 572 /* We have an item that differs. First, shortcuts for EQ/NE */ 573 if (op == Py_EQ) { 574 Py_INCREF(Py_False); 575 res = Py_False; 576 } 577 else if (op == Py_NE) { 578 Py_INCREF(Py_True); 579 res = Py_True; 580 } 581 else { 582 /* Compare the final item again using the proper operator */ 583 res = PyObject_RichCompare(vi, wi, op); 584 } 585 Py_DECREF(vi); 586 Py_DECREF(wi); 587 return res; 588} 589 590static Py_ssize_t 591array_length(arrayobject *a) 592{ 593 return Py_SIZE(a); 594} 595 596static PyObject * 597array_item(arrayobject *a, Py_ssize_t i) 598{ 599 if (i < 0 || i >= Py_SIZE(a)) { 600 PyErr_SetString(PyExc_IndexError, "array index out of range"); 601 return NULL; 602 } 603 return getarrayitem((PyObject *)a, i); 604} 605 606static PyObject * 607array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh) 608{ 609 arrayobject *np; 610 if (ilow < 0) 611 ilow = 0; 612 else if (ilow > Py_SIZE(a)) 613 ilow = Py_SIZE(a); 614 if (ihigh < 0) 615 ihigh = 0; 616 if (ihigh < ilow) 617 ihigh = ilow; 618 else if (ihigh > Py_SIZE(a)) 619 ihigh = Py_SIZE(a); 620 np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr); 621 if (np == NULL) 622 return NULL; 623 if (ihigh > ilow) { 624 memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize, 625 (ihigh-ilow) * a->ob_descr->itemsize); 626 } 627 return (PyObject *)np; 628} 629 630static PyObject * 631array_copy(arrayobject *a, PyObject *unused) 632{ 633 return array_slice(a, 0, Py_SIZE(a)); 634} 635 636PyDoc_STRVAR(copy_doc, 637"copy(array)\n\ 638\n\ 639 Return a copy of the array."); 640 641static PyObject * 642array_concat(arrayobject *a, PyObject *bb) 643{ 644 Py_ssize_t size; 645 arrayobject *np; 646 if (!array_Check(bb)) { 647 PyErr_Format(PyExc_TypeError, 648 "can only append array (not \"%.200s\") to array", 649 Py_TYPE(bb)->tp_name); 650 return NULL; 651 } 652#define b ((arrayobject *)bb) 653 if (a->ob_descr != b->ob_descr) { 654 PyErr_BadArgument(); 655 return NULL; 656 } 657 if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) { 658 return PyErr_NoMemory(); 659 } 660 size = Py_SIZE(a) + Py_SIZE(b); 661 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr); 662 if (np == NULL) { 663 return NULL; 664 } 665 if (Py_SIZE(a) > 0) { 666 memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize); 667 } 668 if (Py_SIZE(b) > 0) { 669 memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize, 670 b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize); 671 } 672 return (PyObject *)np; 673#undef b 674} 675 676static PyObject * 677array_repeat(arrayobject *a, Py_ssize_t n) 678{ 679 Py_ssize_t i; 680 Py_ssize_t size; 681 arrayobject *np; 682 char *p; 683 Py_ssize_t nbytes; 684 if (n < 0) 685 n = 0; 686 if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) { 687 return PyErr_NoMemory(); 688 } 689 size = Py_SIZE(a) * n; 690 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr); 691 if (np == NULL) 692 return NULL; 693 if (size == 0) 694 return (PyObject *)np; 695 p = np->ob_item; 696 nbytes = Py_SIZE(a) * a->ob_descr->itemsize; 697 for (i = 0; i < n; i++) { 698 memcpy(p, a->ob_item, nbytes); 699 p += nbytes; 700 } 701 return (PyObject *) np; 702} 703 704static int 705array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v) 706{ 707 char *item; 708 Py_ssize_t n; /* Size of replacement array */ 709 Py_ssize_t d; /* Change in size */ 710#define b ((arrayobject *)v) 711 if (v == NULL) 712 n = 0; 713 else if (array_Check(v)) { 714 n = Py_SIZE(b); 715 if (a == b) { 716 /* Special case "a[i:j] = a" -- copy b first */ 717 int ret; 718 v = array_slice(b, 0, n); 719 if (!v) 720 return -1; 721 ret = array_ass_slice(a, ilow, ihigh, v); 722 Py_DECREF(v); 723 return ret; 724 } 725 if (b->ob_descr != a->ob_descr) { 726 PyErr_BadArgument(); 727 return -1; 728 } 729 } 730 else { 731 PyErr_Format(PyExc_TypeError, 732 "can only assign array (not \"%.200s\") to array slice", 733 Py_TYPE(v)->tp_name); 734 return -1; 735 } 736 if (ilow < 0) 737 ilow = 0; 738 else if (ilow > Py_SIZE(a)) 739 ilow = Py_SIZE(a); 740 if (ihigh < 0) 741 ihigh = 0; 742 if (ihigh < ilow) 743 ihigh = ilow; 744 else if (ihigh > Py_SIZE(a)) 745 ihigh = Py_SIZE(a); 746 item = a->ob_item; 747 d = n - (ihigh-ilow); 748 if (d < 0) { /* Delete -d items */ 749 memmove(item + (ihigh+d)*a->ob_descr->itemsize, 750 item + ihigh*a->ob_descr->itemsize, 751 (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize); 752 Py_SIZE(a) += d; 753 PyMem_RESIZE(item, char, Py_SIZE(a)*a->ob_descr->itemsize); 754 /* Can't fail */ 755 a->ob_item = item; 756 a->allocated = Py_SIZE(a); 757 } 758 else if (d > 0) { /* Insert d items */ 759 PyMem_RESIZE(item, char, 760 (Py_SIZE(a) + d)*a->ob_descr->itemsize); 761 if (item == NULL) { 762 PyErr_NoMemory(); 763 return -1; 764 } 765 memmove(item + (ihigh+d)*a->ob_descr->itemsize, 766 item + ihigh*a->ob_descr->itemsize, 767 (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize); 768 a->ob_item = item; 769 Py_SIZE(a) += d; 770 a->allocated = Py_SIZE(a); 771 } 772 if (n > 0) 773 memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item, 774 n*b->ob_descr->itemsize); 775 return 0; 776#undef b 777} 778 779static int 780array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v) 781{ 782 if (i < 0 || i >= Py_SIZE(a)) { 783 PyErr_SetString(PyExc_IndexError, 784 "array assignment index out of range"); 785 return -1; 786 } 787 if (v == NULL) 788 return array_ass_slice(a, i, i+1, v); 789 return (*a->ob_descr->setitem)(a, i, v); 790} 791 792static int 793setarrayitem(PyObject *a, Py_ssize_t i, PyObject *v) 794{ 795 assert(array_Check(a)); 796 return array_ass_item((arrayobject *)a, i, v); 797} 798 799static int 800array_iter_extend(arrayobject *self, PyObject *bb) 801{ 802 PyObject *it, *v; 803 804 it = PyObject_GetIter(bb); 805 if (it == NULL) 806 return -1; 807 808 while ((v = PyIter_Next(it)) != NULL) { 809 if (ins1(self, Py_SIZE(self), v) != 0) { 810 Py_DECREF(v); 811 Py_DECREF(it); 812 return -1; 813 } 814 Py_DECREF(v); 815 } 816 Py_DECREF(it); 817 if (PyErr_Occurred()) 818 return -1; 819 return 0; 820} 821 822static int 823array_do_extend(arrayobject *self, PyObject *bb) 824{ 825 Py_ssize_t size; 826 char *old_item; 827 828 if (!array_Check(bb)) 829 return array_iter_extend(self, bb); 830#define b ((arrayobject *)bb) 831 if (self->ob_descr != b->ob_descr) { 832 PyErr_SetString(PyExc_TypeError, 833 "can only extend with array of same kind"); 834 return -1; 835 } 836 if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) || 837 ((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) { 838 PyErr_NoMemory(); 839 return -1; 840 } 841 size = Py_SIZE(self) + Py_SIZE(b); 842 old_item = self->ob_item; 843 PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize); 844 if (self->ob_item == NULL) { 845 self->ob_item = old_item; 846 PyErr_NoMemory(); 847 return -1; 848 } 849 if (Py_SIZE(b) > 0) { 850 memcpy(self->ob_item + Py_SIZE(self)*self->ob_descr->itemsize, 851 b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize); 852 } 853 Py_SIZE(self) = size; 854 self->allocated = size; 855 856 return 0; 857#undef b 858} 859 860static PyObject * 861array_inplace_concat(arrayobject *self, PyObject *bb) 862{ 863 if (!array_Check(bb)) { 864 PyErr_Format(PyExc_TypeError, 865 "can only extend array with array (not \"%.200s\")", 866 Py_TYPE(bb)->tp_name); 867 return NULL; 868 } 869 if (array_do_extend(self, bb) == -1) 870 return NULL; 871 Py_INCREF(self); 872 return (PyObject *)self; 873} 874 875static PyObject * 876array_inplace_repeat(arrayobject *self, Py_ssize_t n) 877{ 878 char *items, *p; 879 Py_ssize_t size, i; 880 881 if (Py_SIZE(self) > 0) { 882 if (n < 0) 883 n = 0; 884 items = self->ob_item; 885 if ((self->ob_descr->itemsize != 0) && 886 (Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) { 887 return PyErr_NoMemory(); 888 } 889 size = Py_SIZE(self) * self->ob_descr->itemsize; 890 if (n == 0) { 891 PyMem_FREE(items); 892 self->ob_item = NULL; 893 Py_SIZE(self) = 0; 894 self->allocated = 0; 895 } 896 else { 897 if (size > PY_SSIZE_T_MAX / n) { 898 return PyErr_NoMemory(); 899 } 900 PyMem_RESIZE(items, char, n * size); 901 if (items == NULL) 902 return PyErr_NoMemory(); 903 p = items; 904 for (i = 1; i < n; i++) { 905 p += size; 906 memcpy(p, items, size); 907 } 908 self->ob_item = items; 909 Py_SIZE(self) *= n; 910 self->allocated = Py_SIZE(self); 911 } 912 } 913 Py_INCREF(self); 914 return (PyObject *)self; 915} 916 917 918static PyObject * 919ins(arrayobject *self, Py_ssize_t where, PyObject *v) 920{ 921 if (ins1(self, where, v) != 0) 922 return NULL; 923 Py_INCREF(Py_None); 924 return Py_None; 925} 926 927static PyObject * 928array_count(arrayobject *self, PyObject *v) 929{ 930 Py_ssize_t count = 0; 931 Py_ssize_t i; 932 933 for (i = 0; i < Py_SIZE(self); i++) { 934 PyObject *selfi = getarrayitem((PyObject *)self, i); 935 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ); 936 Py_DECREF(selfi); 937 if (cmp > 0) 938 count++; 939 else if (cmp < 0) 940 return NULL; 941 } 942 return PyInt_FromSsize_t(count); 943} 944 945PyDoc_STRVAR(count_doc, 946"count(x)\n\ 947\n\ 948Return number of occurrences of x in the array."); 949 950static PyObject * 951array_index(arrayobject *self, PyObject *v) 952{ 953 Py_ssize_t i; 954 955 for (i = 0; i < Py_SIZE(self); i++) { 956 PyObject *selfi = getarrayitem((PyObject *)self, i); 957 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ); 958 Py_DECREF(selfi); 959 if (cmp > 0) { 960 return PyInt_FromLong((long)i); 961 } 962 else if (cmp < 0) 963 return NULL; 964 } 965 PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list"); 966 return NULL; 967} 968 969PyDoc_STRVAR(index_doc, 970"index(x)\n\ 971\n\ 972Return index of first occurrence of x in the array."); 973 974static int 975array_contains(arrayobject *self, PyObject *v) 976{ 977 Py_ssize_t i; 978 int cmp; 979 980 for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) { 981 PyObject *selfi = getarrayitem((PyObject *)self, i); 982 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ); 983 Py_DECREF(selfi); 984 } 985 return cmp; 986} 987 988static PyObject * 989array_remove(arrayobject *self, PyObject *v) 990{ 991 int i; 992 993 for (i = 0; i < Py_SIZE(self); i++) { 994 PyObject *selfi = getarrayitem((PyObject *)self,i); 995 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ); 996 Py_DECREF(selfi); 997 if (cmp > 0) { 998 if (array_ass_slice(self, i, i+1, 999 (PyObject *)NULL) != 0) 1000 return NULL; 1001 Py_INCREF(Py_None); 1002 return Py_None; 1003 } 1004 else if (cmp < 0) 1005 return NULL; 1006 } 1007 PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list"); 1008 return NULL; 1009} 1010 1011PyDoc_STRVAR(remove_doc, 1012"remove(x)\n\ 1013\n\ 1014Remove the first occurrence of x in the array."); 1015 1016static PyObject * 1017array_pop(arrayobject *self, PyObject *args) 1018{ 1019 Py_ssize_t i = -1; 1020 PyObject *v; 1021 if (!PyArg_ParseTuple(args, "|n:pop", &i)) 1022 return NULL; 1023 if (Py_SIZE(self) == 0) { 1024 /* Special-case most common failure cause */ 1025 PyErr_SetString(PyExc_IndexError, "pop from empty array"); 1026 return NULL; 1027 } 1028 if (i < 0) 1029 i += Py_SIZE(self); 1030 if (i < 0 || i >= Py_SIZE(self)) { 1031 PyErr_SetString(PyExc_IndexError, "pop index out of range"); 1032 return NULL; 1033 } 1034 v = getarrayitem((PyObject *)self,i); 1035 if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) { 1036 Py_DECREF(v); 1037 return NULL; 1038 } 1039 return v; 1040} 1041 1042PyDoc_STRVAR(pop_doc, 1043"pop([i])\n\ 1044\n\ 1045Return the i-th element and delete it from the array. i defaults to -1."); 1046 1047static PyObject * 1048array_extend(arrayobject *self, PyObject *bb) 1049{ 1050 if (array_do_extend(self, bb) == -1) 1051 return NULL; 1052 Py_INCREF(Py_None); 1053 return Py_None; 1054} 1055 1056PyDoc_STRVAR(extend_doc, 1057"extend(array or iterable)\n\ 1058\n\ 1059 Append items to the end of the array."); 1060 1061static PyObject * 1062array_insert(arrayobject *self, PyObject *args) 1063{ 1064 Py_ssize_t i; 1065 PyObject *v; 1066 if (!PyArg_ParseTuple(args, "nO:insert", &i, &v)) 1067 return NULL; 1068 return ins(self, i, v); 1069} 1070 1071PyDoc_STRVAR(insert_doc, 1072"insert(i,x)\n\ 1073\n\ 1074Insert a new item x into the array before position i."); 1075 1076 1077static PyObject * 1078array_buffer_info(arrayobject *self, PyObject *unused) 1079{ 1080 PyObject *retval = NULL, *v; 1081 1082 retval = PyTuple_New(2); 1083 if (!retval) 1084 return NULL; 1085 1086 v = PyLong_FromVoidPtr(self->ob_item); 1087 if (v == NULL) { 1088 Py_DECREF(retval); 1089 return NULL; 1090 } 1091 PyTuple_SET_ITEM(retval, 0, v); 1092 1093 v = PyInt_FromSsize_t(Py_SIZE(self)); 1094 if (v == NULL) { 1095 Py_DECREF(retval); 1096 return NULL; 1097 } 1098 PyTuple_SET_ITEM(retval, 1, v); 1099 1100 return retval; 1101} 1102 1103PyDoc_STRVAR(buffer_info_doc, 1104"buffer_info() -> (address, length)\n\ 1105\n\ 1106Return a tuple (address, length) giving the current memory address and\n\ 1107the length in items of the buffer used to hold array's contents\n\ 1108The length should be multiplied by the itemsize attribute to calculate\n\ 1109the buffer length in bytes."); 1110 1111 1112static PyObject * 1113array_append(arrayobject *self, PyObject *v) 1114{ 1115 return ins(self, Py_SIZE(self), v); 1116} 1117 1118PyDoc_STRVAR(append_doc, 1119"append(x)\n\ 1120\n\ 1121Append new value x to the end of the array."); 1122 1123 1124static PyObject * 1125array_byteswap(arrayobject *self, PyObject *unused) 1126{ 1127 char *p; 1128 Py_ssize_t i; 1129 1130 switch (self->ob_descr->itemsize) { 1131 case 1: 1132 break; 1133 case 2: 1134 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) { 1135 char p0 = p[0]; 1136 p[0] = p[1]; 1137 p[1] = p0; 1138 } 1139 break; 1140 case 4: 1141 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) { 1142 char p0 = p[0]; 1143 char p1 = p[1]; 1144 p[0] = p[3]; 1145 p[1] = p[2]; 1146 p[2] = p1; 1147 p[3] = p0; 1148 } 1149 break; 1150 case 8: 1151 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) { 1152 char p0 = p[0]; 1153 char p1 = p[1]; 1154 char p2 = p[2]; 1155 char p3 = p[3]; 1156 p[0] = p[7]; 1157 p[1] = p[6]; 1158 p[2] = p[5]; 1159 p[3] = p[4]; 1160 p[4] = p3; 1161 p[5] = p2; 1162 p[6] = p1; 1163 p[7] = p0; 1164 } 1165 break; 1166 default: 1167 PyErr_SetString(PyExc_RuntimeError, 1168 "don't know how to byteswap this array type"); 1169 return NULL; 1170 } 1171 Py_INCREF(Py_None); 1172 return Py_None; 1173} 1174 1175PyDoc_STRVAR(byteswap_doc, 1176"byteswap()\n\ 1177\n\ 1178Byteswap all items of the array. If the items in the array are not 1, 2,\n\ 11794, or 8 bytes in size, RuntimeError is raised."); 1180 1181static PyObject * 1182array_reverse(arrayobject *self, PyObject *unused) 1183{ 1184 register Py_ssize_t itemsize = self->ob_descr->itemsize; 1185 register char *p, *q; 1186 /* little buffer to hold items while swapping */ 1187 char tmp[256]; /* 8 is probably enough -- but why skimp */ 1188 assert((size_t)itemsize <= sizeof(tmp)); 1189 1190 if (Py_SIZE(self) > 1) { 1191 for (p = self->ob_item, 1192 q = self->ob_item + (Py_SIZE(self) - 1)*itemsize; 1193 p < q; 1194 p += itemsize, q -= itemsize) { 1195 /* memory areas guaranteed disjoint, so memcpy 1196 * is safe (& memmove may be slower). 1197 */ 1198 memcpy(tmp, p, itemsize); 1199 memcpy(p, q, itemsize); 1200 memcpy(q, tmp, itemsize); 1201 } 1202 } 1203 1204 Py_INCREF(Py_None); 1205 return Py_None; 1206} 1207 1208PyDoc_STRVAR(reverse_doc, 1209"reverse()\n\ 1210\n\ 1211Reverse the order of the items in the array."); 1212 1213static PyObject * 1214array_fromfile(arrayobject *self, PyObject *args) 1215{ 1216 PyObject *f; 1217 Py_ssize_t n; 1218 FILE *fp; 1219 if (!PyArg_ParseTuple(args, "On:fromfile", &f, &n)) 1220 return NULL; 1221 fp = PyFile_AsFile(f); 1222 if (fp == NULL) { 1223 PyErr_SetString(PyExc_TypeError, "arg1 must be open file"); 1224 return NULL; 1225 } 1226 if (n > 0) { 1227 char *item = self->ob_item; 1228 Py_ssize_t itemsize = self->ob_descr->itemsize; 1229 size_t nread; 1230 Py_ssize_t newlength; 1231 size_t newbytes; 1232 /* Be careful here about overflow */ 1233 if ((newlength = Py_SIZE(self) + n) <= 0 || 1234 (newbytes = newlength * itemsize) / itemsize != 1235 (size_t)newlength) 1236 goto nomem; 1237 PyMem_RESIZE(item, char, newbytes); 1238 if (item == NULL) { 1239 nomem: 1240 PyErr_NoMemory(); 1241 return NULL; 1242 } 1243 self->ob_item = item; 1244 Py_SIZE(self) += n; 1245 self->allocated = Py_SIZE(self); 1246 nread = fread(item + (Py_SIZE(self) - n) * itemsize, 1247 itemsize, n, fp); 1248 if (nread < (size_t)n) { 1249 Py_SIZE(self) -= (n - nread); 1250 PyMem_RESIZE(item, char, Py_SIZE(self)*itemsize); 1251 self->ob_item = item; 1252 self->allocated = Py_SIZE(self); 1253 if (ferror(fp)) { 1254 PyErr_SetFromErrno(PyExc_IOError); 1255 clearerr(fp); 1256 } 1257 else { 1258 PyErr_SetString(PyExc_EOFError, 1259 "not enough items in file"); 1260 } 1261 return NULL; 1262 } 1263 } 1264 Py_INCREF(Py_None); 1265 return Py_None; 1266} 1267 1268PyDoc_STRVAR(fromfile_doc, 1269"fromfile(f, n)\n\ 1270\n\ 1271Read n objects from the file object f and append them to the end of the\n\ 1272array. Also called as read."); 1273 1274 1275static PyObject * 1276array_fromfile_as_read(arrayobject *self, PyObject *args) 1277{ 1278 if (PyErr_WarnPy3k("array.read() not supported in 3.x; " 1279 "use array.fromfile()", 1) < 0) 1280 return NULL; 1281 return array_fromfile(self, args); 1282} 1283 1284 1285static PyObject * 1286array_tofile(arrayobject *self, PyObject *f) 1287{ 1288 FILE *fp; 1289 1290 fp = PyFile_AsFile(f); 1291 if (fp == NULL) { 1292 PyErr_SetString(PyExc_TypeError, "arg must be open file"); 1293 return NULL; 1294 } 1295 if (self->ob_size > 0) { 1296 if (fwrite(self->ob_item, self->ob_descr->itemsize, 1297 self->ob_size, fp) != (size_t)self->ob_size) { 1298 PyErr_SetFromErrno(PyExc_IOError); 1299 clearerr(fp); 1300 return NULL; 1301 } 1302 } 1303 Py_INCREF(Py_None); 1304 return Py_None; 1305} 1306 1307PyDoc_STRVAR(tofile_doc, 1308"tofile(f)\n\ 1309\n\ 1310Write all items (as machine values) to the file object f. Also called as\n\ 1311write."); 1312 1313 1314static PyObject * 1315array_tofile_as_write(arrayobject *self, PyObject *f) 1316{ 1317 if (PyErr_WarnPy3k("array.write() not supported in 3.x; " 1318 "use array.tofile()", 1) < 0) 1319 return NULL; 1320 return array_tofile(self, f); 1321} 1322 1323 1324static PyObject * 1325array_fromlist(arrayobject *self, PyObject *list) 1326{ 1327 Py_ssize_t n; 1328 Py_ssize_t itemsize = self->ob_descr->itemsize; 1329 1330 if (!PyList_Check(list)) { 1331 PyErr_SetString(PyExc_TypeError, "arg must be list"); 1332 return NULL; 1333 } 1334 n = PyList_Size(list); 1335 if (n > 0) { 1336 char *item = self->ob_item; 1337 Py_ssize_t i; 1338 PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize); 1339 if (item == NULL) { 1340 PyErr_NoMemory(); 1341 return NULL; 1342 } 1343 self->ob_item = item; 1344 Py_SIZE(self) += n; 1345 self->allocated = Py_SIZE(self); 1346 for (i = 0; i < n; i++) { 1347 PyObject *v = PyList_GetItem(list, i); 1348 if ((*self->ob_descr->setitem)(self, 1349 Py_SIZE(self) - n + i, v) != 0) { 1350 Py_SIZE(self) -= n; 1351 if (itemsize && (self->ob_size > PY_SSIZE_T_MAX / itemsize)) { 1352 return PyErr_NoMemory(); 1353 } 1354 PyMem_RESIZE(item, char, 1355 Py_SIZE(self) * itemsize); 1356 self->ob_item = item; 1357 self->allocated = Py_SIZE(self); 1358 return NULL; 1359 } 1360 } 1361 } 1362 Py_INCREF(Py_None); 1363 return Py_None; 1364} 1365 1366PyDoc_STRVAR(fromlist_doc, 1367"fromlist(list)\n\ 1368\n\ 1369Append items to array from list."); 1370 1371 1372static PyObject * 1373array_tolist(arrayobject *self, PyObject *unused) 1374{ 1375 PyObject *list = PyList_New(Py_SIZE(self)); 1376 Py_ssize_t i; 1377 1378 if (list == NULL) 1379 return NULL; 1380 for (i = 0; i < Py_SIZE(self); i++) { 1381 PyObject *v = getarrayitem((PyObject *)self, i); 1382 if (v == NULL) { 1383 Py_DECREF(list); 1384 return NULL; 1385 } 1386 PyList_SetItem(list, i, v); 1387 } 1388 return list; 1389} 1390 1391PyDoc_STRVAR(tolist_doc, 1392"tolist() -> list\n\ 1393\n\ 1394Convert array to an ordinary list with the same items."); 1395 1396 1397static PyObject * 1398array_fromstring(arrayobject *self, PyObject *args) 1399{ 1400 char *str; 1401 Py_ssize_t n; 1402 int itemsize = self->ob_descr->itemsize; 1403 if (!PyArg_ParseTuple(args, "s#:fromstring", &str, &n)) 1404 return NULL; 1405 if (str == self->ob_item) { 1406 PyErr_SetString(PyExc_ValueError, 1407 "array.fromstring(x): x cannot be self"); 1408 return NULL; 1409 } 1410 if (n % itemsize != 0) { 1411 PyErr_SetString(PyExc_ValueError, 1412 "string length not a multiple of item size"); 1413 return NULL; 1414 } 1415 n = n / itemsize; 1416 if (n > 0) { 1417 char *item = self->ob_item; 1418 if ((n > PY_SSIZE_T_MAX - Py_SIZE(self)) || 1419 ((Py_SIZE(self) + n) > PY_SSIZE_T_MAX / itemsize)) { 1420 return PyErr_NoMemory(); 1421 } 1422 PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize); 1423 if (item == NULL) { 1424 PyErr_NoMemory(); 1425 return NULL; 1426 } 1427 self->ob_item = item; 1428 Py_SIZE(self) += n; 1429 self->allocated = Py_SIZE(self); 1430 memcpy(item + (Py_SIZE(self) - n) * itemsize, 1431 str, itemsize*n); 1432 } 1433 Py_INCREF(Py_None); 1434 return Py_None; 1435} 1436 1437PyDoc_STRVAR(fromstring_doc, 1438"fromstring(string)\n\ 1439\n\ 1440Appends items from the string, interpreting it as an array of machine\n\ 1441values,as if it had been read from a file using the fromfile() method)."); 1442 1443 1444static PyObject * 1445array_tostring(arrayobject *self, PyObject *unused) 1446{ 1447 if (self->ob_size <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) { 1448 return PyString_FromStringAndSize(self->ob_item, 1449 Py_SIZE(self) * self->ob_descr->itemsize); 1450 } else { 1451 return PyErr_NoMemory(); 1452 } 1453} 1454 1455PyDoc_STRVAR(tostring_doc, 1456"tostring() -> string\n\ 1457\n\ 1458Convert the array to an array of machine values and return the string\n\ 1459representation."); 1460 1461 1462 1463#ifdef Py_USING_UNICODE 1464static PyObject * 1465array_fromunicode(arrayobject *self, PyObject *args) 1466{ 1467 Py_UNICODE *ustr; 1468 Py_ssize_t n; 1469 1470 if (!PyArg_ParseTuple(args, "u#:fromunicode", &ustr, &n)) 1471 return NULL; 1472 if (self->ob_descr->typecode != 'u') { 1473 PyErr_SetString(PyExc_ValueError, 1474 "fromunicode() may only be called on " 1475 "type 'u' arrays"); 1476 return NULL; 1477 } 1478 if (n > 0) { 1479 Py_UNICODE *item = (Py_UNICODE *) self->ob_item; 1480 if (Py_SIZE(self) > PY_SSIZE_T_MAX - n) { 1481 return PyErr_NoMemory(); 1482 } 1483 PyMem_RESIZE(item, Py_UNICODE, Py_SIZE(self) + n); 1484 if (item == NULL) { 1485 PyErr_NoMemory(); 1486 return NULL; 1487 } 1488 self->ob_item = (char *) item; 1489 Py_SIZE(self) += n; 1490 self->allocated = Py_SIZE(self); 1491 memcpy(item + Py_SIZE(self) - n, 1492 ustr, n * sizeof(Py_UNICODE)); 1493 } 1494 1495 Py_INCREF(Py_None); 1496 return Py_None; 1497} 1498 1499PyDoc_STRVAR(fromunicode_doc, 1500"fromunicode(ustr)\n\ 1501\n\ 1502Extends this array with data from the unicode string ustr.\n\ 1503The array must be a type 'u' array; otherwise a ValueError\n\ 1504is raised. Use array.fromstring(ustr.decode(...)) to\n\ 1505append Unicode data to an array of some other type."); 1506 1507 1508static PyObject * 1509array_tounicode(arrayobject *self, PyObject *unused) 1510{ 1511 if (self->ob_descr->typecode != 'u') { 1512 PyErr_SetString(PyExc_ValueError, 1513 "tounicode() may only be called on type 'u' arrays"); 1514 return NULL; 1515 } 1516 return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self)); 1517} 1518 1519PyDoc_STRVAR(tounicode_doc, 1520"tounicode() -> unicode\n\ 1521\n\ 1522Convert the array to a unicode string. The array must be\n\ 1523a type 'u' array; otherwise a ValueError is raised. Use\n\ 1524array.tostring().decode() to obtain a unicode string from\n\ 1525an array of some other type."); 1526 1527#endif /* Py_USING_UNICODE */ 1528 1529static PyObject * 1530array_reduce(arrayobject *array) 1531{ 1532 PyObject *dict, *result, *list; 1533 1534 dict = PyObject_GetAttrString((PyObject *)array, "__dict__"); 1535 if (dict == NULL) { 1536 if (!PyErr_ExceptionMatches(PyExc_AttributeError)) 1537 return NULL; 1538 PyErr_Clear(); 1539 dict = Py_None; 1540 Py_INCREF(dict); 1541 } 1542 /* Unlike in Python 3.x, we never use the more efficient memory 1543 * representation of an array for pickling. This is unfortunately 1544 * necessary to allow array objects to be unpickled by Python 3.x, 1545 * since str objects from 2.x are always decoded to unicode in 1546 * Python 3.x. 1547 */ 1548 list = array_tolist(array, NULL); 1549 if (list == NULL) { 1550 Py_DECREF(dict); 1551 return NULL; 1552 } 1553 result = Py_BuildValue( 1554 "O(cO)O", Py_TYPE(array), array->ob_descr->typecode, list, dict); 1555 Py_DECREF(list); 1556 Py_DECREF(dict); 1557 return result; 1558} 1559 1560PyDoc_STRVAR(reduce_doc, "Return state information for pickling."); 1561 1562static PyObject * 1563array_sizeof(arrayobject *self, PyObject *unused) 1564{ 1565 Py_ssize_t res; 1566 res = _PyObject_SIZE(Py_TYPE(self)) + self->allocated * self->ob_descr->itemsize; 1567 return PyLong_FromSsize_t(res); 1568} 1569 1570PyDoc_STRVAR(sizeof_doc, 1571"__sizeof__() -> int\n\ 1572\n\ 1573Size of the array in memory, in bytes."); 1574 1575static PyObject * 1576array_get_typecode(arrayobject *a, void *closure) 1577{ 1578 char tc = a->ob_descr->typecode; 1579 return PyString_FromStringAndSize(&tc, 1); 1580} 1581 1582static PyObject * 1583array_get_itemsize(arrayobject *a, void *closure) 1584{ 1585 return PyInt_FromLong((long)a->ob_descr->itemsize); 1586} 1587 1588static PyGetSetDef array_getsets [] = { 1589 {"typecode", (getter) array_get_typecode, NULL, 1590 "the typecode character used to create the array"}, 1591 {"itemsize", (getter) array_get_itemsize, NULL, 1592 "the size, in bytes, of one array item"}, 1593 {NULL} 1594}; 1595 1596static PyMethodDef array_methods[] = { 1597 {"append", (PyCFunction)array_append, METH_O, 1598 append_doc}, 1599 {"buffer_info", (PyCFunction)array_buffer_info, METH_NOARGS, 1600 buffer_info_doc}, 1601 {"byteswap", (PyCFunction)array_byteswap, METH_NOARGS, 1602 byteswap_doc}, 1603 {"__copy__", (PyCFunction)array_copy, METH_NOARGS, 1604 copy_doc}, 1605 {"count", (PyCFunction)array_count, METH_O, 1606 count_doc}, 1607 {"__deepcopy__",(PyCFunction)array_copy, METH_O, 1608 copy_doc}, 1609 {"extend", (PyCFunction)array_extend, METH_O, 1610 extend_doc}, 1611 {"fromfile", (PyCFunction)array_fromfile, METH_VARARGS, 1612 fromfile_doc}, 1613 {"fromlist", (PyCFunction)array_fromlist, METH_O, 1614 fromlist_doc}, 1615 {"fromstring", (PyCFunction)array_fromstring, METH_VARARGS, 1616 fromstring_doc}, 1617#ifdef Py_USING_UNICODE 1618 {"fromunicode", (PyCFunction)array_fromunicode, METH_VARARGS, 1619 fromunicode_doc}, 1620#endif 1621 {"index", (PyCFunction)array_index, METH_O, 1622 index_doc}, 1623 {"insert", (PyCFunction)array_insert, METH_VARARGS, 1624 insert_doc}, 1625 {"pop", (PyCFunction)array_pop, METH_VARARGS, 1626 pop_doc}, 1627 {"read", (PyCFunction)array_fromfile_as_read, METH_VARARGS, 1628 fromfile_doc}, 1629 {"__reduce__", (PyCFunction)array_reduce, METH_NOARGS, 1630 reduce_doc}, 1631 {"remove", (PyCFunction)array_remove, METH_O, 1632 remove_doc}, 1633 {"reverse", (PyCFunction)array_reverse, METH_NOARGS, 1634 reverse_doc}, 1635/* {"sort", (PyCFunction)array_sort, METH_VARARGS, 1636 sort_doc},*/ 1637 {"tofile", (PyCFunction)array_tofile, METH_O, 1638 tofile_doc}, 1639 {"tolist", (PyCFunction)array_tolist, METH_NOARGS, 1640 tolist_doc}, 1641 {"tostring", (PyCFunction)array_tostring, METH_NOARGS, 1642 tostring_doc}, 1643#ifdef Py_USING_UNICODE 1644 {"tounicode", (PyCFunction)array_tounicode, METH_NOARGS, 1645 tounicode_doc}, 1646#endif 1647 {"write", (PyCFunction)array_tofile_as_write, METH_O, 1648 tofile_doc}, 1649 {"__sizeof__", (PyCFunction)array_sizeof, METH_NOARGS, 1650 sizeof_doc}, 1651 {NULL, NULL} /* sentinel */ 1652}; 1653 1654static PyObject * 1655array_repr(arrayobject *a) 1656{ 1657 char buf[256], typecode; 1658 PyObject *s, *t, *v = NULL; 1659 Py_ssize_t len; 1660 1661 len = Py_SIZE(a); 1662 typecode = a->ob_descr->typecode; 1663 if (len == 0) { 1664 PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode); 1665 return PyString_FromString(buf); 1666 } 1667 1668 if (typecode == 'c') 1669 v = array_tostring(a, NULL); 1670#ifdef Py_USING_UNICODE 1671 else if (typecode == 'u') 1672 v = array_tounicode(a, NULL); 1673#endif 1674 else 1675 v = array_tolist(a, NULL); 1676 t = PyObject_Repr(v); 1677 Py_XDECREF(v); 1678 1679 PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode); 1680 s = PyString_FromString(buf); 1681 PyString_ConcatAndDel(&s, t); 1682 PyString_ConcatAndDel(&s, PyString_FromString(")")); 1683 return s; 1684} 1685 1686static PyObject* 1687array_subscr(arrayobject* self, PyObject* item) 1688{ 1689 if (PyIndex_Check(item)) { 1690 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); 1691 if (i==-1 && PyErr_Occurred()) { 1692 return NULL; 1693 } 1694 if (i < 0) 1695 i += Py_SIZE(self); 1696 return array_item(self, i); 1697 } 1698 else if (PySlice_Check(item)) { 1699 Py_ssize_t start, stop, step, slicelength, cur, i; 1700 PyObject* result; 1701 arrayobject* ar; 1702 int itemsize = self->ob_descr->itemsize; 1703 1704 if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self), 1705 &start, &stop, &step, &slicelength) < 0) { 1706 return NULL; 1707 } 1708 1709 if (slicelength <= 0) { 1710 return newarrayobject(&Arraytype, 0, self->ob_descr); 1711 } 1712 else if (step == 1) { 1713 PyObject *result = newarrayobject(&Arraytype, 1714 slicelength, self->ob_descr); 1715 if (result == NULL) 1716 return NULL; 1717 memcpy(((arrayobject *)result)->ob_item, 1718 self->ob_item + start * itemsize, 1719 slicelength * itemsize); 1720 return result; 1721 } 1722 else { 1723 result = newarrayobject(&Arraytype, slicelength, self->ob_descr); 1724 if (!result) return NULL; 1725 1726 ar = (arrayobject*)result; 1727 1728 for (cur = start, i = 0; i < slicelength; 1729 cur += step, i++) { 1730 memcpy(ar->ob_item + i*itemsize, 1731 self->ob_item + cur*itemsize, 1732 itemsize); 1733 } 1734 1735 return result; 1736 } 1737 } 1738 else { 1739 PyErr_SetString(PyExc_TypeError, 1740 "array indices must be integers"); 1741 return NULL; 1742 } 1743} 1744 1745static int 1746array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value) 1747{ 1748 Py_ssize_t start, stop, step, slicelength, needed; 1749 arrayobject* other; 1750 int itemsize; 1751 1752 if (PyIndex_Check(item)) { 1753 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); 1754 1755 if (i == -1 && PyErr_Occurred()) 1756 return -1; 1757 if (i < 0) 1758 i += Py_SIZE(self); 1759 if (i < 0 || i >= Py_SIZE(self)) { 1760 PyErr_SetString(PyExc_IndexError, 1761 "array assignment index out of range"); 1762 return -1; 1763 } 1764 if (value == NULL) { 1765 /* Fall through to slice assignment */ 1766 start = i; 1767 stop = i + 1; 1768 step = 1; 1769 slicelength = 1; 1770 } 1771 else 1772 return (*self->ob_descr->setitem)(self, i, value); 1773 } 1774 else if (PySlice_Check(item)) { 1775 if (PySlice_GetIndicesEx((PySliceObject *)item, 1776 Py_SIZE(self), &start, &stop, 1777 &step, &slicelength) < 0) { 1778 return -1; 1779 } 1780 } 1781 else { 1782 PyErr_SetString(PyExc_TypeError, 1783 "array indices must be integer"); 1784 return -1; 1785 } 1786 if (value == NULL) { 1787 other = NULL; 1788 needed = 0; 1789 } 1790 else if (array_Check(value)) { 1791 other = (arrayobject *)value; 1792 needed = Py_SIZE(other); 1793 if (self == other) { 1794 /* Special case "self[i:j] = self" -- copy self first */ 1795 int ret; 1796 value = array_slice(other, 0, needed); 1797 if (value == NULL) 1798 return -1; 1799 ret = array_ass_subscr(self, item, value); 1800 Py_DECREF(value); 1801 return ret; 1802 } 1803 if (other->ob_descr != self->ob_descr) { 1804 PyErr_BadArgument(); 1805 return -1; 1806 } 1807 } 1808 else { 1809 PyErr_Format(PyExc_TypeError, 1810 "can only assign array (not \"%.200s\") to array slice", 1811 Py_TYPE(value)->tp_name); 1812 return -1; 1813 } 1814 itemsize = self->ob_descr->itemsize; 1815 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */ 1816 if ((step > 0 && stop < start) || 1817 (step < 0 && stop > start)) 1818 stop = start; 1819 if (step == 1) { 1820 if (slicelength > needed) { 1821 memmove(self->ob_item + (start + needed) * itemsize, 1822 self->ob_item + stop * itemsize, 1823 (Py_SIZE(self) - stop) * itemsize); 1824 if (array_resize(self, Py_SIZE(self) + 1825 needed - slicelength) < 0) 1826 return -1; 1827 } 1828 else if (slicelength < needed) { 1829 if (array_resize(self, Py_SIZE(self) + 1830 needed - slicelength) < 0) 1831 return -1; 1832 memmove(self->ob_item + (start + needed) * itemsize, 1833 self->ob_item + stop * itemsize, 1834 (Py_SIZE(self) - start - needed) * itemsize); 1835 } 1836 if (needed > 0) 1837 memcpy(self->ob_item + start * itemsize, 1838 other->ob_item, needed * itemsize); 1839 return 0; 1840 } 1841 else if (needed == 0) { 1842 /* Delete slice */ 1843 size_t cur; 1844 Py_ssize_t i; 1845 1846 if (step < 0) { 1847 stop = start + 1; 1848 start = stop + step * (slicelength - 1) - 1; 1849 step = -step; 1850 } 1851 for (cur = start, i = 0; i < slicelength; 1852 cur += step, i++) { 1853 Py_ssize_t lim = step - 1; 1854 1855 if (cur + step >= (size_t)Py_SIZE(self)) 1856 lim = Py_SIZE(self) - cur - 1; 1857 memmove(self->ob_item + (cur - i) * itemsize, 1858 self->ob_item + (cur + 1) * itemsize, 1859 lim * itemsize); 1860 } 1861 cur = start + slicelength * step; 1862 if (cur < (size_t)Py_SIZE(self)) { 1863 memmove(self->ob_item + (cur-slicelength) * itemsize, 1864 self->ob_item + cur * itemsize, 1865 (Py_SIZE(self) - cur) * itemsize); 1866 } 1867 if (array_resize(self, Py_SIZE(self) - slicelength) < 0) 1868 return -1; 1869 return 0; 1870 } 1871 else { 1872 Py_ssize_t cur, i; 1873 1874 if (needed != slicelength) { 1875 PyErr_Format(PyExc_ValueError, 1876 "attempt to assign array of size %zd " 1877 "to extended slice of size %zd", 1878 needed, slicelength); 1879 return -1; 1880 } 1881 for (cur = start, i = 0; i < slicelength; 1882 cur += step, i++) { 1883 memcpy(self->ob_item + cur * itemsize, 1884 other->ob_item + i * itemsize, 1885 itemsize); 1886 } 1887 return 0; 1888 } 1889} 1890 1891static PyMappingMethods array_as_mapping = { 1892 (lenfunc)array_length, 1893 (binaryfunc)array_subscr, 1894 (objobjargproc)array_ass_subscr 1895}; 1896 1897static const void *emptybuf = ""; 1898 1899static Py_ssize_t 1900array_buffer_getreadbuf(arrayobject *self, Py_ssize_t index, const void **ptr) 1901{ 1902 if ( index != 0 ) { 1903 PyErr_SetString(PyExc_SystemError, 1904 "Accessing non-existent array segment"); 1905 return -1; 1906 } 1907 *ptr = (void *)self->ob_item; 1908 if (*ptr == NULL) 1909 *ptr = emptybuf; 1910 return Py_SIZE(self)*self->ob_descr->itemsize; 1911} 1912 1913static Py_ssize_t 1914array_buffer_getwritebuf(arrayobject *self, Py_ssize_t index, const void **ptr) 1915{ 1916 if ( index != 0 ) { 1917 PyErr_SetString(PyExc_SystemError, 1918 "Accessing non-existent array segment"); 1919 return -1; 1920 } 1921 *ptr = (void *)self->ob_item; 1922 if (*ptr == NULL) 1923 *ptr = emptybuf; 1924 return Py_SIZE(self)*self->ob_descr->itemsize; 1925} 1926 1927static Py_ssize_t 1928array_buffer_getsegcount(arrayobject *self, Py_ssize_t *lenp) 1929{ 1930 if ( lenp ) 1931 *lenp = Py_SIZE(self)*self->ob_descr->itemsize; 1932 return 1; 1933} 1934 1935static PySequenceMethods array_as_sequence = { 1936 (lenfunc)array_length, /*sq_length*/ 1937 (binaryfunc)array_concat, /*sq_concat*/ 1938 (ssizeargfunc)array_repeat, /*sq_repeat*/ 1939 (ssizeargfunc)array_item, /*sq_item*/ 1940 (ssizessizeargfunc)array_slice, /*sq_slice*/ 1941 (ssizeobjargproc)array_ass_item, /*sq_ass_item*/ 1942 (ssizessizeobjargproc)array_ass_slice, /*sq_ass_slice*/ 1943 (objobjproc)array_contains, /*sq_contains*/ 1944 (binaryfunc)array_inplace_concat, /*sq_inplace_concat*/ 1945 (ssizeargfunc)array_inplace_repeat /*sq_inplace_repeat*/ 1946}; 1947 1948static PyBufferProcs array_as_buffer = { 1949 (readbufferproc)array_buffer_getreadbuf, 1950 (writebufferproc)array_buffer_getwritebuf, 1951 (segcountproc)array_buffer_getsegcount, 1952 NULL, 1953}; 1954 1955static PyObject * 1956array_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 1957{ 1958 int c = -1; 1959 PyObject *initial = NULL, *it = NULL, *typecode = NULL; 1960 struct arraydescr *descr; 1961 1962 if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds)) 1963 return NULL; 1964 1965 if (!PyArg_ParseTuple(args, "O|O:array", &typecode, &initial)) 1966 return NULL; 1967 1968 if (PyString_Check(typecode) && PyString_GET_SIZE(typecode) == 1) 1969 c = (unsigned char)*PyString_AS_STRING(typecode); 1970#ifdef Py_USING_UNICODE 1971 else if (PyUnicode_Check(typecode) && PyUnicode_GET_SIZE(typecode) == 1) 1972 c = *PyUnicode_AS_UNICODE(typecode); 1973#endif 1974 else { 1975 PyErr_Format(PyExc_TypeError, 1976 "array() argument 1 or typecode must be char (string or " 1977 "ascii-unicode with length 1), not %s", 1978 Py_TYPE(typecode)->tp_name); 1979 return NULL; 1980 } 1981 1982 if (!(initial == NULL || PyList_Check(initial) 1983 || PyString_Check(initial) || PyTuple_Check(initial) 1984 || (c == 'u' && PyUnicode_Check(initial)))) { 1985 it = PyObject_GetIter(initial); 1986 if (it == NULL) 1987 return NULL; 1988 /* We set initial to NULL so that the subsequent code 1989 will create an empty array of the appropriate type 1990 and afterwards we can use array_iter_extend to populate 1991 the array. 1992 */ 1993 initial = NULL; 1994 } 1995 for (descr = descriptors; descr->typecode != '\0'; descr++) { 1996 if (descr->typecode == c) { 1997 PyObject *a; 1998 Py_ssize_t len; 1999 2000 if (initial == NULL || !(PyList_Check(initial) 2001 || PyTuple_Check(initial))) 2002 len = 0; 2003 else 2004 len = PySequence_Size(initial); 2005 2006 a = newarrayobject(type, len, descr); 2007 if (a == NULL) 2008 return NULL; 2009 2010 if (len > 0) { 2011 Py_ssize_t i; 2012 for (i = 0; i < len; i++) { 2013 PyObject *v = 2014 PySequence_GetItem(initial, i); 2015 if (v == NULL) { 2016 Py_DECREF(a); 2017 return NULL; 2018 } 2019 if (setarrayitem(a, i, v) != 0) { 2020 Py_DECREF(v); 2021 Py_DECREF(a); 2022 return NULL; 2023 } 2024 Py_DECREF(v); 2025 } 2026 } else if (initial != NULL && PyString_Check(initial)) { 2027 PyObject *t_initial, *v; 2028 t_initial = PyTuple_Pack(1, initial); 2029 if (t_initial == NULL) { 2030 Py_DECREF(a); 2031 return NULL; 2032 } 2033 v = array_fromstring((arrayobject *)a, 2034 t_initial); 2035 Py_DECREF(t_initial); 2036 if (v == NULL) { 2037 Py_DECREF(a); 2038 return NULL; 2039 } 2040 Py_DECREF(v); 2041#ifdef Py_USING_UNICODE 2042 } else if (initial != NULL && PyUnicode_Check(initial)) { 2043 Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial); 2044 if (n > 0) { 2045 arrayobject *self = (arrayobject *)a; 2046 char *item = self->ob_item; 2047 item = (char *)PyMem_Realloc(item, n); 2048 if (item == NULL) { 2049 PyErr_NoMemory(); 2050 Py_DECREF(a); 2051 return NULL; 2052 } 2053 self->ob_item = item; 2054 Py_SIZE(self) = n / sizeof(Py_UNICODE); 2055 memcpy(item, PyUnicode_AS_DATA(initial), n); 2056 self->allocated = Py_SIZE(self); 2057 } 2058#endif 2059 } 2060 if (it != NULL) { 2061 if (array_iter_extend((arrayobject *)a, it) == -1) { 2062 Py_DECREF(it); 2063 Py_DECREF(a); 2064 return NULL; 2065 } 2066 Py_DECREF(it); 2067 } 2068 return a; 2069 } 2070 } 2071 PyErr_SetString(PyExc_ValueError, 2072 "bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)"); 2073 return NULL; 2074} 2075 2076 2077PyDoc_STRVAR(module_doc, 2078"This module defines an object type which can efficiently represent\n\ 2079an array of basic values: characters, integers, floating point\n\ 2080numbers. Arrays are sequence types and behave very much like lists,\n\ 2081except that the type of objects stored in them is constrained. The\n\ 2082type is specified at object creation time by using a type code, which\n\ 2083is a single character. The following type codes are defined:\n\ 2084\n\ 2085 Type code C Type Minimum size in bytes \n\ 2086 'c' character 1 \n\ 2087 'b' signed integer 1 \n\ 2088 'B' unsigned integer 1 \n\ 2089 'u' Unicode character 2 \n\ 2090 'h' signed integer 2 \n\ 2091 'H' unsigned integer 2 \n\ 2092 'i' signed integer 2 \n\ 2093 'I' unsigned integer 2 \n\ 2094 'l' signed integer 4 \n\ 2095 'L' unsigned integer 4 \n\ 2096 'f' floating point 4 \n\ 2097 'd' floating point 8 \n\ 2098\n\ 2099The constructor is:\n\ 2100\n\ 2101array(typecode [, initializer]) -- create a new array\n\ 2102"); 2103 2104PyDoc_STRVAR(arraytype_doc, 2105"array(typecode [, initializer]) -> array\n\ 2106\n\ 2107Return a new array whose items are restricted by typecode, and\n\ 2108initialized from the optional initializer value, which must be a list,\n\ 2109string or iterable over elements of the appropriate type.\n\ 2110\n\ 2111Arrays represent basic values and behave very much like lists, except\n\ 2112the type of objects stored in them is constrained.\n\ 2113\n\ 2114Methods:\n\ 2115\n\ 2116append() -- append a new item to the end of the array\n\ 2117buffer_info() -- return information giving the current memory info\n\ 2118byteswap() -- byteswap all the items of the array\n\ 2119count() -- return number of occurrences of an object\n\ 2120extend() -- extend array by appending multiple elements from an iterable\n\ 2121fromfile() -- read items from a file object\n\ 2122fromlist() -- append items from the list\n\ 2123fromstring() -- append items from the string\n\ 2124index() -- return index of first occurrence of an object\n\ 2125insert() -- insert a new item into the array at a provided position\n\ 2126pop() -- remove and return item (default last)\n\ 2127read() -- DEPRECATED, use fromfile()\n\ 2128remove() -- remove first occurrence of an object\n\ 2129reverse() -- reverse the order of the items in the array\n\ 2130tofile() -- write all items to a file object\n\ 2131tolist() -- return the array converted to an ordinary list\n\ 2132tostring() -- return the array converted to a string\n\ 2133write() -- DEPRECATED, use tofile()\n\ 2134\n\ 2135Attributes:\n\ 2136\n\ 2137typecode -- the typecode character used to create the array\n\ 2138itemsize -- the length in bytes of one array item\n\ 2139"); 2140 2141static PyObject *array_iter(arrayobject *ao); 2142 2143static PyTypeObject Arraytype = { 2144 PyVarObject_HEAD_INIT(NULL, 0) 2145 "array.array", 2146 sizeof(arrayobject), 2147 0, 2148 (destructor)array_dealloc, /* tp_dealloc */ 2149 0, /* tp_print */ 2150 0, /* tp_getattr */ 2151 0, /* tp_setattr */ 2152 0, /* tp_compare */ 2153 (reprfunc)array_repr, /* tp_repr */ 2154 0, /* tp_as_number*/ 2155 &array_as_sequence, /* tp_as_sequence*/ 2156 &array_as_mapping, /* tp_as_mapping*/ 2157 0, /* tp_hash */ 2158 0, /* tp_call */ 2159 0, /* tp_str */ 2160 PyObject_GenericGetAttr, /* tp_getattro */ 2161 0, /* tp_setattro */ 2162 &array_as_buffer, /* tp_as_buffer*/ 2163 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ 2164 arraytype_doc, /* tp_doc */ 2165 0, /* tp_traverse */ 2166 0, /* tp_clear */ 2167 array_richcompare, /* tp_richcompare */ 2168 offsetof(arrayobject, weakreflist), /* tp_weaklistoffset */ 2169 (getiterfunc)array_iter, /* tp_iter */ 2170 0, /* tp_iternext */ 2171 array_methods, /* tp_methods */ 2172 0, /* tp_members */ 2173 array_getsets, /* tp_getset */ 2174 0, /* tp_base */ 2175 0, /* tp_dict */ 2176 0, /* tp_descr_get */ 2177 0, /* tp_descr_set */ 2178 0, /* tp_dictoffset */ 2179 0, /* tp_init */ 2180 PyType_GenericAlloc, /* tp_alloc */ 2181 array_new, /* tp_new */ 2182 PyObject_Del, /* tp_free */ 2183}; 2184 2185 2186/*********************** Array Iterator **************************/ 2187 2188typedef struct { 2189 PyObject_HEAD 2190 Py_ssize_t index; 2191 arrayobject *ao; 2192 PyObject * (*getitem)(struct arrayobject *, Py_ssize_t); 2193} arrayiterobject; 2194 2195static PyTypeObject PyArrayIter_Type; 2196 2197#define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type) 2198 2199static PyObject * 2200array_iter(arrayobject *ao) 2201{ 2202 arrayiterobject *it; 2203 2204 if (!array_Check(ao)) { 2205 PyErr_BadInternalCall(); 2206 return NULL; 2207 } 2208 2209 it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type); 2210 if (it == NULL) 2211 return NULL; 2212 2213 Py_INCREF(ao); 2214 it->ao = ao; 2215 it->index = 0; 2216 it->getitem = ao->ob_descr->getitem; 2217 PyObject_GC_Track(it); 2218 return (PyObject *)it; 2219} 2220 2221static PyObject * 2222arrayiter_next(arrayiterobject *it) 2223{ 2224 assert(PyArrayIter_Check(it)); 2225 if (it->index < Py_SIZE(it->ao)) 2226 return (*it->getitem)(it->ao, it->index++); 2227 return NULL; 2228} 2229 2230static void 2231arrayiter_dealloc(arrayiterobject *it) 2232{ 2233 PyObject_GC_UnTrack(it); 2234 Py_XDECREF(it->ao); 2235 PyObject_GC_Del(it); 2236} 2237 2238static int 2239arrayiter_traverse(arrayiterobject *it, visitproc visit, void *arg) 2240{ 2241 Py_VISIT(it->ao); 2242 return 0; 2243} 2244 2245static PyTypeObject PyArrayIter_Type = { 2246 PyVarObject_HEAD_INIT(NULL, 0) 2247 "arrayiterator", /* tp_name */ 2248 sizeof(arrayiterobject), /* tp_basicsize */ 2249 0, /* tp_itemsize */ 2250 /* methods */ 2251 (destructor)arrayiter_dealloc, /* tp_dealloc */ 2252 0, /* tp_print */ 2253 0, /* tp_getattr */ 2254 0, /* tp_setattr */ 2255 0, /* tp_compare */ 2256 0, /* tp_repr */ 2257 0, /* tp_as_number */ 2258 0, /* tp_as_sequence */ 2259 0, /* tp_as_mapping */ 2260 0, /* tp_hash */ 2261 0, /* tp_call */ 2262 0, /* tp_str */ 2263 PyObject_GenericGetAttr, /* tp_getattro */ 2264 0, /* tp_setattro */ 2265 0, /* tp_as_buffer */ 2266 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ 2267 0, /* tp_doc */ 2268 (traverseproc)arrayiter_traverse, /* tp_traverse */ 2269 0, /* tp_clear */ 2270 0, /* tp_richcompare */ 2271 0, /* tp_weaklistoffset */ 2272 PyObject_SelfIter, /* tp_iter */ 2273 (iternextfunc)arrayiter_next, /* tp_iternext */ 2274 0, /* tp_methods */ 2275}; 2276 2277 2278/*********************** Install Module **************************/ 2279 2280/* No functions in array module. */ 2281static PyMethodDef a_methods[] = { 2282 {NULL, NULL, 0, NULL} /* Sentinel */ 2283}; 2284 2285 2286PyMODINIT_FUNC 2287initarray(void) 2288{ 2289 PyObject *m; 2290 2291 Arraytype.ob_type = &PyType_Type; 2292 PyArrayIter_Type.ob_type = &PyType_Type; 2293 m = Py_InitModule3("array", a_methods, module_doc); 2294 if (m == NULL) 2295 return; 2296 2297 Py_INCREF((PyObject *)&Arraytype); 2298 PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype); 2299 Py_INCREF((PyObject *)&Arraytype); 2300 PyModule_AddObject(m, "array", (PyObject *)&Arraytype); 2301 /* No need to check the error here, the caller will do that */ 2302} 2303