PyErr_SetString(PyExc_IndexError, "pop index out of range");		return NULL;	}	v = getarrayitem((PyObject *)self,i);	if (array_ass_slice(self, i, i+1, (PyObject *)NULL) != 0) {		Py_DECREF(v);		return NULL;	}	return v;} PyDoc_STRVAR(pop_doc,"pop([i])\n\\n\Return the i-th element and delete it from the array. i defaults to -1."); static PyObject *array_extend(arrayobject *self, PyObject *bb){	if (array_do_extend(self, bb) == -1)		return NULL;	Py_INCREF(Py_None);	return Py_None;} PyDoc_STRVAR(extend_doc,"extend(array or iterable)\n\\n\ Append items to the end of the array."); static PyObject *array_insert(arrayobject *self, PyObject *args){	Py_ssize_t i;	PyObject *v;        if (!PyArg_ParseTuple(args, "nO:insert", &i, &v))		return NULL;	return ins(self, i, v);} PyDoc_STRVAR(insert_doc,"insert(i,x)\n\\n\Insert a new item x into the array before position i.");  static PyObject *array_buffer_info(arrayobject *self, PyObject *unused){	PyObject* retval = NULL;	retval = PyTuple_New(2);	if (!retval)		return NULL; 	PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));	PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(self->ob_size))); 	return retval;} PyDoc_STRVAR(buffer_info_doc,"buffer_info() -> (address, length)\n\\n\Return a tuple (address, length) giving the current memory address and\n\the length in items of the buffer used to hold array's contents\n\The length should be multiplied by the itemsize attribute to calculate\n\the buffer length in bytes.");  static PyObject *array_append(arrayobject *self, PyObject *v){	return ins(self, (int) self->ob_size, v);} PyDoc_STRVAR(append_doc,"append(x)\n\\n\Append new value x to the end of the array.");  static PyObject *array_byteswap(arrayobject *self, PyObject *unused){	char *p;	Py_ssize_t i; 	switch (self->ob_descr->itemsize) {	case 1:		break;	case 2:		for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 2) {			char p0 = p[0];			p[0] = p[1];			p[1] = p0;		}		break;	case 4:		for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 4) {			char p0 = p[0];			char p1 = p[1];			p[0] = p[3];			p[1] = p[2];			p[2] = p1;			p[3] = p0;		}		break;	case 8:		for (p = self->ob_item, i = self->ob_size; --i >= 0; p += 8) {			char p0 = p[0];			char p1 = p[1];			char p2 = p[2];			char p3 = p[3];			p[0] = p[7];			p[1] = p[6];			p[2] = p[5];			p[3] = p[4];			p[4] = p3;			p[5] = p2;			p[6] = p1;			p[7] = p0;		}		break;	default:		PyErr_SetString(PyExc_RuntimeError,			   "don't know how to byteswap this array type");		return NULL;	}	Py_INCREF(Py_None);	return Py_None;} PyDoc_STRVAR(byteswap_doc,"byteswap()\n\\n\Byteswap all items of the array.  If the items in the array are not 1, 2,\n\4, or 8 bytes in size, RuntimeError is raised."); static PyObject *array_reduce(arrayobject *array){	PyObject *dict, *result; 	dict = PyObject_GetAttrString((PyObject *)array, "__dict__");	if (dict == NULL) {		PyErr_Clear();		dict = Py_None;		Py_INCREF(dict);	}	if (array->ob_size > 0) {		result = Py_BuildValue("O(cs#)O", 			array->ob_type, 			array->ob_descr->typecode,			array->ob_item,			array->ob_size * array->ob_descr->itemsize,			dict);	} else {		result = Py_BuildValue("O(c)O", 			array->ob_type, 			array->ob_descr->typecode,			dict);	}	Py_DECREF(dict);	return result;} PyDoc_STRVAR(array_doc, "Return state information for pickling."); static PyObject *array_reverse(arrayobject *self, PyObject *unused){	register Py_ssize_t itemsize = self->ob_descr->itemsize;	register char *p, *q;	/* little buffer to hold items while swapping */	char tmp[256];	/* 8 is probably enough -- but why skimp */	assert((size_t)itemsize <= sizeof(tmp)); 	if (self->ob_size > 1) {		for (p = self->ob_item,		     q = self->ob_item + (self->ob_size - 1)*itemsize;		     p < q;		     p += itemsize, q -= itemsize) {			/* memory areas guaranteed disjoint, so memcpy			 * is safe (& memmove may be slower).			 */			memcpy(tmp, p, itemsize);			memcpy(p, q, itemsize);			memcpy(q, tmp, itemsize);		}	} 	Py_INCREF(Py_None);	return Py_None;} PyDoc_STRVAR(reverse_doc,"reverse()\n\\n\Reverse the order of the items in the array."); static PyObject *array_fromfile(arrayobject *self, PyObject *args){	PyObject *f;	Py_ssize_t n;	FILE *fp;        if (!PyArg_ParseTuple(args, "On:fromfile", &f, &n))		return NULL;	fp = PyFile_AsFile(f);	if (fp == NULL) {		PyErr_SetString(PyExc_TypeError, "arg1 must be open file");		return NULL;	}	if (n > 0) {		char *item = self->ob_item;		Py_ssize_t itemsize = self->ob_descr->itemsize;		size_t nread;		Py_ssize_t newlength;		size_t newbytes;		/* Be careful here about overflow */		if ((newlength = self->ob_size + n) <= 0 ||		    (newbytes = newlength * itemsize) / itemsize !=		    (size_t)newlength)			goto nomem;		PyMem_RESIZE(item, char, newbytes);		if (item == NULL) {		  nomem:			PyErr_NoMemory();			return NULL;		}		self->ob_item = item;		self->ob_size += n;		self->allocated = self->ob_size;		nread = fread(item + (self->ob_size - n) * itemsize,			      itemsize, n, fp);		if (nread < (size_t)n) {		  self->ob_size -= (n - nread);			PyMem_RESIZE(item, char, self->ob_size*itemsize);			self->ob_item = item;			self->allocated = self->ob_size;			PyErr_SetString(PyExc_EOFError,				         "not enough items in file");			return NULL;		}	}	Py_INCREF(Py_None);	return Py_None;} PyDoc_STRVAR(fromfile_doc,"fromfile(f, n)\n\\n\Read n objects from the file object f and append them to the end of the\n\array.  Also called as read.");  static PyObject *array_tofile(arrayobject *self, PyObject *f){	FILE *fp; 	fp = PyFile_AsFile(f);	if (fp == NULL) {		PyErr_SetString(PyExc_TypeError, "arg must be open file");		return NULL;	}	if (self->ob_size > 0) {		if (fwrite(self->ob_item, self->ob_descr->itemsize,			   self->ob_size, fp) != (size_t)self->ob_size) {			PyErr_SetFromErrno(PyExc_IOError);			clearerr(fp);			return NULL;		}	}	Py_INCREF(Py_None);	return Py_None;} PyDoc_STRVAR(tofile_doc,"tofile(f)\n\\n\Write all items (as machine values) to the file object f.  Also called as\n\write.");  static PyObject *array_fromlist(arrayobject *self, PyObject *list){	Py_ssize_t n;	Py_ssize_t itemsize = self->ob_descr->itemsize; 	if (!PyList_Check(list)) {		PyErr_SetString(PyExc_TypeError, "arg must be list");		return NULL;	}	n = PyList_Size(list);	if (n > 0) {		char *item = self->ob_item;		Py_ssize_t i;		PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize);		if (item == NULL) {			PyErr_NoMemory();			return NULL;		}		self->ob_item = item;		self->ob_size += n;		self->allocated = self->ob_size;		for (i = 0; i < n; i++) {			PyObject *v = PyList_GetItem(list, i);			if ((*self->ob_descr->setitem)(self,					self->ob_size - n + i, v) != 0) {				self->ob_size -= n;				PyMem_RESIZE(item, char,					          self->ob_size * itemsize);				self->ob_item = item;				self->allocated = self->ob_size;				return NULL;			}		}	}	Py_INCREF(Py_None);	return Py_None;} PyDoc_STRVAR(fromlist_doc,"fromlist(list)\n\\n\Append items to array from list.");  static PyObject *array_tolist(arrayobject *self, PyObject *unused){	PyObject *list = PyList_New(self->ob_size);	Py_ssize_t i; 	if (list == NULL)		return NULL;	for (i = 0; i < self->ob_size; i++) {		PyObject *v = getarrayitem((PyObject *)self, i);		if (v == NULL) {			Py_DECREF(list);			return NULL;		}		PyList_SetItem(list, i, v);	}	return list;} PyDoc_STRVAR(tolist_doc,"tolist() -> list\n\\n\Convert array to an ordinary list with the same items.");  static PyObject *array_fromstring(arrayobject *self, PyObject *args){	char *str;	Py_ssize_t n;	int itemsize = self->ob_descr->itemsize;        if (!PyArg_ParseTuple(args, "s#:fromstring", &str, &n))		return NULL;	if (n % itemsize != 0) {		PyErr_SetString(PyExc_ValueError,			   "string length not a multiple of item size");		return NULL;	}	n = n / itemsize;	if (n > 0) {		char *item = self->ob_item;		PyMem_RESIZE(item, char, (self->ob_size + n) * itemsize);		if (item == NULL) {			PyErr_NoMemory();			return NULL;		}		self->ob_item = item;		self->ob_size += n;		self->allocated = self->ob_size;		memcpy(item + (self->ob_size - n) * itemsize,		       str, itemsize*n);	}	Py_INCREF(Py_None);	return Py_None;} PyDoc_STRVAR(fromstring_doc,"fromstring(string)\n\\n\Appends items from the string, interpreting it as an array of machine\n\values,as if it had been read from a file using the fromfile() method).");  static PyObject *array_tostring(arrayobject *self, PyObject *unused){	return PyString_FromStringAndSize(self->ob_item,				    self->ob_size * self->ob_descr->itemsize);} PyDoc_STRVAR(tostring_doc,"tostring() -> string\n\\n\Convert the array to an array of machine values and return the string\n\representation.");   #ifdef Py_USING_UNICODEstatic PyObject *array_fromunicode(arrayobject *self, PyObject *args){	Py_UNICODE *ustr;	Py_ssize_t n;         if (!PyArg_ParseTuple(args, "u#:fromunicode", &ustr, &n))		return NULL;	if (self->ob_descr->typecode != 'u') {		PyErr_SetString(PyExc_ValueError,			"fromunicode() may only be called on "			"type 'u' arrays");		return NULL;	}	if (n > 0) {		Py_UNICODE *item = (Py_UNICODE *) self->ob_item;		PyMem_RESIZE(item, Py_UNICODE, self->ob_size + n);		if (item == NULL) {			PyErr_NoMemory();			return NULL;		}		self->ob_item = (char *) item;		self->ob_size += n;		self->allocated = self->ob_size;		memcpy(item + self->ob_size - n,		       ustr, n * sizeof(Py_UNICODE));	} 	Py_INCREF(Py_None);	return Py_None;} PyDoc_STRVAR(fromunicode_doc,"fromunicode(ustr)\n\\n\Extends this array with data from the unicode string ustr.\n\The array must be a type 'u' array; otherwise a ValueError\n\is raised.  Use array.fromstring(ustr.decode(...)) to\n\append Unicode data to an array of some other type.");  static PyObject *array_tounicode(arrayobject *self, PyObject *unused){	if (self->ob_descr->typecode != 'u') {		PyErr_SetString(PyExc_ValueError,			"tounicode() may only be called on type 'u' arrays");		return NULL;	}	return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, self->ob_size);} PyDoc_STRVAR(tounicode_doc,"tounicode() -> unicode\n\\n\Convert the array to a unicode string.  The array must be\n\a type 'u' array; otherwise a ValueError is raised.  Use\n\array.tostring().decode() to obtain a unicode string from\n\an array of some other type."); #endif /* Py_USING_UNICODE */  static PyObject *array_get_typecode(arrayobject *a, void *closure){	char tc = a->ob_descr->typecode;	return PyString_FromStringAndSize(&tc, 1);} static PyObject *array_get_itemsize(arrayobject *a, void *closure){	return PyInt_FromLong((long)a->ob_descr->itemsize);} static PyGetSetDef array_getsets [] = {	{"typecode", (getter) array_get_typecode, NULL,	 "the typecode character used to create the array"},	{"itemsize", (getter) array_get_itemsize, NULL,	 "the size, in bytes, of one array item"},	{NULL}}; PyMethodDef array_methods[] = {	{"append",	(PyCFunction)array_append,	METH_O,	 append_doc},	{"buffer_info", (PyCFunction)array_buffer_info, METH_NOARGS,	 buffer_info_doc},	{"byteswap",	(PyCFunction)array_byteswap,	METH_NOARGS,	 byteswap_doc},

Lines 1001–1500 of 2141. Previous lines Load more