add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Modules/arraymodule.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Modules/arraymodule.c+2141−0

@@ -0,0 +1,2141 @@
	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) ((op)->ob_type == &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	self->ob_size < newsize + 16 &&
	57	self->ob_item != NULL) {
	58	self->ob_size = 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) + (self->ob_size < 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	self->ob_size = 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_size = size;
	436	if (size <= 0) {
	437	op->ob_item = NULL;
	438	}
	439	else {
	440	op->ob_item = PyMem_NEW(char, nbytes);
	441	if (op->ob_item == NULL) {
	442	PyObject_Del(op);
	443	return PyErr_NoMemory();
	444	}
	445	}
	446	op->ob_descr = descr;
	447	op->allocated = size;
	448	op->weakreflist = NULL;
	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<ap->ob_size);
	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 = self->ob_size;
	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	op->ob_type->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 (va->ob_size != wa->ob_size && (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 < va->ob_size && i < wa->ob_size; 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 = va->ob_size;
	553	Py_ssize_t ws = wa->ob_size;
	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 a->ob_size;
	594	}
	595
	596	static PyObject *
	597	array_item(arrayobject *a, Py_ssize_t i)
	598	{
	599	if (i < 0 \|\| i >= a->ob_size) {
	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 > a->ob_size)
	613	ilow = a->ob_size;
	614	if (ihigh < 0)
	615	ihigh = 0;
	616	if (ihigh < ilow)
	617	ihigh = ilow;
	618	else if (ihigh > a->ob_size)
	619	ihigh = a->ob_size;
	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, a->ob_size);
	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	bb->ob_type->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	size = a->ob_size + b->ob_size;
	656	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
	657	if (np == NULL) {
	658	return NULL;
	659	}
	660	memcpy(np->ob_item, a->ob_item, a->ob_size*a->ob_descr->itemsize);
	661	memcpy(np->ob_item + a->ob_size*a->ob_descr->itemsize,
	662	b->ob_item, b->ob_size*b->ob_descr->itemsize);
	663	return (PyObject *)np;
	664	#undef b
	665	}
	666
	667	static PyObject *
	668	array_repeat(arrayobject *a, Py_ssize_t n)
	669	{
	670	Py_ssize_t i;
	671	Py_ssize_t size;
	672	arrayobject *np;
	673	char *p;
	674	Py_ssize_t nbytes;
	675	if (n < 0)
	676	n = 0;
	677	size = a->ob_size * n;
	678	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);
	679	if (np == NULL)
	680	return NULL;
	681	p = np->ob_item;
	682	nbytes = a->ob_size * a->ob_descr->itemsize;
	683	for (i = 0; i < n; i++) {
	684	memcpy(p, a->ob_item, nbytes);
	685	p += nbytes;
	686	}
	687	return (PyObject *) np;
	688	}
	689
	690	static int
	691	array_ass_slice(arrayobject a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject v)
	692	{
	693	char *item;
	694	Py_ssize_t n; /* Size of replacement array */
	695	Py_ssize_t d; /* Change in size */
	696	#define b ((arrayobject *)v)
	697	if (v == NULL)
	698	n = 0;
	699	else if (array_Check(v)) {
	700	n = b->ob_size;
	701	if (a == b) {
	702	/* Special case "a[i:j] = a" -- copy b first */
	703	int ret;
	704	v = array_slice(b, 0, n);
	705	if (!v)
	706	return -1;
	707	ret = array_ass_slice(a, ilow, ihigh, v);
	708	Py_DECREF(v);
	709	return ret;
	710	}
	711	if (b->ob_descr != a->ob_descr) {
	712	PyErr_BadArgument();
	713	return -1;
	714	}
	715	}
	716	else {
	717	PyErr_Format(PyExc_TypeError,
	718	"can only assign array (not \"%.200s\") to array slice",
	719	v->ob_type->tp_name);
	720	return -1;
	721	}
	722	if (ilow < 0)
	723	ilow = 0;
	724	else if (ilow > a->ob_size)
	725	ilow = a->ob_size;
	726	if (ihigh < 0)
	727	ihigh = 0;
	728	if (ihigh < ilow)
	729	ihigh = ilow;
	730	else if (ihigh > a->ob_size)
	731	ihigh = a->ob_size;
	732	item = a->ob_item;
	733	d = n - (ihigh-ilow);
	734	if (d < 0) { /* Delete -d items */
	735	memmove(item + (ihigh+d)*a->ob_descr->itemsize,
	736	item + ihigh*a->ob_descr->itemsize,
	737	(a->ob_size-ihigh)*a->ob_descr->itemsize);
	738	a->ob_size += d;
	739	PyMem_RESIZE(item, char, a->ob_size*a->ob_descr->itemsize);
	740	/* Can't fail */
	741	a->ob_item = item;
	742	a->allocated = a->ob_size;
	743	}
	744	else if (d > 0) { /* Insert d items */
	745	PyMem_RESIZE(item, char,
	746	(a->ob_size + d)*a->ob_descr->itemsize);
	747	if (item == NULL) {
	748	PyErr_NoMemory();
	749	return -1;
	750	}
	751	memmove(item + (ihigh+d)*a->ob_descr->itemsize,
	752	item + ihigh*a->ob_descr->itemsize,
	753	(a->ob_size-ihigh)*a->ob_descr->itemsize);
	754	a->ob_item = item;
	755	a->ob_size += d;
	756	a->allocated = a->ob_size;
	757	}
	758	if (n > 0)
	759	memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,
	760	n*b->ob_descr->itemsize);
	761	return 0;
	762	#undef b
	763	}
	764
	765	static int
	766	array_ass_item(arrayobject a, Py_ssize_t i, PyObject v)
	767	{
	768	if (i < 0 \|\| i >= a->ob_size) {
	769	PyErr_SetString(PyExc_IndexError,
	770	"array assignment index out of range");
	771	return -1;
	772	}
	773	if (v == NULL)
	774	return array_ass_slice(a, i, i+1, v);
	775	return (*a->ob_descr->setitem)(a, i, v);
	776	}
	777
	778	static int
	779	setarrayitem(PyObject a, Py_ssize_t i, PyObject v)
	780	{
	781	assert(array_Check(a));
	782	return array_ass_item((arrayobject *)a, i, v);
	783	}
	784
	785	static int
	786	array_iter_extend(arrayobject self, PyObject bb)
	787	{
	788	PyObject it, v;
	789
	790	it = PyObject_GetIter(bb);
	791	if (it == NULL)
	792	return -1;
	793
	794	while ((v = PyIter_Next(it)) != NULL) {
	795	if (ins1(self, (int) self->ob_size, v) != 0) {
	796	Py_DECREF(v);
	797	Py_DECREF(it);
	798	return -1;
	799	}
	800	Py_DECREF(v);
	801	}
	802	Py_DECREF(it);
	803	if (PyErr_Occurred())
	804	return -1;
	805	return 0;
	806	}
	807
	808	static int
	809	array_do_extend(arrayobject self, PyObject bb)
	810	{
	811	Py_ssize_t size;
	812
	813	if (!array_Check(bb))
	814	return array_iter_extend(self, bb);
	815	#define b ((arrayobject *)bb)
	816	if (self->ob_descr != b->ob_descr) {
	817	PyErr_SetString(PyExc_TypeError,
	818	"can only extend with array of same kind");
	819	return -1;
	820	}
	821	size = self->ob_size + b->ob_size;
	822	PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);
	823	if (self->ob_item == NULL) {
	824	PyObject_Del(self);
	825	PyErr_NoMemory();
	826	return -1;
	827	}
	828	memcpy(self->ob_item + self->ob_size*self->ob_descr->itemsize,
	829	b->ob_item, b->ob_size*b->ob_descr->itemsize);
	830	self->ob_size = size;
	831	self->allocated = size;
	832
	833	return 0;
	834	#undef b
	835	}
	836
	837	static PyObject *
	838	array_inplace_concat(arrayobject self, PyObject bb)
	839	{
	840	if (!array_Check(bb)) {
	841	PyErr_Format(PyExc_TypeError,
	842	"can only extend array with array (not \"%.200s\")",
	843	bb->ob_type->tp_name);
	844	return NULL;
	845	}
	846	if (array_do_extend(self, bb) == -1)
	847	return NULL;
	848	Py_INCREF(self);
	849	return (PyObject *)self;
	850	}
	851
	852	static PyObject *
	853	array_inplace_repeat(arrayobject *self, Py_ssize_t n)
	854	{
	855	char items, p;
	856	Py_ssize_t size, i;
	857
	858	if (self->ob_size > 0) {
	859	if (n < 0)
	860	n = 0;
	861	items = self->ob_item;
	862	size = self->ob_size * self->ob_descr->itemsize;
	863	if (n == 0) {
	864	PyMem_FREE(items);
	865	self->ob_item = NULL;
	866	self->ob_size = 0;
	867	self->allocated = 0;
	868	}
	869	else {
	870	PyMem_Resize(items, char, n * size);
	871	if (items == NULL)
	872	return PyErr_NoMemory();
	873	p = items;
	874	for (i = 1; i < n; i++) {
	875	p += size;
	876	memcpy(p, items, size);
	877	}
	878	self->ob_item = items;
	879	self->ob_size *= n;
	880	self->allocated = self->ob_size;
	881	}
	882	}
	883	Py_INCREF(self);
	884	return (PyObject *)self;
	885	}
	886
	887
	888	static PyObject *
	889	ins(arrayobject self, Py_ssize_t where, PyObject v)
	890	{
	891	if (ins1(self, where, v) != 0)
	892	return NULL;
	893	Py_INCREF(Py_None);
	894	return Py_None;
	895	}
	896
	897	static PyObject *
	898	array_count(arrayobject self, PyObject v)
	899	{
	900	Py_ssize_t count = 0;
	901	Py_ssize_t i;
	902
	903	for (i = 0; i < self->ob_size; i++) {
	904	PyObject selfi = getarrayitem((PyObject )self, i);
	905	int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
	906	Py_DECREF(selfi);
	907	if (cmp > 0)
	908	count++;
	909	else if (cmp < 0)
	910	return NULL;
	911	}
	912	return PyInt_FromSsize_t(count);
	913	}
	914
	915	PyDoc_STRVAR(count_doc,
	916	"count(x)\n\
	917	\n\
	918	Return number of occurences of x in the array.");
	919
	920	static PyObject *
	921	array_index(arrayobject self, PyObject v)
	922	{
	923	Py_ssize_t i;
	924
	925	for (i = 0; i < self->ob_size; i++) {
	926	PyObject selfi = getarrayitem((PyObject )self, i);
	927	int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
	928	Py_DECREF(selfi);
	929	if (cmp > 0) {
	930	return PyInt_FromLong((long)i);
	931	}
	932	else if (cmp < 0)
	933	return NULL;
	934	}
	935	PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list");
	936	return NULL;
	937	}
	938
	939	PyDoc_STRVAR(index_doc,
	940	"index(x)\n\
	941	\n\
	942	Return index of first occurence of x in the array.");
	943
	944	static int
	945	array_contains(arrayobject self, PyObject v)
	946	{
	947	Py_ssize_t i;
	948	int cmp;
	949
	950	for (i = 0, cmp = 0 ; cmp == 0 && i < self->ob_size; i++) {
	951	PyObject selfi = getarrayitem((PyObject )self, i);
	952	cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
	953	Py_DECREF(selfi);
	954	}
	955	return cmp;
	956	}
	957
	958	static PyObject *
	959	array_remove(arrayobject self, PyObject v)
	960	{
	961	int i;
	962
	963	for (i = 0; i < self->ob_size; i++) {
	964	PyObject selfi = getarrayitem((PyObject )self,i);
	965	int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
	966	Py_DECREF(selfi);
	967	if (cmp > 0) {
	968	if (array_ass_slice(self, i, i+1,
	969	(PyObject *)NULL) != 0)
	970	return NULL;
	971	Py_INCREF(Py_None);
	972	return Py_None;
	973	}
	974	else if (cmp < 0)
	975	return NULL;
	976	}
	977	PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list");
	978	return NULL;
	979	}
	980
	981	PyDoc_STRVAR(remove_doc,
	982	"remove(x)\n\
	983	\n\
	984	Remove the first occurence of x in the array.");
	985
	986	static PyObject *
	987	array_pop(arrayobject self, PyObject args)
	988	{
	989	Py_ssize_t i = -1;
	990	PyObject *v;
	991	if (!PyArg_ParseTuple(args, "\|n:pop", &i))
	992	return NULL;
	993	if (self->ob_size == 0) {
	994	/* Special-case most common failure cause */
	995	PyErr_SetString(PyExc_IndexError, "pop from empty array");
	996	return NULL;
	997	}
	998	if (i < 0)
	999	i += self->ob_size;
	1000	if (i < 0 \|\| i >= self->ob_size) {
	1001	PyErr_SetString(PyExc_IndexError, "pop index out of range");
	1002	return NULL;
	1003	}
	1004	v = getarrayitem((PyObject *)self,i);
	1005	if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) {
	1006	Py_DECREF(v);
	1007	return NULL;
	1008	}
	1009	return v;
	1010	}
	1011
	1012	PyDoc_STRVAR(pop_doc,
	1013	"pop([i])\n\
	1014	\n\
	1015	Return the i-th element and delete it from the array. i defaults to -1.");
	1016
	1017	static PyObject *
	1018	array_extend(arrayobject self, PyObject bb)
	1019	{
	1020	if (array_do_extend(self, bb) == -1)
	1021	return NULL;
	1022	Py_INCREF(Py_None);
	1023	return Py_None;
	1024	}
	1025
	1026	PyDoc_STRVAR(extend_doc,
	1027	"extend(array or iterable)\n\
	1028	\n\
	1029	Append items to the end of the array.");
	1030
	1031	static PyObject *
	1032	array_insert(arrayobject self, PyObject args)
	1033	{
	1034	Py_ssize_t i;
	1035	PyObject *v;
	1036	if (!PyArg_ParseTuple(args, "nO:insert", &i, &v))
	1037	return NULL;
	1038	return ins(self, i, v);
	1039	}
	1040
	1041	PyDoc_STRVAR(insert_doc,
	1042	"insert(i,x)\n\
	1043	\n\
	1044	Insert a new item x into the array before position i.");
	1045
	1046
	1047	static PyObject *
	1048	array_buffer_info(arrayobject self, PyObject unused)
	1049	{
	1050	PyObject* retval = NULL;
	1051	retval = PyTuple_New(2);
	1052	if (!retval)
	1053	return NULL;
	1054
	1055	PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
	1056	PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(self->ob_size)));
	1057
	1058	return retval;
	1059	}
	1060
	1061	PyDoc_STRVAR(buffer_info_doc,
	1062	"buffer_info() -> (address, length)\n\
	1063	\n\
	1064	Return a tuple (address, length) giving the current memory address and\n\
	1065	the length in items of the buffer used to hold array's contents\n\
	1066	The length should be multiplied by the itemsize attribute to calculate\n\
	1067	the buffer length in bytes.");
	1068
	1069
	1070	static PyObject *
	1071	array_append(arrayobject self, PyObject v)
	1072	{
	1073	return ins(self, (int) self->ob_size, v);
	1074	}
	1075
	1076	PyDoc_STRVAR(append_doc,
	1077	"append(x)\n\
	1078	\n\
	1079	Append new value x to the end of the array.");
	1080
	1081
	1082	static PyObject *
	1083	array_byteswap(arrayobject self, PyObject unused)
	1084	{
	1085	char *p;
	1086	Py_ssize_t i;
	1087
	1088	switch (self->ob_descr->itemsize) {
	1089	case 1:
	1090	break;
	1091	case 2:
	1092	for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 2) {
	1093	char p0 = p[0];
	1094	p[0] = p[1];
	1095	p[1] = p0;
	1096	}
	1097	break;
	1098	case 4:
	1099	for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 4) {
	1100	char p0 = p[0];
	1101	char p1 = p[1];
	1102	p[0] = p[3];
	1103	p[1] = p[2];
	1104	p[2] = p1;
	1105	p[3] = p0;
	1106	}
	1107	break;
	1108	case 8:
	1109	for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 8) {
	1110	char p0 = p[0];
	1111	char p1 = p[1];
	1112	char p2 = p[2];
	1113	char p3 = p[3];
	1114	p[0] = p[7];
	1115	p[1] = p[6];
	1116	p[2] = p[5];
	1117	p[3] = p[4];
	1118	p[4] = p3;
	1119	p[5] = p2;
	1120	p[6] = p1;
	1121	p[7] = p0;
	1122	}
	1123	break;
	1124	default:
	1125	PyErr_SetString(PyExc_RuntimeError,
	1126	"don't know how to byteswap this array type");
	1127	return NULL;
	1128	}
	1129	Py_INCREF(Py_None);
	1130	return Py_None;
	1131	}
	1132
	1133	PyDoc_STRVAR(byteswap_doc,
	1134	"byteswap()\n\
	1135	\n\
	1136	Byteswap all items of the array. If the items in the array are not 1, 2,\n\
	1137	4, or 8 bytes in size, RuntimeError is raised.");
	1138
	1139	static PyObject *
	1140	array_reduce(arrayobject *array)
	1141	{
	1142	PyObject dict, result;
	1143
	1144	dict = PyObject_GetAttrString((PyObject *)array, "__dict__");
	1145	if (dict == NULL) {
	1146	PyErr_Clear();
	1147	dict = Py_None;
	1148	Py_INCREF(dict);
	1149	}
	1150	if (array->ob_size > 0) {
	1151	result = Py_BuildValue("O(cs#)O",
	1152	array->ob_type,
	1153	array->ob_descr->typecode,
	1154	array->ob_item,
	1155	array->ob_size * array->ob_descr->itemsize,
	1156	dict);
	1157	} else {
	1158	result = Py_BuildValue("O(c)O",
	1159	array->ob_type,
	1160	array->ob_descr->typecode,
	1161	dict);
	1162	}
	1163	Py_DECREF(dict);
	1164	return result;
	1165	}
	1166
	1167	PyDoc_STRVAR(array_doc, "Return state information for pickling.");
	1168
	1169	static PyObject *
	1170	array_reverse(arrayobject self, PyObject unused)
	1171	{
	1172	register Py_ssize_t itemsize = self->ob_descr->itemsize;
	1173	register char p, q;
	1174	/* little buffer to hold items while swapping */
	1175	char tmp[256]; /* 8 is probably enough -- but why skimp */
	1176	assert((size_t)itemsize <= sizeof(tmp));
	1177
	1178	if (self->ob_size > 1) {
	1179	for (p = self->ob_item,
	1180	q = self->ob_item + (self->ob_size - 1)*itemsize;
	1181	p < q;
	1182	p += itemsize, q -= itemsize) {
	1183	/* memory areas guaranteed disjoint, so memcpy
	1184	* is safe (& memmove may be slower).
	1185	*/
	1186	memcpy(tmp, p, itemsize);
	1187	memcpy(p, q, itemsize);
	1188	memcpy(q, tmp, itemsize);
	1189	}
	1190	}
	1191
	1192	Py_INCREF(Py_None);
	1193	return Py_None;
	1194	}
	1195
	1196	PyDoc_STRVAR(reverse_doc,
	1197	"reverse()\n\
	1198	\n\
	1199	Reverse the order of the items in the array.");
	1200
	1201	static PyObject *
	1202	array_fromfile(arrayobject self, PyObject args)
	1203	{
	1204	PyObject *f;
	1205	Py_ssize_t n;
	1206	FILE *fp;
	1207	if (!PyArg_ParseTuple(args, "On:fromfile", &f, &n))
	1208	return NULL;
	1209	fp = PyFile_AsFile(f);
	1210	if (fp == NULL) {
	1211	PyErr_SetString(PyExc_TypeError, "arg1 must be open file");
	1212	return NULL;
	1213	}
	1214	if (n > 0) {
	1215	char *item = self->ob_item;
	1216	Py_ssize_t itemsize = self->ob_descr->itemsize;
	1217	size_t nread;
	1218	Py_ssize_t newlength;
	1219	size_t newbytes;
	1220	/* Be careful here about overflow */
	1221	if ((newlength = self->ob_size + n) <= 0 \|\|
	1222	(newbytes = newlength * itemsize) / itemsize !=
	1223	(size_t)newlength)
	1224	goto nomem;
	1225	PyMem_RESIZE(item, char, newbytes);
	1226	if (item == NULL) {
	1227	nomem:
	1228	PyErr_NoMemory();
	1229	return NULL;
	1230	}
	1231	self->ob_item = item;
	1232	self->ob_size += n;
	1233	self->allocated = self->ob_size;
	1234	nread = fread(item + (self->ob_size - n) * itemsize,
	1235	itemsize, n, fp);
	1236	if (nread < (size_t)n) {
	1237	self->ob_size -= (n - nread);
	1238	PyMem_RESIZE(item, char, self->ob_size*itemsize);
	1239	self->ob_item = item;
	1240	self->allocated = self->ob_size;
	1241	PyErr_SetString(PyExc_EOFError,
	1242	"not enough items in file");
	1243	return NULL;
	1244	}
	1245	}
	1246	Py_INCREF(Py_None);
	1247	return Py_None;
	1248	}
	1249
	1250	PyDoc_STRVAR(fromfile_doc,
	1251	"fromfile(f, n)\n\
	1252	\n\
	1253	Read n objects from the file object f and append them to the end of the\n\
	1254	array. Also called as read.");
	1255
	1256
	1257	static PyObject *
	1258	array_tofile(arrayobject self, PyObject f)
	1259	{
	1260	FILE *fp;
	1261
	1262	fp = PyFile_AsFile(f);
	1263	if (fp == NULL) {
	1264	PyErr_SetString(PyExc_TypeError, "arg must be open file");
	1265	return NULL;
	1266	}
	1267	if (self->ob_size > 0) {
	1268	if (fwrite(self->ob_item, self->ob_descr->itemsize,
	1269	self->ob_size, fp) != (size_t)self->ob_size) {
	1270	PyErr_SetFromErrno(PyExc_IOError);
	1271	clearerr(fp);
	1272	return NULL;
	1273	}
	1274	}
	1275	Py_INCREF(Py_None);
	1276	return Py_None;
	1277	}
	1278
	1279	PyDoc_STRVAR(tofile_doc,
	1280	"tofile(f)\n\
	1281	\n\
	1282	Write all items (as machine values) to the file object f. Also called as\n\
	1283	write.");
	1284
	1285
	1286	static PyObject *
	1287	array_fromlist(arrayobject self, PyObject list)
	1288	{
	1289	Py_ssize_t n;
	1290	Py_ssize_t itemsize = self->ob_descr->itemsize;
	1291
	1292	if (!PyList_Check(list)) {
	1293	PyErr_SetString(PyExc_TypeError, "arg must be list");
	1294	return NULL;
	1295	}
	1296	n = PyList_Size(list);
	1297	if (n > 0) {
	1298	char *item = self->ob_item;
	1299	Py_ssize_t i;
	1300	PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize);
	1301	if (item == NULL) {
	1302	PyErr_NoMemory();
	1303	return NULL;
	1304	}
	1305	self->ob_item = item;
	1306	self->ob_size += n;
	1307	self->allocated = self->ob_size;
	1308	for (i = 0; i < n; i++) {
	1309	PyObject *v = PyList_GetItem(list, i);
	1310	if ((*self->ob_descr->setitem)(self,
	1311	self->ob_size - n + i, v) != 0) {
	1312	self->ob_size -= n;
	1313	PyMem_RESIZE(item, char,
	1314	self->ob_size * itemsize);
	1315	self->ob_item = item;
	1316	self->allocated = self->ob_size;
	1317	return NULL;
	1318	}
	1319	}
	1320	}
	1321	Py_INCREF(Py_None);
	1322	return Py_None;
	1323	}
	1324
	1325	PyDoc_STRVAR(fromlist_doc,
	1326	"fromlist(list)\n\
	1327	\n\
	1328	Append items to array from list.");
	1329
	1330
	1331	static PyObject *
	1332	array_tolist(arrayobject self, PyObject unused)
	1333	{
	1334	PyObject *list = PyList_New(self->ob_size);
	1335	Py_ssize_t i;
	1336
	1337	if (list == NULL)
	1338	return NULL;
	1339	for (i = 0; i < self->ob_size; i++) {
	1340	PyObject v = getarrayitem((PyObject )self, i);
	1341	if (v == NULL) {
	1342	Py_DECREF(list);
	1343	return NULL;
	1344	}
	1345	PyList_SetItem(list, i, v);
	1346	}
	1347	return list;
	1348	}
	1349
	1350	PyDoc_STRVAR(tolist_doc,
	1351	"tolist() -> list\n\
	1352	\n\
	1353	Convert array to an ordinary list with the same items.");
	1354
	1355
	1356	static PyObject *
	1357	array_fromstring(arrayobject self, PyObject args)
	1358	{
	1359	char *str;
	1360	Py_ssize_t n;
	1361	int itemsize = self->ob_descr->itemsize;
	1362	if (!PyArg_ParseTuple(args, "s#:fromstring", &str, &n))
	1363	return NULL;
	1364	if (n % itemsize != 0) {
	1365	PyErr_SetString(PyExc_ValueError,
	1366	"string length not a multiple of item size");
	1367	return NULL;
	1368	}
	1369	n = n / itemsize;
	1370	if (n > 0) {
	1371	char *item = self->ob_item;
	1372	PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize);
	1373	if (item == NULL) {
	1374	PyErr_NoMemory();
	1375	return NULL;
	1376	}
	1377	self->ob_item = item;
	1378	self->ob_size += n;
	1379	self->allocated = self->ob_size;
	1380	memcpy(item + (self->ob_size - n) * itemsize,
	1381	str, itemsize*n);
	1382	}
	1383	Py_INCREF(Py_None);
	1384	return Py_None;
	1385	}
	1386
	1387	PyDoc_STRVAR(fromstring_doc,
	1388	"fromstring(string)\n\
	1389	\n\
	1390	Appends items from the string, interpreting it as an array of machine\n\
	1391	values,as if it had been read from a file using the fromfile() method).");
	1392
	1393
	1394	static PyObject *
	1395	array_tostring(arrayobject self, PyObject unused)
	1396	{
	1397	return PyString_FromStringAndSize(self->ob_item,
	1398	self->ob_size * self->ob_descr->itemsize);
	1399	}
	1400
	1401	PyDoc_STRVAR(tostring_doc,
	1402	"tostring() -> string\n\
	1403	\n\
	1404	Convert the array to an array of machine values and return the string\n\
	1405	representation.");
	1406
	1407
	1408
	1409	#ifdef Py_USING_UNICODE
	1410	static PyObject *
	1411	array_fromunicode(arrayobject self, PyObject args)
	1412	{
	1413	Py_UNICODE *ustr;
	1414	Py_ssize_t n;
	1415
	1416	if (!PyArg_ParseTuple(args, "u#:fromunicode", &ustr, &n))
	1417	return NULL;
	1418	if (self->ob_descr->typecode != 'u') {
	1419	PyErr_SetString(PyExc_ValueError,
	1420	"fromunicode() may only be called on "
	1421	"type 'u' arrays");
	1422	return NULL;
	1423	}
	1424	if (n > 0) {
	1425	Py_UNICODE item = (Py_UNICODE ) self->ob_item;
	1426	PyMem_RESIZE(item, Py_UNICODE, self->ob_size + n);
	1427	if (item == NULL) {
	1428	PyErr_NoMemory();
	1429	return NULL;
	1430	}
	1431	self->ob_item = (char *) item;
	1432	self->ob_size += n;
	1433	self->allocated = self->ob_size;
	1434	memcpy(item + self->ob_size - n,
	1435	ustr, n * sizeof(Py_UNICODE));
	1436	}
	1437
	1438	Py_INCREF(Py_None);
	1439	return Py_None;
	1440	}
	1441
	1442	PyDoc_STRVAR(fromunicode_doc,
	1443	"fromunicode(ustr)\n\
	1444	\n\
	1445	Extends this array with data from the unicode string ustr.\n\
	1446	The array must be a type 'u' array; otherwise a ValueError\n\
	1447	is raised. Use array.fromstring(ustr.decode(...)) to\n\
	1448	append Unicode data to an array of some other type.");
	1449
	1450
	1451	static PyObject *
	1452	array_tounicode(arrayobject self, PyObject unused)
	1453	{
	1454	if (self->ob_descr->typecode != 'u') {
	1455	PyErr_SetString(PyExc_ValueError,
	1456	"tounicode() may only be called on type 'u' arrays");
	1457	return NULL;
	1458	}
	1459	return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, self->ob_size);
	1460	}
	1461
	1462	PyDoc_STRVAR(tounicode_doc,
	1463	"tounicode() -> unicode\n\
	1464	\n\
	1465	Convert the array to a unicode string. The array must be\n\
	1466	a type 'u' array; otherwise a ValueError is raised. Use\n\
	1467	array.tostring().decode() to obtain a unicode string from\n\
	1468	an array of some other type.");
	1469
	1470	#endif /* Py_USING_UNICODE */
	1471
	1472
	1473	static PyObject *
	1474	array_get_typecode(arrayobject a, void closure)
	1475	{
	1476	char tc = a->ob_descr->typecode;
	1477	return PyString_FromStringAndSize(&tc, 1);
	1478	}
	1479
	1480	static PyObject *
	1481	array_get_itemsize(arrayobject a, void closure)
	1482	{
	1483	return PyInt_FromLong((long)a->ob_descr->itemsize);
	1484	}
	1485
	1486	static PyGetSetDef array_getsets [] = {
	1487	{"typecode", (getter) array_get_typecode, NULL,
	1488	"the typecode character used to create the array"},
	1489	{"itemsize", (getter) array_get_itemsize, NULL,
	1490	"the size, in bytes, of one array item"},
	1491	{NULL}
	1492	};
	1493
	1494	PyMethodDef array_methods[] = {
	1495	{"append", (PyCFunction)array_append, METH_O,
	1496	append_doc},
	1497	{"buffer_info", (PyCFunction)array_buffer_info, METH_NOARGS,
	1498	buffer_info_doc},
	1499	{"byteswap", (PyCFunction)array_byteswap, METH_NOARGS,
	1500	byteswap_doc},
	1501	{"__copy__", (PyCFunction)array_copy, METH_NOARGS,
	1502	copy_doc},
	1503	{"count", (PyCFunction)array_count, METH_O,
	1504	count_doc},
	1505	{"__deepcopy__",(PyCFunction)array_copy, METH_O,
	1506	copy_doc},
	1507	{"extend", (PyCFunction)array_extend, METH_O,
	1508	extend_doc},
	1509	{"fromfile", (PyCFunction)array_fromfile, METH_VARARGS,
	1510	fromfile_doc},
	1511	{"fromlist", (PyCFunction)array_fromlist, METH_O,
	1512	fromlist_doc},
	1513	{"fromstring", (PyCFunction)array_fromstring, METH_VARARGS,
	1514	fromstring_doc},
	1515	#ifdef Py_USING_UNICODE
	1516	{"fromunicode", (PyCFunction)array_fromunicode, METH_VARARGS,
	1517	fromunicode_doc},
	1518	#endif
	1519	{"index", (PyCFunction)array_index, METH_O,
	1520	index_doc},
	1521	{"insert", (PyCFunction)array_insert, METH_VARARGS,
	1522	insert_doc},
	1523	{"pop", (PyCFunction)array_pop, METH_VARARGS,
	1524	pop_doc},
	1525	{"read", (PyCFunction)array_fromfile, METH_VARARGS,
	1526	fromfile_doc},
	1527	{"__reduce__", (PyCFunction)array_reduce, METH_NOARGS,
	1528	array_doc},
	1529	{"remove", (PyCFunction)array_remove, METH_O,
	1530	remove_doc},
	1531	{"reverse", (PyCFunction)array_reverse, METH_NOARGS,
	1532	reverse_doc},
	1533	/* {"sort", (PyCFunction)array_sort, METH_VARARGS,
	1534	sort_doc},*/
	1535	{"tofile", (PyCFunction)array_tofile, METH_O,
	1536	tofile_doc},
	1537	{"tolist", (PyCFunction)array_tolist, METH_NOARGS,
	1538	tolist_doc},
	1539	{"tostring", (PyCFunction)array_tostring, METH_NOARGS,
	1540	tostring_doc},
	1541	#ifdef Py_USING_UNICODE
	1542	{"tounicode", (PyCFunction)array_tounicode, METH_NOARGS,
	1543	tounicode_doc},
	1544	#endif
	1545	{"write", (PyCFunction)array_tofile, METH_O,
	1546	tofile_doc},
	1547	{NULL, NULL} /* sentinel */
	1548	};
	1549
	1550	static PyObject *
	1551	array_repr(arrayobject *a)
	1552	{
	1553	char buf[256], typecode;
	1554	PyObject s, t, *v = NULL;
	1555	Py_ssize_t len;
	1556
	1557	len = a->ob_size;
	1558	typecode = a->ob_descr->typecode;
	1559	if (len == 0) {
	1560	PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
	1561	return PyString_FromString(buf);
	1562	}
	1563
	1564	if (typecode == 'c')
	1565	v = array_tostring(a, NULL);
	1566	#ifdef Py_USING_UNICODE
	1567	else if (typecode == 'u')
	1568	v = array_tounicode(a, NULL);
	1569	#endif
	1570	else
	1571	v = array_tolist(a, NULL);
	1572	t = PyObject_Repr(v);
	1573	Py_XDECREF(v);
	1574
	1575	PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode);
	1576	s = PyString_FromString(buf);
	1577	PyString_ConcatAndDel(&s, t);
	1578	PyString_ConcatAndDel(&s, PyString_FromString(")"));
	1579	return s;
	1580	}
	1581
	1582	static PyObject*
	1583	array_subscr(arrayobject* self, PyObject* item)
	1584	{
	1585	if (PyIndex_Check(item)) {
	1586	Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
	1587	if (i==-1 && PyErr_Occurred()) {
	1588	return NULL;
	1589	}
	1590	if (i < 0)
	1591	i += self->ob_size;
	1592	return array_item(self, i);
	1593	}
	1594	else if (PySlice_Check(item)) {
	1595	Py_ssize_t start, stop, step, slicelength, cur, i;
	1596	PyObject* result;
	1597	arrayobject* ar;
	1598	int itemsize = self->ob_descr->itemsize;
	1599
	1600	if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size,
	1601	&start, &stop, &step, &slicelength) < 0) {
	1602	return NULL;
	1603	}
	1604
	1605	if (slicelength <= 0) {
	1606	return newarrayobject(&Arraytype, 0, self->ob_descr);
	1607	}
	1608	else {
	1609	result = newarrayobject(&Arraytype, slicelength, self->ob_descr);
	1610	if (!result) return NULL;
	1611
	1612	ar = (arrayobject*)result;
	1613
	1614	for (cur = start, i = 0; i < slicelength;
	1615	cur += step, i++) {
	1616	memcpy(ar->ob_item + i*itemsize,
	1617	self->ob_item + cur*itemsize,
	1618	itemsize);
	1619	}
	1620
	1621	return result;
	1622	}
	1623	}
	1624	else {
	1625	PyErr_SetString(PyExc_TypeError,
	1626	"list indices must be integers");
	1627	return NULL;
	1628	}
	1629	}
	1630
	1631	static int
	1632	array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
	1633	{
	1634	if (PyIndex_Check(item)) {
	1635	Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
	1636	if (i==-1 && PyErr_Occurred())
	1637	return -1;
	1638	if (i < 0)
	1639	i += self->ob_size;
	1640	return array_ass_item(self, i, value);
	1641	}
	1642	else if (PySlice_Check(item)) {
	1643	Py_ssize_t start, stop, step, slicelength;
	1644	int itemsize = self->ob_descr->itemsize;
	1645
	1646	if (PySlice_GetIndicesEx((PySliceObject*)item, self->ob_size,
	1647	&start, &stop, &step, &slicelength) < 0) {
	1648	return -1;
	1649	}
	1650
	1651	/* treat A[slice(a,b)] = v _exactly_ like A[a:b] = v */
	1652	if (step == 1 && ((PySliceObject*)item)->step == Py_None)
	1653	return array_ass_slice(self, start, stop, value);
	1654
	1655	if (value == NULL) {
	1656	/* delete slice */
	1657	Py_ssize_t cur, i, extra;
	1658
	1659	if (slicelength <= 0)
	1660	return 0;
	1661
	1662	if (step < 0) {
	1663	stop = start + 1;
	1664	start = stop + step*(slicelength - 1) - 1;
	1665	step = -step;
	1666	}
	1667
	1668	for (cur = start, i = 0; i < slicelength - 1;
	1669	cur += step, i++) {
	1670	memmove(self->ob_item + (cur - i)*itemsize,
	1671	self->ob_item + (cur + 1)*itemsize,
	1672	(step - 1) * itemsize);
	1673	}
	1674	extra = self->ob_size - (cur + 1);
	1675	if (extra > 0) {
	1676	memmove(self->ob_item + (cur - i)*itemsize,
	1677	self->ob_item + (cur + 1)*itemsize,
	1678	extra*itemsize);
	1679	}
	1680
	1681	self->ob_size -= slicelength;
	1682	self->ob_item = (char *)PyMem_REALLOC(self->ob_item,
	1683	itemsize*self->ob_size);
	1684	self->allocated = self->ob_size;
	1685
	1686	return 0;
	1687	}
	1688	else {
	1689	/* assign slice */
	1690	Py_ssize_t cur, i;
	1691	arrayobject* av;
	1692
	1693	if (!array_Check(value)) {
	1694	PyErr_Format(PyExc_TypeError,
	1695	"must assign array (not \"%.200s\") to slice",
	1696	value->ob_type->tp_name);
	1697	return -1;
	1698	}
	1699
	1700	av = (arrayobject*)value;
	1701
	1702	if (av->ob_size != slicelength) {
	1703	PyErr_Format(PyExc_ValueError,
	1704	"attempt to assign array of size %ld to extended slice of size %ld",
	1705	/XXX/(long)av->ob_size, /XXX/(long)slicelength);
	1706	return -1;
	1707	}
	1708
	1709	if (!slicelength)
	1710	return 0;
	1711
	1712	/* protect against a[::-1] = a */
	1713	if (self == av) {
	1714	value = array_slice(av, 0, av->ob_size);
	1715	av = (arrayobject*)value;
	1716	if (!av)
	1717	return -1;
	1718	}
	1719	else {
	1720	Py_INCREF(value);
	1721	}
	1722
	1723	for (cur = start, i = 0; i < slicelength;
	1724	cur += step, i++) {
	1725	memcpy(self->ob_item + cur*itemsize,
	1726	av->ob_item + i*itemsize,
	1727	itemsize);
	1728	}
	1729
	1730	Py_DECREF(value);
	1731
	1732	return 0;
	1733	}
	1734	}
	1735	else {
	1736	PyErr_SetString(PyExc_TypeError,
	1737	"list indices must be integers");
	1738	return -1;
	1739	}
	1740	}
	1741
	1742	static PyMappingMethods array_as_mapping = {
	1743	(lenfunc)array_length,
	1744	(binaryfunc)array_subscr,
	1745	(objobjargproc)array_ass_subscr
	1746	};
	1747
	1748	static const void *emptybuf = "";
	1749
	1750	static Py_ssize_t
	1751	array_buffer_getreadbuf(arrayobject self, Py_ssize_t index, const void *ptr)
	1752	{
	1753	if ( index != 0 ) {
	1754	PyErr_SetString(PyExc_SystemError,
	1755	"Accessing non-existent array segment");
	1756	return -1;
	1757	}
	1758	ptr = (void )self->ob_item;
	1759	if (*ptr == NULL)
	1760	*ptr = emptybuf;
	1761	return self->ob_size*self->ob_descr->itemsize;
	1762	}
	1763
	1764	static Py_ssize_t
	1765	array_buffer_getwritebuf(arrayobject self, Py_ssize_t index, const void *ptr)
	1766	{
	1767	if ( index != 0 ) {
	1768	PyErr_SetString(PyExc_SystemError,
	1769	"Accessing non-existent array segment");
	1770	return -1;
	1771	}
	1772	ptr = (void )self->ob_item;
	1773	if (*ptr == NULL)
	1774	*ptr = emptybuf;
	1775	return self->ob_size*self->ob_descr->itemsize;
	1776	}
	1777
	1778	static Py_ssize_t
	1779	array_buffer_getsegcount(arrayobject self, Py_ssize_t lenp)
	1780	{
	1781	if ( lenp )
	1782	lenp = self->ob_sizeself->ob_descr->itemsize;
	1783	return 1;
	1784	}
	1785
	1786	static PySequenceMethods array_as_sequence = {
	1787	(lenfunc)array_length, /sq_length/
	1788	(binaryfunc)array_concat, /sq_concat/
	1789	(ssizeargfunc)array_repeat, /sq_repeat/
	1790	(ssizeargfunc)array_item, /sq_item/
	1791	(ssizessizeargfunc)array_slice, /sq_slice/
	1792	(ssizeobjargproc)array_ass_item, /sq_ass_item/
	1793	(ssizessizeobjargproc)array_ass_slice, /sq_ass_slice/
	1794	(objobjproc)array_contains, /sq_contains/
	1795	(binaryfunc)array_inplace_concat, /sq_inplace_concat/
	1796	(ssizeargfunc)array_inplace_repeat /sq_inplace_repeat/
	1797	};
	1798
	1799	static PyBufferProcs array_as_buffer = {
	1800	(readbufferproc)array_buffer_getreadbuf,
	1801	(writebufferproc)array_buffer_getwritebuf,
	1802	(segcountproc)array_buffer_getsegcount,
	1803	NULL,
	1804	};
	1805
	1806	static PyObject *
	1807	array_new(PyTypeObject type, PyObject args, PyObject *kwds)
	1808	{
	1809	char c;
	1810	PyObject initial = NULL, it = NULL;
	1811	struct arraydescr *descr;
	1812
	1813	if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds))
	1814	return NULL;
	1815
	1816	if (!PyArg_ParseTuple(args, "c\|O:array", &c, &initial))
	1817	return NULL;
	1818
	1819	if (!(initial == NULL \|\| PyList_Check(initial)
	1820	\|\| PyString_Check(initial) \|\| PyTuple_Check(initial)
	1821	\|\| (c == 'u' && PyUnicode_Check(initial)))) {
	1822	it = PyObject_GetIter(initial);
	1823	if (it == NULL)
	1824	return NULL;
	1825	/* We set initial to NULL so that the subsequent code
	1826	will create an empty array of the appropriate type
	1827	and afterwards we can use array_iter_extend to populate
	1828	the array.
	1829	*/
	1830	initial = NULL;
	1831	}
	1832	for (descr = descriptors; descr->typecode != '\0'; descr++) {
	1833	if (descr->typecode == c) {
	1834	PyObject *a;
	1835	Py_ssize_t len;
	1836
	1837	if (initial == NULL \|\| !(PyList_Check(initial)
	1838	\|\| PyTuple_Check(initial)))
	1839	len = 0;
	1840	else
	1841	len = PySequence_Size(initial);
	1842
	1843	a = newarrayobject(type, len, descr);
	1844	if (a == NULL)
	1845	return NULL;
	1846
	1847	if (len > 0) {
	1848	Py_ssize_t i;
	1849	for (i = 0; i < len; i++) {
	1850	PyObject *v =
	1851	PySequence_GetItem(initial, i);
	1852	if (v == NULL) {
	1853	Py_DECREF(a);
	1854	return NULL;
	1855	}
	1856	if (setarrayitem(a, i, v) != 0) {
	1857	Py_DECREF(v);
	1858	Py_DECREF(a);
	1859	return NULL;
	1860	}
	1861	Py_DECREF(v);
	1862	}
	1863	} else if (initial != NULL && PyString_Check(initial)) {
	1864	PyObject t_initial, v;
	1865	t_initial = PyTuple_Pack(1, initial);
	1866	if (t_initial == NULL) {
	1867	Py_DECREF(a);
	1868	return NULL;
	1869	}
	1870	v = array_fromstring((arrayobject *)a,
	1871	t_initial);
	1872	Py_DECREF(t_initial);
	1873	if (v == NULL) {
	1874	Py_DECREF(a);
	1875	return NULL;
	1876	}
	1877	Py_DECREF(v);
	1878	#ifdef Py_USING_UNICODE
	1879	} else if (initial != NULL && PyUnicode_Check(initial)) {
	1880	Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial);
	1881	if (n > 0) {
	1882	arrayobject self = (arrayobject )a;
	1883	char *item = self->ob_item;
	1884	item = (char *)PyMem_Realloc(item, n);
	1885	if (item == NULL) {
	1886	PyErr_NoMemory();
	1887	Py_DECREF(a);
	1888	return NULL;
	1889	}
	1890	self->ob_item = item;
	1891	self->ob_size = n / sizeof(Py_UNICODE);
	1892	memcpy(item, PyUnicode_AS_DATA(initial), n);
	1893	self->allocated = self->ob_size;
	1894	}
	1895	#endif
	1896	}
	1897	if (it != NULL) {
	1898	if (array_iter_extend((arrayobject *)a, it) == -1) {
	1899	Py_DECREF(it);
	1900	Py_DECREF(a);
	1901	return NULL;
	1902	}
	1903	Py_DECREF(it);
	1904	}
	1905	return a;
	1906	}
	1907	}
	1908	PyErr_SetString(PyExc_ValueError,
	1909	"bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)");
	1910	return NULL;
	1911	}
	1912
	1913
	1914	PyDoc_STRVAR(module_doc,
	1915	"This module defines an object type which can efficiently represent\n\
	1916	an array of basic values: characters, integers, floating point\n\
	1917	numbers. Arrays are sequence types and behave very much like lists,\n\
	1918	except that the type of objects stored in them is constrained. The\n\
	1919	type is specified at object creation time by using a type code, which\n\
	1920	is a single character. The following type codes are defined:\n\
	1921	\n\
	1922	Type code C Type Minimum size in bytes \n\
	1923	'c' character 1 \n\
	1924	'b' signed integer 1 \n\
	1925	'B' unsigned integer 1 \n\
	1926	'u' Unicode character 2 \n\
	1927	'h' signed integer 2 \n\
	1928	'H' unsigned integer 2 \n\
	1929	'i' signed integer 2 \n\
	1930	'I' unsigned integer 2 \n\
	1931	'l' signed integer 4 \n\
	1932	'L' unsigned integer 4 \n\
	1933	'f' floating point 4 \n\
	1934	'd' floating point 8 \n\
	1935	\n\
	1936	The constructor is:\n\
	1937	\n\
	1938	array(typecode [, initializer]) -- create a new array\n\
	1939	");
	1940
	1941	PyDoc_STRVAR(arraytype_doc,
	1942	"array(typecode [, initializer]) -> array\n\
	1943	\n\
	1944	Return a new array whose items are restricted by typecode, and\n\
	1945	initialized from the optional initializer value, which must be a list,\n\
	1946	string. or iterable over elements of the appropriate type.\n\
	1947	\n\
	1948	Arrays represent basic values and behave very much like lists, except\n\
	1949	the type of objects stored in them is constrained.\n\
	1950	\n\
	1951	Methods:\n\
	1952	\n\
	1953	append() -- append a new item to the end of the array\n\
	1954	buffer_info() -- return information giving the current memory info\n\
	1955	byteswap() -- byteswap all the items of the array\n\
	1956	count() -- return number of occurences of an object\n\
	1957	extend() -- extend array by appending multiple elements from an iterable\n\
	1958	fromfile() -- read items from a file object\n\
	1959	fromlist() -- append items from the list\n\
	1960	fromstring() -- append items from the string\n\
	1961	index() -- return index of first occurence of an object\n\
	1962	insert() -- insert a new item into the array at a provided position\n\
	1963	pop() -- remove and return item (default last)\n\
	1964	read() -- DEPRECATED, use fromfile()\n\
	1965	remove() -- remove first occurence of an object\n\
	1966	reverse() -- reverse the order of the items in the array\n\
	1967	tofile() -- write all items to a file object\n\
	1968	tolist() -- return the array converted to an ordinary list\n\
	1969	tostring() -- return the array converted to a string\n\
	1970	write() -- DEPRECATED, use tofile()\n\
	1971	\n\
	1972	Attributes:\n\
	1973	\n\
	1974	typecode -- the typecode character used to create the array\n\
	1975	itemsize -- the length in bytes of one array item\n\
	1976	");
	1977
	1978	static PyObject array_iter(arrayobject ao);
	1979
	1980	static PyTypeObject Arraytype = {
	1981	PyObject_HEAD_INIT(NULL)
	1982	0,
	1983	"array.array",
	1984	sizeof(arrayobject),
	1985	0,
	1986	(destructor)array_dealloc, /* tp_dealloc */
	1987	0, /* tp_print */
	1988	0, /* tp_getattr */
	1989	0, /* tp_setattr */
	1990	0, /* tp_compare */
	1991	(reprfunc)array_repr, /* tp_repr */
	1992	0, /* tp_as_number*/
	1993	&array_as_sequence, /* tp_as_sequence*/
	1994	&array_as_mapping, /* tp_as_mapping*/
	1995	0, /* tp_hash */
	1996	0, /* tp_call */
	1997	0, /* tp_str */
	1998	PyObject_GenericGetAttr, /* tp_getattro */
	1999	0, /* tp_setattro */
	2000	&array_as_buffer, /* tp_as_buffer*/
	2001	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE \| Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
	2002	arraytype_doc, /* tp_doc */
	2003	0, /* tp_traverse */
	2004	0, /* tp_clear */
	2005	array_richcompare, /* tp_richcompare */
	2006	offsetof(arrayobject, weakreflist), /* tp_weaklistoffset */
	2007	(getiterfunc)array_iter, /* tp_iter */
	2008	0, /* tp_iternext */
	2009	array_methods, /* tp_methods */
	2010	0, /* tp_members */
	2011	array_getsets, /* tp_getset */
	2012	0, /* tp_base */
	2013	0, /* tp_dict */
	2014	0, /* tp_descr_get */
	2015	0, /* tp_descr_set */
	2016	0, /* tp_dictoffset */
	2017	0, /* tp_init */
	2018	PyType_GenericAlloc, /* tp_alloc */
	2019	array_new, /* tp_new */
	2020	PyObject_Del, /* tp_free */
	2021	};
	2022
	2023
	2024	/********************* Array Iterator ************************/
	2025
	2026	typedef struct {
	2027	PyObject_HEAD
	2028	Py_ssize_t index;
	2029	arrayobject *ao;
	2030	PyObject * (getitem)(struct arrayobject , Py_ssize_t);
	2031	} arrayiterobject;
	2032
	2033	static PyTypeObject PyArrayIter_Type;
	2034
	2035	#define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type)
	2036
	2037	static PyObject *
	2038	array_iter(arrayobject *ao)
	2039	{
	2040	arrayiterobject *it;
	2041
	2042	if (!array_Check(ao)) {
	2043	PyErr_BadInternalCall();
	2044	return NULL;
	2045	}
	2046
	2047	it = PyObject_GC_New(arrayiterobject, &PyArrayIter_Type);
	2048	if (it == NULL)
	2049	return NULL;
	2050
	2051	Py_INCREF(ao);
	2052	it->ao = ao;
	2053	it->index = 0;
	2054	it->getitem = ao->ob_descr->getitem;
	2055	PyObject_GC_Track(it);
	2056	return (PyObject *)it;
	2057	}
	2058
	2059	static PyObject *
	2060	arrayiter_next(arrayiterobject *it)
	2061	{
	2062	assert(PyArrayIter_Check(it));
	2063	if (it->index < it->ao->ob_size)
	2064	return (*it->getitem)(it->ao, it->index++);
	2065	return NULL;
	2066	}
	2067
	2068	static void
	2069	arrayiter_dealloc(arrayiterobject *it)
	2070	{
	2071	PyObject_GC_UnTrack(it);
	2072	Py_XDECREF(it->ao);
	2073	PyObject_GC_Del(it);
	2074	}
	2075
	2076	static int
	2077	arrayiter_traverse(arrayiterobject it, visitproc visit, void arg)
	2078	{
	2079	Py_VISIT(it->ao);
	2080	return 0;
	2081	}
	2082
	2083	static PyTypeObject PyArrayIter_Type = {
	2084	PyObject_HEAD_INIT(NULL)
	2085	0, /* ob_size */
	2086	"arrayiterator", /* tp_name */
	2087	sizeof(arrayiterobject), /* tp_basicsize */
	2088	0, /* tp_itemsize */
	2089	/* methods */
	2090	(destructor)arrayiter_dealloc, /* tp_dealloc */
	2091	0, /* tp_print */
	2092	0, /* tp_getattr */
	2093	0, /* tp_setattr */
	2094	0, /* tp_compare */
	2095	0, /* tp_repr */
	2096	0, /* tp_as_number */
	2097	0, /* tp_as_sequence */
	2098	0, /* tp_as_mapping */
	2099	0, /* tp_hash */
	2100	0, /* tp_call */
	2101	0, /* tp_str */
	2102	PyObject_GenericGetAttr, /* tp_getattro */
	2103	0, /* tp_setattro */
	2104	0, /* tp_as_buffer */
	2105	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC,/* tp_flags */
	2106	0, /* tp_doc */
	2107	(traverseproc)arrayiter_traverse, /* tp_traverse */
	2108	0, /* tp_clear */
	2109	0, /* tp_richcompare */
	2110	0, /* tp_weaklistoffset */
	2111	PyObject_SelfIter, /* tp_iter */
	2112	(iternextfunc)arrayiter_next, /* tp_iternext */
	2113	0, /* tp_methods */
	2114	};
	2115
	2116
	2117	/********************* Install Module ************************/
	2118
	2119	/* No functions in array module. */
	2120	static PyMethodDef a_methods[] = {
	2121	{NULL, NULL, 0, NULL} /* Sentinel */
	2122	};
	2123
	2124
	2125	PyMODINIT_FUNC
	2126	initarray(void)
	2127	{
	2128	PyObject *m;
	2129
	2130	Arraytype.ob_type = &PyType_Type;
	2131	PyArrayIter_Type.ob_type = &PyType_Type;
	2132	m = Py_InitModule3("array", a_methods, module_doc);
	2133	if (m == NULL)
	2134	return;
	2135
	2136	Py_INCREF((PyObject *)&Arraytype);
	2137	PyModule_AddObject(m, "ArrayType", (PyObject *)&Arraytype);
	2138	Py_INCREF((PyObject *)&Arraytype);
	2139	PyModule_AddObject(m, "array", (PyObject *)&Arraytype);
	2140	/* No need to check the error here, the caller will do that */
	2141	}