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