op->ob_type->tp_free((PyObject *)op);} static PyObject *array_richcompare(PyObject *v, PyObject *w, int op){	arrayobject *va, *wa;	PyObject *vi = NULL;	PyObject *wi = NULL;	Py_ssize_t i, k;	PyObject *res; 	if (!array_Check(v) || !array_Check(w)) {		Py_INCREF(Py_NotImplemented);		return Py_NotImplemented;	} 	va = (arrayobject *)v;	wa = (arrayobject *)w; 	if (va->ob_size != wa->ob_size && (op == Py_EQ || op == Py_NE)) {		/* Shortcut: if the lengths differ, the arrays differ */		if (op == Py_EQ)			res = Py_False;		else			res = Py_True;		Py_INCREF(res);		return res;	} 	/* Search for the first index where items are different */	k = 1;	for (i = 0; i < va->ob_size && i < wa->ob_size; i++) {		vi = getarrayitem(v, i);		wi = getarrayitem(w, i);		if (vi == NULL || wi == NULL) {			Py_XDECREF(vi);			Py_XDECREF(wi);			return NULL;		}		k = PyObject_RichCompareBool(vi, wi, Py_EQ);		if (k == 0)			break; /* Keeping vi and wi alive! */		Py_DECREF(vi);		Py_DECREF(wi);		if (k < 0)			return NULL;	} 	if (k) {		/* No more items to compare -- compare sizes */		Py_ssize_t vs = va->ob_size;		Py_ssize_t ws = wa->ob_size;		int cmp;		switch (op) {		case Py_LT: cmp = vs <  ws; break;		case Py_LE: cmp = vs <= ws; break;		case Py_EQ: cmp = vs == ws; break;		case Py_NE: cmp = vs != ws; break;		case Py_GT: cmp = vs >  ws; break;		case Py_GE: cmp = vs >= ws; break;		default: return NULL; /* cannot happen */		}		if (cmp)			res = Py_True;		else			res = Py_False;		Py_INCREF(res);		return res;	} 	/* We have an item that differs.  First, shortcuts for EQ/NE */	if (op == Py_EQ) {		Py_INCREF(Py_False);		res = Py_False;	}	else if (op == Py_NE) {		Py_INCREF(Py_True);		res = Py_True;	}	else {		/* Compare the final item again using the proper operator */		res = PyObject_RichCompare(vi, wi, op);	}	Py_DECREF(vi);	Py_DECREF(wi);	return res;} static Py_ssize_tarray_length(arrayobject *a){	return a->ob_size;} static PyObject *array_item(arrayobject *a, Py_ssize_t i){	if (i < 0 || i >= a->ob_size) {		PyErr_SetString(PyExc_IndexError, "array index out of range");		return NULL;	}	return getarrayitem((PyObject *)a, i);} static PyObject *array_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh){	arrayobject *np;	if (ilow < 0)		ilow = 0;	else if (ilow > a->ob_size)		ilow = a->ob_size;	if (ihigh < 0)		ihigh = 0;	if (ihigh < ilow)		ihigh = ilow;	else if (ihigh > a->ob_size)		ihigh = a->ob_size;	np = (arrayobject *) newarrayobject(&Arraytype, ihigh - ilow, a->ob_descr);	if (np == NULL)		return NULL;	memcpy(np->ob_item, a->ob_item + ilow * a->ob_descr->itemsize,	       (ihigh-ilow) * a->ob_descr->itemsize);	return (PyObject *)np;} static PyObject *array_copy(arrayobject *a, PyObject *unused){	return array_slice(a, 0, a->ob_size);} PyDoc_STRVAR(copy_doc,"copy(array)\n\\n\ Return a copy of the array."); static PyObject *array_concat(arrayobject *a, PyObject *bb){	Py_ssize_t size;	arrayobject *np;	if (!array_Check(bb)) {		PyErr_Format(PyExc_TypeError,		     "can only append array (not \"%.200s\") to array",			     bb->ob_type->tp_name);		return NULL;	}#define b ((arrayobject *)bb)	if (a->ob_descr != b->ob_descr) {		PyErr_BadArgument();		return NULL;	}	size = a->ob_size + b->ob_size;	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);	if (np == NULL) {		return NULL;	}	memcpy(np->ob_item, a->ob_item, a->ob_size*a->ob_descr->itemsize);	memcpy(np->ob_item + a->ob_size*a->ob_descr->itemsize,	       b->ob_item, b->ob_size*b->ob_descr->itemsize);	return (PyObject *)np;#undef b} static PyObject *array_repeat(arrayobject *a, Py_ssize_t n){	Py_ssize_t i;	Py_ssize_t size;	arrayobject *np;	char *p;	Py_ssize_t nbytes;	if (n < 0)		n = 0;	size = a->ob_size * n;	np = (arrayobject *) newarrayobject(&Arraytype, size, a->ob_descr);	if (np == NULL)		return NULL;	p = np->ob_item;	nbytes = a->ob_size * a->ob_descr->itemsize;	for (i = 0; i < n; i++) {		memcpy(p, a->ob_item, nbytes);		p += nbytes;	}	return (PyObject *) np;} static intarray_ass_slice(arrayobject *a, Py_ssize_t ilow, Py_ssize_t ihigh, PyObject *v){	char *item;	Py_ssize_t n; /* Size of replacement array */	Py_ssize_t d; /* Change in size */#define b ((arrayobject *)v)	if (v == NULL)		n = 0;	else if (array_Check(v)) {		n = b->ob_size;		if (a == b) {			/* Special case "a[i:j] = a" -- copy b first */			int ret;			v = array_slice(b, 0, n);			if (!v)				return -1;			ret = array_ass_slice(a, ilow, ihigh, v);			Py_DECREF(v);			return ret;		}		if (b->ob_descr != a->ob_descr) {			PyErr_BadArgument();			return -1;		}	}	else {		PyErr_Format(PyExc_TypeError,	     "can only assign array (not \"%.200s\") to array slice",			     v->ob_type->tp_name);		return -1;	}	if (ilow < 0)		ilow = 0;	else if (ilow > a->ob_size)		ilow = a->ob_size;	if (ihigh < 0)		ihigh = 0;	if (ihigh < ilow)		ihigh = ilow;	else if (ihigh > a->ob_size)		ihigh = a->ob_size;	item = a->ob_item;	d = n - (ihigh-ilow);	if (d < 0) { /* Delete -d items */		memmove(item + (ihigh+d)*a->ob_descr->itemsize,			item + ihigh*a->ob_descr->itemsize,			(a->ob_size-ihigh)*a->ob_descr->itemsize);		a->ob_size += d;		PyMem_RESIZE(item, char, a->ob_size*a->ob_descr->itemsize);						/* Can't fail */		a->ob_item = item;		a->allocated = a->ob_size;	}	else if (d > 0) { /* Insert d items */		PyMem_RESIZE(item, char,			     (a->ob_size + d)*a->ob_descr->itemsize);		if (item == NULL) {			PyErr_NoMemory();			return -1;		}		memmove(item + (ihigh+d)*a->ob_descr->itemsize,			item + ihigh*a->ob_descr->itemsize,			(a->ob_size-ihigh)*a->ob_descr->itemsize);		a->ob_item = item;		a->ob_size += d;		a->allocated = a->ob_size;	}	if (n > 0)		memcpy(item + ilow*a->ob_descr->itemsize, b->ob_item,		       n*b->ob_descr->itemsize);	return 0;#undef b} static intarray_ass_item(arrayobject *a, Py_ssize_t i, PyObject *v){	if (i < 0 || i >= a->ob_size) {		PyErr_SetString(PyExc_IndexError,			         "array assignment index out of range");		return -1;	}	if (v == NULL)		return array_ass_slice(a, i, i+1, v);	return (*a->ob_descr->setitem)(a, i, v);} static intsetarrayitem(PyObject *a, Py_ssize_t i, PyObject *v){	assert(array_Check(a));	return array_ass_item((arrayobject *)a, i, v);} static intarray_iter_extend(arrayobject *self, PyObject *bb){	PyObject *it, *v; 	it = PyObject_GetIter(bb);	if (it == NULL)		return -1; 	while ((v = PyIter_Next(it)) != NULL) {		if (ins1(self, (int) self->ob_size, v) != 0) {			Py_DECREF(v);			Py_DECREF(it);			return -1;		}		Py_DECREF(v);	}	Py_DECREF(it);	if (PyErr_Occurred())		return -1;	return 0;} static intarray_do_extend(arrayobject *self, PyObject *bb){	Py_ssize_t size; 	if (!array_Check(bb))		return array_iter_extend(self, bb);#define b ((arrayobject *)bb)	if (self->ob_descr != b->ob_descr) {		PyErr_SetString(PyExc_TypeError,			     "can only extend with array of same kind");		return -1;	}	size = self->ob_size + b->ob_size;        PyMem_RESIZE(self->ob_item, char, size*self->ob_descr->itemsize);        if (self->ob_item == NULL) {                PyObject_Del(self);                PyErr_NoMemory();		return -1;        }	memcpy(self->ob_item + self->ob_size*self->ob_descr->itemsize,               b->ob_item, b->ob_size*b->ob_descr->itemsize);	self->ob_size = size;	self->allocated = size; 	return 0;#undef b} static PyObject *array_inplace_concat(arrayobject *self, PyObject *bb){	if (!array_Check(bb)) {		PyErr_Format(PyExc_TypeError,			"can only extend array with array (not \"%.200s\")",			bb->ob_type->tp_name);		return NULL;	}	if (array_do_extend(self, bb) == -1)		return NULL;	Py_INCREF(self);	return (PyObject *)self;} static PyObject *array_inplace_repeat(arrayobject *self, Py_ssize_t n){	char *items, *p;	Py_ssize_t size, i; 	if (self->ob_size > 0) {		if (n < 0)			n = 0;		items = self->ob_item;		size = self->ob_size * self->ob_descr->itemsize;		if (n == 0) {			PyMem_FREE(items);			self->ob_item = NULL;			self->ob_size = 0;			self->allocated = 0;		}		else {			PyMem_Resize(items, char, n * size);			if (items == NULL)				return PyErr_NoMemory();			p = items;			for (i = 1; i < n; i++) {				p += size;				memcpy(p, items, size);			}			self->ob_item = items;			self->ob_size *= n;			self->allocated = self->ob_size;		}	}	Py_INCREF(self);	return (PyObject *)self;}  static PyObject *ins(arrayobject *self, Py_ssize_t where, PyObject *v){	if (ins1(self, where, v) != 0)		return NULL;	Py_INCREF(Py_None);	return Py_None;} static PyObject *array_count(arrayobject *self, PyObject *v){	Py_ssize_t count = 0;	Py_ssize_t i; 	for (i = 0; i < self->ob_size; i++) {		PyObject *selfi = getarrayitem((PyObject *)self, i);		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);		Py_DECREF(selfi);		if (cmp > 0)			count++;		else if (cmp < 0)			return NULL;	}	return PyInt_FromSsize_t(count);} PyDoc_STRVAR(count_doc,"count(x)\n\\n\Return number of occurences of x in the array."); static PyObject *array_index(arrayobject *self, PyObject *v){	Py_ssize_t i; 	for (i = 0; i < self->ob_size; i++) {		PyObject *selfi = getarrayitem((PyObject *)self, i);		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);		Py_DECREF(selfi);		if (cmp > 0) {			return PyInt_FromLong((long)i);		}		else if (cmp < 0)			return NULL;	}	PyErr_SetString(PyExc_ValueError, "array.index(x): x not in list");	return NULL;} PyDoc_STRVAR(index_doc,"index(x)\n\\n\Return index of first occurence of x in the array."); static intarray_contains(arrayobject *self, PyObject *v){	Py_ssize_t i;	int cmp; 	for (i = 0, cmp = 0 ; cmp == 0 && i < self->ob_size; i++) {		PyObject *selfi = getarrayitem((PyObject *)self, i);		cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);		Py_DECREF(selfi);	}	return cmp;} static PyObject *array_remove(arrayobject *self, PyObject *v){	int i; 	for (i = 0; i < self->ob_size; i++) {		PyObject *selfi = getarrayitem((PyObject *)self,i);		int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);		Py_DECREF(selfi);		if (cmp > 0) {			if (array_ass_slice(self, i, i+1,					   (PyObject *)NULL) != 0)				return NULL;			Py_INCREF(Py_None);			return Py_None;		}		else if (cmp < 0)			return NULL;	}	PyErr_SetString(PyExc_ValueError, "array.remove(x): x not in list");	return NULL;} PyDoc_STRVAR(remove_doc,"remove(x)\n\\n\Remove the first occurence of x in the array."); static PyObject *array_pop(arrayobject *self, PyObject *args){	Py_ssize_t i = -1;	PyObject *v;	if (!PyArg_ParseTuple(args, "|n:pop", &i))		return NULL;	if (self->ob_size == 0) {		/* Special-case most common failure cause */		PyErr_SetString(PyExc_IndexError, "pop from empty array");		return NULL;	}	if (i < 0)		i += self->ob_size;	if (i < 0 || i >= self->ob_size) {

Lines 501–1000 of 2141. Previous lines Load more