1 /* Array object implementation */
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 */
6 #define PY_SSIZE_T_CLEAN
8 #include "structmember.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 */
18 struct arrayobject
; /* Forward */
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.
27 PyObject
* (*getitem
)(struct arrayobject
*, Py_ssize_t
);
28 int (*setitem
)(struct arrayobject
*, Py_ssize_t
, PyObject
*);
31 typedef struct arrayobject
{
35 struct arraydescr
*ob_descr
;
36 PyObject
*weakreflist
; /* List of weak references */
39 static PyTypeObject Arraytype
;
41 #define array_Check(op) PyObject_TypeCheck(op, &Arraytype)
42 #define array_CheckExact(op) (Py_TYPE(op) == &Arraytype)
45 array_resize(arrayobject
*self
, Py_ssize_t newsize
)
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.
55 if (self
->allocated
>= newsize
&&
56 Py_SIZE(self
) < newsize
+ 16 &&
57 self
->ob_item
!= NULL
) {
58 Py_SIZE(self
) = newsize
;
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
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
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
));
86 self
->ob_item
= items
;
87 Py_SIZE(self
) = newsize
;
88 self
->allocated
= _new_size
;
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 ****************************************************************************/
105 c_getitem(arrayobject
*ap
, Py_ssize_t i
)
107 return PyString_FromStringAndSize(&((char *)ap
->ob_item
)[i
], 1);
111 c_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
114 if (!PyArg_Parse(v
, "c;array item must be char", &x
))
117 ((char *)ap
->ob_item
)[i
] = x
;
122 b_getitem(arrayobject
*ap
, Py_ssize_t i
)
124 long x
= ((char *)ap
->ob_item
)[i
];
127 return PyInt_FromLong(x
);
131 b_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
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
))
140 PyErr_SetString(PyExc_OverflowError
,
141 "signed char is less than minimum");
145 PyErr_SetString(PyExc_OverflowError
,
146 "signed char is greater than maximum");
150 ((char *)ap
->ob_item
)[i
] = (char)x
;
155 BB_getitem(arrayobject
*ap
, Py_ssize_t i
)
157 long x
= ((unsigned char *)ap
->ob_item
)[i
];
158 return PyInt_FromLong(x
);
162 BB_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
165 /* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */
166 if (!PyArg_Parse(v
, "b;array item must be integer", &x
))
169 ((char *)ap
->ob_item
)[i
] = x
;
173 #ifdef Py_USING_UNICODE
175 u_getitem(arrayobject
*ap
, Py_ssize_t i
)
177 return PyUnicode_FromUnicode(&((Py_UNICODE
*) ap
->ob_item
)[i
], 1);
181 u_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
186 if (!PyArg_Parse(v
, "u#;array item must be unicode character", &p
, &len
))
189 PyErr_SetString(PyExc_TypeError
,
190 "array item must be unicode character");
194 ((Py_UNICODE
*)ap
->ob_item
)[i
] = p
[0];
200 h_getitem(arrayobject
*ap
, Py_ssize_t i
)
202 return PyInt_FromLong((long) ((short *)ap
->ob_item
)[i
]);
206 h_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
209 /* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */
210 if (!PyArg_Parse(v
, "h;array item must be integer", &x
))
213 ((short *)ap
->ob_item
)[i
] = x
;
218 HH_getitem(arrayobject
*ap
, Py_ssize_t i
)
220 return PyInt_FromLong((long) ((unsigned short *)ap
->ob_item
)[i
]);
224 HH_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
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
))
232 PyErr_SetString(PyExc_OverflowError
,
233 "unsigned short is less than minimum");
236 else if (x
> USHRT_MAX
) {
237 PyErr_SetString(PyExc_OverflowError
,
238 "unsigned short is greater than maximum");
242 ((short *)ap
->ob_item
)[i
] = (short)x
;
247 i_getitem(arrayobject
*ap
, Py_ssize_t i
)
249 return PyInt_FromLong((long) ((int *)ap
->ob_item
)[i
]);
253 i_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
256 /* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */
257 if (!PyArg_Parse(v
, "i;array item must be integer", &x
))
260 ((int *)ap
->ob_item
)[i
] = x
;
265 II_getitem(arrayobject
*ap
, Py_ssize_t i
)
267 return PyLong_FromUnsignedLong(
268 (unsigned long) ((unsigned int *)ap
->ob_item
)[i
]);
272 II_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
275 if (PyLong_Check(v
)) {
276 x
= PyLong_AsUnsignedLong(v
);
277 if (x
== (unsigned long) -1 && PyErr_Occurred())
282 if (!PyArg_Parse(v
, "l;array item must be integer", &y
))
285 PyErr_SetString(PyExc_OverflowError
,
286 "unsigned int is less than minimum");
289 x
= (unsigned long)y
;
293 PyErr_SetString(PyExc_OverflowError
,
294 "unsigned int is greater than maximum");
299 ((unsigned int *)ap
->ob_item
)[i
] = (unsigned int)x
;
304 l_getitem(arrayobject
*ap
, Py_ssize_t i
)
306 return PyInt_FromLong(((long *)ap
->ob_item
)[i
]);
310 l_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
313 if (!PyArg_Parse(v
, "l;array item must be integer", &x
))
316 ((long *)ap
->ob_item
)[i
] = x
;
321 LL_getitem(arrayobject
*ap
, Py_ssize_t i
)
323 return PyLong_FromUnsignedLong(((unsigned long *)ap
->ob_item
)[i
]);
327 LL_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
330 if (PyLong_Check(v
)) {
331 x
= PyLong_AsUnsignedLong(v
);
332 if (x
== (unsigned long) -1 && PyErr_Occurred())
337 if (!PyArg_Parse(v
, "l;array item must be integer", &y
))
340 PyErr_SetString(PyExc_OverflowError
,
341 "unsigned long is less than minimum");
344 x
= (unsigned long)y
;
348 PyErr_SetString(PyExc_OverflowError
,
349 "unsigned long is greater than maximum");
354 ((unsigned long *)ap
->ob_item
)[i
] = x
;
359 f_getitem(arrayobject
*ap
, Py_ssize_t i
)
361 return PyFloat_FromDouble((double) ((float *)ap
->ob_item
)[i
]);
365 f_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
368 if (!PyArg_Parse(v
, "f;array item must be float", &x
))
371 ((float *)ap
->ob_item
)[i
] = x
;
376 d_getitem(arrayobject
*ap
, Py_ssize_t i
)
378 return PyFloat_FromDouble(((double *)ap
->ob_item
)[i
]);
382 d_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
385 if (!PyArg_Parse(v
, "d;array item must be float", &x
))
388 ((double *)ap
->ob_item
)[i
] = x
;
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
},
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 */
411 /****************************************************************************
412 Implementations of array object methods.
413 ****************************************************************************/
416 newarrayobject(PyTypeObject
*type
, Py_ssize_t size
, struct arraydescr
*descr
)
422 PyErr_BadInternalCall();
426 nbytes
= size
* descr
->itemsize
;
427 /* Check for overflow */
428 if (nbytes
/ descr
->itemsize
!= (size_t)size
) {
429 return PyErr_NoMemory();
431 op
= (arrayobject
*) type
->tp_alloc(type
, 0);
440 op
->ob_item
= PyMem_NEW(char, nbytes
);
441 if (op
->ob_item
== NULL
) {
443 return PyErr_NoMemory();
446 op
->ob_descr
= descr
;
447 op
->allocated
= size
;
448 op
->weakreflist
= NULL
;
449 return (PyObject
*) op
;
453 getarrayitem(PyObject
*op
, Py_ssize_t i
)
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
);
463 ins1(arrayobject
*self
, Py_ssize_t where
, PyObject
*v
)
466 Py_ssize_t n
= Py_SIZE(self
);
468 PyErr_BadInternalCall();
471 if ((*self
->ob_descr
->setitem
)(self
, -1, v
) < 0)
474 if (array_resize(self
, n
+1) == -1)
476 items
= self
->ob_item
;
484 /* appends don't need to call memmove() */
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
);
495 array_dealloc(arrayobject
*op
)
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
);
505 array_richcompare(PyObject
*v
, PyObject
*w
, int op
)
507 arrayobject
*va
, *wa
;
513 if (!array_Check(v
) || !array_Check(w
)) {
514 Py_INCREF(Py_NotImplemented
);
515 return Py_NotImplemented
;
518 va
= (arrayobject
*)v
;
519 wa
= (arrayobject
*)w
;
521 if (Py_SIZE(va
) != Py_SIZE(wa
) && (op
== Py_EQ
|| op
== Py_NE
)) {
522 /* Shortcut: if the lengths differ, the arrays differ */
531 /* Search for the first index where items are different */
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
) {
541 k
= PyObject_RichCompareBool(vi
, wi
, Py_EQ
);
543 break; /* Keeping vi and wi alive! */
551 /* No more items to compare -- compare sizes */
552 Py_ssize_t vs
= Py_SIZE(va
);
553 Py_ssize_t ws
= Py_SIZE(wa
);
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 */
572 /* We have an item that differs. First, shortcuts for EQ/NE */
577 else if (op
== Py_NE
) {
582 /* Compare the final item again using the proper operator */
583 res
= PyObject_RichCompare(vi
, wi
, op
);
591 array_length(arrayobject
*a
)
597 array_item(arrayobject
*a
, Py_ssize_t i
)
599 if (i
< 0 || i
>= Py_SIZE(a
)) {
600 PyErr_SetString(PyExc_IndexError
, "array index out of range");
603 return getarrayitem((PyObject
*)a
, i
);
607 array_slice(arrayobject
*a
, Py_ssize_t ilow
, Py_ssize_t ihigh
)
612 else if (ilow
> Py_SIZE(a
))
618 else if (ihigh
> Py_SIZE(a
))
620 np
= (arrayobject
*) newarrayobject(&Arraytype
, ihigh
- ilow
, a
->ob_descr
);
623 memcpy(np
->ob_item
, a
->ob_item
+ ilow
* a
->ob_descr
->itemsize
,
624 (ihigh
-ilow
) * a
->ob_descr
->itemsize
);
625 return (PyObject
*)np
;
629 array_copy(arrayobject
*a
, PyObject
*unused
)
631 return array_slice(a
, 0, Py_SIZE(a
));
634 PyDoc_STRVAR(copy_doc
,
637 Return a copy of the array.");
640 array_concat(arrayobject
*a
, PyObject
*bb
)
644 if (!array_Check(bb
)) {
645 PyErr_Format(PyExc_TypeError
,
646 "can only append array (not \"%.200s\") to array",
647 Py_TYPE(bb
)->tp_name
);
650 #define b ((arrayobject *)bb)
651 if (a
->ob_descr
!= b
->ob_descr
) {
655 size
= Py_SIZE(a
) + Py_SIZE(b
);
656 np
= (arrayobject
*) newarrayobject(&Arraytype
, size
, a
->ob_descr
);
660 memcpy(np
->ob_item
, a
->ob_item
, Py_SIZE(a
)*a
->ob_descr
->itemsize
);
661 memcpy(np
->ob_item
+ Py_SIZE(a
)*a
->ob_descr
->itemsize
,
662 b
->ob_item
, Py_SIZE(b
)*b
->ob_descr
->itemsize
);
663 return (PyObject
*)np
;
668 array_repeat(arrayobject
*a
, Py_ssize_t n
)
677 size
= Py_SIZE(a
) * n
;
678 np
= (arrayobject
*) newarrayobject(&Arraytype
, size
, a
->ob_descr
);
682 nbytes
= Py_SIZE(a
) * a
->ob_descr
->itemsize
;
683 for (i
= 0; i
< n
; i
++) {
684 memcpy(p
, a
->ob_item
, nbytes
);
687 return (PyObject
*) np
;
691 array_ass_slice(arrayobject
*a
, Py_ssize_t ilow
, Py_ssize_t ihigh
, PyObject
*v
)
694 Py_ssize_t n
; /* Size of replacement array */
695 Py_ssize_t d
; /* Change in size */
696 #define b ((arrayobject *)v)
699 else if (array_Check(v
)) {
702 /* Special case "a[i:j] = a" -- copy b first */
704 v
= array_slice(b
, 0, n
);
707 ret
= array_ass_slice(a
, ilow
, ihigh
, v
);
711 if (b
->ob_descr
!= a
->ob_descr
) {
717 PyErr_Format(PyExc_TypeError
,
718 "can only assign array (not \"%.200s\") to array slice",
719 Py_TYPE(v
)->tp_name
);
724 else if (ilow
> Py_SIZE(a
))
730 else if (ihigh
> Py_SIZE(a
))
733 d
= n
- (ihigh
-ilow
);
734 if (d
< 0) { /* Delete -d items */
735 memmove(item
+ (ihigh
+d
)*a
->ob_descr
->itemsize
,
736 item
+ ihigh
*a
->ob_descr
->itemsize
,
737 (Py_SIZE(a
)-ihigh
)*a
->ob_descr
->itemsize
);
739 PyMem_RESIZE(item
, char, Py_SIZE(a
)*a
->ob_descr
->itemsize
);
742 a
->allocated
= Py_SIZE(a
);
744 else if (d
> 0) { /* Insert d items */
745 PyMem_RESIZE(item
, char,
746 (Py_SIZE(a
) + d
)*a
->ob_descr
->itemsize
);
751 memmove(item
+ (ihigh
+d
)*a
->ob_descr
->itemsize
,
752 item
+ ihigh
*a
->ob_descr
->itemsize
,
753 (Py_SIZE(a
)-ihigh
)*a
->ob_descr
->itemsize
);
756 a
->allocated
= Py_SIZE(a
);
759 memcpy(item
+ ilow
*a
->ob_descr
->itemsize
, b
->ob_item
,
760 n
*b
->ob_descr
->itemsize
);
766 array_ass_item(arrayobject
*a
, Py_ssize_t i
, PyObject
*v
)
768 if (i
< 0 || i
>= Py_SIZE(a
)) {
769 PyErr_SetString(PyExc_IndexError
,
770 "array assignment index out of range");
774 return array_ass_slice(a
, i
, i
+1, v
);
775 return (*a
->ob_descr
->setitem
)(a
, i
, v
);
779 setarrayitem(PyObject
*a
, Py_ssize_t i
, PyObject
*v
)
781 assert(array_Check(a
));
782 return array_ass_item((arrayobject
*)a
, i
, v
);
786 array_iter_extend(arrayobject
*self
, PyObject
*bb
)
790 it
= PyObject_GetIter(bb
);
794 while ((v
= PyIter_Next(it
)) != NULL
) {
795 if (ins1(self
, (int) Py_SIZE(self
), v
) != 0) {
803 if (PyErr_Occurred())
809 array_do_extend(arrayobject
*self
, PyObject
*bb
)
813 if (!array_Check(bb
))
814 return array_iter_extend(self
, bb
);
815 #define b ((arrayobject *)bb)
816 if (self
->ob_descr
!= b
->ob_descr
) {
817 PyErr_SetString(PyExc_TypeError
,
818 "can only extend with array of same kind");
821 size
= Py_SIZE(self
) + Py_SIZE(b
);
822 PyMem_RESIZE(self
->ob_item
, char, size
*self
->ob_descr
->itemsize
);
823 if (self
->ob_item
== NULL
) {
828 memcpy(self
->ob_item
+ Py_SIZE(self
)*self
->ob_descr
->itemsize
,
829 b
->ob_item
, Py_SIZE(b
)*b
->ob_descr
->itemsize
);
830 Py_SIZE(self
) = size
;
831 self
->allocated
= size
;
838 array_inplace_concat(arrayobject
*self
, PyObject
*bb
)
840 if (!array_Check(bb
)) {
841 PyErr_Format(PyExc_TypeError
,
842 "can only extend array with array (not \"%.200s\")",
843 Py_TYPE(bb
)->tp_name
);
846 if (array_do_extend(self
, bb
) == -1)
849 return (PyObject
*)self
;
853 array_inplace_repeat(arrayobject
*self
, Py_ssize_t n
)
858 if (Py_SIZE(self
) > 0) {
861 items
= self
->ob_item
;
862 size
= Py_SIZE(self
) * self
->ob_descr
->itemsize
;
865 self
->ob_item
= NULL
;
870 PyMem_Resize(items
, char, n
* size
);
872 return PyErr_NoMemory();
874 for (i
= 1; i
< n
; i
++) {
876 memcpy(p
, items
, size
);
878 self
->ob_item
= items
;
880 self
->allocated
= Py_SIZE(self
);
884 return (PyObject
*)self
;
889 ins(arrayobject
*self
, Py_ssize_t where
, PyObject
*v
)
891 if (ins1(self
, where
, v
) != 0)
898 array_count(arrayobject
*self
, PyObject
*v
)
900 Py_ssize_t count
= 0;
903 for (i
= 0; i
< Py_SIZE(self
); i
++) {
904 PyObject
*selfi
= getarrayitem((PyObject
*)self
, i
);
905 int cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
912 return PyInt_FromSsize_t(count
);
915 PyDoc_STRVAR(count_doc
,
918 Return number of occurences of x in the array.");
921 array_index(arrayobject
*self
, PyObject
*v
)
925 for (i
= 0; i
< Py_SIZE(self
); i
++) {
926 PyObject
*selfi
= getarrayitem((PyObject
*)self
, i
);
927 int cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
930 return PyInt_FromLong((long)i
);
935 PyErr_SetString(PyExc_ValueError
, "array.index(x): x not in list");
939 PyDoc_STRVAR(index_doc
,
942 Return index of first occurence of x in the array.");
945 array_contains(arrayobject
*self
, PyObject
*v
)
950 for (i
= 0, cmp
= 0 ; cmp
== 0 && i
< Py_SIZE(self
); i
++) {
951 PyObject
*selfi
= getarrayitem((PyObject
*)self
, i
);
952 cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
959 array_remove(arrayobject
*self
, PyObject
*v
)
963 for (i
= 0; i
< Py_SIZE(self
); i
++) {
964 PyObject
*selfi
= getarrayitem((PyObject
*)self
,i
);
965 int cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
968 if (array_ass_slice(self
, i
, i
+1,
969 (PyObject
*)NULL
) != 0)
977 PyErr_SetString(PyExc_ValueError
, "array.remove(x): x not in list");
981 PyDoc_STRVAR(remove_doc
,
984 Remove the first occurence of x in the array.");
987 array_pop(arrayobject
*self
, PyObject
*args
)
991 if (!PyArg_ParseTuple(args
, "|n:pop", &i
))
993 if (Py_SIZE(self
) == 0) {
994 /* Special-case most common failure cause */
995 PyErr_SetString(PyExc_IndexError
, "pop from empty array");
1000 if (i
< 0 || i
>= Py_SIZE(self
)) {
1001 PyErr_SetString(PyExc_IndexError
, "pop index out of range");
1004 v
= getarrayitem((PyObject
*)self
,i
);
1005 if (array_ass_slice(self
, i
, i
+1, (PyObject
*)NULL
) != 0) {
1012 PyDoc_STRVAR(pop_doc
,
1015 Return the i-th element and delete it from the array. i defaults to -1.");
1018 array_extend(arrayobject
*self
, PyObject
*bb
)
1020 if (array_do_extend(self
, bb
) == -1)
1026 PyDoc_STRVAR(extend_doc
,
1027 "extend(array or iterable)\n\
1029 Append items to the end of the array.");
1032 array_insert(arrayobject
*self
, PyObject
*args
)
1036 if (!PyArg_ParseTuple(args
, "nO:insert", &i
, &v
))
1038 return ins(self
, i
, v
);
1041 PyDoc_STRVAR(insert_doc
,
1044 Insert a new item x into the array before position i.");
1048 array_buffer_info(arrayobject
*self
, PyObject
*unused
)
1050 PyObject
* retval
= NULL
;
1051 retval
= PyTuple_New(2);
1055 PyTuple_SET_ITEM(retval
, 0, PyLong_FromVoidPtr(self
->ob_item
));
1056 PyTuple_SET_ITEM(retval
, 1, PyInt_FromLong((long)(Py_SIZE(self
))));
1061 PyDoc_STRVAR(buffer_info_doc
,
1062 "buffer_info() -> (address, length)\n\
1064 Return a tuple (address, length) giving the current memory address and\n\
1065 the length in items of the buffer used to hold array's contents\n\
1066 The length should be multiplied by the itemsize attribute to calculate\n\
1067 the buffer length in bytes.");
1071 array_append(arrayobject
*self
, PyObject
*v
)
1073 return ins(self
, (int) Py_SIZE(self
), v
);
1076 PyDoc_STRVAR(append_doc
,
1079 Append new value x to the end of the array.");
1083 array_byteswap(arrayobject
*self
, PyObject
*unused
)
1088 switch (self
->ob_descr
->itemsize
) {
1092 for (p
= self
->ob_item
, i
= Py_SIZE(self
); --i
>= 0; p
+= 2) {
1099 for (p
= self
->ob_item
, i
= Py_SIZE(self
); --i
>= 0; p
+= 4) {
1109 for (p
= self
->ob_item
, i
= Py_SIZE(self
); --i
>= 0; p
+= 8) {
1125 PyErr_SetString(PyExc_RuntimeError
,
1126 "don't know how to byteswap this array type");
1133 PyDoc_STRVAR(byteswap_doc
,
1136 Byteswap all items of the array. If the items in the array are not 1, 2,\n\
1137 4, or 8 bytes in size, RuntimeError is raised.");
1140 array_reduce(arrayobject
*array
)
1142 PyObject
*dict
, *result
;
1144 dict
= PyObject_GetAttrString((PyObject
*)array
, "__dict__");
1150 if (Py_SIZE(array
) > 0) {
1151 result
= Py_BuildValue("O(cs#)O",
1153 array
->ob_descr
->typecode
,
1155 Py_SIZE(array
) * array
->ob_descr
->itemsize
,
1158 result
= Py_BuildValue("O(c)O",
1160 array
->ob_descr
->typecode
,
1167 PyDoc_STRVAR(array_doc
, "Return state information for pickling.");
1170 array_reverse(arrayobject
*self
, PyObject
*unused
)
1172 register Py_ssize_t itemsize
= self
->ob_descr
->itemsize
;
1173 register char *p
, *q
;
1174 /* little buffer to hold items while swapping */
1175 char tmp
[256]; /* 8 is probably enough -- but why skimp */
1176 assert((size_t)itemsize
<= sizeof(tmp
));
1178 if (Py_SIZE(self
) > 1) {
1179 for (p
= self
->ob_item
,
1180 q
= self
->ob_item
+ (Py_SIZE(self
) - 1)*itemsize
;
1182 p
+= itemsize
, q
-= itemsize
) {
1183 /* memory areas guaranteed disjoint, so memcpy
1184 * is safe (& memmove may be slower).
1186 memcpy(tmp
, p
, itemsize
);
1187 memcpy(p
, q
, itemsize
);
1188 memcpy(q
, tmp
, itemsize
);
1196 PyDoc_STRVAR(reverse_doc
,
1199 Reverse the order of the items in the array.");
1202 array_fromfile(arrayobject
*self
, PyObject
*args
)
1207 if (!PyArg_ParseTuple(args
, "On:fromfile", &f
, &n
))
1209 fp
= PyFile_AsFile(f
);
1211 PyErr_SetString(PyExc_TypeError
, "arg1 must be open file");
1215 char *item
= self
->ob_item
;
1216 Py_ssize_t itemsize
= self
->ob_descr
->itemsize
;
1218 Py_ssize_t newlength
;
1220 /* Be careful here about overflow */
1221 if ((newlength
= Py_SIZE(self
) + n
) <= 0 ||
1222 (newbytes
= newlength
* itemsize
) / itemsize
!=
1225 PyMem_RESIZE(item
, char, newbytes
);
1231 self
->ob_item
= item
;
1233 self
->allocated
= Py_SIZE(self
);
1234 nread
= fread(item
+ (Py_SIZE(self
) - n
) * itemsize
,
1236 if (nread
< (size_t)n
) {
1237 Py_SIZE(self
) -= (n
- nread
);
1238 PyMem_RESIZE(item
, char, Py_SIZE(self
)*itemsize
);
1239 self
->ob_item
= item
;
1240 self
->allocated
= Py_SIZE(self
);
1241 PyErr_SetString(PyExc_EOFError
,
1242 "not enough items in file");
1250 PyDoc_STRVAR(fromfile_doc
,
1253 Read n objects from the file object f and append them to the end of the\n\
1254 array. Also called as read.");
1258 array_fromfile_as_read(arrayobject
*self
, PyObject
*args
)
1260 if (PyErr_WarnPy3k("array.read() not supported in 3.x; "
1261 "use array.fromfile()", 1) < 0)
1263 return array_fromfile(self
, args
);
1268 array_tofile(arrayobject
*self
, PyObject
*f
)
1272 fp
= PyFile_AsFile(f
);
1274 PyErr_SetString(PyExc_TypeError
, "arg must be open file");
1277 if (self
->ob_size
> 0) {
1278 if (fwrite(self
->ob_item
, self
->ob_descr
->itemsize
,
1279 self
->ob_size
, fp
) != (size_t)self
->ob_size
) {
1280 PyErr_SetFromErrno(PyExc_IOError
);
1289 PyDoc_STRVAR(tofile_doc
,
1292 Write all items (as machine values) to the file object f. Also called as\n\
1297 array_tofile_as_write(arrayobject
*self
, PyObject
*f
)
1299 if (PyErr_WarnPy3k("array.write() not supported in 3.x; "
1300 "use array.tofile()", 1) < 0)
1302 return array_tofile(self
, f
);
1307 array_fromlist(arrayobject
*self
, PyObject
*list
)
1310 Py_ssize_t itemsize
= self
->ob_descr
->itemsize
;
1312 if (!PyList_Check(list
)) {
1313 PyErr_SetString(PyExc_TypeError
, "arg must be list");
1316 n
= PyList_Size(list
);
1318 char *item
= self
->ob_item
;
1320 PyMem_RESIZE(item
, char, (Py_SIZE(self
) + n
) * itemsize
);
1325 self
->ob_item
= item
;
1327 self
->allocated
= Py_SIZE(self
);
1328 for (i
= 0; i
< n
; i
++) {
1329 PyObject
*v
= PyList_GetItem(list
, i
);
1330 if ((*self
->ob_descr
->setitem
)(self
,
1331 Py_SIZE(self
) - n
+ i
, v
) != 0) {
1333 PyMem_RESIZE(item
, char,
1334 Py_SIZE(self
) * itemsize
);
1335 self
->ob_item
= item
;
1336 self
->allocated
= Py_SIZE(self
);
1345 PyDoc_STRVAR(fromlist_doc
,
1348 Append items to array from list.");
1352 array_tolist(arrayobject
*self
, PyObject
*unused
)
1354 PyObject
*list
= PyList_New(Py_SIZE(self
));
1359 for (i
= 0; i
< Py_SIZE(self
); i
++) {
1360 PyObject
*v
= getarrayitem((PyObject
*)self
, i
);
1365 PyList_SetItem(list
, i
, v
);
1370 PyDoc_STRVAR(tolist_doc
,
1371 "tolist() -> list\n\
1373 Convert array to an ordinary list with the same items.");
1377 array_fromstring(arrayobject
*self
, PyObject
*args
)
1381 int itemsize
= self
->ob_descr
->itemsize
;
1382 if (!PyArg_ParseTuple(args
, "s#:fromstring", &str
, &n
))
1384 if (n
% itemsize
!= 0) {
1385 PyErr_SetString(PyExc_ValueError
,
1386 "string length not a multiple of item size");
1391 char *item
= self
->ob_item
;
1392 PyMem_RESIZE(item
, char, (Py_SIZE(self
) + n
) * itemsize
);
1397 self
->ob_item
= item
;
1399 self
->allocated
= Py_SIZE(self
);
1400 memcpy(item
+ (Py_SIZE(self
) - n
) * itemsize
,
1407 PyDoc_STRVAR(fromstring_doc
,
1408 "fromstring(string)\n\
1410 Appends items from the string, interpreting it as an array of machine\n\
1411 values,as if it had been read from a file using the fromfile() method).");
1415 array_tostring(arrayobject
*self
, PyObject
*unused
)
1417 return PyString_FromStringAndSize(self
->ob_item
,
1418 Py_SIZE(self
) * self
->ob_descr
->itemsize
);
1421 PyDoc_STRVAR(tostring_doc
,
1422 "tostring() -> string\n\
1424 Convert the array to an array of machine values and return the string\n\
1429 #ifdef Py_USING_UNICODE
1431 array_fromunicode(arrayobject
*self
, PyObject
*args
)
1436 if (!PyArg_ParseTuple(args
, "u#:fromunicode", &ustr
, &n
))
1438 if (self
->ob_descr
->typecode
!= 'u') {
1439 PyErr_SetString(PyExc_ValueError
,
1440 "fromunicode() may only be called on "
1445 Py_UNICODE
*item
= (Py_UNICODE
*) self
->ob_item
;
1446 PyMem_RESIZE(item
, Py_UNICODE
, Py_SIZE(self
) + n
);
1451 self
->ob_item
= (char *) item
;
1453 self
->allocated
= Py_SIZE(self
);
1454 memcpy(item
+ Py_SIZE(self
) - n
,
1455 ustr
, n
* sizeof(Py_UNICODE
));
1462 PyDoc_STRVAR(fromunicode_doc
,
1463 "fromunicode(ustr)\n\
1465 Extends this array with data from the unicode string ustr.\n\
1466 The array must be a type 'u' array; otherwise a ValueError\n\
1467 is raised. Use array.fromstring(ustr.decode(...)) to\n\
1468 append Unicode data to an array of some other type.");
1472 array_tounicode(arrayobject
*self
, PyObject
*unused
)
1474 if (self
->ob_descr
->typecode
!= 'u') {
1475 PyErr_SetString(PyExc_ValueError
,
1476 "tounicode() may only be called on type 'u' arrays");
1479 return PyUnicode_FromUnicode((Py_UNICODE
*) self
->ob_item
, Py_SIZE(self
));
1482 PyDoc_STRVAR(tounicode_doc
,
1483 "tounicode() -> unicode\n\
1485 Convert the array to a unicode string. The array must be\n\
1486 a type 'u' array; otherwise a ValueError is raised. Use\n\
1487 array.tostring().decode() to obtain a unicode string from\n\
1488 an array of some other type.");
1490 #endif /* Py_USING_UNICODE */
1494 array_get_typecode(arrayobject
*a
, void *closure
)
1496 char tc
= a
->ob_descr
->typecode
;
1497 return PyString_FromStringAndSize(&tc
, 1);
1501 array_get_itemsize(arrayobject
*a
, void *closure
)
1503 return PyInt_FromLong((long)a
->ob_descr
->itemsize
);
1506 static PyGetSetDef array_getsets
[] = {
1507 {"typecode", (getter
) array_get_typecode
, NULL
,
1508 "the typecode character used to create the array"},
1509 {"itemsize", (getter
) array_get_itemsize
, NULL
,
1510 "the size, in bytes, of one array item"},
1514 PyMethodDef array_methods
[] = {
1515 {"append", (PyCFunction
)array_append
, METH_O
,
1517 {"buffer_info", (PyCFunction
)array_buffer_info
, METH_NOARGS
,
1519 {"byteswap", (PyCFunction
)array_byteswap
, METH_NOARGS
,
1521 {"__copy__", (PyCFunction
)array_copy
, METH_NOARGS
,
1523 {"count", (PyCFunction
)array_count
, METH_O
,
1525 {"__deepcopy__",(PyCFunction
)array_copy
, METH_O
,
1527 {"extend", (PyCFunction
)array_extend
, METH_O
,
1529 {"fromfile", (PyCFunction
)array_fromfile
, METH_VARARGS
,
1531 {"fromlist", (PyCFunction
)array_fromlist
, METH_O
,
1533 {"fromstring", (PyCFunction
)array_fromstring
, METH_VARARGS
,
1535 #ifdef Py_USING_UNICODE
1536 {"fromunicode", (PyCFunction
)array_fromunicode
, METH_VARARGS
,
1539 {"index", (PyCFunction
)array_index
, METH_O
,
1541 {"insert", (PyCFunction
)array_insert
, METH_VARARGS
,
1543 {"pop", (PyCFunction
)array_pop
, METH_VARARGS
,
1545 {"read", (PyCFunction
)array_fromfile_as_read
, METH_VARARGS
,
1547 {"__reduce__", (PyCFunction
)array_reduce
, METH_NOARGS
,
1549 {"remove", (PyCFunction
)array_remove
, METH_O
,
1551 {"reverse", (PyCFunction
)array_reverse
, METH_NOARGS
,
1553 /* {"sort", (PyCFunction)array_sort, METH_VARARGS,
1555 {"tofile", (PyCFunction
)array_tofile
, METH_O
,
1557 {"tolist", (PyCFunction
)array_tolist
, METH_NOARGS
,
1559 {"tostring", (PyCFunction
)array_tostring
, METH_NOARGS
,
1561 #ifdef Py_USING_UNICODE
1562 {"tounicode", (PyCFunction
)array_tounicode
, METH_NOARGS
,
1565 {"write", (PyCFunction
)array_tofile_as_write
, METH_O
,
1567 {NULL
, NULL
} /* sentinel */
1571 array_repr(arrayobject
*a
)
1573 char buf
[256], typecode
;
1574 PyObject
*s
, *t
, *v
= NULL
;
1578 typecode
= a
->ob_descr
->typecode
;
1580 PyOS_snprintf(buf
, sizeof(buf
), "array('%c')", typecode
);
1581 return PyString_FromString(buf
);
1584 if (typecode
== 'c')
1585 v
= array_tostring(a
, NULL
);
1586 #ifdef Py_USING_UNICODE
1587 else if (typecode
== 'u')
1588 v
= array_tounicode(a
, NULL
);
1591 v
= array_tolist(a
, NULL
);
1592 t
= PyObject_Repr(v
);
1595 PyOS_snprintf(buf
, sizeof(buf
), "array('%c', ", typecode
);
1596 s
= PyString_FromString(buf
);
1597 PyString_ConcatAndDel(&s
, t
);
1598 PyString_ConcatAndDel(&s
, PyString_FromString(")"));
1603 array_subscr(arrayobject
* self
, PyObject
* item
)
1605 if (PyIndex_Check(item
)) {
1606 Py_ssize_t i
= PyNumber_AsSsize_t(item
, PyExc_IndexError
);
1607 if (i
==-1 && PyErr_Occurred()) {
1612 return array_item(self
, i
);
1614 else if (PySlice_Check(item
)) {
1615 Py_ssize_t start
, stop
, step
, slicelength
, cur
, i
;
1618 int itemsize
= self
->ob_descr
->itemsize
;
1620 if (PySlice_GetIndicesEx((PySliceObject
*)item
, Py_SIZE(self
),
1621 &start
, &stop
, &step
, &slicelength
) < 0) {
1625 if (slicelength
<= 0) {
1626 return newarrayobject(&Arraytype
, 0, self
->ob_descr
);
1628 else if (step
== 1) {
1629 PyObject
*result
= newarrayobject(&Arraytype
,
1630 slicelength
, self
->ob_descr
);
1633 memcpy(((arrayobject
*)result
)->ob_item
,
1634 self
->ob_item
+ start
* itemsize
,
1635 slicelength
* itemsize
);
1639 result
= newarrayobject(&Arraytype
, slicelength
, self
->ob_descr
);
1640 if (!result
) return NULL
;
1642 ar
= (arrayobject
*)result
;
1644 for (cur
= start
, i
= 0; i
< slicelength
;
1646 memcpy(ar
->ob_item
+ i
*itemsize
,
1647 self
->ob_item
+ cur
*itemsize
,
1655 PyErr_SetString(PyExc_TypeError
,
1656 "array indices must be integers");
1662 array_ass_subscr(arrayobject
* self
, PyObject
* item
, PyObject
* value
)
1664 Py_ssize_t start
, stop
, step
, slicelength
, needed
;
1668 if (PyIndex_Check(item
)) {
1669 Py_ssize_t i
= PyNumber_AsSsize_t(item
, PyExc_IndexError
);
1671 if (i
== -1 && PyErr_Occurred())
1675 if (i
< 0 || i
>= Py_SIZE(self
)) {
1676 PyErr_SetString(PyExc_IndexError
,
1677 "array assignment index out of range");
1680 if (value
== NULL
) {
1681 /* Fall through to slice assignment */
1688 return (*self
->ob_descr
->setitem
)(self
, i
, value
);
1690 else if (PySlice_Check(item
)) {
1691 if (PySlice_GetIndicesEx((PySliceObject
*)item
,
1692 Py_SIZE(self
), &start
, &stop
,
1693 &step
, &slicelength
) < 0) {
1698 PyErr_SetString(PyExc_TypeError
,
1699 "array indices must be integer");
1702 if (value
== NULL
) {
1706 else if (array_Check(value
)) {
1707 other
= (arrayobject
*)value
;
1708 needed
= Py_SIZE(other
);
1709 if (self
== other
) {
1710 /* Special case "self[i:j] = self" -- copy self first */
1712 value
= array_slice(other
, 0, needed
);
1715 ret
= array_ass_subscr(self
, item
, value
);
1719 if (other
->ob_descr
!= self
->ob_descr
) {
1720 PyErr_BadArgument();
1725 PyErr_Format(PyExc_TypeError
,
1726 "can only assign array (not \"%.200s\") to array slice",
1727 Py_TYPE(value
)->tp_name
);
1730 itemsize
= self
->ob_descr
->itemsize
;
1731 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
1732 if ((step
> 0 && stop
< start
) ||
1733 (step
< 0 && stop
> start
))
1736 if (slicelength
> needed
) {
1737 memmove(self
->ob_item
+ (start
+ needed
) * itemsize
,
1738 self
->ob_item
+ stop
* itemsize
,
1739 (Py_SIZE(self
) - stop
) * itemsize
);
1740 if (array_resize(self
, Py_SIZE(self
) +
1741 needed
- slicelength
) < 0)
1744 else if (slicelength
< needed
) {
1745 if (array_resize(self
, Py_SIZE(self
) +
1746 needed
- slicelength
) < 0)
1748 memmove(self
->ob_item
+ (start
+ needed
) * itemsize
,
1749 self
->ob_item
+ stop
* itemsize
,
1750 (Py_SIZE(self
) - start
- needed
) * itemsize
);
1753 memcpy(self
->ob_item
+ start
* itemsize
,
1754 other
->ob_item
, needed
* itemsize
);
1757 else if (needed
== 0) {
1763 start
= stop
+ step
* (slicelength
- 1) - 1;
1766 for (cur
= start
, i
= 0; i
< slicelength
;
1768 Py_ssize_t lim
= step
- 1;
1770 if (cur
+ step
>= Py_SIZE(self
))
1771 lim
= Py_SIZE(self
) - cur
- 1;
1772 memmove(self
->ob_item
+ (cur
- i
) * itemsize
,
1773 self
->ob_item
+ (cur
+ 1) * itemsize
,
1776 cur
= start
+ slicelength
* step
;
1777 if (cur
< Py_SIZE(self
)) {
1778 memmove(self
->ob_item
+ (cur
-slicelength
) * itemsize
,
1779 self
->ob_item
+ cur
* itemsize
,
1780 (Py_SIZE(self
) - cur
) * itemsize
);
1782 if (array_resize(self
, Py_SIZE(self
) - slicelength
) < 0)
1789 if (needed
!= slicelength
) {
1790 PyErr_Format(PyExc_ValueError
,
1791 "attempt to assign array of size %zd "
1792 "to extended slice of size %zd",
1793 needed
, slicelength
);
1796 for (cur
= start
, i
= 0; i
< slicelength
;
1798 memcpy(self
->ob_item
+ cur
* itemsize
,
1799 other
->ob_item
+ i
* itemsize
,
1806 static PyMappingMethods array_as_mapping
= {
1807 (lenfunc
)array_length
,
1808 (binaryfunc
)array_subscr
,
1809 (objobjargproc
)array_ass_subscr
1812 static const void *emptybuf
= "";
1815 array_buffer_getreadbuf(arrayobject
*self
, Py_ssize_t index
, const void **ptr
)
1818 PyErr_SetString(PyExc_SystemError
,
1819 "Accessing non-existent array segment");
1822 *ptr
= (void *)self
->ob_item
;
1825 return Py_SIZE(self
)*self
->ob_descr
->itemsize
;
1829 array_buffer_getwritebuf(arrayobject
*self
, Py_ssize_t index
, const void **ptr
)
1832 PyErr_SetString(PyExc_SystemError
,
1833 "Accessing non-existent array segment");
1836 *ptr
= (void *)self
->ob_item
;
1839 return Py_SIZE(self
)*self
->ob_descr
->itemsize
;
1843 array_buffer_getsegcount(arrayobject
*self
, Py_ssize_t
*lenp
)
1846 *lenp
= Py_SIZE(self
)*self
->ob_descr
->itemsize
;
1850 static PySequenceMethods array_as_sequence
= {
1851 (lenfunc
)array_length
, /*sq_length*/
1852 (binaryfunc
)array_concat
, /*sq_concat*/
1853 (ssizeargfunc
)array_repeat
, /*sq_repeat*/
1854 (ssizeargfunc
)array_item
, /*sq_item*/
1855 (ssizessizeargfunc
)array_slice
, /*sq_slice*/
1856 (ssizeobjargproc
)array_ass_item
, /*sq_ass_item*/
1857 (ssizessizeobjargproc
)array_ass_slice
, /*sq_ass_slice*/
1858 (objobjproc
)array_contains
, /*sq_contains*/
1859 (binaryfunc
)array_inplace_concat
, /*sq_inplace_concat*/
1860 (ssizeargfunc
)array_inplace_repeat
/*sq_inplace_repeat*/
1863 static PyBufferProcs array_as_buffer
= {
1864 (readbufferproc
)array_buffer_getreadbuf
,
1865 (writebufferproc
)array_buffer_getwritebuf
,
1866 (segcountproc
)array_buffer_getsegcount
,
1871 array_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1874 PyObject
*initial
= NULL
, *it
= NULL
;
1875 struct arraydescr
*descr
;
1877 if (type
== &Arraytype
&& !_PyArg_NoKeywords("array.array()", kwds
))
1880 if (!PyArg_ParseTuple(args
, "c|O:array", &c
, &initial
))
1883 if (!(initial
== NULL
|| PyList_Check(initial
)
1884 || PyString_Check(initial
) || PyTuple_Check(initial
)
1885 || (c
== 'u' && PyUnicode_Check(initial
)))) {
1886 it
= PyObject_GetIter(initial
);
1889 /* We set initial to NULL so that the subsequent code
1890 will create an empty array of the appropriate type
1891 and afterwards we can use array_iter_extend to populate
1896 for (descr
= descriptors
; descr
->typecode
!= '\0'; descr
++) {
1897 if (descr
->typecode
== c
) {
1901 if (initial
== NULL
|| !(PyList_Check(initial
)
1902 || PyTuple_Check(initial
)))
1905 len
= PySequence_Size(initial
);
1907 a
= newarrayobject(type
, len
, descr
);
1913 for (i
= 0; i
< len
; i
++) {
1915 PySequence_GetItem(initial
, i
);
1920 if (setarrayitem(a
, i
, v
) != 0) {
1927 } else if (initial
!= NULL
&& PyString_Check(initial
)) {
1928 PyObject
*t_initial
, *v
;
1929 t_initial
= PyTuple_Pack(1, initial
);
1930 if (t_initial
== NULL
) {
1934 v
= array_fromstring((arrayobject
*)a
,
1936 Py_DECREF(t_initial
);
1942 #ifdef Py_USING_UNICODE
1943 } else if (initial
!= NULL
&& PyUnicode_Check(initial
)) {
1944 Py_ssize_t n
= PyUnicode_GET_DATA_SIZE(initial
);
1946 arrayobject
*self
= (arrayobject
*)a
;
1947 char *item
= self
->ob_item
;
1948 item
= (char *)PyMem_Realloc(item
, n
);
1954 self
->ob_item
= item
;
1955 Py_SIZE(self
) = n
/ sizeof(Py_UNICODE
);
1956 memcpy(item
, PyUnicode_AS_DATA(initial
), n
);
1957 self
->allocated
= Py_SIZE(self
);
1962 if (array_iter_extend((arrayobject
*)a
, it
) == -1) {
1972 PyErr_SetString(PyExc_ValueError
,
1973 "bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)");
1978 PyDoc_STRVAR(module_doc
,
1979 "This module defines an object type which can efficiently represent\n\
1980 an array of basic values: characters, integers, floating point\n\
1981 numbers. Arrays are sequence types and behave very much like lists,\n\
1982 except that the type of objects stored in them is constrained. The\n\
1983 type is specified at object creation time by using a type code, which\n\
1984 is a single character. The following type codes are defined:\n\
1986 Type code C Type Minimum size in bytes \n\
1988 'b' signed integer 1 \n\
1989 'B' unsigned integer 1 \n\
1990 'u' Unicode character 2 \n\
1991 'h' signed integer 2 \n\
1992 'H' unsigned integer 2 \n\
1993 'i' signed integer 2 \n\
1994 'I' unsigned integer 2 \n\
1995 'l' signed integer 4 \n\
1996 'L' unsigned integer 4 \n\
1997 'f' floating point 4 \n\
1998 'd' floating point 8 \n\
2000 The constructor is:\n\
2002 array(typecode [, initializer]) -- create a new array\n\
2005 PyDoc_STRVAR(arraytype_doc
,
2006 "array(typecode [, initializer]) -> array\n\
2008 Return a new array whose items are restricted by typecode, and\n\
2009 initialized from the optional initializer value, which must be a list,\n\
2010 string. or iterable over elements of the appropriate type.\n\
2012 Arrays represent basic values and behave very much like lists, except\n\
2013 the type of objects stored in them is constrained.\n\
2017 append() -- append a new item to the end of the array\n\
2018 buffer_info() -- return information giving the current memory info\n\
2019 byteswap() -- byteswap all the items of the array\n\
2020 count() -- return number of occurences of an object\n\
2021 extend() -- extend array by appending multiple elements from an iterable\n\
2022 fromfile() -- read items from a file object\n\
2023 fromlist() -- append items from the list\n\
2024 fromstring() -- append items from the string\n\
2025 index() -- return index of first occurence of an object\n\
2026 insert() -- insert a new item into the array at a provided position\n\
2027 pop() -- remove and return item (default last)\n\
2028 read() -- DEPRECATED, use fromfile()\n\
2029 remove() -- remove first occurence of an object\n\
2030 reverse() -- reverse the order of the items in the array\n\
2031 tofile() -- write all items to a file object\n\
2032 tolist() -- return the array converted to an ordinary list\n\
2033 tostring() -- return the array converted to a string\n\
2034 write() -- DEPRECATED, use tofile()\n\
2038 typecode -- the typecode character used to create the array\n\
2039 itemsize -- the length in bytes of one array item\n\
2042 static PyObject
*array_iter(arrayobject
*ao
);
2044 static PyTypeObject Arraytype
= {
2045 PyVarObject_HEAD_INIT(NULL
, 0)
2047 sizeof(arrayobject
),
2049 (destructor
)array_dealloc
, /* tp_dealloc */
2054 (reprfunc
)array_repr
, /* tp_repr */
2055 0, /* tp_as_number*/
2056 &array_as_sequence
, /* tp_as_sequence*/
2057 &array_as_mapping
, /* tp_as_mapping*/
2061 PyObject_GenericGetAttr
, /* tp_getattro */
2062 0, /* tp_setattro */
2063 &array_as_buffer
, /* tp_as_buffer*/
2064 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_WEAKREFS
, /* tp_flags */
2065 arraytype_doc
, /* tp_doc */
2066 0, /* tp_traverse */
2068 array_richcompare
, /* tp_richcompare */
2069 offsetof(arrayobject
, weakreflist
), /* tp_weaklistoffset */
2070 (getiterfunc
)array_iter
, /* tp_iter */
2071 0, /* tp_iternext */
2072 array_methods
, /* tp_methods */
2074 array_getsets
, /* tp_getset */
2077 0, /* tp_descr_get */
2078 0, /* tp_descr_set */
2079 0, /* tp_dictoffset */
2081 PyType_GenericAlloc
, /* tp_alloc */
2082 array_new
, /* tp_new */
2083 PyObject_Del
, /* tp_free */
2087 /*********************** Array Iterator **************************/
2093 PyObject
* (*getitem
)(struct arrayobject
*, Py_ssize_t
);
2096 static PyTypeObject PyArrayIter_Type
;
2098 #define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type)
2101 array_iter(arrayobject
*ao
)
2103 arrayiterobject
*it
;
2105 if (!array_Check(ao
)) {
2106 PyErr_BadInternalCall();
2110 it
= PyObject_GC_New(arrayiterobject
, &PyArrayIter_Type
);
2117 it
->getitem
= ao
->ob_descr
->getitem
;
2118 PyObject_GC_Track(it
);
2119 return (PyObject
*)it
;
2123 arrayiter_next(arrayiterobject
*it
)
2125 assert(PyArrayIter_Check(it
));
2126 if (it
->index
< Py_SIZE(it
->ao
))
2127 return (*it
->getitem
)(it
->ao
, it
->index
++);
2132 arrayiter_dealloc(arrayiterobject
*it
)
2134 PyObject_GC_UnTrack(it
);
2136 PyObject_GC_Del(it
);
2140 arrayiter_traverse(arrayiterobject
*it
, visitproc visit
, void *arg
)
2146 static PyTypeObject PyArrayIter_Type
= {
2147 PyVarObject_HEAD_INIT(NULL
, 0)
2148 "arrayiterator", /* tp_name */
2149 sizeof(arrayiterobject
), /* tp_basicsize */
2150 0, /* tp_itemsize */
2152 (destructor
)arrayiter_dealloc
, /* tp_dealloc */
2158 0, /* tp_as_number */
2159 0, /* tp_as_sequence */
2160 0, /* tp_as_mapping */
2164 PyObject_GenericGetAttr
, /* tp_getattro */
2165 0, /* tp_setattro */
2166 0, /* tp_as_buffer */
2167 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_GC
,/* tp_flags */
2169 (traverseproc
)arrayiter_traverse
, /* tp_traverse */
2171 0, /* tp_richcompare */
2172 0, /* tp_weaklistoffset */
2173 PyObject_SelfIter
, /* tp_iter */
2174 (iternextfunc
)arrayiter_next
, /* tp_iternext */
2179 /*********************** Install Module **************************/
2181 /* No functions in array module. */
2182 static PyMethodDef a_methods
[] = {
2183 {NULL
, NULL
, 0, NULL
} /* Sentinel */
2192 Arraytype
.ob_type
= &PyType_Type
;
2193 PyArrayIter_Type
.ob_type
= &PyType_Type
;
2194 m
= Py_InitModule3("array", a_methods
, module_doc
);
2198 Py_INCREF((PyObject
*)&Arraytype
);
2199 PyModule_AddObject(m
, "ArrayType", (PyObject
*)&Arraytype
);
2200 Py_INCREF((PyObject
*)&Arraytype
);
2201 PyModule_AddObject(m
, "array", (PyObject
*)&Arraytype
);
2202 /* No need to check the error here, the caller will do that */