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