PageRenderTime 201ms CodeModel.GetById 20ms app.highlight 158ms RepoModel.GetById 1ms app.codeStats 1ms

/Modules/arraymodule.c

http://unladen-swallow.googlecode.com/
C | 2241 lines | 1951 code | 211 blank | 79 comment | 412 complexity | 938d3ec52719d97fbeb115a77fbc6898 MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   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
  18struct 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 */
  24struct 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
  31typedef 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
  39static PyTypeObject Arraytype;
  40
  41#define array_Check(op) PyObject_TypeCheck(op, &Arraytype)
  42#define array_CheckExact(op) (Py_TYPE(op) == &Arraytype)
  43
  44static int
  45array_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/****************************************************************************
  93Get and Set functions for each type.
  94A Get function takes an arrayobject* and an integer index, returning the
  95array value at that index wrapped in an appropriate PyObject*.
  96A Set function takes an arrayobject, integer index, and PyObject*; sets
  97the array value at that index to the raw C data extracted from the PyObject*,
  98and returns 0 if successful, else nonzero on failure (PyObject* not of an
  99appropriate type or value).
 100Note that the basic Get and Set functions do NOT check that the index is
 101in bounds; that's the responsibility of the caller.
 102****************************************************************************/
 103
 104static PyObject *
 105c_getitem(arrayobject *ap, Py_ssize_t i)
 106{
 107	return PyString_FromStringAndSize(&((char *)ap->ob_item)[i], 1);
 108}
 109
 110static int
 111c_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
 121static PyObject *
 122b_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
 130static int
 131b_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
 154static PyObject *
 155BB_getitem(arrayobject *ap, Py_ssize_t i)
 156{
 157	long x = ((unsigned char *)ap->ob_item)[i];
 158	return PyInt_FromLong(x);
 159}
 160
 161static int
 162BB_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
 174static PyObject *
 175u_getitem(arrayobject *ap, Py_ssize_t i)
 176{
 177	return PyUnicode_FromUnicode(&((Py_UNICODE *) ap->ob_item)[i], 1);
 178}
 179
 180static int
 181u_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
 199static PyObject *
 200h_getitem(arrayobject *ap, Py_ssize_t i)
 201{
 202	return PyInt_FromLong((long) ((short *)ap->ob_item)[i]);
 203}
 204
 205static int
 206h_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
 217static PyObject *
 218HH_getitem(arrayobject *ap, Py_ssize_t i)
 219{
 220	return PyInt_FromLong((long) ((unsigned short *)ap->ob_item)[i]);
 221}
 222
 223static int
 224HH_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
 246static PyObject *
 247i_getitem(arrayobject *ap, Py_ssize_t i)
 248{
 249	return PyInt_FromLong((long) ((int *)ap->ob_item)[i]);
 250}
 251
 252static int
 253i_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
 264static PyObject *
 265II_getitem(arrayobject *ap, Py_ssize_t i)
 266{
 267	return PyLong_FromUnsignedLong(
 268		(unsigned long) ((unsigned int *)ap->ob_item)[i]);
 269}
 270
 271static int
 272II_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
 303static PyObject *
 304l_getitem(arrayobject *ap, Py_ssize_t i)
 305{
 306	return PyInt_FromLong(((long *)ap->ob_item)[i]);
 307}
 308
 309static int
 310l_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
 320static PyObject *
 321LL_getitem(arrayobject *ap, Py_ssize_t i)
 322{
 323	return PyLong_FromUnsignedLong(((unsigned long *)ap->ob_item)[i]);
 324}
 325
 326static int
 327LL_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
 358static PyObject *
 359f_getitem(arrayobject *ap, Py_ssize_t i)
 360{
 361	return PyFloat_FromDouble((double) ((float *)ap->ob_item)[i]);
 362}
 363
 364static int
 365f_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
 375static PyObject *
 376d_getitem(arrayobject *ap, Py_ssize_t i)
 377{
 378	return PyFloat_FromDouble(((double *)ap->ob_item)[i]);
 379}
 380
 381static int
 382d_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 */
 393static 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/****************************************************************************
 412Implementations of array object methods.
 413****************************************************************************/
 414
 415static PyObject *
 416newarrayobject(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
 452static PyObject *
 453getarrayitem(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
 462static int
 463ins1(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
 494static void
 495array_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
 504static PyObject *
 505array_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
 590static Py_ssize_t
 591array_length(arrayobject *a)
 592{
 593	return Py_SIZE(a);
 594}
 595
 596static PyObject *
 597array_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
 606static PyObject *
 607array_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
 628static PyObject *
 629array_copy(arrayobject *a, PyObject *unused)
 630{
 631	return array_slice(a, 0, Py_SIZE(a));
 632}
 633
 634PyDoc_STRVAR(copy_doc,
 635"copy(array)\n\
 636\n\
 637 Return a copy of the array.");
 638
 639static PyObject *
 640array_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
 670static PyObject *
 671array_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
 696static int
 697array_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
 771static int
 772array_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
 784static int
 785setarrayitem(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
 791static int
 792array_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
 814static int
 815array_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
 850static PyObject *
 851array_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
 865static PyObject *
 866array_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
 908static PyObject *
 909ins(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
 917static PyObject *
 918array_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
 935PyDoc_STRVAR(count_doc,
 936"count(x)\n\
 937\n\
 938Return number of occurrences of x in the array.");
 939
 940static PyObject *
 941array_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
 959PyDoc_STRVAR(index_doc,
 960"index(x)\n\
 961\n\
 962Return index of first occurrence of x in the array.");
 963
 964static int
 965array_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
 978static PyObject *
 979array_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
1001PyDoc_STRVAR(remove_doc,
1002"remove(x)\n\
1003\n\
1004Remove the first occurrence of x in the array.");
1005
1006static PyObject *
1007array_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
1032PyDoc_STRVAR(pop_doc,
1033"pop([i])\n\
1034\n\
1035Return the i-th element and delete it from the array. i defaults to -1.");
1036
1037static PyObject *
1038array_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
1046PyDoc_STRVAR(extend_doc,
1047"extend(array or iterable)\n\
1048\n\
1049 Append items to the end of the array.");
1050
1051static PyObject *
1052array_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
1061PyDoc_STRVAR(insert_doc,
1062"insert(i,x)\n\
1063\n\
1064Insert a new item x into the array before position i.");
1065
1066
1067static PyObject *
1068array_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
1081PyDoc_STRVAR(buffer_info_doc,
1082"buffer_info() -> (address, length)\n\
1083\n\
1084Return a tuple (address, length) giving the current memory address and\n\
1085the length in items of the buffer used to hold array's contents\n\
1086The length should be multiplied by the itemsize attribute to calculate\n\
1087the buffer length in bytes.");
1088
1089
1090static PyObject *
1091array_append(arrayobject *self, PyObject *v)
1092{
1093	return ins(self, (int) Py_SIZE(self), v);
1094}
1095
1096PyDoc_STRVAR(append_doc,
1097"append(x)\n\
1098\n\
1099Append new value x to the end of the array.");
1100
1101
1102static PyObject *
1103array_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
1153PyDoc_STRVAR(byteswap_doc,
1154"byteswap()\n\
1155\n\
1156Byteswap all items of the array.  If the items in the array are not 1, 2,\n\
11574, or 8 bytes in size, RuntimeError is raised.");
1158
1159static PyObject *
1160array_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
1191PyDoc_STRVAR(array_doc, "Return state information for pickling.");
1192
1193static PyObject *
1194array_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
1220PyDoc_STRVAR(reverse_doc,
1221"reverse()\n\
1222\n\
1223Reverse the order of the items in the array.");
1224
1225static PyObject *
1226array_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
1274PyDoc_STRVAR(fromfile_doc,
1275"fromfile(f, n)\n\
1276\n\
1277Read n objects from the file object f and append them to the end of the\n\
1278array.  Also called as read.");
1279
1280
1281static PyObject *
1282array_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
1291static PyObject *
1292array_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
1313PyDoc_STRVAR(tofile_doc,
1314"tofile(f)\n\
1315\n\
1316Write all items (as machine values) to the file object f.  Also called as\n\
1317write.");
1318
1319
1320static PyObject *
1321array_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
1330static PyObject *
1331array_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
1372PyDoc_STRVAR(fromlist_doc,
1373"fromlist(list)\n\
1374\n\
1375Append items to array from list.");
1376
1377
1378static PyObject *
1379array_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
1397PyDoc_STRVAR(tolist_doc,
1398"tolist() -> list\n\
1399\n\
1400Convert array to an ordinary list with the same items.");
1401
1402
1403static PyObject *
1404array_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
1438PyDoc_STRVAR(fromstring_doc,
1439"fromstring(string)\n\
1440\n\
1441Appends items from the string, interpreting it as an array of machine\n\
1442values,as if it had been read from a file using the fromfile() method).");
1443
1444
1445static PyObject *
1446array_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
1456PyDoc_STRVAR(tostring_doc,
1457"tostring() -> string\n\
1458\n\
1459Convert the array to an array of machine values and return the string\n\
1460representation.");
1461
1462
1463
1464#ifdef Py_USING_UNICODE
1465static PyObject *
1466array_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
1500PyDoc_STRVAR(fromunicode_doc,
1501"fromunicode(ustr)\n\
1502\n\
1503Extends this array with data from the unicode string ustr.\n\
1504The array must be a type 'u' array; otherwise a ValueError\n\
1505is raised.  Use array.fromstring(ustr.decode(...)) to\n\
1506append Unicode data to an array of some other type.");
1507
1508
1509static PyObject *
1510array_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
1520PyDoc_STRVAR(tounicode_doc,
1521"tounicode() -> unicode\n\
1522\n\
1523Convert the array to a unicode string.  The array must be\n\
1524a type 'u' array; otherwise a ValueError is raised.  Use\n\
1525array.tostring().decode() to obtain a unicode string from\n\
1526an array of some other type.");
1527
1528#endif /* Py_USING_UNICODE */
1529
1530
1531static PyObject *
1532array_get_typecode(arrayobject *a, void *closure)
1533{
1534	char tc = a->ob_descr->typecode;
1535	return PyString_FromStringAndSize(&tc, 1);
1536}
1537
1538static PyObject *
1539array_get_itemsize(arrayobject *a, void *closure)
1540{
1541	return PyInt_FromLong((long)a->ob_descr->itemsize);
1542}
1543
1544static 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
1552static 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
1608static PyObject *
1609array_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
1640static PyObject*
1641array_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
1699static int
1700array_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		Py_ssize_t cur, i;
1798		
1799		if (step < 0) {
1800			stop = start + 1;
1801			start = stop + step * (slicelength - 1) - 1;
1802			step = -step;
1803		}
1804		for (cur = start, i = 0; i < slicelength;
1805		     cur += step, i++) {
1806			Py_ssize_t lim = step - 1;
1807
1808			if (cur + step >= Py_SIZE(self))
1809				lim = Py_SIZE(self) - cur - 1;
1810			memmove(self->ob_item + (cur - i) * itemsize,
1811				self->ob_item + (cur + 1) * itemsize,
1812				lim * itemsize);
1813		}
1814		cur = start + slicelength * step;
1815		if (cur < Py_SIZE(self)) {
1816			memmove(self->ob_item + (cur-slicelength) * itemsize,
1817				self->ob_item + cur * itemsize,
1818				(Py_SIZE(self) - cur) * itemsize);
1819		}
1820		if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
1821			return -1;
1822		return 0;
1823	}
1824	else {
1825		Py_ssize_t cur, i;
1826
1827		if (needed != slicelength) {
1828			PyErr_Format(PyExc_ValueError,
1829				"attempt to assign array of size %zd "
1830				"to extended slice of size %zd",
1831				needed, slicelength);
1832			return -1;
1833		}
1834		for (cur = start, i = 0; i < slicelength;
1835		     cur += step, i++) {
1836			memcpy(self->ob_item + cur * itemsize,
1837			       other->ob_item + i * itemsize,
1838			       itemsize);
1839		}
1840		return 0;
1841	}
1842}
1843
1844static PyMappingMethods array_as_mapping = {
1845	(lenfunc)array_length,
1846	(binaryfunc)array_subscr,
1847	(objobjargproc)array_ass_subscr
1848};
1849
1850static const void *emptybuf = "";
1851
1852static Py_ssize_t
1853array_buffer_getreadbuf(arrayobject *self, Py_ssize_t index, const void **ptr)
1854{
1855	if ( index != 0 ) {
1856		PyErr_SetString(PyExc_SystemError,
1857				"Accessing non-existent array segment");
1858		return -1;
1859	}
1860	*ptr = (void *)self->ob_item;
1861	if (*ptr == NULL)
1862		*ptr = emptybuf;
1863	return Py_SIZE(self)*self->ob_descr->itemsize;
1864}
1865
1866static Py_ssize_t
1867array_buffer_getwritebuf(arrayobject *self, Py_ssize_t index, const void **ptr)
1868{
1869	if ( index != 0 ) {
1870		PyErr_SetString(PyExc_SystemError,
1871				"Accessing non-existent array segment");
1872		return -1;
1873	}
1874	*ptr = (void *)self->ob_item;
1875	if (*ptr == NULL)
1876		*ptr = emptybuf;
1877	return Py_SIZE(self)*self->ob_descr->itemsize;
1878}
1879
1880static Py_ssize_t
1881array_buffer_getsegcount(arrayobject *self, Py_ssize_t *lenp)
1882{
1883	if ( lenp )
1884		*lenp = Py_SIZE(self)*self->ob_descr->itemsize;
1885	return 1;
1886}
1887
1888static PySequenceMethods array_as_sequence = {
1889	(lenfunc)array_length,		        /*sq_length*/
1890	(binaryfunc)array_concat,               /*sq_concat*/
1891	(ssizeargfunc)array_repeat,		/*sq_repeat*/
1892	(ssizeargfunc)array_item,		        /*sq_item*/
1893	(ssizessizeargfunc)array_slice,		/*sq_slice*/
1894	(ssizeobjargproc)array_ass_item,		/*sq_ass_item*/
1895	(ssizessizeobjargproc)array_ass_slice,	/*sq_ass_slice*/
1896	(objobjproc)array_contains,		/*sq_contains*/
1897	(binaryfunc)array_inplace_concat,	/*sq_inplace_concat*/
1898	(ssizeargfunc)array_inplace_repeat	/*sq_inplace_repeat*/
1899};
1900
1901static PyBufferProcs array_as_buffer = {
1902	(readbufferproc)array_buffer_getreadbuf,
1903	(writebufferproc)array_buffer_getwritebuf,
1904	(segcountproc)array_buffer_getsegcount,
1905	NULL,
1906};
1907
1908static PyObject *
1909array_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
1910{
1911	char c;
1912	PyObject *initial = NULL, *it = NULL;
1913	struct arraydescr *descr;
1914	
1915	if (type == &Arraytype && !_PyArg_NoKeywords("array.array()", kwds))
1916		return NULL;
1917
1918	if (!PyArg_ParseTuple(args, "c|O:array", &c, &initial))
1919		return NULL;
1920
1921	if (!(initial == NULL || PyList_Check(initial)
1922	      || PyString_Check(initial) || PyTuple_Check(initial)
1923	      || (c == 'u' && PyUnicode_Check(initial)))) {
1924		it = PyObject_GetIter(initial);
1925		if (it == NULL)
1926			return NULL;
1927		/* We set initial to NULL so that the subsequent code
1928		   will create an empty array of the appropriate type
1929		   and afterwards we can use array_iter_extend to populate
1930		   the array.
1931		*/
1932		initial = NULL;
1933	}
1934	for (descr = descriptors; descr->typecode != '\0'; descr++) {
1935		if (descr->typecode == c) {
1936			PyObject *a;
1937			Py_ssize_t len;
1938
1939			if (initial == NULL || !(PyList_Check(initial) 
1940				|| PyTuple_Check(initial)))
1941				len = 0;
1942			else
1943				len = PySequence_Size(initial);
1944
1945			a = newarrayobject(type, len, descr);
1946			if (a == NULL)
1947				return NULL;
1948
1949			if (len > 0) {
1950				Py_ssize_t i;
1951				for (i = 0; i < len; i++) {
1952					PyObject *v =
1953					        PySequence_GetItem(initial, i);
1954					if (v == NULL) {
1955						Py_DECREF(a);
1956						return NULL;
1957					}
1958					if (setarrayitem(a, i, v) != 0) {
1959						Py_DECREF(v);
1960						Py_DECREF(a);
1961						return NULL;
1962					}
1963					Py_DECREF(v);
1964				}
1965			} else if (initial != NULL && PyString_Check(initial)) {
1966				PyObject *t_initial, *v;
1967				t_initial = PyTuple_Pack(1, initial);
1968				if (t_initial == NULL) {
1969					Py_DECREF(a);
1970					return NULL;
1971				}
1972				v = array_fromstring((arrayobject *)a,
1973							 t_initial);
1974				Py_DECREF(t_initial);
1975				if (v == NULL) {
1976					Py_DECREF(a);
1977					return NULL;
1978				}
1979				Py_DECREF(v);
1980#ifdef Py_USING_UNICODE
1981			} else if (initial != NULL && PyUnicode_Check(initial))  {
1982				Py_ssize_t n = PyUnicode_GET_DATA_SIZE(initial);
1983				if (n > 0) {
1984					arrayobject *self = (arrayobject *)a;
1985					char *item = self->ob_item;
1986					item = (char *)PyMem_Realloc(item, n);
1987					if (item == NULL) {
1988						PyErr_NoMemory();
1989						Py_DECREF(a);
1990						return NULL;
1991					}
1992					self->ob_item = item;
1993					Py_SIZE(self) = n / sizeof(Py_UNICODE);
1994					memcpy(item, PyUnicode_AS_DATA(initial), n);
1995					self->allocated = Py_SIZE(self);
1996				}
1997#endif
1998			}
1999			if (it != NULL) {
2000				if (array_iter_extend((arrayobject *)a, it) == -1) {
2001					Py_DECREF(it);
2002					Py_DECREF(a);
2003					return NULL;
2004				}
2005				Py_DECREF(it);
2006			}
2007			return a;
2008		}
2009	}
2010	PyErr_SetString(PyExc_ValueError,
2011		"bad typecode (must be c, b, B, u, h, H, i, I, l, L, f or d)");
2012	return NULL;
2013}
2014
2015
2016PyDoc_STRVAR(module_doc,
2017"This module defines an object type which can efficiently represent\n\
2018an array of basic values: characters, integers, floating point\n\
2019numbers.  Arrays are sequence types and behave very much like lists,\n\
2020except that the type of objects stored in them is constrained.  The\n\
2021type is specified at object creation time by using a type code, which\n\
2022is a single character.  The following type codes are defined:\n\
2023\n\
2024    Type code   C Type             Minimum size in bytes \n\
2025    'c'         character          1 \n\
2026    'b'         signed integer     1 \n\
2027    'B'         unsigned integer   1 \n\
2028    'u'         Unicode character  2 \n\
2029    'h'         signed integer     2 \n\
2030    'H'         unsigned integer   2 \n\
2031    'i'         signed integer     2 \n\
2032    'I'         unsigned integer   2 \n\
2033    'l'         signed integer     4 \n\
2034    'L'         unsigned integer   4 \n\
2035    'f'         floating point     4 \n\
2036    'd'         floating point     8 \n\
2037\n\
2038The constructor is:\n\
2039\n\
2040array(typecode [, initializer]) -- create a new array\n\
2041");
2042
2043PyDoc_STRVAR(arraytype_doc,
2044"array(typecode [, initializer]) -> array\n\
2045\n\
2046Return a new array whose items are restricted by typecode, and\n\
2047initialized from the optional initializer value, which must be a list,\n\
2048string. or iterable over elements of the appropriate type.\n\
2049\n\
2050Arrays represent basic values and behave very much like lists, except\n\
2051the type of objects stored in them is constrained.\n\
2052\n\
2053Methods:\n\
2054\n\
2055append() -- append a new item to the end of the array\n\
2056buffer_info() -- return information giving the current memory info\n\
2057byteswap() -- byteswap all the items of the array\n\
2058count() -- return number of occurrences of an object\n\
2059extend() -- extend array by appending multiple elements from an iterable\n\
2060fromfile() -- read items from a file object\n\
2061fromlist() -- append items from the list\n\
2062fromstring() -- append items from the string\n\
2063index() -- return index of first occurrence of an object\n\
2064insert() -- insert a new item into the array at a provided position\n\
2065pop() -- remove and return item (default last)\n\
2066read() -- DEPRECATED…

Large files files are truncated, but you can click here to view the full file