Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Blame
Revision Log

arraymodule.c@ 388

Last change on this file since 388 was 2, checked in by Yuri Dario, 15 years ago
Initial import for vendor code.
Property svn:eol-style set to `native`
File size: 53.9 KB

Line
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 "structmember.h"
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	struct arrayobject; /* Forward */
19
20	/* All possible arraydescr values are defined in the vector "descriptors"
21	* below. That's defined later because the appropriate get and set
22	* functions aren't visible yet.
23	*/
24	struct arraydescr {
25	int typecode;
26	int itemsize;
27	PyObject * (getitem)(struct arrayobject , Py_ssize_t);
28	int (setitem)(struct arrayobject , Py_ssize_t, PyObject *);
29	};
30
31	typedef struct arrayobject {
32	PyObject_VAR_HEAD
33	char *ob_item;
34	Py_ssize_t allocated;
35	struct arraydescr *ob_descr;
36	PyObject weakreflist; / List of weak references */
37	} arrayobject;
38
39	static PyTypeObject Arraytype;
40
41	#define array_Check(op) PyObject_TypeCheck(op, &Arraytype)
42	#define array_CheckExact(op) (Py_TYPE(op) == &Arraytype)
43
44	static int
45	array_resize(arrayobject *self, Py_ssize_t newsize)
46	{
47	char *items;
48	size_t _new_size;
49
50	/* Bypass realloc() when a previous overallocation is large enough
51	to accommodate the newsize. If the newsize is 16 smaller than the
52	current size, then proceed with the realloc() to shrink the list.
53	*/
54
55	if (self->allocated >= newsize &&
56	Py_SIZE(self) < newsize + 16 &&
57	self->ob_item != NULL) {
58	Py_SIZE(self) = newsize;
59	return 0;
60	}
61
62	/* This over-allocates proportional to the array size, making room
63	* for additional growth. The over-allocation is mild, but is
64	* enough to give linear-time amortized behavior over a long
65	* sequence of appends() in the presence of a poorly-performing
66	* system realloc().
67	* The growth pattern is: 0, 4, 8, 16, 25, 34, 46, 56, 67, 79, ...
68	* Note, the pattern starts out the same as for lists but then
69	* grows at a smaller rate so that larger arrays only overallocate
70	* by about 1/16th -- this is done because arrays are presumed to be more
71	* memory critical.
72	*/
73
74	_new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize;
75	items = self->ob_item;
76	/* XXX The following multiplication and division does not optimize away
77	like it does for lists since the size is not known at compile time */
78	if (_new_size <= ((~(size_t)0) / self->ob_descr->itemsize))
79	PyMem_RESIZE(items, char, (_new_size * self->ob_descr->itemsize));
80	else
81	items = NULL;
82	if (items == NULL) {
83	PyErr_NoMemory();
84	return -1;
85	}
86	self->ob_item = items;
87	Py_SIZE(self) = newsize;
88	self->allocated = _new_size;
89	return 0;
90	}
91
92	/****************************************************************************
93	Get and Set functions for each type.
94	A Get function takes an arrayobject* and an integer index, returning the
95	array value at that index wrapped in an appropriate PyObject*.
96	A Set function takes an arrayobject, integer index, and PyObject*; sets
97	the array value at that index to the raw C data extracted from the PyObject*,
98	and returns 0 if successful, else nonzero on failure (PyObject* not of an
99	appropriate type or value).
100	Note that the basic Get and Set functions do NOT check that the index is
101	in bounds; that's the responsibility of the caller.
102	****************************************************************************/
103
104	static PyObject *
105	c_getitem(arrayobject *ap, Py_ssize_t i)
106	{
107	return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1);
108	}
109
110	static int
111	c_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
112	{
113	char x;
114	if (!PyArg_Parse(v, "c;array item must be char", &x))
115	return -1;
116	if (i >= 0)
117	((char *)ap->ob_item)[i] = x;
118	return 0;
119	}
120
121	static PyObject *
122	b_getitem(arrayobject *ap, Py_ssize_t i)
123	{
124	long x = ((char *)ap->ob_item)[i];
125	if (x >= 128)
126	x -= 256;
127	return PyInt_FromLong(x);
128	}
129
130	static int
131	b_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
132	{
133	short x;
134	/* PyArg_Parse's 'b' formatter is for an unsigned char, therefore
135	must use the next size up that is signed ('h') and manually do
136	the overflow checking */
137	if (!PyArg_Parse(v, "h;array item must be integer", &x))
138	return -1;
139	else if (x < -128) {
140	PyErr_SetString(PyExc_OverflowError,
141	"signed char is less than minimum");
142	return -1;
143	}
144	else if (x > 127) {
145	PyErr_SetString(PyExc_OverflowError,
146	"signed char is greater than maximum");
147	return -1;
148	}
149	if (i >= 0)
150	((char *)ap->ob_item)[i] = (char)x;
151	return 0;
152	}
153
154	static PyObject *
155	BB_getitem(arrayobject *ap, Py_ssize_t i)
156	{
157	long x = ((unsigned char *)ap->ob_item)[i];
158	return PyInt_FromLong(x);
159	}
160
161	static int
162	BB_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
163	{
164	unsigned char x;
165	/* 'B' == unsigned char, maps to PyArg_Parse's 'b' formatter */
166	if (!PyArg_Parse(v, "b;array item must be integer", &x))
167	return -1;
168	if (i >= 0)
169	((char *)ap->ob_item)[i] = x;
170	return 0;
171	}
172
173	#ifdef Py_USING_UNICODE
174	static PyObject *
175	u_getitem(arrayobject *ap, Py_ssize_t i)
176	{
177	return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1);
178	}
179
180	static int
181	u_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
182	{
183	Py_UNICODE *p;
184	Py_ssize_t len;
185
186	if (!PyArg_Parse(v, "u#;array item must be unicode character", &p, &len))
187	return -1;
188	if (len != 1) {
189	PyErr_SetString(PyExc_TypeError,
190	"array item must be unicode character");
191	return -1;
192	}
193	if (i >= 0)
194	((Py_UNICODE *)ap->ob_item)[i] = p[0];
195	return 0;
196	}
197	#endif
198
199	static PyObject *
200	h_getitem(arrayobject *ap, Py_ssize_t i)
201	{
202	return PyInt_FromLong((long) ((short *)ap->ob_item)[i]);
203	}
204
205	static int
206	h_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
207	{
208	short x;
209	/* 'h' == signed short, maps to PyArg_Parse's 'h' formatter */
210	if (!PyArg_Parse(v, "h;array item must be integer", &x))
211	return -1;
212	if (i >= 0)
213	((short *)ap->ob_item)[i] = x;
214	return 0;
215	}
216
217	static PyObject *
218	HH_getitem(arrayobject *ap, Py_ssize_t i)
219	{
220	return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]);
221	}
222
223	static int
224	HH_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
225	{
226	int x;
227	/* PyArg_Parse's 'h' formatter is for a signed short, therefore
228	must use the next size up and manually do the overflow checking */
229	if (!PyArg_Parse(v, "i;array item must be integer", &x))
230	return -1;
231	else if (x < 0) {
232	PyErr_SetString(PyExc_OverflowError,
233	"unsigned short is less than minimum");
234	return -1;
235	}
236	else if (x > USHRT_MAX) {
237	PyErr_SetString(PyExc_OverflowError,
238	"unsigned short is greater than maximum");
239	return -1;
240	}
241	if (i >= 0)
242	((short *)ap->ob_item)[i] = (short)x;
243	return 0;
244	}
245
246	static PyObject *
247	i_getitem(arrayobject *ap, Py_ssize_t i)
248	{
249	return PyInt_FromLong((long) ((int *)ap->ob_item)[i]);
250	}
251
252	static int
253	i_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
254	{
255	int x;
256	/* 'i' == signed int, maps to PyArg_Parse's 'i' formatter */
257	if (!PyArg_Parse(v, "i;array item must be integer", &x))
258	return -1;
259	if (i >= 0)
260	((int *)ap->ob_item)[i] = x;
261	return 0;
262	}
263
264	static PyObject *
265	II_getitem(arrayobject *ap, Py_ssize_t i)
266	{
267	return PyLong_FromUnsignedLong(
268	(unsigned long) ((unsigned int *)ap->ob_item)[i]);
269	}
270
271	static int
272	II_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
273	{
274	unsigned long x;
275	if (PyLong_Check(v)) {
276	x = PyLong_AsUnsignedLong(v);
277	if (x == (unsigned long) -1 && PyErr_Occurred())
278	return -1;
279	}
280	else {
281	long y;
282	if (!PyArg_Parse(v, "l;array item must be integer", &y))
283	return -1;
284	if (y < 0) {
285	PyErr_SetString(PyExc_OverflowError,
286	"unsigned int is less than minimum");
287	return -1;
288	}
289	x = (unsigned long)y;
290
291	}
292	if (x > UINT_MAX) {
293	PyErr_SetString(PyExc_OverflowError,
294	"unsigned int is greater than maximum");
295	return -1;
296	}
297
298	if (i >= 0)
299	((unsigned int *)ap->ob_item)[i] = (unsigned int)x;
300	return 0;
301	}
302
303	static PyObject *
304	l_getitem(arrayobject *ap, Py_ssize_t i)
305	{
306	return PyInt_FromLong(((long *)ap->ob_item)[i]);
307	}
308
309	static int
310	l_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
311	{
312	long x;
313	if (!PyArg_Parse(v, "l;array item must be integer", &x))
314	return -1;
315	if (i >= 0)
316	((long *)ap->ob_item)[i] = x;
317	return 0;
318	}
319
320	static PyObject *
321	LL_getitem(arrayobject *ap, Py_ssize_t i)
322	{
323	return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]);
324	}
325
326	static int
327	LL_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
328	{
329	unsigned long x;
330	if (PyLong_Check(v)) {
331	x = PyLong_AsUnsignedLong(v);
332	if (x == (unsigned long) -1 && PyErr_Occurred())
333	return -1;
334	}
335	else {
336	long y;
337	if (!PyArg_Parse(v, "l;array item must be integer", &y))
338	return -1;
339	if (y < 0) {
340	PyErr_SetString(PyExc_OverflowError,
341	"unsigned long is less than minimum");
342	return -1;
343	}
344	x = (unsigned long)y;
345
346	}
347	if (x > ULONG_MAX) {
348	PyErr_SetString(PyExc_OverflowError,
349	"unsigned long is greater than maximum");
350	return -1;
351	}
352
353	if (i >= 0)
354	((unsigned long *)ap->ob_item)[i] = x;
355	return 0;
356	}
357
358	static PyObject *
359	f_getitem(arrayobject *ap, Py_ssize_t i)
360	{
361	return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]);
362	}
363
364	static int
365	f_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
366	{
367	float x;
368	if (!PyArg_Parse(v, "f;array item must be float", &x))
369	return -1;
370	if (i >= 0)
371	((float *)ap->ob_item)[i] = x;
372	return 0;
373	}
374
375	static PyObject *
376	d_getitem(arrayobject *ap, Py_ssize_t i)
377	{
378	return PyFloat_FromDouble(((double *)ap->ob_item)[i]);
379	}
380
381	static int
382	d_setitem(arrayobject ap, Py_ssize_t i, PyObject v)
383	{
384	double x;
385	if (!PyArg_Parse(v, "d;array item must be float", &x))
386	return -1;
387	if (i >= 0)
388	((double *)ap->ob_item)[i] = x;
389	return 0;
390	}
391
392	/* Description of types */
393	static struct arraydescr descriptors[] = {
394	{'c', sizeof(char), c_getitem, c_setitem},
395	{'b', sizeof(char), b_getitem, b_setitem},
396	{'B', sizeof(char), BB_getitem, BB_setitem},
397	#ifdef Py_USING_UNICODE
398	{'u', sizeof(Py_UNICODE), u_getitem, u_setitem},
399	#endif
400	{'h', sizeof(short), h_getitem, h_setitem},
401	{'H', sizeof(short), HH_getitem, HH_setitem},
402	{'i', sizeof(int), i_getitem, i_setitem},
403	{'I', sizeof(int), II_getitem, II_setitem},
404	{'l', sizeof(long), l_getitem, l_setitem},
405	{'L', sizeof(long), LL_getitem, LL_setitem},
406	{'f', sizeof(float), f_getitem, f_setitem},
407	{'d', sizeof(double), d_getitem, d_setitem},
408	{'\0', 0, 0, 0} /* Sentinel */
409	};
410
411	/****************************************************************************
412	Implementations of array object methods.
413	****************************************************************************/
414
415	static PyObject *
416	newarrayobject(PyTypeObject type, Py_ssize_t size, struct arraydescr descr)
417	{
418	arrayobject *op;
419	size_t nbytes;
420
421	if (size < 0) {
422	PyErr_BadInternalCall();
423	return NULL;
424	}
425
426	nbytes = size * descr->itemsize;
427	/* Check for overflow */
428	if (nbytes / descr->itemsize != (size_t)size) {
429	return PyErr_NoMemory();
430	}
431	op = (arrayobject *) type->tp_alloc(type, 0);
432	if (op == NULL) {
433	return NULL;
434	}
435	op->ob_descr = descr;
436	op->allocated = size;
437	op->weakreflist = NULL;
438	Py_SIZE(op) = size;
439	if (size <= 0) {
440	op->ob_item = NULL;
441	}
442	else {
443	op->ob_item = PyMem_NEW(char, nbytes);
444	if (op->ob_item == NULL) {
445	Py_DECREF(op);
446	return PyErr_NoMemory();
447	}
448	}
449	return (PyObject *) op;
450	}
451
452	static PyObject *
453	getarrayitem(PyObject *op, Py_ssize_t i)
454	{
455	register arrayobject *ap;
456	assert(array_Check(op));
457	ap = (arrayobject *)op;
458	assert(i>=0 && i<Py_SIZE(ap));
459	return (*ap->ob_descr->getitem)(ap, i);
460	}
461
462	static int
463	ins1(arrayobject self, Py_ssize_t where, PyObject v)
464	{
465	char *items;
466	Py_ssize_t n = Py_SIZE(self);
467	if (v == NULL) {
468	PyErr_BadInternalCall();
469	return -1;
470	}
471	if ((*self->ob_descr->setitem)(self, -1, v) < 0)
472	return -1;
473
474	if (array_resize(self, n+1) == -1)
475	return -1;
476	items = self->ob_item;
477	if (where < 0) {
478	where += n;
479	if (where < 0)
480	where = 0;
481	}
482	if (where > n)
483	where = n;
484	/* appends don't need to call memmove() */
485	if (where != n)
486	memmove(items + (where+1)*self->ob_descr->itemsize,
487	items + where*self->ob_descr->itemsize,
488	(n-where)*self->ob_descr->itemsize);
489	return (*self->ob_descr->setitem)(self, where, v);
490	}
491
492	/* Methods */
493
494	static void
495	array_dealloc(arrayobject *op)
496	{
497	if (op->weakreflist != NULL)
498	PyObject_ClearWeakRefs((PyObject *) op);
499	if (op->ob_item != NULL)
500	PyMem_DEL(op->ob_item);
501	Py_TYPE(op)->tp_free((PyObject *)op);
502	}
503
504	static PyObject *
505	array_richcompare(PyObject v, PyObject w, int op)
506	{
507	arrayobject va, wa;
508	PyObject *vi = NULL;
509	PyObject *wi = NULL;
510	Py_ssize_t i, k;
511	PyObject *res;
512
513	if (!array_Check(v) \|\| !array_Check(w)) {
514	Py_INCREF(Py_NotImplemented);
515	return Py_NotImplemented;
516	}
517
518	va = (arrayobject *)v;
519	wa = (arrayobject *)w;
520
521	if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ \|\| op == Py_NE)) {
522	/* Shortcut: if the lengths differ, the arrays differ */
523	if (op == Py_EQ)
524	res = Py_False;
525	else
526	res = Py_True;
527	Py_INCREF(res);
528	return res;
529	}
530
531	/* Search for the first index where items are different */
532	k = 1;
533	for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) {
534	vi = getarrayitem(v, i);
535	wi = getarrayitem(w, i);
536	if (vi == NULL \|\| wi == NULL) {
537	Py_XDECREF(vi);
538	Py_XDECREF(wi);
539	return NULL;
540	}
541	k = PyObject_RichCompareBool(vi, wi, Py_EQ);
542	if (k == 0)
543	break; /* Keeping vi and wi alive! */
544	Py_DECREF(vi);
545	Py_DECREF(wi);
546	if (k < 0)
547	return NULL;
548	}
549
550	if (k) {
551	/* No more items to compare -- compare sizes */
552	Py_ssize_t vs = Py_SIZE(va);
553	Py_ssize_t ws = Py_SIZE(wa);
554	int cmp;
555	switch (op) {
556	case Py_LT: cmp = vs < ws; break;
557	case Py_LE: cmp = vs <= ws; break;
558	case Py_EQ: cmp = vs == ws; break;
559	case Py_NE: cmp = vs != ws; break;
560	case Py_GT: cmp = vs > ws; break;
561	case Py_GE: cmp = vs >= ws; break;
562	default: return NULL; /* cannot happen */
563	}
564	if (cmp)
565	res = Py_True;
566	else
567	res = Py_False;
568	Py_INCREF(res);
569	return res;
570	}
571
572	/* We have an item that differs. First, shortcuts for EQ/NE */
573	if (op == Py_EQ) {
574	Py_INCREF(Py_False);
575	res = Py_False;
576	}
577	else if (op == Py_NE) {
578	Py_INCREF(Py_True);
579	res = Py_True;
580	}
581	else {
582	/* Compare the final item again using the proper operator */
583	res = PyObject_RichCompare(vi, wi, op);
584	}
585	Py_DECREF(vi);
586	Py_DECREF(wi);
587	return res;
588	}
589
590	static Py_ssize_t
591	array_length(arrayobject *a)
592	{
593	return Py_SIZE(a);
594	}
595
596	static PyObject *
597	array_item(arrayobject *a, Py_ssize_t i)
598	{
599	if (i < 0 \|\| i >= Py_SIZE(a)) {
600	PyErr_SetString(PyExc_IndexError, "array index out of range");
601	return NULL;
602	}
603	return getarrayitem((PyObject *)a, i);
604	}
605
606	static PyObject *
607	array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh)
608	{
609	arrayobject *np;
610	if (ilow < 0)
611	ilow = 0;
612	else if (ilow > Py_SIZE(a))
613	ilow = Py_SIZE(a);
614	if (ihigh < 0)
615	ihigh = 0;
616	if (ihigh < ilow)
617	ihigh = ilow;
618	else if (ihigh > Py_SIZE(a))
619	ihigh = Py_SIZE(a);
620	np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);
621	if (np == NULL)
622	return NULL;
623	memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize,
624	(ihigh-ilow) * a->ob_descr->itemsize);
625	return (PyObject *)np;
626	}
627
628	static PyObject *
629	array_copy(arrayobject a, PyObject unused)
630	{
631	return array_slice(a, 0, Py_SIZE(a));
632	}
633
634	PyDoc_STRVAR(copy_doc,
635	"copy(array)\n\
636	\n\
637	Return a copy of the array.");
638
639	static PyObject *
640	array_concat(arrayobject a, PyObject bb)
641	{
642	Py_ssize_t size;
643	arrayobject *np;
644	if (!array_Check(bb)) {
645	PyErr_Format(PyExc_TypeError,
646	"can only append array (not \"%.200s\") to array",
647	Py_TYPE(bb)->tp_name);
648	return NULL;
649	}
650	#define b ((arrayobject *)bb)
651	if (a->ob_descr != b->ob_descr) {
652	PyErr_BadArgument();
653	return NULL;
654	}
655	if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) {
656	return PyErr_NoMemory();
657	}
658	size = Py_SIZE(a) + Py_SIZE(b);
659	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
660	if (np == NULL) {
661	return NULL;
662	}
663	memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize);
664	memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize,
665	b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
666	return (PyObject *)np;
667	#undef b
668	}
669
670	static PyObject *
671	array_repeat(arrayobject *a, Py_ssize_t n)
672	{
673	Py_ssize_t i;
674	Py_ssize_t size;
675	arrayobject *np;
676	char *p;
677	Py_ssize_t nbytes;
678	if (n < 0)
679	n = 0;
680	if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) {
681	return PyErr_NoMemory();
682	}
683	size = Py_SIZE(a) * n;
684	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
685	if (np == NULL)
686	return NULL;
687	p = np->ob_item;
688	nbytes = Py_SIZE(a) * a->ob_descr->itemsize;
689	for (i = 0; i < n; i++) {
690	memcpy(p, a->ob_item, nbytes);
691	p += nbytes;
692	}
693	return (PyObject *) np;
694	}
695
696	static int
697	array_ass_slice(arrayobject a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject v)
698	{
699	char *item;
700	Py_ssize_t n; /* Size of replacement array */
701	Py_ssize_t d; /* Change in size */
702	#define b ((arrayobject *)v)
703	if (v == NULL)
704	n = 0;
705	else if (array_Check(v)) {
706	n = Py_SIZE(b);
707	if (a == b) {
708	/* Special case "a[i:j] = a" -- copy b first */
709	int ret;
710	v = array_slice(b, 0, n);
711	if (!v)
712	return -1;
713	ret = array_ass_slice(a, ilow, ihigh, v);
714	Py_DECREF(v);
715	return ret;
716	}
717	if (b->ob_descr != a->ob_descr) {
718	PyErr_BadArgument();
719	return -1;
720	}
721	}
722	else {
723	PyErr_Format(PyExc_TypeError,
724	"can only assign array (not \"%.200s\") to array slice",
725	Py_TYPE(v)->tp_name);
726	return -1;
727	}
728	if (ilow < 0)
729	ilow = 0;
730	else if (ilow > Py_SIZE(a))
731	ilow = Py_SIZE(a);
732	if (ihigh < 0)
733	ihigh = 0;
734	if (ihigh < ilow)
735	ihigh = ilow;
736	else if (ihigh > Py_SIZE(a))
737	ihigh = Py_SIZE(a);
738	item = a->ob_item;
739	d = n - (ihigh-ilow);
740	if (d < 0) { /* Delete -d items */
741	memmove(item + (ihigh+d)*a->ob_descr->itemsize,
742	item + ihigh*a->ob_descr->itemsize,
743	(Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
744	Py_SIZE(a) += d;
745	PyMem_RESIZE(item, char, Py_SIZE(a)*a->ob_descr->itemsize);
746	/* Can't fail */
747	a->ob_item = item;
748	a->allocated = Py_SIZE(a);
749	}
750	else if (d > 0) { /* Insert d items */
751	PyMem_RESIZE(item, char,
752	(Py_SIZE(a) + d)*a->ob_descr->itemsize);
753	if (item == NULL) {
754	PyErr_NoMemory();
755	return -1;
756	}
757	memmove(item + (ihigh+d)*a->ob_descr->itemsize,
758	item + ihigh*a->ob_descr->itemsize,
759	(Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
760	a->ob_item = item;
761	Py_SIZE(a) += d;
762	a->allocated = Py_SIZE(a);
763	}
764	if (n > 0)
765	memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
766	n*b->ob_descr->itemsize);
767	return 0;
768	#undef b
769	}
770
771	static int
772	array_ass_item(arrayobject a, Py_ssize_t i, PyObject v)
773	{
774	if (i < 0 \|\| i >= Py_SIZE(a)) {
775	PyErr_SetString(PyExc_IndexError,
776	"array assignment index out of range");
777	return -1;
778	}
779	if (v == NULL)
780	return array_ass_slice(a, i, i+1, v);
781	return (*a->ob_descr->setitem)(a, i, v);
782	}
783
784	static int
785	setarrayitem(PyObject a, Py_ssize_t i, PyObject v)
786	{
787	assert(array_Check(a));
788	return array_ass_item((arrayobject *)a, i, v);
789	}
790
791	static int
792	array_iter_extend(arrayobject self, PyObject bb)
793	{
794	PyObject it, v;
795
796	it = PyObject_GetIter(bb);
797	if (it == NULL)
798	return -1;
799
800	while ((v = PyIter_Next(it)) != NULL) {
801	if (ins1(self, (int) Py_SIZE(self), v) != 0) {
802	Py_DECREF(v);
803	Py_DECREF(it);
804	return -1;
805	}
806	Py_DECREF(v);
807	}
808	Py_DECREF(it);
809	if (PyErr_Occurred())
810	return -1;
811	return 0;
812	}
813
814	static int
815	array_do_extend(arrayobject self, PyObject bb)
816	{
817	Py_ssize_t size;
818	char *old_item;
819
820	if (!array_Check(bb))
821	return array_iter_extend(self, bb);
822	#define b ((arrayobject *)bb)
823	if (self->ob_descr != b->ob_descr) {
824	PyErr_SetString(PyExc_TypeError,
825	"can only extend with array of same kind");
826	return -1;
827	}
828	if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) \|\|
829	((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
830	PyErr_NoMemory();
831	return -1;
832	}
833	size = Py_SIZE(self) + Py_SIZE(b);
834	old_item = self->ob_item;
835	PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
836	if (self->ob_item == NULL) {
837	self->ob_item = old_item;
838	PyErr_NoMemory();
839	return -1;
840	}
841	memcpy(self->ob_item + Py_SIZE(self)*self->ob_descr->itemsize,
842	b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
843	Py_SIZE(self) = size;
844	self->allocated = size;
845
846	return 0;
847	#undef b
848	}
849
850	static PyObject *
851	array_inplace_concat(arrayobject self, PyObject bb)
852	{
853	if (!array_Check(bb)) {
854	PyErr_Format(PyExc_TypeError,
855	"can only extend array with array (not \"%.200s\")",
856	Py_TYPE(bb)->tp_name);
857	return NULL;
858	}
859	if (array_do_extend(self, bb) == -1)
860	return NULL;
861	Py_INCREF(self);
862	return (PyObject *)self;
863	}
864
865	static PyObject *
866	array_inplace_repeat(arrayobject *self, Py_ssize_t n)
867	{
868	char items, p;
869	Py_ssize_t size, i;
870
871	if (Py_SIZE(self) > 0) {
872	if (n < 0)
873	n = 0;
874	items = self->ob_item;
875	if ((self->ob_descr->itemsize != 0) &&
876	(Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
877	return PyErr_NoMemory();
878	}
879	size = Py_SIZE(self) * self->ob_descr->itemsize;
880	if (n == 0) {
881	PyMem_FREE(items);
882	self->ob_item = NULL;
883	Py_SIZE(self) = 0;
884	self->allocated = 0;
885	}
886	else {
887	if (size > PY_SSIZE_T_MAX / n) {
888	return PyErr_NoMemory();
889	}
890	PyMem_RESIZE(items, char, n * size);
891	if (items == NULL)
892	return PyErr_NoMemory();
893	p = items;
894	for (i = 1; i < n; i++) {
895	p += size;
896	memcpy(p, items, size);
897	}
898	self->ob_item = items;
899	Py_SIZE(self) *= n;
900	self->allocated = Py_SIZE(self);
901	}
902	}
903	Py_INCREF(self);
904	return (PyObject *)self;
905	}
906
907
908	static PyObject *
909	ins(arrayobject self, Py_ssize_t where, PyObject v)
910	{
911	if (ins1(self, where, v) != 0)
912	return NULL;
913	Py_INCREF(Py_None);
914	return Py_None;
915	}
916
917	static PyObject *
918	array_count(arrayobject self, PyObject v)
919	{
920	Py_ssize_t count = 0;
921	Py_ssize_t i;
922
923	for (i = 0; i < Py_SIZE(self); i++) {
924	PyObject selfi = getarrayitem((PyObject )self, i);
925	int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
926	Py_DECREF(selfi);
927	if (cmp > 0)
928	count++;
929	else if (cmp < 0)
930	return NULL;
931	}
932	return PyInt_FromSsize_t(count);
933	}
934
935	PyDoc_STRVAR(count_doc,
936	"count(x)\n\
937	\n\
938	Return number of occurrences of x in the array.");
939
940	static PyObject *
941	array_index(arrayobject self, PyObject v)
942	{
943	Py_ssize_t i;
944
945	for (i = 0; i < Py_SIZE(self); i++) {
946	PyObject selfi = getarrayitem((PyObject )self, i);
947	int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
948	Py_DECREF(selfi);
949	if (cmp > 0) {
950	return PyInt_FromLong((long)i);
951	}
952	else if (cmp < 0)
953	return NULL;
954	}
955	PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list");
956	return NULL;
957	}
958
959	PyDoc_STRVAR(index_doc,
960	"index(x)\n\
961	\n\
962	Return index of first occurrence of x in the array.");
963
964	static int
965	array_contains(arrayobject self, PyObject v)
966	{
967	Py_ssize_t i;
968	int cmp;
969
970	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) {
971	PyObject selfi = getarrayitem((PyObject )self, i);
972	cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
973	Py_DECREF(selfi);
974	}
975	return cmp;
976	}
977
978	static PyObject *
979	array_remove(arrayobject self, PyObject v)
980	{
981	int i;
982
983	for (i = 0; i < Py_SIZE(self); i++) {
984	PyObject selfi = getarrayitem((PyObject )self,i);
985	int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
986	Py_DECREF(selfi);
987	if (cmp > 0) {
988	if (array_ass_slice(self, i, i+1,
989	(PyObject *)NULL) != 0)
990	return NULL;
991	Py_INCREF(Py_None);
992	return Py_None;
993	}
994	else if (cmp < 0)
995	return NULL;
996	}
997	PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list");
998	return NULL;
999	}
1000
1001	PyDoc_STRVAR(remove_doc,
1002	"remove(x)\n\
1003	\n\
1004	Remove the first occurrence of x in the array.");
1005
1006	static PyObject *
1007	array_pop(arrayobject self, PyObject args)
1008	{
1009	Py_ssize_t i = -1;
1010	PyObject *v;
1011	if (!PyArg_ParseTuple(args, "\|n:pop", &i))
1012	return NULL;
1013	if (Py_SIZE(self) == 0) {
1014	/* Special-case most common failure cause */
1015	PyErr_SetString(PyExc_IndexError, "pop from empty array");
1016	return NULL;
1017	}
1018	if (i < 0)
1019	i += Py_SIZE(self);
1020	if (i < 0 \|\| i >= Py_SIZE(self)) {
1021	PyErr_SetString(PyExc_IndexError, "pop index out of range");
1022	return NULL;
1023	}
1024	v = getarrayitem((PyObject *)self,i);
1025	if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) {
1026	Py_DECREF(v);
1027	return NULL;
1028	}
1029	return v;
1030	}
1031
1032	PyDoc_STRVAR(pop_doc,
1033	"pop([i])\n\
1034	\n\
1035	Return the i-th element and delete it from the array. i defaults to -1.");
1036
1037	static PyObject *
1038	array_extend(arrayobject self, PyObject bb)
1039	{
1040	if (array_do_extend(self, bb) == -1)
1041	return NULL;
1042	Py_INCREF(Py_None);
1043	return Py_None;
1044	}
1045
1046	PyDoc_STRVAR(extend_doc,
1047	"extend(array or iterable)\n\
1048	\n\
1049	Append items to the end of the array.");
1050
1051	static PyObject *
1052	array_insert(arrayobject self, PyObject args)
1053	{
1054	Py_ssize_t i;
1055	PyObject *v;
1056	if (!PyArg_ParseTuple(args, "nO:insert", &i, &v))
1057	return NULL;
1058	return ins(self, i, v);
1059	}
1060
1061	PyDoc_STRVAR(insert_doc,
1062	"insert(i,x)\n\
1063	\n\
1064	Insert a new item x into the array before position i.");
1065
1066
1067	static PyObject *
1068	array_buffer_info(arrayobject self, PyObject unused)
1069	{
1070	PyObject* retval = NULL;
1071	retval = PyTuple_New(2);
1072	if (!retval)
1073	return NULL;
1074
1075	PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
1076	PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(Py_SIZE(self))));
1077
1078	return retval;
1079	}
1080
1081	PyDoc_STRVAR(buffer_info_doc,
1082	"buffer_info() -> (address, length)\n\
1083	\n\
1084	Return a tuple (address, length) giving the current memory address and\n\
1085	the length in items of the buffer used to hold array's contents\n\
1086	The length should be multiplied by the itemsize attribute to calculate\n\
1087	the buffer length in bytes.");
1088
1089
1090	static PyObject *
1091	array_append(arrayobject self, PyObject v)
1092	{
1093	return ins(self, (int) Py_SIZE(self), v);
1094	}
1095
1096	PyDoc_STRVAR(append_doc,
1097	"append(x)\n\
1098	\n\
1099	Append new value x to the end of the array.");
1100
1101
1102	static PyObject *
1103	array_byteswap(arrayobject self, PyObject unused)
1104	{
1105	char *p;
1106	Py_ssize_t i;
1107
1108	switch (self->ob_descr->itemsize) {
1109	case 1:
1110	break;
1111	case 2:
1112	for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) {
1113	char p0 = p[0];
1114	p[0] = p[1];
1115	p[1] = p0;
1116	}
1117	break;
1118	case 4:
1119	for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) {
1120	char p0 = p[0];
1121	char p1 = p[1];
1122	p[0] = p[3];
1123	p[1] = p[2];
1124	p[2] = p1;
1125	p[3] = p0;
1126	}
1127	break;
1128	case 8:
1129	for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) {
1130	char p0 = p[0];
1131	char p1 = p[1];
1132	char p2 = p[2];
1133	char p3 = p[3];
1134	p[0] = p[7];
1135	p[1] = p[6];
1136	p[2] = p[5];
1137	p[3] = p[4];
1138	p[4] = p3;
1139	p[5] = p2;
1140	p[6] = p1;
1141	p[7] = p0;
1142	}
1143	break;
1144	default:
1145	PyErr_SetString(PyExc_RuntimeError,
1146	"don't know how to byteswap this array type");
1147	return NULL;
1148	}
1149	Py_INCREF(Py_None);
1150	return Py_None;
1151	}
1152
1153	PyDoc_STRVAR(byteswap_doc,
1154	"byteswap()\n\
1155	\n\
1156	Byteswap all items of the array. If the items in the array are not 1, 2,\n\
1157	4, or 8 bytes in size, RuntimeError is raised.");
1158
1159	static PyObject *
1160	array_reduce(arrayobject *array)
1161	{
1162	PyObject dict, result;
1163
1164	dict = PyObject_GetAttrString((PyObject *)array, "__dict__");
1165	if (dict == NULL) {
1166	PyErr_Clear();
1167	dict = Py_None;
1168	Py_INCREF(dict);
1169	}
1170	if (Py_SIZE(array) > 0) {
1171	if (array->ob_descr->itemsize
1172	> PY_SSIZE_T_MAX / array->ob_size) {
1173	return PyErr_NoMemory();
1174	}
1175	result = Py_BuildValue("O(cs#)O",
1176	Py_TYPE(array),
1177	array->ob_descr->typecode,
1178	array->ob_item,
1179	Py_SIZE(array) * array->ob_descr->itemsize,
1180	dict);
1181	} else {
1182	result = Py_BuildValue("O(c)O",
1183	Py_TYPE(array),
1184	array->ob_descr->typecode,
1185	dict);
1186	}
1187	Py_DECREF(dict);
1188	return result;
1189	}
1190
1191	PyDoc_STRVAR(array_doc, "Return state information for pickling.");
1192
1193	static PyObject *
1194	array_reverse(arrayobject self, PyObject unused)
1195	{
1196	register Py_ssize_t itemsize = self->ob_descr->itemsize;
1197	register char p, q;
1198	/* little buffer to hold items while swapping */
1199	char tmp[256]; /* 8 is probably enough -- but why skimp */
1200	assert((size_t)itemsize <= sizeof(tmp));
1201
1202	if (Py_SIZE(self) > 1) {
1203	for (p = self->ob_item,
1204	q = self->ob_item + (Py_SIZE(self) - 1)*itemsize;
1205	p < q;
1206	p += itemsize, q -= itemsize) {
1207	/* memory areas guaranteed disjoint, so memcpy
1208	* is safe (& memmove may be slower).
1209	*/
1210	memcpy(tmp, p, itemsize);
1211	memcpy(p, q, itemsize);
1212	memcpy(q, tmp, itemsize);
1213	}
1214	}
1215
1216	Py_INCREF(Py_None);
1217	return Py_None;
1218	}
1219
1220	PyDoc_STRVAR(reverse_doc,
1221	"reverse()\n\
1222	\n\
1223	Reverse the order of the items in the array.");
1224
1225	static PyObject *
1226	array_fromfile(arrayobject self, PyObject args)
1227	{
1228	PyObject *f;
1229	Py_ssize_t n;
1230	FILE *fp;
1231	if (!PyArg_ParseTuple(args, "On:fromfile", &f, &n))
1232	return NULL;
1233	fp = PyFile_AsFile(f);
1234	if (fp == NULL) {
1235	PyErr_SetString(PyExc_TypeError, "arg1 must be open file");
1236	return NULL;
1237	}
1238	if (n > 0) {
1239	char *item = self->ob_item;
1240	Py_ssize_t itemsize = self->ob_descr->itemsize;
1241	size_t nread;
1242	Py_ssize_t newlength;
1243	size_t newbytes;
1244	/* Be careful here about overflow */
1245	if ((newlength = Py_SIZE(self) + n) <= 0 \|\|
1246	(newbytes = newlength * itemsize) / itemsize !=
1247	(size_t)newlength)
1248	goto nomem;
1249	PyMem_RESIZE(item, char, newbytes);
1250	if (item == NULL) {
1251	nomem:
1252	PyErr_NoMemory();
1253	return NULL;
1254	}
1255	self->ob_item = item;
1256	Py_SIZE(self) += n;
1257	self->allocated = Py_SIZE(self);
1258	nread = fread(item + (Py_SIZE(self) - n) * itemsize,
1259	itemsize, n, fp);
1260	if (nread < (size_t)n) {
1261	Py_SIZE(self) -= (n - nread);
1262	PyMem_RESIZE(item, char, Py_SIZE(self)*itemsize);
1263	self->ob_item = item;
1264	self->allocated = Py_SIZE(self);
1265	PyErr_SetString(PyExc_EOFError,
1266	"not enough items in file");
1267	return NULL;
1268	}
1269	}
1270	Py_INCREF(Py_None);
1271	return Py_None;
1272	}
1273
1274	PyDoc_STRVAR(fromfile_doc,
1275	"fromfile(f, n)\n\
1276	\n\
1277	Read n objects from the file object f and append them to the end of the\n\
1278	array. Also called as read.");
1279
1280
1281	static PyObject *
1282	array_fromfile_as_read(arrayobject self, PyObject args)
1283	{
1284	if (PyErr_WarnPy3k("array.read() not supported in 3.x; "
1285	"use array.fromfile()", 1) < 0)
1286	return NULL;
1287	return array_fromfile(self, args);
1288	}
1289
1290
1291	static PyObject *
1292	array_tofile(arrayobject self, PyObject f)
1293	{
1294	FILE *fp;
1295
1296	fp = PyFile_AsFile(f);
1297	if (fp == NULL) {
1298	PyErr_SetString(PyExc_TypeError, "arg must be open file");
1299	return NULL;
1300	}
1301	if (self->ob_size > 0) {
1302	if (fwrite(self->ob_item, self->ob_descr->itemsize,
1303	self->ob_size, fp) != (size_t)self->ob_size) {
1304	PyErr_SetFromErrno(PyExc_IOError);
1305	clearerr(fp);
1306	return NULL;
1307	}
1308	}
1309	Py_INCREF(Py_None);
1310	return Py_None;
1311	}
1312
1313	PyDoc_STRVAR(tofile_doc,
1314	"tofile(f)\n\
1315	\n\
1316	Write all items (as machine values) to the file object f. Also called as\n\
1317	write.");
1318
1319
1320	static PyObject *
1321	array_tofile_as_write(arrayobject self, PyObject f)
1322	{
1323	if (PyErr_WarnPy3k("array.write() not supported in 3.x; "
1324	"use array.tofile()", 1) < 0)
1325	return NULL;
1326	return array_tofile(self, f);
1327	}
1328
1329
1330	static PyObject *
1331	array_fromlist(arrayobject self, PyObject list)
1332	{
1333	Py_ssize_t n;
1334	Py_ssize_t itemsize = self->ob_descr->itemsize;
1335
1336	if (!PyList_Check(list)) {
1337	PyErr_SetString(PyExc_TypeError, "arg must be list");
1338	return NULL;
1339	}
1340	n = PyList_Size(list);
1341	if (n > 0) {
1342	char *item = self->ob_item;
1343	Py_ssize_t i;
1344	PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
1345	if (item == NULL) {
1346	PyErr_NoMemory();
1347	return NULL;
1348	}
1349	self->ob_item = item;
1350	Py_SIZE(self) += n;
1351	self->allocated = Py_SIZE(self);
1352	for (i = 0; i < n; i++) {
1353	PyObject *v = PyList_GetItem(list, i);
1354	if ((*self->ob_descr->setitem)(self,
1355	Py_SIZE(self) - n + i, v) != 0) {
1356	Py_SIZE(self) -= n;
1357	if (itemsize && (self->ob_size > PY_SSIZE_T_MAX / itemsize)) {
1358	return PyErr_NoMemory();
1359	}
1360	PyMem_RESIZE(item, char,
1361	Py_SIZE(self) * itemsize);
1362	self->ob_item = item;
1363	self->allocated = Py_SIZE(self);
1364	return NULL;
1365	}
1366	}
1367	}
1368	Py_INCREF(Py_None);
1369	return Py_None;
1370	}
1371
1372	PyDoc_STRVAR(fromlist_doc,
1373	"fromlist(list)\n\
1374	\n\
1375	Append items to array from list.");
1376
1377
1378	static PyObject *
1379	array_tolist(arrayobject self, PyObject unused)
1380	{
1381	PyObject *list = PyList_New(Py_SIZE(self));
1382	Py_ssize_t i;
1383
1384	if (list == NULL)
1385	return NULL;
1386	for (i = 0; i < Py_SIZE(self); i++) {
1387	PyObject v = getarrayitem((PyObject )self, i);
1388	if (v == NULL) {
1389	Py_DECREF(list);
1390	return NULL;
1391	}
1392	PyList_SetItem(list, i, v);
1393	}
1394	return list;
1395	}
1396
1397	PyDoc_STRVAR(tolist_doc,
1398	"tolist() -> list\n\
1399	\n\
1400	Convert array to an ordinary list with the same items.");
1401
1402
1403	static PyObject *
1404	array_fromstring(arrayobject self, PyObject args)
1405	{
1406	char *str;
1407	Py_ssize_t n;
1408	int itemsize = self->ob_descr->itemsize;
1409	if (!PyArg_ParseTuple(args, "s#:fromstring", &str, &n))
1410	return NULL;
1411	if (n % itemsize != 0) {
1412	PyErr_SetString(PyExc_ValueError,
1413	"string length not a multiple of item size");
1414	return NULL;
1415	}
1416	n = n / itemsize;
1417	if (n > 0) {
1418	char *item = self->ob_item;
1419	if ((n > PY_SSIZE_T_MAX - Py_SIZE(self)) \|\|
1420	((Py_SIZE(self) + n) > PY_SSIZE_T_MAX / itemsize)) {
1421	return PyErr_NoMemory();
1422	}
1423	PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
1424	if (item == NULL) {
1425	PyErr_NoMemory();
1426	return NULL;
1427	}
1428	self->ob_item = item;
1429	Py_SIZE(self) += n;
1430	self->allocated = Py_SIZE(self);
1431	memcpy(item + (Py_SIZE(self) - n) * itemsize,
1432	str, itemsize*n);
1433	}
1434	Py_INCREF(Py_None);
1435	return Py_None;
1436	}
1437
1438	PyDoc_STRVAR(fromstring_doc,
1439	"fromstring(string)\n\
1440	\n\
1441	Appends items from the string, interpreting it as an array of machine\n\
1442	values,as if it had been read from a file using the fromfile() method).");
1443
1444
1445	static PyObject *
1446	array_tostring(arrayobject self, PyObject unused)
1447	{
1448	if (self->ob_size <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) {
1449	return PyString_FromStringAndSize(self->ob_item,
1450	Py_SIZE(self) * self->ob_descr->itemsize);
1451	} else {
1452	return PyErr_NoMemory();
1453	}
1454	}
1455
1456	PyDoc_STRVAR(tostring_doc,
1457	"tostring() -> string\n\
1458	\n\
1459	Convert the array to an array of machine values and return the string\n\
1460	representation.");
1461
1462
1463
1464	#ifdef Py_USING_UNICODE
1465	static PyObject *
1466	array_fromunicode(arrayobject self, PyObject args)
1467	{
1468	Py_UNICODE *ustr;
1469	Py_ssize_t n;
1470
1471	if (!PyArg_ParseTuple(args, "u#:fromunicode", &ustr, &n))
1472	return NULL;
1473	if (self->ob_descr->typecode != 'u') {
1474	PyErr_SetString(PyExc_ValueError,
1475	"fromunicode() may only be called on "
1476	"type 'u' arrays");
1477	return NULL;
1478	}
1479	if (n > 0) {
1480	Py_UNICODE item = (Py_UNICODE ) self->ob_item;
1481	if (Py_SIZE(self) > PY_SSIZE_T_MAX - n) {
1482	return PyErr_NoMemory();
1483	}
1484	PyMem_RESIZE(item, Py_UNICODE, Py_SIZE(self) + n);
1485	if (item == NULL) {
1486	PyErr_NoMemory();
1487	return NULL;
1488	}
1489	self->ob_item = (char *) item;
1490	Py_SIZE(self) += n;
1491	self->allocated = Py_SIZE(self);
1492	memcpy(item + Py_SIZE(self) - n,
1493	ustr, n * sizeof(Py_UNICODE));
1494	}
1495
1496	Py_INCREF(Py_None);
1497	return Py_None;
1498	}
1499
1500	PyDoc_STRVAR(fromunicode_doc,
1501	"fromunicode(ustr)\n\
1502	\n\
1503	Extends this array with data from the unicode string ustr.\n\
1504	The array must be a type 'u' array; otherwise a ValueError\n\
1505	is raised. Use array.fromstring(ustr.decode(...)) to\n\
1506	append Unicode data to an array of some other type.");
1507
1508
1509	static PyObject *
1510	array_tounicode(arrayobject self, PyObject unused)
1511	{
1512	if (self->ob_descr->typecode != 'u') {
1513	PyErr_SetString(PyExc_ValueError,
1514	"tounicode() may only be called on type 'u' arrays");
1515	return NULL;
1516	}
1517	return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self));
1518	}
1519
1520	PyDoc_STRVAR(tounicode_doc,
1521	"tounicode() -> unicode\n\
1522	\n\
1523	Convert the array to a unicode string. The array must be\n\
1524	a type 'u' array; otherwise a ValueError is raised. Use\n\
1525	array.tostring().decode() to obtain a unicode string from\n\
1526	an array of some other type.");
1527
1528	#endif /* Py_USING_UNICODE */
1529
1530
1531	static PyObject *
1532	array_get_typecode(arrayobject a, void closure)
1533	{
1534	char tc = a->ob_descr->typecode;
1535	return PyString_FromStringAndSize(&tc, 1);
1536	}
1537
1538	static PyObject *
1539	array_get_itemsize(arrayobject a, void closure)
1540	{
1541	return PyInt_FromLong((long)a->ob_descr->itemsize);
1542	}
1543
1544	static PyGetSetDef array_getsets [] = {
1545	{"typecode", (getter) array_get_typecode, NULL,
1546	"the typecode character used to create the array"},
1547	{"itemsize", (getter) array_get_itemsize, NULL,
1548	"the size, in bytes, of one array item"},
1549	{NULL}
1550	};
1551
1552	static PyMethodDef array_methods[] = {
1553	{"append", (PyCFunction)array_append, METH_O,
1554	append_doc},
1555	{"buffer_info", (PyCFunction)array_buffer_info, METH_NOARGS,
1556	buffer_info_doc},
1557	{"byteswap", (PyCFunction)array_byteswap, METH_NOARGS,
1558	byteswap_doc},
1559	{"__copy__", (PyCFunction)array_copy, METH_NOARGS,
1560	copy_doc},
1561	{"count", (PyCFunction)array_count, METH_O,
1562	count_doc},
1563	{"__deepcopy__",(PyCFunction)array_copy, METH_O,
1564	copy_doc},
1565	{"extend", (PyCFunction)array_extend, METH_O,
1566	extend_doc},
1567	{"fromfile", (PyCFunction)array_fromfile, METH_VARARGS,
1568	fromfile_doc},
1569	{"fromlist", (PyCFunction)array_fromlist, METH_O,
1570	fromlist_doc},
1571	{"fromstring", (PyCFunction)array_fromstring, METH_VARARGS,
1572	fromstring_doc},
1573	#ifdef Py_USING_UNICODE
1574	{"fromunicode", (PyCFunction)array_fromunicode, METH_VARARGS,
1575	fromunicode_doc},
1576	#endif
1577	{"index", (PyCFunction)array_index, METH_O,
1578	index_doc},
1579	{"insert", (PyCFunction)array_insert, METH_VARARGS,
1580	insert_doc},
1581	{"pop", (PyCFunction)array_pop, METH_VARARGS,
1582	pop_doc},
1583	{"read", (PyCFunction)array_fromfile_as_read, METH_VARARGS,
1584	fromfile_doc},
1585	{"__reduce__", (PyCFunction)array_reduce, METH_NOARGS,
1586	array_doc},
1587	{"remove", (PyCFunction)array_remove, METH_O,
1588	remove_doc},
1589	{"reverse", (PyCFunction)array_reverse, METH_NOARGS,
1590	reverse_doc},
1591	/* {"sort", (PyCFunction)array_sort, METH_VARARGS,
1592	sort_doc},*/
1593	{"tofile", (PyCFunction)array_tofile, METH_O,
1594	tofile_doc},
1595	{"tolist", (PyCFunction)array_tolist, METH_NOARGS,
1596	tolist_doc},
1597	{"tostring", (PyCFunction)array_tostring, METH_NOARGS,
1598	tostring_doc},
1599	#ifdef Py_USING_UNICODE
1600	{"tounicode", (PyCFunction)array_tounicode, METH_NOARGS,
1601	tounicode_doc},
1602	#endif
1603	{"write", (PyCFunction)array_tofile_as_write, METH_O,
1604	tofile_doc},
1605	{NULL, NULL} /* sentinel */
1606	};
1607
1608	static PyObject *
1609	array_repr(arrayobject *a)
1610	{
1611	char buf[256], typecode;
1612	PyObject s, t, *v = NULL;
1613	Py_ssize_t len;
1614
1615	len = Py_SIZE(a);
1616	typecode = a->ob_descr->typecode;
1617	if (len == 0) {
1618	PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
1619	return PyString_FromString(buf);
1620	}
1621
1622	if (typecode == 'c')
1623	v = array_tostring(a, NULL);
1624	#ifdef Py_USING_UNICODE
1625	else if (typecode == 'u')
1626	v = array_tounicode(a, NULL);
1627	#endif
1628	else
1629	v = array_tolist(a, NULL);
1630	t = PyObject_Repr(v);
1631	Py_XDECREF(v);
1632
1633	PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode);
1634	s = PyString_FromString(buf);
1635	PyString_ConcatAndDel(&s, t);
1636	PyString_ConcatAndDel(&s, PyString_FromString(")"));
1637	return s;
1638	}
1639
1640	static PyObject*
1641	array_subscr(arrayobject* self, PyObject* item)
1642	{
1643	if (PyIndex_Check(item)) {
1644	Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1645	if (i==-1 && PyErr_Occurred()) {
1646	return NULL;
1647	}
1648	if (i < 0)
1649	i += Py_SIZE(self);
1650	return array_item(self, i);
1651	}
1652	else if (PySlice_Check(item)) {
1653	Py_ssize_t start, stop, step, slicelength, cur, i;
1654	PyObject* result;
1655	arrayobject* ar;
1656	int itemsize = self->ob_descr->itemsize;
1657
1658	if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
1659	&start, &stop, &step, &slicelength) < 0) {
1660	return NULL;
1661	}
1662
1663	if (slicelength <= 0) {
1664	return newarrayobject(&Arraytype, 0, self->ob_descr);
1665	}
1666	else if (step == 1) {
1667	PyObject *result = newarrayobject(&Arraytype,
1668	slicelength, self->ob_descr);
1669	if (result == NULL)
1670	return NULL;
1671	memcpy(((arrayobject *)result)->ob_item,
1672	self->ob_item + start * itemsize,
1673	slicelength * itemsize);
1674	return result;
1675	}
1676	else {
1677	result = newarrayobject(&Arraytype, slicelength, self->ob_descr);
1678	if (!result) return NULL;
1679
1680	ar = (arrayobject*)result;
1681
1682	for (cur = start, i = 0; i < slicelength;
1683	cur += step, i++) {
1684	memcpy(ar->ob_item + i*itemsize,
1685	self->ob_item + cur*itemsize,
1686	itemsize);
1687	}
1688
1689	return result;
1690	}
1691	}
1692	else {
1693	PyErr_SetString(PyExc_TypeError,
1694	"array indices must be integers");
1695	return NULL;
1696	}
1697	}
1698
1699	static int
1700	array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
1701	{
1702	Py_ssize_t start, stop, step, slicelength, needed;
1703	arrayobject* other;
1704	int itemsize;
1705
1706	if (PyIndex_Check(item)) {
1707	Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1708
1709	if (i == -1 && PyErr_Occurred())
1710	return -1;
1711	if (i < 0)
1712	i += Py_SIZE(self);
1713	if (i < 0 \|\| i >= Py_SIZE(self)) {
1714	PyErr_SetString(PyExc_IndexError,
1715	"array assignment index out of range");
1716	return -1;
1717	}
1718	if (value == NULL) {
1719	/* Fall through to slice assignment */
1720	start = i;
1721	stop = i + 1;
1722	step = 1;
1723	slicelength = 1;
1724	}
1725	else
1726	return (*self->ob_descr->setitem)(self, i, value);
1727	}
1728	else if (PySlice_Check(item)) {
1729	if (PySlice_GetIndicesEx((PySliceObject *)item,
1730	Py_SIZE(self), &start, &stop,
1731	&step, &slicelength) < 0) {
1732	return -1;
1733	}
1734	}
1735	else {
1736	PyErr_SetString(PyExc_TypeError,
1737	"array indices must be integer");
1738	return -1;
1739	}
1740	if (value == NULL) {
1741	other = NULL;
1742	needed = 0;
1743	}
1744	else if (array_Check(value)) {
1745	other = (arrayobject *)value;
1746	needed = Py_SIZE(other);
1747	if (self == other) {
1748	/* Special case "self[i:j] = self" -- copy self first */
1749	int ret;
1750	value = array_slice(other, 0, needed);
1751	if (value == NULL)
1752	return -1;
1753	ret = array_ass_subscr(self, item, value);
1754	Py_DECREF(value);
1755	return ret;
1756	}
1757	if (other->ob_descr != self->ob_descr) {
1758	PyErr_BadArgument();
1759	return -1;
1760	}
1761	}
1762	else {
1763	PyErr_Format(PyExc_TypeError,
1764	"can only assign array (not \"%.200s\") to array slice",
1765	Py_TYPE(value)->tp_name);
1766	return -1;
1767	}
1768	itemsize = self->ob_descr->itemsize;
1769	/* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
1770	if ((step > 0 && stop < start) \|\|
1771	(step < 0 && stop > start))
1772	stop = start;
1773	if (step == 1) {
1774	if (slicelength > needed) {
1775	memmove(self->ob_item + (start + needed) * itemsize,
1776	self->ob_item + stop * itemsize,
1777	(Py_SIZE(self) - stop) * itemsize);
1778	if (array_resize(self, Py_SIZE(self) +
1779	needed - slicelength) < 0)
1780	return -1;
1781	}
1782	else if (slicelength < needed) {
1783	if (array_resize(self, Py_SIZE(self) +
1784	needed - slicelength) < 0)
1785	return -1;
1786	memmove(self->ob_item + (start + needed) * itemsize,
1787	self->ob_item + stop * itemsize,
1788	(Py_SIZE(self) - start - needed) * itemsize);
1789	}
1790	if (needed > 0)
1791	memcpy(self->ob_item + start * itemsize,
1792	other->ob_item, needed * itemsize);
1793	return 0;
1794	}
1795	else if (needed == 0) {
1796	/* Delete slice */
1797	size_t cur;
1798	Py_ssize_t i;
1799
1800	if (step < 0) {
1801	stop = start + 1;
1802	start = stop + step * (slicelength - 1) - 1;
1803	step = -step;
1804	}
1805	for (cur = start, i = 0; i < slicelength;
1806	cur += step, i++) {
1807	Py_ssize_t lim = step - 1;
1808
1809	if (cur + step >= (size_t)Py_SIZE(self))
1810	lim = Py_SIZE(self) - cur - 1;
1811	memmove(self->ob_item + (cur - i) * itemsize,
1812	self->ob_item + (cur + 1) * itemsize,
1813	lim * itemsize);
1814	}
1815	cur = start + slicelength * step;
1816	if (cur < (size_t)Py_SIZE(self)) {
1817	memmove(self->ob_item + (cur-slicelength) * itemsize,
1818	self->ob_item + cur * itemsize,
1819	(Py_SIZE(self) - cur) * itemsize);
1820	}
1821	if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
1822	return -1;
1823	return 0;
1824	}
1825	else {
1826	Py_ssize_t cur, i;
1827
1828	if (needed != slicelength) {
1829	PyErr_Format(PyExc_ValueError,
1830	"attempt to assign array of size %zd "
1831	"to extended slice of size %zd",
1832	needed, slicelength);
1833	return -1;
1834	}
1835	for (cur = start, i = 0; i < slicelength;
1836	cur += step, i++) {
1837	memcpy(self->ob_item + cur * itemsize,
1838	other->ob_item + i * itemsize,
1839	itemsize);
1840	}
1841	return 0;
1842	}
1843	}
1844
1845	static PyMappingMethods array_as_mapping = {
1846	(lenfunc)array_length,
1847	(binaryfunc)array_subscr,
1848	(objobjargproc)array_ass_subscr
1849	};
1850
1851	static const void *emptybuf = "";
1852
1853	static Py_ssize_t
1854	array_buffer_getreadbuf(arrayobject self, Py_ssize_t index, const void *ptr)
1855	{
1856	if ( index != 0 ) {
1857	PyErr_SetString(PyExc_SystemError,
1858	"Accessing non-existent array segment");
1859	return -1;
1860	}
1861	ptr = (void )self->ob_item;
1862	if (*ptr == NULL)
1863	*ptr = emptybuf;
1864	return Py_SIZE(self)*self->ob_descr->itemsize;
1865	}
1866
1867	static Py_ssize_t
1868	array_buffer_getwritebuf(arrayobject self, Py_ssize_t index, const void *ptr)
1869	{
1870	if ( index != 0 ) {
1871	PyErr_SetString(PyExc_SystemError,
1872	"Accessing non-existent array segment");
1873	return -1;
1874	}
1875	ptr = (void )self->ob_item;
1876	if (*ptr == NULL)
1877	*ptr = emptybuf;
1878	return Py_SIZE(self)*self->ob_descr->itemsize;
1879	}
1880
1881	static Py_ssize_t
1882	array_buffer_getsegcount(arrayobject self, Py_ssize_t lenp)
1883	{
1884	if ( lenp )
1885	lenp = Py_SIZE(self)self->ob_descr->itemsize;
1886	return 1;
1887	}
1888
1889	static PySequenceMethods array_as_sequence = {
1890	(lenfunc)array_length, /sq_length/
1891	(binaryfunc)array_concat, /sq_concat/
1892	(ssizeargfunc)array_repeat, /sq_repeat/
1893	(ssizeargfunc)array_item, /sq_item/
1894	(ssizessizeargfunc)array_slice, /sq_slice/
1895	(ssizeobjargproc)array_ass_item, /sq_ass_item/
1896	(ssizessizeobjargproc)array_ass_slice, /sq_ass_slice/
1897	(objobjproc)array_contains, /sq_contains/
1898	(binaryfunc)array_inplace_concat, /sq_inplace_concat/
1899	(ssizeargfunc)array_inplace_repeat /sq_inplace_repeat/
1900	};
1901
1902	static PyBufferProcs array_as_buffer = {
1903	(readbufferproc)array_buffer_getreadbuf,
1904	(writebufferproc)array_buffer_getwritebuf,
1905	(segcountproc)array_buffer_getsegcount,
1906	NULL,
1907	};
1908
1909	static PyObject *
1910	array_new(PyTypeObject type, PyObject args, PyObject *kwds)
1911	{
1912	char c;
1913	PyObject initial = NULL, it = NULL;
1914	struct arraydescr *descr;
1915
1916	if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds))
1917	return NULL;
1918
1919	if (!PyArg_ParseTuple(args, "c\|O:array", &c, &initial))
1920	return NULL;
1921
1922	if (!(initial == NULL \|\| PyList_Check(initial)
1923	\|\| PyString_Check(initial) \|\| PyTuple_Check(initial)
1924	\|\| (c == 'u' && PyUnicode_Check(initial)))) {
1925	it = PyObject_GetIter(initial);
1926	if (it == NULL)
1927	return NULL;
1928	/* We set initial to NULL so that the subsequent code
1929	will create an empty array of the appropriate type
1930	and afterwards we can use array_iter_extend to populate
1931	the array.
1932	*/
1933	initial = NULL;
1934	}
1935	for (descr = descriptors; descr->typecode != '\0'; descr++) {
1936	if (descr->typecode == c) {
1937	PyObject *a;
1938	Py_ssize_t len;
1939
1940	if (initial == NULL \|\| !(PyList_Check(initial)
1941	\|\| PyTuple_Check(initial)))
1942	len = 0;
1943	else
1944	len = PySequence_Size(initial);
1945
1946	a = newarrayobject(type, len, descr);
1947	if (a == NULL)
1948	return NULL;
1949
1950	if (len > 0) {
1951	Py_ssize_t i;
1952	for (i = 0; i < len; i++) {
1953	PyObject *v =
1954	PySequence_GetItem(initial, i);
1955	if (v == NULL) {
1956	Py_DECREF(a);
1957	return NULL;
1958	}
1959	if (setarrayitem(a, i, v) != 0) {
1960	Py_DECREF(v);
1961	Py_DECREF(a);
1962	return NULL;
1963	}
1964	Py_DECREF(v);
1965	}
1966	} else if (initial != NULL && PyString_Check(initial)) {
1967	PyObject t_initial, v;
1968	t_initial = PyTuple_Pack(1, initial);
1969	if (t_initial == NULL) {
1970	Py_DECREF(a);
1971	return NULL;
1972	}
1973	v = array_fromstring((arrayobject *)a,
1974	t_initial);
1975	Py_DECREF(t_initial);
1976	if (v == NULL) {
1977	Py_DECREF(a);
1978	return NULL;
1979	}
1980	Py_DECREF(v);
1981	#ifdef Py_USING_UNICODE
1982	} else if (initial != NULL && PyUnicode_Check(initial)) {
1983	Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial);
1984	if (n > 0) {
1985	arrayobject self = (arrayobject )a;
1986	char *item = self->ob_item;
1987	item = (char *)PyMem_Realloc(item, n);
1988	if (item == NULL) {
1989	PyErr_NoMemory();
1990	Py_DECREF(a);
1991	return NULL;
1992	}
1993	self->ob_item = item;
1994	Py_SIZE(self) = n / sizeof(Py_UNICODE);
1995	memcpy(item, PyUnicode_AS_DATA(initial), n);
1996	self->allocated = Py_SIZE(self);
1997	}
1998	#endif
1999	}
2000	if (it != NULL) {
2001	if (array_iter_extend((arrayobject *)a, it) == -1) {
2002	Py_DECREF(it);
2003	Py_DECREF(a);
2004	return NULL;
2005	}
2006	Py_DECREF(it);
2007	}
2008	return a;
2009	}
2010	}
2011	PyErr_SetString(PyExc_ValueError,
2012	"bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)");
2013	return NULL;
2014	}
2015
2016
2017	PyDoc_STRVAR(module_doc,
2018	"This module defines an object type which can efficiently represent\n\
2019	an array of basic values: characters, integers, floating point\n\
2020	numbers. Arrays are sequence types and behave very much like lists,\n\
2021	except that the type of objects stored in them is constrained. The\n\
2022	type is specified at object creation time by using a type code, which\n\
2023	is a single character. The following type codes are defined:\n\
2024	\n\
2025	Type code C Type Minimum size in bytes \n\
2026	'c' character 1 \n\
2027	'b' signed integer 1 \n\
2028	'B' unsigned integer 1 \n\
2029	'u' Unicode character 2 \n\
2030	'h' signed integer 2 \n\
2031	'H' unsigned integer 2 \n\
2032	'i' signed integer 2 \n\
2033	'I' unsigned integer 2 \n\
2034	'l' signed integer 4 \n\
2035	'L' unsigned integer 4 \n\
2036	'f' floating point 4 \n\
2037	'd' floating point 8 \n\
2038	\n\
2039	The constructor is:\n\
2040	\n\
2041	array(typecode [, initializer]) -- create a new array\n\
2042	");
2043
2044	PyDoc_STRVAR(arraytype_doc,
2045	"array(typecode [, initializer]) -> array\n\
2046	\n\
2047	Return a new array whose items are restricted by typecode, and\n\
2048	initialized from the optional initializer value, which must be a list,\n\
2049	string. or iterable over elements of the appropriate type.\n\
2050	\n\
2051	Arrays represent basic values and behave very much like lists, except\n\
2052	the type of objects stored in them is constrained.\n\
2053	\n\
2054	Methods:\n\
2055	\n\
2056	append() -- append a new item to the end of the array\n\
2057	buffer_info() -- return information giving the current memory info\n\
2058	byteswap() -- byteswap all the items of the array\n\
2059	count() -- return number of occurrences of an object\n\
2060	extend() -- extend array by appending multiple elements from an iterable\n\
2061	fromfile() -- read items from a file object\n\
2062	fromlist() -- append items from the list\n\
2063	fromstring() -- append items from the string\n\
2064	index() -- return index of first occurrence of an object\n\
2065	insert() -- insert a new item into the array at a provided position\n\
2066	pop() -- remove and return item (default last)\n\
2067	read() -- DEPRECATED, use fromfile()\n\
2068	remove() -- remove first occurrence of an object\n\
2069	reverse() -- reverse the order of the items in the array\n\
2070	tofile() -- write all items to a file object\n\
2071	tolist() -- return the array converted to an ordinary list\n\
2072	tostring() -- return the array converted to a string\n\
2073	write() -- DEPRECATED, use tofile()\n\
2074	\n\
2075	Attributes:\n\
2076	\n\
2077	typecode -- the typecode character used to create the array\n\
2078	itemsize -- the length in bytes of one array item\n\
2079	");
2080
2081	static PyObject array_iter(arrayobject ao);
2082
2083	static PyTypeObject Arraytype = {
2084	PyVarObject_HEAD_INIT(NULL, 0)
2085	"array.array",
2086	sizeof(arrayobject),
2087	0,
2088	(destructor)array_dealloc, /* tp_dealloc */
2089	0, /* tp_print */
2090	0, /* tp_getattr */
2091	0, /* tp_setattr */
2092	0, /* tp_compare */
2093	(reprfunc)array_repr, /* tp_repr */
2094	0, /* tp_as_number*/
2095	&array_as_sequence, /* tp_as_sequence*/
2096	&array_as_mapping, /* tp_as_mapping*/
2097	0, /* tp_hash */
2098	0, /* tp_call */
2099	0, /* tp_str */
2100	PyObject_GenericGetAttr, /* tp_getattro */
2101	0, /* tp_setattro */
2102	&array_as_buffer, /* tp_as_buffer*/
2103	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE \| Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
2104	arraytype_doc, /* tp_doc */
2105	0, /* tp_traverse */
2106	0, /* tp_clear */
2107	array_richcompare, /* tp_richcompare */
2108	offsetof(arrayobject, weakreflist), /* tp_weaklistoffset */
2109	(getiterfunc)array_iter, /* tp_iter */
2110	0, /* tp_iternext */
2111	array_methods, /* tp_methods */
2112	0, /* tp_members */
2113	array_getsets, /* tp_getset */
2114	0, /* tp_base */
2115	0, /* tp_dict */
2116	0, /* tp_descr_get */
2117	0, /* tp_descr_set */
2118	0, /* tp_dictoffset */
2119	0, /* tp_init */
2120	PyType_GenericAlloc, /* tp_alloc */
2121	array_new, /* tp_new */
2122	PyObject_Del, /* tp_free */
2123	};
2124
2125
2126	/********************* Array Iterator ************************/
2127
2128	typedef struct {
2129	PyObject_HEAD
2130	Py_ssize_t index;
2131	arrayobject *ao;
2132	PyObject * (getitem)(struct arrayobject , Py_ssize_t);
2133	} arrayiterobject;
2134
2135	static PyTypeObject PyArrayIter_Type;
2136
2137	#define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type)
2138
2139	static PyObject *
2140	array_iter(arrayobject *ao)
2141	{
2142	arrayiterobject *it;
2143
2144	if (!array_Check(ao)) {
2145	PyErr_BadInternalCall();
2146	return NULL;
2147	}
2148
2149	it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type);
2150	if (it == NULL)
2151	return NULL;
2152
2153	Py_INCREF(ao);
2154	it->ao = ao;
2155	it->index = 0;
2156	it->getitem = ao->ob_descr->getitem;
2157	PyObject_GC_Track(it);
2158	return (PyObject *)it;
2159	}
2160
2161	static PyObject *
2162	arrayiter_next(arrayiterobject *it)
2163	{
2164	assert(PyArrayIter_Check(it));
2165	if (it->index < Py_SIZE(it->ao))
2166	return (*it->getitem)(it->ao, it->index++);
2167	return NULL;
2168	}
2169
2170	static void
2171	arrayiter_dealloc(arrayiterobject *it)
2172	{
2173	PyObject_GC_UnTrack(it);
2174	Py_XDECREF(it->ao);
2175	PyObject_GC_Del(it);
2176	}
2177
2178	static int
2179	arrayiter_traverse(arrayiterobject it, visitproc visit, void arg)
2180	{
2181	Py_VISIT(it->ao);
2182	return 0;
2183	}
2184
2185	static PyTypeObject PyArrayIter_Type = {
2186	PyVarObject_HEAD_INIT(NULL, 0)
2187	"arrayiterator", /* tp_name */
2188	sizeof(arrayiterobject), /* tp_basicsize */
2189	0, /* tp_itemsize */
2190	/* methods */
2191	(destructor)arrayiter_dealloc, /* tp_dealloc */
2192	0, /* tp_print */
2193	0, /* tp_getattr */
2194	0, /* tp_setattr */
2195	0, /* tp_compare */
2196	0, /* tp_repr */
2197	0, /* tp_as_number */
2198	0, /* tp_as_sequence */
2199	0, /* tp_as_mapping */
2200	0, /* tp_hash */
2201	0, /* tp_call */
2202	0, /* tp_str */
2203	PyObject_GenericGetAttr, /* tp_getattro */
2204	0, /* tp_setattro */
2205	0, /* tp_as_buffer */
2206	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC,/* tp_flags */
2207	0, /* tp_doc */
2208	(traverseproc)arrayiter_traverse, /* tp_traverse */
2209	0, /* tp_clear */
2210	0, /* tp_richcompare */
2211	0, /* tp_weaklistoffset */
2212	PyObject_SelfIter, /* tp_iter */
2213	(iternextfunc)arrayiter_next, /* tp_iternext */
2214	0, /* tp_methods */
2215	};
2216
2217
2218	/********************* Install Module ************************/
2219
2220	/* No functions in array module. */
2221	static PyMethodDef a_methods[] = {
2222	{NULL, NULL, 0, NULL} /* Sentinel */
2223	};
2224
2225
2226	PyMODINIT_FUNC
2227	initarray(void)
2228	{
2229	PyObject *m;
2230
2231	Arraytype.ob_type = &PyType_Type;
2232	PyArrayIter_Type.ob_type = &PyType_Type;
2233	m = Py_InitModule3("array", a_methods, module_doc);
2234	if (m == NULL)
2235	return;
2236
2237	Py_INCREF((PyObject *)&Arraytype);
2238	PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype);
2239	Py_INCREF((PyObject *)&Arraytype);
2240	PyModule_AddObject(m, "array", (PyObject *)&Arraytype);
2241	/* No need to check the error here, the caller will do that */
2242	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: python/trunk/Modules/arraymodule.c@ 388

Download in other formats: