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