?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated with fix for #3126.
[python.git] / Modules / arraymodule.c
blob99d25d38d2f6579a4bbaa85d28efa656ded39df5
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 memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize,
624 (ihigh-ilow) * a->ob_descr->itemsize);
625 return (PyObject *)np;
626 }
627
628 static PyObject *
629 array_copy(arrayobject *a, PyObject *unused)
630 {
631 return array_slice(a, 0, Py_SIZE(a));
632 }
633
634 PyDoc_STRVAR(copy_doc,
635 "copy(array)\n\
636 \n\
637 Return a copy of the array.");
638
639 static PyObject *
640 array_concat(arrayobject *a, PyObject *bb)
641 {
642 Py_ssize_t size;
643 arrayobject *np;
644 if (!array_Check(bb)) {
645 PyErr_Format(PyExc_TypeError,
646 "can only append array (not \"%.200s\") to array",
647 Py_TYPE(bb)->tp_name);
648 return NULL;
649 }
650 #define b ((arrayobject *)bb)
651 if (a->ob_descr != b->ob_descr) {
652 PyErr_BadArgument();
653 return NULL;
654 }
655 if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) {
656 return PyErr_NoMemory();
657 }
658 size = Py_SIZE(a) + Py_SIZE(b);
659 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
660 if (np == NULL) {
661 return NULL;
662 }
663 memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize);
664 memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize,
665 b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
666 return (PyObject *)np;
667 #undef b
668 }
669
670 static PyObject *
671 array_repeat(arrayobject *a, Py_ssize_t n)
672 {
673 Py_ssize_t i;
674 Py_ssize_t size;
675 arrayobject *np;
676 char *p;
677 Py_ssize_t nbytes;
678 if (n < 0)
679 n = 0;
680 if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) {
681 return PyErr_NoMemory();
682 }
683 size = Py_SIZE(a) * n;
684 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
685 if (np == NULL)
686 return NULL;
687 p = np->ob_item;
688 nbytes = Py_SIZE(a) * a->ob_descr->itemsize;
689 for (i = 0; i < n; i++) {
690 memcpy(p, a->ob_item, nbytes);
691 p += nbytes;
692 }
693 return (PyObject *) np;
694 }
695
696 static int
697 array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
698 {
699 char *item;
700 Py_ssize_t n; /* Size of replacement array */
701 Py_ssize_t d; /* Change in size */
702 #define b ((arrayobject *)v)
703 if (v == NULL)
704 n = 0;
705 else if (array_Check(v)) {
706 n = Py_SIZE(b);
707 if (a == b) {
708 /* Special case "a[i:j] = a" -- copy b first */
709 int ret;
710 v = array_slice(b, 0, n);
711 if (!v)
712 return -1;
713 ret = array_ass_slice(a, ilow, ihigh, v);
714 Py_DECREF(v);
715 return ret;
716 }
717 if (b->ob_descr != a->ob_descr) {
718 PyErr_BadArgument();
719 return -1;
720 }
721 }
722 else {
723 PyErr_Format(PyExc_TypeError,
724 "can only assign array (not \"%.200s\") to array slice",
725 Py_TYPE(v)->tp_name);
726 return -1;
727 }
728 if (ilow < 0)
729 ilow = 0;
730 else if (ilow > Py_SIZE(a))
731 ilow = Py_SIZE(a);
732 if (ihigh < 0)
733 ihigh = 0;
734 if (ihigh < ilow)
735 ihigh = ilow;
736 else if (ihigh > Py_SIZE(a))
737 ihigh = Py_SIZE(a);
738 item = a->ob_item;
739 d = n - (ihigh-ilow);
740 if (d < 0) { /* Delete -d items */
741 memmove(item + (ihigh+d)*a->ob_descr->itemsize,
742 item + ihigh*a->ob_descr->itemsize,
743 (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
744 Py_SIZE(a) += d;
745 PyMem_RESIZE(item, char, Py_SIZE(a)*a->ob_descr->itemsize);
746 /* Can't fail */
747 a->ob_item = item;
748 a->allocated = Py_SIZE(a);
749 }
750 else if (d > 0) { /* Insert d items */
751 PyMem_RESIZE(item, char,
752 (Py_SIZE(a) + d)*a->ob_descr->itemsize);
753 if (item == NULL) {
754 PyErr_NoMemory();
755 return -1;
756 }
757 memmove(item + (ihigh+d)*a->ob_descr->itemsize,
758 item + ihigh*a->ob_descr->itemsize,
759 (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
760 a->ob_item = item;
761 Py_SIZE(a) += d;
762 a->allocated = Py_SIZE(a);
763 }
764 if (n > 0)
765 memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
766 n*b->ob_descr->itemsize);
767 return 0;
768 #undef b
769 }
770
771 static int
772 array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v)
773 {
774 if (i < 0 || i >= Py_SIZE(a)) {
775 PyErr_SetString(PyExc_IndexError,
776 "array assignment index out of range");
777 return -1;
778 }
779 if (v == NULL)
780 return array_ass_slice(a, i, i+1, v);
781 return (*a->ob_descr->setitem)(a, i, v);
782 }
783
784 static int
785 setarrayitem(PyObject *a, Py_ssize_t i, PyObject *v)
786 {
787 assert(array_Check(a));
788 return array_ass_item((arrayobject *)a, i, v);
789 }
790
791 static int
792 array_iter_extend(arrayobject *self, PyObject *bb)
793 {
794 PyObject *it, *v;
795
796 it = PyObject_GetIter(bb);
797 if (it == NULL)
798 return -1;
799
800 while ((v = PyIter_Next(it)) != NULL) {
801 if (ins1(self, (int) Py_SIZE(self), v) != 0) {
802 Py_DECREF(v);
803 Py_DECREF(it);
804 return -1;
805 }
806 Py_DECREF(v);
807 }
808 Py_DECREF(it);
809 if (PyErr_Occurred())
810 return -1;
811 return 0;
812 }
813
814 static int
815 array_do_extend(arrayobject *self, PyObject *bb)
816 {
817 Py_ssize_t size;
818
819 if (!array_Check(bb))
820 return array_iter_extend(self, bb);
821 #define b ((arrayobject *)bb)
822 if (self->ob_descr != b->ob_descr) {
823 PyErr_SetString(PyExc_TypeError,
824 "can only extend with array of same kind");
825 return -1;
826 }
827 if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) ||
828 ((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
829 PyErr_NoMemory();
830 return -1;
831 }
832 size = Py_SIZE(self) + Py_SIZE(b);
833 PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
834 if (self->ob_item == NULL) {
835 PyErr_NoMemory();
836 return -1;
837 }
838 memcpy(self->ob_item + Py_SIZE(self)*self->ob_descr->itemsize,
839 b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
840 Py_SIZE(self) = size;
841 self->allocated = size;
842
843 return 0;
844 #undef b
845 }
846
847 static PyObject *
848 array_inplace_concat(arrayobject *self, PyObject *bb)
849 {
850 if (!array_Check(bb)) {
851 PyErr_Format(PyExc_TypeError,
852 "can only extend array with array (not \"%.200s\")",
853 Py_TYPE(bb)->tp_name);
854 return NULL;
855 }
856 if (array_do_extend(self, bb) == -1)
857 return NULL;
858 Py_INCREF(self);
859 return (PyObject *)self;
860 }
861
862 static PyObject *
863 array_inplace_repeat(arrayobject *self, Py_ssize_t n)
864 {
865 char *items, *p;
866 Py_ssize_t size, i;
867
868 if (Py_SIZE(self) > 0) {
869 if (n < 0)
870 n = 0;
871 items = self->ob_item;
872 if ((self->ob_descr->itemsize != 0) &&
873 (Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
874 return PyErr_NoMemory();
875 }
876 size = Py_SIZE(self) * self->ob_descr->itemsize;
877 if (n == 0) {
878 PyMem_FREE(items);
879 self->ob_item = NULL;
880 Py_SIZE(self) = 0;
881 self->allocated = 0;
882 }
883 else {
884 if (size > PY_SSIZE_T_MAX / n) {
885 return PyErr_NoMemory();
886 }
887 PyMem_Resize(items, char, n * size);
888 if (items == NULL)
889 return PyErr_NoMemory();
890 p = items;
891 for (i = 1; i < n; i++) {
892 p += size;
893 memcpy(p, items, size);
894 }
895 self->ob_item = items;
896 Py_SIZE(self) *= n;
897 self->allocated = Py_SIZE(self);
898 }
899 }
900 Py_INCREF(self);
901 return (PyObject *)self;
902 }
903
904
905 static PyObject *
906 ins(arrayobject *self, Py_ssize_t where, PyObject *v)
907 {
908 if (ins1(self, where, v) != 0)
909 return NULL;
910 Py_INCREF(Py_None);
911 return Py_None;
912 }
913
914 static PyObject *
915 array_count(arrayobject *self, PyObject *v)
916 {
917 Py_ssize_t count = 0;
918 Py_ssize_t i;
919
920 for (i = 0; i < Py_SIZE(self); i++) {
921 PyObject *selfi = getarrayitem((PyObject *)self, i);
922 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
923 Py_DECREF(selfi);
924 if (cmp > 0)
925 count++;
926 else if (cmp < 0)
927 return NULL;
928 }
929 return PyInt_FromSsize_t(count);
930 }
931
932 PyDoc_STRVAR(count_doc,
933 "count(x)\n\
934 \n\
935 Return number of occurences of x in the array.");
936
937 static PyObject *
938 array_index(arrayobject *self, PyObject *v)
939 {
940 Py_ssize_t i;
941
942 for (i = 0; i < Py_SIZE(self); i++) {
943 PyObject *selfi = getarrayitem((PyObject *)self, i);
944 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
945 Py_DECREF(selfi);
946 if (cmp > 0) {
947 return PyInt_FromLong((long)i);
948 }
949 else if (cmp < 0)
950 return NULL;
951 }
952 PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list");
953 return NULL;
954 }
955
956 PyDoc_STRVAR(index_doc,
957 "index(x)\n\
958 \n\
959 Return index of first occurence of x in the array.");
960
961 static int
962 array_contains(arrayobject *self, PyObject *v)
963 {
964 Py_ssize_t i;
965 int cmp;
966
967 for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) {
968 PyObject *selfi = getarrayitem((PyObject *)self, i);
969 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
970 Py_DECREF(selfi);
971 }
972 return cmp;
973 }
974
975 static PyObject *
976 array_remove(arrayobject *self, PyObject *v)
977 {
978 int i;
979
980 for (i = 0; i < Py_SIZE(self); i++) {
981 PyObject *selfi = getarrayitem((PyObject *)self,i);
982 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
983 Py_DECREF(selfi);
984 if (cmp > 0) {
985 if (array_ass_slice(self, i, i+1,
986 (PyObject *)NULL) != 0)
987 return NULL;
988 Py_INCREF(Py_None);
989 return Py_None;
990 }
991 else if (cmp < 0)
992 return NULL;
993 }
994 PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list");
995 return NULL;
996 }
997
998 PyDoc_STRVAR(remove_doc,
999 "remove(x)\n\
1000 \n\
1001 Remove the first occurence of x in the array.");
1002
1003 static PyObject *
1004 array_pop(arrayobject *self, PyObject *args)
1005 {
1006 Py_ssize_t i = -1;
1007 PyObject *v;
1008 if (!PyArg_ParseTuple(args, "|n:pop", &i))
1009 return NULL;
1010 if (Py_SIZE(self) == 0) {
1011 /* Special-case most common failure cause */
1012 PyErr_SetString(PyExc_IndexError, "pop from empty array");
1013 return NULL;
1014 }
1015 if (i < 0)
1016 i += Py_SIZE(self);
1017 if (i < 0 || i >= Py_SIZE(self)) {
1018 PyErr_SetString(PyExc_IndexError, "pop index out of range");
1019 return NULL;
1020 }
1021 v = getarrayitem((PyObject *)self,i);
1022 if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) {
1023 Py_DECREF(v);
1024 return NULL;
1025 }
1026 return v;
1027 }
1028
1029 PyDoc_STRVAR(pop_doc,
1030 "pop([i])\n\
1031 \n\
1032 Return the i-th element and delete it from the array. i defaults to -1.");
1033
1034 static PyObject *
1035 array_extend(arrayobject *self, PyObject *bb)
1036 {
1037 if (array_do_extend(self, bb) == -1)
1038 return NULL;
1039 Py_INCREF(Py_None);
1040 return Py_None;
1041 }
1042
1043 PyDoc_STRVAR(extend_doc,
1044 "extend(array or iterable)\n\
1045 \n\
1046 Append items to the end of the array.");
1047
1048 static PyObject *
1049 array_insert(arrayobject *self, PyObject *args)
1050 {
1051 Py_ssize_t i;
1052 PyObject *v;
1053 if (!PyArg_ParseTuple(args, "nO:insert", &i, &v))
1054 return NULL;
1055 return ins(self, i, v);
1056 }
1057
1058 PyDoc_STRVAR(insert_doc,
1059 "insert(i,x)\n\
1060 \n\
1061 Insert a new item x into the array before position i.");
1062
1063
1064 static PyObject *
1065 array_buffer_info(arrayobject *self, PyObject *unused)
1066 {
1067 PyObject* retval = NULL;
1068 retval = PyTuple_New(2);
1069 if (!retval)
1070 return NULL;
1071
1072 PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
1073 PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(Py_SIZE(self))));
1074
1075 return retval;
1076 }
1077
1078 PyDoc_STRVAR(buffer_info_doc,
1079 "buffer_info() -> (address, length)\n\
1080 \n\
1081 Return a tuple (address, length) giving the current memory address and\n\
1082 the length in items of the buffer used to hold array's contents\n\
1083 The length should be multiplied by the itemsize attribute to calculate\n\
1084 the buffer length in bytes.");
1085
1086
1087 static PyObject *
1088 array_append(arrayobject *self, PyObject *v)
1089 {
1090 return ins(self, (int) Py_SIZE(self), v);
1091 }
1092
1093 PyDoc_STRVAR(append_doc,
1094 "append(x)\n\
1095 \n\
1096 Append new value x to the end of the array.");
1097
1098
1099 static PyObject *
1100 array_byteswap(arrayobject *self, PyObject *unused)
1101 {
1102 char *p;
1103 Py_ssize_t i;
1104
1105 switch (self->ob_descr->itemsize) {
1106 case 1:
1107 break;
1108 case 2:
1109 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) {
1110 char p0 = p[0];
1111 p[0] = p[1];
1112 p[1] = p0;
1113 }
1114 break;
1115 case 4:
1116 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) {
1117 char p0 = p[0];
1118 char p1 = p[1];
1119 p[0] = p[3];
1120 p[1] = p[2];
1121 p[2] = p1;
1122 p[3] = p0;
1123 }
1124 break;
1125 case 8:
1126 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) {
1127 char p0 = p[0];
1128 char p1 = p[1];
1129 char p2 = p[2];
1130 char p3 = p[3];
1131 p[0] = p[7];
1132 p[1] = p[6];
1133 p[2] = p[5];
1134 p[3] = p[4];
1135 p[4] = p3;
1136 p[5] = p2;
1137 p[6] = p1;
1138 p[7] = p0;
1139 }
1140 break;
1141 default:
1142 PyErr_SetString(PyExc_RuntimeError,
1143 "don't know how to byteswap this array type");
1144 return NULL;
1145 }
1146 Py_INCREF(Py_None);
1147 return Py_None;
1148 }
1149
1150 PyDoc_STRVAR(byteswap_doc,
1151 "byteswap()\n\
1152 \n\
1153 Byteswap all items of the array. If the items in the array are not 1, 2,\n\
1154 4, or 8 bytes in size, RuntimeError is raised.");
1155
1156 static PyObject *
1157 array_reduce(arrayobject *array)
1158 {
1159 PyObject *dict, *result;
1160
1161 dict = PyObject_GetAttrString((PyObject *)array, "__dict__");
1162 if (dict == NULL) {
1163 PyErr_Clear();
1164 dict = Py_None;
1165 Py_INCREF(dict);
1166 }
1167 if (Py_SIZE(array) > 0) {
1168 if (array->ob_descr->itemsize
1169 > PY_SSIZE_T_MAX / array->ob_size) {
1170 return PyErr_NoMemory();
1171 }
1172 result = Py_BuildValue("O(cs#)O",
1173 Py_TYPE(array),
1174 array->ob_descr->typecode,
1175 array->ob_item,
1176 Py_SIZE(array) * array->ob_descr->itemsize,
1177 dict);
1178 } else {
1179 result = Py_BuildValue("O(c)O",
1180 Py_TYPE(array),
1181 array->ob_descr->typecode,
1182 dict);
1183 }
1184 Py_DECREF(dict);
1185 return result;
1186 }
1187
1188 PyDoc_STRVAR(array_doc, "Return state information for pickling.");
1189
1190 static PyObject *
1191 array_reverse(arrayobject *self, PyObject *unused)
1192 {
1193 register Py_ssize_t itemsize = self->ob_descr->itemsize;
1194 register char *p, *q;
1195 /* little buffer to hold items while swapping */
1196 char tmp[256]; /* 8 is probably enough -- but why skimp */
1197 assert((size_t)itemsize <= sizeof(tmp));
1198
1199 if (Py_SIZE(self) > 1) {
1200 for (p = self->ob_item,
1201 q = self->ob_item + (Py_SIZE(self) - 1)*itemsize;
1202 p < q;
1203 p += itemsize, q -= itemsize) {
1204 /* memory areas guaranteed disjoint, so memcpy
1205 * is safe (& memmove may be slower).
1206 */
1207 memcpy(tmp, p, itemsize);
1208 memcpy(p, q, itemsize);
1209 memcpy(q, tmp, itemsize);
1210 }
1211 }
1212
1213 Py_INCREF(Py_None);
1214 return Py_None;
1215 }
1216
1217 PyDoc_STRVAR(reverse_doc,
1218 "reverse()\n\
1219 \n\
1220 Reverse the order of the items in the array.");
1221
1222 static PyObject *
1223 array_fromfile(arrayobject *self, PyObject *args)
1224 {
1225 PyObject *f;
1226 Py_ssize_t n;
1227 FILE *fp;
1228 if (!PyArg_ParseTuple(args, "On:fromfile", &f, &n))
1229 return NULL;
1230 fp = PyFile_AsFile(f);
1231 if (fp == NULL) {
1232 PyErr_SetString(PyExc_TypeError, "arg1 must be open file");
1233 return NULL;
1234 }
1235 if (n > 0) {
1236 char *item = self->ob_item;
1237 Py_ssize_t itemsize = self->ob_descr->itemsize;
1238 size_t nread;
1239 Py_ssize_t newlength;
1240 size_t newbytes;
1241 /* Be careful here about overflow */
1242 if ((newlength = Py_SIZE(self) + n) <= 0 ||
1243 (newbytes = newlength * itemsize) / itemsize !=
1244 (size_t)newlength)
1245 goto nomem;
1246 PyMem_RESIZE(item, char, newbytes);
1247 if (item == NULL) {
1248 nomem:
1249 PyErr_NoMemory();
1250 return NULL;
1251 }
1252 self->ob_item = item;
1253 Py_SIZE(self) += n;
1254 self->allocated = Py_SIZE(self);
1255 nread = fread(item + (Py_SIZE(self) - n) * itemsize,
1256 itemsize, n, fp);
1257 if (nread < (size_t)n) {
1258 Py_SIZE(self) -= (n - nread);
1259 PyMem_RESIZE(item, char, Py_SIZE(self)*itemsize);
1260 self->ob_item = item;
1261 self->allocated = Py_SIZE(self);
1262 PyErr_SetString(PyExc_EOFError,
1263 "not enough items in file");
1264 return NULL;
1265 }
1266 }
1267 Py_INCREF(Py_None);
1268 return Py_None;
1269 }
1270
1271 PyDoc_STRVAR(fromfile_doc,
1272 "fromfile(f, n)\n\
1273 \n\
1274 Read n objects from the file object f and append them to the end of the\n\
1275 array. Also called as read.");
1276
1277
1278 static PyObject *
1279 array_fromfile_as_read(arrayobject *self, PyObject *args)
1280 {
1281 if (PyErr_WarnPy3k("array.read() not supported in 3.x; "
1282 "use array.fromfile()", 1) < 0)
1283 return NULL;
1284 return array_fromfile(self, args);
1285 }
1286
1287
1288 static PyObject *
1289 array_tofile(arrayobject *self, PyObject *f)
1290 {
1291 FILE *fp;
1292
1293 fp = PyFile_AsFile(f);
1294 if (fp == NULL) {
1295 PyErr_SetString(PyExc_TypeError, "arg must be open file");
1296 return NULL;
1297 }
1298 if (self->ob_size > 0) {
1299 if (fwrite(self->ob_item, self->ob_descr->itemsize,
1300 self->ob_size, fp) != (size_t)self->ob_size) {
1301 PyErr_SetFromErrno(PyExc_IOError);
1302 clearerr(fp);
1303 return NULL;
1304 }
1305 }
1306 Py_INCREF(Py_None);
1307 return Py_None;
1308 }
1309
1310 PyDoc_STRVAR(tofile_doc,
1311 "tofile(f)\n\
1312 \n\
1313 Write all items (as machine values) to the file object f. Also called as\n\
1314 write.");
1315
1316
1317 static PyObject *
1318 array_tofile_as_write(arrayobject *self, PyObject *f)
1319 {
1320 if (PyErr_WarnPy3k("array.write() not supported in 3.x; "
1321 "use array.tofile()", 1) < 0)
1322 return NULL;
1323 return array_tofile(self, f);
1324 }
1325
1326
1327 static PyObject *
1328 array_fromlist(arrayobject *self, PyObject *list)
1329 {
1330 Py_ssize_t n;
1331 Py_ssize_t itemsize = self->ob_descr->itemsize;
1332
1333 if (!PyList_Check(list)) {
1334 PyErr_SetString(PyExc_TypeError, "arg must be list");
1335 return NULL;
1336 }
1337 n = PyList_Size(list);
1338 if (n > 0) {
1339 char *item = self->ob_item;
1340 Py_ssize_t i;
1341 PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
1342 if (item == NULL) {
1343 PyErr_NoMemory();
1344 return NULL;
1345 }
1346 self->ob_item = item;
1347 Py_SIZE(self) += n;
1348 self->allocated = Py_SIZE(self);
1349 for (i = 0; i < n; i++) {
1350 PyObject *v = PyList_GetItem(list, i);
1351 if ((*self->ob_descr->setitem)(self,
1352 Py_SIZE(self) - n + i, v) != 0) {
1353 Py_SIZE(self) -= n;
1354 if (itemsize && (self->ob_size > PY_SSIZE_T_MAX / itemsize)) {
1355 return PyErr_NoMemory();
1356 }
1357 PyMem_RESIZE(item, char,
1358 Py_SIZE(self) * itemsize);
1359 self->ob_item = item;
1360 self->allocated = Py_SIZE(self);
1361 return NULL;
1362 }
1363 }
1364 }
1365 Py_INCREF(Py_None);
1366 return Py_None;
1367 }
1368
1369 PyDoc_STRVAR(fromlist_doc,
1370 "fromlist(list)\n\
1371 \n\
1372 Append items to array from list.");
1373
1374
1375 static PyObject *
1376 array_tolist(arrayobject *self, PyObject *unused)
1377 {
1378 PyObject *list = PyList_New(Py_SIZE(self));
1379 Py_ssize_t i;
1380
1381 if (list == NULL)
1382 return NULL;
1383 for (i = 0; i < Py_SIZE(self); i++) {
1384 PyObject *v = getarrayitem((PyObject *)self, i);
1385 if (v == NULL) {
1386 Py_DECREF(list);
1387 return NULL;
1388 }
1389 PyList_SetItem(list, i, v);
1390 }
1391 return list;
1392 }
1393
1394 PyDoc_STRVAR(tolist_doc,
1395 "tolist() -> list\n\
1396 \n\
1397 Convert array to an ordinary list with the same items.");
1398
1399
1400 static PyObject *
1401 array_fromstring(arrayobject *self, PyObject *args)
1402 {
1403 char *str;
1404 Py_ssize_t n;
1405 int itemsize = self->ob_descr->itemsize;
1406 if (!PyArg_ParseTuple(args, "s#:fromstring", &str, &n))
1407 return NULL;
1408 if (n % itemsize != 0) {
1409 PyErr_SetString(PyExc_ValueError,
1410 "string length not a multiple of item size");
1411 return NULL;
1412 }
1413 n = n / itemsize;
1414 if (n > 0) {
1415 char *item = self->ob_item;
1416 if ((n > PY_SSIZE_T_MAX - Py_SIZE(self)) ||
1417 ((Py_SIZE(self) + n) > PY_SSIZE_T_MAX / itemsize)) {
1418 return PyErr_NoMemory();
1419 }
1420 PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
1421 if (item == NULL) {
1422 PyErr_NoMemory();
1423 return NULL;
1424 }
1425 self->ob_item = item;
1426 Py_SIZE(self) += n;
1427 self->allocated = Py_SIZE(self);
1428 memcpy(item + (Py_SIZE(self) - n) * itemsize,
1429 str, itemsize*n);
1430 }
1431 Py_INCREF(Py_None);
1432 return Py_None;
1433 }
1434
1435 PyDoc_STRVAR(fromstring_doc,
1436 "fromstring(string)\n\
1437 \n\
1438 Appends items from the string, interpreting it as an array of machine\n\
1439 values,as if it had been read from a file using the fromfile() method).");
1440
1441
1442 static PyObject *
1443 array_tostring(arrayobject *self, PyObject *unused)
1444 {
1445 if (self->ob_size <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) {
1446 return PyString_FromStringAndSize(self->ob_item,
1447 Py_SIZE(self) * self->ob_descr->itemsize);
1448 } else {
1449 return PyErr_NoMemory();
1450 }
1451 }
1452
1453 PyDoc_STRVAR(tostring_doc,
1454 "tostring() -> string\n\
1455 \n\
1456 Convert the array to an array of machine values and return the string\n\
1457 representation.");
1458
1459
1460
1461 #ifdef Py_USING_UNICODE
1462 static PyObject *
1463 array_fromunicode(arrayobject *self, PyObject *args)
1464 {
1465 Py_UNICODE *ustr;
1466 Py_ssize_t n;
1467
1468 if (!PyArg_ParseTuple(args, "u#:fromunicode", &ustr, &n))
1469 return NULL;
1470 if (self->ob_descr->typecode != 'u') {
1471 PyErr_SetString(PyExc_ValueError,
1472 "fromunicode() may only be called on "
1473 "type 'u' arrays");
1474 return NULL;
1475 }
1476 if (n > 0) {
1477 Py_UNICODE *item = (Py_UNICODE *) self->ob_item;
1478 if (Py_SIZE(self) > PY_SSIZE_T_MAX - n) {
1479 return PyErr_NoMemory();
1480 }
1481 PyMem_RESIZE(item, Py_UNICODE, Py_SIZE(self) + n);
1482 if (item == NULL) {
1483 PyErr_NoMemory();
1484 return NULL;
1485 }
1486 self->ob_item = (char *) item;
1487 Py_SIZE(self) += n;
1488 self->allocated = Py_SIZE(self);
1489 memcpy(item + Py_SIZE(self) - n,
1490 ustr, n * sizeof(Py_UNICODE));
1491 }
1492
1493 Py_INCREF(Py_None);
1494 return Py_None;
1495 }
1496
1497 PyDoc_STRVAR(fromunicode_doc,
1498 "fromunicode(ustr)\n\
1499 \n\
1500 Extends this array with data from the unicode string ustr.\n\
1501 The array must be a type 'u' array; otherwise a ValueError\n\
1502 is raised. Use array.fromstring(ustr.decode(...)) to\n\
1503 append Unicode data to an array of some other type.");
1504
1505
1506 static PyObject *
1507 array_tounicode(arrayobject *self, PyObject *unused)
1508 {
1509 if (self->ob_descr->typecode != 'u') {
1510 PyErr_SetString(PyExc_ValueError,
1511 "tounicode() may only be called on type 'u' arrays");
1512 return NULL;
1513 }
1514 return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self));
1515 }
1516
1517 PyDoc_STRVAR(tounicode_doc,
1518 "tounicode() -> unicode\n\
1519 \n\
1520 Convert the array to a unicode string. The array must be\n\
1521 a type 'u' array; otherwise a ValueError is raised. Use\n\
1522 array.tostring().decode() to obtain a unicode string from\n\
1523 an array of some other type.");
1524
1525 #endif /* Py_USING_UNICODE */
1526
1527
1528 static PyObject *
1529 array_get_typecode(arrayobject *a, void *closure)
1530 {
1531 char tc = a->ob_descr->typecode;
1532 return PyString_FromStringAndSize(&tc, 1);
1533 }
1534
1535 static PyObject *
1536 array_get_itemsize(arrayobject *a, void *closure)
1537 {
1538 return PyInt_FromLong((long)a->ob_descr->itemsize);
1539 }
1540
1541 static PyGetSetDef array_getsets [] = {
1542 {"typecode", (getter) array_get_typecode, NULL,
1543 "the typecode character used to create the array"},
1544 {"itemsize", (getter) array_get_itemsize, NULL,
1545 "the size, in bytes, of one array item"},
1546 {NULL}
1547 };
1548
1549 static PyMethodDef array_methods[] = {
1550 {"append", (PyCFunction)array_append, METH_O,
1551 append_doc},
1552 {"buffer_info", (PyCFunction)array_buffer_info, METH_NOARGS,
1553 buffer_info_doc},
1554 {"byteswap", (PyCFunction)array_byteswap, METH_NOARGS,
1555 byteswap_doc},
1556 {"__copy__", (PyCFunction)array_copy, METH_NOARGS,
1557 copy_doc},
1558 {"count", (PyCFunction)array_count, METH_O,
1559 count_doc},
1560 {"__deepcopy__",(PyCFunction)array_copy, METH_O,
1561 copy_doc},
1562 {"extend", (PyCFunction)array_extend, METH_O,
1563 extend_doc},
1564 {"fromfile", (PyCFunction)array_fromfile, METH_VARARGS,
1565 fromfile_doc},
1566 {"fromlist", (PyCFunction)array_fromlist, METH_O,
1567 fromlist_doc},
1568 {"fromstring", (PyCFunction)array_fromstring, METH_VARARGS,
1569 fromstring_doc},
1570 #ifdef Py_USING_UNICODE
1571 {"fromunicode", (PyCFunction)array_fromunicode, METH_VARARGS,
1572 fromunicode_doc},
1573 #endif
1574 {"index", (PyCFunction)array_index, METH_O,
1575 index_doc},
1576 {"insert", (PyCFunction)array_insert, METH_VARARGS,
1577 insert_doc},
1578 {"pop", (PyCFunction)array_pop, METH_VARARGS,
1579 pop_doc},
1580 {"read", (PyCFunction)array_fromfile_as_read, METH_VARARGS,
1581 fromfile_doc},
1582 {"__reduce__", (PyCFunction)array_reduce, METH_NOARGS,
1583 array_doc},
1584 {"remove", (PyCFunction)array_remove, METH_O,
1585 remove_doc},
1586 {"reverse", (PyCFunction)array_reverse, METH_NOARGS,
1587 reverse_doc},
1588 /* {"sort", (PyCFunction)array_sort, METH_VARARGS,
1589 sort_doc},*/
1590 {"tofile", (PyCFunction)array_tofile, METH_O,
1591 tofile_doc},
1592 {"tolist", (PyCFunction)array_tolist, METH_NOARGS,
1593 tolist_doc},
1594 {"tostring", (PyCFunction)array_tostring, METH_NOARGS,
1595 tostring_doc},
1596 #ifdef Py_USING_UNICODE
1597 {"tounicode", (PyCFunction)array_tounicode, METH_NOARGS,
1598 tounicode_doc},
1599 #endif
1600 {"write", (PyCFunction)array_tofile_as_write, METH_O,
1601 tofile_doc},
1602 {NULL, NULL} /* sentinel */
1603 };
1604
1605 static PyObject *
1606 array_repr(arrayobject *a)
1607 {
1608 char buf[256], typecode;
1609 PyObject *s, *t, *v = NULL;
1610 Py_ssize_t len;
1611
1612 len = Py_SIZE(a);
1613 typecode = a->ob_descr->typecode;
1614 if (len == 0) {
1615 PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
1616 return PyString_FromString(buf);
1617 }
1618
1619 if (typecode == 'c')
1620 v = array_tostring(a, NULL);
1621 #ifdef Py_USING_UNICODE
1622 else if (typecode == 'u')
1623 v = array_tounicode(a, NULL);
1624 #endif
1625 else
1626 v = array_tolist(a, NULL);
1627 t = PyObject_Repr(v);
1628 Py_XDECREF(v);
1629
1630 PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode);
1631 s = PyString_FromString(buf);
1632 PyString_ConcatAndDel(&s, t);
1633 PyString_ConcatAndDel(&s, PyString_FromString(")"));
1634 return s;
1635 }
1636
1637 static PyObject*
1638 array_subscr(arrayobject* self, PyObject* item)
1639 {
1640 if (PyIndex_Check(item)) {
1641 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1642 if (i==-1 && PyErr_Occurred()) {
1643 return NULL;
1644 }
1645 if (i < 0)
1646 i += Py_SIZE(self);
1647 return array_item(self, i);
1648 }
1649 else if (PySlice_Check(item)) {
1650 Py_ssize_t start, stop, step, slicelength, cur, i;
1651 PyObject* result;
1652 arrayobject* ar;
1653 int itemsize = self->ob_descr->itemsize;
1654
1655 if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
1656 &start, &stop, &step, &slicelength) < 0) {
1657 return NULL;
1658 }
1659
1660 if (slicelength <= 0) {
1661 return newarrayobject(&Arraytype, 0, self->ob_descr);
1662 }
1663 else if (step == 1) {
1664 PyObject *result = newarrayobject(&Arraytype,
1665 slicelength, self->ob_descr);
1666 if (result == NULL)
1667 return NULL;
1668 memcpy(((arrayobject *)result)->ob_item,
1669 self->ob_item + start * itemsize,
1670 slicelength * itemsize);
1671 return result;
1672 }
1673 else {
1674 result = newarrayobject(&Arraytype, slicelength, self->ob_descr);
1675 if (!result) return NULL;
1676
1677 ar = (arrayobject*)result;
1678
1679 for (cur = start, i = 0; i < slicelength;
1680 cur += step, i++) {
1681 memcpy(ar->ob_item + i*itemsize,
1682 self->ob_item + cur*itemsize,
1683 itemsize);
1684 }
1685
1686 return result;
1687 }
1688 }
1689 else {
1690 PyErr_SetString(PyExc_TypeError,
1691 "array indices must be integers");
1692 return NULL;
1693 }
1694 }
1695
1696 static int
1697 array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
1698 {
1699 Py_ssize_t start, stop, step, slicelength, needed;
1700 arrayobject* other;
1701 int itemsize;
1702
1703 if (PyIndex_Check(item)) {
1704 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1705
1706 if (i == -1 && PyErr_Occurred())
1707 return -1;
1708 if (i < 0)
1709 i += Py_SIZE(self);
1710 if (i < 0 || i >= Py_SIZE(self)) {
1711 PyErr_SetString(PyExc_IndexError,
1712 "array assignment index out of range");
1713 return -1;
1714 }
1715 if (value == NULL) {
1716 /* Fall through to slice assignment */
1717 start = i;
1718 stop = i + 1;
1719 step = 1;
1720 slicelength = 1;
1721 }
1722 else
1723 return (*self->ob_descr->setitem)(self, i, value);
1724 }
1725 else if (PySlice_Check(item)) {
1726 if (PySlice_GetIndicesEx((PySliceObject *)item,
1727 Py_SIZE(self), &start, &stop,
1728 &step, &slicelength) < 0) {
1729 return -1;
1730 }
1731 }
1732 else {
1733 PyErr_SetString(PyExc_TypeError,
1734 "array indices must be integer");
1735 return -1;
1736 }
1737 if (value == NULL) {
1738 other = NULL;
1739 needed = 0;
1740 }
1741 else if (array_Check(value)) {
1742 other = (arrayobject *)value;
1743 needed = Py_SIZE(other);
1744 if (self == other) {
1745 /* Special case "self[i:j] = self" -- copy self first */
1746 int ret;
1747 value = array_slice(other, 0, needed);
1748 if (value == NULL)
1749 return -1;
1750 ret = array_ass_subscr(self, item, value);
1751 Py_DECREF(value);
1752 return ret;
1753 }
1754 if (other->ob_descr != self->ob_descr) {
1755 PyErr_BadArgument();
1756 return -1;
1757 }
1758 }
1759 else {
1760 PyErr_Format(PyExc_TypeError,
1761 "can only assign array (not \"%.200s\") to array slice",
1762 Py_TYPE(value)->tp_name);
1763 return -1;
1764 }
1765 itemsize = self->ob_descr->itemsize;
1766 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
1767 if ((step > 0 && stop < start) ||
1768 (step < 0 && stop > start))
1769 stop = start;
1770 if (step == 1) {
1771 if (slicelength > needed) {
1772 memmove(self->ob_item + (start + needed) * itemsize,
1773 self->ob_item + stop * itemsize,
1774 (Py_SIZE(self) - stop) * itemsize);
1775 if (array_resize(self, Py_SIZE(self) +
1776 needed - slicelength) < 0)
1777 return -1;
1778 }
1779 else if (slicelength < needed) {
1780 if (array_resize(self, Py_SIZE(self) +
1781 needed - slicelength) < 0)
1782 return -1;
1783 memmove(self->ob_item + (start + needed) * itemsize,
1784 self->ob_item + stop * itemsize,
1785 (Py_SIZE(self) - start - needed) * itemsize);
1786 }
1787 if (needed > 0)
1788 memcpy(self->ob_item + start * itemsize,
1789 other->ob_item, needed * itemsize);
1790 return 0;
1791 }
1792 else if (needed == 0) {
1793 /* Delete slice */
1794 Py_ssize_t cur, i;
1795
1796 if (step < 0) {
1797 stop = start + 1;
1798 start = stop + step * (slicelength - 1) - 1;
1799 step = -step;
1800 }
1801 for (cur = start, i = 0; i < slicelength;
1802 cur += step, i++) {
1803 Py_ssize_t lim = step - 1;
1804
1805 if (cur + step >= Py_SIZE(self))
1806 lim = Py_SIZE(self) - cur - 1;
1807 memmove(self->ob_item + (cur - i) * itemsize,
1808 self->ob_item + (cur + 1) * itemsize,
1809 lim * itemsize);
1810 }
1811 cur = start + slicelength * step;
1812 if (cur < Py_SIZE(self)) {
1813 memmove(self->ob_item + (cur-slicelength) * itemsize,
1814 self->ob_item + cur * itemsize,
1815 (Py_SIZE(self) - cur) * itemsize);
1816 }
1817 if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
1818 return -1;
1819 return 0;
1820 }
1821 else {
1822 Py_ssize_t cur, i;
1823
1824 if (needed != slicelength) {
1825 PyErr_Format(PyExc_ValueError,
1826 "attempt to assign array of size %zd "
1827 "to extended slice of size %zd",
1828 needed, slicelength);
1829 return -1;
1830 }
1831 for (cur = start, i = 0; i < slicelength;
1832 cur += step, i++) {
1833 memcpy(self->ob_item + cur * itemsize,
1834 other->ob_item + i * itemsize,
1835 itemsize);
1836 }
1837 return 0;
1838 }
1839 }
1840
1841 static PyMappingMethods array_as_mapping = {
1842 (lenfunc)array_length,
1843 (binaryfunc)array_subscr,
1844 (objobjargproc)array_ass_subscr
1845 };
1846
1847 static const void *emptybuf = "";
1848
1849 static Py_ssize_t
1850 array_buffer_getreadbuf(arrayobject *self, Py_ssize_t index, const void **ptr)
1851 {
1852 if ( index != 0 ) {
1853 PyErr_SetString(PyExc_SystemError,
1854 "Accessing non-existent array segment");
1855 return -1;
1856 }
1857 *ptr = (void *)self->ob_item;
1858 if (*ptr == NULL)
1859 *ptr = emptybuf;
1860 return Py_SIZE(self)*self->ob_descr->itemsize;
1861 }
1862
1863 static Py_ssize_t
1864 array_buffer_getwritebuf(arrayobject *self, Py_ssize_t index, const void **ptr)
1865 {
1866 if ( index != 0 ) {
1867 PyErr_SetString(PyExc_SystemError,
1868 "Accessing non-existent array segment");
1869 return -1;
1870 }
1871 *ptr = (void *)self->ob_item;
1872 if (*ptr == NULL)
1873 *ptr = emptybuf;
1874 return Py_SIZE(self)*self->ob_descr->itemsize;
1875 }
1876
1877 static Py_ssize_t
1878 array_buffer_getsegcount(arrayobject *self, Py_ssize_t *lenp)
1879 {
1880 if ( lenp )
1881 *lenp = Py_SIZE(self)*self->ob_descr->itemsize;
1882 return 1;
1883 }
1884
1885 static PySequenceMethods array_as_sequence = {
1886 (lenfunc)array_length, /*sq_length*/
1887 (binaryfunc)array_concat, /*sq_concat*/
1888 (ssizeargfunc)array_repeat, /*sq_repeat*/
1889 (ssizeargfunc)array_item, /*sq_item*/
1890 (ssizessizeargfunc)array_slice, /*sq_slice*/
1891 (ssizeobjargproc)array_ass_item, /*sq_ass_item*/
1892 (ssizessizeobjargproc)array_ass_slice, /*sq_ass_slice*/
1893 (objobjproc)array_contains, /*sq_contains*/
1894 (binaryfunc)array_inplace_concat, /*sq_inplace_concat*/
1895 (ssizeargfunc)array_inplace_repeat /*sq_inplace_repeat*/
1896 };
1897
1898 static PyBufferProcs array_as_buffer = {
1899 (readbufferproc)array_buffer_getreadbuf,
1900 (writebufferproc)array_buffer_getwritebuf,
1901 (segcountproc)array_buffer_getsegcount,
1902 NULL,
1903 };
1904
1905 static PyObject *
1906 array_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1907 {
1908 char c;
1909 PyObject *initial = NULL, *it = NULL;
1910 struct arraydescr *descr;
1911
1912 if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds))
1913 return NULL;
1914
1915 if (!PyArg_ParseTuple(args, "c|O:array", &c, &initial))
1916 return NULL;
1917
1918 if (!(initial == NULL || PyList_Check(initial)
1919 || PyString_Check(initial) || PyTuple_Check(initial)
1920 || (c == 'u' && PyUnicode_Check(initial)))) {
1921 it = PyObject_GetIter(initial);
1922 if (it == NULL)
1923 return NULL;
1924 /* We set initial to NULL so that the subsequent code
1925 will create an empty array of the appropriate type
1926 and afterwards we can use array_iter_extend to populate
1927 the array.
1928 */
1929 initial = NULL;
1930 }
1931 for (descr = descriptors; descr->typecode != '\0'; descr++) {
1932 if (descr->typecode == c) {
1933 PyObject *a;
1934 Py_ssize_t len;
1935
1936 if (initial == NULL || !(PyList_Check(initial)
1937 || PyTuple_Check(initial)))
1938 len = 0;
1939 else
1940 len = PySequence_Size(initial);
1941
1942 a = newarrayobject(type, len, descr);
1943 if (a == NULL)
1944 return NULL;
1945
1946 if (len > 0) {
1947 Py_ssize_t i;
1948 for (i = 0; i < len; i++) {
1949 PyObject *v =
1950 PySequence_GetItem(initial, i);
1951 if (v == NULL) {
1952 Py_DECREF(a);
1953 return NULL;
1954 }
1955 if (setarrayitem(a, i, v) != 0) {
1956 Py_DECREF(v);
1957 Py_DECREF(a);
1958 return NULL;
1959 }
1960 Py_DECREF(v);
1961 }
1962 } else if (initial != NULL && PyString_Check(initial)) {
1963 PyObject *t_initial, *v;
1964 t_initial = PyTuple_Pack(1, initial);
1965 if (t_initial == NULL) {
1966 Py_DECREF(a);
1967 return NULL;
1968 }
1969 v = array_fromstring((arrayobject *)a,
1970 t_initial);
1971 Py_DECREF(t_initial);
1972 if (v == NULL) {
1973 Py_DECREF(a);
1974 return NULL;
1975 }
1976 Py_DECREF(v);
1977 #ifdef Py_USING_UNICODE
1978 } else if (initial != NULL && PyUnicode_Check(initial)) {
1979 Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial);
1980 if (n > 0) {
1981 arrayobject *self = (arrayobject *)a;
1982 char *item = self->ob_item;
1983 item = (char *)PyMem_Realloc(item, n);
1984 if (item == NULL) {
1985 PyErr_NoMemory();
1986 Py_DECREF(a);
1987 return NULL;
1988 }
1989 self->ob_item = item;
1990 Py_SIZE(self) = n / sizeof(Py_UNICODE);
1991 memcpy(item, PyUnicode_AS_DATA(initial), n);
1992 self->allocated = Py_SIZE(self);
1993 }
1994 #endif
1995 }
1996 if (it != NULL) {
1997 if (array_iter_extend((arrayobject *)a, it) == -1) {
1998 Py_DECREF(it);
1999 Py_DECREF(a);
2000 return NULL;
2001 }
2002 Py_DECREF(it);
2003 }
2004 return a;
2005 }
2006 }
2007 PyErr_SetString(PyExc_ValueError,
2008 "bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)");
2009 return NULL;
2010 }
2011
2012
2013 PyDoc_STRVAR(module_doc,
2014 "This module defines an object type which can efficiently represent\n\
2015 an array of basic values: characters, integers, floating point\n\
2016 numbers. Arrays are sequence types and behave very much like lists,\n\
2017 except that the type of objects stored in them is constrained. The\n\
2018 type is specified at object creation time by using a type code, which\n\
2019 is a single character. The following type codes are defined:\n\
2020 \n\
2021 Type code C Type Minimum size in bytes \n\
2022 'c' character 1 \n\
2023 'b' signed integer 1 \n\
2024 'B' unsigned integer 1 \n\
2025 'u' Unicode character 2 \n\
2026 'h' signed integer 2 \n\
2027 'H' unsigned integer 2 \n\
2028 'i' signed integer 2 \n\
2029 'I' unsigned integer 2 \n\
2030 'l' signed integer 4 \n\
2031 'L' unsigned integer 4 \n\
2032 'f' floating point 4 \n\
2033 'd' floating point 8 \n\
2034 \n\
2035 The constructor is:\n\
2036 \n\
2037 array(typecode [, initializer]) -- create a new array\n\
2038 ");
2039
2040 PyDoc_STRVAR(arraytype_doc,
2041 "array(typecode [, initializer]) -> array\n\
2042 \n\
2043 Return a new array whose items are restricted by typecode, and\n\
2044 initialized from the optional initializer value, which must be a list,\n\
2045 string. or iterable over elements of the appropriate type.\n\
2046 \n\
2047 Arrays represent basic values and behave very much like lists, except\n\
2048 the type of objects stored in them is constrained.\n\
2049 \n\
2050 Methods:\n\
2051 \n\
2052 append() -- append a new item to the end of the array\n\
2053 buffer_info() -- return information giving the current memory info\n\
2054 byteswap() -- byteswap all the items of the array\n\
2055 count() -- return number of occurences of an object\n\
2056 extend() -- extend array by appending multiple elements from an iterable\n\
2057 fromfile() -- read items from a file object\n\
2058 fromlist() -- append items from the list\n\
2059 fromstring() -- append items from the string\n\
2060 index() -- return index of first occurence of an object\n\
2061 insert() -- insert a new item into the array at a provided position\n\
2062 pop() -- remove and return item (default last)\n\
2063 read() -- DEPRECATED, use fromfile()\n\
2064 remove() -- remove first occurence of an object\n\
2065 reverse() -- reverse the order of the items in the array\n\
2066 tofile() -- write all items to a file object\n\
2067 tolist() -- return the array converted to an ordinary list\n\
2068 tostring() -- return the array converted to a string\n\
2069 write() -- DEPRECATED, use tofile()\n\
2070 \n\
2071 Attributes:\n\
2072 \n\
2073 typecode -- the typecode character used to create the array\n\
2074 itemsize -- the length in bytes of one array item\n\
2075 ");
2076
2077 static PyObject *array_iter(arrayobject *ao);
2078
2079 static PyTypeObject Arraytype = {
2080 PyVarObject_HEAD_INIT(NULL, 0)
2081 "array.array",
2082 sizeof(arrayobject),
2083 0,
2084 (destructor)array_dealloc, /* tp_dealloc */
2085 0, /* tp_print */
2086 0, /* tp_getattr */
2087 0, /* tp_setattr */
2088 0, /* tp_compare */
2089 (reprfunc)array_repr, /* tp_repr */
2090 0, /* tp_as_number*/
2091 &array_as_sequence, /* tp_as_sequence*/
2092 &array_as_mapping, /* tp_as_mapping*/
2093 0, /* tp_hash */
2094 0, /* tp_call */
2095 0, /* tp_str */
2096 PyObject_GenericGetAttr, /* tp_getattro */
2097 0, /* tp_setattro */
2098 &array_as_buffer, /* tp_as_buffer*/
2099 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
2100 arraytype_doc, /* tp_doc */
2101 0, /* tp_traverse */
2102 0, /* tp_clear */
2103 array_richcompare, /* tp_richcompare */
2104 offsetof(arrayobject, weakreflist), /* tp_weaklistoffset */
2105 (getiterfunc)array_iter, /* tp_iter */
2106 0, /* tp_iternext */
2107 array_methods, /* tp_methods */
2108 0, /* tp_members */
2109 array_getsets, /* tp_getset */
2110 0, /* tp_base */
2111 0, /* tp_dict */
2112 0, /* tp_descr_get */
2113 0, /* tp_descr_set */
2114 0, /* tp_dictoffset */
2115 0, /* tp_init */
2116 PyType_GenericAlloc, /* tp_alloc */
2117 array_new, /* tp_new */
2118 PyObject_Del, /* tp_free */
2119 };
2120
2121
2122 /*********************** Array Iterator **************************/
2123
2124 typedef struct {
2125 PyObject_HEAD
2126 Py_ssize_t index;
2127 arrayobject *ao;
2128 PyObject * (*getitem)(struct arrayobject *, Py_ssize_t);
2129 } arrayiterobject;
2130
2131 static PyTypeObject PyArrayIter_Type;
2132
2133 #define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type)
2134
2135 static PyObject *
2136 array_iter(arrayobject *ao)
2137 {
2138 arrayiterobject *it;
2139
2140 if (!array_Check(ao)) {
2141 PyErr_BadInternalCall();
2142 return NULL;
2143 }
2144
2145 it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type);
2146 if (it == NULL)
2147 return NULL;
2148
2149 Py_INCREF(ao);
2150 it->ao = ao;
2151 it->index = 0;
2152 it->getitem = ao->ob_descr->getitem;
2153 PyObject_GC_Track(it);
2154 return (PyObject *)it;
2155 }
2156
2157 static PyObject *
2158 arrayiter_next(arrayiterobject *it)
2159 {
2160 assert(PyArrayIter_Check(it));
2161 if (it->index < Py_SIZE(it->ao))
2162 return (*it->getitem)(it->ao, it->index++);
2163 return NULL;
2164 }
2165
2166 static void
2167 arrayiter_dealloc(arrayiterobject *it)
2168 {
2169 PyObject_GC_UnTrack(it);
2170 Py_XDECREF(it->ao);
2171 PyObject_GC_Del(it);
2172 }
2173
2174 static int
2175 arrayiter_traverse(arrayiterobject *it, visitproc visit, void *arg)
2176 {
2177 Py_VISIT(it->ao);
2178 return 0;
2179 }
2180
2181 static PyTypeObject PyArrayIter_Type = {
2182 PyVarObject_HEAD_INIT(NULL, 0)
2183 "arrayiterator", /* tp_name */
2184 sizeof(arrayiterobject), /* tp_basicsize */
2185 0, /* tp_itemsize */
2186 /* methods */
2187 (destructor)arrayiter_dealloc, /* tp_dealloc */
2188 0, /* tp_print */
2189 0, /* tp_getattr */
2190 0, /* tp_setattr */
2191 0, /* tp_compare */
2192 0, /* tp_repr */
2193 0, /* tp_as_number */
2194 0, /* tp_as_sequence */
2195 0, /* tp_as_mapping */
2196 0, /* tp_hash */
2197 0, /* tp_call */
2198 0, /* tp_str */
2199 PyObject_GenericGetAttr, /* tp_getattro */
2200 0, /* tp_setattro */
2201 0, /* tp_as_buffer */
2202 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
2203 0, /* tp_doc */
2204 (traverseproc)arrayiter_traverse, /* tp_traverse */
2205 0, /* tp_clear */
2206 0, /* tp_richcompare */
2207 0, /* tp_weaklistoffset */
2208 PyObject_SelfIter, /* tp_iter */
2209 (iternextfunc)arrayiter_next, /* tp_iternext */
2210 0, /* tp_methods */
2211 };
2212
2213
2214 /*********************** Install Module **************************/
2215
2216 /* No functions in array module. */
2217 static PyMethodDef a_methods[] = {
2218 {NULL, NULL, 0, NULL} /* Sentinel */
2219 };
2220
2221
2222 PyMODINIT_FUNC
2223 initarray(void)
2224 {
2225 PyObject *m;
2226
2227 Arraytype.ob_type = &PyType_Type;
2228 PyArrayIter_Type.ob_type = &PyType_Type;
2229 m = Py_InitModule3("array", a_methods, module_doc);
2230 if (m == NULL)
2231 return;
2232
2233 Py_INCREF((PyObject *)&Arraytype);
2234 PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype);
2235 Py_INCREF((PyObject *)&Arraytype);
2236 PyModule_AddObject(m, "array", (PyObject *)&Arraytype);
2237 /* No need to check the error here, the caller will do that */
2238 }
python git mirror