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