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 struct 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 */ 24 struct 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 31 typedef 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 39 static PyTypeObject Arraytype; 40 41 #define array_Check(op) PyObject_TypeCheck(op, &Arraytype) 42 #define array_CheckExact(op) (Py_TYPE(op) == &Arraytype) 43 44 static int 45 array_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 /**************************************************************************** 93 Get and Set functions for each type. 94 A Get function takes an arrayobject* and an integer index, returning the 95 array value at that index wrapped in an appropriate PyObject*. 96 A Set function takes an arrayobject, integer index, and PyObject*; sets 97 the array value at that index to the raw C data extracted from the PyObject*, 98 and returns 0 if successful, else nonzero on failure (PyObject* not of an 99 appropriate type or value). 100 Note that the basic Get and Set functions do NOT check that the index is 101 in bounds; that's the responsibility of the caller. 102 ****************************************************************************/ 103 104 static PyObject * 105 c_getitem(arrayobject *ap, Py_ssize_t i) 106 { 107 return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1); 108 } 109 110 static int 111 c_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 121 static PyObject * 122 b_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 130 static int 131 b_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 154 static PyObject * 155 BB_getitem(arrayobject *ap, Py_ssize_t i) 156 { 157 long x = ((unsigned char *)ap->ob_item)[i]; 158 return PyInt_FromLong(x); 159 } 160 161 static int 162 BB_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 174 static PyObject * 175 u_getitem(arrayobject *ap, Py_ssize_t i) 176 { 177 return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1); 178 } 179 180 static int 181 u_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 199 static PyObject * 200 h_getitem(arrayobject *ap, Py_ssize_t i) 201 { 202 return PyInt_FromLong((long) ((short *)ap->ob_item)[i]); 203 } 204 205 static int 206 h_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 217 static PyObject * 218 HH_getitem(arrayobject *ap, Py_ssize_t i) 219 { 220 return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]); 221 } 222 223 static int 224 HH_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 246 static PyObject * 247 i_getitem(arrayobject *ap, Py_ssize_t i) 248 { 249 return PyInt_FromLong((long) ((int *)ap->ob_item)[i]); 250 } 251 252 static int 253 i_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 264 static PyObject * 265 II_getitem(arrayobject *ap, Py_ssize_t i) 266 { 267 return PyLong_FromUnsignedLong( 268 (unsigned long) ((unsigned int *)ap->ob_item)[i]); 269 } 270 271 static int 272 II_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 303 static PyObject * 304 l_getitem(arrayobject *ap, Py_ssize_t i) 305 { 306 return PyInt_FromLong(((long *)ap->ob_item)[i]); 307 } 308 309 static int 310 l_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 320 static PyObject * 321 LL_getitem(arrayobject *ap, Py_ssize_t i) 322 { 323 return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]); 324 } 325 326 static int 327 LL_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 358 static PyObject * 359 f_getitem(arrayobject *ap, Py_ssize_t i) 360 { 361 return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]); 362 } 363 364 static int 365 f_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 375 static PyObject * 376 d_getitem(arrayobject *ap, Py_ssize_t i) 377 { 378 return PyFloat_FromDouble(((double *)ap->ob_item)[i]); 379 } 380 381 static int 382 d_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 */ 393 static 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 /**************************************************************************** 412 Implementations of array object methods. 413 ****************************************************************************/ 414 415 static PyObject * 416 newarrayobject(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 452 static PyObject * 453 getarrayitem(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 462 static int 463 ins1(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 494 static void 495 array_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 504 static PyObject * 505 array_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 590 static Py_ssize_t 591 array_length(arrayobject *a) 592 { 593 return Py_SIZE(a); 594 } 595 596 static PyObject * 597 array_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 606 static PyObject * 607 array_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 630 static PyObject * 631 array_copy(arrayobject *a, PyObject *unused) 632 { 633 return array_slice(a, 0, Py_SIZE(a)); 634 } 635 636 PyDoc_STRVAR(copy_doc, 637 "copy(array)\n\ 638 \n\ 639 Return a copy of the array."); 640 641 static PyObject * 642 array_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 676 static PyObject * 677 array_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 704 static int 705 array_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 779 static int 780 array_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 792 static int 793 setarrayitem(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 799 static int 800 array_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 822 static int 823 array_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 860 static PyObject * 861 array_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 875 static PyObject * 876 array_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 918 static PyObject * 919 ins(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 927 static PyObject * 928 array_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 945 PyDoc_STRVAR(count_doc, 946 "count(x)\n\ 947 \n\ 948 Return number of occurrences of x in the array."); 949 950 static PyObject * 951 array_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 969 PyDoc_STRVAR(index_doc, 970 "index(x)\n\ 971 \n\ 972 Return index of first occurrence of x in the array."); 973 974 static int 975 array_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 988 static PyObject * 989 array_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 1011 PyDoc_STRVAR(remove_doc, 1012 "remove(x)\n\ 1013 \n\ 1014 Remove the first occurrence of x in the array."); 1015 1016 static PyObject * 1017 array_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 1042 PyDoc_STRVAR(pop_doc, 1043 "pop([i])\n\ 1044 \n\ 1045 Return the i-th element and delete it from the array. i defaults to -1."); 1046 1047 static PyObject * 1048 array_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 1056 PyDoc_STRVAR(extend_doc, 1057 "extend(array or iterable)\n\ 1058 \n\ 1059 Append items to the end of the array."); 1060 1061 static PyObject * 1062 array_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 1071 PyDoc_STRVAR(insert_doc, 1072 "insert(i,x)\n\ 1073 \n\ 1074 Insert a new item x into the array before position i."); 1075 1076 1077 static PyObject * 1078 array_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 1103 PyDoc_STRVAR(buffer_info_doc, 1104 "buffer_info() -> (address, length)\n\ 1105 \n\ 1106 Return a tuple (address, length) giving the current memory address and\n\ 1107 the length in items of the buffer used to hold array's contents\n\ 1108 The length should be multiplied by the itemsize attribute to calculate\n\ 1109 the buffer length in bytes."); 1110 1111 1112 static PyObject * 1113 array_append(arrayobject *self, PyObject *v) 1114 { 1115 return ins(self, Py_SIZE(self), v); 1116 } 1117 1118 PyDoc_STRVAR(append_doc, 1119 "append(x)\n\ 1120 \n\ 1121 Append new value x to the end of the array."); 1122 1123 1124 static PyObject * 1125 array_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 1175 PyDoc_STRVAR(byteswap_doc, 1176 "byteswap()\n\ 1177 \n\ 1178 Byteswap all items of the array. If the items in the array are not 1, 2,\n\ 1179 4, or 8 bytes in size, RuntimeError is raised."); 1180 1181 static PyObject * 1182 array_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 1208 PyDoc_STRVAR(reverse_doc, 1209 "reverse()\n\ 1210 \n\ 1211 Reverse the order of the items in the array."); 1212 1213 static PyObject * 1214 array_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 1268 PyDoc_STRVAR(fromfile_doc, 1269 "fromfile(f, n)\n\ 1270 \n\ 1271 Read n objects from the file object f and append them to the end of the\n\ 1272 array. Also called as read."); 1273 1274 1275 static PyObject * 1276 array_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 1285 static PyObject * 1286 array_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 (Py_SIZE(self) > 0) { 1296 if (fwrite(self->ob_item, self->ob_descr->itemsize, 1297 Py_SIZE(self), fp) != (size_t)Py_SIZE(self)) { 1298 PyErr_SetFromErrno(PyExc_IOError); 1299 clearerr(fp); 1300 return NULL; 1301 } 1302 } 1303 Py_INCREF(Py_None); 1304 return Py_None; 1305 } 1306 1307 PyDoc_STRVAR(tofile_doc, 1308 "tofile(f)\n\ 1309 \n\ 1310 Write all items (as machine values) to the file object f. Also called as\n\ 1311 write."); 1312 1313 1314 static PyObject * 1315 array_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 1324 static PyObject * 1325 array_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 && (Py_SIZE(self) > 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 1366 PyDoc_STRVAR(fromlist_doc, 1367 "fromlist(list)\n\ 1368 \n\ 1369 Append items to array from list."); 1370 1371 1372 static PyObject * 1373 array_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 1391 PyDoc_STRVAR(tolist_doc, 1392 "tolist() -> list\n\ 1393 \n\ 1394 Convert array to an ordinary list with the same items."); 1395 1396 1397 static PyObject * 1398 array_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 1437 PyDoc_STRVAR(fromstring_doc, 1438 "fromstring(string)\n\ 1439 \n\ 1440 Appends items from the string, interpreting it as an array of machine\n\ 1441 values,as if it had been read from a file using the fromfile() method)."); 1442 1443 1444 static PyObject * 1445 array_tostring(arrayobject *self, PyObject *unused) 1446 { 1447 if (Py_SIZE(self) <= 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 1455 PyDoc_STRVAR(tostring_doc, 1456 "tostring() -> string\n\ 1457 \n\ 1458 Convert the array to an array of machine values and return the string\n\ 1459 representation."); 1460 1461 1462 1463 #ifdef Py_USING_UNICODE 1464 static PyObject * 1465 array_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 1499 PyDoc_STRVAR(fromunicode_doc, 1500 "fromunicode(ustr)\n\ 1501 \n\ 1502 Extends this array with data from the unicode string ustr.\n\ 1503 The array must be a type 'u' array; otherwise a ValueError\n\ 1504 is raised. Use array.fromstring(ustr.decode(...)) to\n\ 1505 append Unicode data to an array of some other type."); 1506 1507 1508 static PyObject * 1509 array_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 1519 PyDoc_STRVAR(tounicode_doc, 1520 "tounicode() -> unicode\n\ 1521 \n\ 1522 Convert the array to a unicode string. The array must be\n\ 1523 a type 'u' array; otherwise a ValueError is raised. Use\n\ 1524 array.tostring().decode() to obtain a unicode string from\n\ 1525 an array of some other type."); 1526 1527 #endif /* Py_USING_UNICODE */ 1528 1529 static PyObject * 1530 array_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 1560 PyDoc_STRVAR(reduce_doc, "Return state information for pickling."); 1561 1562 static PyObject * 1563 array_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 1570 PyDoc_STRVAR(sizeof_doc, 1571 "__sizeof__() -> int\n\ 1572 \n\ 1573 Size of the array in memory, in bytes."); 1574 1575 static PyObject * 1576 array_get_typecode(arrayobject *a, void *closure) 1577 { 1578 char tc = a->ob_descr->typecode; 1579 return PyString_FromStringAndSize(&tc, 1); 1580 } 1581 1582 static PyObject * 1583 array_get_itemsize(arrayobject *a, void *closure) 1584 { 1585 return PyInt_FromLong((long)a->ob_descr->itemsize); 1586 } 1587 1588 static 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 1596 static 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 1654 static PyObject * 1655 array_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 1686 static PyObject* 1687 array_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_Unpack(item, &start, &stop, &step) < 0) { 1705 return NULL; 1706 } 1707 slicelength = _PySlice_AdjustIndices(Py_SIZE(self), &start, &stop, 1708 step); 1709 1710 if (slicelength <= 0) { 1711 return newarrayobject(&Arraytype, 0, self->ob_descr); 1712 } 1713 else if (step == 1) { 1714 PyObject *result = newarrayobject(&Arraytype, 1715 slicelength, self->ob_descr); 1716 if (result == NULL) 1717 return NULL; 1718 memcpy(((arrayobject *)result)->ob_item, 1719 self->ob_item + start * itemsize, 1720 slicelength * itemsize); 1721 return result; 1722 } 1723 else { 1724 result = newarrayobject(&Arraytype, slicelength, self->ob_descr); 1725 if (!result) return NULL; 1726 1727 ar = (arrayobject*)result; 1728 1729 for (cur = start, i = 0; i < slicelength; 1730 cur += step, i++) { 1731 memcpy(ar->ob_item + i*itemsize, 1732 self->ob_item + cur*itemsize, 1733 itemsize); 1734 } 1735 1736 return result; 1737 } 1738 } 1739 else { 1740 PyErr_SetString(PyExc_TypeError, 1741 "array indices must be integers"); 1742 return NULL; 1743 } 1744 } 1745 1746 static int 1747 array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value) 1748 { 1749 Py_ssize_t start, stop, step, slicelength, needed; 1750 arrayobject* other; 1751 int itemsize; 1752 1753 if (PyIndex_Check(item)) { 1754 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError); 1755 1756 if (i == -1 && PyErr_Occurred()) 1757 return -1; 1758 if (i < 0) 1759 i += Py_SIZE(self); 1760 if (i < 0 || i >= Py_SIZE(self)) { 1761 PyErr_SetString(PyExc_IndexError, 1762 "array assignment index out of range"); 1763 return -1; 1764 } 1765 if (value == NULL) { 1766 /* Fall through to slice assignment */ 1767 start = i; 1768 stop = i + 1; 1769 step = 1; 1770 slicelength = 1; 1771 } 1772 else 1773 return (*self->ob_descr->setitem)(self, i, value); 1774 } 1775 else if (PySlice_Check(item)) { 1776 if (_PySlice_Unpack(item, &start, &stop, &step) < 0) { 1777 return -1; 1778 } 1779 slicelength = _PySlice_AdjustIndices(Py_SIZE(self), &start, &stop, 1780 step); 1781 } 1782 else { 1783 PyErr_SetString(PyExc_TypeError, 1784 "array indices must be integer"); 1785 return -1; 1786 } 1787 if (value == NULL) { 1788 other = NULL; 1789 needed = 0; 1790 } 1791 else if (array_Check(value)) { 1792 other = (arrayobject *)value; 1793 needed = Py_SIZE(other); 1794 if (self == other) { 1795 /* Special case "self[i:j] = self" -- copy self first */ 1796 int ret; 1797 value = array_slice(other, 0, needed); 1798 if (value == NULL) 1799 return -1; 1800 ret = array_ass_subscr(self, item, value); 1801 Py_DECREF(value); 1802 return ret; 1803 } 1804 if (other->ob_descr != self->ob_descr) { 1805 PyErr_BadArgument(); 1806 return -1; 1807 } 1808 } 1809 else { 1810 PyErr_Format(PyExc_TypeError, 1811 "can only assign array (not \"%.200s\") to array slice", 1812 Py_TYPE(value)->tp_name); 1813 return -1; 1814 } 1815 itemsize = self->ob_descr->itemsize; 1816 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */ 1817 if ((step > 0 && stop < start) || 1818 (step < 0 && stop > start)) 1819 stop = start; 1820 if (step == 1) { 1821 if (slicelength > needed) { 1822 memmove(self->ob_item + (start + needed) * itemsize, 1823 self->ob_item + stop * itemsize, 1824 (Py_SIZE(self) - stop) * itemsize); 1825 if (array_resize(self, Py_SIZE(self) + 1826 needed - slicelength) < 0) 1827 return -1; 1828 } 1829 else if (slicelength < needed) { 1830 if (array_resize(self, Py_SIZE(self) + 1831 needed - slicelength) < 0) 1832 return -1; 1833 memmove(self->ob_item + (start + needed) * itemsize, 1834 self->ob_item + stop * itemsize, 1835 (Py_SIZE(self) - start - needed) * itemsize); 1836 } 1837 if (needed > 0) 1838 memcpy(self->ob_item + start * itemsize, 1839 other->ob_item, needed * itemsize); 1840 return 0; 1841 } 1842 else if (needed == 0) { 1843 /* Delete slice */ 1844 size_t cur; 1845 Py_ssize_t i; 1846 1847 if (step < 0) { 1848 stop = start + 1; 1849 start = stop + step * (slicelength - 1) - 1; 1850 step = -step; 1851 } 1852 for (cur = start, i = 0; i < slicelength; 1853 cur += step, i++) { 1854 Py_ssize_t lim = step - 1; 1855 1856 if (cur + step >= (size_t)Py_SIZE(self)) 1857 lim = Py_SIZE(self) - cur - 1; 1858 memmove(self->ob_item + (cur - i) * itemsize, 1859 self->ob_item + (cur + 1) * itemsize, 1860 lim * itemsize); 1861 } 1862 cur = start + slicelength * step; 1863 if (cur < (size_t)Py_SIZE(self)) { 1864 memmove(self->ob_item + (cur-slicelength) * itemsize, 1865 self->ob_item + cur * itemsize, 1866 (Py_SIZE(self) - cur) * itemsize); 1867 } 1868 if (array_resize(self, Py_SIZE(self) - slicelength) < 0) 1869 return -1; 1870 return 0; 1871 } 1872 else { 1873 Py_ssize_t cur, i; 1874 1875 if (needed != slicelength) { 1876 PyErr_Format(PyExc_ValueError, 1877 "attempt to assign array of size %zd " 1878 "to extended slice of size %zd", 1879 needed, slicelength); 1880 return -1; 1881 } 1882 for (cur = start, i = 0; i < slicelength; 1883 cur += step, i++) { 1884 memcpy(self->ob_item + cur * itemsize, 1885 other->ob_item + i * itemsize, 1886 itemsize); 1887 } 1888 return 0; 1889 } 1890 } 1891 1892 static PyMappingMethods array_as_mapping = { 1893 (lenfunc)array_length, 1894 (binaryfunc)array_subscr, 1895 (objobjargproc)array_ass_subscr 1896 }; 1897 1898 static const void *emptybuf = ""; 1899 1900 static Py_ssize_t 1901 array_buffer_getreadbuf(arrayobject *self, Py_ssize_t index, const void **ptr) 1902 { 1903 if ( index != 0 ) { 1904 PyErr_SetString(PyExc_SystemError, 1905 "Accessing non-existent array segment"); 1906 return -1; 1907 } 1908 *ptr = (void *)self->ob_item; 1909 if (*ptr == NULL) 1910 *ptr = emptybuf; 1911 return Py_SIZE(self)*self->ob_descr->itemsize; 1912 } 1913 1914 static Py_ssize_t 1915 array_buffer_getwritebuf(arrayobject *self, Py_ssize_t index, const void **ptr) 1916 { 1917 if ( index != 0 ) { 1918 PyErr_SetString(PyExc_SystemError, 1919 "Accessing non-existent array segment"); 1920 return -1; 1921 } 1922 *ptr = (void *)self->ob_item; 1923 if (*ptr == NULL) 1924 *ptr = emptybuf; 1925 return Py_SIZE(self)*self->ob_descr->itemsize; 1926 } 1927 1928 static Py_ssize_t 1929 array_buffer_getsegcount(arrayobject *self, Py_ssize_t *lenp) 1930 { 1931 if ( lenp ) 1932 *lenp = Py_SIZE(self)*self->ob_descr->itemsize; 1933 return 1; 1934 } 1935 1936 static PySequenceMethods array_as_sequence = { 1937 (lenfunc)array_length, /*sq_length*/ 1938 (binaryfunc)array_concat, /*sq_concat*/ 1939 (ssizeargfunc)array_repeat, /*sq_repeat*/ 1940 (ssizeargfunc)array_item, /*sq_item*/ 1941 (ssizessizeargfunc)array_slice, /*sq_slice*/ 1942 (ssizeobjargproc)array_ass_item, /*sq_ass_item*/ 1943 (ssizessizeobjargproc)array_ass_slice, /*sq_ass_slice*/ 1944 (objobjproc)array_contains, /*sq_contains*/ 1945 (binaryfunc)array_inplace_concat, /*sq_inplace_concat*/ 1946 (ssizeargfunc)array_inplace_repeat /*sq_inplace_repeat*/ 1947 }; 1948 1949 static PyBufferProcs array_as_buffer = { 1950 (readbufferproc)array_buffer_getreadbuf, 1951 (writebufferproc)array_buffer_getwritebuf, 1952 (segcountproc)array_buffer_getsegcount, 1953 NULL, 1954 }; 1955 1956 static PyObject * 1957 array_new(PyTypeObject *type, PyObject *args, PyObject *kwds) 1958 { 1959 int c = -1; 1960 PyObject *initial = NULL, *it = NULL, *typecode = NULL; 1961 struct arraydescr *descr; 1962 1963 if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds)) 1964 return NULL; 1965 1966 if (!PyArg_ParseTuple(args, "O|O:array", &typecode, &initial)) 1967 return NULL; 1968 1969 if (PyString_Check(typecode) && PyString_GET_SIZE(typecode) == 1) 1970 c = (unsigned char)*PyString_AS_STRING(typecode); 1971 #ifdef Py_USING_UNICODE 1972 else if (PyUnicode_Check(typecode) && PyUnicode_GET_SIZE(typecode) == 1) 1973 c = *PyUnicode_AS_UNICODE(typecode); 1974 #endif 1975 else { 1976 PyErr_Format(PyExc_TypeError, 1977 "array() argument 1 or typecode must be char (string or " 1978 "ascii-unicode with length 1), not %s", 1979 Py_TYPE(typecode)->tp_name); 1980 return NULL; 1981 } 1982 1983 if (!(initial == NULL || PyList_Check(initial) 1984 || PyString_Check(initial) || PyTuple_Check(initial) 1985 || (c == 'u' && PyUnicode_Check(initial)))) { 1986 it = PyObject_GetIter(initial); 1987 if (it == NULL) 1988 return NULL; 1989 /* We set initial to NULL so that the subsequent code 1990 will create an empty array of the appropriate type 1991 and afterwards we can use array_iter_extend to populate 1992 the array. 1993 */ 1994 initial = NULL; 1995 } 1996 for (descr = descriptors; descr->typecode != '\0'; descr++) { 1997 if (descr->typecode == c) { 1998 PyObject *a; 1999 Py_ssize_t len; 2000 2001 if (initial == NULL || !(PyList_Check(initial) 2002 || PyTuple_Check(initial))) 2003 len = 0; 2004 else 2005 len = PySequence_Size(initial); 2006 2007 a = newarrayobject(type, len, descr); 2008 if (a == NULL) 2009 return NULL; 2010 2011 if (len > 0) { 2012 Py_ssize_t i; 2013 for (i = 0; i < len; i++) { 2014 PyObject *v = 2015 PySequence_GetItem(initial, i); 2016 if (v == NULL) { 2017 Py_DECREF(a); 2018 return NULL; 2019 } 2020 if (setarrayitem(a, i, v) != 0) { 2021 Py_DECREF(v); 2022 Py_DECREF(a); 2023 return NULL; 2024 } 2025 Py_DECREF(v); 2026 } 2027 } else if (initial != NULL && PyString_Check(initial)) { 2028 PyObject *t_initial, *v; 2029 t_initial = PyTuple_Pack(1, initial); 2030 if (t_initial == NULL) { 2031 Py_DECREF(a); 2032 return NULL; 2033 } 2034 v = array_fromstring((arrayobject *)a, 2035 t_initial); 2036 Py_DECREF(t_initial); 2037 if (v == NULL) { 2038 Py_DECREF(a); 2039 return NULL; 2040 } 2041 Py_DECREF(v); 2042 #ifdef Py_USING_UNICODE 2043 } else if (initial != NULL && PyUnicode_Check(initial)) { 2044 Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial); 2045 if (n > 0) { 2046 arrayobject *self = (arrayobject *)a; 2047 char *item = self->ob_item; 2048 item = (char *)PyMem_Realloc(item, n); 2049 if (item == NULL) { 2050 PyErr_NoMemory(); 2051 Py_DECREF(a); 2052 return NULL; 2053 } 2054 self->ob_item = item; 2055 Py_SIZE(self) = n / sizeof(Py_UNICODE); 2056 memcpy(item, PyUnicode_AS_DATA(initial), n); 2057 self->allocated = Py_SIZE(self); 2058 } 2059 #endif 2060 } 2061 if (it != NULL) { 2062 if (array_iter_extend((arrayobject *)a, it) == -1) { 2063 Py_DECREF(it); 2064 Py_DECREF(a); 2065 return NULL; 2066 } 2067 Py_DECREF(it); 2068 } 2069 return a; 2070 } 2071 } 2072 PyErr_SetString(PyExc_ValueError, 2073 "bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)"); 2074 return NULL; 2075 } 2076 2077 2078 PyDoc_STRVAR(module_doc, 2079 "This module defines an object type which can efficiently represent\n\ 2080 an array of basic values: characters, integers, floating point\n\ 2081 numbers. Arrays are sequence types and behave very much like lists,\n\ 2082 except that the type of objects stored in them is constrained. The\n\ 2083 type is specified at object creation time by using a type code, which\n\ 2084 is a single character. The following type codes are defined:\n\ 2085 \n\ 2086 Type code C Type Minimum size in bytes \n\ 2087 'c' character 1 \n\ 2088 'b' signed integer 1 \n\ 2089 'B' unsigned integer 1 \n\ 2090 'u' Unicode character 2 \n\ 2091 'h' signed integer 2 \n\ 2092 'H' unsigned integer 2 \n\ 2093 'i' signed integer 2 \n\ 2094 'I' unsigned integer 2 \n\ 2095 'l' signed integer 4 \n\ 2096 'L' unsigned integer 4 \n\ 2097 'f' floating point 4 \n\ 2098 'd' floating point 8 \n\ 2099 \n\ 2100 The constructor is:\n\ 2101 \n\ 2102 array(typecode [, initializer]) -- create a new array\n\ 2103 "); 2104 2105 PyDoc_STRVAR(arraytype_doc, 2106 "array(typecode [, initializer]) -> array\n\ 2107 \n\ 2108 Return a new array whose items are restricted by typecode, and\n\ 2109 initialized from the optional initializer value, which must be a list,\n\ 2110 string or iterable over elements of the appropriate type.\n\ 2111 \n\ 2112 Arrays represent basic values and behave very much like lists, except\n\ 2113 the type of objects stored in them is constrained.\n\ 2114 \n\ 2115 Methods:\n\ 2116 \n\ 2117 append() -- append a new item to the end of the array\n\ 2118 buffer_info() -- return information giving the current memory info\n\ 2119 byteswap() -- byteswap all the items of the array\n\ 2120 count() -- return number of occurrences of an object\n\ 2121 extend() -- extend array by appending multiple elements from an iterable\n\ 2122 fromfile() -- read items from a file object\n\ 2123 fromlist() -- append items from the list\n\ 2124 fromstring() -- append items from the string\n\ 2125 index() -- return index of first occurrence of an object\n\ 2126 insert() -- insert a new item into the array at a provided position\n\ 2127 pop() -- remove and return item (default last)\n\ 2128 read() -- DEPRECATED, use fromfile()\n\ 2129 remove() -- remove first occurrence of an object\n\ 2130 reverse() -- reverse the order of the items in the array\n\ 2131 tofile() -- write all items to a file object\n\ 2132 tolist() -- return the array converted to an ordinary list\n\ 2133 tostring() -- return the array converted to a string\n\ 2134 write() -- DEPRECATED, use tofile()\n\ 2135 \n\ 2136 Attributes:\n\ 2137 \n\ 2138 typecode -- the typecode character used to create the array\n\ 2139 itemsize -- the length in bytes of one array item\n\ 2140 "); 2141 2142 static PyObject *array_iter(arrayobject *ao); 2143 2144 static PyTypeObject Arraytype = { 2145 PyVarObject_HEAD_INIT(NULL, 0) 2146 "array.array", 2147 sizeof(arrayobject), 2148 0, 2149 (destructor)array_dealloc, /* tp_dealloc */ 2150 0, /* tp_print */ 2151 0, /* tp_getattr */ 2152 0, /* tp_setattr */ 2153 0, /* tp_compare */ 2154 (reprfunc)array_repr, /* tp_repr */ 2155 0, /* tp_as_number*/ 2156 &array_as_sequence, /* tp_as_sequence*/ 2157 &array_as_mapping, /* tp_as_mapping*/ 2158 0, /* tp_hash */ 2159 0, /* tp_call */ 2160 0, /* tp_str */ 2161 PyObject_GenericGetAttr, /* tp_getattro */ 2162 0, /* tp_setattro */ 2163 &array_as_buffer, /* tp_as_buffer*/ 2164 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */ 2165 arraytype_doc, /* tp_doc */ 2166 0, /* tp_traverse */ 2167 0, /* tp_clear */ 2168 array_richcompare, /* tp_richcompare */ 2169 offsetof(arrayobject, weakreflist), /* tp_weaklistoffset */ 2170 (getiterfunc)array_iter, /* tp_iter */ 2171 0, /* tp_iternext */ 2172 array_methods, /* tp_methods */ 2173 0, /* tp_members */ 2174 array_getsets, /* tp_getset */ 2175 0, /* tp_base */ 2176 0, /* tp_dict */ 2177 0, /* tp_descr_get */ 2178 0, /* tp_descr_set */ 2179 0, /* tp_dictoffset */ 2180 0, /* tp_init */ 2181 PyType_GenericAlloc, /* tp_alloc */ 2182 array_new, /* tp_new */ 2183 PyObject_Del, /* tp_free */ 2184 }; 2185 2186 2187 /*********************** Array Iterator **************************/ 2188 2189 typedef struct { 2190 PyObject_HEAD 2191 Py_ssize_t index; 2192 arrayobject *ao; 2193 PyObject * (*getitem)(struct arrayobject *, Py_ssize_t); 2194 } arrayiterobject; 2195 2196 static PyTypeObject PyArrayIter_Type; 2197 2198 #define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type) 2199 2200 static PyObject * 2201 array_iter(arrayobject *ao) 2202 { 2203 arrayiterobject *it; 2204 2205 if (!array_Check(ao)) { 2206 PyErr_BadInternalCall(); 2207 return NULL; 2208 } 2209 2210 it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type); 2211 if (it == NULL) 2212 return NULL; 2213 2214 Py_INCREF(ao); 2215 it->ao = ao; 2216 it->index = 0; 2217 it->getitem = ao->ob_descr->getitem; 2218 PyObject_GC_Track(it); 2219 return (PyObject *)it; 2220 } 2221 2222 static PyObject * 2223 arrayiter_next(arrayiterobject *it) 2224 { 2225 assert(PyArrayIter_Check(it)); 2226 if (it->index < Py_SIZE(it->ao)) 2227 return (*it->getitem)(it->ao, it->index++); 2228 return NULL; 2229 } 2230 2231 static void 2232 arrayiter_dealloc(arrayiterobject *it) 2233 { 2234 PyObject_GC_UnTrack(it); 2235 Py_XDECREF(it->ao); 2236 PyObject_GC_Del(it); 2237 } 2238 2239 static int 2240 arrayiter_traverse(arrayiterobject *it, visitproc visit, void *arg) 2241 { 2242 Py_VISIT(it->ao); 2243 return 0; 2244 } 2245 2246 static PyTypeObject PyArrayIter_Type = { 2247 PyVarObject_HEAD_INIT(NULL, 0) 2248 "arrayiterator", /* tp_name */ 2249 sizeof(arrayiterobject), /* tp_basicsize */ 2250 0, /* tp_itemsize */ 2251 /* methods */ 2252 (destructor)arrayiter_dealloc, /* tp_dealloc */ 2253 0, /* tp_print */ 2254 0, /* tp_getattr */ 2255 0, /* tp_setattr */ 2256 0, /* tp_compare */ 2257 0, /* tp_repr */ 2258 0, /* tp_as_number */ 2259 0, /* tp_as_sequence */ 2260 0, /* tp_as_mapping */ 2261 0, /* tp_hash */ 2262 0, /* tp_call */ 2263 0, /* tp_str */ 2264 PyObject_GenericGetAttr, /* tp_getattro */ 2265 0, /* tp_setattro */ 2266 0, /* tp_as_buffer */ 2267 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */ 2268 0, /* tp_doc */ 2269 (traverseproc)arrayiter_traverse, /* tp_traverse */ 2270 0, /* tp_clear */ 2271 0, /* tp_richcompare */ 2272 0, /* tp_weaklistoffset */ 2273 PyObject_SelfIter, /* tp_iter */ 2274 (iternextfunc)arrayiter_next, /* tp_iternext */ 2275 0, /* tp_methods */ 2276 }; 2277 2278 2279 /*********************** Install Module **************************/ 2280 2281 /* No functions in array module. */ 2282 static PyMethodDef a_methods[] = { 2283 {NULL, NULL, 0, NULL} /* Sentinel */ 2284 }; 2285 2286 2287 PyMODINIT_FUNC 2288 initarray(void) 2289 { 2290 PyObject *m; 2291 2292 Py_TYPE(&Arraytype) = &PyType_Type; 2293 Py_TYPE(&PyArrayIter_Type) = &PyType_Type; 2294 m = Py_InitModule3("array", a_methods, module_doc); 2295 if (m == NULL) 2296 return; 2297 2298 Py_INCREF((PyObject *)&Arraytype); 2299 PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype); 2300 Py_INCREF((PyObject *)&Arraytype); 2301 PyModule_AddObject(m, "array", (PyObject *)&Arraytype); 2302 /* No need to check the error here, the caller will do that */ 2303 } 2304