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 (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 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 && (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 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 (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 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_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 1745 static int 1746 array_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 1891 static PyMappingMethods array_as_mapping = { 1892 (lenfunc)array_length, 1893 (binaryfunc)array_subscr, 1894 (objobjargproc)array_ass_subscr 1895 }; 1896 1897 static const void *emptybuf = ""; 1898 1899 static Py_ssize_t 1900 array_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 1913 static Py_ssize_t 1914 array_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 1927 static Py_ssize_t 1928 array_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 1935 static 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 1948 static PyBufferProcs array_as_buffer = { 1949 (readbufferproc)array_buffer_getreadbuf, 1950 (writebufferproc)array_buffer_getwritebuf, 1951 (segcountproc)array_buffer_getsegcount, 1952 NULL, 1953 }; 1954 1955 static PyObject * 1956 array_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 2077 PyDoc_STRVAR(module_doc, 2078 "This module defines an object type which can efficiently represent\n\ 2079 an array of basic values: characters, integers, floating point\n\ 2080 numbers. Arrays are sequence types and behave very much like lists,\n\ 2081 except that the type of objects stored in them is constrained. The\n\ 2082 type is specified at object creation time by using a type code, which\n\ 2083 is 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\ 2099 The constructor is:\n\ 2100 \n\ 2101 array(typecode [, initializer]) -- create a new array\n\ 2102 "); 2103 2104 PyDoc_STRVAR(arraytype_doc, 2105 "array(typecode [, initializer]) -> array\n\ 2106 \n\ 2107 Return a new array whose items are restricted by typecode, and\n\ 2108 initialized from the optional initializer value, which must be a list,\n\ 2109 string or iterable over elements of the appropriate type.\n\ 2110 \n\ 2111 Arrays represent basic values and behave very much like lists, except\n\ 2112 the type of objects stored in them is constrained.\n\ 2113 \n\ 2114 Methods:\n\ 2115 \n\ 2116 append() -- append a new item to the end of the array\n\ 2117 buffer_info() -- return information giving the current memory info\n\ 2118 byteswap() -- byteswap all the items of the array\n\ 2119 count() -- return number of occurrences of an object\n\ 2120 extend() -- extend array by appending multiple elements from an iterable\n\ 2121 fromfile() -- read items from a file object\n\ 2122 fromlist() -- append items from the list\n\ 2123 fromstring() -- append items from the string\n\ 2124 index() -- return index of first occurrence of an object\n\ 2125 insert() -- insert a new item into the array at a provided position\n\ 2126 pop() -- remove and return item (default last)\n\ 2127 read() -- DEPRECATED, use fromfile()\n\ 2128 remove() -- remove first occurrence of an object\n\ 2129 reverse() -- reverse the order of the items in the array\n\ 2130 tofile() -- write all items to a file object\n\ 2131 tolist() -- return the array converted to an ordinary list\n\ 2132 tostring() -- return the array converted to a string\n\ 2133 write() -- DEPRECATED, use tofile()\n\ 2134 \n\ 2135 Attributes:\n\ 2136 \n\ 2137 typecode -- the typecode character used to create the array\n\ 2138 itemsize -- the length in bytes of one array item\n\ 2139 "); 2140 2141 static PyObject *array_iter(arrayobject *ao); 2142 2143 static 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 2188 typedef struct { 2189 PyObject_HEAD 2190 Py_ssize_t index; 2191 arrayobject *ao; 2192 PyObject * (*getitem)(struct arrayobject *, Py_ssize_t); 2193 } arrayiterobject; 2194 2195 static PyTypeObject PyArrayIter_Type; 2196 2197 #define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type) 2198 2199 static PyObject * 2200 array_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 2221 static PyObject * 2222 arrayiter_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 2230 static void 2231 arrayiter_dealloc(arrayiterobject *it) 2232 { 2233 PyObject_GC_UnTrack(it); 2234 Py_XDECREF(it->ao); 2235 PyObject_GC_Del(it); 2236 } 2237 2238 static int 2239 arrayiter_traverse(arrayiterobject *it, visitproc visit, void *arg) 2240 { 2241 Py_VISIT(it->ao); 2242 return 0; 2243 } 2244 2245 static 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. */ 2281 static PyMethodDef a_methods[] = { 2282 {NULL, NULL, 0, NULL} /* Sentinel */ 2283 }; 2284 2285 2286 PyMODINIT_FUNC 2287 initarray(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