blob: 5748a3c04758104ce1a2a72cc2b92e854774a5f8 [file] [log] [blame]
Guido van Rossum778983b1993-02-19 15:55:02 +00001/* Array object implementation */
2
3/* An array is a uniform list -- all items have the same type.
4 The item type is restricted to simple C types like int or float */
5
Martin v. Löwis18e16552006-02-15 17:27:45 +00006#define PY_SSIZE_T_CLEAN
Roger E. Masse2919eaa1996-12-09 20:10:36 +00007#include "Python.h"
Raymond Hettingercb87bc82004-05-31 00:35:52 +00008#include "structmember.h"
Roger E. Masse5817f8f1996-12-09 22:24:19 +00009
Guido van Rossum0c709541994-08-19 12:01:32 +000010#ifdef STDC_HEADERS
11#include <stddef.h>
Guido van Rossum7f1de831999-08-27 20:33:52 +000012#else /* !STDC_HEADERS */
Thomas Wouters0e3f5912006-08-11 14:57:12 +000013#ifdef HAVE_SYS_TYPES_H
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000014#include <sys/types.h> /* For size_t */
Thomas Wouters0e3f5912006-08-11 14:57:12 +000015#endif /* HAVE_SYS_TYPES_H */
Guido van Rossum7f1de831999-08-27 20:33:52 +000016#endif /* !STDC_HEADERS */
Guido van Rossum778983b1993-02-19 15:55:02 +000017
18struct arrayobject; /* Forward */
19
Tim Petersbb307342000-09-10 05:22:54 +000020/* All possible arraydescr values are defined in the vector "descriptors"
21 * below. That's defined later because the appropriate get and set
22 * functions aren't visible yet.
23 */
Guido van Rossum778983b1993-02-19 15:55:02 +000024struct arraydescr {
Victor Stinner9f0b51e2010-11-09 09:38:30 +000025 Py_UNICODE typecode;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000026 int itemsize;
27 PyObject * (*getitem)(struct arrayobject *, Py_ssize_t);
28 int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *);
29 char *formats;
30 int is_integer_type;
31 int is_signed;
Guido van Rossum778983b1993-02-19 15:55:02 +000032};
33
34typedef struct arrayobject {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000035 PyObject_VAR_HEAD
36 char *ob_item;
37 Py_ssize_t allocated;
38 struct arraydescr *ob_descr;
39 PyObject *weakreflist; /* List of weak references */
40 int ob_exports; /* Number of exported buffers */
Guido van Rossum778983b1993-02-19 15:55:02 +000041} arrayobject;
42
Jeremy Hylton938ace62002-07-17 16:30:39 +000043static PyTypeObject Arraytype;
Guido van Rossum778983b1993-02-19 15:55:02 +000044
Martin v. Löwis99866332002-03-01 10:27:01 +000045#define array_Check(op) PyObject_TypeCheck(op, &Arraytype)
Christian Heimes90aa7642007-12-19 02:45:37 +000046#define array_CheckExact(op) (Py_TYPE(op) == &Arraytype)
Guido van Rossum778983b1993-02-19 15:55:02 +000047
Raymond Hettinger6e2ee862004-03-14 04:37:50 +000048static int
Martin v. Löwis18e16552006-02-15 17:27:45 +000049array_resize(arrayobject *self, Py_ssize_t newsize)
Raymond Hettinger6e2ee862004-03-14 04:37:50 +000050{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000051 char *items;
52 size_t _new_size;
Raymond Hettinger6e2ee862004-03-14 04:37:50 +000053
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000054 if (self->ob_exports > 0 && newsize != Py_SIZE(self)) {
55 PyErr_SetString(PyExc_BufferError,
56 "cannot resize an array that is exporting buffers");
57 return -1;
58 }
Antoine Pitrou3ad3a0d2008-12-18 17:08:32 +000059
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000060 /* Bypass realloc() when a previous overallocation is large enough
61 to accommodate the newsize. If the newsize is 16 smaller than the
62 current size, then proceed with the realloc() to shrink the array.
63 */
Raymond Hettinger6e2ee862004-03-14 04:37:50 +000064
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000065 if (self->allocated >= newsize &&
66 Py_SIZE(self) < newsize + 16 &&
67 self->ob_item != NULL) {
68 Py_SIZE(self) = newsize;
69 return 0;
70 }
Raymond Hettinger6e2ee862004-03-14 04:37:50 +000071
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000072 if (newsize == 0) {
73 PyMem_FREE(self->ob_item);
74 self->ob_item = NULL;
75 Py_SIZE(self) = 0;
76 self->allocated = 0;
77 return 0;
78 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +000079
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000080 /* This over-allocates proportional to the array size, making room
81 * for additional growth. The over-allocation is mild, but is
82 * enough to give linear-time amortized behavior over a long
83 * sequence of appends() in the presence of a poorly-performing
84 * system realloc().
85 * The growth pattern is: 0, 4, 8, 16, 25, 34, 46, 56, 67, 79, ...
86 * Note, the pattern starts out the same as for lists but then
87 * grows at a smaller rate so that larger arrays only overallocate
88 * by about 1/16th -- this is done because arrays are presumed to be more
89 * memory critical.
90 */
Raymond Hettinger6e2ee862004-03-14 04:37:50 +000091
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000092 _new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize;
93 items = self->ob_item;
94 /* XXX The following multiplication and division does not optimize away
95 like it does for lists since the size is not known at compile time */
96 if (_new_size <= ((~(size_t)0) / self->ob_descr->itemsize))
97 PyMem_RESIZE(items, char, (_new_size * self->ob_descr->itemsize));
98 else
99 items = NULL;
100 if (items == NULL) {
101 PyErr_NoMemory();
102 return -1;
103 }
104 self->ob_item = items;
105 Py_SIZE(self) = newsize;
106 self->allocated = _new_size;
107 return 0;
Raymond Hettinger6e2ee862004-03-14 04:37:50 +0000108}
109
Tim Petersbb307342000-09-10 05:22:54 +0000110/****************************************************************************
111Get and Set functions for each type.
112A Get function takes an arrayobject* and an integer index, returning the
113array value at that index wrapped in an appropriate PyObject*.
114A Set function takes an arrayobject, integer index, and PyObject*; sets
115the array value at that index to the raw C data extracted from the PyObject*,
116and returns 0 if successful, else nonzero on failure (PyObject* not of an
117appropriate type or value).
118Note that the basic Get and Set functions do NOT check that the index is
119in bounds; that's the responsibility of the caller.
120****************************************************************************/
Guido van Rossum778983b1993-02-19 15:55:02 +0000121
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000122static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000123b_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossum778983b1993-02-19 15:55:02 +0000124{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000125 long x = ((char *)ap->ob_item)[i];
126 if (x >= 128)
127 x -= 256;
128 return PyLong_FromLong(x);
Guido van Rossum778983b1993-02-19 15:55:02 +0000129}
130
131static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000132b_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000133{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000134 short x;
135 /* PyArg_Parse's 'b' formatter is for an unsigned char, therefore
136 must use the next size up that is signed ('h') and manually do
137 the overflow checking */
138 if (!PyArg_Parse(v, "h;array item must be integer", &x))
139 return -1;
140 else if (x < -128) {
141 PyErr_SetString(PyExc_OverflowError,
142 "signed char is less than minimum");
143 return -1;
144 }
145 else if (x > 127) {
146 PyErr_SetString(PyExc_OverflowError,
147 "signed char is greater than maximum");
148 return -1;
149 }
150 if (i >= 0)
151 ((char *)ap->ob_item)[i] = (char)x;
152 return 0;
Guido van Rossum778983b1993-02-19 15:55:02 +0000153}
154
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000155static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000156BB_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossum549ab711997-01-03 19:09:47 +0000157{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000158 long x = ((unsigned char *)ap->ob_item)[i];
159 return PyLong_FromLong(x);
Guido van Rossum549ab711997-01-03 19:09:47 +0000160}
161
Fred Drake541dc3b2000-06-28 17:49:30 +0000162static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000163BB_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Fred Drake541dc3b2000-06-28 17:49:30 +0000164{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000165 unsigned char x;
166 /* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */
167 if (!PyArg_Parse(v, "b;array item must be integer", &x))
168 return -1;
169 if (i >= 0)
170 ((char *)ap->ob_item)[i] = x;
171 return 0;
Fred Drake541dc3b2000-06-28 17:49:30 +0000172}
Guido van Rossum549ab711997-01-03 19:09:47 +0000173
Martin v. Löwis99866332002-03-01 10:27:01 +0000174static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000175u_getitem(arrayobject *ap, Py_ssize_t i)
Martin v. Löwis99866332002-03-01 10:27:01 +0000176{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000177 return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1);
Martin v. Löwis99866332002-03-01 10:27:01 +0000178}
179
180static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000181u_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Martin v. Löwis99866332002-03-01 10:27:01 +0000182{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000183 Py_UNICODE *p;
184 Py_ssize_t len;
Martin v. Löwis99866332002-03-01 10:27:01 +0000185
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000186 if (!PyArg_Parse(v, "u#;array item must be unicode character", &p, &len))
187 return -1;
188 if (len != 1) {
189 PyErr_SetString(PyExc_TypeError,
190 "array item must be unicode character");
191 return -1;
192 }
193 if (i >= 0)
194 ((Py_UNICODE *)ap->ob_item)[i] = p[0];
195 return 0;
Martin v. Löwis99866332002-03-01 10:27:01 +0000196}
Martin v. Löwis99866332002-03-01 10:27:01 +0000197
Travis E. Oliphantd5c0add2007-10-12 22:05:15 +0000198
Guido van Rossum549ab711997-01-03 19:09:47 +0000199static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000200h_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossum778983b1993-02-19 15:55:02 +0000201{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000202 return PyLong_FromLong((long) ((short *)ap->ob_item)[i]);
Guido van Rossum778983b1993-02-19 15:55:02 +0000203}
204
Travis E. Oliphantd5c0add2007-10-12 22:05:15 +0000205
Guido van Rossum778983b1993-02-19 15:55:02 +0000206static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000207h_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000208{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000209 short x;
210 /* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */
211 if (!PyArg_Parse(v, "h;array item must be integer", &x))
212 return -1;
213 if (i >= 0)
214 ((short *)ap->ob_item)[i] = x;
215 return 0;
Guido van Rossum778983b1993-02-19 15:55:02 +0000216}
217
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000218static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000219HH_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossum549ab711997-01-03 19:09:47 +0000220{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000221 return PyLong_FromLong((long) ((unsigned short *)ap->ob_item)[i]);
Guido van Rossum549ab711997-01-03 19:09:47 +0000222}
223
Fred Drake541dc3b2000-06-28 17:49:30 +0000224static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000225HH_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Fred Drake541dc3b2000-06-28 17:49:30 +0000226{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000227 int x;
228 /* PyArg_Parse's 'h' formatter is for a signed short, therefore
229 must use the next size up and manually do the overflow checking */
230 if (!PyArg_Parse(v, "i;array item must be integer", &x))
231 return -1;
232 else if (x < 0) {
233 PyErr_SetString(PyExc_OverflowError,
234 "unsigned short is less than minimum");
235 return -1;
236 }
237 else if (x > USHRT_MAX) {
238 PyErr_SetString(PyExc_OverflowError,
239 "unsigned short is greater than maximum");
240 return -1;
241 }
242 if (i >= 0)
243 ((short *)ap->ob_item)[i] = (short)x;
244 return 0;
Fred Drake541dc3b2000-06-28 17:49:30 +0000245}
Guido van Rossum549ab711997-01-03 19:09:47 +0000246
247static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000248i_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossume77a7571993-11-03 15:01:26 +0000249{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000250 return PyLong_FromLong((long) ((int *)ap->ob_item)[i]);
Guido van Rossume77a7571993-11-03 15:01:26 +0000251}
252
253static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000254i_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Guido van Rossume77a7571993-11-03 15:01:26 +0000255{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000256 int x;
257 /* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */
258 if (!PyArg_Parse(v, "i;array item must be integer", &x))
259 return -1;
260 if (i >= 0)
261 ((int *)ap->ob_item)[i] = x;
262 return 0;
Guido van Rossume77a7571993-11-03 15:01:26 +0000263}
264
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000265static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000266II_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossum549ab711997-01-03 19:09:47 +0000267{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000268 return PyLong_FromUnsignedLong(
269 (unsigned long) ((unsigned int *)ap->ob_item)[i]);
Guido van Rossum549ab711997-01-03 19:09:47 +0000270}
271
272static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000273II_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Guido van Rossum549ab711997-01-03 19:09:47 +0000274{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000275 unsigned long x;
276 if (PyLong_Check(v)) {
277 x = PyLong_AsUnsignedLong(v);
278 if (x == (unsigned long) -1 && PyErr_Occurred())
279 return -1;
280 }
281 else {
282 long y;
283 if (!PyArg_Parse(v, "l;array item must be integer", &y))
284 return -1;
285 if (y < 0) {
286 PyErr_SetString(PyExc_OverflowError,
287 "unsigned int is less than minimum");
288 return -1;
289 }
290 x = (unsigned long)y;
Tim Petersbb307342000-09-10 05:22:54 +0000291
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000292 }
293 if (x > UINT_MAX) {
294 PyErr_SetString(PyExc_OverflowError,
295 "unsigned int is greater than maximum");
296 return -1;
297 }
Fred Drake541dc3b2000-06-28 17:49:30 +0000298
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000299 if (i >= 0)
300 ((unsigned int *)ap->ob_item)[i] = (unsigned int)x;
301 return 0;
Guido van Rossum549ab711997-01-03 19:09:47 +0000302}
303
304static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000305l_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossum778983b1993-02-19 15:55:02 +0000306{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000307 return PyLong_FromLong(((long *)ap->ob_item)[i]);
Guido van Rossum778983b1993-02-19 15:55:02 +0000308}
309
310static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000311l_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000312{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000313 long x;
314 if (!PyArg_Parse(v, "l;array item must be integer", &x))
315 return -1;
316 if (i >= 0)
317 ((long *)ap->ob_item)[i] = x;
318 return 0;
Guido van Rossum778983b1993-02-19 15:55:02 +0000319}
320
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000321static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000322LL_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossum549ab711997-01-03 19:09:47 +0000323{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000324 return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]);
Guido van Rossum549ab711997-01-03 19:09:47 +0000325}
326
327static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000328LL_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Guido van Rossum549ab711997-01-03 19:09:47 +0000329{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000330 unsigned long x;
331 if (PyLong_Check(v)) {
332 x = PyLong_AsUnsignedLong(v);
333 if (x == (unsigned long) -1 && PyErr_Occurred())
334 return -1;
335 }
336 else {
337 long y;
338 if (!PyArg_Parse(v, "l;array item must be integer", &y))
339 return -1;
340 if (y < 0) {
341 PyErr_SetString(PyExc_OverflowError,
342 "unsigned long is less than minimum");
343 return -1;
344 }
345 x = (unsigned long)y;
Tim Petersbb307342000-09-10 05:22:54 +0000346
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000347 }
348 if (x > ULONG_MAX) {
349 PyErr_SetString(PyExc_OverflowError,
350 "unsigned long is greater than maximum");
351 return -1;
352 }
Tim Petersbb307342000-09-10 05:22:54 +0000353
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000354 if (i >= 0)
355 ((unsigned long *)ap->ob_item)[i] = x;
356 return 0;
Guido van Rossum549ab711997-01-03 19:09:47 +0000357}
358
Meador Inge1c9f0c92011-09-20 19:55:51 -0500359#ifdef HAVE_LONG_LONG
360
361static PyObject *
362q_getitem(arrayobject *ap, Py_ssize_t i)
363{
364 return PyLong_FromLongLong(((PY_LONG_LONG *)ap->ob_item)[i]);
365}
366
367static int
368q_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
369{
370 PY_LONG_LONG x;
371 if (!PyArg_Parse(v, "L;array item must be integer", &x))
372 return -1;
373 if (i >= 0)
374 ((PY_LONG_LONG *)ap->ob_item)[i] = x;
375 return 0;
376}
377
378static PyObject *
379QQ_getitem(arrayobject *ap, Py_ssize_t i)
380{
381 return PyLong_FromUnsignedLongLong(
382 ((unsigned PY_LONG_LONG *)ap->ob_item)[i]);
383}
384
385static int
386QQ_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
387{
388 unsigned PY_LONG_LONG x;
389 if (PyLong_Check(v)) {
390 x = PyLong_AsUnsignedLongLong(v);
391 if (x == (unsigned PY_LONG_LONG) -1 && PyErr_Occurred())
392 return -1;
393 }
394 else {
395 PY_LONG_LONG y;
396 if (!PyArg_Parse(v, "L;array item must be integer", &y))
397 return -1;
398 if (y < 0) {
399 PyErr_SetString(PyExc_OverflowError,
400 "unsigned long long is less than minimum");
401 return -1;
402 }
403 x = (unsigned PY_LONG_LONG)y;
404 }
405
406 if (i >= 0)
407 ((unsigned PY_LONG_LONG *)ap->ob_item)[i] = x;
408 return 0;
409}
410#endif
411
Guido van Rossum549ab711997-01-03 19:09:47 +0000412static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000413f_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossum778983b1993-02-19 15:55:02 +0000414{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000415 return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]);
Guido van Rossum778983b1993-02-19 15:55:02 +0000416}
417
418static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000419f_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000420{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000421 float x;
422 if (!PyArg_Parse(v, "f;array item must be float", &x))
423 return -1;
424 if (i >= 0)
425 ((float *)ap->ob_item)[i] = x;
426 return 0;
Guido van Rossum778983b1993-02-19 15:55:02 +0000427}
428
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000429static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000430d_getitem(arrayobject *ap, Py_ssize_t i)
Guido van Rossum778983b1993-02-19 15:55:02 +0000431{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000432 return PyFloat_FromDouble(((double *)ap->ob_item)[i]);
Guido van Rossum778983b1993-02-19 15:55:02 +0000433}
434
435static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000436d_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000437{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000438 double x;
439 if (!PyArg_Parse(v, "d;array item must be float", &x))
440 return -1;
441 if (i >= 0)
442 ((double *)ap->ob_item)[i] = x;
443 return 0;
Guido van Rossum778983b1993-02-19 15:55:02 +0000444}
445
Travis E. Oliphantb99f7622007-08-18 11:21:56 +0000446
Alexandre Vassalottiad077152009-07-15 17:49:23 +0000447/* Description of types.
448 *
449 * Don't forget to update typecode_to_mformat_code() if you add a new
450 * typecode.
451 */
Guido van Rossum234f9421993-06-17 12:35:49 +0000452static struct arraydescr descriptors[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000453 {'b', 1, b_getitem, b_setitem, "b", 1, 1},
454 {'B', 1, BB_getitem, BB_setitem, "B", 1, 0},
455 {'u', sizeof(Py_UNICODE), u_getitem, u_setitem, "u", 0, 0},
456 {'h', sizeof(short), h_getitem, h_setitem, "h", 1, 1},
457 {'H', sizeof(short), HH_getitem, HH_setitem, "H", 1, 0},
458 {'i', sizeof(int), i_getitem, i_setitem, "i", 1, 1},
459 {'I', sizeof(int), II_getitem, II_setitem, "I", 1, 0},
460 {'l', sizeof(long), l_getitem, l_setitem, "l", 1, 1},
461 {'L', sizeof(long), LL_getitem, LL_setitem, "L", 1, 0},
Meador Inge1c9f0c92011-09-20 19:55:51 -0500462#ifdef HAVE_LONG_LONG
463 {'q', sizeof(PY_LONG_LONG), q_getitem, q_setitem, "q", 1, 1},
464 {'Q', sizeof(PY_LONG_LONG), QQ_getitem, QQ_setitem, "Q", 1, 0},
465#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000466 {'f', sizeof(float), f_getitem, f_setitem, "f", 0, 0},
467 {'d', sizeof(double), d_getitem, d_setitem, "d", 0, 0},
468 {'\0', 0, 0, 0, 0, 0, 0} /* Sentinel */
Guido van Rossum778983b1993-02-19 15:55:02 +0000469};
Tim Petersbb307342000-09-10 05:22:54 +0000470
471/****************************************************************************
472Implementations of array object methods.
473****************************************************************************/
Guido van Rossum778983b1993-02-19 15:55:02 +0000474
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000475static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000476newarrayobject(PyTypeObject *type, Py_ssize_t size, struct arraydescr *descr)
Guido van Rossum778983b1993-02-19 15:55:02 +0000477{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000478 arrayobject *op;
479 size_t nbytes;
Martin v. Löwis99866332002-03-01 10:27:01 +0000480
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000481 if (size < 0) {
482 PyErr_BadInternalCall();
483 return NULL;
484 }
Martin v. Löwis99866332002-03-01 10:27:01 +0000485
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000486 nbytes = size * descr->itemsize;
487 /* Check for overflow */
488 if (nbytes / descr->itemsize != (size_t)size) {
489 return PyErr_NoMemory();
490 }
491 op = (arrayobject *) type->tp_alloc(type, 0);
492 if (op == NULL) {
493 return NULL;
494 }
495 op->ob_descr = descr;
496 op->allocated = size;
497 op->weakreflist = NULL;
498 Py_SIZE(op) = size;
499 if (size <= 0) {
500 op->ob_item = NULL;
501 }
502 else {
503 op->ob_item = PyMem_NEW(char, nbytes);
504 if (op->ob_item == NULL) {
505 Py_DECREF(op);
506 return PyErr_NoMemory();
507 }
508 }
509 op->ob_exports = 0;
510 return (PyObject *) op;
Guido van Rossum778983b1993-02-19 15:55:02 +0000511}
512
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000513static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000514getarrayitem(PyObject *op, Py_ssize_t i)
Guido van Rossum778983b1993-02-19 15:55:02 +0000515{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000516 register arrayobject *ap;
517 assert(array_Check(op));
518 ap = (arrayobject *)op;
519 assert(i>=0 && i<Py_SIZE(ap));
520 return (*ap->ob_descr->getitem)(ap, i);
Guido van Rossum778983b1993-02-19 15:55:02 +0000521}
522
523static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000524ins1(arrayobject *self, Py_ssize_t where, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000525{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000526 char *items;
527 Py_ssize_t n = Py_SIZE(self);
528 if (v == NULL) {
529 PyErr_BadInternalCall();
530 return -1;
531 }
532 if ((*self->ob_descr->setitem)(self, -1, v) < 0)
533 return -1;
Raymond Hettinger6e2ee862004-03-14 04:37:50 +0000534
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000535 if (array_resize(self, n+1) == -1)
536 return -1;
537 items = self->ob_item;
538 if (where < 0) {
539 where += n;
540 if (where < 0)
541 where = 0;
542 }
543 if (where > n)
544 where = n;
545 /* appends don't need to call memmove() */
546 if (where != n)
547 memmove(items + (where+1)*self->ob_descr->itemsize,
548 items + where*self->ob_descr->itemsize,
549 (n-where)*self->ob_descr->itemsize);
550 return (*self->ob_descr->setitem)(self, where, v);
Guido van Rossum778983b1993-02-19 15:55:02 +0000551}
552
Guido van Rossum778983b1993-02-19 15:55:02 +0000553/* Methods */
554
555static void
Peter Schneider-Kamp9656abd2000-07-13 21:10:57 +0000556array_dealloc(arrayobject *op)
Guido van Rossum778983b1993-02-19 15:55:02 +0000557{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000558 if (op->weakreflist != NULL)
559 PyObject_ClearWeakRefs((PyObject *) op);
560 if (op->ob_item != NULL)
561 PyMem_DEL(op->ob_item);
562 Py_TYPE(op)->tp_free((PyObject *)op);
Guido van Rossum778983b1993-02-19 15:55:02 +0000563}
564
Guido van Rossum9d19cb82001-01-18 01:02:55 +0000565static PyObject *
566array_richcompare(PyObject *v, PyObject *w, int op)
Guido van Rossum778983b1993-02-19 15:55:02 +0000567{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000568 arrayobject *va, *wa;
569 PyObject *vi = NULL;
570 PyObject *wi = NULL;
571 Py_ssize_t i, k;
572 PyObject *res;
Guido van Rossum9d19cb82001-01-18 01:02:55 +0000573
Brian Curtindfc80e32011-08-10 20:28:54 -0500574 if (!array_Check(v) || !array_Check(w))
575 Py_RETURN_NOTIMPLEMENTED;
Guido van Rossum9d19cb82001-01-18 01:02:55 +0000576
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000577 va = (arrayobject *)v;
578 wa = (arrayobject *)w;
Guido van Rossum9d19cb82001-01-18 01:02:55 +0000579
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000580 if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ || op == Py_NE)) {
581 /* Shortcut: if the lengths differ, the arrays differ */
582 if (op == Py_EQ)
583 res = Py_False;
584 else
585 res = Py_True;
586 Py_INCREF(res);
587 return res;
588 }
Guido van Rossum9d19cb82001-01-18 01:02:55 +0000589
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000590 /* Search for the first index where items are different */
591 k = 1;
592 for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) {
593 vi = getarrayitem(v, i);
594 wi = getarrayitem(w, i);
595 if (vi == NULL || wi == NULL) {
596 Py_XDECREF(vi);
597 Py_XDECREF(wi);
598 return NULL;
599 }
600 k = PyObject_RichCompareBool(vi, wi, Py_EQ);
601 if (k == 0)
602 break; /* Keeping vi and wi alive! */
603 Py_DECREF(vi);
604 Py_DECREF(wi);
605 if (k < 0)
606 return NULL;
607 }
Guido van Rossum9d19cb82001-01-18 01:02:55 +0000608
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000609 if (k) {
610 /* No more items to compare -- compare sizes */
611 Py_ssize_t vs = Py_SIZE(va);
612 Py_ssize_t ws = Py_SIZE(wa);
613 int cmp;
614 switch (op) {
615 case Py_LT: cmp = vs < ws; break;
616 case Py_LE: cmp = vs <= ws; break;
617 case Py_EQ: cmp = vs == ws; break;
618 case Py_NE: cmp = vs != ws; break;
619 case Py_GT: cmp = vs > ws; break;
620 case Py_GE: cmp = vs >= ws; break;
621 default: return NULL; /* cannot happen */
622 }
623 if (cmp)
624 res = Py_True;
625 else
626 res = Py_False;
627 Py_INCREF(res);
628 return res;
629 }
Guido van Rossum9d19cb82001-01-18 01:02:55 +0000630
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000631 /* We have an item that differs. First, shortcuts for EQ/NE */
632 if (op == Py_EQ) {
633 Py_INCREF(Py_False);
634 res = Py_False;
635 }
636 else if (op == Py_NE) {
637 Py_INCREF(Py_True);
638 res = Py_True;
639 }
640 else {
641 /* Compare the final item again using the proper operator */
642 res = PyObject_RichCompare(vi, wi, op);
643 }
644 Py_DECREF(vi);
645 Py_DECREF(wi);
646 return res;
Guido van Rossum778983b1993-02-19 15:55:02 +0000647}
648
Martin v. Löwis18e16552006-02-15 17:27:45 +0000649static Py_ssize_t
Peter Schneider-Kamp9656abd2000-07-13 21:10:57 +0000650array_length(arrayobject *a)
Guido van Rossum778983b1993-02-19 15:55:02 +0000651{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000652 return Py_SIZE(a);
Guido van Rossum778983b1993-02-19 15:55:02 +0000653}
654
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000655static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000656array_item(arrayobject *a, Py_ssize_t i)
Guido van Rossum778983b1993-02-19 15:55:02 +0000657{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000658 if (i < 0 || i >= Py_SIZE(a)) {
659 PyErr_SetString(PyExc_IndexError, "array index out of range");
660 return NULL;
661 }
662 return getarrayitem((PyObject *)a, i);
Guido van Rossum778983b1993-02-19 15:55:02 +0000663}
664
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000665static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000666array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
Guido van Rossum778983b1993-02-19 15:55:02 +0000667{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000668 arrayobject *np;
669 if (ilow < 0)
670 ilow = 0;
671 else if (ilow > Py_SIZE(a))
672 ilow = Py_SIZE(a);
673 if (ihigh < 0)
674 ihigh = 0;
675 if (ihigh < ilow)
676 ihigh = ilow;
677 else if (ihigh > Py_SIZE(a))
678 ihigh = Py_SIZE(a);
679 np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);
680 if (np == NULL)
681 return NULL;
682 memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize,
683 (ihigh-ilow) * a->ob_descr->itemsize);
684 return (PyObject *)np;
Guido van Rossum778983b1993-02-19 15:55:02 +0000685}
686
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000687static PyObject *
Raymond Hettinger3aa82c02004-03-13 18:18:51 +0000688array_copy(arrayobject *a, PyObject *unused)
689{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000690 return array_slice(a, 0, Py_SIZE(a));
Raymond Hettinger3aa82c02004-03-13 18:18:51 +0000691}
692
693PyDoc_STRVAR(copy_doc,
694"copy(array)\n\
695\n\
696 Return a copy of the array.");
697
698static PyObject *
Peter Schneider-Kamp9656abd2000-07-13 21:10:57 +0000699array_concat(arrayobject *a, PyObject *bb)
Guido van Rossum778983b1993-02-19 15:55:02 +0000700{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000701 Py_ssize_t size;
702 arrayobject *np;
703 if (!array_Check(bb)) {
704 PyErr_Format(PyExc_TypeError,
705 "can only append array (not \"%.200s\") to array",
706 Py_TYPE(bb)->tp_name);
707 return NULL;
708 }
Guido van Rossum778983b1993-02-19 15:55:02 +0000709#define b ((arrayobject *)bb)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000710 if (a->ob_descr != b->ob_descr) {
711 PyErr_BadArgument();
712 return NULL;
713 }
714 if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) {
715 return PyErr_NoMemory();
716 }
717 size = Py_SIZE(a) + Py_SIZE(b);
718 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
719 if (np == NULL) {
720 return NULL;
721 }
722 memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize);
723 memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize,
724 b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
725 return (PyObject *)np;
Guido van Rossum778983b1993-02-19 15:55:02 +0000726#undef b
727}
728
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000729static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000730array_repeat(arrayobject *a, Py_ssize_t n)
Guido van Rossum778983b1993-02-19 15:55:02 +0000731{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000732 Py_ssize_t size;
733 arrayobject *np;
Georg Brandlc29cc6a2010-12-04 11:02:04 +0000734 Py_ssize_t oldbytes, newbytes;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000735 if (n < 0)
736 n = 0;
737 if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) {
738 return PyErr_NoMemory();
739 }
740 size = Py_SIZE(a) * n;
741 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
742 if (np == NULL)
743 return NULL;
Georg Brandlc29cc6a2010-12-04 11:02:04 +0000744 if (n == 0)
745 return (PyObject *)np;
746 oldbytes = Py_SIZE(a) * a->ob_descr->itemsize;
747 newbytes = oldbytes * n;
748 /* this follows the code in unicode_repeat */
749 if (oldbytes == 1) {
750 memset(np->ob_item, a->ob_item[0], newbytes);
751 } else {
752 Py_ssize_t done = oldbytes;
753 Py_MEMCPY(np->ob_item, a->ob_item, oldbytes);
754 while (done < newbytes) {
755 Py_ssize_t ncopy = (done <= newbytes-done) ? done : newbytes-done;
756 Py_MEMCPY(np->ob_item+done, np->ob_item, ncopy);
757 done += ncopy;
758 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000759 }
Georg Brandlc29cc6a2010-12-04 11:02:04 +0000760 return (PyObject *)np;
Guido van Rossum778983b1993-02-19 15:55:02 +0000761}
762
763static int
Martin v. Löwisad0a4622006-02-16 14:30:23 +0000764array_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000765{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000766 char *item;
767 Py_ssize_t n; /* Size of replacement array */
768 Py_ssize_t d; /* Change in size */
Guido van Rossum778983b1993-02-19 15:55:02 +0000769#define b ((arrayobject *)v)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000770 if (v == NULL)
771 n = 0;
772 else if (array_Check(v)) {
773 n = Py_SIZE(b);
774 if (a == b) {
775 /* Special case "a[i:j] = a" -- copy b first */
776 int ret;
777 v = array_slice(b, 0, n);
778 if (!v)
779 return -1;
780 ret = array_ass_slice(a, ilow, ihigh, v);
781 Py_DECREF(v);
782 return ret;
783 }
784 if (b->ob_descr != a->ob_descr) {
785 PyErr_BadArgument();
786 return -1;
787 }
788 }
789 else {
790 PyErr_Format(PyExc_TypeError,
791 "can only assign array (not \"%.200s\") to array slice",
792 Py_TYPE(v)->tp_name);
793 return -1;
794 }
795 if (ilow < 0)
796 ilow = 0;
797 else if (ilow > Py_SIZE(a))
798 ilow = Py_SIZE(a);
799 if (ihigh < 0)
800 ihigh = 0;
801 if (ihigh < ilow)
802 ihigh = ilow;
803 else if (ihigh > Py_SIZE(a))
804 ihigh = Py_SIZE(a);
805 item = a->ob_item;
806 d = n - (ihigh-ilow);
807 /* Issue #4509: If the array has exported buffers and the slice
808 assignment would change the size of the array, fail early to make
809 sure we don't modify it. */
810 if (d != 0 && a->ob_exports > 0) {
811 PyErr_SetString(PyExc_BufferError,
812 "cannot resize an array that is exporting buffers");
813 return -1;
814 }
815 if (d < 0) { /* Delete -d items */
816 memmove(item + (ihigh+d)*a->ob_descr->itemsize,
817 item + ihigh*a->ob_descr->itemsize,
818 (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
819 if (array_resize(a, Py_SIZE(a) + d) == -1)
820 return -1;
821 }
822 else if (d > 0) { /* Insert d items */
823 if (array_resize(a, Py_SIZE(a) + d))
824 return -1;
825 memmove(item + (ihigh+d)*a->ob_descr->itemsize,
826 item + ihigh*a->ob_descr->itemsize,
827 (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
828 }
829 if (n > 0)
830 memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
831 n*b->ob_descr->itemsize);
832 return 0;
Guido van Rossum778983b1993-02-19 15:55:02 +0000833#undef b
834}
835
836static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000837array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000838{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000839 if (i < 0 || i >= Py_SIZE(a)) {
840 PyErr_SetString(PyExc_IndexError,
841 "array assignment index out of range");
842 return -1;
843 }
844 if (v == NULL)
845 return array_ass_slice(a, i, i+1, v);
846 return (*a->ob_descr->setitem)(a, i, v);
Guido van Rossum778983b1993-02-19 15:55:02 +0000847}
848
849static int
Martin v. Löwis18e16552006-02-15 17:27:45 +0000850setarrayitem(PyObject *a, Py_ssize_t i, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000851{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000852 assert(array_Check(a));
853 return array_ass_item((arrayobject *)a, i, v);
Guido van Rossum778983b1993-02-19 15:55:02 +0000854}
855
Martin v. Löwis99866332002-03-01 10:27:01 +0000856static int
Raymond Hettinger49f9bd12004-03-14 05:43:59 +0000857array_iter_extend(arrayobject *self, PyObject *bb)
858{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000859 PyObject *it, *v;
Raymond Hettinger49f9bd12004-03-14 05:43:59 +0000860
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000861 it = PyObject_GetIter(bb);
862 if (it == NULL)
863 return -1;
Raymond Hettinger49f9bd12004-03-14 05:43:59 +0000864
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000865 while ((v = PyIter_Next(it)) != NULL) {
Mark Dickinson346f0af2010-08-06 09:36:57 +0000866 if (ins1(self, Py_SIZE(self), v) != 0) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000867 Py_DECREF(v);
868 Py_DECREF(it);
869 return -1;
870 }
871 Py_DECREF(v);
872 }
873 Py_DECREF(it);
874 if (PyErr_Occurred())
875 return -1;
876 return 0;
Raymond Hettinger49f9bd12004-03-14 05:43:59 +0000877}
878
879static int
Martin v. Löwis99866332002-03-01 10:27:01 +0000880array_do_extend(arrayobject *self, PyObject *bb)
881{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000882 Py_ssize_t size, oldsize, bbsize;
Martin v. Löwis99866332002-03-01 10:27:01 +0000883
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000884 if (!array_Check(bb))
885 return array_iter_extend(self, bb);
886#define b ((arrayobject *)bb)
887 if (self->ob_descr != b->ob_descr) {
888 PyErr_SetString(PyExc_TypeError,
889 "can only extend with array of same kind");
890 return -1;
891 }
892 if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) ||
893 ((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
894 PyErr_NoMemory();
895 return -1;
896 }
897 oldsize = Py_SIZE(self);
898 /* Get the size of bb before resizing the array since bb could be self. */
899 bbsize = Py_SIZE(bb);
900 size = oldsize + Py_SIZE(b);
901 if (array_resize(self, size) == -1)
902 return -1;
903 memcpy(self->ob_item + oldsize * self->ob_descr->itemsize,
904 b->ob_item, bbsize * b->ob_descr->itemsize);
905
906 return 0;
Martin v. Löwis99866332002-03-01 10:27:01 +0000907#undef b
908}
909
910static PyObject *
911array_inplace_concat(arrayobject *self, PyObject *bb)
912{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000913 if (!array_Check(bb)) {
914 PyErr_Format(PyExc_TypeError,
915 "can only extend array with array (not \"%.200s\")",
916 Py_TYPE(bb)->tp_name);
917 return NULL;
918 }
919 if (array_do_extend(self, bb) == -1)
920 return NULL;
921 Py_INCREF(self);
922 return (PyObject *)self;
Martin v. Löwis99866332002-03-01 10:27:01 +0000923}
924
925static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000926array_inplace_repeat(arrayobject *self, Py_ssize_t n)
Martin v. Löwis99866332002-03-01 10:27:01 +0000927{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000928 char *items, *p;
929 Py_ssize_t size, i;
Martin v. Löwis99866332002-03-01 10:27:01 +0000930
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000931 if (Py_SIZE(self) > 0) {
932 if (n < 0)
933 n = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000934 if ((self->ob_descr->itemsize != 0) &&
935 (Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
936 return PyErr_NoMemory();
937 }
938 size = Py_SIZE(self) * self->ob_descr->itemsize;
939 if (n > 0 && size > PY_SSIZE_T_MAX / n) {
940 return PyErr_NoMemory();
941 }
942 if (array_resize(self, n * Py_SIZE(self)) == -1)
943 return NULL;
944 items = p = self->ob_item;
945 for (i = 1; i < n; i++) {
946 p += size;
947 memcpy(p, items, size);
948 }
949 }
950 Py_INCREF(self);
951 return (PyObject *)self;
Martin v. Löwis99866332002-03-01 10:27:01 +0000952}
953
954
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000955static PyObject *
Martin v. Löwis18e16552006-02-15 17:27:45 +0000956ins(arrayobject *self, Py_ssize_t where, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +0000957{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000958 if (ins1(self, where, v) != 0)
959 return NULL;
960 Py_INCREF(Py_None);
961 return Py_None;
Guido van Rossum778983b1993-02-19 15:55:02 +0000962}
963
Roger E. Masse2919eaa1996-12-09 20:10:36 +0000964static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000965array_count(arrayobject *self, PyObject *v)
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +0000966{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000967 Py_ssize_t count = 0;
968 Py_ssize_t i;
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +0000969
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000970 for (i = 0; i < Py_SIZE(self); i++) {
971 PyObject *selfi = getarrayitem((PyObject *)self, i);
972 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
973 Py_DECREF(selfi);
974 if (cmp > 0)
975 count++;
976 else if (cmp < 0)
977 return NULL;
978 }
979 return PyLong_FromSsize_t(count);
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +0000980}
981
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000982PyDoc_STRVAR(count_doc,
Tim Peters077a11d2000-09-16 22:31:29 +0000983"count(x)\n\
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +0000984\n\
Mark Dickinson934896d2009-02-21 20:59:32 +0000985Return number of occurrences of x in the array.");
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +0000986
987static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +0000988array_index(arrayobject *self, PyObject *v)
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +0000989{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000990 Py_ssize_t i;
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +0000991
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000992 for (i = 0; i < Py_SIZE(self); i++) {
993 PyObject *selfi = getarrayitem((PyObject *)self, i);
994 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
995 Py_DECREF(selfi);
996 if (cmp > 0) {
997 return PyLong_FromLong((long)i);
998 }
999 else if (cmp < 0)
1000 return NULL;
1001 }
1002 PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list");
1003 return NULL;
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001004}
1005
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001006PyDoc_STRVAR(index_doc,
Tim Peters077a11d2000-09-16 22:31:29 +00001007"index(x)\n\
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001008\n\
Mark Dickinson934896d2009-02-21 20:59:32 +00001009Return index of first occurrence of x in the array.");
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001010
Raymond Hettinger625812f2003-01-07 01:58:52 +00001011static int
1012array_contains(arrayobject *self, PyObject *v)
1013{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001014 Py_ssize_t i;
1015 int cmp;
Raymond Hettinger625812f2003-01-07 01:58:52 +00001016
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001017 for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) {
1018 PyObject *selfi = getarrayitem((PyObject *)self, i);
1019 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
1020 Py_DECREF(selfi);
1021 }
1022 return cmp;
Raymond Hettinger625812f2003-01-07 01:58:52 +00001023}
1024
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001025static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001026array_remove(arrayobject *self, PyObject *v)
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001027{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001028 int i;
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001029
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001030 for (i = 0; i < Py_SIZE(self); i++) {
1031 PyObject *selfi = getarrayitem((PyObject *)self,i);
1032 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
1033 Py_DECREF(selfi);
1034 if (cmp > 0) {
1035 if (array_ass_slice(self, i, i+1,
1036 (PyObject *)NULL) != 0)
1037 return NULL;
1038 Py_INCREF(Py_None);
1039 return Py_None;
1040 }
1041 else if (cmp < 0)
1042 return NULL;
1043 }
1044 PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list");
1045 return NULL;
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001046}
1047
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001048PyDoc_STRVAR(remove_doc,
Tim Peters077a11d2000-09-16 22:31:29 +00001049"remove(x)\n\
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001050\n\
Mark Dickinson934896d2009-02-21 20:59:32 +00001051Remove the first occurrence of x in the array.");
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001052
1053static PyObject *
1054array_pop(arrayobject *self, PyObject *args)
1055{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001056 Py_ssize_t i = -1;
1057 PyObject *v;
1058 if (!PyArg_ParseTuple(args, "|n:pop", &i))
1059 return NULL;
1060 if (Py_SIZE(self) == 0) {
1061 /* Special-case most common failure cause */
1062 PyErr_SetString(PyExc_IndexError, "pop from empty array");
1063 return NULL;
1064 }
1065 if (i < 0)
1066 i += Py_SIZE(self);
1067 if (i < 0 || i >= Py_SIZE(self)) {
1068 PyErr_SetString(PyExc_IndexError, "pop index out of range");
1069 return NULL;
1070 }
1071 v = getarrayitem((PyObject *)self,i);
1072 if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) {
1073 Py_DECREF(v);
1074 return NULL;
1075 }
1076 return v;
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001077}
1078
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001079PyDoc_STRVAR(pop_doc,
Tim Peters077a11d2000-09-16 22:31:29 +00001080"pop([i])\n\
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001081\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001082Return the i-th element and delete it from the array. i defaults to -1.");
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001083
1084static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001085array_extend(arrayobject *self, PyObject *bb)
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001086{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001087 if (array_do_extend(self, bb) == -1)
1088 return NULL;
1089 Py_INCREF(Py_None);
1090 return Py_None;
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001091}
1092
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001093PyDoc_STRVAR(extend_doc,
Raymond Hettinger49f9bd12004-03-14 05:43:59 +00001094"extend(array or iterable)\n\
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001095\n\
Raymond Hettinger49f9bd12004-03-14 05:43:59 +00001096 Append items to the end of the array.");
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00001097
1098static PyObject *
Peter Schneider-Kamp9656abd2000-07-13 21:10:57 +00001099array_insert(arrayobject *self, PyObject *args)
Guido van Rossum778983b1993-02-19 15:55:02 +00001100{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001101 Py_ssize_t i;
1102 PyObject *v;
1103 if (!PyArg_ParseTuple(args, "nO:insert", &i, &v))
1104 return NULL;
1105 return ins(self, i, v);
Guido van Rossum778983b1993-02-19 15:55:02 +00001106}
1107
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001108PyDoc_STRVAR(insert_doc,
Tim Peters077a11d2000-09-16 22:31:29 +00001109"insert(i,x)\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001110\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001111Insert a new item x into the array before position i.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001112
1113
Roger E. Masse2919eaa1996-12-09 20:10:36 +00001114static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001115array_buffer_info(arrayobject *self, PyObject *unused)
Guido van Rossumde4a4ca1997-08-12 14:55:56 +00001116{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001117 PyObject* retval = NULL;
1118 retval = PyTuple_New(2);
1119 if (!retval)
1120 return NULL;
Fred Drake541dc3b2000-06-28 17:49:30 +00001121
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001122 PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
1123 PyTuple_SET_ITEM(retval, 1, PyLong_FromLong((long)(Py_SIZE(self))));
Fred Drake541dc3b2000-06-28 17:49:30 +00001124
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001125 return retval;
Guido van Rossumde4a4ca1997-08-12 14:55:56 +00001126}
1127
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001128PyDoc_STRVAR(buffer_info_doc,
Tim Peters077a11d2000-09-16 22:31:29 +00001129"buffer_info() -> (address, length)\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001130\n\
1131Return a tuple (address, length) giving the current memory address and\n\
Guido van Rossum702d08e2001-07-27 16:05:32 +00001132the length in items of the buffer used to hold array's contents\n\
1133The length should be multiplied by the itemsize attribute to calculate\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001134the buffer length in bytes.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001135
1136
Guido van Rossumde4a4ca1997-08-12 14:55:56 +00001137static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001138array_append(arrayobject *self, PyObject *v)
Guido van Rossum778983b1993-02-19 15:55:02 +00001139{
Mark Dickinson346f0af2010-08-06 09:36:57 +00001140 return ins(self, Py_SIZE(self), v);
Guido van Rossum778983b1993-02-19 15:55:02 +00001141}
1142
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001143PyDoc_STRVAR(append_doc,
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001144"append(x)\n\
1145\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001146Append new value x to the end of the array.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001147
1148
Roger E. Masse2919eaa1996-12-09 20:10:36 +00001149static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001150array_byteswap(arrayobject *self, PyObject *unused)
Guido van Rossum778983b1993-02-19 15:55:02 +00001151{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001152 char *p;
1153 Py_ssize_t i;
Fred Drakebf272981999-12-03 17:15:30 +00001154
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001155 switch (self->ob_descr->itemsize) {
1156 case 1:
1157 break;
1158 case 2:
1159 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) {
1160 char p0 = p[0];
1161 p[0] = p[1];
1162 p[1] = p0;
1163 }
1164 break;
1165 case 4:
1166 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) {
1167 char p0 = p[0];
1168 char p1 = p[1];
1169 p[0] = p[3];
1170 p[1] = p[2];
1171 p[2] = p1;
1172 p[3] = p0;
1173 }
1174 break;
1175 case 8:
1176 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) {
1177 char p0 = p[0];
1178 char p1 = p[1];
1179 char p2 = p[2];
1180 char p3 = p[3];
1181 p[0] = p[7];
1182 p[1] = p[6];
1183 p[2] = p[5];
1184 p[3] = p[4];
1185 p[4] = p3;
1186 p[5] = p2;
1187 p[6] = p1;
1188 p[7] = p0;
1189 }
1190 break;
1191 default:
1192 PyErr_SetString(PyExc_RuntimeError,
1193 "don't know how to byteswap this array type");
1194 return NULL;
1195 }
1196 Py_INCREF(Py_None);
1197 return Py_None;
Guido van Rossum778983b1993-02-19 15:55:02 +00001198}
1199
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001200PyDoc_STRVAR(byteswap_doc,
Fred Drakebf272981999-12-03 17:15:30 +00001201"byteswap()\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001202\n\
Fred Drakebf272981999-12-03 17:15:30 +00001203Byteswap all items of the array. If the items in the array are not 1, 2,\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +000012044, or 8 bytes in size, RuntimeError is raised.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001205
Roger E. Masse2919eaa1996-12-09 20:10:36 +00001206static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001207array_reverse(arrayobject *self, PyObject *unused)
Guido van Rossum778983b1993-02-19 15:55:02 +00001208{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001209 register Py_ssize_t itemsize = self->ob_descr->itemsize;
1210 register char *p, *q;
1211 /* little buffer to hold items while swapping */
1212 char tmp[256]; /* 8 is probably enough -- but why skimp */
1213 assert((size_t)itemsize <= sizeof(tmp));
Guido van Rossume77a7571993-11-03 15:01:26 +00001214
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001215 if (Py_SIZE(self) > 1) {
1216 for (p = self->ob_item,
1217 q = self->ob_item + (Py_SIZE(self) - 1)*itemsize;
1218 p < q;
1219 p += itemsize, q -= itemsize) {
1220 /* memory areas guaranteed disjoint, so memcpy
1221 * is safe (& memmove may be slower).
1222 */
1223 memcpy(tmp, p, itemsize);
1224 memcpy(p, q, itemsize);
1225 memcpy(q, tmp, itemsize);
1226 }
1227 }
Tim Petersbb307342000-09-10 05:22:54 +00001228
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001229 Py_INCREF(Py_None);
1230 return Py_None;
Guido van Rossum778983b1993-02-19 15:55:02 +00001231}
Guido van Rossume77a7571993-11-03 15:01:26 +00001232
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001233PyDoc_STRVAR(reverse_doc,
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001234"reverse()\n\
1235\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001236Reverse the order of the items in the array.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001237
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001238
1239/* Forward */
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001240static PyObject *array_frombytes(arrayobject *self, PyObject *args);
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001241
Roger E. Masse2919eaa1996-12-09 20:10:36 +00001242static PyObject *
Peter Schneider-Kamp9656abd2000-07-13 21:10:57 +00001243array_fromfile(arrayobject *self, PyObject *args)
Guido van Rossum778983b1993-02-19 15:55:02 +00001244{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001245 PyObject *f, *b, *res;
1246 Py_ssize_t itemsize = self->ob_descr->itemsize;
1247 Py_ssize_t n, nbytes;
1248 int not_enough_bytes;
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001249
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001250 if (!PyArg_ParseTuple(args, "On:fromfile", &f, &n))
1251 return NULL;
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001252
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001253 nbytes = n * itemsize;
1254 if (nbytes < 0 || nbytes/itemsize != n) {
1255 PyErr_NoMemory();
1256 return NULL;
1257 }
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001258
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001259 b = PyObject_CallMethod(f, "read", "n", nbytes);
1260 if (b == NULL)
1261 return NULL;
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001262
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001263 if (!PyBytes_Check(b)) {
1264 PyErr_SetString(PyExc_TypeError,
1265 "read() didn't return bytes");
1266 Py_DECREF(b);
1267 return NULL;
1268 }
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001269
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001270 not_enough_bytes = (PyBytes_GET_SIZE(b) != nbytes);
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001271
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001272 args = Py_BuildValue("(O)", b);
1273 Py_DECREF(b);
1274 if (args == NULL)
1275 return NULL;
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001276
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001277 res = array_frombytes(self, args);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001278 Py_DECREF(args);
1279 if (res == NULL)
1280 return NULL;
Hirokazu Yamamoto54d0df62009-03-06 03:04:07 +00001281
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001282 if (not_enough_bytes) {
1283 PyErr_SetString(PyExc_EOFError,
1284 "read() didn't return enough bytes");
1285 Py_DECREF(res);
1286 return NULL;
1287 }
Guido van Rossum2c94aa52007-05-24 19:02:32 +00001288
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001289 return res;
Guido van Rossum778983b1993-02-19 15:55:02 +00001290}
1291
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001292PyDoc_STRVAR(fromfile_doc,
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001293"fromfile(f, n)\n\
1294\n\
1295Read n objects from the file object f and append them to the end of the\n\
Georg Brandlf25ef502008-02-01 11:30:18 +00001296array.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001297
1298
Roger E. Masse2919eaa1996-12-09 20:10:36 +00001299static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001300array_tofile(arrayobject *self, PyObject *f)
Guido van Rossum778983b1993-02-19 15:55:02 +00001301{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001302 Py_ssize_t nbytes = Py_SIZE(self) * self->ob_descr->itemsize;
1303 /* Write 64K blocks at a time */
1304 /* XXX Make the block size settable */
1305 int BLOCKSIZE = 64*1024;
1306 Py_ssize_t nblocks = (nbytes + BLOCKSIZE - 1) / BLOCKSIZE;
1307 Py_ssize_t i;
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001308
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001309 if (Py_SIZE(self) == 0)
1310 goto done;
Guido van Rossumb5ddcfd2007-04-11 17:08:28 +00001311
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001312 for (i = 0; i < nblocks; i++) {
1313 char* ptr = self->ob_item + i*BLOCKSIZE;
1314 Py_ssize_t size = BLOCKSIZE;
1315 PyObject *bytes, *res;
1316 if (i*BLOCKSIZE + size > nbytes)
1317 size = nbytes - i*BLOCKSIZE;
1318 bytes = PyBytes_FromStringAndSize(ptr, size);
1319 if (bytes == NULL)
1320 return NULL;
1321 res = PyObject_CallMethod(f, "write", "O", bytes);
1322 Py_DECREF(bytes);
1323 if (res == NULL)
1324 return NULL;
1325 Py_DECREF(res); /* drop write result */
1326 }
Guido van Rossumb5ddcfd2007-04-11 17:08:28 +00001327
1328 done:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001329 Py_INCREF(Py_None);
1330 return Py_None;
Guido van Rossum778983b1993-02-19 15:55:02 +00001331}
1332
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001333PyDoc_STRVAR(tofile_doc,
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001334"tofile(f)\n\
1335\n\
Georg Brandlf25ef502008-02-01 11:30:18 +00001336Write all items (as machine values) to the file object f.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001337
1338
Roger E. Masse2919eaa1996-12-09 20:10:36 +00001339static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001340array_fromlist(arrayobject *self, PyObject *list)
Guido van Rossum778983b1993-02-19 15:55:02 +00001341{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001342 Py_ssize_t n;
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001343
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001344 if (!PyList_Check(list)) {
1345 PyErr_SetString(PyExc_TypeError, "arg must be list");
1346 return NULL;
1347 }
1348 n = PyList_Size(list);
1349 if (n > 0) {
1350 Py_ssize_t i, old_size;
1351 old_size = Py_SIZE(self);
1352 if (array_resize(self, old_size + n) == -1)
1353 return NULL;
1354 for (i = 0; i < n; i++) {
1355 PyObject *v = PyList_GetItem(list, i);
1356 if ((*self->ob_descr->setitem)(self,
1357 Py_SIZE(self) - n + i, v) != 0) {
1358 array_resize(self, old_size);
1359 return NULL;
1360 }
1361 }
1362 }
1363 Py_INCREF(Py_None);
1364 return Py_None;
Guido van Rossum778983b1993-02-19 15:55:02 +00001365}
1366
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001367PyDoc_STRVAR(fromlist_doc,
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001368"fromlist(list)\n\
1369\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001370Append items to array from list.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001371
Roger E. Masse2919eaa1996-12-09 20:10:36 +00001372static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001373array_tolist(arrayobject *self, PyObject *unused)
Guido van Rossum778983b1993-02-19 15:55:02 +00001374{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001375 PyObject *list = PyList_New(Py_SIZE(self));
1376 Py_ssize_t i;
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001377
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001378 if (list == NULL)
1379 return NULL;
1380 for (i = 0; i < Py_SIZE(self); i++) {
1381 PyObject *v = getarrayitem((PyObject *)self, i);
1382 if (v == NULL) {
1383 Py_DECREF(list);
1384 return NULL;
1385 }
1386 PyList_SetItem(list, i, v);
1387 }
1388 return list;
Guido van Rossum778983b1993-02-19 15:55:02 +00001389}
1390
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001391PyDoc_STRVAR(tolist_doc,
Guido van Rossumfc6aba51998-10-14 02:52:31 +00001392"tolist() -> list\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001393\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001394Convert array to an ordinary list with the same items.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001395
Roger E. Masse2919eaa1996-12-09 20:10:36 +00001396static PyObject *
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001397frombytes(arrayobject *self, Py_buffer *buffer)
Guido van Rossum778983b1993-02-19 15:55:02 +00001398{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001399 int itemsize = self->ob_descr->itemsize;
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001400 Py_ssize_t n;
1401 if (buffer->itemsize != 1) {
1402 PyBuffer_Release(buffer);
1403 PyErr_SetString(PyExc_TypeError, "string/buffer of bytes required.");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001404 return NULL;
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001405 }
1406 n = buffer->len;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001407 if (n % itemsize != 0) {
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001408 PyBuffer_Release(buffer);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001409 PyErr_SetString(PyExc_ValueError,
1410 "string length not a multiple of item size");
1411 return NULL;
1412 }
1413 n = n / itemsize;
1414 if (n > 0) {
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001415 Py_ssize_t old_size = Py_SIZE(self);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001416 if ((n > PY_SSIZE_T_MAX - old_size) ||
1417 ((old_size + n) > PY_SSIZE_T_MAX / itemsize)) {
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001418 PyBuffer_Release(buffer);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001419 return PyErr_NoMemory();
1420 }
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001421 if (array_resize(self, old_size + n) == -1) {
1422 PyBuffer_Release(buffer);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001423 return NULL;
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001424 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001425 memcpy(self->ob_item + old_size * itemsize,
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001426 buffer->buf, n * itemsize);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001427 }
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001428 PyBuffer_Release(buffer);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001429 Py_INCREF(Py_None);
1430 return Py_None;
Guido van Rossum778983b1993-02-19 15:55:02 +00001431}
1432
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001433static PyObject *
1434array_fromstring(arrayobject *self, PyObject *args)
1435{
1436 Py_buffer buffer;
1437 if (PyErr_WarnEx(PyExc_DeprecationWarning,
1438 "fromstring() is deprecated. Use frombytes() instead.", 2) != 0)
1439 return NULL;
1440 if (!PyArg_ParseTuple(args, "s*:fromstring", &buffer))
1441 return NULL;
1442 else
1443 return frombytes(self, &buffer);
1444}
1445
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001446PyDoc_STRVAR(fromstring_doc,
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001447"fromstring(string)\n\
1448\n\
1449Appends items from the string, interpreting it as an array of machine\n\
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001450values, as if it had been read from a file using the fromfile() method).\n\
1451\n\
1452This method is deprecated. Use frombytes instead.");
1453
1454
1455static PyObject *
1456array_frombytes(arrayobject *self, PyObject *args)
1457{
1458 Py_buffer buffer;
1459 if (!PyArg_ParseTuple(args, "y*:frombytes", &buffer))
1460 return NULL;
1461 else
1462 return frombytes(self, &buffer);
1463}
1464
1465PyDoc_STRVAR(frombytes_doc,
1466"frombytes(bytestring)\n\
1467\n\
1468Appends items from the string, interpreting it as an array of machine\n\
Walter Dörwald93b30b52007-06-22 12:21:53 +00001469values, as if it had been read from a file using the fromfile() method).");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001470
1471
Roger E. Masse2919eaa1996-12-09 20:10:36 +00001472static PyObject *
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001473array_tobytes(arrayobject *self, PyObject *unused)
Guido van Rossum778983b1993-02-19 15:55:02 +00001474{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001475 if (Py_SIZE(self) <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) {
1476 return PyBytes_FromStringAndSize(self->ob_item,
1477 Py_SIZE(self) * self->ob_descr->itemsize);
1478 } else {
1479 return PyErr_NoMemory();
1480 }
Guido van Rossum778983b1993-02-19 15:55:02 +00001481}
1482
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001483PyDoc_STRVAR(tobytes_doc,
1484"tobytes() -> bytes\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001485\n\
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001486Convert the array to an array of machine values and return the bytes\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001487representation.");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00001488
Martin v. Löwis99866332002-03-01 10:27:01 +00001489
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001490static PyObject *
1491array_tostring(arrayobject *self, PyObject *unused)
1492{
Victor Stinner9f0b51e2010-11-09 09:38:30 +00001493 if (PyErr_WarnEx(PyExc_DeprecationWarning,
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001494 "tostring() is deprecated. Use tobytes() instead.", 2) != 0)
1495 return NULL;
1496 return array_tobytes(self, unused);
1497}
1498
1499PyDoc_STRVAR(tostring_doc,
1500"tostring() -> bytes\n\
1501\n\
1502Convert the array to an array of machine values and return the bytes\n\
1503representation.\n\
1504\n\
1505This method is deprecated. Use tobytes instead.");
1506
Martin v. Löwis99866332002-03-01 10:27:01 +00001507
Martin v. Löwis99866332002-03-01 10:27:01 +00001508static PyObject *
1509array_fromunicode(arrayobject *self, PyObject *args)
1510{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001511 Py_UNICODE *ustr;
1512 Py_ssize_t n;
Amaury Forgeot d'Arc24aa26b2010-11-25 08:13:35 +00001513 Py_UNICODE typecode;
Martin v. Löwis99866332002-03-01 10:27:01 +00001514
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001515 if (!PyArg_ParseTuple(args, "u#:fromunicode", &ustr, &n))
1516 return NULL;
1517 typecode = self->ob_descr->typecode;
1518 if ((typecode != 'u')) {
1519 PyErr_SetString(PyExc_ValueError,
1520 "fromunicode() may only be called on "
1521 "unicode type arrays");
1522 return NULL;
1523 }
1524 if (n > 0) {
1525 Py_ssize_t old_size = Py_SIZE(self);
1526 if (array_resize(self, old_size + n) == -1)
1527 return NULL;
1528 memcpy(self->ob_item + old_size * sizeof(Py_UNICODE),
1529 ustr, n * sizeof(Py_UNICODE));
1530 }
Martin v. Löwis99866332002-03-01 10:27:01 +00001531
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001532 Py_INCREF(Py_None);
1533 return Py_None;
Martin v. Löwis99866332002-03-01 10:27:01 +00001534}
1535
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001536PyDoc_STRVAR(fromunicode_doc,
Martin v. Löwis99866332002-03-01 10:27:01 +00001537"fromunicode(ustr)\n\
1538\n\
1539Extends this array with data from the unicode string ustr.\n\
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001540The array must be a unicode type array; otherwise a ValueError\n\
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00001541is raised. Use array.frombytes(ustr.decode(...)) to\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001542append Unicode data to an array of some other type.");
Martin v. Löwis99866332002-03-01 10:27:01 +00001543
1544
1545static PyObject *
Raymond Hettinger36cd2bf2003-01-03 08:24:58 +00001546array_tounicode(arrayobject *self, PyObject *unused)
Martin v. Löwis99866332002-03-01 10:27:01 +00001547{
Amaury Forgeot d'Arc24aa26b2010-11-25 08:13:35 +00001548 Py_UNICODE typecode;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001549 typecode = self->ob_descr->typecode;
1550 if ((typecode != 'u')) {
1551 PyErr_SetString(PyExc_ValueError,
1552 "tounicode() may only be called on unicode type arrays");
1553 return NULL;
1554 }
1555 return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self));
Martin v. Löwis99866332002-03-01 10:27:01 +00001556}
1557
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001558PyDoc_STRVAR(tounicode_doc,
Martin v. Löwis99866332002-03-01 10:27:01 +00001559"tounicode() -> unicode\n\
1560\n\
1561Convert the array to a unicode string. The array must be\n\
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00001562a unicode type array; otherwise a ValueError is raised. Use\n\
Martin v. Löwis99866332002-03-01 10:27:01 +00001563array.tostring().decode() to obtain a unicode string from\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001564an array of some other type.");
Martin v. Löwis99866332002-03-01 10:27:01 +00001565
Martin v. Löwis99866332002-03-01 10:27:01 +00001566
1567
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001568/*********************** Pickling support ************************/
1569
1570enum machine_format_code {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001571 UNKNOWN_FORMAT = -1,
1572 /* UNKNOWN_FORMAT is used to indicate that the machine format for an
1573 * array type code cannot be interpreted. When this occurs, a list of
1574 * Python objects is used to represent the content of the array
1575 * instead of using the memory content of the array directly. In that
1576 * case, the array_reconstructor mechanism is bypassed completely, and
1577 * the standard array constructor is used instead.
1578 *
1579 * This is will most likely occur when the machine doesn't use IEEE
1580 * floating-point numbers.
1581 */
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001582
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001583 UNSIGNED_INT8 = 0,
1584 SIGNED_INT8 = 1,
1585 UNSIGNED_INT16_LE = 2,
1586 UNSIGNED_INT16_BE = 3,
1587 SIGNED_INT16_LE = 4,
1588 SIGNED_INT16_BE = 5,
1589 UNSIGNED_INT32_LE = 6,
1590 UNSIGNED_INT32_BE = 7,
1591 SIGNED_INT32_LE = 8,
1592 SIGNED_INT32_BE = 9,
1593 UNSIGNED_INT64_LE = 10,
1594 UNSIGNED_INT64_BE = 11,
1595 SIGNED_INT64_LE = 12,
1596 SIGNED_INT64_BE = 13,
1597 IEEE_754_FLOAT_LE = 14,
1598 IEEE_754_FLOAT_BE = 15,
1599 IEEE_754_DOUBLE_LE = 16,
1600 IEEE_754_DOUBLE_BE = 17,
1601 UTF16_LE = 18,
1602 UTF16_BE = 19,
1603 UTF32_LE = 20,
1604 UTF32_BE = 21
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001605};
1606#define MACHINE_FORMAT_CODE_MIN 0
1607#define MACHINE_FORMAT_CODE_MAX 21
1608
1609static const struct mformatdescr {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001610 size_t size;
1611 int is_signed;
1612 int is_big_endian;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001613} mformat_descriptors[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001614 {1, 0, 0}, /* 0: UNSIGNED_INT8 */
1615 {1, 1, 0}, /* 1: SIGNED_INT8 */
1616 {2, 0, 0}, /* 2: UNSIGNED_INT16_LE */
1617 {2, 0, 1}, /* 3: UNSIGNED_INT16_BE */
1618 {2, 1, 0}, /* 4: SIGNED_INT16_LE */
1619 {2, 1, 1}, /* 5: SIGNED_INT16_BE */
1620 {4, 0, 0}, /* 6: UNSIGNED_INT32_LE */
1621 {4, 0, 1}, /* 7: UNSIGNED_INT32_BE */
1622 {4, 1, 0}, /* 8: SIGNED_INT32_LE */
1623 {4, 1, 1}, /* 9: SIGNED_INT32_BE */
1624 {8, 0, 0}, /* 10: UNSIGNED_INT64_LE */
1625 {8, 0, 1}, /* 11: UNSIGNED_INT64_BE */
1626 {8, 1, 0}, /* 12: SIGNED_INT64_LE */
1627 {8, 1, 1}, /* 13: SIGNED_INT64_BE */
1628 {4, 0, 0}, /* 14: IEEE_754_FLOAT_LE */
1629 {4, 0, 1}, /* 15: IEEE_754_FLOAT_BE */
1630 {8, 0, 0}, /* 16: IEEE_754_DOUBLE_LE */
1631 {8, 0, 1}, /* 17: IEEE_754_DOUBLE_BE */
1632 {4, 0, 0}, /* 18: UTF16_LE */
1633 {4, 0, 1}, /* 19: UTF16_BE */
1634 {8, 0, 0}, /* 20: UTF32_LE */
1635 {8, 0, 1} /* 21: UTF32_BE */
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001636};
1637
1638
1639/*
1640 * Internal: This function is used to find the machine format of a given
1641 * array type code. This returns UNKNOWN_FORMAT when the machine format cannot
1642 * be found.
1643 */
1644static enum machine_format_code
1645typecode_to_mformat_code(int typecode)
1646{
Alexandre Vassalotti7aaa7702009-07-17 03:51:27 +00001647#ifdef WORDS_BIGENDIAN
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001648 const int is_big_endian = 1;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001649#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001650 const int is_big_endian = 0;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001651#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001652 size_t intsize;
1653 int is_signed;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001654
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001655 switch (typecode) {
1656 case 'b':
1657 return SIGNED_INT8;
1658 case 'B':
1659 return UNSIGNED_INT8;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001660
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001661 case 'u':
1662 if (sizeof(Py_UNICODE) == 2) {
1663 return UTF16_LE + is_big_endian;
1664 }
1665 if (sizeof(Py_UNICODE) == 4) {
1666 return UTF32_LE + is_big_endian;
1667 }
1668 return UNKNOWN_FORMAT;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001669
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001670 case 'f':
1671 if (sizeof(float) == 4) {
1672 const float y = 16711938.0;
1673 if (memcmp(&y, "\x4b\x7f\x01\x02", 4) == 0)
1674 return IEEE_754_FLOAT_BE;
1675 if (memcmp(&y, "\x02\x01\x7f\x4b", 4) == 0)
1676 return IEEE_754_FLOAT_LE;
1677 }
1678 return UNKNOWN_FORMAT;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001679
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001680 case 'd':
1681 if (sizeof(double) == 8) {
1682 const double x = 9006104071832581.0;
1683 if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0)
1684 return IEEE_754_DOUBLE_BE;
1685 if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0)
1686 return IEEE_754_DOUBLE_LE;
1687 }
1688 return UNKNOWN_FORMAT;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001689
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001690 /* Integers */
1691 case 'h':
1692 intsize = sizeof(short);
1693 is_signed = 1;
1694 break;
1695 case 'H':
1696 intsize = sizeof(short);
1697 is_signed = 0;
1698 break;
1699 case 'i':
1700 intsize = sizeof(int);
1701 is_signed = 1;
1702 break;
1703 case 'I':
1704 intsize = sizeof(int);
1705 is_signed = 0;
1706 break;
1707 case 'l':
1708 intsize = sizeof(long);
1709 is_signed = 1;
1710 break;
1711 case 'L':
1712 intsize = sizeof(long);
1713 is_signed = 0;
1714 break;
Meador Inge1c9f0c92011-09-20 19:55:51 -05001715#if HAVE_LONG_LONG
1716 case 'q':
1717 intsize = sizeof(PY_LONG_LONG);
1718 is_signed = 1;
1719 break;
1720 case 'Q':
1721 intsize = sizeof(PY_LONG_LONG);
1722 is_signed = 0;
1723 break;
1724#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001725 default:
1726 return UNKNOWN_FORMAT;
1727 }
1728 switch (intsize) {
1729 case 2:
1730 return UNSIGNED_INT16_LE + is_big_endian + (2 * is_signed);
1731 case 4:
1732 return UNSIGNED_INT32_LE + is_big_endian + (2 * is_signed);
1733 case 8:
1734 return UNSIGNED_INT64_LE + is_big_endian + (2 * is_signed);
1735 default:
1736 return UNKNOWN_FORMAT;
1737 }
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001738}
1739
1740/* Forward declaration. */
1741static PyObject *array_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
1742
1743/*
1744 * Internal: This function wraps the array constructor--i.e., array_new()--to
1745 * allow the creation of array objects from C code without having to deal
1746 * directly the tuple argument of array_new(). The typecode argument is a
1747 * Unicode character value, like 'i' or 'f' for example, representing an array
1748 * type code. The items argument is a bytes or a list object from which
1749 * contains the initial value of the array.
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001750 *
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001751 * On success, this functions returns the array object created. Otherwise,
1752 * NULL is returned to indicate a failure.
1753 */
1754static PyObject *
Victor Stinner9f0b51e2010-11-09 09:38:30 +00001755make_array(PyTypeObject *arraytype, Py_UNICODE typecode, PyObject *items)
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001756{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001757 PyObject *new_args;
1758 PyObject *array_obj;
1759 PyObject *typecode_obj;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001760
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001761 assert(arraytype != NULL);
1762 assert(items != NULL);
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001763
Victor Stinner9f0b51e2010-11-09 09:38:30 +00001764 typecode_obj = PyUnicode_FromUnicode(&typecode, 1);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001765 if (typecode_obj == NULL)
1766 return NULL;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001767
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001768 new_args = PyTuple_New(2);
1769 if (new_args == NULL)
1770 return NULL;
1771 Py_INCREF(items);
1772 PyTuple_SET_ITEM(new_args, 0, typecode_obj);
1773 PyTuple_SET_ITEM(new_args, 1, items);
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001774
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001775 array_obj = array_new(arraytype, new_args, NULL);
1776 Py_DECREF(new_args);
1777 if (array_obj == NULL)
1778 return NULL;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001779
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001780 return array_obj;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001781}
1782
1783/*
1784 * This functions is a special constructor used when unpickling an array. It
1785 * provides a portable way to rebuild an array from its memory representation.
1786 */
1787static PyObject *
1788array_reconstructor(PyObject *self, PyObject *args)
1789{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001790 PyTypeObject *arraytype;
1791 PyObject *items;
1792 PyObject *converted_items;
1793 PyObject *result;
Victor Stinner9f0b51e2010-11-09 09:38:30 +00001794 int typecode_int;
1795 Py_UNICODE typecode;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001796 enum machine_format_code mformat_code;
1797 struct arraydescr *descr;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001798
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001799 if (!PyArg_ParseTuple(args, "OCiO:array._array_reconstructor",
Victor Stinner9f0b51e2010-11-09 09:38:30 +00001800 &arraytype, &typecode_int, &mformat_code, &items))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001801 return NULL;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001802
Victor Stinner9f0b51e2010-11-09 09:38:30 +00001803 typecode = (Py_UNICODE)typecode_int;
1804
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001805 if (!PyType_Check(arraytype)) {
1806 PyErr_Format(PyExc_TypeError,
1807 "first argument must a type object, not %.200s",
1808 Py_TYPE(arraytype)->tp_name);
1809 return NULL;
1810 }
1811 if (!PyType_IsSubtype(arraytype, &Arraytype)) {
1812 PyErr_Format(PyExc_TypeError,
1813 "%.200s is not a subtype of %.200s",
1814 arraytype->tp_name, Arraytype.tp_name);
1815 return NULL;
1816 }
1817 for (descr = descriptors; descr->typecode != '\0'; descr++) {
1818 if (descr->typecode == typecode)
1819 break;
1820 }
1821 if (descr->typecode == '\0') {
1822 PyErr_SetString(PyExc_ValueError,
1823 "second argument must be a valid type code");
1824 return NULL;
1825 }
1826 if (mformat_code < MACHINE_FORMAT_CODE_MIN ||
1827 mformat_code > MACHINE_FORMAT_CODE_MAX) {
1828 PyErr_SetString(PyExc_ValueError,
1829 "third argument must be a valid machine format code.");
1830 return NULL;
1831 }
1832 if (!PyBytes_Check(items)) {
1833 PyErr_Format(PyExc_TypeError,
1834 "fourth argument should be bytes, not %.200s",
1835 Py_TYPE(items)->tp_name);
1836 return NULL;
1837 }
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001838
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001839 /* Fast path: No decoding has to be done. */
1840 if (mformat_code == typecode_to_mformat_code(typecode) ||
1841 mformat_code == UNKNOWN_FORMAT) {
1842 return make_array(arraytype, typecode, items);
1843 }
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001844
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001845 /* Slow path: Decode the byte string according to the given machine
1846 * format code. This occurs when the computer unpickling the array
1847 * object is architecturally different from the one that pickled the
1848 * array.
1849 */
1850 if (Py_SIZE(items) % mformat_descriptors[mformat_code].size != 0) {
1851 PyErr_SetString(PyExc_ValueError,
1852 "string length not a multiple of item size");
1853 return NULL;
1854 }
1855 switch (mformat_code) {
1856 case IEEE_754_FLOAT_LE:
1857 case IEEE_754_FLOAT_BE: {
1858 int i;
1859 int le = (mformat_code == IEEE_754_FLOAT_LE) ? 1 : 0;
1860 Py_ssize_t itemcount = Py_SIZE(items) / 4;
1861 const unsigned char *memstr =
1862 (unsigned char *)PyBytes_AS_STRING(items);
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001863
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001864 converted_items = PyList_New(itemcount);
1865 if (converted_items == NULL)
1866 return NULL;
1867 for (i = 0; i < itemcount; i++) {
1868 PyObject *pyfloat = PyFloat_FromDouble(
1869 _PyFloat_Unpack4(&memstr[i * 4], le));
1870 if (pyfloat == NULL) {
1871 Py_DECREF(converted_items);
1872 return NULL;
1873 }
1874 PyList_SET_ITEM(converted_items, i, pyfloat);
1875 }
1876 break;
1877 }
1878 case IEEE_754_DOUBLE_LE:
1879 case IEEE_754_DOUBLE_BE: {
1880 int i;
1881 int le = (mformat_code == IEEE_754_DOUBLE_LE) ? 1 : 0;
1882 Py_ssize_t itemcount = Py_SIZE(items) / 8;
1883 const unsigned char *memstr =
1884 (unsigned char *)PyBytes_AS_STRING(items);
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001885
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001886 converted_items = PyList_New(itemcount);
1887 if (converted_items == NULL)
1888 return NULL;
1889 for (i = 0; i < itemcount; i++) {
1890 PyObject *pyfloat = PyFloat_FromDouble(
1891 _PyFloat_Unpack8(&memstr[i * 8], le));
1892 if (pyfloat == NULL) {
1893 Py_DECREF(converted_items);
1894 return NULL;
1895 }
1896 PyList_SET_ITEM(converted_items, i, pyfloat);
1897 }
1898 break;
1899 }
1900 case UTF16_LE:
1901 case UTF16_BE: {
1902 int byteorder = (mformat_code == UTF16_LE) ? -1 : 1;
1903 converted_items = PyUnicode_DecodeUTF16(
1904 PyBytes_AS_STRING(items), Py_SIZE(items),
1905 "strict", &byteorder);
1906 if (converted_items == NULL)
1907 return NULL;
1908 break;
1909 }
1910 case UTF32_LE:
1911 case UTF32_BE: {
1912 int byteorder = (mformat_code == UTF32_LE) ? -1 : 1;
1913 converted_items = PyUnicode_DecodeUTF32(
1914 PyBytes_AS_STRING(items), Py_SIZE(items),
1915 "strict", &byteorder);
1916 if (converted_items == NULL)
1917 return NULL;
1918 break;
1919 }
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001920
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001921 case UNSIGNED_INT8:
1922 case SIGNED_INT8:
1923 case UNSIGNED_INT16_LE:
1924 case UNSIGNED_INT16_BE:
1925 case SIGNED_INT16_LE:
1926 case SIGNED_INT16_BE:
1927 case UNSIGNED_INT32_LE:
1928 case UNSIGNED_INT32_BE:
1929 case SIGNED_INT32_LE:
1930 case SIGNED_INT32_BE:
1931 case UNSIGNED_INT64_LE:
1932 case UNSIGNED_INT64_BE:
1933 case SIGNED_INT64_LE:
1934 case SIGNED_INT64_BE: {
1935 int i;
1936 const struct mformatdescr mf_descr =
1937 mformat_descriptors[mformat_code];
1938 Py_ssize_t itemcount = Py_SIZE(items) / mf_descr.size;
1939 const unsigned char *memstr =
1940 (unsigned char *)PyBytes_AS_STRING(items);
1941 struct arraydescr *descr;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001942
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001943 /* If possible, try to pack array's items using a data type
1944 * that fits better. This may result in an array with narrower
1945 * or wider elements.
1946 *
1947 * For example, if a 32-bit machine pickles a L-code array of
1948 * unsigned longs, then the array will be unpickled by 64-bit
1949 * machine as an I-code array of unsigned ints.
1950 *
1951 * XXX: Is it possible to write a unit test for this?
1952 */
1953 for (descr = descriptors; descr->typecode != '\0'; descr++) {
1954 if (descr->is_integer_type &&
1955 descr->itemsize == mf_descr.size &&
1956 descr->is_signed == mf_descr.is_signed)
1957 typecode = descr->typecode;
1958 }
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001959
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001960 converted_items = PyList_New(itemcount);
1961 if (converted_items == NULL)
1962 return NULL;
1963 for (i = 0; i < itemcount; i++) {
1964 PyObject *pylong;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001965
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001966 pylong = _PyLong_FromByteArray(
1967 &memstr[i * mf_descr.size],
1968 mf_descr.size,
1969 !mf_descr.is_big_endian,
1970 mf_descr.is_signed);
1971 if (pylong == NULL) {
1972 Py_DECREF(converted_items);
1973 return NULL;
1974 }
1975 PyList_SET_ITEM(converted_items, i, pylong);
1976 }
1977 break;
1978 }
1979 case UNKNOWN_FORMAT:
1980 /* Impossible, but needed to shut up GCC about the unhandled
1981 * enumeration value.
1982 */
1983 default:
1984 PyErr_BadArgument();
1985 return NULL;
1986 }
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001987
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001988 result = make_array(arraytype, typecode, converted_items);
1989 Py_DECREF(converted_items);
1990 return result;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00001991}
1992
1993static PyObject *
1994array_reduce_ex(arrayobject *array, PyObject *value)
1995{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001996 PyObject *dict;
1997 PyObject *result;
1998 PyObject *array_str;
1999 int typecode = array->ob_descr->typecode;
2000 int mformat_code;
2001 static PyObject *array_reconstructor = NULL;
2002 long protocol;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00002003
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002004 if (array_reconstructor == NULL) {
2005 PyObject *array_module = PyImport_ImportModule("array");
2006 if (array_module == NULL)
2007 return NULL;
2008 array_reconstructor = PyObject_GetAttrString(
2009 array_module,
2010 "_array_reconstructor");
2011 Py_DECREF(array_module);
2012 if (array_reconstructor == NULL)
2013 return NULL;
2014 }
Alexandre Vassalottiad077152009-07-15 17:49:23 +00002015
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002016 if (!PyLong_Check(value)) {
2017 PyErr_SetString(PyExc_TypeError,
2018 "__reduce_ex__ argument should an integer");
2019 return NULL;
2020 }
2021 protocol = PyLong_AsLong(value);
2022 if (protocol == -1 && PyErr_Occurred())
2023 return NULL;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00002024
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002025 dict = PyObject_GetAttrString((PyObject *)array, "__dict__");
2026 if (dict == NULL) {
2027 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
2028 return NULL;
2029 PyErr_Clear();
2030 dict = Py_None;
2031 Py_INCREF(dict);
2032 }
Alexandre Vassalottiad077152009-07-15 17:49:23 +00002033
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002034 mformat_code = typecode_to_mformat_code(typecode);
2035 if (mformat_code == UNKNOWN_FORMAT || protocol < 3) {
2036 /* Convert the array to a list if we got something weird
2037 * (e.g., non-IEEE floats), or we are pickling the array using
2038 * a Python 2.x compatible protocol.
2039 *
2040 * It is necessary to use a list representation for Python 2.x
2041 * compatible pickle protocol, since Python 2's str objects
2042 * are unpickled as unicode by Python 3. Thus it is impossible
2043 * to make arrays unpicklable by Python 3 by using their memory
2044 * representation, unless we resort to ugly hacks such as
2045 * coercing unicode objects to bytes in array_reconstructor.
2046 */
2047 PyObject *list;
2048 list = array_tolist(array, NULL);
2049 if (list == NULL) {
2050 Py_DECREF(dict);
2051 return NULL;
2052 }
2053 result = Py_BuildValue(
2054 "O(CO)O", Py_TYPE(array), typecode, list, dict);
2055 Py_DECREF(list);
2056 Py_DECREF(dict);
2057 return result;
2058 }
Alexandre Vassalottiad077152009-07-15 17:49:23 +00002059
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00002060 array_str = array_tobytes(array, NULL);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002061 if (array_str == NULL) {
2062 Py_DECREF(dict);
2063 return NULL;
2064 }
2065 result = Py_BuildValue(
2066 "O(OCiN)O", array_reconstructor, Py_TYPE(array), typecode,
2067 mformat_code, array_str, dict);
2068 Py_DECREF(dict);
2069 return result;
Alexandre Vassalottiad077152009-07-15 17:49:23 +00002070}
2071
2072PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
2073
Martin v. Löwis99866332002-03-01 10:27:01 +00002074static PyObject *
2075array_get_typecode(arrayobject *a, void *closure)
2076{
Amaury Forgeot d'Arc24aa26b2010-11-25 08:13:35 +00002077 Py_UNICODE tc = a->ob_descr->typecode;
2078 return PyUnicode_FromUnicode(&tc, 1);
Martin v. Löwis99866332002-03-01 10:27:01 +00002079}
2080
2081static PyObject *
2082array_get_itemsize(arrayobject *a, void *closure)
2083{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002084 return PyLong_FromLong((long)a->ob_descr->itemsize);
Martin v. Löwis99866332002-03-01 10:27:01 +00002085}
2086
2087static PyGetSetDef array_getsets [] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002088 {"typecode", (getter) array_get_typecode, NULL,
2089 "the typecode character used to create the array"},
2090 {"itemsize", (getter) array_get_itemsize, NULL,
2091 "the size, in bytes, of one array item"},
2092 {NULL}
Martin v. Löwis99866332002-03-01 10:27:01 +00002093};
2094
Martin v. Löwis59683e82008-06-13 07:50:45 +00002095static PyMethodDef array_methods[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002096 {"append", (PyCFunction)array_append, METH_O,
2097 append_doc},
2098 {"buffer_info", (PyCFunction)array_buffer_info, METH_NOARGS,
2099 buffer_info_doc},
2100 {"byteswap", (PyCFunction)array_byteswap, METH_NOARGS,
2101 byteswap_doc},
2102 {"__copy__", (PyCFunction)array_copy, METH_NOARGS,
2103 copy_doc},
2104 {"count", (PyCFunction)array_count, METH_O,
2105 count_doc},
2106 {"__deepcopy__",(PyCFunction)array_copy, METH_O,
2107 copy_doc},
2108 {"extend", (PyCFunction)array_extend, METH_O,
2109 extend_doc},
2110 {"fromfile", (PyCFunction)array_fromfile, METH_VARARGS,
2111 fromfile_doc},
2112 {"fromlist", (PyCFunction)array_fromlist, METH_O,
2113 fromlist_doc},
2114 {"fromstring", (PyCFunction)array_fromstring, METH_VARARGS,
2115 fromstring_doc},
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00002116 {"frombytes", (PyCFunction)array_frombytes, METH_VARARGS,
2117 frombytes_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002118 {"fromunicode", (PyCFunction)array_fromunicode, METH_VARARGS,
2119 fromunicode_doc},
2120 {"index", (PyCFunction)array_index, METH_O,
2121 index_doc},
2122 {"insert", (PyCFunction)array_insert, METH_VARARGS,
2123 insert_doc},
2124 {"pop", (PyCFunction)array_pop, METH_VARARGS,
2125 pop_doc},
2126 {"__reduce_ex__", (PyCFunction)array_reduce_ex, METH_O,
2127 reduce_doc},
2128 {"remove", (PyCFunction)array_remove, METH_O,
2129 remove_doc},
2130 {"reverse", (PyCFunction)array_reverse, METH_NOARGS,
2131 reverse_doc},
2132/* {"sort", (PyCFunction)array_sort, METH_VARARGS,
2133 sort_doc},*/
2134 {"tofile", (PyCFunction)array_tofile, METH_O,
2135 tofile_doc},
2136 {"tolist", (PyCFunction)array_tolist, METH_NOARGS,
2137 tolist_doc},
2138 {"tostring", (PyCFunction)array_tostring, METH_NOARGS,
2139 tostring_doc},
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00002140 {"tobytes", (PyCFunction)array_tobytes, METH_NOARGS,
2141 tobytes_doc},
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002142 {"tounicode", (PyCFunction)array_tounicode, METH_NOARGS,
2143 tounicode_doc},
2144 {NULL, NULL} /* sentinel */
Guido van Rossum778983b1993-02-19 15:55:02 +00002145};
2146
Roger E. Masse2919eaa1996-12-09 20:10:36 +00002147static PyObject *
Peter Schneider-Kamp9656abd2000-07-13 21:10:57 +00002148array_repr(arrayobject *a)
Guido van Rossum778983b1993-02-19 15:55:02 +00002149{
Amaury Forgeot d'Arc24aa26b2010-11-25 08:13:35 +00002150 Py_UNICODE typecode;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002151 PyObject *s, *v = NULL;
2152 Py_ssize_t len;
Martin v. Löwis99866332002-03-01 10:27:01 +00002153
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002154 len = Py_SIZE(a);
2155 typecode = a->ob_descr->typecode;
2156 if (len == 0) {
Amaury Forgeot d'Arc24aa26b2010-11-25 08:13:35 +00002157 return PyUnicode_FromFormat("array('%c')", (int)typecode);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002158 }
Brett Cannon4a5e5de2011-06-07 20:09:32 -07002159 if (typecode == 'u')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002160 v = array_tounicode(a, NULL);
2161 else
2162 v = array_tolist(a, NULL);
Raymond Hettinger88ba1e32003-04-23 17:27:00 +00002163
Amaury Forgeot d'Arc24aa26b2010-11-25 08:13:35 +00002164 s = PyUnicode_FromFormat("array('%c', %R)", (int)typecode, v);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002165 Py_DECREF(v);
2166 return s;
Guido van Rossum778983b1993-02-19 15:55:02 +00002167}
2168
Michael W. Hudson9c14bad2002-06-19 15:44:15 +00002169static PyObject*
2170array_subscr(arrayobject* self, PyObject* item)
2171{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002172 if (PyIndex_Check(item)) {
2173 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
2174 if (i==-1 && PyErr_Occurred()) {
2175 return NULL;
2176 }
2177 if (i < 0)
2178 i += Py_SIZE(self);
2179 return array_item(self, i);
2180 }
2181 else if (PySlice_Check(item)) {
2182 Py_ssize_t start, stop, step, slicelength, cur, i;
2183 PyObject* result;
2184 arrayobject* ar;
2185 int itemsize = self->ob_descr->itemsize;
Michael W. Hudson9c14bad2002-06-19 15:44:15 +00002186
Martin v. Löwis4d0d4712010-12-03 20:14:31 +00002187 if (PySlice_GetIndicesEx(item, Py_SIZE(self),
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002188 &start, &stop, &step, &slicelength) < 0) {
2189 return NULL;
2190 }
Michael W. Hudson9c14bad2002-06-19 15:44:15 +00002191
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002192 if (slicelength <= 0) {
2193 return newarrayobject(&Arraytype, 0, self->ob_descr);
2194 }
2195 else if (step == 1) {
2196 PyObject *result = newarrayobject(&Arraytype,
2197 slicelength, self->ob_descr);
2198 if (result == NULL)
2199 return NULL;
2200 memcpy(((arrayobject *)result)->ob_item,
2201 self->ob_item + start * itemsize,
2202 slicelength * itemsize);
2203 return result;
2204 }
2205 else {
2206 result = newarrayobject(&Arraytype, slicelength, self->ob_descr);
2207 if (!result) return NULL;
Michael W. Hudson9c14bad2002-06-19 15:44:15 +00002208
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002209 ar = (arrayobject*)result;
Michael W. Hudson9c14bad2002-06-19 15:44:15 +00002210
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002211 for (cur = start, i = 0; i < slicelength;
2212 cur += step, i++) {
2213 memcpy(ar->ob_item + i*itemsize,
2214 self->ob_item + cur*itemsize,
2215 itemsize);
2216 }
2217
2218 return result;
2219 }
2220 }
2221 else {
2222 PyErr_SetString(PyExc_TypeError,
2223 "array indices must be integers");
2224 return NULL;
2225 }
Michael W. Hudson9c14bad2002-06-19 15:44:15 +00002226}
2227
2228static int
2229array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
2230{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002231 Py_ssize_t start, stop, step, slicelength, needed;
2232 arrayobject* other;
2233 int itemsize;
Thomas Woutersed03b412007-08-28 21:37:11 +00002234
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002235 if (PyIndex_Check(item)) {
2236 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
Alexandre Vassalotti47137252009-07-05 19:57:00 +00002237
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002238 if (i == -1 && PyErr_Occurred())
2239 return -1;
2240 if (i < 0)
2241 i += Py_SIZE(self);
2242 if (i < 0 || i >= Py_SIZE(self)) {
2243 PyErr_SetString(PyExc_IndexError,
2244 "array assignment index out of range");
2245 return -1;
2246 }
2247 if (value == NULL) {
2248 /* Fall through to slice assignment */
2249 start = i;
2250 stop = i + 1;
2251 step = 1;
2252 slicelength = 1;
2253 }
2254 else
2255 return (*self->ob_descr->setitem)(self, i, value);
2256 }
2257 else if (PySlice_Check(item)) {
Martin v. Löwis4d0d4712010-12-03 20:14:31 +00002258 if (PySlice_GetIndicesEx(item,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002259 Py_SIZE(self), &start, &stop,
2260 &step, &slicelength) < 0) {
2261 return -1;
2262 }
2263 }
2264 else {
2265 PyErr_SetString(PyExc_TypeError,
2266 "array indices must be integer");
2267 return -1;
2268 }
2269 if (value == NULL) {
2270 other = NULL;
2271 needed = 0;
2272 }
2273 else if (array_Check(value)) {
2274 other = (arrayobject *)value;
2275 needed = Py_SIZE(other);
2276 if (self == other) {
2277 /* Special case "self[i:j] = self" -- copy self first */
2278 int ret;
2279 value = array_slice(other, 0, needed);
2280 if (value == NULL)
2281 return -1;
2282 ret = array_ass_subscr(self, item, value);
2283 Py_DECREF(value);
2284 return ret;
2285 }
2286 if (other->ob_descr != self->ob_descr) {
2287 PyErr_BadArgument();
2288 return -1;
2289 }
2290 }
2291 else {
2292 PyErr_Format(PyExc_TypeError,
2293 "can only assign array (not \"%.200s\") to array slice",
2294 Py_TYPE(value)->tp_name);
2295 return -1;
2296 }
2297 itemsize = self->ob_descr->itemsize;
2298 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
2299 if ((step > 0 && stop < start) ||
2300 (step < 0 && stop > start))
2301 stop = start;
Alexandre Vassalotti47137252009-07-05 19:57:00 +00002302
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002303 /* Issue #4509: If the array has exported buffers and the slice
2304 assignment would change the size of the array, fail early to make
2305 sure we don't modify it. */
2306 if ((needed == 0 || slicelength != needed) && self->ob_exports > 0) {
2307 PyErr_SetString(PyExc_BufferError,
2308 "cannot resize an array that is exporting buffers");
2309 return -1;
2310 }
Mark Dickinsonbc099642010-01-29 17:27:24 +00002311
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002312 if (step == 1) {
2313 if (slicelength > needed) {
2314 memmove(self->ob_item + (start + needed) * itemsize,
2315 self->ob_item + stop * itemsize,
2316 (Py_SIZE(self) - stop) * itemsize);
2317 if (array_resize(self, Py_SIZE(self) +
2318 needed - slicelength) < 0)
2319 return -1;
2320 }
2321 else if (slicelength < needed) {
2322 if (array_resize(self, Py_SIZE(self) +
2323 needed - slicelength) < 0)
2324 return -1;
2325 memmove(self->ob_item + (start + needed) * itemsize,
2326 self->ob_item + stop * itemsize,
2327 (Py_SIZE(self) - start - needed) * itemsize);
2328 }
2329 if (needed > 0)
2330 memcpy(self->ob_item + start * itemsize,
2331 other->ob_item, needed * itemsize);
2332 return 0;
2333 }
2334 else if (needed == 0) {
2335 /* Delete slice */
2336 size_t cur;
2337 Py_ssize_t i;
Thomas Woutersed03b412007-08-28 21:37:11 +00002338
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002339 if (step < 0) {
2340 stop = start + 1;
2341 start = stop + step * (slicelength - 1) - 1;
2342 step = -step;
2343 }
2344 for (cur = start, i = 0; i < slicelength;
2345 cur += step, i++) {
2346 Py_ssize_t lim = step - 1;
Thomas Woutersed03b412007-08-28 21:37:11 +00002347
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002348 if (cur + step >= (size_t)Py_SIZE(self))
2349 lim = Py_SIZE(self) - cur - 1;
2350 memmove(self->ob_item + (cur - i) * itemsize,
2351 self->ob_item + (cur + 1) * itemsize,
2352 lim * itemsize);
2353 }
2354 cur = start + slicelength * step;
2355 if (cur < (size_t)Py_SIZE(self)) {
2356 memmove(self->ob_item + (cur-slicelength) * itemsize,
2357 self->ob_item + cur * itemsize,
2358 (Py_SIZE(self) - cur) * itemsize);
2359 }
2360 if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
2361 return -1;
2362 return 0;
2363 }
2364 else {
2365 Py_ssize_t cur, i;
2366
2367 if (needed != slicelength) {
2368 PyErr_Format(PyExc_ValueError,
2369 "attempt to assign array of size %zd "
2370 "to extended slice of size %zd",
2371 needed, slicelength);
2372 return -1;
2373 }
2374 for (cur = start, i = 0; i < slicelength;
2375 cur += step, i++) {
2376 memcpy(self->ob_item + cur * itemsize,
2377 other->ob_item + i * itemsize,
2378 itemsize);
2379 }
2380 return 0;
2381 }
Michael W. Hudson9c14bad2002-06-19 15:44:15 +00002382}
2383
2384static PyMappingMethods array_as_mapping = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002385 (lenfunc)array_length,
2386 (binaryfunc)array_subscr,
2387 (objobjargproc)array_ass_subscr
Michael W. Hudson9c14bad2002-06-19 15:44:15 +00002388};
2389
Guido van Rossumd8faa362007-04-27 19:54:29 +00002390static const void *emptybuf = "";
2391
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00002392
2393static int
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +00002394array_buffer_getbuf(arrayobject *self, Py_buffer *view, int flags)
Guido van Rossumfdf95dd1997-05-05 22:15:02 +00002395{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002396 if (view==NULL) goto finish;
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00002397
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002398 view->buf = (void *)self->ob_item;
2399 view->obj = (PyObject*)self;
2400 Py_INCREF(self);
2401 if (view->buf == NULL)
2402 view->buf = (void *)emptybuf;
2403 view->len = (Py_SIZE(self)) * self->ob_descr->itemsize;
2404 view->readonly = 0;
2405 view->ndim = 1;
2406 view->itemsize = self->ob_descr->itemsize;
2407 view->suboffsets = NULL;
2408 view->shape = NULL;
2409 if ((flags & PyBUF_ND)==PyBUF_ND) {
2410 view->shape = &((Py_SIZE(self)));
2411 }
2412 view->strides = NULL;
2413 if ((flags & PyBUF_STRIDES)==PyBUF_STRIDES)
2414 view->strides = &(view->itemsize);
2415 view->format = NULL;
2416 view->internal = NULL;
2417 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) {
2418 view->format = self->ob_descr->formats;
Travis E. Oliphantddacf962007-10-13 21:03:27 +00002419#ifdef Py_UNICODE_WIDE
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002420 if (self->ob_descr->typecode == 'u') {
2421 view->format = "w";
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00002422 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002423#endif
2424 }
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00002425
2426 finish:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002427 self->ob_exports++;
2428 return 0;
Guido van Rossumfdf95dd1997-05-05 22:15:02 +00002429}
2430
Travis E. Oliphantb99f7622007-08-18 11:21:56 +00002431static void
Travis E. Oliphant8ae62b62007-09-23 02:00:13 +00002432array_buffer_relbuf(arrayobject *self, Py_buffer *view)
Guido van Rossumfdf95dd1997-05-05 22:15:02 +00002433{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002434 self->ob_exports--;
Guido van Rossumfdf95dd1997-05-05 22:15:02 +00002435}
2436
Roger E. Masse2919eaa1996-12-09 20:10:36 +00002437static PySequenceMethods array_as_sequence = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002438 (lenfunc)array_length, /*sq_length*/
2439 (binaryfunc)array_concat, /*sq_concat*/
2440 (ssizeargfunc)array_repeat, /*sq_repeat*/
2441 (ssizeargfunc)array_item, /*sq_item*/
2442 0, /*sq_slice*/
2443 (ssizeobjargproc)array_ass_item, /*sq_ass_item*/
2444 0, /*sq_ass_slice*/
2445 (objobjproc)array_contains, /*sq_contains*/
2446 (binaryfunc)array_inplace_concat, /*sq_inplace_concat*/
2447 (ssizeargfunc)array_inplace_repeat /*sq_inplace_repeat*/
Guido van Rossum778983b1993-02-19 15:55:02 +00002448};
2449
Guido van Rossumfdf95dd1997-05-05 22:15:02 +00002450static PyBufferProcs array_as_buffer = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002451 (getbufferproc)array_buffer_getbuf,
2452 (releasebufferproc)array_buffer_relbuf
Guido van Rossumfdf95dd1997-05-05 22:15:02 +00002453};
2454
Roger E. Masse2919eaa1996-12-09 20:10:36 +00002455static PyObject *
Martin v. Löwis99866332002-03-01 10:27:01 +00002456array_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
Guido van Rossum778983b1993-02-19 15:55:02 +00002457{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002458 int c;
2459 PyObject *initial = NULL, *it = NULL;
2460 struct arraydescr *descr;
Martin v. Löwis99866332002-03-01 10:27:01 +00002461
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002462 if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds))
2463 return NULL;
Martin v. Löwis99866332002-03-01 10:27:01 +00002464
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002465 if (!PyArg_ParseTuple(args, "C|O:array", &c, &initial))
2466 return NULL;
Raymond Hettinger84fc9aa2003-04-24 10:41:55 +00002467
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002468 if (!(initial == NULL || PyList_Check(initial)
2469 || PyByteArray_Check(initial)
2470 || PyBytes_Check(initial)
2471 || PyTuple_Check(initial)
Alexander Belopolskyef4a03f2011-01-11 21:44:00 +00002472 || ((c=='u') && PyUnicode_Check(initial))
2473 || (array_Check(initial)
2474 && c == ((arrayobject*)initial)->ob_descr->typecode))) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002475 it = PyObject_GetIter(initial);
2476 if (it == NULL)
2477 return NULL;
2478 /* We set initial to NULL so that the subsequent code
2479 will create an empty array of the appropriate type
2480 and afterwards we can use array_iter_extend to populate
2481 the array.
2482 */
2483 initial = NULL;
2484 }
2485 for (descr = descriptors; descr->typecode != '\0'; descr++) {
2486 if (descr->typecode == c) {
2487 PyObject *a;
2488 Py_ssize_t len;
Martin v. Löwis99866332002-03-01 10:27:01 +00002489
Alexander Belopolskyef4a03f2011-01-11 21:44:00 +00002490 if (initial == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002491 len = 0;
Alexander Belopolskyef4a03f2011-01-11 21:44:00 +00002492 else if (PyList_Check(initial))
2493 len = PyList_GET_SIZE(initial);
2494 else if (PyTuple_Check(initial) || array_Check(initial))
2495 len = Py_SIZE(initial);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002496 else
Alexander Belopolskyef4a03f2011-01-11 21:44:00 +00002497 len = 0;
Martin v. Löwis99866332002-03-01 10:27:01 +00002498
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002499 a = newarrayobject(type, len, descr);
2500 if (a == NULL)
2501 return NULL;
2502
Alexander Belopolskyef4a03f2011-01-11 21:44:00 +00002503 if (len > 0 && !array_Check(initial)) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002504 Py_ssize_t i;
2505 for (i = 0; i < len; i++) {
2506 PyObject *v =
2507 PySequence_GetItem(initial, i);
2508 if (v == NULL) {
2509 Py_DECREF(a);
2510 return NULL;
2511 }
2512 if (setarrayitem(a, i, v) != 0) {
2513 Py_DECREF(v);
2514 Py_DECREF(a);
2515 return NULL;
2516 }
2517 Py_DECREF(v);
2518 }
2519 }
2520 else if (initial != NULL && (PyByteArray_Check(initial) ||
2521 PyBytes_Check(initial))) {
2522 PyObject *t_initial, *v;
2523 t_initial = PyTuple_Pack(1, initial);
2524 if (t_initial == NULL) {
2525 Py_DECREF(a);
2526 return NULL;
2527 }
Antoine Pitrou1ce3eb52010-09-01 20:29:34 +00002528 v = array_frombytes((arrayobject *)a,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002529 t_initial);
2530 Py_DECREF(t_initial);
2531 if (v == NULL) {
2532 Py_DECREF(a);
2533 return NULL;
2534 }
2535 Py_DECREF(v);
2536 }
2537 else if (initial != NULL && PyUnicode_Check(initial)) {
2538 Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial);
2539 if (n > 0) {
2540 arrayobject *self = (arrayobject *)a;
2541 char *item = self->ob_item;
2542 item = (char *)PyMem_Realloc(item, n);
2543 if (item == NULL) {
2544 PyErr_NoMemory();
2545 Py_DECREF(a);
2546 return NULL;
2547 }
2548 self->ob_item = item;
2549 Py_SIZE(self) = n / sizeof(Py_UNICODE);
2550 memcpy(item, PyUnicode_AS_DATA(initial), n);
2551 self->allocated = Py_SIZE(self);
2552 }
2553 }
Alexander Belopolskyef4a03f2011-01-11 21:44:00 +00002554 else if (initial != NULL && array_Check(initial)) {
2555 arrayobject *self = (arrayobject *)a;
2556 arrayobject *other = (arrayobject *)initial;
2557 memcpy(self->ob_item, other->ob_item, len * other->ob_descr->itemsize);
2558 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002559 if (it != NULL) {
2560 if (array_iter_extend((arrayobject *)a, it) == -1) {
2561 Py_DECREF(it);
2562 Py_DECREF(a);
2563 return NULL;
2564 }
2565 Py_DECREF(it);
2566 }
2567 return a;
2568 }
2569 }
2570 PyErr_SetString(PyExc_ValueError,
Meador Inge1c9f0c92011-09-20 19:55:51 -05002571#ifdef HAVE_LONG_LONG
2572 "bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)");
2573#else
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002574 "bad typecode (must be b, B, u, h, H, i, I, l, L, f or d)");
Meador Inge1c9f0c92011-09-20 19:55:51 -05002575#endif
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002576 return NULL;
Guido van Rossum778983b1993-02-19 15:55:02 +00002577}
2578
Guido van Rossum778983b1993-02-19 15:55:02 +00002579
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002580PyDoc_STRVAR(module_doc,
Martin v. Löwis99866332002-03-01 10:27:01 +00002581"This module defines an object type which can efficiently represent\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002582an array of basic values: characters, integers, floating point\n\
2583numbers. Arrays are sequence types and behave very much like lists,\n\
2584except that the type of objects stored in them is constrained. The\n\
2585type is specified at object creation time by using a type code, which\n\
2586is a single character. The following type codes are defined:\n\
2587\n\
2588 Type code C Type Minimum size in bytes \n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002589 'b' signed integer 1 \n\
2590 'B' unsigned integer 1 \n\
Travis E. Oliphantd5c0add2007-10-12 22:05:15 +00002591 'u' Unicode character 2 (see note) \n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002592 'h' signed integer 2 \n\
2593 'H' unsigned integer 2 \n\
2594 'i' signed integer 2 \n\
2595 'I' unsigned integer 2 \n\
2596 'l' signed integer 4 \n\
2597 'L' unsigned integer 4 \n\
Meador Inge1c9f0c92011-09-20 19:55:51 -05002598 'q' signed integer 8 (see note) \n\
2599 'Q' unsigned integer 8 (see note) \n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002600 'f' floating point 4 \n\
2601 'd' floating point 8 \n\
2602\n\
Meador Inge1c9f0c92011-09-20 19:55:51 -05002603NOTE: The 'u' type code corresponds to Python's unicode character. On \n\
Travis E. Oliphantd5c0add2007-10-12 22:05:15 +00002604narrow builds this is 2-bytes on wide builds this is 4-bytes.\n\
2605\n\
Meador Inge1c9f0c92011-09-20 19:55:51 -05002606NOTE: The 'q' and 'Q' type codes are only available if the platform \n\
2607C compiler used to build Python supports 'long long', or, on Windows, \n\
2608'__int64'.\n\
2609\n\
Martin v. Löwis99866332002-03-01 10:27:01 +00002610The constructor is:\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002611\n\
2612array(typecode [, initializer]) -- create a new array\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002613");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002614
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002615PyDoc_STRVAR(arraytype_doc,
Martin v. Löwis99866332002-03-01 10:27:01 +00002616"array(typecode [, initializer]) -> array\n\
2617\n\
2618Return a new array whose items are restricted by typecode, and\n\
Raymond Hettinger6ab78cd2004-08-29 07:50:43 +00002619initialized from the optional initializer value, which must be a list,\n\
2620string. or iterable over elements of the appropriate type.\n\
Martin v. Löwis99866332002-03-01 10:27:01 +00002621\n\
2622Arrays represent basic values and behave very much like lists, except\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002623the type of objects stored in them is constrained.\n\
2624\n\
2625Methods:\n\
2626\n\
2627append() -- append a new item to the end of the array\n\
2628buffer_info() -- return information giving the current memory info\n\
2629byteswap() -- byteswap all the items of the array\n\
Mark Dickinson934896d2009-02-21 20:59:32 +00002630count() -- return number of occurrences of an object\n\
Raymond Hettinger49f9bd12004-03-14 05:43:59 +00002631extend() -- extend array by appending multiple elements from an iterable\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002632fromfile() -- read items from a file object\n\
2633fromlist() -- append items from the list\n\
2634fromstring() -- append items from the string\n\
Mark Dickinson934896d2009-02-21 20:59:32 +00002635index() -- return index of first occurrence of an object\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002636insert() -- insert a new item into the array at a provided position\n\
Peter Schneider-Kamp5a65c2d2000-07-31 20:52:21 +00002637pop() -- remove and return item (default last)\n\
Mark Dickinson934896d2009-02-21 20:59:32 +00002638remove() -- remove first occurrence of an object\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002639reverse() -- reverse the order of the items in the array\n\
2640tofile() -- write all items to a file object\n\
2641tolist() -- return the array converted to an ordinary list\n\
2642tostring() -- return the array converted to a string\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002643\n\
Martin v. Löwis99866332002-03-01 10:27:01 +00002644Attributes:\n\
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002645\n\
2646typecode -- the typecode character used to create the array\n\
2647itemsize -- the length in bytes of one array item\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00002648");
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002649
Raymond Hettinger625812f2003-01-07 01:58:52 +00002650static PyObject *array_iter(arrayobject *ao);
2651
Tim Peters0c322792002-07-17 16:49:03 +00002652static PyTypeObject Arraytype = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002653 PyVarObject_HEAD_INIT(NULL, 0)
2654 "array.array",
2655 sizeof(arrayobject),
2656 0,
2657 (destructor)array_dealloc, /* tp_dealloc */
2658 0, /* tp_print */
2659 0, /* tp_getattr */
2660 0, /* tp_setattr */
2661 0, /* tp_reserved */
2662 (reprfunc)array_repr, /* tp_repr */
2663 0, /* tp_as_number*/
2664 &array_as_sequence, /* tp_as_sequence*/
2665 &array_as_mapping, /* tp_as_mapping*/
2666 0, /* tp_hash */
2667 0, /* tp_call */
2668 0, /* tp_str */
2669 PyObject_GenericGetAttr, /* tp_getattro */
2670 0, /* tp_setattro */
2671 &array_as_buffer, /* tp_as_buffer*/
2672 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
2673 arraytype_doc, /* tp_doc */
2674 0, /* tp_traverse */
2675 0, /* tp_clear */
2676 array_richcompare, /* tp_richcompare */
2677 offsetof(arrayobject, weakreflist), /* tp_weaklistoffset */
2678 (getiterfunc)array_iter, /* tp_iter */
2679 0, /* tp_iternext */
2680 array_methods, /* tp_methods */
2681 0, /* tp_members */
2682 array_getsets, /* tp_getset */
2683 0, /* tp_base */
2684 0, /* tp_dict */
2685 0, /* tp_descr_get */
2686 0, /* tp_descr_set */
2687 0, /* tp_dictoffset */
2688 0, /* tp_init */
2689 PyType_GenericAlloc, /* tp_alloc */
2690 array_new, /* tp_new */
2691 PyObject_Del, /* tp_free */
Guido van Rossumb39b90d1998-10-13 14:27:22 +00002692};
2693
Raymond Hettinger625812f2003-01-07 01:58:52 +00002694
2695/*********************** Array Iterator **************************/
2696
2697typedef struct {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002698 PyObject_HEAD
2699 Py_ssize_t index;
2700 arrayobject *ao;
2701 PyObject * (*getitem)(struct arrayobject *, Py_ssize_t);
Raymond Hettinger625812f2003-01-07 01:58:52 +00002702} arrayiterobject;
2703
2704static PyTypeObject PyArrayIter_Type;
2705
2706#define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type)
2707
2708static PyObject *
2709array_iter(arrayobject *ao)
2710{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002711 arrayiterobject *it;
Raymond Hettinger625812f2003-01-07 01:58:52 +00002712
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002713 if (!array_Check(ao)) {
2714 PyErr_BadInternalCall();
2715 return NULL;
2716 }
Raymond Hettinger625812f2003-01-07 01:58:52 +00002717
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002718 it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type);
2719 if (it == NULL)
2720 return NULL;
Raymond Hettinger625812f2003-01-07 01:58:52 +00002721
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002722 Py_INCREF(ao);
2723 it->ao = ao;
2724 it->index = 0;
2725 it->getitem = ao->ob_descr->getitem;
2726 PyObject_GC_Track(it);
2727 return (PyObject *)it;
Raymond Hettinger625812f2003-01-07 01:58:52 +00002728}
2729
2730static PyObject *
Raymond Hettinger625812f2003-01-07 01:58:52 +00002731arrayiter_next(arrayiterobject *it)
2732{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002733 assert(PyArrayIter_Check(it));
2734 if (it->index < Py_SIZE(it->ao))
2735 return (*it->getitem)(it->ao, it->index++);
2736 return NULL;
Raymond Hettinger625812f2003-01-07 01:58:52 +00002737}
2738
2739static void
2740arrayiter_dealloc(arrayiterobject *it)
2741{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002742 PyObject_GC_UnTrack(it);
2743 Py_XDECREF(it->ao);
2744 PyObject_GC_Del(it);
Raymond Hettinger625812f2003-01-07 01:58:52 +00002745}
2746
2747static int
2748arrayiter_traverse(arrayiterobject *it, visitproc visit, void *arg)
2749{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002750 Py_VISIT(it->ao);
2751 return 0;
Raymond Hettinger625812f2003-01-07 01:58:52 +00002752}
2753
2754static PyTypeObject PyArrayIter_Type = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002755 PyVarObject_HEAD_INIT(NULL, 0)
2756 "arrayiterator", /* tp_name */
2757 sizeof(arrayiterobject), /* tp_basicsize */
2758 0, /* tp_itemsize */
2759 /* methods */
2760 (destructor)arrayiter_dealloc, /* tp_dealloc */
2761 0, /* tp_print */
2762 0, /* tp_getattr */
2763 0, /* tp_setattr */
2764 0, /* tp_reserved */
2765 0, /* tp_repr */
2766 0, /* tp_as_number */
2767 0, /* tp_as_sequence */
2768 0, /* tp_as_mapping */
2769 0, /* tp_hash */
2770 0, /* tp_call */
2771 0, /* tp_str */
2772 PyObject_GenericGetAttr, /* tp_getattro */
2773 0, /* tp_setattro */
2774 0, /* tp_as_buffer */
2775 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
2776 0, /* tp_doc */
2777 (traverseproc)arrayiter_traverse, /* tp_traverse */
2778 0, /* tp_clear */
2779 0, /* tp_richcompare */
2780 0, /* tp_weaklistoffset */
2781 PyObject_SelfIter, /* tp_iter */
2782 (iternextfunc)arrayiter_next, /* tp_iternext */
2783 0, /* tp_methods */
Raymond Hettinger625812f2003-01-07 01:58:52 +00002784};
2785
2786
2787/*********************** Install Module **************************/
2788
Martin v. Löwis99866332002-03-01 10:27:01 +00002789/* No functions in array module. */
2790static PyMethodDef a_methods[] = {
Alexandre Vassalottiad077152009-07-15 17:49:23 +00002791 {"_array_reconstructor", array_reconstructor, METH_VARARGS,
2792 PyDoc_STR("Internal. Used for pickling support.")},
Martin v. Löwis99866332002-03-01 10:27:01 +00002793 {NULL, NULL, 0, NULL} /* Sentinel */
2794};
2795
Martin v. Löwis1a214512008-06-11 05:26:20 +00002796static struct PyModuleDef arraymodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002797 PyModuleDef_HEAD_INIT,
2798 "array",
2799 module_doc,
2800 -1,
2801 a_methods,
2802 NULL,
2803 NULL,
2804 NULL,
2805 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00002806};
2807
Martin v. Löwis99866332002-03-01 10:27:01 +00002808
Mark Hammondfe51c6d2002-08-02 02:27:13 +00002809PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00002810PyInit_array(void)
Guido van Rossum778983b1993-02-19 15:55:02 +00002811{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002812 PyObject *m;
2813 PyObject *typecodes;
2814 Py_ssize_t size = 0;
2815 register Py_UNICODE *p;
2816 struct arraydescr *descr;
Fred Drake0d40ba42000-02-04 20:33:49 +00002817
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002818 if (PyType_Ready(&Arraytype) < 0)
2819 return NULL;
2820 Py_TYPE(&PyArrayIter_Type) = &PyType_Type;
2821 m = PyModule_Create(&arraymodule);
2822 if (m == NULL)
2823 return NULL;
Fred Drakef4e34842002-04-01 03:45:06 +00002824
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002825 Py_INCREF((PyObject *)&Arraytype);
2826 PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype);
2827 Py_INCREF((PyObject *)&Arraytype);
2828 PyModule_AddObject(m, "array", (PyObject *)&Arraytype);
Travis E. Oliphantd5c0add2007-10-12 22:05:15 +00002829
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002830 for (descr=descriptors; descr->typecode != '\0'; descr++) {
2831 size++;
2832 }
Travis E. Oliphantd5c0add2007-10-12 22:05:15 +00002833
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00002834 typecodes = PyUnicode_FromStringAndSize(NULL, size);
2835 p = PyUnicode_AS_UNICODE(typecodes);
2836 for (descr = descriptors; descr->typecode != '\0'; descr++) {
2837 *p++ = (char)descr->typecode;
2838 }
2839
2840 PyModule_AddObject(m, "typecodes", (PyObject *)typecodes);
2841
2842 if (PyErr_Occurred()) {
2843 Py_DECREF(m);
2844 m = NULL;
2845 }
2846 return m;
Guido van Rossum778983b1993-02-19 15:55:02 +00002847}