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
*);
32 typedef struct arrayobject
{
36 struct arraydescr
*ob_descr
;
37 PyObject
*weakreflist
; /* List of weak references */
38 int ob_exports
; /* Number of exported buffers */
41 static PyTypeObject Arraytype
;
43 #define array_Check(op) PyObject_TypeCheck(op, &Arraytype)
44 #define array_CheckExact(op) (Py_TYPE(op) == &Arraytype)
47 array_resize(arrayobject
*self
, Py_ssize_t newsize
)
52 if (self
->ob_exports
> 0 && newsize
!= Py_SIZE(self
)) {
53 PyErr_SetString(PyExc_BufferError
,
54 "cannot resize an array that is exporting buffers");
58 /* Bypass realloc() when a previous overallocation is large enough
59 to accommodate the newsize. If the newsize is 16 smaller than the
60 current size, then proceed with the realloc() to shrink the array.
63 if (self
->allocated
>= newsize
&&
64 Py_SIZE(self
) < newsize
+ 16 &&
65 self
->ob_item
!= NULL
) {
66 Py_SIZE(self
) = newsize
;
71 PyMem_FREE(self
->ob_item
);
78 /* This over-allocates proportional to the array size, making room
79 * for additional growth. The over-allocation is mild, but is
80 * enough to give linear-time amortized behavior over a long
81 * sequence of appends() in the presence of a poorly-performing
83 * The growth pattern is: 0, 4, 8, 16, 25, 34, 46, 56, 67, 79, ...
84 * Note, the pattern starts out the same as for lists but then
85 * grows at a smaller rate so that larger arrays only overallocate
86 * by about 1/16th -- this is done because arrays are presumed to be more
90 _new_size
= (newsize
>> 4) + (Py_SIZE(self
) < 8 ? 3 : 7) + newsize
;
91 items
= self
->ob_item
;
92 /* XXX The following multiplication and division does not optimize away
93 like it does for lists since the size is not known at compile time */
94 if (_new_size
<= ((~(size_t)0) / self
->ob_descr
->itemsize
))
95 PyMem_RESIZE(items
, char, (_new_size
* self
->ob_descr
->itemsize
));
102 self
->ob_item
= items
;
103 Py_SIZE(self
) = newsize
;
104 self
->allocated
= _new_size
;
108 /****************************************************************************
109 Get and Set functions for each type.
110 A Get function takes an arrayobject* and an integer index, returning the
111 array value at that index wrapped in an appropriate PyObject*.
112 A Set function takes an arrayobject, integer index, and PyObject*; sets
113 the array value at that index to the raw C data extracted from the PyObject*,
114 and returns 0 if successful, else nonzero on failure (PyObject* not of an
115 appropriate type or value).
116 Note that the basic Get and Set functions do NOT check that the index is
117 in bounds; that's the responsibility of the caller.
118 ****************************************************************************/
121 b_getitem(arrayobject
*ap
, Py_ssize_t i
)
123 long x
= ((char *)ap
->ob_item
)[i
];
126 return PyLong_FromLong(x
);
130 b_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
133 /* PyArg_Parse's 'b' formatter is for an unsigned char, therefore
134 must use the next size up that is signed ('h') and manually do
135 the overflow checking */
136 if (!PyArg_Parse(v
, "h;array item must be integer", &x
))
139 PyErr_SetString(PyExc_OverflowError
,
140 "signed char is less than minimum");
144 PyErr_SetString(PyExc_OverflowError
,
145 "signed char is greater than maximum");
149 ((char *)ap
->ob_item
)[i
] = (char)x
;
154 BB_getitem(arrayobject
*ap
, Py_ssize_t i
)
156 long x
= ((unsigned char *)ap
->ob_item
)[i
];
157 return PyLong_FromLong(x
);
161 BB_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
164 /* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */
165 if (!PyArg_Parse(v
, "b;array item must be integer", &x
))
168 ((char *)ap
->ob_item
)[i
] = x
;
173 u_getitem(arrayobject
*ap
, Py_ssize_t i
)
175 return PyUnicode_FromUnicode(&((Py_UNICODE
*) ap
->ob_item
)[i
], 1);
179 u_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
184 if (!PyArg_Parse(v
, "u#;array item must be unicode character", &p
, &len
))
187 PyErr_SetString(PyExc_TypeError
,
188 "array item must be unicode character");
192 ((Py_UNICODE
*)ap
->ob_item
)[i
] = p
[0];
198 h_getitem(arrayobject
*ap
, Py_ssize_t i
)
200 return PyLong_FromLong((long) ((short *)ap
->ob_item
)[i
]);
205 h_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
208 /* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */
209 if (!PyArg_Parse(v
, "h;array item must be integer", &x
))
212 ((short *)ap
->ob_item
)[i
] = x
;
217 HH_getitem(arrayobject
*ap
, Py_ssize_t i
)
219 return PyLong_FromLong((long) ((unsigned short *)ap
->ob_item
)[i
]);
223 HH_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
226 /* PyArg_Parse's 'h' formatter is for a signed short, therefore
227 must use the next size up and manually do the overflow checking */
228 if (!PyArg_Parse(v
, "i;array item must be integer", &x
))
231 PyErr_SetString(PyExc_OverflowError
,
232 "unsigned short is less than minimum");
235 else if (x
> USHRT_MAX
) {
236 PyErr_SetString(PyExc_OverflowError
,
237 "unsigned short is greater than maximum");
241 ((short *)ap
->ob_item
)[i
] = (short)x
;
246 i_getitem(arrayobject
*ap
, Py_ssize_t i
)
248 return PyLong_FromLong((long) ((int *)ap
->ob_item
)[i
]);
252 i_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
255 /* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */
256 if (!PyArg_Parse(v
, "i;array item must be integer", &x
))
259 ((int *)ap
->ob_item
)[i
] = x
;
264 II_getitem(arrayobject
*ap
, Py_ssize_t i
)
266 return PyLong_FromUnsignedLong(
267 (unsigned long) ((unsigned int *)ap
->ob_item
)[i
]);
271 II_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
274 if (PyLong_Check(v
)) {
275 x
= PyLong_AsUnsignedLong(v
);
276 if (x
== (unsigned long) -1 && PyErr_Occurred())
281 if (!PyArg_Parse(v
, "l;array item must be integer", &y
))
284 PyErr_SetString(PyExc_OverflowError
,
285 "unsigned int is less than minimum");
288 x
= (unsigned long)y
;
292 PyErr_SetString(PyExc_OverflowError
,
293 "unsigned int is greater than maximum");
298 ((unsigned int *)ap
->ob_item
)[i
] = (unsigned int)x
;
303 l_getitem(arrayobject
*ap
, Py_ssize_t i
)
305 return PyLong_FromLong(((long *)ap
->ob_item
)[i
]);
309 l_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
312 if (!PyArg_Parse(v
, "l;array item must be integer", &x
))
315 ((long *)ap
->ob_item
)[i
] = x
;
320 LL_getitem(arrayobject
*ap
, Py_ssize_t i
)
322 return PyLong_FromUnsignedLong(((unsigned long *)ap
->ob_item
)[i
]);
326 LL_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
329 if (PyLong_Check(v
)) {
330 x
= PyLong_AsUnsignedLong(v
);
331 if (x
== (unsigned long) -1 && PyErr_Occurred())
336 if (!PyArg_Parse(v
, "l;array item must be integer", &y
))
339 PyErr_SetString(PyExc_OverflowError
,
340 "unsigned long is less than minimum");
343 x
= (unsigned long)y
;
347 PyErr_SetString(PyExc_OverflowError
,
348 "unsigned long is greater than maximum");
353 ((unsigned long *)ap
->ob_item
)[i
] = x
;
358 f_getitem(arrayobject
*ap
, Py_ssize_t i
)
360 return PyFloat_FromDouble((double) ((float *)ap
->ob_item
)[i
]);
364 f_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
367 if (!PyArg_Parse(v
, "f;array item must be float", &x
))
370 ((float *)ap
->ob_item
)[i
] = x
;
375 d_getitem(arrayobject
*ap
, Py_ssize_t i
)
377 return PyFloat_FromDouble(((double *)ap
->ob_item
)[i
]);
381 d_setitem(arrayobject
*ap
, Py_ssize_t i
, PyObject
*v
)
384 if (!PyArg_Parse(v
, "d;array item must be float", &x
))
387 ((double *)ap
->ob_item
)[i
] = x
;
392 /* Description of types */
393 static struct arraydescr descriptors
[] = {
394 {'b', 1, b_getitem
, b_setitem
, "b"},
395 {'B', 1, BB_getitem
, BB_setitem
, "B"},
396 {'u', sizeof(Py_UNICODE
), u_getitem
, u_setitem
, "u"},
397 {'h', sizeof(short), h_getitem
, h_setitem
, "h"},
398 {'H', sizeof(short), HH_getitem
, HH_setitem
, "H"},
399 {'i', sizeof(int), i_getitem
, i_setitem
, "i"},
400 {'I', sizeof(int), II_getitem
, II_setitem
, "I"},
401 {'l', sizeof(long), l_getitem
, l_setitem
, "l"},
402 {'L', sizeof(long), LL_getitem
, LL_setitem
, "L"},
403 {'f', sizeof(float), f_getitem
, f_setitem
, "f"},
404 {'d', sizeof(double), d_getitem
, d_setitem
, "d"},
405 {'\0', 0, 0, 0, 0} /* Sentinel */
408 /****************************************************************************
409 Implementations of array object methods.
410 ****************************************************************************/
413 newarrayobject(PyTypeObject
*type
, Py_ssize_t size
, struct arraydescr
*descr
)
419 PyErr_BadInternalCall();
423 nbytes
= size
* descr
->itemsize
;
424 /* Check for overflow */
425 if (nbytes
/ descr
->itemsize
!= (size_t)size
) {
426 return PyErr_NoMemory();
428 op
= (arrayobject
*) type
->tp_alloc(type
, 0);
432 op
->ob_descr
= descr
;
433 op
->allocated
= size
;
434 op
->weakreflist
= NULL
;
440 op
->ob_item
= PyMem_NEW(char, nbytes
);
441 if (op
->ob_item
== NULL
) {
443 return PyErr_NoMemory();
447 return (PyObject
*) op
;
451 getarrayitem(PyObject
*op
, Py_ssize_t i
)
453 register arrayobject
*ap
;
454 assert(array_Check(op
));
455 ap
= (arrayobject
*)op
;
456 assert(i
>=0 && i
<Py_SIZE(ap
));
457 return (*ap
->ob_descr
->getitem
)(ap
, i
);
461 ins1(arrayobject
*self
, Py_ssize_t where
, PyObject
*v
)
464 Py_ssize_t n
= Py_SIZE(self
);
466 PyErr_BadInternalCall();
469 if ((*self
->ob_descr
->setitem
)(self
, -1, v
) < 0)
472 if (array_resize(self
, n
+1) == -1)
474 items
= self
->ob_item
;
482 /* appends don't need to call memmove() */
484 memmove(items
+ (where
+1)*self
->ob_descr
->itemsize
,
485 items
+ where
*self
->ob_descr
->itemsize
,
486 (n
-where
)*self
->ob_descr
->itemsize
);
487 return (*self
->ob_descr
->setitem
)(self
, where
, v
);
493 array_dealloc(arrayobject
*op
)
495 if (op
->weakreflist
!= NULL
)
496 PyObject_ClearWeakRefs((PyObject
*) op
);
497 if (op
->ob_item
!= NULL
)
498 PyMem_DEL(op
->ob_item
);
499 Py_TYPE(op
)->tp_free((PyObject
*)op
);
503 array_richcompare(PyObject
*v
, PyObject
*w
, int op
)
505 arrayobject
*va
, *wa
;
511 if (!array_Check(v
) || !array_Check(w
)) {
512 Py_INCREF(Py_NotImplemented
);
513 return Py_NotImplemented
;
516 va
= (arrayobject
*)v
;
517 wa
= (arrayobject
*)w
;
519 if (Py_SIZE(va
) != Py_SIZE(wa
) && (op
== Py_EQ
|| op
== Py_NE
)) {
520 /* Shortcut: if the lengths differ, the arrays differ */
529 /* Search for the first index where items are different */
531 for (i
= 0; i
< Py_SIZE(va
) && i
< Py_SIZE(wa
); i
++) {
532 vi
= getarrayitem(v
, i
);
533 wi
= getarrayitem(w
, i
);
534 if (vi
== NULL
|| wi
== NULL
) {
539 k
= PyObject_RichCompareBool(vi
, wi
, Py_EQ
);
541 break; /* Keeping vi and wi alive! */
549 /* No more items to compare -- compare sizes */
550 Py_ssize_t vs
= Py_SIZE(va
);
551 Py_ssize_t ws
= Py_SIZE(wa
);
554 case Py_LT
: cmp
= vs
< ws
; break;
555 case Py_LE
: cmp
= vs
<= ws
; break;
556 case Py_EQ
: cmp
= vs
== ws
; break;
557 case Py_NE
: cmp
= vs
!= ws
; break;
558 case Py_GT
: cmp
= vs
> ws
; break;
559 case Py_GE
: cmp
= vs
>= ws
; break;
560 default: return NULL
; /* cannot happen */
570 /* We have an item that differs. First, shortcuts for EQ/NE */
575 else if (op
== Py_NE
) {
580 /* Compare the final item again using the proper operator */
581 res
= PyObject_RichCompare(vi
, wi
, op
);
589 array_length(arrayobject
*a
)
595 array_item(arrayobject
*a
, Py_ssize_t i
)
597 if (i
< 0 || i
>= Py_SIZE(a
)) {
598 PyErr_SetString(PyExc_IndexError
, "array index out of range");
601 return getarrayitem((PyObject
*)a
, i
);
605 array_slice(arrayobject
*a
, Py_ssize_t ilow
, Py_ssize_t ihigh
)
610 else if (ilow
> Py_SIZE(a
))
616 else if (ihigh
> Py_SIZE(a
))
618 np
= (arrayobject
*) newarrayobject(&Arraytype
, ihigh
- ilow
, a
->ob_descr
);
621 memcpy(np
->ob_item
, a
->ob_item
+ ilow
* a
->ob_descr
->itemsize
,
622 (ihigh
-ilow
) * a
->ob_descr
->itemsize
);
623 return (PyObject
*)np
;
627 array_copy(arrayobject
*a
, PyObject
*unused
)
629 return array_slice(a
, 0, Py_SIZE(a
));
632 PyDoc_STRVAR(copy_doc
,
635 Return a copy of the array.");
638 array_concat(arrayobject
*a
, PyObject
*bb
)
642 if (!array_Check(bb
)) {
643 PyErr_Format(PyExc_TypeError
,
644 "can only append array (not \"%.200s\") to array",
645 Py_TYPE(bb
)->tp_name
);
648 #define b ((arrayobject *)bb)
649 if (a
->ob_descr
!= b
->ob_descr
) {
653 if (Py_SIZE(a
) > PY_SSIZE_T_MAX
- Py_SIZE(b
)) {
654 return PyErr_NoMemory();
656 size
= Py_SIZE(a
) + Py_SIZE(b
);
657 np
= (arrayobject
*) newarrayobject(&Arraytype
, size
, a
->ob_descr
);
661 memcpy(np
->ob_item
, a
->ob_item
, Py_SIZE(a
)*a
->ob_descr
->itemsize
);
662 memcpy(np
->ob_item
+ Py_SIZE(a
)*a
->ob_descr
->itemsize
,
663 b
->ob_item
, Py_SIZE(b
)*b
->ob_descr
->itemsize
);
664 return (PyObject
*)np
;
669 array_repeat(arrayobject
*a
, Py_ssize_t n
)
678 if ((Py_SIZE(a
) != 0) && (n
> PY_SSIZE_T_MAX
/ Py_SIZE(a
))) {
679 return PyErr_NoMemory();
681 size
= Py_SIZE(a
) * n
;
682 np
= (arrayobject
*) newarrayobject(&Arraytype
, size
, a
->ob_descr
);
686 nbytes
= Py_SIZE(a
) * a
->ob_descr
->itemsize
;
687 for (i
= 0; i
< n
; i
++) {
688 memcpy(p
, a
->ob_item
, nbytes
);
691 return (PyObject
*) np
;
695 array_ass_slice(arrayobject
*a
, Py_ssize_t ilow
, Py_ssize_t ihigh
, PyObject
*v
)
698 Py_ssize_t n
; /* Size of replacement array */
699 Py_ssize_t d
; /* Change in size */
700 #define b ((arrayobject *)v)
703 else if (array_Check(v
)) {
706 /* Special case "a[i:j] = a" -- copy b first */
708 v
= array_slice(b
, 0, n
);
711 ret
= array_ass_slice(a
, ilow
, ihigh
, v
);
715 if (b
->ob_descr
!= a
->ob_descr
) {
721 PyErr_Format(PyExc_TypeError
,
722 "can only assign array (not \"%.200s\") to array slice",
723 Py_TYPE(v
)->tp_name
);
728 else if (ilow
> Py_SIZE(a
))
734 else if (ihigh
> Py_SIZE(a
))
737 d
= n
- (ihigh
-ilow
);
738 /* Issue #4509: If the array has exported buffers and the slice
739 assignment would change the size of the array, fail early to make
740 sure we don't modify it. */
741 if (d
!= 0 && a
->ob_exports
> 0) {
742 PyErr_SetString(PyExc_BufferError
,
743 "cannot resize an array that is exporting buffers");
746 if (d
< 0) { /* Delete -d items */
747 memmove(item
+ (ihigh
+d
)*a
->ob_descr
->itemsize
,
748 item
+ ihigh
*a
->ob_descr
->itemsize
,
749 (Py_SIZE(a
)-ihigh
)*a
->ob_descr
->itemsize
);
750 if (array_resize(a
, Py_SIZE(a
) + d
) == -1)
753 else if (d
> 0) { /* Insert d items */
754 if (array_resize(a
, Py_SIZE(a
) + d
))
756 memmove(item
+ (ihigh
+d
)*a
->ob_descr
->itemsize
,
757 item
+ ihigh
*a
->ob_descr
->itemsize
,
758 (Py_SIZE(a
)-ihigh
)*a
->ob_descr
->itemsize
);
761 memcpy(item
+ ilow
*a
->ob_descr
->itemsize
, b
->ob_item
,
762 n
*b
->ob_descr
->itemsize
);
768 array_ass_item(arrayobject
*a
, Py_ssize_t i
, PyObject
*v
)
770 if (i
< 0 || i
>= Py_SIZE(a
)) {
771 PyErr_SetString(PyExc_IndexError
,
772 "array assignment index out of range");
776 return array_ass_slice(a
, i
, i
+1, v
);
777 return (*a
->ob_descr
->setitem
)(a
, i
, v
);
781 setarrayitem(PyObject
*a
, Py_ssize_t i
, PyObject
*v
)
783 assert(array_Check(a
));
784 return array_ass_item((arrayobject
*)a
, i
, v
);
788 array_iter_extend(arrayobject
*self
, PyObject
*bb
)
792 it
= PyObject_GetIter(bb
);
796 while ((v
= PyIter_Next(it
)) != NULL
) {
797 if (ins1(self
, (int) Py_SIZE(self
), v
) != 0) {
805 if (PyErr_Occurred())
811 array_do_extend(arrayobject
*self
, PyObject
*bb
)
813 Py_ssize_t size
, oldsize
, bbsize
;
815 if (!array_Check(bb
))
816 return array_iter_extend(self
, bb
);
817 #define b ((arrayobject *)bb)
818 if (self
->ob_descr
!= b
->ob_descr
) {
819 PyErr_SetString(PyExc_TypeError
,
820 "can only extend with array of same kind");
823 if ((Py_SIZE(self
) > PY_SSIZE_T_MAX
- Py_SIZE(b
)) ||
824 ((Py_SIZE(self
) + Py_SIZE(b
)) > PY_SSIZE_T_MAX
/ self
->ob_descr
->itemsize
)) {
828 oldsize
= Py_SIZE(self
);
829 /* Get the size of bb before resizing the array since bb could be self. */
830 bbsize
= Py_SIZE(bb
);
831 size
= oldsize
+ Py_SIZE(b
);
832 if (array_resize(self
, size
) == -1)
834 memcpy(self
->ob_item
+ oldsize
* self
->ob_descr
->itemsize
,
835 b
->ob_item
, bbsize
* b
->ob_descr
->itemsize
);
842 array_inplace_concat(arrayobject
*self
, PyObject
*bb
)
844 if (!array_Check(bb
)) {
845 PyErr_Format(PyExc_TypeError
,
846 "can only extend array with array (not \"%.200s\")",
847 Py_TYPE(bb
)->tp_name
);
850 if (array_do_extend(self
, bb
) == -1)
853 return (PyObject
*)self
;
857 array_inplace_repeat(arrayobject
*self
, Py_ssize_t n
)
862 if (Py_SIZE(self
) > 0) {
865 items
= self
->ob_item
;
866 if ((self
->ob_descr
->itemsize
!= 0) &&
867 (Py_SIZE(self
) > PY_SSIZE_T_MAX
/ self
->ob_descr
->itemsize
)) {
868 return PyErr_NoMemory();
870 size
= Py_SIZE(self
) * self
->ob_descr
->itemsize
;
871 if (n
> 0 && size
> PY_SSIZE_T_MAX
/ n
) {
872 return PyErr_NoMemory();
874 if (array_resize(self
, n
* Py_SIZE(self
)) == -1)
876 items
= p
= self
->ob_item
;
877 for (i
= 1; i
< n
; i
++) {
879 memcpy(p
, items
, size
);
883 return (PyObject
*)self
;
888 ins(arrayobject
*self
, Py_ssize_t where
, PyObject
*v
)
890 if (ins1(self
, where
, v
) != 0)
897 array_count(arrayobject
*self
, PyObject
*v
)
899 Py_ssize_t count
= 0;
902 for (i
= 0; i
< Py_SIZE(self
); i
++) {
903 PyObject
*selfi
= getarrayitem((PyObject
*)self
, i
);
904 int cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
911 return PyLong_FromSsize_t(count
);
914 PyDoc_STRVAR(count_doc
,
917 Return number of occurrences of x in the array.");
920 array_index(arrayobject
*self
, PyObject
*v
)
924 for (i
= 0; i
< Py_SIZE(self
); i
++) {
925 PyObject
*selfi
= getarrayitem((PyObject
*)self
, i
);
926 int cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
929 return PyLong_FromLong((long)i
);
934 PyErr_SetString(PyExc_ValueError
, "array.index(x): x not in list");
938 PyDoc_STRVAR(index_doc
,
941 Return index of first occurrence of x in the array.");
944 array_contains(arrayobject
*self
, PyObject
*v
)
949 for (i
= 0, cmp
= 0 ; cmp
== 0 && i
< Py_SIZE(self
); i
++) {
950 PyObject
*selfi
= getarrayitem((PyObject
*)self
, i
);
951 cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
958 array_remove(arrayobject
*self
, PyObject
*v
)
962 for (i
= 0; i
< Py_SIZE(self
); i
++) {
963 PyObject
*selfi
= getarrayitem((PyObject
*)self
,i
);
964 int cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
967 if (array_ass_slice(self
, i
, i
+1,
968 (PyObject
*)NULL
) != 0)
976 PyErr_SetString(PyExc_ValueError
, "array.remove(x): x not in list");
980 PyDoc_STRVAR(remove_doc
,
983 Remove the first occurrence of x in the array.");
986 array_pop(arrayobject
*self
, PyObject
*args
)
990 if (!PyArg_ParseTuple(args
, "|n:pop", &i
))
992 if (Py_SIZE(self
) == 0) {
993 /* Special-case most common failure cause */
994 PyErr_SetString(PyExc_IndexError
, "pop from empty array");
999 if (i
< 0 || i
>= Py_SIZE(self
)) {
1000 PyErr_SetString(PyExc_IndexError
, "pop index out of range");
1003 v
= getarrayitem((PyObject
*)self
,i
);
1004 if (array_ass_slice(self
, i
, i
+1, (PyObject
*)NULL
) != 0) {
1011 PyDoc_STRVAR(pop_doc
,
1014 Return the i-th element and delete it from the array. i defaults to -1.");
1017 array_extend(arrayobject
*self
, PyObject
*bb
)
1019 if (array_do_extend(self
, bb
) == -1)
1025 PyDoc_STRVAR(extend_doc
,
1026 "extend(array or iterable)\n\
1028 Append items to the end of the array.");
1031 array_insert(arrayobject
*self
, PyObject
*args
)
1035 if (!PyArg_ParseTuple(args
, "nO:insert", &i
, &v
))
1037 return ins(self
, i
, v
);
1040 PyDoc_STRVAR(insert_doc
,
1043 Insert a new item x into the array before position i.");
1047 array_buffer_info(arrayobject
*self
, PyObject
*unused
)
1049 PyObject
* retval
= NULL
;
1050 retval
= PyTuple_New(2);
1054 PyTuple_SET_ITEM(retval
, 0, PyLong_FromVoidPtr(self
->ob_item
));
1055 PyTuple_SET_ITEM(retval
, 1, PyLong_FromLong((long)(Py_SIZE(self
))));
1060 PyDoc_STRVAR(buffer_info_doc
,
1061 "buffer_info() -> (address, length)\n\
1063 Return a tuple (address, length) giving the current memory address and\n\
1064 the length in items of the buffer used to hold array's contents\n\
1065 The length should be multiplied by the itemsize attribute to calculate\n\
1066 the buffer length in bytes.");
1070 array_append(arrayobject
*self
, PyObject
*v
)
1072 return ins(self
, (int) Py_SIZE(self
), v
);
1075 PyDoc_STRVAR(append_doc
,
1078 Append new value x to the end of the array.");
1082 array_byteswap(arrayobject
*self
, PyObject
*unused
)
1087 switch (self
->ob_descr
->itemsize
) {
1091 for (p
= self
->ob_item
, i
= Py_SIZE(self
); --i
>= 0; p
+= 2) {
1098 for (p
= self
->ob_item
, i
= Py_SIZE(self
); --i
>= 0; p
+= 4) {
1108 for (p
= self
->ob_item
, i
= Py_SIZE(self
); --i
>= 0; p
+= 8) {
1124 PyErr_SetString(PyExc_RuntimeError
,
1125 "don't know how to byteswap this array type");
1132 PyDoc_STRVAR(byteswap_doc
,
1135 Byteswap all items of the array. If the items in the array are not 1, 2,\n\
1136 4, or 8 bytes in size, RuntimeError is raised.");
1139 array_reduce(arrayobject
*array
)
1141 PyObject
*dict
, *result
;
1143 dict
= PyObject_GetAttrString((PyObject
*)array
, "__dict__");
1149 if (Py_SIZE(array
) > 0) {
1150 if (array
->ob_descr
->itemsize
1151 > PY_SSIZE_T_MAX
/ Py_SIZE(array
)) {
1152 return PyErr_NoMemory();
1154 result
= Py_BuildValue("O(Cy#)O",
1156 array
->ob_descr
->typecode
,
1158 Py_SIZE(array
) * array
->ob_descr
->itemsize
,
1161 result
= Py_BuildValue("O(C)O",
1163 array
->ob_descr
->typecode
,
1170 PyDoc_STRVAR(array_doc
, "Return state information for pickling.");
1173 array_reverse(arrayobject
*self
, PyObject
*unused
)
1175 register Py_ssize_t itemsize
= self
->ob_descr
->itemsize
;
1176 register char *p
, *q
;
1177 /* little buffer to hold items while swapping */
1178 char tmp
[256]; /* 8 is probably enough -- but why skimp */
1179 assert((size_t)itemsize
<= sizeof(tmp
));
1181 if (Py_SIZE(self
) > 1) {
1182 for (p
= self
->ob_item
,
1183 q
= self
->ob_item
+ (Py_SIZE(self
) - 1)*itemsize
;
1185 p
+= itemsize
, q
-= itemsize
) {
1186 /* memory areas guaranteed disjoint, so memcpy
1187 * is safe (& memmove may be slower).
1189 memcpy(tmp
, p
, itemsize
);
1190 memcpy(p
, q
, itemsize
);
1191 memcpy(q
, tmp
, itemsize
);
1199 PyDoc_STRVAR(reverse_doc
,
1202 Reverse the order of the items in the array.");
1206 static PyObject
*array_fromstring(arrayobject
*self
, PyObject
*args
);
1209 array_fromfile(arrayobject
*self
, PyObject
*args
)
1211 PyObject
*f
, *b
, *res
;
1212 Py_ssize_t itemsize
= self
->ob_descr
->itemsize
;
1213 Py_ssize_t n
, nbytes
;
1214 int not_enough_bytes
;
1216 if (!PyArg_ParseTuple(args
, "On:fromfile", &f
, &n
))
1219 nbytes
= n
* itemsize
;
1220 if (nbytes
< 0 || nbytes
/itemsize
!= n
) {
1225 b
= PyObject_CallMethod(f
, "read", "n", nbytes
);
1229 if (!PyBytes_Check(b
)) {
1230 PyErr_SetString(PyExc_TypeError
,
1231 "read() didn't return bytes");
1236 not_enough_bytes
= (PyBytes_GET_SIZE(b
) != nbytes
);
1238 args
= Py_BuildValue("(O)", b
);
1243 res
= array_fromstring(self
, args
);
1248 if (not_enough_bytes
) {
1249 PyErr_SetString(PyExc_EOFError
,
1250 "read() didn't return enough bytes");
1258 PyDoc_STRVAR(fromfile_doc
,
1261 Read n objects from the file object f and append them to the end of the\n\
1266 array_tofile(arrayobject
*self
, PyObject
*f
)
1268 Py_ssize_t nbytes
= Py_SIZE(self
) * self
->ob_descr
->itemsize
;
1269 /* Write 64K blocks at a time */
1270 /* XXX Make the block size settable */
1271 int BLOCKSIZE
= 64*1024;
1272 Py_ssize_t nblocks
= (nbytes
+ BLOCKSIZE
- 1) / BLOCKSIZE
;
1275 if (Py_SIZE(self
) == 0)
1278 for (i
= 0; i
< nblocks
; i
++) {
1279 char* ptr
= self
->ob_item
+ i
*BLOCKSIZE
;
1280 Py_ssize_t size
= BLOCKSIZE
;
1281 PyObject
*bytes
, *res
;
1282 if (i
*BLOCKSIZE
+ size
> nbytes
)
1283 size
= nbytes
- i
*BLOCKSIZE
;
1284 bytes
= PyBytes_FromStringAndSize(ptr
, size
);
1287 res
= PyObject_CallMethod(f
, "write", "O", bytes
);
1291 Py_DECREF(res
); /* drop write result */
1299 PyDoc_STRVAR(tofile_doc
,
1302 Write all items (as machine values) to the file object f.");
1306 array_fromlist(arrayobject
*self
, PyObject
*list
)
1310 if (!PyList_Check(list
)) {
1311 PyErr_SetString(PyExc_TypeError
, "arg must be list");
1314 n
= PyList_Size(list
);
1316 Py_ssize_t i
, old_size
;
1317 old_size
= Py_SIZE(self
);
1318 if (array_resize(self
, old_size
+ n
) == -1)
1320 for (i
= 0; i
< n
; i
++) {
1321 PyObject
*v
= PyList_GetItem(list
, i
);
1322 if ((*self
->ob_descr
->setitem
)(self
,
1323 Py_SIZE(self
) - n
+ i
, v
) != 0) {
1324 array_resize(self
, old_size
);
1333 PyDoc_STRVAR(fromlist_doc
,
1336 Append items to array from list.");
1339 array_tolist(arrayobject
*self
, PyObject
*unused
)
1341 PyObject
*list
= PyList_New(Py_SIZE(self
));
1346 for (i
= 0; i
< Py_SIZE(self
); i
++) {
1347 PyObject
*v
= getarrayitem((PyObject
*)self
, i
);
1352 PyList_SetItem(list
, i
, v
);
1357 PyDoc_STRVAR(tolist_doc
,
1358 "tolist() -> list\n\
1360 Convert array to an ordinary list with the same items.");
1364 array_fromstring(arrayobject
*self
, PyObject
*args
)
1368 int itemsize
= self
->ob_descr
->itemsize
;
1369 if (!PyArg_ParseTuple(args
, "s#:fromstring", &str
, &n
))
1371 if (n
% itemsize
!= 0) {
1372 PyErr_SetString(PyExc_ValueError
,
1373 "string length not a multiple of item size");
1378 Py_ssize_t old_size
= Py_SIZE(self
);
1379 if ((n
> PY_SSIZE_T_MAX
- old_size
) ||
1380 ((old_size
+ n
) > PY_SSIZE_T_MAX
/ itemsize
)) {
1381 return PyErr_NoMemory();
1383 if (array_resize(self
, old_size
+ n
) == -1)
1385 memcpy(self
->ob_item
+ old_size
* itemsize
,
1392 PyDoc_STRVAR(fromstring_doc
,
1393 "fromstring(string)\n\
1395 Appends items from the string, interpreting it as an array of machine\n\
1396 values, as if it had been read from a file using the fromfile() method).");
1400 array_tostring(arrayobject
*self
, PyObject
*unused
)
1402 if (Py_SIZE(self
) <= PY_SSIZE_T_MAX
/ self
->ob_descr
->itemsize
) {
1403 return PyBytes_FromStringAndSize(self
->ob_item
,
1404 Py_SIZE(self
) * self
->ob_descr
->itemsize
);
1406 return PyErr_NoMemory();
1410 PyDoc_STRVAR(tostring_doc
,
1411 "tostring() -> string\n\
1413 Convert the array to an array of machine values and return the string\n\
1419 array_fromunicode(arrayobject
*self
, PyObject
*args
)
1425 if (!PyArg_ParseTuple(args
, "u#:fromunicode", &ustr
, &n
))
1427 typecode
= self
->ob_descr
->typecode
;
1428 if ((typecode
!= 'u')) {
1429 PyErr_SetString(PyExc_ValueError
,
1430 "fromunicode() may only be called on "
1431 "unicode type arrays");
1435 Py_ssize_t old_size
= Py_SIZE(self
);
1436 if (array_resize(self
, old_size
+ n
) == -1)
1438 memcpy(self
->ob_item
+ old_size
* sizeof(Py_UNICODE
),
1439 ustr
, n
* sizeof(Py_UNICODE
));
1446 PyDoc_STRVAR(fromunicode_doc
,
1447 "fromunicode(ustr)\n\
1449 Extends this array with data from the unicode string ustr.\n\
1450 The array must be a unicode type array; otherwise a ValueError\n\
1451 is raised. Use array.fromstring(ustr.decode(...)) to\n\
1452 append Unicode data to an array of some other type.");
1456 array_tounicode(arrayobject
*self
, PyObject
*unused
)
1459 typecode
= self
->ob_descr
->typecode
;
1460 if ((typecode
!= 'u')) {
1461 PyErr_SetString(PyExc_ValueError
,
1462 "tounicode() may only be called on unicode type arrays");
1465 return PyUnicode_FromUnicode((Py_UNICODE
*) self
->ob_item
, Py_SIZE(self
));
1468 PyDoc_STRVAR(tounicode_doc
,
1469 "tounicode() -> unicode\n\
1471 Convert the array to a unicode string. The array must be\n\
1472 a unicode type array; otherwise a ValueError is raised. Use\n\
1473 array.tostring().decode() to obtain a unicode string from\n\
1474 an array of some other type.");
1479 array_get_typecode(arrayobject
*a
, void *closure
)
1481 char tc
= a
->ob_descr
->typecode
;
1482 return PyUnicode_FromStringAndSize(&tc
, 1);
1486 array_get_itemsize(arrayobject
*a
, void *closure
)
1488 return PyLong_FromLong((long)a
->ob_descr
->itemsize
);
1491 static PyGetSetDef array_getsets
[] = {
1492 {"typecode", (getter
) array_get_typecode
, NULL
,
1493 "the typecode character used to create the array"},
1494 {"itemsize", (getter
) array_get_itemsize
, NULL
,
1495 "the size, in bytes, of one array item"},
1499 static PyMethodDef array_methods
[] = {
1500 {"append", (PyCFunction
)array_append
, METH_O
,
1502 {"buffer_info", (PyCFunction
)array_buffer_info
, METH_NOARGS
,
1504 {"byteswap", (PyCFunction
)array_byteswap
, METH_NOARGS
,
1506 {"__copy__", (PyCFunction
)array_copy
, METH_NOARGS
,
1508 {"count", (PyCFunction
)array_count
, METH_O
,
1510 {"__deepcopy__",(PyCFunction
)array_copy
, METH_O
,
1512 {"extend", (PyCFunction
)array_extend
, METH_O
,
1514 {"fromfile", (PyCFunction
)array_fromfile
, METH_VARARGS
,
1516 {"fromlist", (PyCFunction
)array_fromlist
, METH_O
,
1518 {"fromstring", (PyCFunction
)array_fromstring
, METH_VARARGS
,
1520 {"fromunicode", (PyCFunction
)array_fromunicode
, METH_VARARGS
,
1522 {"index", (PyCFunction
)array_index
, METH_O
,
1524 {"insert", (PyCFunction
)array_insert
, METH_VARARGS
,
1526 {"pop", (PyCFunction
)array_pop
, METH_VARARGS
,
1528 {"__reduce__", (PyCFunction
)array_reduce
, METH_NOARGS
,
1530 {"remove", (PyCFunction
)array_remove
, METH_O
,
1532 {"reverse", (PyCFunction
)array_reverse
, METH_NOARGS
,
1534 /* {"sort", (PyCFunction)array_sort, METH_VARARGS,
1536 {"tofile", (PyCFunction
)array_tofile
, METH_O
,
1538 {"tolist", (PyCFunction
)array_tolist
, METH_NOARGS
,
1540 {"tostring", (PyCFunction
)array_tostring
, METH_NOARGS
,
1542 {"tounicode", (PyCFunction
)array_tounicode
, METH_NOARGS
,
1544 {NULL
, NULL
} /* sentinel */
1548 array_repr(arrayobject
*a
)
1551 PyObject
*s
, *v
= NULL
;
1555 typecode
= a
->ob_descr
->typecode
;
1557 return PyUnicode_FromFormat("array('%c')", typecode
);
1559 if ((typecode
== 'u'))
1560 v
= array_tounicode(a
, NULL
);
1562 v
= array_tolist(a
, NULL
);
1564 s
= PyUnicode_FromFormat("array('%c', %R)", typecode
, v
);
1570 array_subscr(arrayobject
* self
, PyObject
* item
)
1572 if (PyIndex_Check(item
)) {
1573 Py_ssize_t i
= PyNumber_AsSsize_t(item
, PyExc_IndexError
);
1574 if (i
==-1 && PyErr_Occurred()) {
1579 return array_item(self
, i
);
1581 else if (PySlice_Check(item
)) {
1582 Py_ssize_t start
, stop
, step
, slicelength
, cur
, i
;
1585 int itemsize
= self
->ob_descr
->itemsize
;
1587 if (PySlice_GetIndicesEx((PySliceObject
*)item
, Py_SIZE(self
),
1588 &start
, &stop
, &step
, &slicelength
) < 0) {
1592 if (slicelength
<= 0) {
1593 return newarrayobject(&Arraytype
, 0, self
->ob_descr
);
1595 else if (step
== 1) {
1596 PyObject
*result
= newarrayobject(&Arraytype
,
1597 slicelength
, self
->ob_descr
);
1600 memcpy(((arrayobject
*)result
)->ob_item
,
1601 self
->ob_item
+ start
* itemsize
,
1602 slicelength
* itemsize
);
1606 result
= newarrayobject(&Arraytype
, slicelength
, self
->ob_descr
);
1607 if (!result
) return NULL
;
1609 ar
= (arrayobject
*)result
;
1611 for (cur
= start
, i
= 0; i
< slicelength
;
1613 memcpy(ar
->ob_item
+ i
*itemsize
,
1614 self
->ob_item
+ cur
*itemsize
,
1622 PyErr_SetString(PyExc_TypeError
,
1623 "array indices must be integers");
1629 array_ass_subscr(arrayobject
* self
, PyObject
* item
, PyObject
* value
)
1631 Py_ssize_t start
, stop
, step
, slicelength
, needed
;
1635 if (PyIndex_Check(item
)) {
1636 Py_ssize_t i
= PyNumber_AsSsize_t(item
, PyExc_IndexError
);
1638 if (i
== -1 && PyErr_Occurred())
1642 if (i
< 0 || i
>= Py_SIZE(self
)) {
1643 PyErr_SetString(PyExc_IndexError
,
1644 "array assignment index out of range");
1647 if (value
== NULL
) {
1648 /* Fall through to slice assignment */
1655 return (*self
->ob_descr
->setitem
)(self
, i
, value
);
1657 else if (PySlice_Check(item
)) {
1658 if (PySlice_GetIndicesEx((PySliceObject
*)item
,
1659 Py_SIZE(self
), &start
, &stop
,
1660 &step
, &slicelength
) < 0) {
1665 PyErr_SetString(PyExc_TypeError
,
1666 "array indices must be integer");
1669 if (value
== NULL
) {
1673 else if (array_Check(value
)) {
1674 other
= (arrayobject
*)value
;
1675 needed
= Py_SIZE(other
);
1676 if (self
== other
) {
1677 /* Special case "self[i:j] = self" -- copy self first */
1679 value
= array_slice(other
, 0, needed
);
1682 ret
= array_ass_subscr(self
, item
, value
);
1686 if (other
->ob_descr
!= self
->ob_descr
) {
1687 PyErr_BadArgument();
1692 PyErr_Format(PyExc_TypeError
,
1693 "can only assign array (not \"%.200s\") to array slice",
1694 Py_TYPE(value
)->tp_name
);
1697 itemsize
= self
->ob_descr
->itemsize
;
1698 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
1699 if ((step
> 0 && stop
< start
) ||
1700 (step
< 0 && stop
> start
))
1703 /* Issue #4509: If the array has exported buffers and the slice
1704 assignment would change the size of the array, fail early to make
1705 sure we don't modify it. */
1706 if ((needed
== 0 || slicelength
!= needed
) && self
->ob_exports
> 0) {
1707 PyErr_SetString(PyExc_BufferError
,
1708 "cannot resize an array that is exporting buffers");
1713 if (slicelength
> needed
) {
1714 memmove(self
->ob_item
+ (start
+ needed
) * itemsize
,
1715 self
->ob_item
+ stop
* itemsize
,
1716 (Py_SIZE(self
) - stop
) * itemsize
);
1717 if (array_resize(self
, Py_SIZE(self
) +
1718 needed
- slicelength
) < 0)
1721 else if (slicelength
< needed
) {
1722 if (array_resize(self
, Py_SIZE(self
) +
1723 needed
- slicelength
) < 0)
1725 memmove(self
->ob_item
+ (start
+ needed
) * itemsize
,
1726 self
->ob_item
+ stop
* itemsize
,
1727 (Py_SIZE(self
) - start
- needed
) * itemsize
);
1730 memcpy(self
->ob_item
+ start
* itemsize
,
1731 other
->ob_item
, needed
* itemsize
);
1734 else if (needed
== 0) {
1741 start
= stop
+ step
* (slicelength
- 1) - 1;
1744 for (cur
= start
, i
= 0; i
< slicelength
;
1746 Py_ssize_t lim
= step
- 1;
1748 if (cur
+ step
>= (size_t)Py_SIZE(self
))
1749 lim
= Py_SIZE(self
) - cur
- 1;
1750 memmove(self
->ob_item
+ (cur
- i
) * itemsize
,
1751 self
->ob_item
+ (cur
+ 1) * itemsize
,
1754 cur
= start
+ slicelength
* step
;
1755 if (cur
< (size_t)Py_SIZE(self
)) {
1756 memmove(self
->ob_item
+ (cur
-slicelength
) * itemsize
,
1757 self
->ob_item
+ cur
* itemsize
,
1758 (Py_SIZE(self
) - cur
) * itemsize
);
1760 if (array_resize(self
, Py_SIZE(self
) - slicelength
) < 0)
1767 if (needed
!= slicelength
) {
1768 PyErr_Format(PyExc_ValueError
,
1769 "attempt to assign array of size %zd "
1770 "to extended slice of size %zd",
1771 needed
, slicelength
);
1774 for (cur
= start
, i
= 0; i
< slicelength
;
1776 memcpy(self
->ob_item
+ cur
* itemsize
,
1777 other
->ob_item
+ i
* itemsize
,
1784 static PyMappingMethods array_as_mapping
= {
1785 (lenfunc
)array_length
,
1786 (binaryfunc
)array_subscr
,
1787 (objobjargproc
)array_ass_subscr
1790 static const void *emptybuf
= "";
1794 array_buffer_getbuf(arrayobject
*self
, Py_buffer
*view
, int flags
)
1796 if (view
==NULL
) goto finish
;
1798 view
->buf
= (void *)self
->ob_item
;
1799 view
->obj
= (PyObject
*)self
;
1801 if (view
->buf
== NULL
)
1802 view
->buf
= (void *)emptybuf
;
1803 view
->len
= (Py_SIZE(self
)) * self
->ob_descr
->itemsize
;
1806 view
->itemsize
= self
->ob_descr
->itemsize
;
1807 view
->suboffsets
= NULL
;
1809 if ((flags
& PyBUF_ND
)==PyBUF_ND
) {
1810 view
->shape
= &((Py_SIZE(self
)));
1812 view
->strides
= NULL
;
1813 if ((flags
& PyBUF_STRIDES
)==PyBUF_STRIDES
)
1814 view
->strides
= &(view
->itemsize
);
1815 view
->format
= NULL
;
1816 view
->internal
= NULL
;
1817 if ((flags
& PyBUF_FORMAT
) == PyBUF_FORMAT
) {
1818 view
->format
= self
->ob_descr
->formats
;
1819 #ifdef Py_UNICODE_WIDE
1820 if (self
->ob_descr
->typecode
== 'u') {
1832 array_buffer_relbuf(arrayobject
*self
, Py_buffer
*view
)
1837 static PySequenceMethods array_as_sequence
= {
1838 (lenfunc
)array_length
, /*sq_length*/
1839 (binaryfunc
)array_concat
, /*sq_concat*/
1840 (ssizeargfunc
)array_repeat
, /*sq_repeat*/
1841 (ssizeargfunc
)array_item
, /*sq_item*/
1843 (ssizeobjargproc
)array_ass_item
, /*sq_ass_item*/
1845 (objobjproc
)array_contains
, /*sq_contains*/
1846 (binaryfunc
)array_inplace_concat
, /*sq_inplace_concat*/
1847 (ssizeargfunc
)array_inplace_repeat
/*sq_inplace_repeat*/
1850 static PyBufferProcs array_as_buffer
= {
1851 (getbufferproc
)array_buffer_getbuf
,
1852 (releasebufferproc
)array_buffer_relbuf
1856 array_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1859 PyObject
*initial
= NULL
, *it
= NULL
;
1860 struct arraydescr
*descr
;
1862 if (type
== &Arraytype
&& !_PyArg_NoKeywords("array.array()", kwds
))
1865 if (!PyArg_ParseTuple(args
, "C|O:array", &c
, &initial
))
1868 if (!(initial
== NULL
|| PyList_Check(initial
)
1869 || PyByteArray_Check(initial
)
1870 || PyBytes_Check(initial
)
1871 || PyTuple_Check(initial
)
1872 || ((c
=='u') && PyUnicode_Check(initial
)))) {
1873 it
= PyObject_GetIter(initial
);
1876 /* We set initial to NULL so that the subsequent code
1877 will create an empty array of the appropriate type
1878 and afterwards we can use array_iter_extend to populate
1883 for (descr
= descriptors
; descr
->typecode
!= '\0'; descr
++) {
1884 if (descr
->typecode
== c
) {
1888 if (initial
== NULL
|| !(PyList_Check(initial
)
1889 || PyTuple_Check(initial
)))
1892 len
= PySequence_Size(initial
);
1894 a
= newarrayobject(type
, len
, descr
);
1900 for (i
= 0; i
< len
; i
++) {
1902 PySequence_GetItem(initial
, i
);
1907 if (setarrayitem(a
, i
, v
) != 0) {
1915 else if (initial
!= NULL
&& (PyByteArray_Check(initial
) ||
1916 PyBytes_Check(initial
))) {
1917 PyObject
*t_initial
, *v
;
1918 t_initial
= PyTuple_Pack(1, initial
);
1919 if (t_initial
== NULL
) {
1923 v
= array_fromstring((arrayobject
*)a
,
1925 Py_DECREF(t_initial
);
1932 else if (initial
!= NULL
&& PyUnicode_Check(initial
)) {
1933 Py_ssize_t n
= PyUnicode_GET_DATA_SIZE(initial
);
1935 arrayobject
*self
= (arrayobject
*)a
;
1936 char *item
= self
->ob_item
;
1937 item
= (char *)PyMem_Realloc(item
, n
);
1943 self
->ob_item
= item
;
1944 Py_SIZE(self
) = n
/ sizeof(Py_UNICODE
);
1945 memcpy(item
, PyUnicode_AS_DATA(initial
), n
);
1946 self
->allocated
= Py_SIZE(self
);
1950 if (array_iter_extend((arrayobject
*)a
, it
) == -1) {
1960 PyErr_SetString(PyExc_ValueError
,
1961 "bad typecode (must be b, B, u, h, H, i, I, l, L, f or d)");
1966 PyDoc_STRVAR(module_doc
,
1967 "This module defines an object type which can efficiently represent\n\
1968 an array of basic values: characters, integers, floating point\n\
1969 numbers. Arrays are sequence types and behave very much like lists,\n\
1970 except that the type of objects stored in them is constrained. The\n\
1971 type is specified at object creation time by using a type code, which\n\
1972 is a single character. The following type codes are defined:\n\
1974 Type code C Type Minimum size in bytes \n\
1975 'b' signed integer 1 \n\
1976 'B' unsigned integer 1 \n\
1977 'u' Unicode character 2 (see note) \n\
1978 'h' signed integer 2 \n\
1979 'H' unsigned integer 2 \n\
1980 'i' signed integer 2 \n\
1981 'I' unsigned integer 2 \n\
1982 'l' signed integer 4 \n\
1983 'L' unsigned integer 4 \n\
1984 'f' floating point 4 \n\
1985 'd' floating point 8 \n\
1987 NOTE: The 'u' typecode corresponds to Python's unicode character. On \n\
1988 narrow builds this is 2-bytes on wide builds this is 4-bytes.\n\
1990 The constructor is:\n\
1992 array(typecode [, initializer]) -- create a new array\n\
1995 PyDoc_STRVAR(arraytype_doc
,
1996 "array(typecode [, initializer]) -> array\n\
1998 Return a new array whose items are restricted by typecode, and\n\
1999 initialized from the optional initializer value, which must be a list,\n\
2000 string. or iterable over elements of the appropriate type.\n\
2002 Arrays represent basic values and behave very much like lists, except\n\
2003 the type of objects stored in them is constrained.\n\
2007 append() -- append a new item to the end of the array\n\
2008 buffer_info() -- return information giving the current memory info\n\
2009 byteswap() -- byteswap all the items of the array\n\
2010 count() -- return number of occurrences of an object\n\
2011 extend() -- extend array by appending multiple elements from an iterable\n\
2012 fromfile() -- read items from a file object\n\
2013 fromlist() -- append items from the list\n\
2014 fromstring() -- append items from the string\n\
2015 index() -- return index of first occurrence of an object\n\
2016 insert() -- insert a new item into the array at a provided position\n\
2017 pop() -- remove and return item (default last)\n\
2018 remove() -- remove first occurrence of an object\n\
2019 reverse() -- reverse the order of the items in the array\n\
2020 tofile() -- write all items to a file object\n\
2021 tolist() -- return the array converted to an ordinary list\n\
2022 tostring() -- return the array converted to a string\n\
2026 typecode -- the typecode character used to create the array\n\
2027 itemsize -- the length in bytes of one array item\n\
2030 static PyObject
*array_iter(arrayobject
*ao
);
2032 static PyTypeObject Arraytype
= {
2033 PyVarObject_HEAD_INIT(NULL
, 0)
2035 sizeof(arrayobject
),
2037 (destructor
)array_dealloc
, /* tp_dealloc */
2041 0, /* tp_reserved */
2042 (reprfunc
)array_repr
, /* tp_repr */
2043 0, /* tp_as_number*/
2044 &array_as_sequence
, /* tp_as_sequence*/
2045 &array_as_mapping
, /* tp_as_mapping*/
2049 PyObject_GenericGetAttr
, /* tp_getattro */
2050 0, /* tp_setattro */
2051 &array_as_buffer
, /* tp_as_buffer*/
2052 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
, /* tp_flags */
2053 arraytype_doc
, /* tp_doc */
2054 0, /* tp_traverse */
2056 array_richcompare
, /* tp_richcompare */
2057 offsetof(arrayobject
, weakreflist
), /* tp_weaklistoffset */
2058 (getiterfunc
)array_iter
, /* tp_iter */
2059 0, /* tp_iternext */
2060 array_methods
, /* tp_methods */
2062 array_getsets
, /* tp_getset */
2065 0, /* tp_descr_get */
2066 0, /* tp_descr_set */
2067 0, /* tp_dictoffset */
2069 PyType_GenericAlloc
, /* tp_alloc */
2070 array_new
, /* tp_new */
2071 PyObject_Del
, /* tp_free */
2075 /*********************** Array Iterator **************************/
2081 PyObject
* (*getitem
)(struct arrayobject
*, Py_ssize_t
);
2084 static PyTypeObject PyArrayIter_Type
;
2086 #define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type)
2089 array_iter(arrayobject
*ao
)
2091 arrayiterobject
*it
;
2093 if (!array_Check(ao
)) {
2094 PyErr_BadInternalCall();
2098 it
= PyObject_GC_New(arrayiterobject
, &PyArrayIter_Type
);
2105 it
->getitem
= ao
->ob_descr
->getitem
;
2106 PyObject_GC_Track(it
);
2107 return (PyObject
*)it
;
2111 arrayiter_next(arrayiterobject
*it
)
2113 assert(PyArrayIter_Check(it
));
2114 if (it
->index
< Py_SIZE(it
->ao
))
2115 return (*it
->getitem
)(it
->ao
, it
->index
++);
2120 arrayiter_dealloc(arrayiterobject
*it
)
2122 PyObject_GC_UnTrack(it
);
2124 PyObject_GC_Del(it
);
2128 arrayiter_traverse(arrayiterobject
*it
, visitproc visit
, void *arg
)
2134 static PyTypeObject PyArrayIter_Type
= {
2135 PyVarObject_HEAD_INIT(NULL
, 0)
2136 "arrayiterator", /* tp_name */
2137 sizeof(arrayiterobject
), /* tp_basicsize */
2138 0, /* tp_itemsize */
2140 (destructor
)arrayiter_dealloc
, /* tp_dealloc */
2144 0, /* tp_reserved */
2146 0, /* tp_as_number */
2147 0, /* tp_as_sequence */
2148 0, /* tp_as_mapping */
2152 PyObject_GenericGetAttr
, /* tp_getattro */
2153 0, /* tp_setattro */
2154 0, /* tp_as_buffer */
2155 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_GC
,/* tp_flags */
2157 (traverseproc
)arrayiter_traverse
, /* tp_traverse */
2159 0, /* tp_richcompare */
2160 0, /* tp_weaklistoffset */
2161 PyObject_SelfIter
, /* tp_iter */
2162 (iternextfunc
)arrayiter_next
, /* tp_iternext */
2167 /*********************** Install Module **************************/
2169 /* No functions in array module. */
2170 static PyMethodDef a_methods
[] = {
2171 {NULL
, NULL
, 0, NULL
} /* Sentinel */
2174 static struct PyModuleDef arraymodule
= {
2175 PyModuleDef_HEAD_INIT
,
2191 PyObject
*typecodes
;
2192 Py_ssize_t size
= 0;
2193 register Py_UNICODE
*p
;
2194 struct arraydescr
*descr
;
2196 if (PyType_Ready(&Arraytype
) < 0)
2198 Py_TYPE(&PyArrayIter_Type
) = &PyType_Type
;
2199 m
= PyModule_Create(&arraymodule
);
2203 Py_INCREF((PyObject
*)&Arraytype
);
2204 PyModule_AddObject(m
, "ArrayType", (PyObject
*)&Arraytype
);
2205 Py_INCREF((PyObject
*)&Arraytype
);
2206 PyModule_AddObject(m
, "array", (PyObject
*)&Arraytype
);
2208 for (descr
=descriptors
; descr
->typecode
!= '\0'; descr
++) {
2212 typecodes
= PyUnicode_FromStringAndSize(NULL
, size
);
2213 p
= PyUnicode_AS_UNICODE(typecodes
);
2214 for (descr
= descriptors
; descr
->typecode
!= '\0'; descr
++) {
2215 *p
++ = (char)descr
->typecode
;
2218 PyModule_AddObject(m
, "typecodes", (PyObject
*)typecodes
);
2220 if (PyErr_Occurred()) {