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