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);
435 op
->ob_descr
= descr
;
436 op
->allocated
= size
;
437 op
->weakreflist
= NULL
;
443 op
->ob_item
= PyMem_NEW(char, nbytes
);
444 if (op
->ob_item
== NULL
) {
446 return PyErr_NoMemory();
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 if (Py_SIZE(a
) > PY_SSIZE_T_MAX
- Py_SIZE(b
)) {
656 return PyErr_NoMemory();
658 size
= Py_SIZE(a
) + Py_SIZE(b
);
659 np
= (arrayobject
*) newarrayobject(&Arraytype
, size
, a
->ob_descr
);
663 memcpy(np
->ob_item
, a
->ob_item
, Py_SIZE(a
)*a
->ob_descr
->itemsize
);
664 memcpy(np
->ob_item
+ Py_SIZE(a
)*a
->ob_descr
->itemsize
,
665 b
->ob_item
, Py_SIZE(b
)*b
->ob_descr
->itemsize
);
666 return (PyObject
*)np
;
671 array_repeat(arrayobject
*a
, Py_ssize_t n
)
680 if ((Py_SIZE(a
) != 0) && (n
> PY_SSIZE_T_MAX
/ Py_SIZE(a
))) {
681 return PyErr_NoMemory();
683 size
= Py_SIZE(a
) * n
;
684 np
= (arrayobject
*) newarrayobject(&Arraytype
, size
, a
->ob_descr
);
688 nbytes
= Py_SIZE(a
) * a
->ob_descr
->itemsize
;
689 for (i
= 0; i
< n
; i
++) {
690 memcpy(p
, a
->ob_item
, nbytes
);
693 return (PyObject
*) np
;
697 array_ass_slice(arrayobject
*a
, Py_ssize_t ilow
, Py_ssize_t ihigh
, PyObject
*v
)
700 Py_ssize_t n
; /* Size of replacement array */
701 Py_ssize_t d
; /* Change in size */
702 #define b ((arrayobject *)v)
705 else if (array_Check(v
)) {
708 /* Special case "a[i:j] = a" -- copy b first */
710 v
= array_slice(b
, 0, n
);
713 ret
= array_ass_slice(a
, ilow
, ihigh
, v
);
717 if (b
->ob_descr
!= a
->ob_descr
) {
723 PyErr_Format(PyExc_TypeError
,
724 "can only assign array (not \"%.200s\") to array slice",
725 Py_TYPE(v
)->tp_name
);
730 else if (ilow
> Py_SIZE(a
))
736 else if (ihigh
> Py_SIZE(a
))
739 d
= n
- (ihigh
-ilow
);
740 if (d
< 0) { /* Delete -d items */
741 memmove(item
+ (ihigh
+d
)*a
->ob_descr
->itemsize
,
742 item
+ ihigh
*a
->ob_descr
->itemsize
,
743 (Py_SIZE(a
)-ihigh
)*a
->ob_descr
->itemsize
);
745 PyMem_RESIZE(item
, char, Py_SIZE(a
)*a
->ob_descr
->itemsize
);
748 a
->allocated
= Py_SIZE(a
);
750 else if (d
> 0) { /* Insert d items */
751 PyMem_RESIZE(item
, char,
752 (Py_SIZE(a
) + d
)*a
->ob_descr
->itemsize
);
757 memmove(item
+ (ihigh
+d
)*a
->ob_descr
->itemsize
,
758 item
+ ihigh
*a
->ob_descr
->itemsize
,
759 (Py_SIZE(a
)-ihigh
)*a
->ob_descr
->itemsize
);
762 a
->allocated
= Py_SIZE(a
);
765 memcpy(item
+ ilow
*a
->ob_descr
->itemsize
, b
->ob_item
,
766 n
*b
->ob_descr
->itemsize
);
772 array_ass_item(arrayobject
*a
, Py_ssize_t i
, PyObject
*v
)
774 if (i
< 0 || i
>= Py_SIZE(a
)) {
775 PyErr_SetString(PyExc_IndexError
,
776 "array assignment index out of range");
780 return array_ass_slice(a
, i
, i
+1, v
);
781 return (*a
->ob_descr
->setitem
)(a
, i
, v
);
785 setarrayitem(PyObject
*a
, Py_ssize_t i
, PyObject
*v
)
787 assert(array_Check(a
));
788 return array_ass_item((arrayobject
*)a
, i
, v
);
792 array_iter_extend(arrayobject
*self
, PyObject
*bb
)
796 it
= PyObject_GetIter(bb
);
800 while ((v
= PyIter_Next(it
)) != NULL
) {
801 if (ins1(self
, Py_SIZE(self
), v
) != 0) {
809 if (PyErr_Occurred())
815 array_do_extend(arrayobject
*self
, PyObject
*bb
)
820 if (!array_Check(bb
))
821 return array_iter_extend(self
, bb
);
822 #define b ((arrayobject *)bb)
823 if (self
->ob_descr
!= b
->ob_descr
) {
824 PyErr_SetString(PyExc_TypeError
,
825 "can only extend with array of same kind");
828 if ((Py_SIZE(self
) > PY_SSIZE_T_MAX
- Py_SIZE(b
)) ||
829 ((Py_SIZE(self
) + Py_SIZE(b
)) > PY_SSIZE_T_MAX
/ self
->ob_descr
->itemsize
)) {
833 size
= Py_SIZE(self
) + Py_SIZE(b
);
834 old_item
= self
->ob_item
;
835 PyMem_RESIZE(self
->ob_item
, char, size
*self
->ob_descr
->itemsize
);
836 if (self
->ob_item
== NULL
) {
837 self
->ob_item
= old_item
;
841 memcpy(self
->ob_item
+ Py_SIZE(self
)*self
->ob_descr
->itemsize
,
842 b
->ob_item
, Py_SIZE(b
)*b
->ob_descr
->itemsize
);
843 Py_SIZE(self
) = size
;
844 self
->allocated
= size
;
851 array_inplace_concat(arrayobject
*self
, PyObject
*bb
)
853 if (!array_Check(bb
)) {
854 PyErr_Format(PyExc_TypeError
,
855 "can only extend array with array (not \"%.200s\")",
856 Py_TYPE(bb
)->tp_name
);
859 if (array_do_extend(self
, bb
) == -1)
862 return (PyObject
*)self
;
866 array_inplace_repeat(arrayobject
*self
, Py_ssize_t n
)
871 if (Py_SIZE(self
) > 0) {
874 items
= self
->ob_item
;
875 if ((self
->ob_descr
->itemsize
!= 0) &&
876 (Py_SIZE(self
) > PY_SSIZE_T_MAX
/ self
->ob_descr
->itemsize
)) {
877 return PyErr_NoMemory();
879 size
= Py_SIZE(self
) * self
->ob_descr
->itemsize
;
882 self
->ob_item
= NULL
;
887 if (size
> PY_SSIZE_T_MAX
/ n
) {
888 return PyErr_NoMemory();
890 PyMem_RESIZE(items
, char, n
* size
);
892 return PyErr_NoMemory();
894 for (i
= 1; i
< n
; i
++) {
896 memcpy(p
, items
, size
);
898 self
->ob_item
= items
;
900 self
->allocated
= Py_SIZE(self
);
904 return (PyObject
*)self
;
909 ins(arrayobject
*self
, Py_ssize_t where
, PyObject
*v
)
911 if (ins1(self
, where
, v
) != 0)
918 array_count(arrayobject
*self
, PyObject
*v
)
920 Py_ssize_t count
= 0;
923 for (i
= 0; i
< Py_SIZE(self
); i
++) {
924 PyObject
*selfi
= getarrayitem((PyObject
*)self
, i
);
925 int cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
932 return PyInt_FromSsize_t(count
);
935 PyDoc_STRVAR(count_doc
,
938 Return number of occurrences of x in the array.");
941 array_index(arrayobject
*self
, PyObject
*v
)
945 for (i
= 0; i
< Py_SIZE(self
); i
++) {
946 PyObject
*selfi
= getarrayitem((PyObject
*)self
, i
);
947 int cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
950 return PyInt_FromLong((long)i
);
955 PyErr_SetString(PyExc_ValueError
, "array.index(x): x not in list");
959 PyDoc_STRVAR(index_doc
,
962 Return index of first occurrence of x in the array.");
965 array_contains(arrayobject
*self
, PyObject
*v
)
970 for (i
= 0, cmp
= 0 ; cmp
== 0 && i
< Py_SIZE(self
); i
++) {
971 PyObject
*selfi
= getarrayitem((PyObject
*)self
, i
);
972 cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
979 array_remove(arrayobject
*self
, PyObject
*v
)
983 for (i
= 0; i
< Py_SIZE(self
); i
++) {
984 PyObject
*selfi
= getarrayitem((PyObject
*)self
,i
);
985 int cmp
= PyObject_RichCompareBool(selfi
, v
, Py_EQ
);
988 if (array_ass_slice(self
, i
, i
+1,
989 (PyObject
*)NULL
) != 0)
997 PyErr_SetString(PyExc_ValueError
, "array.remove(x): x not in list");
1001 PyDoc_STRVAR(remove_doc
,
1004 Remove the first occurrence of x in the array.");
1007 array_pop(arrayobject
*self
, PyObject
*args
)
1011 if (!PyArg_ParseTuple(args
, "|n:pop", &i
))
1013 if (Py_SIZE(self
) == 0) {
1014 /* Special-case most common failure cause */
1015 PyErr_SetString(PyExc_IndexError
, "pop from empty array");
1020 if (i
< 0 || i
>= Py_SIZE(self
)) {
1021 PyErr_SetString(PyExc_IndexError
, "pop index out of range");
1024 v
= getarrayitem((PyObject
*)self
,i
);
1025 if (array_ass_slice(self
, i
, i
+1, (PyObject
*)NULL
) != 0) {
1032 PyDoc_STRVAR(pop_doc
,
1035 Return the i-th element and delete it from the array. i defaults to -1.");
1038 array_extend(arrayobject
*self
, PyObject
*bb
)
1040 if (array_do_extend(self
, bb
) == -1)
1046 PyDoc_STRVAR(extend_doc
,
1047 "extend(array or iterable)\n\
1049 Append items to the end of the array.");
1052 array_insert(arrayobject
*self
, PyObject
*args
)
1056 if (!PyArg_ParseTuple(args
, "nO:insert", &i
, &v
))
1058 return ins(self
, i
, v
);
1061 PyDoc_STRVAR(insert_doc
,
1064 Insert a new item x into the array before position i.");
1068 array_buffer_info(arrayobject
*self
, PyObject
*unused
)
1070 PyObject
* retval
= NULL
;
1071 retval
= PyTuple_New(2);
1075 PyTuple_SET_ITEM(retval
, 0, PyLong_FromVoidPtr(self
->ob_item
));
1076 PyTuple_SET_ITEM(retval
, 1, PyInt_FromLong((long)(Py_SIZE(self
))));
1081 PyDoc_STRVAR(buffer_info_doc
,
1082 "buffer_info() -> (address, length)\n\
1084 Return a tuple (address, length) giving the current memory address and\n\
1085 the length in items of the buffer used to hold array's contents\n\
1086 The length should be multiplied by the itemsize attribute to calculate\n\
1087 the buffer length in bytes.");
1091 array_append(arrayobject
*self
, PyObject
*v
)
1093 return ins(self
, Py_SIZE(self
), v
);
1096 PyDoc_STRVAR(append_doc
,
1099 Append new value x to the end of the array.");
1103 array_byteswap(arrayobject
*self
, PyObject
*unused
)
1108 switch (self
->ob_descr
->itemsize
) {
1112 for (p
= self
->ob_item
, i
= Py_SIZE(self
); --i
>= 0; p
+= 2) {
1119 for (p
= self
->ob_item
, i
= Py_SIZE(self
); --i
>= 0; p
+= 4) {
1129 for (p
= self
->ob_item
, i
= Py_SIZE(self
); --i
>= 0; p
+= 8) {
1145 PyErr_SetString(PyExc_RuntimeError
,
1146 "don't know how to byteswap this array type");
1153 PyDoc_STRVAR(byteswap_doc
,
1156 Byteswap all items of the array. If the items in the array are not 1, 2,\n\
1157 4, or 8 bytes in size, RuntimeError is raised.");
1160 array_reverse(arrayobject
*self
, PyObject
*unused
)
1162 register Py_ssize_t itemsize
= self
->ob_descr
->itemsize
;
1163 register char *p
, *q
;
1164 /* little buffer to hold items while swapping */
1165 char tmp
[256]; /* 8 is probably enough -- but why skimp */
1166 assert((size_t)itemsize
<= sizeof(tmp
));
1168 if (Py_SIZE(self
) > 1) {
1169 for (p
= self
->ob_item
,
1170 q
= self
->ob_item
+ (Py_SIZE(self
) - 1)*itemsize
;
1172 p
+= itemsize
, q
-= itemsize
) {
1173 /* memory areas guaranteed disjoint, so memcpy
1174 * is safe (& memmove may be slower).
1176 memcpy(tmp
, p
, itemsize
);
1177 memcpy(p
, q
, itemsize
);
1178 memcpy(q
, tmp
, itemsize
);
1186 PyDoc_STRVAR(reverse_doc
,
1189 Reverse the order of the items in the array.");
1192 array_fromfile(arrayobject
*self
, PyObject
*args
)
1197 if (!PyArg_ParseTuple(args
, "On:fromfile", &f
, &n
))
1199 fp
= PyFile_AsFile(f
);
1201 PyErr_SetString(PyExc_TypeError
, "arg1 must be open file");
1205 char *item
= self
->ob_item
;
1206 Py_ssize_t itemsize
= self
->ob_descr
->itemsize
;
1208 Py_ssize_t newlength
;
1210 /* Be careful here about overflow */
1211 if ((newlength
= Py_SIZE(self
) + n
) <= 0 ||
1212 (newbytes
= newlength
* itemsize
) / itemsize
!=
1215 PyMem_RESIZE(item
, char, newbytes
);
1221 self
->ob_item
= item
;
1223 self
->allocated
= Py_SIZE(self
);
1224 nread
= fread(item
+ (Py_SIZE(self
) - n
) * itemsize
,
1226 if (nread
< (size_t)n
) {
1227 Py_SIZE(self
) -= (n
- nread
);
1228 PyMem_RESIZE(item
, char, Py_SIZE(self
)*itemsize
);
1229 self
->ob_item
= item
;
1230 self
->allocated
= Py_SIZE(self
);
1232 PyErr_SetFromErrno(PyExc_IOError
);
1236 PyErr_SetString(PyExc_EOFError
,
1237 "not enough items in file");
1246 PyDoc_STRVAR(fromfile_doc
,
1249 Read n objects from the file object f and append them to the end of the\n\
1250 array. Also called as read.");
1254 array_fromfile_as_read(arrayobject
*self
, PyObject
*args
)
1256 if (PyErr_WarnPy3k("array.read() not supported in 3.x; "
1257 "use array.fromfile()", 1) < 0)
1259 return array_fromfile(self
, args
);
1264 array_tofile(arrayobject
*self
, PyObject
*f
)
1268 fp
= PyFile_AsFile(f
);
1270 PyErr_SetString(PyExc_TypeError
, "arg must be open file");
1273 if (self
->ob_size
> 0) {
1274 if (fwrite(self
->ob_item
, self
->ob_descr
->itemsize
,
1275 self
->ob_size
, fp
) != (size_t)self
->ob_size
) {
1276 PyErr_SetFromErrno(PyExc_IOError
);
1285 PyDoc_STRVAR(tofile_doc
,
1288 Write all items (as machine values) to the file object f. Also called as\n\
1293 array_tofile_as_write(arrayobject
*self
, PyObject
*f
)
1295 if (PyErr_WarnPy3k("array.write() not supported in 3.x; "
1296 "use array.tofile()", 1) < 0)
1298 return array_tofile(self
, f
);
1303 array_fromlist(arrayobject
*self
, PyObject
*list
)
1306 Py_ssize_t itemsize
= self
->ob_descr
->itemsize
;
1308 if (!PyList_Check(list
)) {
1309 PyErr_SetString(PyExc_TypeError
, "arg must be list");
1312 n
= PyList_Size(list
);
1314 char *item
= self
->ob_item
;
1316 PyMem_RESIZE(item
, char, (Py_SIZE(self
) + n
) * itemsize
);
1321 self
->ob_item
= item
;
1323 self
->allocated
= Py_SIZE(self
);
1324 for (i
= 0; i
< n
; i
++) {
1325 PyObject
*v
= PyList_GetItem(list
, i
);
1326 if ((*self
->ob_descr
->setitem
)(self
,
1327 Py_SIZE(self
) - n
+ i
, v
) != 0) {
1329 if (itemsize
&& (self
->ob_size
> PY_SSIZE_T_MAX
/ itemsize
)) {
1330 return PyErr_NoMemory();
1332 PyMem_RESIZE(item
, char,
1333 Py_SIZE(self
) * itemsize
);
1334 self
->ob_item
= item
;
1335 self
->allocated
= Py_SIZE(self
);
1344 PyDoc_STRVAR(fromlist_doc
,
1347 Append items to array from list.");
1351 array_tolist(arrayobject
*self
, PyObject
*unused
)
1353 PyObject
*list
= PyList_New(Py_SIZE(self
));
1358 for (i
= 0; i
< Py_SIZE(self
); i
++) {
1359 PyObject
*v
= getarrayitem((PyObject
*)self
, i
);
1364 PyList_SetItem(list
, i
, v
);
1369 PyDoc_STRVAR(tolist_doc
,
1370 "tolist() -> list\n\
1372 Convert array to an ordinary list with the same items.");
1376 array_fromstring(arrayobject
*self
, PyObject
*args
)
1380 int itemsize
= self
->ob_descr
->itemsize
;
1381 if (!PyArg_ParseTuple(args
, "s#:fromstring", &str
, &n
))
1383 if (n
% itemsize
!= 0) {
1384 PyErr_SetString(PyExc_ValueError
,
1385 "string length not a multiple of item size");
1390 char *item
= self
->ob_item
;
1391 if ((n
> PY_SSIZE_T_MAX
- Py_SIZE(self
)) ||
1392 ((Py_SIZE(self
) + n
) > PY_SSIZE_T_MAX
/ itemsize
)) {
1393 return PyErr_NoMemory();
1395 PyMem_RESIZE(item
, char, (Py_SIZE(self
) + n
) * itemsize
);
1400 self
->ob_item
= item
;
1402 self
->allocated
= Py_SIZE(self
);
1403 memcpy(item
+ (Py_SIZE(self
) - n
) * itemsize
,
1410 PyDoc_STRVAR(fromstring_doc
,
1411 "fromstring(string)\n\
1413 Appends items from the string, interpreting it as an array of machine\n\
1414 values,as if it had been read from a file using the fromfile() method).");
1418 array_tostring(arrayobject
*self
, PyObject
*unused
)
1420 if (self
->ob_size
<= PY_SSIZE_T_MAX
/ self
->ob_descr
->itemsize
) {
1421 return PyString_FromStringAndSize(self
->ob_item
,
1422 Py_SIZE(self
) * self
->ob_descr
->itemsize
);
1424 return PyErr_NoMemory();
1428 PyDoc_STRVAR(tostring_doc
,
1429 "tostring() -> string\n\
1431 Convert the array to an array of machine values and return the string\n\
1436 #ifdef Py_USING_UNICODE
1438 array_fromunicode(arrayobject
*self
, PyObject
*args
)
1443 if (!PyArg_ParseTuple(args
, "u#:fromunicode", &ustr
, &n
))
1445 if (self
->ob_descr
->typecode
!= 'u') {
1446 PyErr_SetString(PyExc_ValueError
,
1447 "fromunicode() may only be called on "
1452 Py_UNICODE
*item
= (Py_UNICODE
*) self
->ob_item
;
1453 if (Py_SIZE(self
) > PY_SSIZE_T_MAX
- n
) {
1454 return PyErr_NoMemory();
1456 PyMem_RESIZE(item
, Py_UNICODE
, Py_SIZE(self
) + n
);
1461 self
->ob_item
= (char *) item
;
1463 self
->allocated
= Py_SIZE(self
);
1464 memcpy(item
+ Py_SIZE(self
) - n
,
1465 ustr
, n
* sizeof(Py_UNICODE
));
1472 PyDoc_STRVAR(fromunicode_doc
,
1473 "fromunicode(ustr)\n\
1475 Extends this array with data from the unicode string ustr.\n\
1476 The array must be a type 'u' array; otherwise a ValueError\n\
1477 is raised. Use array.fromstring(ustr.decode(...)) to\n\
1478 append Unicode data to an array of some other type.");
1482 array_tounicode(arrayobject
*self
, PyObject
*unused
)
1484 if (self
->ob_descr
->typecode
!= 'u') {
1485 PyErr_SetString(PyExc_ValueError
,
1486 "tounicode() may only be called on type 'u' arrays");
1489 return PyUnicode_FromUnicode((Py_UNICODE
*) self
->ob_item
, Py_SIZE(self
));
1492 PyDoc_STRVAR(tounicode_doc
,
1493 "tounicode() -> unicode\n\
1495 Convert the array to a unicode string. The array must be\n\
1496 a type 'u' array; otherwise a ValueError is raised. Use\n\
1497 array.tostring().decode() to obtain a unicode string from\n\
1498 an array of some other type.");
1500 #endif /* Py_USING_UNICODE */
1503 array_reduce(arrayobject
*array
)
1505 PyObject
*dict
, *result
, *list
;
1507 dict
= PyObject_GetAttrString((PyObject
*)array
, "__dict__");
1509 if (!PyErr_ExceptionMatches(PyExc_AttributeError
))
1515 /* Unlike in Python 3.x, we never use the more efficient memory
1516 * representation of an array for pickling. This is unfortunately
1517 * necessary to allow array objects to be unpickled by Python 3.x,
1518 * since str objects from 2.x are always decoded to unicode in
1521 list
= array_tolist(array
, NULL
);
1526 result
= Py_BuildValue(
1527 "O(cO)O", Py_TYPE(array
), array
->ob_descr
->typecode
, list
, dict
);
1533 PyDoc_STRVAR(reduce_doc
, "Return state information for pickling.");
1536 array_sizeof(arrayobject
*self
, PyObject
*unused
)
1539 res
= sizeof(arrayobject
) + self
->allocated
* self
->ob_descr
->itemsize
;
1540 return PyLong_FromSsize_t(res
);
1543 PyDoc_STRVAR(sizeof_doc
,
1544 "__sizeof__() -> int\n\
1546 Size of the array in memory, in bytes.");
1549 array_get_typecode(arrayobject
*a
, void *closure
)
1551 char tc
= a
->ob_descr
->typecode
;
1552 return PyString_FromStringAndSize(&tc
, 1);
1556 array_get_itemsize(arrayobject
*a
, void *closure
)
1558 return PyInt_FromLong((long)a
->ob_descr
->itemsize
);
1561 static PyGetSetDef array_getsets
[] = {
1562 {"typecode", (getter
) array_get_typecode
, NULL
,
1563 "the typecode character used to create the array"},
1564 {"itemsize", (getter
) array_get_itemsize
, NULL
,
1565 "the size, in bytes, of one array item"},
1569 static PyMethodDef array_methods
[] = {
1570 {"append", (PyCFunction
)array_append
, METH_O
,
1572 {"buffer_info", (PyCFunction
)array_buffer_info
, METH_NOARGS
,
1574 {"byteswap", (PyCFunction
)array_byteswap
, METH_NOARGS
,
1576 {"__copy__", (PyCFunction
)array_copy
, METH_NOARGS
,
1578 {"count", (PyCFunction
)array_count
, METH_O
,
1580 {"__deepcopy__",(PyCFunction
)array_copy
, METH_O
,
1582 {"extend", (PyCFunction
)array_extend
, METH_O
,
1584 {"fromfile", (PyCFunction
)array_fromfile
, METH_VARARGS
,
1586 {"fromlist", (PyCFunction
)array_fromlist
, METH_O
,
1588 {"fromstring", (PyCFunction
)array_fromstring
, METH_VARARGS
,
1590 #ifdef Py_USING_UNICODE
1591 {"fromunicode", (PyCFunction
)array_fromunicode
, METH_VARARGS
,
1594 {"index", (PyCFunction
)array_index
, METH_O
,
1596 {"insert", (PyCFunction
)array_insert
, METH_VARARGS
,
1598 {"pop", (PyCFunction
)array_pop
, METH_VARARGS
,
1600 {"read", (PyCFunction
)array_fromfile_as_read
, METH_VARARGS
,
1602 {"__reduce__", (PyCFunction
)array_reduce
, METH_NOARGS
,
1604 {"remove", (PyCFunction
)array_remove
, METH_O
,
1606 {"reverse", (PyCFunction
)array_reverse
, METH_NOARGS
,
1608 /* {"sort", (PyCFunction)array_sort, METH_VARARGS,
1610 {"tofile", (PyCFunction
)array_tofile
, METH_O
,
1612 {"tolist", (PyCFunction
)array_tolist
, METH_NOARGS
,
1614 {"tostring", (PyCFunction
)array_tostring
, METH_NOARGS
,
1616 #ifdef Py_USING_UNICODE
1617 {"tounicode", (PyCFunction
)array_tounicode
, METH_NOARGS
,
1620 {"write", (PyCFunction
)array_tofile_as_write
, METH_O
,
1622 {"__sizeof__", (PyCFunction
)array_sizeof
, METH_NOARGS
,
1624 {NULL
, NULL
} /* sentinel */
1628 array_repr(arrayobject
*a
)
1630 char buf
[256], typecode
;
1631 PyObject
*s
, *t
, *v
= NULL
;
1635 typecode
= a
->ob_descr
->typecode
;
1637 PyOS_snprintf(buf
, sizeof(buf
), "array('%c')", typecode
);
1638 return PyString_FromString(buf
);
1641 if (typecode
== 'c')
1642 v
= array_tostring(a
, NULL
);
1643 #ifdef Py_USING_UNICODE
1644 else if (typecode
== 'u')
1645 v
= array_tounicode(a
, NULL
);
1648 v
= array_tolist(a
, NULL
);
1649 t
= PyObject_Repr(v
);
1652 PyOS_snprintf(buf
, sizeof(buf
), "array('%c', ", typecode
);
1653 s
= PyString_FromString(buf
);
1654 PyString_ConcatAndDel(&s
, t
);
1655 PyString_ConcatAndDel(&s
, PyString_FromString(")"));
1660 array_subscr(arrayobject
* self
, PyObject
* item
)
1662 if (PyIndex_Check(item
)) {
1663 Py_ssize_t i
= PyNumber_AsSsize_t(item
, PyExc_IndexError
);
1664 if (i
==-1 && PyErr_Occurred()) {
1669 return array_item(self
, i
);
1671 else if (PySlice_Check(item
)) {
1672 Py_ssize_t start
, stop
, step
, slicelength
, cur
, i
;
1675 int itemsize
= self
->ob_descr
->itemsize
;
1677 if (PySlice_GetIndicesEx((PySliceObject
*)item
, Py_SIZE(self
),
1678 &start
, &stop
, &step
, &slicelength
) < 0) {
1682 if (slicelength
<= 0) {
1683 return newarrayobject(&Arraytype
, 0, self
->ob_descr
);
1685 else if (step
== 1) {
1686 PyObject
*result
= newarrayobject(&Arraytype
,
1687 slicelength
, self
->ob_descr
);
1690 memcpy(((arrayobject
*)result
)->ob_item
,
1691 self
->ob_item
+ start
* itemsize
,
1692 slicelength
* itemsize
);
1696 result
= newarrayobject(&Arraytype
, slicelength
, self
->ob_descr
);
1697 if (!result
) return NULL
;
1699 ar
= (arrayobject
*)result
;
1701 for (cur
= start
, i
= 0; i
< slicelength
;
1703 memcpy(ar
->ob_item
+ i
*itemsize
,
1704 self
->ob_item
+ cur
*itemsize
,
1712 PyErr_SetString(PyExc_TypeError
,
1713 "array indices must be integers");
1719 array_ass_subscr(arrayobject
* self
, PyObject
* item
, PyObject
* value
)
1721 Py_ssize_t start
, stop
, step
, slicelength
, needed
;
1725 if (PyIndex_Check(item
)) {
1726 Py_ssize_t i
= PyNumber_AsSsize_t(item
, PyExc_IndexError
);
1728 if (i
== -1 && PyErr_Occurred())
1732 if (i
< 0 || i
>= Py_SIZE(self
)) {
1733 PyErr_SetString(PyExc_IndexError
,
1734 "array assignment index out of range");
1737 if (value
== NULL
) {
1738 /* Fall through to slice assignment */
1745 return (*self
->ob_descr
->setitem
)(self
, i
, value
);
1747 else if (PySlice_Check(item
)) {
1748 if (PySlice_GetIndicesEx((PySliceObject
*)item
,
1749 Py_SIZE(self
), &start
, &stop
,
1750 &step
, &slicelength
) < 0) {
1755 PyErr_SetString(PyExc_TypeError
,
1756 "array indices must be integer");
1759 if (value
== NULL
) {
1763 else if (array_Check(value
)) {
1764 other
= (arrayobject
*)value
;
1765 needed
= Py_SIZE(other
);
1766 if (self
== other
) {
1767 /* Special case "self[i:j] = self" -- copy self first */
1769 value
= array_slice(other
, 0, needed
);
1772 ret
= array_ass_subscr(self
, item
, value
);
1776 if (other
->ob_descr
!= self
->ob_descr
) {
1777 PyErr_BadArgument();
1782 PyErr_Format(PyExc_TypeError
,
1783 "can only assign array (not \"%.200s\") to array slice",
1784 Py_TYPE(value
)->tp_name
);
1787 itemsize
= self
->ob_descr
->itemsize
;
1788 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
1789 if ((step
> 0 && stop
< start
) ||
1790 (step
< 0 && stop
> start
))
1793 if (slicelength
> needed
) {
1794 memmove(self
->ob_item
+ (start
+ needed
) * itemsize
,
1795 self
->ob_item
+ stop
* itemsize
,
1796 (Py_SIZE(self
) - stop
) * itemsize
);
1797 if (array_resize(self
, Py_SIZE(self
) +
1798 needed
- slicelength
) < 0)
1801 else if (slicelength
< needed
) {
1802 if (array_resize(self
, Py_SIZE(self
) +
1803 needed
- slicelength
) < 0)
1805 memmove(self
->ob_item
+ (start
+ needed
) * itemsize
,
1806 self
->ob_item
+ stop
* itemsize
,
1807 (Py_SIZE(self
) - start
- needed
) * itemsize
);
1810 memcpy(self
->ob_item
+ start
* itemsize
,
1811 other
->ob_item
, needed
* itemsize
);
1814 else if (needed
== 0) {
1821 start
= stop
+ step
* (slicelength
- 1) - 1;
1824 for (cur
= start
, i
= 0; i
< slicelength
;
1826 Py_ssize_t lim
= step
- 1;
1828 if (cur
+ step
>= (size_t)Py_SIZE(self
))
1829 lim
= Py_SIZE(self
) - cur
- 1;
1830 memmove(self
->ob_item
+ (cur
- i
) * itemsize
,
1831 self
->ob_item
+ (cur
+ 1) * itemsize
,
1834 cur
= start
+ slicelength
* step
;
1835 if (cur
< (size_t)Py_SIZE(self
)) {
1836 memmove(self
->ob_item
+ (cur
-slicelength
) * itemsize
,
1837 self
->ob_item
+ cur
* itemsize
,
1838 (Py_SIZE(self
) - cur
) * itemsize
);
1840 if (array_resize(self
, Py_SIZE(self
) - slicelength
) < 0)
1847 if (needed
!= slicelength
) {
1848 PyErr_Format(PyExc_ValueError
,
1849 "attempt to assign array of size %zd "
1850 "to extended slice of size %zd",
1851 needed
, slicelength
);
1854 for (cur
= start
, i
= 0; i
< slicelength
;
1856 memcpy(self
->ob_item
+ cur
* itemsize
,
1857 other
->ob_item
+ i
* itemsize
,
1864 static PyMappingMethods array_as_mapping
= {
1865 (lenfunc
)array_length
,
1866 (binaryfunc
)array_subscr
,
1867 (objobjargproc
)array_ass_subscr
1870 static const void *emptybuf
= "";
1873 array_buffer_getreadbuf(arrayobject
*self
, Py_ssize_t index
, const void **ptr
)
1876 PyErr_SetString(PyExc_SystemError
,
1877 "Accessing non-existent array segment");
1880 *ptr
= (void *)self
->ob_item
;
1883 return Py_SIZE(self
)*self
->ob_descr
->itemsize
;
1887 array_buffer_getwritebuf(arrayobject
*self
, Py_ssize_t index
, const void **ptr
)
1890 PyErr_SetString(PyExc_SystemError
,
1891 "Accessing non-existent array segment");
1894 *ptr
= (void *)self
->ob_item
;
1897 return Py_SIZE(self
)*self
->ob_descr
->itemsize
;
1901 array_buffer_getsegcount(arrayobject
*self
, Py_ssize_t
*lenp
)
1904 *lenp
= Py_SIZE(self
)*self
->ob_descr
->itemsize
;
1908 static PySequenceMethods array_as_sequence
= {
1909 (lenfunc
)array_length
, /*sq_length*/
1910 (binaryfunc
)array_concat
, /*sq_concat*/
1911 (ssizeargfunc
)array_repeat
, /*sq_repeat*/
1912 (ssizeargfunc
)array_item
, /*sq_item*/
1913 (ssizessizeargfunc
)array_slice
, /*sq_slice*/
1914 (ssizeobjargproc
)array_ass_item
, /*sq_ass_item*/
1915 (ssizessizeobjargproc
)array_ass_slice
, /*sq_ass_slice*/
1916 (objobjproc
)array_contains
, /*sq_contains*/
1917 (binaryfunc
)array_inplace_concat
, /*sq_inplace_concat*/
1918 (ssizeargfunc
)array_inplace_repeat
/*sq_inplace_repeat*/
1921 static PyBufferProcs array_as_buffer
= {
1922 (readbufferproc
)array_buffer_getreadbuf
,
1923 (writebufferproc
)array_buffer_getwritebuf
,
1924 (segcountproc
)array_buffer_getsegcount
,
1929 array_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwds
)
1932 PyObject
*initial
= NULL
, *it
= NULL
;
1933 struct arraydescr
*descr
;
1935 if (type
== &Arraytype
&& !_PyArg_NoKeywords("array.array()", kwds
))
1938 if (!PyArg_ParseTuple(args
, "c|O:array", &c
, &initial
))
1941 if (!(initial
== NULL
|| PyList_Check(initial
)
1942 || PyString_Check(initial
) || PyTuple_Check(initial
)
1943 || (c
== 'u' && PyUnicode_Check(initial
)))) {
1944 it
= PyObject_GetIter(initial
);
1947 /* We set initial to NULL so that the subsequent code
1948 will create an empty array of the appropriate type
1949 and afterwards we can use array_iter_extend to populate
1954 for (descr
= descriptors
; descr
->typecode
!= '\0'; descr
++) {
1955 if (descr
->typecode
== c
) {
1959 if (initial
== NULL
|| !(PyList_Check(initial
)
1960 || PyTuple_Check(initial
)))
1963 len
= PySequence_Size(initial
);
1965 a
= newarrayobject(type
, len
, descr
);
1971 for (i
= 0; i
< len
; i
++) {
1973 PySequence_GetItem(initial
, i
);
1978 if (setarrayitem(a
, i
, v
) != 0) {
1985 } else if (initial
!= NULL
&& PyString_Check(initial
)) {
1986 PyObject
*t_initial
, *v
;
1987 t_initial
= PyTuple_Pack(1, initial
);
1988 if (t_initial
== NULL
) {
1992 v
= array_fromstring((arrayobject
*)a
,
1994 Py_DECREF(t_initial
);
2000 #ifdef Py_USING_UNICODE
2001 } else if (initial
!= NULL
&& PyUnicode_Check(initial
)) {
2002 Py_ssize_t n
= PyUnicode_GET_DATA_SIZE(initial
);
2004 arrayobject
*self
= (arrayobject
*)a
;
2005 char *item
= self
->ob_item
;
2006 item
= (char *)PyMem_Realloc(item
, n
);
2012 self
->ob_item
= item
;
2013 Py_SIZE(self
) = n
/ sizeof(Py_UNICODE
);
2014 memcpy(item
, PyUnicode_AS_DATA(initial
), n
);
2015 self
->allocated
= Py_SIZE(self
);
2020 if (array_iter_extend((arrayobject
*)a
, it
) == -1) {
2030 PyErr_SetString(PyExc_ValueError
,
2031 "bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)");
2036 PyDoc_STRVAR(module_doc
,
2037 "This module defines an object type which can efficiently represent\n\
2038 an array of basic values: characters, integers, floating point\n\
2039 numbers. Arrays are sequence types and behave very much like lists,\n\
2040 except that the type of objects stored in them is constrained. The\n\
2041 type is specified at object creation time by using a type code, which\n\
2042 is a single character. The following type codes are defined:\n\
2044 Type code C Type Minimum size in bytes \n\
2046 'b' signed integer 1 \n\
2047 'B' unsigned integer 1 \n\
2048 'u' Unicode character 2 \n\
2049 'h' signed integer 2 \n\
2050 'H' unsigned integer 2 \n\
2051 'i' signed integer 2 \n\
2052 'I' unsigned integer 2 \n\
2053 'l' signed integer 4 \n\
2054 'L' unsigned integer 4 \n\
2055 'f' floating point 4 \n\
2056 'd' floating point 8 \n\
2058 The constructor is:\n\
2060 array(typecode [, initializer]) -- create a new array\n\
2063 PyDoc_STRVAR(arraytype_doc
,
2064 "array(typecode [, initializer]) -> array\n\
2066 Return a new array whose items are restricted by typecode, and\n\
2067 initialized from the optional initializer value, which must be a list,\n\
2068 string or iterable over elements of the appropriate type.\n\
2070 Arrays represent basic values and behave very much like lists, except\n\
2071 the type of objects stored in them is constrained.\n\
2075 append() -- append a new item to the end of the array\n\
2076 buffer_info() -- return information giving the current memory info\n\
2077 byteswap() -- byteswap all the items of the array\n\
2078 count() -- return number of occurrences of an object\n\
2079 extend() -- extend array by appending multiple elements from an iterable\n\
2080 fromfile() -- read items from a file object\n\
2081 fromlist() -- append items from the list\n\
2082 fromstring() -- append items from the string\n\
2083 index() -- return index of first occurrence of an object\n\
2084 insert() -- insert a new item into the array at a provided position\n\
2085 pop() -- remove and return item (default last)\n\
2086 read() -- DEPRECATED, use fromfile()\n\
2087 remove() -- remove first occurrence of an object\n\
2088 reverse() -- reverse the order of the items in the array\n\
2089 tofile() -- write all items to a file object\n\
2090 tolist() -- return the array converted to an ordinary list\n\
2091 tostring() -- return the array converted to a string\n\
2092 write() -- DEPRECATED, use tofile()\n\
2096 typecode -- the typecode character used to create the array\n\
2097 itemsize -- the length in bytes of one array item\n\
2100 static PyObject
*array_iter(arrayobject
*ao
);
2102 static PyTypeObject Arraytype
= {
2103 PyVarObject_HEAD_INIT(NULL
, 0)
2105 sizeof(arrayobject
),
2107 (destructor
)array_dealloc
, /* tp_dealloc */
2112 (reprfunc
)array_repr
, /* tp_repr */
2113 0, /* tp_as_number*/
2114 &array_as_sequence
, /* tp_as_sequence*/
2115 &array_as_mapping
, /* tp_as_mapping*/
2119 PyObject_GenericGetAttr
, /* tp_getattro */
2120 0, /* tp_setattro */
2121 &array_as_buffer
, /* tp_as_buffer*/
2122 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE
| Py_TPFLAGS_HAVE_WEAKREFS
, /* tp_flags */
2123 arraytype_doc
, /* tp_doc */
2124 0, /* tp_traverse */
2126 array_richcompare
, /* tp_richcompare */
2127 offsetof(arrayobject
, weakreflist
), /* tp_weaklistoffset */
2128 (getiterfunc
)array_iter
, /* tp_iter */
2129 0, /* tp_iternext */
2130 array_methods
, /* tp_methods */
2132 array_getsets
, /* tp_getset */
2135 0, /* tp_descr_get */
2136 0, /* tp_descr_set */
2137 0, /* tp_dictoffset */
2139 PyType_GenericAlloc
, /* tp_alloc */
2140 array_new
, /* tp_new */
2141 PyObject_Del
, /* tp_free */
2145 /*********************** Array Iterator **************************/
2151 PyObject
* (*getitem
)(struct arrayobject
*, Py_ssize_t
);
2154 static PyTypeObject PyArrayIter_Type
;
2156 #define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type)
2159 array_iter(arrayobject
*ao
)
2161 arrayiterobject
*it
;
2163 if (!array_Check(ao
)) {
2164 PyErr_BadInternalCall();
2168 it
= PyObject_GC_New(arrayiterobject
, &PyArrayIter_Type
);
2175 it
->getitem
= ao
->ob_descr
->getitem
;
2176 PyObject_GC_Track(it
);
2177 return (PyObject
*)it
;
2181 arrayiter_next(arrayiterobject
*it
)
2183 assert(PyArrayIter_Check(it
));
2184 if (it
->index
< Py_SIZE(it
->ao
))
2185 return (*it
->getitem
)(it
->ao
, it
->index
++);
2190 arrayiter_dealloc(arrayiterobject
*it
)
2192 PyObject_GC_UnTrack(it
);
2194 PyObject_GC_Del(it
);
2198 arrayiter_traverse(arrayiterobject
*it
, visitproc visit
, void *arg
)
2204 static PyTypeObject PyArrayIter_Type
= {
2205 PyVarObject_HEAD_INIT(NULL
, 0)
2206 "arrayiterator", /* tp_name */
2207 sizeof(arrayiterobject
), /* tp_basicsize */
2208 0, /* tp_itemsize */
2210 (destructor
)arrayiter_dealloc
, /* tp_dealloc */
2216 0, /* tp_as_number */
2217 0, /* tp_as_sequence */
2218 0, /* tp_as_mapping */
2222 PyObject_GenericGetAttr
, /* tp_getattro */
2223 0, /* tp_setattro */
2224 0, /* tp_as_buffer */
2225 Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_HAVE_GC
,/* tp_flags */
2227 (traverseproc
)arrayiter_traverse
, /* tp_traverse */
2229 0, /* tp_richcompare */
2230 0, /* tp_weaklistoffset */
2231 PyObject_SelfIter
, /* tp_iter */
2232 (iternextfunc
)arrayiter_next
, /* tp_iternext */
2237 /*********************** Install Module **************************/
2239 /* No functions in array module. */
2240 static PyMethodDef a_methods
[] = {
2241 {NULL
, NULL
, 0, NULL
} /* Sentinel */
2250 Arraytype
.ob_type
= &PyType_Type
;
2251 PyArrayIter_Type
.ob_type
= &PyType_Type
;
2252 m
= Py_InitModule3("array", a_methods
, module_doc
);
2256 Py_INCREF((PyObject
*)&Arraytype
);
2257 PyModule_AddObject(m
, "ArrayType", (PyObject
*)&Arraytype
);
2258 Py_INCREF((PyObject
*)&Arraytype
);
2259 PyModule_AddObject(m
, "array", (PyObject
*)&Arraytype
);
2260 /* No need to check the error here, the caller will do that */