cpython-lru_cache-weakref: Modules/arraymodule.c annotate

annotate Modules/arraymodule.c @ 45337:8cbe0bd93c28 2.5

Added checks for integer overflows, contributed by Google. Some are only available if asserts are left in the code, in cases where they can't be triggered from Python code.

author	Martin v. Löwis <martin@v.loewis.de>
date	Thu, 14 Feb 2008 11:26:18 +0000
parents	4a03860ae08b
children	4504dfcc1924

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

Mercurial > cpython-lru_cache-weakref

annotate Modules/arraymodule.c @ 45337:8cbe0bd93c28 2.5