1 /* Array object implementation */
2
3 /* An array is a uniform list -- all items have the same type.
4 The item type is restricted to simple C types like int or float */
5
6 #define PY_SSIZE_T_CLEAN
7 #include "Python.h"
8 #include <stddef.h> // offsetof()
9
10 #ifdef STDC_HEADERS
11 #include <stddef.h>
12 #else /* !STDC_HEADERS */
13 #ifdef HAVE_SYS_TYPES_H
14 #include <sys/types.h> /* For size_t */
15 #endif /* HAVE_SYS_TYPES_H */
16 #endif /* !STDC_HEADERS */
17
18 /*[clinic input]
19 module array
20 [clinic start generated code]*/
21 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=7d1b8d7f5958fd83]*/
22
23 struct arrayobject; /* Forward */
24
25 /* All possible arraydescr values are defined in the vector "descriptors"
26 * below. That's defined later because the appropriate get and set
27 * functions aren't visible yet.
28 */
29 struct arraydescr {
30 char typecode;
31 int itemsize;
32 PyObject * (*getitem)(struct arrayobject *, Py_ssize_t);
33 int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *);
34 int (*compareitems)(const void *, const void *, Py_ssize_t);
35 const char *formats;
36 int is_integer_type;
37 int is_signed;
38 };
39
40 typedef struct arrayobject {
41 PyObject_VAR_HEAD
42 char *ob_item;
43 Py_ssize_t allocated;
44 const struct arraydescr *ob_descr;
45 PyObject *weakreflist; /* List of weak references */
46 Py_ssize_t ob_exports; /* Number of exported buffers */
47 } arrayobject;
48
49 static PyTypeObject Arraytype;
50
51 typedef struct {
52 PyObject_HEAD
53 Py_ssize_t index;
54 arrayobject *ao;
55 PyObject* (*getitem)(struct arrayobject *, Py_ssize_t);
56 } arrayiterobject;
57
58 static PyTypeObject PyArrayIter_Type;
59
60 #define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type)
61
62 enum machine_format_code {
63 UNKNOWN_FORMAT = -1,
64 /* UNKNOWN_FORMAT is used to indicate that the machine format for an
65 * array type code cannot be interpreted. When this occurs, a list of
66 * Python objects is used to represent the content of the array
67 * instead of using the memory content of the array directly. In that
68 * case, the array_reconstructor mechanism is bypassed completely, and
69 * the standard array constructor is used instead.
70 *
71 * This is will most likely occur when the machine doesn't use IEEE
72 * floating-point numbers.
73 */
74
75 UNSIGNED_INT8 = 0,
76 SIGNED_INT8 = 1,
77 UNSIGNED_INT16_LE = 2,
78 UNSIGNED_INT16_BE = 3,
79 SIGNED_INT16_LE = 4,
80 SIGNED_INT16_BE = 5,
81 UNSIGNED_INT32_LE = 6,
82 UNSIGNED_INT32_BE = 7,
83 SIGNED_INT32_LE = 8,
84 SIGNED_INT32_BE = 9,
85 UNSIGNED_INT64_LE = 10,
86 UNSIGNED_INT64_BE = 11,
87 SIGNED_INT64_LE = 12,
88 SIGNED_INT64_BE = 13,
89 IEEE_754_FLOAT_LE = 14,
90 IEEE_754_FLOAT_BE = 15,
91 IEEE_754_DOUBLE_LE = 16,
92 IEEE_754_DOUBLE_BE = 17,
93 UTF16_LE = 18,
94 UTF16_BE = 19,
95 UTF32_LE = 20,
96 UTF32_BE = 21
97 };
98 #define MACHINE_FORMAT_CODE_MIN 0
99 #define MACHINE_FORMAT_CODE_MAX 21
100
101
102 /*
103 * Must come after arrayobject, arrayiterobject,
104 * and enum machine_code_type definitions.
105 */
106 #include "clinic/arraymodule.c.h"
107
108 #define array_Check(op) PyObject_TypeCheck(op, &Arraytype)
109 #define array_CheckExact(op) Py_IS_TYPE(op, &Arraytype)
110
111 static int
array_resize(arrayobject * self,Py_ssize_t newsize)112 array_resize(arrayobject *self, Py_ssize_t newsize)
113 {
114 char *items;
115 size_t _new_size;
116
117 if (self->ob_exports > 0 && newsize != Py_SIZE(self)) {
118 PyErr_SetString(PyExc_BufferError,
119 "cannot resize an array that is exporting buffers");
120 return -1;
121 }
122
123 /* Bypass realloc() when a previous overallocation is large enough
124 to accommodate the newsize. If the newsize is 16 smaller than the
125 current size, then proceed with the realloc() to shrink the array.
126 */
127
128 if (self->allocated >= newsize &&
129 Py_SIZE(self) < newsize + 16 &&
130 self->ob_item != NULL) {
131 Py_SET_SIZE(self, newsize);
132 return 0;
133 }
134
135 if (newsize == 0) {
136 PyMem_FREE(self->ob_item);
137 self->ob_item = NULL;
138 Py_SET_SIZE(self, 0);
139 self->allocated = 0;
140 return 0;
141 }
142
143 /* This over-allocates proportional to the array size, making room
144 * for additional growth. The over-allocation is mild, but is
145 * enough to give linear-time amortized behavior over a long
146 * sequence of appends() in the presence of a poorly-performing
147 * system realloc().
148 * The growth pattern is: 0, 4, 8, 16, 25, 34, 46, 56, 67, 79, ...
149 * Note, the pattern starts out the same as for lists but then
150 * grows at a smaller rate so that larger arrays only overallocate
151 * by about 1/16th -- this is done because arrays are presumed to be more
152 * memory critical.
153 */
154
155 _new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize;
156 items = self->ob_item;
157 /* XXX The following multiplication and division does not optimize away
158 like it does for lists since the size is not known at compile time */
159 if (_new_size <= ((~(size_t)0) / self->ob_descr->itemsize))
160 PyMem_RESIZE(items, char, (_new_size * self->ob_descr->itemsize));
161 else
162 items = NULL;
163 if (items == NULL) {
164 PyErr_NoMemory();
165 return -1;
166 }
167 self->ob_item = items;
168 Py_SET_SIZE(self, newsize);
169 self->allocated = _new_size;
170 return 0;
171 }
172
173 /****************************************************************************
174 Get and Set functions for each type.
175 A Get function takes an arrayobject* and an integer index, returning the
176 array value at that index wrapped in an appropriate PyObject*.
177 A Set function takes an arrayobject, integer index, and PyObject*; sets
178 the array value at that index to the raw C data extracted from the PyObject*,
179 and returns 0 if successful, else nonzero on failure (PyObject* not of an
180 appropriate type or value).
181 Note that the basic Get and Set functions do NOT check that the index is
182 in bounds; that's the responsibility of the caller.
183 ****************************************************************************/
184
185 static PyObject *
b_getitem(arrayobject * ap,Py_ssize_t i)186 b_getitem(arrayobject *ap, Py_ssize_t i)
187 {
188 long x = ((signed char *)ap->ob_item)[i];
189 return PyLong_FromLong(x);
190 }
191
192 static int
b_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)193 b_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
194 {
195 short x;
196 /* PyArg_Parse's 'b' formatter is for an unsigned char, therefore
197 must use the next size up that is signed ('h') and manually do
198 the overflow checking */
199 if (!PyArg_Parse(v, "h;array item must be integer", &x))
200 return -1;
201 else if (x < -128) {
202 PyErr_SetString(PyExc_OverflowError,
203 "signed char is less than minimum");
204 return -1;
205 }
206 else if (x > 127) {
207 PyErr_SetString(PyExc_OverflowError,
208 "signed char is greater than maximum");
209 return -1;
210 }
211 if (i >= 0)
212 ((char *)ap->ob_item)[i] = (char)x;
213 return 0;
214 }
215
216 static PyObject *
BB_getitem(arrayobject * ap,Py_ssize_t i)217 BB_getitem(arrayobject *ap, Py_ssize_t i)
218 {
219 long x = ((unsigned char *)ap->ob_item)[i];
220 return PyLong_FromLong(x);
221 }
222
223 static int
BB_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)224 BB_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
225 {
226 unsigned char x;
227 /* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */
228 if (!PyArg_Parse(v, "b;array item must be integer", &x))
229 return -1;
230 if (i >= 0)
231 ((char *)ap->ob_item)[i] = x;
232 return 0;
233 }
234
235 static PyObject *
u_getitem(arrayobject * ap,Py_ssize_t i)236 u_getitem(arrayobject *ap, Py_ssize_t i)
237 {
238 return PyUnicode_FromOrdinal(((wchar_t *) ap->ob_item)[i]);
239 }
240
241 static int
u_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)242 u_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
243 {
244 PyObject *u;
245 if (!PyArg_Parse(v, "U;array item must be unicode character", &u)) {
246 return -1;
247 }
248
249 Py_ssize_t len = PyUnicode_AsWideChar(u, NULL, 0);
250 if (len != 2) {
251 PyErr_SetString(PyExc_TypeError,
252 "array item must be unicode character");
253 return -1;
254 }
255
256 wchar_t w;
257 len = PyUnicode_AsWideChar(u, &w, 1);
258 assert(len == 1);
259
260 if (i >= 0) {
261 ((wchar_t *)ap->ob_item)[i] = w;
262 }
263 return 0;
264 }
265
266
267 static PyObject *
h_getitem(arrayobject * ap,Py_ssize_t i)268 h_getitem(arrayobject *ap, Py_ssize_t i)
269 {
270 return PyLong_FromLong((long) ((short *)ap->ob_item)[i]);
271 }
272
273
274 static int
h_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)275 h_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
276 {
277 short x;
278 /* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */
279 if (!PyArg_Parse(v, "h;array item must be integer", &x))
280 return -1;
281 if (i >= 0)
282 ((short *)ap->ob_item)[i] = x;
283 return 0;
284 }
285
286 static PyObject *
HH_getitem(arrayobject * ap,Py_ssize_t i)287 HH_getitem(arrayobject *ap, Py_ssize_t i)
288 {
289 return PyLong_FromLong((long) ((unsigned short *)ap->ob_item)[i]);
290 }
291
292 static int
HH_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)293 HH_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
294 {
295 int x;
296 /* PyArg_Parse's 'h' formatter is for a signed short, therefore
297 must use the next size up and manually do the overflow checking */
298 if (!PyArg_Parse(v, "i;array item must be integer", &x))
299 return -1;
300 else if (x < 0) {
301 PyErr_SetString(PyExc_OverflowError,
302 "unsigned short is less than minimum");
303 return -1;
304 }
305 else if (x > USHRT_MAX) {
306 PyErr_SetString(PyExc_OverflowError,
307 "unsigned short is greater than maximum");
308 return -1;
309 }
310 if (i >= 0)
311 ((short *)ap->ob_item)[i] = (short)x;
312 return 0;
313 }
314
315 static PyObject *
i_getitem(arrayobject * ap,Py_ssize_t i)316 i_getitem(arrayobject *ap, Py_ssize_t i)
317 {
318 return PyLong_FromLong((long) ((int *)ap->ob_item)[i]);
319 }
320
321 static int
i_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)322 i_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
323 {
324 int x;
325 /* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */
326 if (!PyArg_Parse(v, "i;array item must be integer", &x))
327 return -1;
328 if (i >= 0)
329 ((int *)ap->ob_item)[i] = x;
330 return 0;
331 }
332
333 static PyObject *
II_getitem(arrayobject * ap,Py_ssize_t i)334 II_getitem(arrayobject *ap, Py_ssize_t i)
335 {
336 return PyLong_FromUnsignedLong(
337 (unsigned long) ((unsigned int *)ap->ob_item)[i]);
338 }
339
340 static PyObject *
get_int_unless_float(PyObject * v)341 get_int_unless_float(PyObject *v)
342 {
343 if (PyFloat_Check(v)) {
344 PyErr_SetString(PyExc_TypeError,
345 "array item must be integer");
346 return NULL;
347 }
348 return _PyLong_FromNbIndexOrNbInt(v);
349 }
350
351 static int
II_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)352 II_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
353 {
354 unsigned long x;
355 int do_decref = 0; /* if nb_int was called */
356
357 if (!PyLong_Check(v)) {
358 v = get_int_unless_float(v);
359 if (NULL == v) {
360 return -1;
361 }
362 do_decref = 1;
363 }
364 x = PyLong_AsUnsignedLong(v);
365 if (x == (unsigned long)-1 && PyErr_Occurred()) {
366 if (do_decref) {
367 Py_DECREF(v);
368 }
369 return -1;
370 }
371 if (x > UINT_MAX) {
372 PyErr_SetString(PyExc_OverflowError,
373 "unsigned int is greater than maximum");
374 if (do_decref) {
375 Py_DECREF(v);
376 }
377 return -1;
378 }
379 if (i >= 0)
380 ((unsigned int *)ap->ob_item)[i] = (unsigned int)x;
381
382 if (do_decref) {
383 Py_DECREF(v);
384 }
385 return 0;
386 }
387
388 static PyObject *
l_getitem(arrayobject * ap,Py_ssize_t i)389 l_getitem(arrayobject *ap, Py_ssize_t i)
390 {
391 return PyLong_FromLong(((long *)ap->ob_item)[i]);
392 }
393
394 static int
l_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)395 l_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
396 {
397 long x;
398 if (!PyArg_Parse(v, "l;array item must be integer", &x))
399 return -1;
400 if (i >= 0)
401 ((long *)ap->ob_item)[i] = x;
402 return 0;
403 }
404
405 static PyObject *
LL_getitem(arrayobject * ap,Py_ssize_t i)406 LL_getitem(arrayobject *ap, Py_ssize_t i)
407 {
408 return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]);
409 }
410
411 static int
LL_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)412 LL_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
413 {
414 unsigned long x;
415 int do_decref = 0; /* if nb_int was called */
416
417 if (!PyLong_Check(v)) {
418 v = get_int_unless_float(v);
419 if (NULL == v) {
420 return -1;
421 }
422 do_decref = 1;
423 }
424 x = PyLong_AsUnsignedLong(v);
425 if (x == (unsigned long)-1 && PyErr_Occurred()) {
426 if (do_decref) {
427 Py_DECREF(v);
428 }
429 return -1;
430 }
431 if (i >= 0)
432 ((unsigned long *)ap->ob_item)[i] = x;
433
434 if (do_decref) {
435 Py_DECREF(v);
436 }
437 return 0;
438 }
439
440 static PyObject *
q_getitem(arrayobject * ap,Py_ssize_t i)441 q_getitem(arrayobject *ap, Py_ssize_t i)
442 {
443 return PyLong_FromLongLong(((long long *)ap->ob_item)[i]);
444 }
445
446 static int
q_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)447 q_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
448 {
449 long long x;
450 if (!PyArg_Parse(v, "L;array item must be integer", &x))
451 return -1;
452 if (i >= 0)
453 ((long long *)ap->ob_item)[i] = x;
454 return 0;
455 }
456
457 static PyObject *
QQ_getitem(arrayobject * ap,Py_ssize_t i)458 QQ_getitem(arrayobject *ap, Py_ssize_t i)
459 {
460 return PyLong_FromUnsignedLongLong(
461 ((unsigned long long *)ap->ob_item)[i]);
462 }
463
464 static int
QQ_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)465 QQ_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
466 {
467 unsigned long long x;
468 int do_decref = 0; /* if nb_int was called */
469
470 if (!PyLong_Check(v)) {
471 v = get_int_unless_float(v);
472 if (NULL == v) {
473 return -1;
474 }
475 do_decref = 1;
476 }
477 x = PyLong_AsUnsignedLongLong(v);
478 if (x == (unsigned long long)-1 && PyErr_Occurred()) {
479 if (do_decref) {
480 Py_DECREF(v);
481 }
482 return -1;
483 }
484 if (i >= 0)
485 ((unsigned long long *)ap->ob_item)[i] = x;
486
487 if (do_decref) {
488 Py_DECREF(v);
489 }
490 return 0;
491 }
492
493 static PyObject *
f_getitem(arrayobject * ap,Py_ssize_t i)494 f_getitem(arrayobject *ap, Py_ssize_t i)
495 {
496 return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]);
497 }
498
499 static int
f_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)500 f_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
501 {
502 float x;
503 if (!PyArg_Parse(v, "f;array item must be float", &x))
504 return -1;
505 if (i >= 0)
506 ((float *)ap->ob_item)[i] = x;
507 return 0;
508 }
509
510 static PyObject *
d_getitem(arrayobject * ap,Py_ssize_t i)511 d_getitem(arrayobject *ap, Py_ssize_t i)
512 {
513 return PyFloat_FromDouble(((double *)ap->ob_item)[i]);
514 }
515
516 static int
d_setitem(arrayobject * ap,Py_ssize_t i,PyObject * v)517 d_setitem(arrayobject *ap, Py_ssize_t i, PyObject *v)
518 {
519 double x;
520 if (!PyArg_Parse(v, "d;array item must be float", &x))
521 return -1;
522 if (i >= 0)
523 ((double *)ap->ob_item)[i] = x;
524 return 0;
525 }
526
527 #define DEFINE_COMPAREITEMS(code, type) \
528 static int \
529 code##_compareitems(const void *lhs, const void *rhs, Py_ssize_t length) \
530 { \
531 const type *a = lhs, *b = rhs; \
532 for (Py_ssize_t i = 0; i < length; ++i) \
533 if (a[i] != b[i]) \
534 return a[i] < b[i] ? -1 : 1; \
535 return 0; \
536 }
537
538 DEFINE_COMPAREITEMS(b, signed char)
539 DEFINE_COMPAREITEMS(BB, unsigned char)
540 DEFINE_COMPAREITEMS(u, wchar_t)
541 DEFINE_COMPAREITEMS(h, short)
542 DEFINE_COMPAREITEMS(HH, unsigned short)
543 DEFINE_COMPAREITEMS(i, int)
544 DEFINE_COMPAREITEMS(II, unsigned int)
545 DEFINE_COMPAREITEMS(l, long)
546 DEFINE_COMPAREITEMS(LL, unsigned long)
547 DEFINE_COMPAREITEMS(q, long long)
548 DEFINE_COMPAREITEMS(QQ, unsigned long long)
549
550 /* Description of types.
551 *
552 * Don't forget to update typecode_to_mformat_code() if you add a new
553 * typecode.
554 */
555 static const struct arraydescr descriptors[] = {
556 {'b', 1, b_getitem, b_setitem, b_compareitems, "b", 1, 1},
557 {'B', 1, BB_getitem, BB_setitem, BB_compareitems, "B", 1, 0},
558 {'u', sizeof(wchar_t), u_getitem, u_setitem, u_compareitems, "u", 0, 0},
559 {'h', sizeof(short), h_getitem, h_setitem, h_compareitems, "h", 1, 1},
560 {'H', sizeof(short), HH_getitem, HH_setitem, HH_compareitems, "H", 1, 0},
561 {'i', sizeof(int), i_getitem, i_setitem, i_compareitems, "i", 1, 1},
562 {'I', sizeof(int), II_getitem, II_setitem, II_compareitems, "I", 1, 0},
563 {'l', sizeof(long), l_getitem, l_setitem, l_compareitems, "l", 1, 1},
564 {'L', sizeof(long), LL_getitem, LL_setitem, LL_compareitems, "L", 1, 0},
565 {'q', sizeof(long long), q_getitem, q_setitem, q_compareitems, "q", 1, 1},
566 {'Q', sizeof(long long), QQ_getitem, QQ_setitem, QQ_compareitems, "Q", 1, 0},
567 {'f', sizeof(float), f_getitem, f_setitem, NULL, "f", 0, 0},
568 {'d', sizeof(double), d_getitem, d_setitem, NULL, "d", 0, 0},
569 {'\0', 0, 0, 0, 0, 0, 0} /* Sentinel */
570 };
571
572 /****************************************************************************
573 Implementations of array object methods.
574 ****************************************************************************/
575 /*[clinic input]
576 class array.array "arrayobject *" "&Arraytype"
577 [clinic start generated code]*/
578 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=ad43d37e942a8854]*/
579
580 static PyObject *
newarrayobject(PyTypeObject * type,Py_ssize_t size,const struct arraydescr * descr)581 newarrayobject(PyTypeObject *type, Py_ssize_t size, const struct arraydescr *descr)
582 {
583 arrayobject *op;
584 size_t nbytes;
585
586 if (size < 0) {
587 PyErr_BadInternalCall();
588 return NULL;
589 }
590
591 /* Check for overflow */
592 if (size > PY_SSIZE_T_MAX / descr->itemsize) {
593 return PyErr_NoMemory();
594 }
595 nbytes = size * descr->itemsize;
596 op = (arrayobject *) type->tp_alloc(type, 0);
597 if (op == NULL) {
598 return NULL;
599 }
600 op->ob_descr = descr;
601 op->allocated = size;
602 op->weakreflist = NULL;
603 Py_SET_SIZE(op, size);
604 if (size <= 0) {
605 op->ob_item = NULL;
606 }
607 else {
608 op->ob_item = PyMem_NEW(char, nbytes);
609 if (op->ob_item == NULL) {
610 Py_DECREF(op);
611 return PyErr_NoMemory();
612 }
613 }
614 op->ob_exports = 0;
615 return (PyObject *) op;
616 }
617
618 static PyObject *
getarrayitem(PyObject * op,Py_ssize_t i)619 getarrayitem(PyObject *op, Py_ssize_t i)
620 {
621 arrayobject *ap;
622 assert(array_Check(op));
623 ap = (arrayobject *)op;
624 assert(i>=0 && i<Py_SIZE(ap));
625 return (*ap->ob_descr->getitem)(ap, i);
626 }
627
628 static int
ins1(arrayobject * self,Py_ssize_t where,PyObject * v)629 ins1(arrayobject *self, Py_ssize_t where, PyObject *v)
630 {
631 char *items;
632 Py_ssize_t n = Py_SIZE(self);
633 if (v == NULL) {
634 PyErr_BadInternalCall();
635 return -1;
636 }
637 if ((*self->ob_descr->setitem)(self, -1, v) < 0)
638 return -1;
639
640 if (array_resize(self, n+1) == -1)
641 return -1;
642 items = self->ob_item;
643 if (where < 0) {
644 where += n;
645 if (where < 0)
646 where = 0;
647 }
648 if (where > n)
649 where = n;
650 /* appends don't need to call memmove() */
651 if (where != n)
652 memmove(items + (where+1)*self->ob_descr->itemsize,
653 items + where*self->ob_descr->itemsize,
654 (n-where)*self->ob_descr->itemsize);
655 return (*self->ob_descr->setitem)(self, where, v);
656 }
657
658 /* Methods */
659
660 static void
array_dealloc(arrayobject * op)661 array_dealloc(arrayobject *op)
662 {
663 if (op->weakreflist != NULL)
664 PyObject_ClearWeakRefs((PyObject *) op);
665 if (op->ob_item != NULL)
666 PyMem_DEL(op->ob_item);
667 Py_TYPE(op)->tp_free((PyObject *)op);
668 }
669
670 static PyObject *
array_richcompare(PyObject * v,PyObject * w,int op)671 array_richcompare(PyObject *v, PyObject *w, int op)
672 {
673 arrayobject *va, *wa;
674 PyObject *vi = NULL;
675 PyObject *wi = NULL;
676 Py_ssize_t i, k;
677 PyObject *res;
678
679 if (!array_Check(v) || !array_Check(w))
680 Py_RETURN_NOTIMPLEMENTED;
681
682 va = (arrayobject *)v;
683 wa = (arrayobject *)w;
684
685 if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ || op == Py_NE)) {
686 /* Shortcut: if the lengths differ, the arrays differ */
687 if (op == Py_EQ)
688 res = Py_False;
689 else
690 res = Py_True;
691 Py_INCREF(res);
692 return res;
693 }
694
695 if (va->ob_descr == wa->ob_descr && va->ob_descr->compareitems != NULL) {
696 /* Fast path:
697 arrays with same types can have their buffers compared directly */
698 Py_ssize_t common_length = Py_MIN(Py_SIZE(va), Py_SIZE(wa));
699 int result = va->ob_descr->compareitems(va->ob_item, wa->ob_item,
700 common_length);
701 if (result == 0)
702 goto compare_sizes;
703
704 int cmp;
705 switch (op) {
706 case Py_LT: cmp = result < 0; break;
707 case Py_LE: cmp = result <= 0; break;
708 case Py_EQ: cmp = result == 0; break;
709 case Py_NE: cmp = result != 0; break;
710 case Py_GT: cmp = result > 0; break;
711 case Py_GE: cmp = result >= 0; break;
712 default: return NULL; /* cannot happen */
713 }
714 PyObject *res = cmp ? Py_True : Py_False;
715 Py_INCREF(res);
716 return res;
717 }
718
719
720 /* Search for the first index where items are different */
721 k = 1;
722 for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) {
723 vi = getarrayitem(v, i);
724 wi = getarrayitem(w, i);
725 if (vi == NULL || wi == NULL) {
726 Py_XDECREF(vi);
727 Py_XDECREF(wi);
728 return NULL;
729 }
730 k = PyObject_RichCompareBool(vi, wi, Py_EQ);
731 if (k == 0)
732 break; /* Keeping vi and wi alive! */
733 Py_DECREF(vi);
734 Py_DECREF(wi);
735 if (k < 0)
736 return NULL;
737 }
738
739 if (k) {
740 /* No more items to compare -- compare sizes */
741 compare_sizes: ;
742 Py_ssize_t vs = Py_SIZE(va);
743 Py_ssize_t ws = Py_SIZE(wa);
744 int cmp;
745 switch (op) {
746 case Py_LT: cmp = vs < ws; break;
747 case Py_LE: cmp = vs <= ws; break;
748 /* If the lengths were not equal,
749 the earlier fast-path check would have caught that. */
750 case Py_EQ: assert(vs == ws); cmp = 1; break;
751 case Py_NE: assert(vs == ws); cmp = 0; break;
752 case Py_GT: cmp = vs > ws; break;
753 case Py_GE: cmp = vs >= ws; break;
754 default: return NULL; /* cannot happen */
755 }
756 if (cmp)
757 res = Py_True;
758 else
759 res = Py_False;
760 Py_INCREF(res);
761 return res;
762 }
763
764 /* We have an item that differs. First, shortcuts for EQ/NE */
765 if (op == Py_EQ) {
766 Py_INCREF(Py_False);
767 res = Py_False;
768 }
769 else if (op == Py_NE) {
770 Py_INCREF(Py_True);
771 res = Py_True;
772 }
773 else {
774 /* Compare the final item again using the proper operator */
775 res = PyObject_RichCompare(vi, wi, op);
776 }
777 Py_DECREF(vi);
778 Py_DECREF(wi);
779 return res;
780 }
781
782 static Py_ssize_t
array_length(arrayobject * a)783 array_length(arrayobject *a)
784 {
785 return Py_SIZE(a);
786 }
787
788 static PyObject *
array_item(arrayobject * a,Py_ssize_t i)789 array_item(arrayobject *a, Py_ssize_t i)
790 {
791 if (i < 0 || i >= Py_SIZE(a)) {
792 PyErr_SetString(PyExc_IndexError, "array index out of range");
793 return NULL;
794 }
795 return getarrayitem((PyObject *)a, i);
796 }
797
798 static PyObject *
array_slice(arrayobject * a,Py_ssize_t ilow,Py_ssize_t ihigh)799 array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
800 {
801 arrayobject *np;
802 if (ilow < 0)
803 ilow = 0;
804 else if (ilow > Py_SIZE(a))
805 ilow = Py_SIZE(a);
806 if (ihigh < 0)
807 ihigh = 0;
808 if (ihigh < ilow)
809 ihigh = ilow;
810 else if (ihigh > Py_SIZE(a))
811 ihigh = Py_SIZE(a);
812 np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);
813 if (np == NULL)
814 return NULL;
815 if (ihigh > ilow) {
816 memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize,
817 (ihigh-ilow) * a->ob_descr->itemsize);
818 }
819 return (PyObject *)np;
820 }
821
822
823 /*[clinic input]
824 array.array.__copy__
825
826 Return a copy of the array.
827 [clinic start generated code]*/
828
829 static PyObject *
array_array___copy___impl(arrayobject * self)830 array_array___copy___impl(arrayobject *self)
831 /*[clinic end generated code: output=dec7c3f925d9619e input=ad1ee5b086965f09]*/
832 {
833 return array_slice(self, 0, Py_SIZE(self));
834 }
835
836 /*[clinic input]
837 array.array.__deepcopy__
838
839 unused: object
840 /
841
842 Return a copy of the array.
843 [clinic start generated code]*/
844
845 static PyObject *
array_array___deepcopy__(arrayobject * self,PyObject * unused)846 array_array___deepcopy__(arrayobject *self, PyObject *unused)
847 /*[clinic end generated code: output=1ec748d8e14a9faa input=2405ecb4933748c4]*/
848 {
849 return array_array___copy___impl(self);
850 }
851
852 static PyObject *
array_concat(arrayobject * a,PyObject * bb)853 array_concat(arrayobject *a, PyObject *bb)
854 {
855 Py_ssize_t size;
856 arrayobject *np;
857 if (!array_Check(bb)) {
858 PyErr_Format(PyExc_TypeError,
859 "can only append array (not \"%.200s\") to array",
860 Py_TYPE(bb)->tp_name);
861 return NULL;
862 }
863 #define b ((arrayobject *)bb)
864 if (a->ob_descr != b->ob_descr) {
865 PyErr_BadArgument();
866 return NULL;
867 }
868 if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) {
869 return PyErr_NoMemory();
870 }
871 size = Py_SIZE(a) + Py_SIZE(b);
872 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
873 if (np == NULL) {
874 return NULL;
875 }
876 if (Py_SIZE(a) > 0) {
877 memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize);
878 }
879 if (Py_SIZE(b) > 0) {
880 memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize,
881 b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
882 }
883 return (PyObject *)np;
884 #undef b
885 }
886
887 static PyObject *
array_repeat(arrayobject * a,Py_ssize_t n)888 array_repeat(arrayobject *a, Py_ssize_t n)
889 {
890 Py_ssize_t size;
891 arrayobject *np;
892 Py_ssize_t oldbytes, newbytes;
893 if (n < 0)
894 n = 0;
895 if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) {
896 return PyErr_NoMemory();
897 }
898 size = Py_SIZE(a) * n;
899 np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
900 if (np == NULL)
901 return NULL;
902 if (size == 0)
903 return (PyObject *)np;
904 oldbytes = Py_SIZE(a) * a->ob_descr->itemsize;
905 newbytes = oldbytes * n;
906 /* this follows the code in unicode_repeat */
907 if (oldbytes == 1) {
908 memset(np->ob_item, a->ob_item[0], newbytes);
909 } else {
910 Py_ssize_t done = oldbytes;
911 memcpy(np->ob_item, a->ob_item, oldbytes);
912 while (done < newbytes) {
913 Py_ssize_t ncopy = (done <= newbytes-done) ? done : newbytes-done;
914 memcpy(np->ob_item+done, np->ob_item, ncopy);
915 done += ncopy;
916 }
917 }
918 return (PyObject *)np;
919 }
920
921 static int
array_del_slice(arrayobject * a,Py_ssize_t ilow,Py_ssize_t ihigh)922 array_del_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
923 {
924 char *item;
925 Py_ssize_t d; /* Change in size */
926 if (ilow < 0)
927 ilow = 0;
928 else if (ilow > Py_SIZE(a))
929 ilow = Py_SIZE(a);
930 if (ihigh < 0)
931 ihigh = 0;
932 if (ihigh < ilow)
933 ihigh = ilow;
934 else if (ihigh > Py_SIZE(a))
935 ihigh = Py_SIZE(a);
936 item = a->ob_item;
937 d = ihigh-ilow;
938 /* Issue #4509: If the array has exported buffers and the slice
939 assignment would change the size of the array, fail early to make
940 sure we don't modify it. */
941 if (d != 0 && a->ob_exports > 0) {
942 PyErr_SetString(PyExc_BufferError,
943 "cannot resize an array that is exporting buffers");
944 return -1;
945 }
946 if (d > 0) { /* Delete d items */
947 memmove(item + (ihigh-d)*a->ob_descr->itemsize,
948 item + ihigh*a->ob_descr->itemsize,
949 (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
950 if (array_resize(a, Py_SIZE(a) - d) == -1)
951 return -1;
952 }
953 return 0;
954 }
955
956 static int
array_ass_item(arrayobject * a,Py_ssize_t i,PyObject * v)957 array_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v)
958 {
959 if (i < 0 || i >= Py_SIZE(a)) {
960 PyErr_SetString(PyExc_IndexError,
961 "array assignment index out of range");
962 return -1;
963 }
964 if (v == NULL)
965 return array_del_slice(a, i, i+1);
966 return (*a->ob_descr->setitem)(a, i, v);
967 }
968
969 static int
setarrayitem(PyObject * a,Py_ssize_t i,PyObject * v)970 setarrayitem(PyObject *a, Py_ssize_t i, PyObject *v)
971 {
972 assert(array_Check(a));
973 return array_ass_item((arrayobject *)a, i, v);
974 }
975
976 static int
array_iter_extend(arrayobject * self,PyObject * bb)977 array_iter_extend(arrayobject *self, PyObject *bb)
978 {
979 PyObject *it, *v;
980
981 it = PyObject_GetIter(bb);
982 if (it == NULL)
983 return -1;
984
985 while ((v = PyIter_Next(it)) != NULL) {
986 if (ins1(self, Py_SIZE(self), v) != 0) {
987 Py_DECREF(v);
988 Py_DECREF(it);
989 return -1;
990 }
991 Py_DECREF(v);
992 }
993 Py_DECREF(it);
994 if (PyErr_Occurred())
995 return -1;
996 return 0;
997 }
998
999 static int
array_do_extend(arrayobject * self,PyObject * bb)1000 array_do_extend(arrayobject *self, PyObject *bb)
1001 {
1002 Py_ssize_t size, oldsize, bbsize;
1003
1004 if (!array_Check(bb))
1005 return array_iter_extend(self, bb);
1006 #define b ((arrayobject *)bb)
1007 if (self->ob_descr != b->ob_descr) {
1008 PyErr_SetString(PyExc_TypeError,
1009 "can only extend with array of same kind");
1010 return -1;
1011 }
1012 if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) ||
1013 ((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
1014 PyErr_NoMemory();
1015 return -1;
1016 }
1017 oldsize = Py_SIZE(self);
1018 /* Get the size of bb before resizing the array since bb could be self. */
1019 bbsize = Py_SIZE(bb);
1020 size = oldsize + Py_SIZE(b);
1021 if (array_resize(self, size) == -1)
1022 return -1;
1023 if (bbsize > 0) {
1024 memcpy(self->ob_item + oldsize * self->ob_descr->itemsize,
1025 b->ob_item, bbsize * b->ob_descr->itemsize);
1026 }
1027
1028 return 0;
1029 #undef b
1030 }
1031
1032 static PyObject *
array_inplace_concat(arrayobject * self,PyObject * bb)1033 array_inplace_concat(arrayobject *self, PyObject *bb)
1034 {
1035 if (!array_Check(bb)) {
1036 PyErr_Format(PyExc_TypeError,
1037 "can only extend array with array (not \"%.200s\")",
1038 Py_TYPE(bb)->tp_name);
1039 return NULL;
1040 }
1041 if (array_do_extend(self, bb) == -1)
1042 return NULL;
1043 Py_INCREF(self);
1044 return (PyObject *)self;
1045 }
1046
1047 static PyObject *
array_inplace_repeat(arrayobject * self,Py_ssize_t n)1048 array_inplace_repeat(arrayobject *self, Py_ssize_t n)
1049 {
1050 char *items, *p;
1051 Py_ssize_t size, i;
1052
1053 if (Py_SIZE(self) > 0) {
1054 if (n < 0)
1055 n = 0;
1056 if ((self->ob_descr->itemsize != 0) &&
1057 (Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
1058 return PyErr_NoMemory();
1059 }
1060 size = Py_SIZE(self) * self->ob_descr->itemsize;
1061 if (n > 0 && size > PY_SSIZE_T_MAX / n) {
1062 return PyErr_NoMemory();
1063 }
1064 if (array_resize(self, n * Py_SIZE(self)) == -1)
1065 return NULL;
1066 items = p = self->ob_item;
1067 for (i = 1; i < n; i++) {
1068 p += size;
1069 memcpy(p, items, size);
1070 }
1071 }
1072 Py_INCREF(self);
1073 return (PyObject *)self;
1074 }
1075
1076
1077 static PyObject *
ins(arrayobject * self,Py_ssize_t where,PyObject * v)1078 ins(arrayobject *self, Py_ssize_t where, PyObject *v)
1079 {
1080 if (ins1(self, where, v) != 0)
1081 return NULL;
1082 Py_RETURN_NONE;
1083 }
1084
1085 /*[clinic input]
1086 array.array.count
1087
1088 v: object
1089 /
1090
1091 Return number of occurrences of v in the array.
1092 [clinic start generated code]*/
1093
1094 static PyObject *
array_array_count(arrayobject * self,PyObject * v)1095 array_array_count(arrayobject *self, PyObject *v)
1096 /*[clinic end generated code: output=3dd3624bf7135a3a input=d9bce9d65e39d1f5]*/
1097 {
1098 Py_ssize_t count = 0;
1099 Py_ssize_t i;
1100
1101 for (i = 0; i < Py_SIZE(self); i++) {
1102 PyObject *selfi;
1103 int cmp;
1104
1105 selfi = getarrayitem((PyObject *)self, i);
1106 if (selfi == NULL)
1107 return NULL;
1108 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
1109 Py_DECREF(selfi);
1110 if (cmp > 0)
1111 count++;
1112 else if (cmp < 0)
1113 return NULL;
1114 }
1115 return PyLong_FromSsize_t(count);
1116 }
1117
1118
1119 /*[clinic input]
1120 array.array.index
1121
1122 v: object
1123 /
1124
1125 Return index of first occurrence of v in the array.
1126 [clinic start generated code]*/
1127
1128 static PyObject *
array_array_index(arrayobject * self,PyObject * v)1129 array_array_index(arrayobject *self, PyObject *v)
1130 /*[clinic end generated code: output=d48498d325602167 input=cf619898c6649d08]*/
1131 {
1132 Py_ssize_t i;
1133
1134 for (i = 0; i < Py_SIZE(self); i++) {
1135 PyObject *selfi;
1136 int cmp;
1137
1138 selfi = getarrayitem((PyObject *)self, i);
1139 if (selfi == NULL)
1140 return NULL;
1141 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
1142 Py_DECREF(selfi);
1143 if (cmp > 0) {
1144 return PyLong_FromSsize_t(i);
1145 }
1146 else if (cmp < 0)
1147 return NULL;
1148 }
1149 PyErr_SetString(PyExc_ValueError, "array.index(x): x not in array");
1150 return NULL;
1151 }
1152
1153 static int
array_contains(arrayobject * self,PyObject * v)1154 array_contains(arrayobject *self, PyObject *v)
1155 {
1156 Py_ssize_t i;
1157 int cmp;
1158
1159 for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) {
1160 PyObject *selfi = getarrayitem((PyObject *)self, i);
1161 if (selfi == NULL)
1162 return -1;
1163 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
1164 Py_DECREF(selfi);
1165 }
1166 return cmp;
1167 }
1168
1169 /*[clinic input]
1170 array.array.remove
1171
1172 v: object
1173 /
1174
1175 Remove the first occurrence of v in the array.
1176 [clinic start generated code]*/
1177
1178 static PyObject *
array_array_remove(arrayobject * self,PyObject * v)1179 array_array_remove(arrayobject *self, PyObject *v)
1180 /*[clinic end generated code: output=bef06be9fdf9dceb input=0b1e5aed25590027]*/
1181 {
1182 Py_ssize_t i;
1183
1184 for (i = 0; i < Py_SIZE(self); i++) {
1185 PyObject *selfi;
1186 int cmp;
1187
1188 selfi = getarrayitem((PyObject *)self,i);
1189 if (selfi == NULL)
1190 return NULL;
1191 cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
1192 Py_DECREF(selfi);
1193 if (cmp > 0) {
1194 if (array_del_slice(self, i, i+1) != 0)
1195 return NULL;
1196 Py_RETURN_NONE;
1197 }
1198 else if (cmp < 0)
1199 return NULL;
1200 }
1201 PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in array");
1202 return NULL;
1203 }
1204
1205 /*[clinic input]
1206 array.array.pop
1207
1208 i: Py_ssize_t = -1
1209 /
1210
1211 Return the i-th element and delete it from the array.
1212
1213 i defaults to -1.
1214 [clinic start generated code]*/
1215
1216 static PyObject *
array_array_pop_impl(arrayobject * self,Py_ssize_t i)1217 array_array_pop_impl(arrayobject *self, Py_ssize_t i)
1218 /*[clinic end generated code: output=bc1f0c54fe5308e4 input=8e5feb4c1a11cd44]*/
1219 {
1220 PyObject *v;
1221
1222 if (Py_SIZE(self) == 0) {
1223 /* Special-case most common failure cause */
1224 PyErr_SetString(PyExc_IndexError, "pop from empty array");
1225 return NULL;
1226 }
1227 if (i < 0)
1228 i += Py_SIZE(self);
1229 if (i < 0 || i >= Py_SIZE(self)) {
1230 PyErr_SetString(PyExc_IndexError, "pop index out of range");
1231 return NULL;
1232 }
1233 v = getarrayitem((PyObject *)self, i);
1234 if (v == NULL)
1235 return NULL;
1236 if (array_del_slice(self, i, i+1) != 0) {
1237 Py_DECREF(v);
1238 return NULL;
1239 }
1240 return v;
1241 }
1242
1243 /*[clinic input]
1244 array.array.extend
1245
1246 bb: object
1247 /
1248
1249 Append items to the end of the array.
1250 [clinic start generated code]*/
1251
1252 static PyObject *
array_array_extend(arrayobject * self,PyObject * bb)1253 array_array_extend(arrayobject *self, PyObject *bb)
1254 /*[clinic end generated code: output=bbddbc8e8bef871d input=43be86aba5c31e44]*/
1255 {
1256 if (array_do_extend(self, bb) == -1)
1257 return NULL;
1258 Py_RETURN_NONE;
1259 }
1260
1261 /*[clinic input]
1262 array.array.insert
1263
1264 i: Py_ssize_t
1265 v: object
1266 /
1267
1268 Insert a new item v into the array before position i.
1269 [clinic start generated code]*/
1270
1271 static PyObject *
array_array_insert_impl(arrayobject * self,Py_ssize_t i,PyObject * v)1272 array_array_insert_impl(arrayobject *self, Py_ssize_t i, PyObject *v)
1273 /*[clinic end generated code: output=5a3648e278348564 input=5577d1b4383e9313]*/
1274 {
1275 return ins(self, i, v);
1276 }
1277
1278 /*[clinic input]
1279 array.array.buffer_info
1280
1281 Return a tuple (address, length) giving the current memory address and the length in items of the buffer used to hold array's contents.
1282
1283 The length should be multiplied by the itemsize attribute to calculate
1284 the buffer length in bytes.
1285 [clinic start generated code]*/
1286
1287 static PyObject *
array_array_buffer_info_impl(arrayobject * self)1288 array_array_buffer_info_impl(arrayobject *self)
1289 /*[clinic end generated code: output=9b2a4ec3ae7e98e7 input=a58bae5c6e1ac6a6]*/
1290 {
1291 PyObject *retval = NULL, *v;
1292
1293 retval = PyTuple_New(2);
1294 if (!retval)
1295 return NULL;
1296
1297 v = PyLong_FromVoidPtr(self->ob_item);
1298 if (v == NULL) {
1299 Py_DECREF(retval);
1300 return NULL;
1301 }
1302 PyTuple_SET_ITEM(retval, 0, v);
1303
1304 v = PyLong_FromSsize_t(Py_SIZE(self));
1305 if (v == NULL) {
1306 Py_DECREF(retval);
1307 return NULL;
1308 }
1309 PyTuple_SET_ITEM(retval, 1, v);
1310
1311 return retval;
1312 }
1313
1314 /*[clinic input]
1315 array.array.append
1316
1317 v: object
1318 /
1319
1320 Append new value v to the end of the array.
1321 [clinic start generated code]*/
1322
1323 static PyObject *
array_array_append(arrayobject * self,PyObject * v)1324 array_array_append(arrayobject *self, PyObject *v)
1325 /*[clinic end generated code: output=745a0669bf8db0e2 input=0b98d9d78e78f0fa]*/
1326 {
1327 return ins(self, Py_SIZE(self), v);
1328 }
1329
1330 /*[clinic input]
1331 array.array.byteswap
1332
1333 Byteswap all items of the array.
1334
1335 If the items in the array are not 1, 2, 4, or 8 bytes in size, RuntimeError is
1336 raised.
1337 [clinic start generated code]*/
1338
1339 static PyObject *
array_array_byteswap_impl(arrayobject * self)1340 array_array_byteswap_impl(arrayobject *self)
1341 /*[clinic end generated code: output=5f8236cbdf0d90b5 input=6a85591b950a0186]*/
1342 {
1343 char *p;
1344 Py_ssize_t i;
1345
1346 switch (self->ob_descr->itemsize) {
1347 case 1:
1348 break;
1349 case 2:
1350 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) {
1351 char p0 = p[0];
1352 p[0] = p[1];
1353 p[1] = p0;
1354 }
1355 break;
1356 case 4:
1357 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) {
1358 char p0 = p[0];
1359 char p1 = p[1];
1360 p[0] = p[3];
1361 p[1] = p[2];
1362 p[2] = p1;
1363 p[3] = p0;
1364 }
1365 break;
1366 case 8:
1367 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) {
1368 char p0 = p[0];
1369 char p1 = p[1];
1370 char p2 = p[2];
1371 char p3 = p[3];
1372 p[0] = p[7];
1373 p[1] = p[6];
1374 p[2] = p[5];
1375 p[3] = p[4];
1376 p[4] = p3;
1377 p[5] = p2;
1378 p[6] = p1;
1379 p[7] = p0;
1380 }
1381 break;
1382 default:
1383 PyErr_SetString(PyExc_RuntimeError,
1384 "don't know how to byteswap this array type");
1385 return NULL;
1386 }
1387 Py_RETURN_NONE;
1388 }
1389
1390 /*[clinic input]
1391 array.array.reverse
1392
1393 Reverse the order of the items in the array.
1394 [clinic start generated code]*/
1395
1396 static PyObject *
array_array_reverse_impl(arrayobject * self)1397 array_array_reverse_impl(arrayobject *self)
1398 /*[clinic end generated code: output=c04868b36f6f4089 input=cd904f01b27d966a]*/
1399 {
1400 Py_ssize_t itemsize = self->ob_descr->itemsize;
1401 char *p, *q;
1402 /* little buffer to hold items while swapping */
1403 char tmp[256]; /* 8 is probably enough -- but why skimp */
1404 assert((size_t)itemsize <= sizeof(tmp));
1405
1406 if (Py_SIZE(self) > 1) {
1407 for (p = self->ob_item,
1408 q = self->ob_item + (Py_SIZE(self) - 1)*itemsize;
1409 p < q;
1410 p += itemsize, q -= itemsize) {
1411 /* memory areas guaranteed disjoint, so memcpy
1412 * is safe (& memmove may be slower).
1413 */
1414 memcpy(tmp, p, itemsize);
1415 memcpy(p, q, itemsize);
1416 memcpy(q, tmp, itemsize);
1417 }
1418 }
1419
1420 Py_RETURN_NONE;
1421 }
1422
1423 /*[clinic input]
1424 array.array.fromfile
1425
1426 f: object
1427 n: Py_ssize_t
1428 /
1429
1430 Read n objects from the file object f and append them to the end of the array.
1431 [clinic start generated code]*/
1432
1433 static PyObject *
array_array_fromfile_impl(arrayobject * self,PyObject * f,Py_ssize_t n)1434 array_array_fromfile_impl(arrayobject *self, PyObject *f, Py_ssize_t n)
1435 /*[clinic end generated code: output=ec9f600e10f53510 input=e188afe8e58adf40]*/
1436 {
1437 PyObject *b, *res;
1438 Py_ssize_t itemsize = self->ob_descr->itemsize;
1439 Py_ssize_t nbytes;
1440 _Py_IDENTIFIER(read);
1441 int not_enough_bytes;
1442
1443 if (n < 0) {
1444 PyErr_SetString(PyExc_ValueError, "negative count");
1445 return NULL;
1446 }
1447 if (n > PY_SSIZE_T_MAX / itemsize) {
1448 PyErr_NoMemory();
1449 return NULL;
1450 }
1451 nbytes = n * itemsize;
1452
1453 b = _PyObject_CallMethodId(f, &PyId_read, "n", nbytes);
1454 if (b == NULL)
1455 return NULL;
1456
1457 if (!PyBytes_Check(b)) {
1458 PyErr_SetString(PyExc_TypeError,
1459 "read() didn't return bytes");
1460 Py_DECREF(b);
1461 return NULL;
1462 }
1463
1464 not_enough_bytes = (PyBytes_GET_SIZE(b) != nbytes);
1465
1466 res = array_array_frombytes(self, b);
1467 Py_DECREF(b);
1468 if (res == NULL)
1469 return NULL;
1470
1471 if (not_enough_bytes) {
1472 PyErr_SetString(PyExc_EOFError,
1473 "read() didn't return enough bytes");
1474 Py_DECREF(res);
1475 return NULL;
1476 }
1477
1478 return res;
1479 }
1480
1481 /*[clinic input]
1482 array.array.tofile
1483
1484 f: object
1485 /
1486
1487 Write all items (as machine values) to the file object f.
1488 [clinic start generated code]*/
1489
1490 static PyObject *
array_array_tofile(arrayobject * self,PyObject * f)1491 array_array_tofile(arrayobject *self, PyObject *f)
1492 /*[clinic end generated code: output=3a2cfa8128df0777 input=b0669a484aab0831]*/
1493 {
1494 Py_ssize_t nbytes = Py_SIZE(self) * self->ob_descr->itemsize;
1495 /* Write 64K blocks at a time */
1496 /* XXX Make the block size settable */
1497 int BLOCKSIZE = 64*1024;
1498 Py_ssize_t nblocks = (nbytes + BLOCKSIZE - 1) / BLOCKSIZE;
1499 Py_ssize_t i;
1500
1501 if (Py_SIZE(self) == 0)
1502 goto done;
1503
1504 for (i = 0; i < nblocks; i++) {
1505 char* ptr = self->ob_item + i*BLOCKSIZE;
1506 Py_ssize_t size = BLOCKSIZE;
1507 PyObject *bytes, *res;
1508 _Py_IDENTIFIER(write);
1509
1510 if (i*BLOCKSIZE + size > nbytes)
1511 size = nbytes - i*BLOCKSIZE;
1512 bytes = PyBytes_FromStringAndSize(ptr, size);
1513 if (bytes == NULL)
1514 return NULL;
1515 res = _PyObject_CallMethodIdOneArg(f, &PyId_write, bytes);
1516 Py_DECREF(bytes);
1517 if (res == NULL)
1518 return NULL;
1519 Py_DECREF(res); /* drop write result */
1520 }
1521
1522 done:
1523 Py_RETURN_NONE;
1524 }
1525
1526 /*[clinic input]
1527 array.array.fromlist
1528
1529 list: object
1530 /
1531
1532 Append items to array from list.
1533 [clinic start generated code]*/
1534
1535 static PyObject *
array_array_fromlist(arrayobject * self,PyObject * list)1536 array_array_fromlist(arrayobject *self, PyObject *list)
1537 /*[clinic end generated code: output=26411c2d228a3e3f input=be2605a96c49680f]*/
1538 {
1539 Py_ssize_t n;
1540
1541 if (!PyList_Check(list)) {
1542 PyErr_SetString(PyExc_TypeError, "arg must be list");
1543 return NULL;
1544 }
1545 n = PyList_Size(list);
1546 if (n > 0) {
1547 Py_ssize_t i, old_size;
1548 old_size = Py_SIZE(self);
1549 if (array_resize(self, old_size + n) == -1)
1550 return NULL;
1551 for (i = 0; i < n; i++) {
1552 PyObject *v = PyList_GET_ITEM(list, i);
1553 if ((*self->ob_descr->setitem)(self,
1554 Py_SIZE(self) - n + i, v) != 0) {
1555 array_resize(self, old_size);
1556 return NULL;
1557 }
1558 if (n != PyList_GET_SIZE(list)) {
1559 PyErr_SetString(PyExc_RuntimeError,
1560 "list changed size during iteration");
1561 array_resize(self, old_size);
1562 return NULL;
1563 }
1564 }
1565 }
1566 Py_RETURN_NONE;
1567 }
1568
1569 /*[clinic input]
1570 array.array.tolist
1571
1572 Convert array to an ordinary list with the same items.
1573 [clinic start generated code]*/
1574
1575 static PyObject *
array_array_tolist_impl(arrayobject * self)1576 array_array_tolist_impl(arrayobject *self)
1577 /*[clinic end generated code: output=00b60cc9eab8ef89 input=a8d7784a94f86b53]*/
1578 {
1579 PyObject *list = PyList_New(Py_SIZE(self));
1580 Py_ssize_t i;
1581
1582 if (list == NULL)
1583 return NULL;
1584 for (i = 0; i < Py_SIZE(self); i++) {
1585 PyObject *v = getarrayitem((PyObject *)self, i);
1586 if (v == NULL)
1587 goto error;
1588 PyList_SET_ITEM(list, i, v);
1589 }
1590 return list;
1591
1592 error:
1593 Py_DECREF(list);
1594 return NULL;
1595 }
1596
1597 static PyObject *
frombytes(arrayobject * self,Py_buffer * buffer)1598 frombytes(arrayobject *self, Py_buffer *buffer)
1599 {
1600 int itemsize = self->ob_descr->itemsize;
1601 Py_ssize_t n;
1602 if (buffer->itemsize != 1) {
1603 PyBuffer_Release(buffer);
1604 PyErr_SetString(PyExc_TypeError, "a bytes-like object is required");
1605 return NULL;
1606 }
1607 n = buffer->len;
1608 if (n % itemsize != 0) {
1609 PyBuffer_Release(buffer);
1610 PyErr_SetString(PyExc_ValueError,
1611 "bytes length not a multiple of item size");
1612 return NULL;
1613 }
1614 n = n / itemsize;
1615 if (n > 0) {
1616 Py_ssize_t old_size = Py_SIZE(self);
1617 if ((n > PY_SSIZE_T_MAX - old_size) ||
1618 ((old_size + n) > PY_SSIZE_T_MAX / itemsize)) {
1619 PyBuffer_Release(buffer);
1620 return PyErr_NoMemory();
1621 }
1622 if (array_resize(self, old_size + n) == -1) {
1623 PyBuffer_Release(buffer);
1624 return NULL;
1625 }
1626 memcpy(self->ob_item + old_size * itemsize,
1627 buffer->buf, n * itemsize);
1628 }
1629 PyBuffer_Release(buffer);
1630 Py_RETURN_NONE;
1631 }
1632
1633 /*[clinic input]
1634 array.array.frombytes
1635
1636 buffer: Py_buffer
1637 /
1638
1639 Appends items from the string, interpreting it as an array of machine values, as if it had been read from a file using the fromfile() method).
1640 [clinic start generated code]*/
1641
1642 static PyObject *
array_array_frombytes_impl(arrayobject * self,Py_buffer * buffer)1643 array_array_frombytes_impl(arrayobject *self, Py_buffer *buffer)
1644 /*[clinic end generated code: output=d9842c8f7510a516 input=2bbf2b53ebfcc988]*/
1645 {
1646 return frombytes(self, buffer);
1647 }
1648
1649 /*[clinic input]
1650 array.array.tobytes
1651
1652 Convert the array to an array of machine values and return the bytes representation.
1653 [clinic start generated code]*/
1654
1655 static PyObject *
array_array_tobytes_impl(arrayobject * self)1656 array_array_tobytes_impl(arrayobject *self)
1657 /*[clinic end generated code: output=87318e4edcdc2bb6 input=90ee495f96de34f5]*/
1658 {
1659 if (Py_SIZE(self) <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) {
1660 return PyBytes_FromStringAndSize(self->ob_item,
1661 Py_SIZE(self) * self->ob_descr->itemsize);
1662 } else {
1663 return PyErr_NoMemory();
1664 }
1665 }
1666
1667 /*[clinic input]
1668 array.array.fromunicode
1669
1670 ustr: unicode
1671 /
1672
1673 Extends this array with data from the unicode string ustr.
1674
1675 The array must be a unicode type array; otherwise a ValueError is raised.
1676 Use array.frombytes(ustr.encode(...)) to append Unicode data to an array of
1677 some other type.
1678 [clinic start generated code]*/
1679
1680 static PyObject *
array_array_fromunicode_impl(arrayobject * self,PyObject * ustr)1681 array_array_fromunicode_impl(arrayobject *self, PyObject *ustr)
1682 /*[clinic end generated code: output=24359f5e001a7f2b input=025db1fdade7a4ce]*/
1683 {
1684 if (self->ob_descr->typecode != 'u') {
1685 PyErr_SetString(PyExc_ValueError,
1686 "fromunicode() may only be called on "
1687 "unicode type arrays");
1688 return NULL;
1689 }
1690
1691 Py_ssize_t ustr_length = PyUnicode_AsWideChar(ustr, NULL, 0);
1692 assert(ustr_length > 0);
1693 if (ustr_length > 1) {
1694 ustr_length--; /* trim trailing NUL character */
1695 Py_ssize_t old_size = Py_SIZE(self);
1696 if (array_resize(self, old_size + ustr_length) == -1) {
1697 return NULL;
1698 }
1699
1700 // must not fail
1701 PyUnicode_AsWideChar(
1702 ustr, ((wchar_t *)self->ob_item) + old_size, ustr_length);
1703 }
1704
1705 Py_RETURN_NONE;
1706 }
1707
1708 /*[clinic input]
1709 array.array.tounicode
1710
1711 Extends this array with data from the unicode string ustr.
1712
1713 Convert the array to a unicode string. The array must be a unicode type array;
1714 otherwise a ValueError is raised. Use array.tobytes().decode() to obtain a
1715 unicode string from an array of some other type.
1716 [clinic start generated code]*/
1717
1718 static PyObject *
array_array_tounicode_impl(arrayobject * self)1719 array_array_tounicode_impl(arrayobject *self)
1720 /*[clinic end generated code: output=08e442378336e1ef input=127242eebe70b66d]*/
1721 {
1722 if (self->ob_descr->typecode != 'u') {
1723 PyErr_SetString(PyExc_ValueError,
1724 "tounicode() may only be called on unicode type arrays");
1725 return NULL;
1726 }
1727 return PyUnicode_FromWideChar((wchar_t *) self->ob_item, Py_SIZE(self));
1728 }
1729
1730 /*[clinic input]
1731 array.array.__sizeof__
1732
1733 Size of the array in memory, in bytes.
1734 [clinic start generated code]*/
1735
1736 static PyObject *
array_array___sizeof___impl(arrayobject * self)1737 array_array___sizeof___impl(arrayobject *self)
1738 /*[clinic end generated code: output=d8e1c61ebbe3eaed input=805586565bf2b3c6]*/
1739 {
1740 Py_ssize_t res;
1741 res = _PyObject_SIZE(Py_TYPE(self)) + self->allocated * self->ob_descr->itemsize;
1742 return PyLong_FromSsize_t(res);
1743 }
1744
1745
1746 /*********************** Pickling support ************************/
1747
1748 static const struct mformatdescr {
1749 size_t size;
1750 int is_signed;
1751 int is_big_endian;
1752 } mformat_descriptors[] = {
1753 {1, 0, 0}, /* 0: UNSIGNED_INT8 */
1754 {1, 1, 0}, /* 1: SIGNED_INT8 */
1755 {2, 0, 0}, /* 2: UNSIGNED_INT16_LE */
1756 {2, 0, 1}, /* 3: UNSIGNED_INT16_BE */
1757 {2, 1, 0}, /* 4: SIGNED_INT16_LE */
1758 {2, 1, 1}, /* 5: SIGNED_INT16_BE */
1759 {4, 0, 0}, /* 6: UNSIGNED_INT32_LE */
1760 {4, 0, 1}, /* 7: UNSIGNED_INT32_BE */
1761 {4, 1, 0}, /* 8: SIGNED_INT32_LE */
1762 {4, 1, 1}, /* 9: SIGNED_INT32_BE */
1763 {8, 0, 0}, /* 10: UNSIGNED_INT64_LE */
1764 {8, 0, 1}, /* 11: UNSIGNED_INT64_BE */
1765 {8, 1, 0}, /* 12: SIGNED_INT64_LE */
1766 {8, 1, 1}, /* 13: SIGNED_INT64_BE */
1767 {4, 0, 0}, /* 14: IEEE_754_FLOAT_LE */
1768 {4, 0, 1}, /* 15: IEEE_754_FLOAT_BE */
1769 {8, 0, 0}, /* 16: IEEE_754_DOUBLE_LE */
1770 {8, 0, 1}, /* 17: IEEE_754_DOUBLE_BE */
1771 {4, 0, 0}, /* 18: UTF16_LE */
1772 {4, 0, 1}, /* 19: UTF16_BE */
1773 {8, 0, 0}, /* 20: UTF32_LE */
1774 {8, 0, 1} /* 21: UTF32_BE */
1775 };
1776
1777
1778 /*
1779 * Internal: This function is used to find the machine format of a given
1780 * array type code. This returns UNKNOWN_FORMAT when the machine format cannot
1781 * be found.
1782 */
1783 static enum machine_format_code
typecode_to_mformat_code(char typecode)1784 typecode_to_mformat_code(char typecode)
1785 {
1786 const int is_big_endian = PY_BIG_ENDIAN;
1787
1788 size_t intsize;
1789 int is_signed;
1790
1791 switch (typecode) {
1792 case 'b':
1793 return SIGNED_INT8;
1794 case 'B':
1795 return UNSIGNED_INT8;
1796
1797 case 'u':
1798 if (sizeof(Py_UNICODE) == 2) {
1799 return UTF16_LE + is_big_endian;
1800 }
1801 if (sizeof(Py_UNICODE) == 4) {
1802 return UTF32_LE + is_big_endian;
1803 }
1804 return UNKNOWN_FORMAT;
1805
1806 case 'f':
1807 if (sizeof(float) == 4) {
1808 const float y = 16711938.0;
1809 if (memcmp(&y, "\x4b\x7f\x01\x02", 4) == 0)
1810 return IEEE_754_FLOAT_BE;
1811 if (memcmp(&y, "\x02\x01\x7f\x4b", 4) == 0)
1812 return IEEE_754_FLOAT_LE;
1813 }
1814 return UNKNOWN_FORMAT;
1815
1816 case 'd':
1817 if (sizeof(double) == 8) {
1818 const double x = 9006104071832581.0;
1819 if (memcmp(&x, "\x43\x3f\xff\x01\x02\x03\x04\x05", 8) == 0)
1820 return IEEE_754_DOUBLE_BE;
1821 if (memcmp(&x, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0)
1822 return IEEE_754_DOUBLE_LE;
1823 }
1824 return UNKNOWN_FORMAT;
1825
1826 /* Integers */
1827 case 'h':
1828 intsize = sizeof(short);
1829 is_signed = 1;
1830 break;
1831 case 'H':
1832 intsize = sizeof(short);
1833 is_signed = 0;
1834 break;
1835 case 'i':
1836 intsize = sizeof(int);
1837 is_signed = 1;
1838 break;
1839 case 'I':
1840 intsize = sizeof(int);
1841 is_signed = 0;
1842 break;
1843 case 'l':
1844 intsize = sizeof(long);
1845 is_signed = 1;
1846 break;
1847 case 'L':
1848 intsize = sizeof(long);
1849 is_signed = 0;
1850 break;
1851 case 'q':
1852 intsize = sizeof(long long);
1853 is_signed = 1;
1854 break;
1855 case 'Q':
1856 intsize = sizeof(long long);
1857 is_signed = 0;
1858 break;
1859 default:
1860 return UNKNOWN_FORMAT;
1861 }
1862 switch (intsize) {
1863 case 2:
1864 return UNSIGNED_INT16_LE + is_big_endian + (2 * is_signed);
1865 case 4:
1866 return UNSIGNED_INT32_LE + is_big_endian + (2 * is_signed);
1867 case 8:
1868 return UNSIGNED_INT64_LE + is_big_endian + (2 * is_signed);
1869 default:
1870 return UNKNOWN_FORMAT;
1871 }
1872 }
1873
1874 /* Forward declaration. */
1875 static PyObject *array_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
1876
1877 /*
1878 * Internal: This function wraps the array constructor--i.e., array_new()--to
1879 * allow the creation of array objects from C code without having to deal
1880 * directly the tuple argument of array_new(). The typecode argument is a
1881 * Unicode character value, like 'i' or 'f' for example, representing an array
1882 * type code. The items argument is a bytes or a list object from which
1883 * contains the initial value of the array.
1884 *
1885 * On success, this functions returns the array object created. Otherwise,
1886 * NULL is returned to indicate a failure.
1887 */
1888 static PyObject *
make_array(PyTypeObject * arraytype,char typecode,PyObject * items)1889 make_array(PyTypeObject *arraytype, char typecode, PyObject *items)
1890 {
1891 PyObject *new_args;
1892 PyObject *array_obj;
1893 PyObject *typecode_obj;
1894
1895 assert(arraytype != NULL);
1896 assert(items != NULL);
1897
1898 typecode_obj = PyUnicode_FromOrdinal(typecode);
1899 if (typecode_obj == NULL)
1900 return NULL;
1901
1902 new_args = PyTuple_New(2);
1903 if (new_args == NULL) {
1904 Py_DECREF(typecode_obj);
1905 return NULL;
1906 }
1907 Py_INCREF(items);
1908 PyTuple_SET_ITEM(new_args, 0, typecode_obj);
1909 PyTuple_SET_ITEM(new_args, 1, items);
1910
1911 array_obj = array_new(arraytype, new_args, NULL);
1912 Py_DECREF(new_args);
1913 if (array_obj == NULL)
1914 return NULL;
1915
1916 return array_obj;
1917 }
1918
1919 /*
1920 * This functions is a special constructor used when unpickling an array. It
1921 * provides a portable way to rebuild an array from its memory representation.
1922 */
1923 /*[clinic input]
1924 array._array_reconstructor
1925
1926 arraytype: object(type="PyTypeObject *")
1927 typecode: int(accept={str})
1928 mformat_code: int(type="enum machine_format_code")
1929 items: object
1930 /
1931
1932 Internal. Used for pickling support.
1933 [clinic start generated code]*/
1934
1935 static PyObject *
array__array_reconstructor_impl(PyObject * module,PyTypeObject * arraytype,int typecode,enum machine_format_code mformat_code,PyObject * items)1936 array__array_reconstructor_impl(PyObject *module, PyTypeObject *arraytype,
1937 int typecode,
1938 enum machine_format_code mformat_code,
1939 PyObject *items)
1940 /*[clinic end generated code: output=e05263141ba28365 input=2464dc8f4c7736b5]*/
1941 {
1942 PyObject *converted_items;
1943 PyObject *result;
1944 const struct arraydescr *descr;
1945
1946 if (!PyType_Check(arraytype)) {
1947 PyErr_Format(PyExc_TypeError,
1948 "first argument must be a type object, not %.200s",
1949 Py_TYPE(arraytype)->tp_name);
1950 return NULL;
1951 }
1952 if (!PyType_IsSubtype(arraytype, &Arraytype)) {
1953 PyErr_Format(PyExc_TypeError,
1954 "%.200s is not a subtype of %.200s",
1955 arraytype->tp_name, Arraytype.tp_name);
1956 return NULL;
1957 }
1958 for (descr = descriptors; descr->typecode != '\0'; descr++) {
1959 if ((int)descr->typecode == typecode)
1960 break;
1961 }
1962 if (descr->typecode == '\0') {
1963 PyErr_SetString(PyExc_ValueError,
1964 "second argument must be a valid type code");
1965 return NULL;
1966 }
1967 if (mformat_code < MACHINE_FORMAT_CODE_MIN ||
1968 mformat_code > MACHINE_FORMAT_CODE_MAX) {
1969 PyErr_SetString(PyExc_ValueError,
1970 "third argument must be a valid machine format code.");
1971 return NULL;
1972 }
1973 if (!PyBytes_Check(items)) {
1974 PyErr_Format(PyExc_TypeError,
1975 "fourth argument should be bytes, not %.200s",
1976 Py_TYPE(items)->tp_name);
1977 return NULL;
1978 }
1979
1980 /* Fast path: No decoding has to be done. */
1981 if (mformat_code == typecode_to_mformat_code((char)typecode) ||
1982 mformat_code == UNKNOWN_FORMAT) {
1983 return make_array(arraytype, (char)typecode, items);
1984 }
1985
1986 /* Slow path: Decode the byte string according to the given machine
1987 * format code. This occurs when the computer unpickling the array
1988 * object is architecturally different from the one that pickled the
1989 * array.
1990 */
1991 if (Py_SIZE(items) % mformat_descriptors[mformat_code].size != 0) {
1992 PyErr_SetString(PyExc_ValueError,
1993 "string length not a multiple of item size");
1994 return NULL;
1995 }
1996 switch (mformat_code) {
1997 case IEEE_754_FLOAT_LE:
1998 case IEEE_754_FLOAT_BE: {
1999 Py_ssize_t i;
2000 int le = (mformat_code == IEEE_754_FLOAT_LE) ? 1 : 0;
2001 Py_ssize_t itemcount = Py_SIZE(items) / 4;
2002 const unsigned char *memstr =
2003 (unsigned char *)PyBytes_AS_STRING(items);
2004
2005 converted_items = PyList_New(itemcount);
2006 if (converted_items == NULL)
2007 return NULL;
2008 for (i = 0; i < itemcount; i++) {
2009 PyObject *pyfloat = PyFloat_FromDouble(
2010 _PyFloat_Unpack4(&memstr[i * 4], le));
2011 if (pyfloat == NULL) {
2012 Py_DECREF(converted_items);
2013 return NULL;
2014 }
2015 PyList_SET_ITEM(converted_items, i, pyfloat);
2016 }
2017 break;
2018 }
2019 case IEEE_754_DOUBLE_LE:
2020 case IEEE_754_DOUBLE_BE: {
2021 Py_ssize_t i;
2022 int le = (mformat_code == IEEE_754_DOUBLE_LE) ? 1 : 0;
2023 Py_ssize_t itemcount = Py_SIZE(items) / 8;
2024 const unsigned char *memstr =
2025 (unsigned char *)PyBytes_AS_STRING(items);
2026
2027 converted_items = PyList_New(itemcount);
2028 if (converted_items == NULL)
2029 return NULL;
2030 for (i = 0; i < itemcount; i++) {
2031 PyObject *pyfloat = PyFloat_FromDouble(
2032 _PyFloat_Unpack8(&memstr[i * 8], le));
2033 if (pyfloat == NULL) {
2034 Py_DECREF(converted_items);
2035 return NULL;
2036 }
2037 PyList_SET_ITEM(converted_items, i, pyfloat);
2038 }
2039 break;
2040 }
2041 case UTF16_LE:
2042 case UTF16_BE: {
2043 int byteorder = (mformat_code == UTF16_LE) ? -1 : 1;
2044 converted_items = PyUnicode_DecodeUTF16(
2045 PyBytes_AS_STRING(items), Py_SIZE(items),
2046 "strict", &byteorder);
2047 if (converted_items == NULL)
2048 return NULL;
2049 break;
2050 }
2051 case UTF32_LE:
2052 case UTF32_BE: {
2053 int byteorder = (mformat_code == UTF32_LE) ? -1 : 1;
2054 converted_items = PyUnicode_DecodeUTF32(
2055 PyBytes_AS_STRING(items), Py_SIZE(items),
2056 "strict", &byteorder);
2057 if (converted_items == NULL)
2058 return NULL;
2059 break;
2060 }
2061
2062 case UNSIGNED_INT8:
2063 case SIGNED_INT8:
2064 case UNSIGNED_INT16_LE:
2065 case UNSIGNED_INT16_BE:
2066 case SIGNED_INT16_LE:
2067 case SIGNED_INT16_BE:
2068 case UNSIGNED_INT32_LE:
2069 case UNSIGNED_INT32_BE:
2070 case SIGNED_INT32_LE:
2071 case SIGNED_INT32_BE:
2072 case UNSIGNED_INT64_LE:
2073 case UNSIGNED_INT64_BE:
2074 case SIGNED_INT64_LE:
2075 case SIGNED_INT64_BE: {
2076 Py_ssize_t i;
2077 const struct mformatdescr mf_descr =
2078 mformat_descriptors[mformat_code];
2079 Py_ssize_t itemcount = Py_SIZE(items) / mf_descr.size;
2080 const unsigned char *memstr =
2081 (unsigned char *)PyBytes_AS_STRING(items);
2082 const struct arraydescr *descr;
2083
2084 /* If possible, try to pack array's items using a data type
2085 * that fits better. This may result in an array with narrower
2086 * or wider elements.
2087 *
2088 * For example, if a 32-bit machine pickles an L-code array of
2089 * unsigned longs, then the array will be unpickled by 64-bit
2090 * machine as an I-code array of unsigned ints.
2091 *
2092 * XXX: Is it possible to write a unit test for this?
2093 */
2094 for (descr = descriptors; descr->typecode != '\0'; descr++) {
2095 if (descr->is_integer_type &&
2096 (size_t)descr->itemsize == mf_descr.size &&
2097 descr->is_signed == mf_descr.is_signed)
2098 typecode = descr->typecode;
2099 }
2100
2101 converted_items = PyList_New(itemcount);
2102 if (converted_items == NULL)
2103 return NULL;
2104 for (i = 0; i < itemcount; i++) {
2105 PyObject *pylong;
2106
2107 pylong = _PyLong_FromByteArray(
2108 &memstr[i * mf_descr.size],
2109 mf_descr.size,
2110 !mf_descr.is_big_endian,
2111 mf_descr.is_signed);
2112 if (pylong == NULL) {
2113 Py_DECREF(converted_items);
2114 return NULL;
2115 }
2116 PyList_SET_ITEM(converted_items, i, pylong);
2117 }
2118 break;
2119 }
2120 case UNKNOWN_FORMAT:
2121 /* Impossible, but needed to shut up GCC about the unhandled
2122 * enumeration value.
2123 */
2124 default:
2125 PyErr_BadArgument();
2126 return NULL;
2127 }
2128
2129 result = make_array(arraytype, (char)typecode, converted_items);
2130 Py_DECREF(converted_items);
2131 return result;
2132 }
2133
2134 /*[clinic input]
2135 array.array.__reduce_ex__
2136
2137 value: object
2138 /
2139
2140 Return state information for pickling.
2141 [clinic start generated code]*/
2142
2143 static PyObject *
array_array___reduce_ex__(arrayobject * self,PyObject * value)2144 array_array___reduce_ex__(arrayobject *self, PyObject *value)
2145 /*[clinic end generated code: output=051e0a6175d0eddb input=c36c3f85de7df6cd]*/
2146 {
2147 PyObject *dict;
2148 PyObject *result;
2149 PyObject *array_str;
2150 int typecode = self->ob_descr->typecode;
2151 int mformat_code;
2152 static PyObject *array_reconstructor = NULL;
2153 long protocol;
2154 _Py_IDENTIFIER(_array_reconstructor);
2155 _Py_IDENTIFIER(__dict__);
2156
2157 if (array_reconstructor == NULL) {
2158 PyObject *array_module = PyImport_ImportModule("array");
2159 if (array_module == NULL)
2160 return NULL;
2161 array_reconstructor = _PyObject_GetAttrId(
2162 array_module,
2163 &PyId__array_reconstructor);
2164 Py_DECREF(array_module);
2165 if (array_reconstructor == NULL)
2166 return NULL;
2167 }
2168
2169 if (!PyLong_Check(value)) {
2170 PyErr_SetString(PyExc_TypeError,
2171 "__reduce_ex__ argument should be an integer");
2172 return NULL;
2173 }
2174 protocol = PyLong_AsLong(value);
2175 if (protocol == -1 && PyErr_Occurred())
2176 return NULL;
2177
2178 if (_PyObject_LookupAttrId((PyObject *)self, &PyId___dict__, &dict) < 0) {
2179 return NULL;
2180 }
2181 if (dict == NULL) {
2182 dict = Py_None;
2183 Py_INCREF(dict);
2184 }
2185
2186 mformat_code = typecode_to_mformat_code(typecode);
2187 if (mformat_code == UNKNOWN_FORMAT || protocol < 3) {
2188 /* Convert the array to a list if we got something weird
2189 * (e.g., non-IEEE floats), or we are pickling the array using
2190 * a Python 2.x compatible protocol.
2191 *
2192 * It is necessary to use a list representation for Python 2.x
2193 * compatible pickle protocol, since Python 2's str objects
2194 * are unpickled as unicode by Python 3. Thus it is impossible
2195 * to make arrays unpicklable by Python 3 by using their memory
2196 * representation, unless we resort to ugly hacks such as
2197 * coercing unicode objects to bytes in array_reconstructor.
2198 */
2199 PyObject *list;
2200 list = array_array_tolist_impl(self);
2201 if (list == NULL) {
2202 Py_DECREF(dict);
2203 return NULL;
2204 }
2205 result = Py_BuildValue(
2206 "O(CO)O", Py_TYPE(self), typecode, list, dict);
2207 Py_DECREF(list);
2208 Py_DECREF(dict);
2209 return result;
2210 }
2211
2212 array_str = array_array_tobytes_impl(self);
2213 if (array_str == NULL) {
2214 Py_DECREF(dict);
2215 return NULL;
2216 }
2217 result = Py_BuildValue(
2218 "O(OCiN)O", array_reconstructor, Py_TYPE(self), typecode,
2219 mformat_code, array_str, dict);
2220 Py_DECREF(dict);
2221 return result;
2222 }
2223
2224 static PyObject *
array_get_typecode(arrayobject * a,void * closure)2225 array_get_typecode(arrayobject *a, void *closure)
2226 {
2227 char typecode = a->ob_descr->typecode;
2228 return PyUnicode_FromOrdinal(typecode);
2229 }
2230
2231 static PyObject *
array_get_itemsize(arrayobject * a,void * closure)2232 array_get_itemsize(arrayobject *a, void *closure)
2233 {
2234 return PyLong_FromLong((long)a->ob_descr->itemsize);
2235 }
2236
2237 static PyGetSetDef array_getsets [] = {
2238 {"typecode", (getter) array_get_typecode, NULL,
2239 "the typecode character used to create the array"},
2240 {"itemsize", (getter) array_get_itemsize, NULL,
2241 "the size, in bytes, of one array item"},
2242 {NULL}
2243 };
2244
2245 static PyMethodDef array_methods[] = {
2246 ARRAY_ARRAY_APPEND_METHODDEF
2247 ARRAY_ARRAY_BUFFER_INFO_METHODDEF
2248 ARRAY_ARRAY_BYTESWAP_METHODDEF
2249 ARRAY_ARRAY___COPY___METHODDEF
2250 ARRAY_ARRAY_COUNT_METHODDEF
2251 ARRAY_ARRAY___DEEPCOPY___METHODDEF
2252 ARRAY_ARRAY_EXTEND_METHODDEF
2253 ARRAY_ARRAY_FROMFILE_METHODDEF
2254 ARRAY_ARRAY_FROMLIST_METHODDEF
2255 ARRAY_ARRAY_FROMBYTES_METHODDEF
2256 ARRAY_ARRAY_FROMUNICODE_METHODDEF
2257 ARRAY_ARRAY_INDEX_METHODDEF
2258 ARRAY_ARRAY_INSERT_METHODDEF
2259 ARRAY_ARRAY_POP_METHODDEF
2260 ARRAY_ARRAY___REDUCE_EX___METHODDEF
2261 ARRAY_ARRAY_REMOVE_METHODDEF
2262 ARRAY_ARRAY_REVERSE_METHODDEF
2263 ARRAY_ARRAY_TOFILE_METHODDEF
2264 ARRAY_ARRAY_TOLIST_METHODDEF
2265 ARRAY_ARRAY_TOBYTES_METHODDEF
2266 ARRAY_ARRAY_TOUNICODE_METHODDEF
2267 ARRAY_ARRAY___SIZEOF___METHODDEF
2268 {NULL, NULL} /* sentinel */
2269 };
2270
2271 static PyObject *
array_repr(arrayobject * a)2272 array_repr(arrayobject *a)
2273 {
2274 char typecode;
2275 PyObject *s, *v = NULL;
2276 Py_ssize_t len;
2277
2278 len = Py_SIZE(a);
2279 typecode = a->ob_descr->typecode;
2280 if (len == 0) {
2281 return PyUnicode_FromFormat("%s('%c')",
2282 _PyType_Name(Py_TYPE(a)), (int)typecode);
2283 }
2284 if (typecode == 'u') {
2285 v = array_array_tounicode_impl(a);
2286 } else {
2287 v = array_array_tolist_impl(a);
2288 }
2289 if (v == NULL)
2290 return NULL;
2291
2292 s = PyUnicode_FromFormat("%s('%c', %R)",
2293 _PyType_Name(Py_TYPE(a)), (int)typecode, v);
2294 Py_DECREF(v);
2295 return s;
2296 }
2297
2298 static PyObject*
array_subscr(arrayobject * self,PyObject * item)2299 array_subscr(arrayobject* self, PyObject* item)
2300 {
2301 if (PyIndex_Check(item)) {
2302 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
2303 if (i==-1 && PyErr_Occurred()) {
2304 return NULL;
2305 }
2306 if (i < 0)
2307 i += Py_SIZE(self);
2308 return array_item(self, i);
2309 }
2310 else if (PySlice_Check(item)) {
2311 Py_ssize_t start, stop, step, slicelength, i;
2312 size_t cur;
2313 PyObject* result;
2314 arrayobject* ar;
2315 int itemsize = self->ob_descr->itemsize;
2316
2317 if (PySlice_Unpack(item, &start, &stop, &step) < 0) {
2318 return NULL;
2319 }
2320 slicelength = PySlice_AdjustIndices(Py_SIZE(self), &start, &stop,
2321 step);
2322
2323 if (slicelength <= 0) {
2324 return newarrayobject(&Arraytype, 0, self->ob_descr);
2325 }
2326 else if (step == 1) {
2327 PyObject *result = newarrayobject(&Arraytype,
2328 slicelength, self->ob_descr);
2329 if (result == NULL)
2330 return NULL;
2331 memcpy(((arrayobject *)result)->ob_item,
2332 self->ob_item + start * itemsize,
2333 slicelength * itemsize);
2334 return result;
2335 }
2336 else {
2337 result = newarrayobject(&Arraytype, slicelength, self->ob_descr);
2338 if (!result) return NULL;
2339
2340 ar = (arrayobject*)result;
2341
2342 for (cur = start, i = 0; i < slicelength;
2343 cur += step, i++) {
2344 memcpy(ar->ob_item + i*itemsize,
2345 self->ob_item + cur*itemsize,
2346 itemsize);
2347 }
2348
2349 return result;
2350 }
2351 }
2352 else {
2353 PyErr_SetString(PyExc_TypeError,
2354 "array indices must be integers");
2355 return NULL;
2356 }
2357 }
2358
2359 static int
array_ass_subscr(arrayobject * self,PyObject * item,PyObject * value)2360 array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
2361 {
2362 Py_ssize_t start, stop, step, slicelength, needed;
2363 arrayobject* other;
2364 int itemsize;
2365
2366 if (PyIndex_Check(item)) {
2367 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
2368
2369 if (i == -1 && PyErr_Occurred())
2370 return -1;
2371 if (i < 0)
2372 i += Py_SIZE(self);
2373 if (i < 0 || i >= Py_SIZE(self)) {
2374 PyErr_SetString(PyExc_IndexError,
2375 "array assignment index out of range");
2376 return -1;
2377 }
2378 if (value == NULL) {
2379 /* Fall through to slice assignment */
2380 start = i;
2381 stop = i + 1;
2382 step = 1;
2383 slicelength = 1;
2384 }
2385 else
2386 return (*self->ob_descr->setitem)(self, i, value);
2387 }
2388 else if (PySlice_Check(item)) {
2389 if (PySlice_Unpack(item, &start, &stop, &step) < 0) {
2390 return -1;
2391 }
2392 slicelength = PySlice_AdjustIndices(Py_SIZE(self), &start, &stop,
2393 step);
2394 }
2395 else {
2396 PyErr_SetString(PyExc_TypeError,
2397 "array indices must be integers");
2398 return -1;
2399 }
2400 if (value == NULL) {
2401 other = NULL;
2402 needed = 0;
2403 }
2404 else if (array_Check(value)) {
2405 other = (arrayobject *)value;
2406 needed = Py_SIZE(other);
2407 if (self == other) {
2408 /* Special case "self[i:j] = self" -- copy self first */
2409 int ret;
2410 value = array_slice(other, 0, needed);
2411 if (value == NULL)
2412 return -1;
2413 ret = array_ass_subscr(self, item, value);
2414 Py_DECREF(value);
2415 return ret;
2416 }
2417 if (other->ob_descr != self->ob_descr) {
2418 PyErr_BadArgument();
2419 return -1;
2420 }
2421 }
2422 else {
2423 PyErr_Format(PyExc_TypeError,
2424 "can only assign array (not \"%.200s\") to array slice",
2425 Py_TYPE(value)->tp_name);
2426 return -1;
2427 }
2428 itemsize = self->ob_descr->itemsize;
2429 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
2430 if ((step > 0 && stop < start) ||
2431 (step < 0 && stop > start))
2432 stop = start;
2433
2434 /* Issue #4509: If the array has exported buffers and the slice
2435 assignment would change the size of the array, fail early to make
2436 sure we don't modify it. */
2437 if ((needed == 0 || slicelength != needed) && self->ob_exports > 0) {
2438 PyErr_SetString(PyExc_BufferError,
2439 "cannot resize an array that is exporting buffers");
2440 return -1;
2441 }
2442
2443 if (step == 1) {
2444 if (slicelength > needed) {
2445 memmove(self->ob_item + (start + needed) * itemsize,
2446 self->ob_item + stop * itemsize,
2447 (Py_SIZE(self) - stop) * itemsize);
2448 if (array_resize(self, Py_SIZE(self) +
2449 needed - slicelength) < 0)
2450 return -1;
2451 }
2452 else if (slicelength < needed) {
2453 if (array_resize(self, Py_SIZE(self) +
2454 needed - slicelength) < 0)
2455 return -1;
2456 memmove(self->ob_item + (start + needed) * itemsize,
2457 self->ob_item + stop * itemsize,
2458 (Py_SIZE(self) - start - needed) * itemsize);
2459 }
2460 if (needed > 0)
2461 memcpy(self->ob_item + start * itemsize,
2462 other->ob_item, needed * itemsize);
2463 return 0;
2464 }
2465 else if (needed == 0) {
2466 /* Delete slice */
2467 size_t cur;
2468 Py_ssize_t i;
2469
2470 if (step < 0) {
2471 stop = start + 1;
2472 start = stop + step * (slicelength - 1) - 1;
2473 step = -step;
2474 }
2475 for (cur = start, i = 0; i < slicelength;
2476 cur += step, i++) {
2477 Py_ssize_t lim = step - 1;
2478
2479 if (cur + step >= (size_t)Py_SIZE(self))
2480 lim = Py_SIZE(self) - cur - 1;
2481 memmove(self->ob_item + (cur - i) * itemsize,
2482 self->ob_item + (cur + 1) * itemsize,
2483 lim * itemsize);
2484 }
2485 cur = start + (size_t)slicelength * step;
2486 if (cur < (size_t)Py_SIZE(self)) {
2487 memmove(self->ob_item + (cur-slicelength) * itemsize,
2488 self->ob_item + cur * itemsize,
2489 (Py_SIZE(self) - cur) * itemsize);
2490 }
2491 if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
2492 return -1;
2493 return 0;
2494 }
2495 else {
2496 size_t cur;
2497 Py_ssize_t i;
2498
2499 if (needed != slicelength) {
2500 PyErr_Format(PyExc_ValueError,
2501 "attempt to assign array of size %zd "
2502 "to extended slice of size %zd",
2503 needed, slicelength);
2504 return -1;
2505 }
2506 for (cur = start, i = 0; i < slicelength;
2507 cur += step, i++) {
2508 memcpy(self->ob_item + cur * itemsize,
2509 other->ob_item + i * itemsize,
2510 itemsize);
2511 }
2512 return 0;
2513 }
2514 }
2515
2516 static PyMappingMethods array_as_mapping = {
2517 (lenfunc)array_length,
2518 (binaryfunc)array_subscr,
2519 (objobjargproc)array_ass_subscr
2520 };
2521
2522 static const void *emptybuf = "";
2523
2524
2525 static int
array_buffer_getbuf(arrayobject * self,Py_buffer * view,int flags)2526 array_buffer_getbuf(arrayobject *self, Py_buffer *view, int flags)
2527 {
2528 if (view == NULL) {
2529 PyErr_SetString(PyExc_BufferError,
2530 "array_buffer_getbuf: view==NULL argument is obsolete");
2531 return -1;
2532 }
2533
2534 view->buf = (void *)self->ob_item;
2535 view->obj = (PyObject*)self;
2536 Py_INCREF(self);
2537 if (view->buf == NULL)
2538 view->buf = (void *)emptybuf;
2539 view->len = (Py_SIZE(self)) * self->ob_descr->itemsize;
2540 view->readonly = 0;
2541 view->ndim = 1;
2542 view->itemsize = self->ob_descr->itemsize;
2543 view->suboffsets = NULL;
2544 view->shape = NULL;
2545 if ((flags & PyBUF_ND)==PyBUF_ND) {
2546 view->shape = &((Py_SIZE(self)));
2547 }
2548 view->strides = NULL;
2549 if ((flags & PyBUF_STRIDES)==PyBUF_STRIDES)
2550 view->strides = &(view->itemsize);
2551 view->format = NULL;
2552 view->internal = NULL;
2553 if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) {
2554 view->format = (char *)self->ob_descr->formats;
2555 #ifdef Py_UNICODE_WIDE
2556 if (self->ob_descr->typecode == 'u') {
2557 view->format = "w";
2558 }
2559 #endif
2560 }
2561
2562 self->ob_exports++;
2563 return 0;
2564 }
2565
2566 static void
array_buffer_relbuf(arrayobject * self,Py_buffer * view)2567 array_buffer_relbuf(arrayobject *self, Py_buffer *view)
2568 {
2569 self->ob_exports--;
2570 }
2571
2572 static PySequenceMethods array_as_sequence = {
2573 (lenfunc)array_length, /*sq_length*/
2574 (binaryfunc)array_concat, /*sq_concat*/
2575 (ssizeargfunc)array_repeat, /*sq_repeat*/
2576 (ssizeargfunc)array_item, /*sq_item*/
2577 0, /*sq_slice*/
2578 (ssizeobjargproc)array_ass_item, /*sq_ass_item*/
2579 0, /*sq_ass_slice*/
2580 (objobjproc)array_contains, /*sq_contains*/
2581 (binaryfunc)array_inplace_concat, /*sq_inplace_concat*/
2582 (ssizeargfunc)array_inplace_repeat /*sq_inplace_repeat*/
2583 };
2584
2585 static PyBufferProcs array_as_buffer = {
2586 (getbufferproc)array_buffer_getbuf,
2587 (releasebufferproc)array_buffer_relbuf
2588 };
2589
2590 static PyObject *
array_new(PyTypeObject * type,PyObject * args,PyObject * kwds)2591 array_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
2592 {
2593 int c;
2594 PyObject *initial = NULL, *it = NULL;
2595 const struct arraydescr *descr;
2596
2597 if (type == &Arraytype && !_PyArg_NoKeywords("array.array", kwds))
2598 return NULL;
2599
2600 if (!PyArg_ParseTuple(args, "C|O:array", &c, &initial))
2601 return NULL;
2602
2603 if (PySys_Audit("array.__new__", "CO",
2604 c, initial ? initial : Py_None) < 0) {
2605 return NULL;
2606 }
2607
2608 if (initial && c != 'u') {
2609 if (PyUnicode_Check(initial)) {
2610 PyErr_Format(PyExc_TypeError, "cannot use a str to initialize "
2611 "an array with typecode '%c'", c);
2612 return NULL;
2613 }
2614 else if (array_Check(initial) &&
2615 ((arrayobject*)initial)->ob_descr->typecode == 'u') {
2616 PyErr_Format(PyExc_TypeError, "cannot use a unicode array to "
2617 "initialize an array with typecode '%c'", c);
2618 return NULL;
2619 }
2620 }
2621
2622 if (!(initial == NULL || PyList_Check(initial)
2623 || PyByteArray_Check(initial)
2624 || PyBytes_Check(initial)
2625 || PyTuple_Check(initial)
2626 || ((c=='u') && PyUnicode_Check(initial))
2627 || (array_Check(initial)
2628 && c == ((arrayobject*)initial)->ob_descr->typecode))) {
2629 it = PyObject_GetIter(initial);
2630 if (it == NULL)
2631 return NULL;
2632 /* We set initial to NULL so that the subsequent code
2633 will create an empty array of the appropriate type
2634 and afterwards we can use array_iter_extend to populate
2635 the array.
2636 */
2637 initial = NULL;
2638 }
2639 for (descr = descriptors; descr->typecode != '\0'; descr++) {
2640 if (descr->typecode == c) {
2641 PyObject *a;
2642 Py_ssize_t len;
2643
2644 if (initial == NULL)
2645 len = 0;
2646 else if (PyList_Check(initial))
2647 len = PyList_GET_SIZE(initial);
2648 else if (PyTuple_Check(initial) || array_Check(initial))
2649 len = Py_SIZE(initial);
2650 else
2651 len = 0;
2652
2653 a = newarrayobject(type, len, descr);
2654 if (a == NULL)
2655 return NULL;
2656
2657 if (len > 0 && !array_Check(initial)) {
2658 Py_ssize_t i;
2659 for (i = 0; i < len; i++) {
2660 PyObject *v =
2661 PySequence_GetItem(initial, i);
2662 if (v == NULL) {
2663 Py_DECREF(a);
2664 return NULL;
2665 }
2666 if (setarrayitem(a, i, v) != 0) {
2667 Py_DECREF(v);
2668 Py_DECREF(a);
2669 return NULL;
2670 }
2671 Py_DECREF(v);
2672 }
2673 }
2674 else if (initial != NULL && (PyByteArray_Check(initial) ||
2675 PyBytes_Check(initial))) {
2676 PyObject *v;
2677 v = array_array_frombytes((arrayobject *)a,
2678 initial);
2679 if (v == NULL) {
2680 Py_DECREF(a);
2681 return NULL;
2682 }
2683 Py_DECREF(v);
2684 }
2685 else if (initial != NULL && PyUnicode_Check(initial)) {
2686 Py_ssize_t n;
2687 wchar_t *ustr = PyUnicode_AsWideCharString(initial, &n);
2688 if (ustr == NULL) {
2689 Py_DECREF(a);
2690 return NULL;
2691 }
2692
2693 if (n > 0) {
2694 arrayobject *self = (arrayobject *)a;
2695 // self->ob_item may be NULL but it is safe.
2696 PyMem_Free(self->ob_item);
2697 self->ob_item = (char *)ustr;
2698 Py_SET_SIZE(self, n);
2699 self->allocated = n;
2700 }
2701 }
2702 else if (initial != NULL && array_Check(initial) && len > 0) {
2703 arrayobject *self = (arrayobject *)a;
2704 arrayobject *other = (arrayobject *)initial;
2705 memcpy(self->ob_item, other->ob_item, len * other->ob_descr->itemsize);
2706 }
2707 if (it != NULL) {
2708 if (array_iter_extend((arrayobject *)a, it) == -1) {
2709 Py_DECREF(it);
2710 Py_DECREF(a);
2711 return NULL;
2712 }
2713 Py_DECREF(it);
2714 }
2715 return a;
2716 }
2717 }
2718 PyErr_SetString(PyExc_ValueError,
2719 "bad typecode (must be b, B, u, h, H, i, I, l, L, q, Q, f or d)");
2720 return NULL;
2721 }
2722
2723
2724 PyDoc_STRVAR(module_doc,
2725 "This module defines an object type which can efficiently represent\n\
2726 an array of basic values: characters, integers, floating point\n\
2727 numbers. Arrays are sequence types and behave very much like lists,\n\
2728 except that the type of objects stored in them is constrained.\n");
2729
2730 PyDoc_STRVAR(arraytype_doc,
2731 "array(typecode [, initializer]) -> array\n\
2732 \n\
2733 Return a new array whose items are restricted by typecode, and\n\
2734 initialized from the optional initializer value, which must be a list,\n\
2735 string or iterable over elements of the appropriate type.\n\
2736 \n\
2737 Arrays represent basic values and behave very much like lists, except\n\
2738 the type of objects stored in them is constrained. The type is specified\n\
2739 at object creation time by using a type code, which is a single character.\n\
2740 The following type codes are defined:\n\
2741 \n\
2742 Type code C Type Minimum size in bytes\n\
2743 'b' signed integer 1\n\
2744 'B' unsigned integer 1\n\
2745 'u' Unicode character 2 (see note)\n\
2746 'h' signed integer 2\n\
2747 'H' unsigned integer 2\n\
2748 'i' signed integer 2\n\
2749 'I' unsigned integer 2\n\
2750 'l' signed integer 4\n\
2751 'L' unsigned integer 4\n\
2752 'q' signed integer 8 (see note)\n\
2753 'Q' unsigned integer 8 (see note)\n\
2754 'f' floating point 4\n\
2755 'd' floating point 8\n\
2756 \n\
2757 NOTE: The 'u' typecode corresponds to Python's unicode character. On\n\
2758 narrow builds this is 2-bytes on wide builds this is 4-bytes.\n\
2759 \n\
2760 NOTE: The 'q' and 'Q' type codes are only available if the platform\n\
2761 C compiler used to build Python supports 'long long', or, on Windows,\n\
2762 '__int64'.\n\
2763 \n\
2764 Methods:\n\
2765 \n\
2766 append() -- append a new item to the end of the array\n\
2767 buffer_info() -- return information giving the current memory info\n\
2768 byteswap() -- byteswap all the items of the array\n\
2769 count() -- return number of occurrences of an object\n\
2770 extend() -- extend array by appending multiple elements from an iterable\n\
2771 fromfile() -- read items from a file object\n\
2772 fromlist() -- append items from the list\n\
2773 frombytes() -- append items from the string\n\
2774 index() -- return index of first occurrence of an object\n\
2775 insert() -- insert a new item into the array at a provided position\n\
2776 pop() -- remove and return item (default last)\n\
2777 remove() -- remove first occurrence of an object\n\
2778 reverse() -- reverse the order of the items in the array\n\
2779 tofile() -- write all items to a file object\n\
2780 tolist() -- return the array converted to an ordinary list\n\
2781 tobytes() -- return the array converted to a string\n\
2782 \n\
2783 Attributes:\n\
2784 \n\
2785 typecode -- the typecode character used to create the array\n\
2786 itemsize -- the length in bytes of one array item\n\
2787 ");
2788
2789 static PyObject *array_iter(arrayobject *ao);
2790
2791 static PyTypeObject Arraytype = {
2792 PyVarObject_HEAD_INIT(NULL, 0)
2793 "array.array",
2794 sizeof(arrayobject),
2795 0,
2796 (destructor)array_dealloc, /* tp_dealloc */
2797 0, /* tp_vectorcall_offset */
2798 0, /* tp_getattr */
2799 0, /* tp_setattr */
2800 0, /* tp_as_async */
2801 (reprfunc)array_repr, /* tp_repr */
2802 0, /* tp_as_number*/
2803 &array_as_sequence, /* tp_as_sequence*/
2804 &array_as_mapping, /* tp_as_mapping*/
2805 0, /* tp_hash */
2806 0, /* tp_call */
2807 0, /* tp_str */
2808 PyObject_GenericGetAttr, /* tp_getattro */
2809 0, /* tp_setattro */
2810 &array_as_buffer, /* tp_as_buffer*/
2811 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
2812 arraytype_doc, /* tp_doc */
2813 0, /* tp_traverse */
2814 0, /* tp_clear */
2815 array_richcompare, /* tp_richcompare */
2816 offsetof(arrayobject, weakreflist), /* tp_weaklistoffset */
2817 (getiterfunc)array_iter, /* tp_iter */
2818 0, /* tp_iternext */
2819 array_methods, /* tp_methods */
2820 0, /* tp_members */
2821 array_getsets, /* tp_getset */
2822 0, /* tp_base */
2823 0, /* tp_dict */
2824 0, /* tp_descr_get */
2825 0, /* tp_descr_set */
2826 0, /* tp_dictoffset */
2827 0, /* tp_init */
2828 PyType_GenericAlloc, /* tp_alloc */
2829 array_new, /* tp_new */
2830 PyObject_Del, /* tp_free */
2831 };
2832
2833
2834 /*********************** Array Iterator **************************/
2835
2836 /*[clinic input]
2837 class array.arrayiterator "arrayiterobject *" "&PyArrayIter_Type"
2838 [clinic start generated code]*/
2839 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=5aefd2d74d8c8e30]*/
2840
2841 static PyObject *
array_iter(arrayobject * ao)2842 array_iter(arrayobject *ao)
2843 {
2844 arrayiterobject *it;
2845
2846 if (!array_Check(ao)) {
2847 PyErr_BadInternalCall();
2848 return NULL;
2849 }
2850
2851 it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type);
2852 if (it == NULL)
2853 return NULL;
2854
2855 Py_INCREF(ao);
2856 it->ao = ao;
2857 it->index = 0;
2858 it->getitem = ao->ob_descr->getitem;
2859 PyObject_GC_Track(it);
2860 return (PyObject *)it;
2861 }
2862
2863 static PyObject *
arrayiter_next(arrayiterobject * it)2864 arrayiter_next(arrayiterobject *it)
2865 {
2866 arrayobject *ao;
2867
2868 assert(it != NULL);
2869 assert(PyArrayIter_Check(it));
2870 ao = it->ao;
2871 if (ao == NULL) {
2872 return NULL;
2873 }
2874 assert(array_Check(ao));
2875 if (it->index < Py_SIZE(ao)) {
2876 return (*it->getitem)(ao, it->index++);
2877 }
2878 it->ao = NULL;
2879 Py_DECREF(ao);
2880 return NULL;
2881 }
2882
2883 static void
arrayiter_dealloc(arrayiterobject * it)2884 arrayiter_dealloc(arrayiterobject *it)
2885 {
2886 PyObject_GC_UnTrack(it);
2887 Py_XDECREF(it->ao);
2888 PyObject_GC_Del(it);
2889 }
2890
2891 static int
arrayiter_traverse(arrayiterobject * it,visitproc visit,void * arg)2892 arrayiter_traverse(arrayiterobject *it, visitproc visit, void *arg)
2893 {
2894 Py_VISIT(it->ao);
2895 return 0;
2896 }
2897
2898 /*[clinic input]
2899 array.arrayiterator.__reduce__
2900
2901 Return state information for pickling.
2902 [clinic start generated code]*/
2903
2904 static PyObject *
array_arrayiterator___reduce___impl(arrayiterobject * self)2905 array_arrayiterator___reduce___impl(arrayiterobject *self)
2906 /*[clinic end generated code: output=7898a52e8e66e016 input=a062ea1e9951417a]*/
2907 {
2908 _Py_IDENTIFIER(iter);
2909 PyObject *func = _PyEval_GetBuiltinId(&PyId_iter);
2910 if (self->ao == NULL) {
2911 return Py_BuildValue("N(())", func);
2912 }
2913 return Py_BuildValue("N(O)n", func, self->ao, self->index);
2914 }
2915
2916 /*[clinic input]
2917 array.arrayiterator.__setstate__
2918
2919 state: object
2920 /
2921
2922 Set state information for unpickling.
2923 [clinic start generated code]*/
2924
2925 static PyObject *
array_arrayiterator___setstate__(arrayiterobject * self,PyObject * state)2926 array_arrayiterator___setstate__(arrayiterobject *self, PyObject *state)
2927 /*[clinic end generated code: output=397da9904e443cbe input=f47d5ceda19e787b]*/
2928 {
2929 Py_ssize_t index = PyLong_AsSsize_t(state);
2930 if (index == -1 && PyErr_Occurred())
2931 return NULL;
2932 if (index < 0)
2933 index = 0;
2934 else if (index > Py_SIZE(self->ao))
2935 index = Py_SIZE(self->ao); /* iterator exhausted */
2936 self->index = index;
2937 Py_RETURN_NONE;
2938 }
2939
2940 static PyMethodDef arrayiter_methods[] = {
2941 ARRAY_ARRAYITERATOR___REDUCE___METHODDEF
2942 ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF
2943 {NULL, NULL} /* sentinel */
2944 };
2945
2946 static PyTypeObject PyArrayIter_Type = {
2947 PyVarObject_HEAD_INIT(NULL, 0)
2948 "arrayiterator", /* tp_name */
2949 sizeof(arrayiterobject), /* tp_basicsize */
2950 0, /* tp_itemsize */
2951 /* methods */
2952 (destructor)arrayiter_dealloc, /* tp_dealloc */
2953 0, /* tp_vectorcall_offset */
2954 0, /* tp_getattr */
2955 0, /* tp_setattr */
2956 0, /* tp_as_async */
2957 0, /* tp_repr */
2958 0, /* tp_as_number */
2959 0, /* tp_as_sequence */
2960 0, /* tp_as_mapping */
2961 0, /* tp_hash */
2962 0, /* tp_call */
2963 0, /* tp_str */
2964 PyObject_GenericGetAttr, /* tp_getattro */
2965 0, /* tp_setattro */
2966 0, /* tp_as_buffer */
2967 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
2968 0, /* tp_doc */
2969 (traverseproc)arrayiter_traverse, /* tp_traverse */
2970 0, /* tp_clear */
2971 0, /* tp_richcompare */
2972 0, /* tp_weaklistoffset */
2973 PyObject_SelfIter, /* tp_iter */
2974 (iternextfunc)arrayiter_next, /* tp_iternext */
2975 arrayiter_methods, /* tp_methods */
2976 };
2977
2978
2979 /*********************** Install Module **************************/
2980
2981 /* No functions in array module. */
2982 static PyMethodDef a_methods[] = {
2983 ARRAY__ARRAY_RECONSTRUCTOR_METHODDEF
2984 {NULL, NULL, 0, NULL} /* Sentinel */
2985 };
2986
2987 static int
array_modexec(PyObject * m)2988 array_modexec(PyObject *m)
2989 {
2990 char buffer[Py_ARRAY_LENGTH(descriptors)], *p;
2991 PyObject *typecodes;
2992 const struct arraydescr *descr;
2993
2994 if (PyType_Ready(&Arraytype) < 0)
2995 return -1;
2996 Py_SET_TYPE(&PyArrayIter_Type, &PyType_Type);
2997
2998 Py_INCREF((PyObject *)&Arraytype);
2999 if (PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype) < 0) {
3000 Py_DECREF((PyObject *)&Arraytype);
3001 return -1;
3002 }
3003 Py_INCREF((PyObject *)&Arraytype);
3004 if (PyModule_AddObject(m, "array", (PyObject *)&Arraytype) < 0) {
3005 Py_DECREF((PyObject *)&Arraytype);
3006 return -1;
3007 }
3008
3009 p = buffer;
3010 for (descr = descriptors; descr->typecode != '\0'; descr++) {
3011 *p++ = (char)descr->typecode;
3012 }
3013 typecodes = PyUnicode_DecodeASCII(buffer, p - buffer, NULL);
3014 if (PyModule_AddObject(m, "typecodes", typecodes) < 0) {
3015 Py_XDECREF(typecodes);
3016 return -1;
3017 }
3018
3019 return 0;
3020 }
3021
3022 static PyModuleDef_Slot arrayslots[] = {
3023 {Py_mod_exec, array_modexec},
3024 {0, NULL}
3025 };
3026
3027
3028 static struct PyModuleDef arraymodule = {
3029 PyModuleDef_HEAD_INIT,
3030 "array",
3031 module_doc,
3032 0,
3033 a_methods,
3034 arrayslots,
3035 NULL,
3036 NULL,
3037 NULL
3038 };
3039
3040
3041 PyMODINIT_FUNC
PyInit_array(void)3042 PyInit_array(void)
3043 {
3044 return PyModuleDef_Init(&arraymodule);
3045 }
3046