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

annotate Modules/arraymodule.c @ 58973:db86bf39ccaa legacy-trunk

Issue 7970: When email.Parser.Parser parses a MIME message of type message/rfc822 it turns it into an object whose body consists of a list containing a single Message object. HeaderParser, on the other hand, just copies the body as a string. Generator.flatten has a special handler for the message mime type that expected the body to be the one item list. This fails if the message was parsed by HeaderParser. So we now check to see if the body is a string first, and if so just we just emit it.

author	R. David Murray <rdmurray@bitdance.com>
date	Sun, 21 Feb 2010 04:23:00 +0000
parents	5e6edb4e76f5
children	fd25030223b0

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)
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	42 #define array_CheckExact(op) (Py_TYPE(op) == &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 &&
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	56 Py_SIZE(self) < newsize + 16 &&
31659 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) {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	58 Py_SIZE(self) = newsize;
31659 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
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	74 _new_size = (newsize >> 4) + (Py_SIZE(self) < 8 ? 3 : 7) + newsize;
31659 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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	87 Py_SIZE(self) = newsize;
31659 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 {
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 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 }
47672 5ebcdeb0cb26 Fix some memory dealloc problems when exceptions occur. Neal Norwitz <nnorwitz@gmail.com> parents: 47587 diff changeset	435 op->ob_descr = descr;
5ebcdeb0cb26 Fix some memory dealloc problems when exceptions occur. Neal Norwitz <nnorwitz@gmail.com> parents: 47587 diff changeset	436 op->allocated = size;
5ebcdeb0cb26 Fix some memory dealloc problems when exceptions occur. Neal Norwitz <nnorwitz@gmail.com> parents: 47587 diff changeset	437 op->weakreflist = NULL;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	438 Py_SIZE(op) = size;
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	439 if (size <= 0) {
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	440 op->ob_item = NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	441 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	442 else {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	443 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	444 if (op->ob_item == NULL) {
47672 5ebcdeb0cb26 Fix some memory dealloc problems when exceptions occur. Neal Norwitz <nnorwitz@gmail.com> parents: 47587 diff changeset	445 Py_DECREF(op);
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	446 return PyErr_NoMemory();
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	447 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	448 }
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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	458 assert(i>=0 && i<Py_SIZE(ap));
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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	466 Py_ssize_t n = Py_SIZE(self);
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);
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	501 Py_TYPE(op)->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
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	521 if (Py_SIZE(va) != Py_SIZE(wa) && (op == Py_EQ \|\| op == Py_NE)) {
15975 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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	533 for (i = 0; i < Py_SIZE(va) && i < Py_SIZE(wa); i++) {
15975 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 */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	552 Py_ssize_t vs = Py_SIZE(va);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	553 Py_ssize_t ws = Py_SIZE(wa);
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 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	593 return Py_SIZE(a);
1235 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 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	599 if (i < 0 \|\| i >= Py_SIZE(a)) {
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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	612 else if (ilow > Py_SIZE(a))
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	613 ilow = Py_SIZE(a);
1235 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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	618 else if (ihigh > Py_SIZE(a))
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	619 ihigh = Py_SIZE(a);
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 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	631 return array_slice(a, 0, Py_SIZE(a));
31651 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",
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	647 Py_TYPE(bb)->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 }
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	655 if (Py_SIZE(a) > PY_SSIZE_T_MAX - Py_SIZE(b)) {
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	656 return PyErr_NoMemory();
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	657 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	658 size = Py_SIZE(a) + Py_SIZE(b);
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 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	663 memcpy(np->ob_item, a->ob_item, Py_SIZE(a)*a->ob_descr->itemsize);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	664 memcpy(np->ob_item + Py_SIZE(a)*a->ob_descr->itemsize,
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	665 b->ob_item, Py_SIZE(b)*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;
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	680 if ((Py_SIZE(a) != 0) && (n > PY_SSIZE_T_MAX / Py_SIZE(a))) {
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	681 return PyErr_NoMemory();
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	682 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	683 size = Py_SIZE(a) * 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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	688 nbytes = Py_SIZE(a) * 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	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)) {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	706 n = Py_SIZE(b);
1235 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",
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	725 Py_TYPE(v)->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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	730 else if (ilow > Py_SIZE(a))
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	731 ilow = Py_SIZE(a);
1235 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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	736 else if (ihigh > Py_SIZE(a))
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	737 ihigh = Py_SIZE(a);
1235 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,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	743 (Py_SIZE(a)-ihigh)*a->ob_descr->itemsize);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	744 Py_SIZE(a) += d;
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	745 PyMem_RESIZE(item, char, Py_SIZE(a)*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;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	748 a->allocated = Py_SIZE(a);
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,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	752 (Py_SIZE(a) + 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,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	759 (Py_SIZE(a)-ihigh)*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	760 a->ob_item = item;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	761 Py_SIZE(a) += d;
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	762 a->allocated = Py_SIZE(a);
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 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	774 if (i < 0 \|\| i >= Py_SIZE(a)) {
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) {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	801 if (ins1(self, (int) Py_SIZE(self), v) != 0) {
31660 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;
48046 5d3833e6aae3 Issue #2620: Overflow checking when allocating or reallocating memory Gregory P. Smith <greg@mad-scientist.com> parents: 47678 diff changeset	818 char *old_item;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	819
31660 35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	820 if (!array_Check(bb))
35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	821 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	822 #define b ((arrayobject *)bb)
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	823 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	824 PyErr_SetString(PyExc_TypeError,
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	825 "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	826 return -1;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	827 }
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	828 if ((Py_SIZE(self) > PY_SSIZE_T_MAX - Py_SIZE(b)) \|\|
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	829 ((Py_SIZE(self) + Py_SIZE(b)) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
47672 5ebcdeb0cb26 Fix some memory dealloc problems when exceptions occur. Neal Norwitz <nnorwitz@gmail.com> parents: 47587 diff changeset	830 PyErr_NoMemory();
5ebcdeb0cb26 Fix some memory dealloc problems when exceptions occur. Neal Norwitz <nnorwitz@gmail.com> parents: 47587 diff changeset	831 return -1;
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	832 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	833 size = Py_SIZE(self) + Py_SIZE(b);
48046 5d3833e6aae3 Issue #2620: Overflow checking when allocating or reallocating memory Gregory P. Smith <greg@mad-scientist.com> parents: 47678 diff changeset	834 old_item = self->ob_item;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	835 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	836 if (self->ob_item == NULL) {
48046 5d3833e6aae3 Issue #2620: Overflow checking when allocating or reallocating memory Gregory P. Smith <greg@mad-scientist.com> parents: 47678 diff changeset	837 self->ob_item = old_item;
47672 5ebcdeb0cb26 Fix some memory dealloc problems when exceptions occur. Neal Norwitz <nnorwitz@gmail.com> parents: 47587 diff changeset	838 PyErr_NoMemory();
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	839 return -1;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	840 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	841 memcpy(self->ob_item + Py_SIZE(self)*self->ob_descr->itemsize,
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	842 b->ob_item, Py_SIZE(b)*b->ob_descr->itemsize);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	843 Py_SIZE(self) = size;
31659 206d8575f644 Update the array overallocation scheme to match the approach used for Raymond Hettinger <python@rcn.com> parents: 31651 diff changeset	844 self->allocated = size;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	845
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	846 return 0;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	847 #undef b
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	848 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	849
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	850 static PyObject *
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	851 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	852 {
31660 35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	853 if (!array_Check(bb)) {
35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	854 PyErr_Format(PyExc_TypeError,
35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	855 "can only extend array with array (not \"%.200s\")",
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	856 Py_TYPE(bb)->tp_name);
31660 35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	857 return NULL;
35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	858 }
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	859 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	860 return NULL;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	861 Py_INCREF(self);
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	862 return (PyObject *)self;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	863 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	864
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	865 static PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	866 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	867 {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	868 char items, p;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	869 Py_ssize_t size, i;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	870
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	871 if (Py_SIZE(self) > 0) {
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	872 if (n < 0)
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	873 n = 0;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	874 items = self->ob_item;
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	875 if ((self->ob_descr->itemsize != 0) &&
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	876 (Py_SIZE(self) > PY_SSIZE_T_MAX / self->ob_descr->itemsize)) {
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	877 return PyErr_NoMemory();
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	878 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	879 size = Py_SIZE(self) * self->ob_descr->itemsize;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	880 if (n == 0) {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	881 PyMem_FREE(items);
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	882 self->ob_item = NULL;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	883 Py_SIZE(self) = 0;
31659 206d8575f644 Update the array overallocation scheme to match the approach used for Raymond Hettinger <python@rcn.com> parents: 31651 diff changeset	884 self->allocated = 0;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	885 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	886 else {
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	887 if (size > PY_SSIZE_T_MAX / n) {
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	888 return PyErr_NoMemory();
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	889 }
48046 5d3833e6aae3 Issue #2620: Overflow checking when allocating or reallocating memory Gregory P. Smith <greg@mad-scientist.com> parents: 47678 diff changeset	890 PyMem_RESIZE(items, char, n * size);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	891 if (items == NULL)
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	892 return PyErr_NoMemory();
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	893 p = items;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	894 for (i = 1; i < n; i++) {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	895 p += size;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	896 memcpy(p, items, size);
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	897 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	898 self->ob_item = items;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	899 Py_SIZE(self) *= n;
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	900 self->allocated = Py_SIZE(self);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	901 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	902 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	903 Py_INCREF(self);
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	904 return (PyObject *)self;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	905 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	906
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	907
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	908 static PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	909 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	910 {
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	911 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	912 return NULL;
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	913 Py_INCREF(Py_None);
7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	914 return Py_None;
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	915 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	916
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	917 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	918 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	919 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	920 Py_ssize_t count = 0;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	921 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	922
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	923 for (i = 0; i < Py_SIZE(self); i++) {
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	924 PyObject selfi = getarrayitem((PyObject )self, i);
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	925 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	926 Py_DECREF(selfi);
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	927 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 count++;
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	929 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	930 return NULL;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	931 }
36518 9f3f87e920a6 Use Py_ssize_t for counts and sizes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	932 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	933 }
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	934
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	935 PyDoc_STRVAR(count_doc,
14649 1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	936 "count(x)\n\
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	937 \n\
55049 74c0a78114ae Merged revisions 69846 via svnmerge from Jesus Cea <jcea@jcea.es> parents: 48046 diff changeset	938 Return number of occurrences 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	939
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	940 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	941 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	942 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	943 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	944
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	945 for (i = 0; i < Py_SIZE(self); i++) {
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	946 PyObject selfi = getarrayitem((PyObject )self, i);
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	947 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	948 Py_DECREF(selfi);
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	949 if (cmp > 0) {
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	950 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	951 }
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	952 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	953 return NULL;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	954 }
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	955 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	956 return NULL;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	957 }
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	958
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	959 PyDoc_STRVAR(index_doc,
14649 1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	960 "index(x)\n\
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	961 \n\
55049 74c0a78114ae Merged revisions 69846 via svnmerge from Jesus Cea <jcea@jcea.es> parents: 48046 diff changeset	962 Return index of first occurrence 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	963
27128 047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	964 static int
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	965 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	966 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	967 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	968 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	969
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	970 for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(self); i++) {
27128 047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	971 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	972 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	973 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	974 }
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	975 return cmp;
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	976 }
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	977
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	978 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	979 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	980 {
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	981 int i;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	982
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	983 for (i = 0; i < Py_SIZE(self); i++) {
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	984 PyObject selfi = getarrayitem((PyObject )self,i);
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	985 int cmp = PyObject_RichCompareBool(selfi, v, Py_EQ);
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	986 Py_DECREF(selfi);
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	987 if (cmp > 0) {
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	988 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	989 (PyObject *)NULL) != 0)
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	990 return NULL;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	991 Py_INCREF(Py_None);
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	992 return Py_None;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	993 }
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	994 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	995 return NULL;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	996 }
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	997 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	998 return NULL;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	999 }
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1000
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1001 PyDoc_STRVAR(remove_doc,
14649 1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1002 "remove(x)\n\
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1003 \n\
55049 74c0a78114ae Merged revisions 69846 via svnmerge from Jesus Cea <jcea@jcea.es> parents: 48046 diff changeset	1004 Remove the first occurrence 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	1005
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1006 static PyObject *
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1007 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	1008 {
36518 9f3f87e920a6 Use Py_ssize_t for counts and sizes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	1009 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	1010 PyObject *v;
36518 9f3f87e920a6 Use Py_ssize_t for counts and sizes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	1011 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	1012 return NULL;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1013 if (Py_SIZE(self) == 0) {
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1014 /* 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	1015 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	1016 return NULL;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1017 }
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1018 if (i < 0)
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1019 i += Py_SIZE(self);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1020 if (i < 0 \|\| i >= Py_SIZE(self)) {
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1021 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	1022 return NULL;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1023 }
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1024 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	1025 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	1026 Py_DECREF(v);
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1027 return NULL;
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 return v;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1030 }
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1031
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1032 PyDoc_STRVAR(pop_doc,
14649 1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1033 "pop([i])\n\
13772 eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1034 \n\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1035 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	1036
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1037 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1038 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	1039 {
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1040 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	1041 return NULL;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1042 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	1043 return Py_None;
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1044 }
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1045
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1046 PyDoc_STRVAR(extend_doc,
31660 35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	1047 "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	1048 \n\
31660 35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	1049 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	1050
eea51275acbf added count, extend, index, pop and remove to arraymodule Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13651 diff changeset	1051 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	1052 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	1053 {
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 Py_ssize_t i;
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1055 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	1056 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	1057 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1058 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	1059 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1060
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1061 PyDoc_STRVAR(insert_doc,
14649 1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1062 "insert(i,x)\n\
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1063 \n\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1064 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	1065
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1066
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1067 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1068 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	1069 {
14649 1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1070 PyObject* retval = NULL;
1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1071 retval = PyTuple_New(2);
1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1072 if (!retval)
1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1073 return NULL;
13068 705132667f7b Trent Mick <trentm@activestate.com>: Fred Drake <fdrake@acm.org> parents: 12814 diff changeset	1074
705132667f7b Trent Mick <trentm@activestate.com>: Fred Drake <fdrake@acm.org> parents: 12814 diff changeset	1075 PyTuple_SET_ITEM(retval, 0, PyLong_FromVoidPtr(self->ob_item));
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1076 PyTuple_SET_ITEM(retval, 1, PyInt_FromLong((long)(Py_SIZE(self))));
13068 705132667f7b Trent Mick <trentm@activestate.com>: Fred Drake <fdrake@acm.org> parents: 12814 diff changeset	1077
705132667f7b Trent Mick <trentm@activestate.com>: Fred Drake <fdrake@acm.org> parents: 12814 diff changeset	1078 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	1079 }
6aebd970b7a9 Added buffer_info() method that returns address and length in bytes of Guido van Rossum <guido@python.org> parents: 5696 diff changeset	1080
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1081 PyDoc_STRVAR(buffer_info_doc,
14649 1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1082 "buffer_info() -> (address, length)\n\
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1083 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1084 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	1085 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	1086 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	1087 the buffer length in bytes.");
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1088
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1089
5982 6aebd970b7a9 Added buffer_info() method that returns address and length in bytes of Guido van Rossum <guido@python.org> parents: 5696 diff changeset	1090 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1091 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	1092 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1093 return ins(self, (int) Py_SIZE(self), v);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1094 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1095
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1096 PyDoc_STRVAR(append_doc,
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1097 "append(x)\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1098 \n\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1099 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	1100
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1101
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1102 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1103 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	1104 {
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1105 char *p;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1106 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	1107
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1108 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	1109 case 1:
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1110 break;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1111 case 2:
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1112 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 2) {
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1113 char p0 = p[0];
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1114 p[0] = p[1];
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1115 p[1] = p0;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1116 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1117 break;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1118 case 4:
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1119 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 4) {
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1120 char p0 = p[0];
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1121 char p1 = p[1];
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1122 p[0] = p[3];
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1123 p[1] = p[2];
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1124 p[2] = p1;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1125 p[3] = p0;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1126 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1127 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	1128 case 8:
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1129 for (p = self->ob_item, i = Py_SIZE(self); --i >= 0; p += 8) {
1393 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 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	1131 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	1132 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	1133 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	1134 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	1135 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	1136 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	1137 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	1138 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	1139 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	1140 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	1141 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	1142 }
7d6a2d950f13 * nismodule.c: database keys and values can contain null bytes. be more Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1143 break;
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1144 default:
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1145 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	1146 "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	1147 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1148 }
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1149 Py_INCREF(Py_None);
7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1150 return Py_None;
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1151 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1152
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1153 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	1154 "byteswap()\n\
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1155 \n\
11522 cbf58cd0bb57 Correct the docstring for byteswap(); error noted by Bernhard Reiter Fred Drake <fdrake@acm.org> parents: 11242 diff changeset	1156 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	1157 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	1158
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1159 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1160 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	1161 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1162 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	1163 register char p, q;
14649 1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1164 /* little buffer to hold items while swapping */
1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1165 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	1166 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	1167
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1168 if (Py_SIZE(self) > 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	1169 for (p = self->ob_item,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1170 q = self->ob_item + (Py_SIZE(self) - 1)*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	1171 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	1172 p += itemsize, q -= itemsize) {
14649 1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1173 /* memory areas guaranteed disjoint, so memcpy
1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1174 * is safe (& memmove may be slower).
1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1175 */
1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1176 memcpy(tmp, p, itemsize);
1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1177 memcpy(p, q, itemsize);
1ec6c63347ea arraymodule: Fix SF bug 113960. Tim Peters <tim.peters@gmail.com> parents: 14499 diff changeset	1178 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	1179 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1180 }
14499 7f23ec5cd9ca General cleanup in preparation for a bugfix: removed unused code, useless Tim Peters <tim.peters@gmail.com> parents: 14375 diff changeset	1181
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1182 Py_INCREF(Py_None);
7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1183 return Py_None;
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1184 }
1393 7d6a2d950f13 * nismodule.c: database keys and values can contain null bytes. be more Guido van Rossum <guido@python.org> parents: 1391 diff changeset	1185
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1186 PyDoc_STRVAR(reverse_doc,
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1187 "reverse()\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1188 \n\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1189 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	1190
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1191 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	1192 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	1193 {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1194 PyObject *f;
36518 9f3f87e920a6 Use Py_ssize_t for counts and sizes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	1195 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	1196 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	1197 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	1198 return NULL;
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1199 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	1200 if (fp == NULL) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1201 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	1202 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1203 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1204 if (n > 0) {
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1205 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	1206 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	1207 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	1208 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	1209 size_t newbytes;
d3bece46486e Carefully check for overflow when allocating the memory for fromfile Guido van Rossum <guido@python.org> parents: 9588 diff changeset	1210 /* Be careful here about overflow */
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1211 if ((newlength = Py_SIZE(self) + n) <= 0 \|\|
10434 a4768315948d Use an unsigned cast to avoid a warning in VC++. Guido van Rossum <guido@python.org> parents: 10283 diff changeset	1212 (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	1213 (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	1214 goto nomem;
d3bece46486e Carefully check for overflow when allocating the memory for fromfile Guido van Rossum <guido@python.org> parents: 9588 diff changeset	1215 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	1216 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	1217 nomem:
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1218 PyErr_NoMemory();
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1219 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1220 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1221 self->ob_item = item;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1222 Py_SIZE(self) += n;
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1223 self->allocated = Py_SIZE(self);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1224 nread = fread(item + (Py_SIZE(self) - n) * itemsize,
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1225 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	1226 if (nread < (size_t)n) {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1227 Py_SIZE(self) -= (n - nread);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1228 PyMem_RESIZE(item, char, Py_SIZE(self)*itemsize);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1229 self->ob_item = item;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1230 self->allocated = Py_SIZE(self);
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1231 PyErr_SetString(PyExc_EOFError,
7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1232 "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	1233 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1234 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1235 }
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1236 Py_INCREF(Py_None);
7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1237 return Py_None;
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1238 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1239
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1240 PyDoc_STRVAR(fromfile_doc,
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1241 "fromfile(f, n)\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1242 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1243 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	1244 array. Also called as read.");
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1245
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1246
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1247 static PyObject *
46077 ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1248 array_fromfile_as_read(arrayobject self, PyObject args)
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1249 {
46573 aef3501d8e77 Use PyErr_WarnPy3k throughout Benjamin Peterson <benjamin@python.org> parents: 46077 diff changeset	1250 if (PyErr_WarnPy3k("array.read() not supported in 3.x; "
46578 7670005da8c5 A little reformating of Py3k warnings Benjamin Peterson <benjamin@python.org> parents: 46573 diff changeset	1251 "use array.fromfile()", 1) < 0)
46077 ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1252 return NULL;
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1253 return array_fromfile(self, args);
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1254 }
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1255
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1256
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1257 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1258 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	1259 {
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1260 FILE *fp;
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1261
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1262 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	1263 if (fp == NULL) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1264 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	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 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	1268 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	1269 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	1270 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	1271 clearerr(fp);
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1272 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1273 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1274 }
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1275 Py_INCREF(Py_None);
7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1276 return Py_None;
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1277 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1278
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1279 PyDoc_STRVAR(tofile_doc,
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1280 "tofile(f)\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1281 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1282 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	1283 write.");
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1284
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1285
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1286 static PyObject *
46077 ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1287 array_tofile_as_write(arrayobject self, PyObject f)
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1288 {
46573 aef3501d8e77 Use PyErr_WarnPy3k throughout Benjamin Peterson <benjamin@python.org> parents: 46077 diff changeset	1289 if (PyErr_WarnPy3k("array.write() not supported in 3.x; "
46578 7670005da8c5 A little reformating of Py3k warnings Benjamin Peterson <benjamin@python.org> parents: 46573 diff changeset	1290 "use array.tofile()", 1) < 0)
46077 ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1291 return NULL;
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1292 return array_tofile(self, f);
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1293 }
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1294
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1295
ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1296 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1297 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	1298 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1299 Py_ssize_t n;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1300 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	1301
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1302 if (!PyList_Check(list)) {
7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1303 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	1304 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1305 }
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1306 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	1307 if (n > 0) {
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1308 char *item = self->ob_item;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1309 Py_ssize_t i;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1310 PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1311 if (item == NULL) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1312 PyErr_NoMemory();
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1313 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1314 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1315 self->ob_item = item;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1316 Py_SIZE(self) += n;
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1317 self->allocated = Py_SIZE(self);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1318 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	1319 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	1320 if ((*self->ob_descr->setitem)(self,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1321 Py_SIZE(self) - n + i, v) != 0) {
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1322 Py_SIZE(self) -= n;
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1323 if (itemsize && (self->ob_size > PY_SSIZE_T_MAX / itemsize)) {
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1324 return PyErr_NoMemory();
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1325 }
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1326 PyMem_RESIZE(item, char,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1327 Py_SIZE(self) * itemsize);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1328 self->ob_item = item;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1329 self->allocated = Py_SIZE(self);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1330 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1331 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1332 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1333 }
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1334 Py_INCREF(Py_None);
7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1335 return Py_None;
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1336 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1337
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1338 PyDoc_STRVAR(fromlist_doc,
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1339 "fromlist(list)\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1340 \n\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1341 Append items to array from list.");
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1342
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1343
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1344 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1345 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	1346 {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1347 PyObject *list = PyList_New(Py_SIZE(self));
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1348 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	1349
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1350 if (list == NULL)
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1351 return NULL;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1352 for (i = 0; i < Py_SIZE(self); i++) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1353 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	1354 if (v == NULL) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1355 Py_DECREF(list);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1356 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1357 }
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1358 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	1359 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1360 return list;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1361 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1362
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1363 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	1364 "tolist() -> list\n\
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1365 \n\
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1366 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	1367
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1368
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1369 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	1370 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	1371 {
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1372 char *str;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1373 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	1374 int itemsize = self->ob_descr->itemsize;
13773 b6d93dba120e replaced PyArgs_Parse by PyArgs_ParseTuple Peter Schneider-Kamp <nowonder@nowonder.de> parents: 13772 diff changeset	1375 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	1376 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1377 if (n % itemsize != 0) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1378 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	1379 "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	1380 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1381 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1382 n = n / itemsize;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1383 if (n > 0) {
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1384 char *item = self->ob_item;
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1385 if ((n > PY_SSIZE_T_MAX - Py_SIZE(self)) \|\|
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1386 ((Py_SIZE(self) + n) > PY_SSIZE_T_MAX / itemsize)) {
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1387 return PyErr_NoMemory();
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1388 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1389 PyMem_RESIZE(item, char, (Py_SIZE(self) + n) * itemsize);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1390 if (item == NULL) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1391 PyErr_NoMemory();
1235 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 self->ob_item = item;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1395 Py_SIZE(self) += n;
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1396 self->allocated = Py_SIZE(self);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1397 memcpy(item + (Py_SIZE(self) - n) * itemsize,
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	1398 str, itemsize*n);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1399 }
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1400 Py_INCREF(Py_None);
7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1401 return Py_None;
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1402 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1403
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1404 PyDoc_STRVAR(fromstring_doc,
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1405 "fromstring(string)\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1406 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1407 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	1408 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	1409
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1410
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1411 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1412 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	1413 {
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1414 if (self->ob_size <= PY_SSIZE_T_MAX / self->ob_descr->itemsize) {
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1415 return PyString_FromStringAndSize(self->ob_item,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1416 Py_SIZE(self) * self->ob_descr->itemsize);
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1417 } else {
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1418 return PyErr_NoMemory();
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1419 }
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1420 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1421
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1422 PyDoc_STRVAR(tostring_doc,
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1423 "tostring() -> string\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1424 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1425 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	1426 representation.");
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1427
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1428
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1429
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1430 #ifdef Py_USING_UNICODE
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1431 static PyObject *
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1432 array_fromunicode(arrayobject self, PyObject args)
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1433 {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1434 Py_UNICODE *ustr;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1435 Py_ssize_t n;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1436
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1437 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	1438 return NULL;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1439 if (self->ob_descr->typecode != 'u') {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1440 PyErr_SetString(PyExc_ValueError,
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1441 "fromunicode() may only be called on "
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1442 "type 'u' arrays");
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1443 return NULL;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1444 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1445 if (n > 0) {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1446 Py_UNICODE item = (Py_UNICODE ) self->ob_item;
47587 1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1447 if (Py_SIZE(self) > PY_SSIZE_T_MAX - n) {
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1448 return PyErr_NoMemory();
1c964ed35ef9 Merge in release25-maint r60793: Gregory P. Smith <greg@mad-scientist.com> parents: 47527 diff changeset	1449 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1450 PyMem_RESIZE(item, Py_UNICODE, Py_SIZE(self) + n);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1451 if (item == NULL) {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1452 PyErr_NoMemory();
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1453 return NULL;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1454 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1455 self->ob_item = (char *) item;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1456 Py_SIZE(self) += n;
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1457 self->allocated = Py_SIZE(self);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1458 memcpy(item + Py_SIZE(self) - n,
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1459 ustr, n * sizeof(Py_UNICODE));
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1460 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1461
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1462 Py_INCREF(Py_None);
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1463 return Py_None;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1464 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1465
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1466 PyDoc_STRVAR(fromunicode_doc,
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1467 "fromunicode(ustr)\n\
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1468 \n\
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1469 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	1470 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	1471 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	1472 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	1473
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1474
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1475 static PyObject *
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1476 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	1477 {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1478 if (self->ob_descr->typecode != 'u') {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1479 PyErr_SetString(PyExc_ValueError,
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1480 "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	1481 return NULL;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1482 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1483 return PyUnicode_FromUnicode((Py_UNICODE *) self->ob_item, Py_SIZE(self));
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1484 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1485
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	1486 PyDoc_STRVAR(tounicode_doc,
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1487 "tounicode() -> unicode\n\
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1488 \n\
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1489 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	1490 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	1491 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	1492 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	1493
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1494 #endif /* Py_USING_UNICODE */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1495
55260 3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1496 static PyObject *
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1497 array_reduce(arrayobject *array)
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1498 {
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1499 PyObject dict, result, *list;
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1500
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1501 dict = PyObject_GetAttrString((PyObject *)array, "__dict__");
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1502 if (dict == NULL) {
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1503 if (!PyErr_ExceptionMatches(PyExc_AttributeError))
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1504 return NULL;
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1505 PyErr_Clear();
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1506 dict = Py_None;
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1507 Py_INCREF(dict);
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1508 }
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1509 /* Unlike in Python 3.x, we never use the more efficient memory
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1510 * representation of an array for pickling. This is unfortunately
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1511 * necessary to allow array objects to be unpickled by Python 3.x,
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1512 * since str objects from 2.x are always decoded to unicode in
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1513 * Python 3.x.
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1514 */
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1515 list = array_tolist(array, NULL);
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1516 if (list == NULL) {
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1517 Py_DECREF(dict);
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1518 return NULL;
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1519 }
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1520 result = Py_BuildValue(
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1521 "O(cO)O", Py_TYPE(array), array->ob_descr->typecode, list, dict);
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1522 Py_DECREF(list);
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1523 Py_DECREF(dict);
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1524 return result;
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1525 }
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1526
3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1527 PyDoc_STRVAR(reduce_doc, "Return state information for pickling.");
22098 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 static PyObject *
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1530 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	1531 {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1532 char tc = a->ob_descr->typecode;
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	1533 return PyString_FromStringAndSize(&tc, 1);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1534 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1535
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1536 static PyObject *
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1537 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	1538 {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1539 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	1540 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1541
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1542 static PyGetSetDef array_getsets [] = {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1543 {"typecode", (getter) array_get_typecode, NULL,
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1544 "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	1545 {"itemsize", (getter) array_get_itemsize, NULL,
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1546 "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	1547 {NULL}
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1548 };
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1549
47678 a35da94e05fc Make more symbols static. Martin v. Löwis <martin@v.loewis.de> parents: 47672 diff changeset	1550 static 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	1551 {"append", (PyCFunction)array_append, METH_O,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1552 append_doc},
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1553 {"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	1554 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	1555 {"byteswap", (PyCFunction)array_byteswap, METH_NOARGS,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1556 byteswap_doc},
31651 35cb8114b45c SF bug #910986: copy.copy fails for array.array Raymond Hettinger <python@rcn.com> parents: 30683 diff changeset	1557 {"__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	1558 copy_doc},
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1559 {"count", (PyCFunction)array_count, METH_O,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1560 count_doc},
39653 a88bc3bad651 Fix SF bug #1545837: array.array borks on deepcopy. Thomas Wouters <thomas@python.org> parents: 39463 diff changeset	1561 {"__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	1562 copy_doc},
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1563 {"extend", (PyCFunction)array_extend, METH_O,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1564 extend_doc},
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1565 {"fromfile", (PyCFunction)array_fromfile, METH_VARARGS,
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1566 fromfile_doc},
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1567 {"fromlist", (PyCFunction)array_fromlist, METH_O,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1568 fromlist_doc},
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1569 {"fromstring", (PyCFunction)array_fromstring, METH_VARARGS,
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1570 fromstring_doc},
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1571 #ifdef Py_USING_UNICODE
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1572 {"fromunicode", (PyCFunction)array_fromunicode, METH_VARARGS,
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1573 fromunicode_doc},
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1574 #endif
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1575 {"index", (PyCFunction)array_index, METH_O,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1576 index_doc},
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1577 {"insert", (PyCFunction)array_insert, METH_VARARGS,
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1578 insert_doc},
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1579 {"pop", (PyCFunction)array_pop, METH_VARARGS,
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1580 pop_doc},
46077 ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1581 {"read", (PyCFunction)array_fromfile_as_read, METH_VARARGS,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1582 fromfile_doc},
34174 30b97c1bb12d SF #1085304: Make array.array pickle-able Raymond Hettinger <python@rcn.com> parents: 33316 diff changeset	1583 {"__reduce__", (PyCFunction)array_reduce, METH_NOARGS,
55260 3a316243bd6c Issue #2389: Pickle array objects using a list representation for portability Alexandre Vassalotti <alexandre@peadrop.com> parents: 55049 diff changeset	1584 reduce_doc},
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1585 {"remove", (PyCFunction)array_remove, METH_O,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1586 remove_doc},
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1587 {"reverse", (PyCFunction)array_reverse, METH_NOARGS,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1588 reverse_doc},
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1589 /* {"sort", (PyCFunction)array_sort, METH_VARARGS,
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1590 sort_doc},*/
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1591 {"tofile", (PyCFunction)array_tofile, METH_O,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1592 tofile_doc},
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1593 {"tolist", (PyCFunction)array_tolist, METH_NOARGS,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1594 tolist_doc},
27044 23280a64288e SF patch 660559: Use METH_O and METH_NOARGS where possible Raymond Hettinger <python@rcn.com> parents: 24471 diff changeset	1595 {"tostring", (PyCFunction)array_tostring, METH_NOARGS,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1596 tostring_doc},
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1597 #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	1598 {"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	1599 tounicode_doc},
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1600 #endif
46077 ae659ff0528b #2359: add Py3k warning for array.read/array.write. Georg Brandl <georg@python.org> parents: 44350 diff changeset	1601 {"write", (PyCFunction)array_tofile_as_write, METH_O,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1602 tofile_doc},
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1603 {NULL, NULL} /* sentinel */
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1604 };
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1605
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1606 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	1607 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	1608 {
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1609 char buf[256], typecode;
28742 bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1610 PyObject s, t, *v = NULL;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1611 Py_ssize_t len;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1612
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1613 len = Py_SIZE(a);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1614 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	1615 if (len == 0) {
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1616 PyOS_snprintf(buf, sizeof(buf), "array('%c')", typecode);
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	1617 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	1618 }
28742 bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1619
bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1620 if (typecode == 'c')
bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1621 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	1622 #ifdef Py_USING_UNICODE
28742 bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1623 else if (typecode == 'u')
bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1624 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	1625 #endif
28742 bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1626 else
bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1627 v = array_tolist(a, NULL);
bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1628 t = PyObject_Repr(v);
bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1629 Py_XDECREF(v);
bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1630
bd678e65f784 SF Patch 685051: fix for 680789: reprs in arraymodule Raymond Hettinger <python@rcn.com> parents: 28320 diff changeset	1631 PyOS_snprintf(buf, sizeof(buf), "array('%c', ", typecode);
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	1632 s = PyString_FromString(buf);
52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	1633 PyString_ConcatAndDel(&s, t);
52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	1634 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	1635 return s;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1636 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1637
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1638 static PyObject*
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1639 array_subscr(arrayobject* self, PyObject* item)
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1640 {
39463 6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39445 diff changeset	1641 if (PyIndex_Check(item)) {
6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39445 diff changeset	1642 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	1643 if (i==-1 && PyErr_Occurred()) {
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1644 return NULL;
36882 6a9c7165b17b Checking in the code for PEP 357. Guido van Rossum <guido@python.org> parents: 36877 diff changeset	1645 }
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1646 if (i < 0)
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1647 i += Py_SIZE(self);
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1648 return array_item(self, i);
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 else if (PySlice_Check(item)) {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1651 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	1652 PyObject* result;
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1653 arrayobject* ar;
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1654 int itemsize = self->ob_descr->itemsize;
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1655
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1656 if (PySlice_GetIndicesEx((PySliceObject*)item, Py_SIZE(self),
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1657 &start, &stop, &step, &slicelength) < 0) {
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1658 return NULL;
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
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1661 if (slicelength <= 0) {
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1662 return newarrayobject(&Arraytype, 0, self->ob_descr);
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1663 }
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1664 else if (step == 1) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1665 PyObject *result = newarrayobject(&Arraytype,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1666 slicelength, self->ob_descr);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1667 if (result == NULL)
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1668 return NULL;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1669 memcpy(((arrayobject *)result)->ob_item,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1670 self->ob_item + start * itemsize,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1671 slicelength * itemsize);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1672 return result;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1673 }
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1674 else {
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1675 result = newarrayobject(&Arraytype, slicelength, self->ob_descr);
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1676 if (!result) return NULL;
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 ar = (arrayobject*)result;
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1679
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1680 for (cur = start, i = 0; i < slicelength;
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1681 cur += step, i++) {
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1682 memcpy(ar->ob_item + i*itemsize,
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1683 self->ob_item + cur*itemsize,
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1684 itemsize);
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 return result;
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1688 }
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1689 }
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1690 else {
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1691 PyErr_SetString(PyExc_TypeError,
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1692 "array indices must be integers");
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1693 return NULL;
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 }
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1696
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1697 static int
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1698 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	1699 {
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1700 Py_ssize_t start, stop, step, slicelength, needed;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1701 arrayobject* other;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1702 int itemsize;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1703
39463 6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39445 diff changeset	1704 if (PyIndex_Check(item)) {
6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 39445 diff changeset	1705 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1706
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1707 if (i == -1 && PyErr_Occurred())
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1708 return -1;
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1709 if (i < 0)
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1710 i += Py_SIZE(self);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1711 if (i < 0 \|\| i >= Py_SIZE(self)) {
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1712 PyErr_SetString(PyExc_IndexError,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1713 "array assignment index out of range");
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1714 return -1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1715 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1716 if (value == NULL) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1717 /* Fall through to slice assignment */
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1718 start = i;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1719 stop = i + 1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1720 step = 1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1721 slicelength = 1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1722 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1723 else
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1724 return (*self->ob_descr->setitem)(self, i, value);
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1725 }
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1726 else if (PySlice_Check(item)) {
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1727 if (PySlice_GetIndicesEx((PySliceObject *)item,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1728 Py_SIZE(self), &start, &stop,
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1729 &step, &slicelength) < 0) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1730 return -1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1731 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1732 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1733 else {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1734 PyErr_SetString(PyExc_TypeError,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1735 "array indices must be integer");
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1736 return -1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1737 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1738 if (value == NULL) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1739 other = NULL;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1740 needed = 0;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1741 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1742 else if (array_Check(value)) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1743 other = (arrayobject *)value;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1744 needed = Py_SIZE(other);
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1745 if (self == other) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1746 /* Special case "self[i:j] = self" -- copy self first */
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1747 int ret;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1748 value = array_slice(other, 0, needed);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1749 if (value == NULL)
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1750 return -1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1751 ret = array_ass_subscr(self, item, value);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1752 Py_DECREF(value);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1753 return ret;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1754 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1755 if (other->ob_descr != self->ob_descr) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1756 PyErr_BadArgument();
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1757 return -1;
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1758 }
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1759 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1760 else {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1761 PyErr_Format(PyExc_TypeError,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1762 "can only assign array (not \"%.200s\") to array slice",
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1763 Py_TYPE(value)->tp_name);
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1764 return -1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1765 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1766 itemsize = self->ob_descr->itemsize;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1767 /* for 'a[2:1] = ...', the insertion point is 'start', not 'stop' */
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1768 if ((step > 0 && stop < start) \|\|
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1769 (step < 0 && stop > start))
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1770 stop = start;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1771 if (step == 1) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1772 if (slicelength > needed) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1773 memmove(self->ob_item + (start + needed) * itemsize,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1774 self->ob_item + stop * itemsize,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1775 (Py_SIZE(self) - stop) * itemsize);
26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1776 if (array_resize(self, Py_SIZE(self) +
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1777 needed - slicelength) < 0)
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1778 return -1;
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1779 }
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1780 else if (slicelength < needed) {
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1781 if (array_resize(self, Py_SIZE(self) +
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1782 needed - slicelength) < 0)
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1783 return -1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1784 memmove(self->ob_item + (start + needed) * itemsize,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1785 self->ob_item + stop * itemsize,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1786 (Py_SIZE(self) - start - needed) * itemsize);
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1787 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1788 if (needed > 0)
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1789 memcpy(self->ob_item + start * itemsize,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1790 other->ob_item, needed * itemsize);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1791 return 0;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1792 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1793 else if (needed == 0) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1794 /* Delete slice */
58561 c57998e3be33 Issue #7788: Fix a crash produced by deleting a list slice with huge Mark Dickinson <dickinsm@gmail.com> parents: 55260 diff changeset	1795 size_t cur;
c57998e3be33 Issue #7788: Fix a crash produced by deleting a list slice with huge Mark Dickinson <dickinsm@gmail.com> parents: 55260 diff changeset	1796 Py_ssize_t i;
c57998e3be33 Issue #7788: Fix a crash produced by deleting a list slice with huge Mark Dickinson <dickinsm@gmail.com> parents: 55260 diff changeset	1797
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1798 if (step < 0) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1799 stop = start + 1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1800 start = stop + step * (slicelength - 1) - 1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1801 step = -step;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1802 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1803 for (cur = start, i = 0; i < slicelength;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1804 cur += step, i++) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1805 Py_ssize_t lim = step - 1;
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1806
58906 5e6edb4e76f5 Silence more 'comparison between signed and unsigned' warnings. Mark Dickinson <dickinsm@gmail.com> parents: 58561 diff changeset	1807 if (cur + step >= (size_t)Py_SIZE(self))
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1808 lim = Py_SIZE(self) - cur - 1;
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1809 memmove(self->ob_item + (cur - i) * itemsize,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1810 self->ob_item + (cur + 1) * itemsize,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1811 lim * itemsize);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1812 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1813 cur = start + slicelength * step;
58906 5e6edb4e76f5 Silence more 'comparison between signed and unsigned' warnings. Mark Dickinson <dickinsm@gmail.com> parents: 58561 diff changeset	1814 if (cur < (size_t)Py_SIZE(self)) {
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1815 memmove(self->ob_item + (cur-slicelength) * itemsize,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1816 self->ob_item + cur * itemsize,
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1817 (Py_SIZE(self) - cur) * itemsize);
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1818 }
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1819 if (array_resize(self, Py_SIZE(self) - slicelength) < 0)
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1820 return -1;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1821 return 0;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1822 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1823 else {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1824 Py_ssize_t cur, i;
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1825
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1826 if (needed != slicelength) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1827 PyErr_Format(PyExc_ValueError,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1828 "attempt to assign array of size %zd "
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1829 "to extended slice of size %zd",
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1830 needed, slicelength);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1831 return -1;
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1832 }
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1833 for (cur = start, i = 0; i < slicelength;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1834 cur += step, i++) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1835 memcpy(self->ob_item + cur * itemsize,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1836 other->ob_item + i * itemsize,
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1837 itemsize);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1838 }
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	1839 return 0;
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1840 }
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1841 }
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1842
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1843 static PyMappingMethods array_as_mapping = {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1844 (lenfunc)array_length,
23929 26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1845 (binaryfunc)array_subscr,
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1846 (objobjargproc)array_ass_subscr
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1847 };
26ba17b758b9 Fix the bug described in Michael W. Hudson <mwh@python.net> parents: 23832 diff changeset	1848
41361 4a03860ae08b Array module's buffer interface can now handle empty arrays. Raymond Hettinger <python@rcn.com> parents: 41359 diff changeset	1849 static const void *emptybuf = "";
4a03860ae08b Array module's buffer interface can now handle empty arrays. Raymond Hettinger <python@rcn.com> parents: 41359 diff changeset	1850
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1851 static Py_ssize_t
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1852 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	1853 {
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1854 if ( index != 0 ) {
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1855 PyErr_SetString(PyExc_SystemError,
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1856 "Accessing non-existent array segment");
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1857 return -1;
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1858 }
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1859 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	1860 if (*ptr == NULL)
4a03860ae08b Array module's buffer interface can now handle empty arrays. Raymond Hettinger <python@rcn.com> parents: 41359 diff changeset	1861 *ptr = emptybuf;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1862 return Py_SIZE(self)*self->ob_descr->itemsize;
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1863 }
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1864
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1865 static Py_ssize_t
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1866 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	1867 {
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1868 if ( index != 0 ) {
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1869 PyErr_SetString(PyExc_SystemError,
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	1870 "Accessing non-existent array segment");
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1871 return -1;
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1872 }
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1873 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	1874 if (*ptr == NULL)
4a03860ae08b Array module's buffer interface can now handle empty arrays. Raymond Hettinger <python@rcn.com> parents: 41359 diff changeset	1875 *ptr = emptybuf;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1876 return Py_SIZE(self)*self->ob_descr->itemsize;
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1877 }
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1878
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1879 static Py_ssize_t
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1880 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	1881 {
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1882 if ( lenp )
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1883 lenp = Py_SIZE(self)self->ob_descr->itemsize;
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1884 return 1;
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1885 }
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1886
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1887 static PySequenceMethods array_as_sequence = {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1888 (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	1889 (binaryfunc)array_concat, /sq_concat/
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1890 (ssizeargfunc)array_repeat, /sq_repeat/
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1891 (ssizeargfunc)array_item, /sq_item/
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1892 (ssizessizeargfunc)array_slice, /sq_slice/
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1893 (ssizeobjargproc)array_ass_item, /sq_ass_item/
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1894 (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	1895 (objobjproc)array_contains, /sq_contains/
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1896 (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	1897 (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	1898 };
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1899
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1900 static PyBufferProcs array_as_buffer = {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1901 (readbufferproc)array_buffer_getreadbuf,
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1902 (writebufferproc)array_buffer_getwritebuf,
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1903 (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	1904 NULL,
5410 3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1905 };
3b2fda31bf1b Checkin of Jack's buffer mods. Guido van Rossum <guido@python.org> parents: 5318 diff changeset	1906
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1907 static PyObject *
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1908 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	1909 {
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1910 char c;
33316 0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	1911 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	1912 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	1913
40682 77e0f4718a7c Bug #1486663: don't reject keyword arguments for subclasses of builtin Georg Brandl <georg@python.org> parents: 39653 diff changeset	1914 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	1915 return NULL;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1916
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1917 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	1918 return NULL;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1919
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1920 if (!(initial == NULL \|\| PyList_Check(initial)
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	1921 \|\| 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	1922 \|\| (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	1923 it = PyObject_GetIter(initial);
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	1924 if (it == NULL)
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	1925 return NULL;
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	1926 /* 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	1927 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	1928 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	1929 the array.
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	1930 */
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	1931 initial = NULL;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1932 }
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1933 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	1934 if (descr->typecode == c) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1935 PyObject *a;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1936 Py_ssize_t len;
28760 22d177682ae1 SF 686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 28742 diff changeset	1937
22d177682ae1 SF 686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 28742 diff changeset	1938 if (initial == NULL \|\| !(PyList_Check(initial)
22d177682ae1 SF 686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 28742 diff changeset	1939 \|\| PyTuple_Check(initial)))
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1940 len = 0;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1941 else
28760 22d177682ae1 SF 686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 28742 diff changeset	1942 len = PySequence_Size(initial);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1943
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1944 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	1945 if (a == NULL)
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1946 return NULL;
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1947
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1948 if (len > 0) {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1949 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	1950 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	1951 PyObject *v =
28760 22d177682ae1 SF 686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 28742 diff changeset	1952 PySequence_GetItem(initial, i);
30066 ae0242e3459e SF bug #782369: Massive memory leak in array module Raymond Hettinger <python@rcn.com> parents: 29244 diff changeset	1953 if (v == NULL) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1954 Py_DECREF(a);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1955 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1956 }
30066 ae0242e3459e SF bug #782369: Massive memory leak in array module Raymond Hettinger <python@rcn.com> parents: 29244 diff changeset	1957 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	1958 Py_DECREF(v);
ae0242e3459e SF bug #782369: Massive memory leak in array module Raymond Hettinger <python@rcn.com> parents: 29244 diff changeset	1959 Py_DECREF(a);
ae0242e3459e SF bug #782369: Massive memory leak in array module Raymond Hettinger <python@rcn.com> parents: 29244 diff changeset	1960 return NULL;
ae0242e3459e SF bug #782369: Massive memory leak in array module Raymond Hettinger <python@rcn.com> parents: 29244 diff changeset	1961 }
ae0242e3459e SF bug #782369: Massive memory leak in array module Raymond Hettinger <python@rcn.com> parents: 29244 diff changeset	1962 Py_DECREF(v);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1963 }
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	1964 } 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	1965 PyObject t_initial, v;
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36689 diff changeset	1966 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	1967 if (t_initial == NULL) {
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36689 diff changeset	1968 Py_DECREF(a);
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36689 diff changeset	1969 return NULL;
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36689 diff changeset	1970 }
e9a7a2784e17 SF #1444030: Fix several potential defects found by Coverity. Hye-Shik Chang <hyeshik@gmail.com> parents: 36689 diff changeset	1971 v = array_fromstring((arrayobject *)a,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	1972 t_initial);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1973 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	1974 if (v == NULL) {
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1975 Py_DECREF(a);
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1976 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1977 }
4628 7df5d4cf8277 Renamed Grandly (I think). Roger E. Masse <rmasse@newcnri.cnri.reston.va.us> parents: 4600 diff changeset	1978 Py_DECREF(v);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1979 #ifdef Py_USING_UNICODE
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1980 } 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	1981 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	1982 if (n > 0) {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1983 arrayobject self = (arrayobject )a;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1984 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	1985 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	1986 if (item == NULL) {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1987 PyErr_NoMemory();
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1988 Py_DECREF(a);
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1989 return NULL;
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1990 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1991 self->ob_item = item;
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1992 Py_SIZE(self) = n / sizeof(Py_UNICODE);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1993 memcpy(item, PyUnicode_AS_DATA(initial), n);
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	1994 self->allocated = Py_SIZE(self);
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1995 }
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	1996 #endif
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	1997 }
33316 0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	1998 if (it != NULL) {
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	1999 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	2000 Py_DECREF(it);
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	2001 Py_DECREF(a);
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	2002 return NULL;
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	2003 }
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	2004 Py_DECREF(it);
0b181bf230c9 SF feature request #992967: array.array objects should support sequences. Raymond Hettinger <python@rcn.com> parents: 32159 diff changeset	2005 }
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	2006 return a;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	2007 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	2008 }
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	2009 PyErr_SetString(PyExc_ValueError,
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2010 "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	2011 return NULL;
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	2012 }
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	2013
87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	2014
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	2015 PyDoc_STRVAR(module_doc,
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2016 "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	2017 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	2018 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	2019 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	2020 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	2021 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	2022 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2023 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	2024 'c' character 1 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2025 'b' signed integer 1 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2026 'B' unsigned integer 1 \n\
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2027 'u' Unicode character 2 \n\
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2028 'h' signed integer 2 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2029 'H' unsigned integer 2 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2030 'i' signed integer 2 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2031 'I' unsigned integer 2 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2032 'l' signed integer 4 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2033 'L' unsigned integer 4 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2034 'f' floating point 4 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2035 'd' floating point 8 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2036 \n\
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2037 The constructor is:\n\
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2038 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2039 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	2040 ");
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2041
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23433 diff changeset	2042 PyDoc_STRVAR(arraytype_doc,
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2043 "array(typecode [, initializer]) -> array\n\
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2044 \n\
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2045 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	2046 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	2047 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	2048 \n\
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2049 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	2050 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	2051 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2052 Methods:\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2053 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2054 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	2055 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	2056 byteswap() -- byteswap all the items of the array\n\
55049 74c0a78114ae Merged revisions 69846 via svnmerge from Jesus Cea <jcea@jcea.es> parents: 48046 diff changeset	2057 count() -- return number of occurrences of an object\n\
31660 35f56e08727f SF feature request #686323: Minor array module enhancements Raymond Hettinger <python@rcn.com> parents: 31659 diff changeset	2058 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	2059 fromfile() -- read items from a file object\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2060 fromlist() -- append items from the list\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2061 fromstring() -- append items from the string\n\
55049 74c0a78114ae Merged revisions 69846 via svnmerge from Jesus Cea <jcea@jcea.es> parents: 48046 diff changeset	2062 index() -- return index of first occurrence of an object\n\
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2063 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	2064 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	2065 read() -- DEPRECATED, use fromfile()\n\
55049 74c0a78114ae Merged revisions 69846 via svnmerge from Jesus Cea <jcea@jcea.es> parents: 48046 diff changeset	2066 remove() -- remove first occurrence of an object\n\
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2067 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	2068 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	2069 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	2070 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	2071 write() -- DEPRECATED, use tofile()\n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2072 \n\
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2073 Attributes:\n\
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2074 \n\
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2075 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	2076 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	2077 ");
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2078
27128 047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2079 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	2080
24283 c0a67a1cab09 Removed more stray instances of statichere, but left _sre.c alone. Tim Peters <tim.peters@gmail.com> parents: 24280 diff changeset	2081 static PyTypeObject Arraytype = {
42333 6620a510e9a9 PEP 3123: Provide forward compatibility with Python 3.0, while keeping Martin v. Löwis <martin@v.loewis.de> parents: 41361 diff changeset	2082 PyVarObject_HEAD_INIT(NULL, 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	2083 "array.array",
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2084 sizeof(arrayobject),
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2085 0,
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2086 (destructor)array_dealloc, /* tp_dealloc */
22124 edf05c69bbf3 Remove tp_print. Martin v. Löwis <martin@v.loewis.de> parents: 22098 diff changeset	2087 0, /* tp_print */
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2088 0, /* tp_getattr */
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2089 0, /* tp_setattr */
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2090 0, /* tp_compare */
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2091 (reprfunc)array_repr, /* tp_repr */
38353 36cd4a4ab8f7 Support for buffer protocol for socket and struct. Martin Blais <blais@furius.ca> parents: 37847 diff changeset	2092 0, /* tp_as_number*/
36cd4a4ab8f7 Support for buffer protocol for socket and struct. Martin Blais <blais@furius.ca> parents: 37847 diff changeset	2093 &array_as_sequence, /* tp_as_sequence*/
36cd4a4ab8f7 Support for buffer protocol for socket and struct. Martin Blais <blais@furius.ca> parents: 37847 diff changeset	2094 &array_as_mapping, /* tp_as_mapping*/
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2095 0, /* tp_hash */
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2096 0, /* tp_call */
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2097 0, /* tp_str */
27104 2443c557cbc3 Patch #661760: Cygwin auto-import module patch Jason Tishler <jason@tishler.net> parents: 27044 diff changeset	2098 PyObject_GenericGetAttr, /* tp_getattro */
15975 54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2099 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	2100 &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	2101 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	2102 arraytype_doc, /* tp_doc */
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2103 0, /* tp_traverse */
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2104 0, /* tp_clear */
54205828b1e1 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15396 diff changeset	2105 array_richcompare, /* tp_richcompare */
32159 2c169ca5fa69 Add weakref support to array.array and file objects. Raymond Hettinger <python@rcn.com> parents: 31660 diff changeset	2106 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	2107 (getiterfunc)array_iter, /* tp_iter */
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2108 0, /* tp_iternext */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2109 array_methods, /* tp_methods */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2110 0, /* tp_members */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2111 array_getsets, /* tp_getset */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2112 0, /* tp_base */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2113 0, /* tp_dict */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2114 0, /* tp_descr_get */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2115 0, /* tp_descr_set */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2116 0, /* tp_dictoffset */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2117 0, /* tp_init */
27104 2443c557cbc3 Patch #661760: Cygwin auto-import module patch Jason Tishler <jason@tishler.net> parents: 27044 diff changeset	2118 PyType_GenericAlloc, /* tp_alloc */
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2119 array_new, /* tp_new */
27104 2443c557cbc3 Patch #661760: Cygwin auto-import module patch Jason Tishler <jason@tishler.net> parents: 27044 diff changeset	2120 PyObject_Del, /* tp_free */
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2121 };
4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2122
27128 047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2123
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2124 /********************* Array Iterator ************************/
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2125
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2126 typedef struct {
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2127 PyObject_HEAD
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	2128 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	2129 arrayobject *ao;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	2130 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	2131 } arrayiterobject;
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2132
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2133 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	2134
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2135 #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	2136
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2137 static PyObject *
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2138 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	2139 {
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2140 arrayiterobject *it;
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2141
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2142 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	2143 PyErr_BadInternalCall();
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2144 return NULL;
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2145 }
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2146
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2147 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	2148 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	2149 return NULL;
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 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	2152 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	2153 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	2154 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	2155 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	2156 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	2157 }
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2158
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2159 static PyObject *
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2160 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	2161 {
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2162 assert(PyArrayIter_Check(it));
44350 26384b8180c7 #1629: Renamed Py_Size, Py_Type and Py_Refcnt to Py_SIZE, Py_TYPE and Py_REFCNT. Macros for b/w compatibility are available. Christian Heimes <christian@cheimes.de> parents: 42951 diff changeset	2163 if (it->index < Py_SIZE(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	2164 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	2165 return NULL;
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2166 }
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2167
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2168 static void
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2169 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	2170 {
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2171 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	2172 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	2173 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	2174 }
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2175
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2176 static int
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2177 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	2178 {
37756 7b2e436a4a21 Use Py_VISIT in all tp_traverse methods, instead of traversing manually or Thomas Wouters <thomas@python.org> parents: 37410 diff changeset	2179 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	2180 return 0;
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2181 }
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2182
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2183 static PyTypeObject PyArrayIter_Type = {
42333 6620a510e9a9 PEP 3123: Provide forward compatibility with Python 3.0, while keeping Martin v. Löwis <martin@v.loewis.de> parents: 41361 diff changeset	2184 PyVarObject_HEAD_INIT(NULL, 0)
27128 047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2185 "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	2186 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	2187 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	2188 /* methods */
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2189 (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	2190 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	2191 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	2192 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	2193 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	2194 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	2195 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	2196 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	2197 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	2198 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	2199 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	2200 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	2201 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	2202 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	2203 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	2204 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	2205 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	2206 (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	2207 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	2208 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	2209 0, /* tp_weaklistoffset */
28320 fd5ef7003469 Renamed PyObject_GenericGetIter to PyObject_SelfIter Raymond Hettinger <python@rcn.com> parents: 28309 diff changeset	2210 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	2211 (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	2212 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	2213 };
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2214
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2215
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2216 /********************* Install Module ************************/
047b6e16ab2e SF patch #662433: Fill arraymodule's tp_iter and sq_contains slots Raymond Hettinger <python@rcn.com> parents: 27104 diff changeset	2217
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2218 /* No functions in array module. */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2219 static PyMethodDef a_methods[] = {
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2220 {NULL, NULL, 0, NULL} /* Sentinel */
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2221 };
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2222
966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2223
24471 f66b3a3509c7 Excise DL_EXPORT/DL_IMPORT from Modules/. Required adding a prototype Mark Hammond <mhammond@skippinet.com.au>* parents: 24424 diff changeset	2224 PyMODINIT_FUNC
13651 8a063423e0b7 Bunch of minor ANSIfications: 'void initfunc()' -> 'void initfunc(void)', Thomas Wouters <thomas@python.org> parents: 13590 diff changeset	2225 initarray(void)
1235 87ed00a62d31 Added new module "array" (for now optional) defining array objects. Guido van Rossum <guido@python.org> parents: diff changeset	2226 {
22722 ba68dda15df0 Use the PyModule_() API instead of manipulating the module dictionary Fred Drake <fdrake@acm.org>* parents: 22124 diff changeset	2227 PyObject *m;
11711 6546ea06e157 Patch from Paul Sokolovsky <Paul.Sokolovsky@technologist.com>: Fred Drake <fdrake@acm.org> parents: 11673 diff changeset	2228
22098 966725095854 Patch 520694: arraymodule.c improvements: Martin v. Löwis <martin@v.loewis.de> parents: 21313 diff changeset	2229 Arraytype.ob_type = &PyType_Type;
27804 8d1b272c9e71 Patch #676837: Cygwin array module patch Jason Tishler <jason@tishler.net> parents: 27128 diff changeset	2230 PyArrayIter_Type.ob_type = &PyType_Type;
9343 4f78504a5f81 Doc strings by Chris Petrilli. Guido van Rossum <guido@python.org> parents: 5982 diff changeset	2231 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	2232 if (m == NULL)
1af7f719ed28 Check return result from Py_InitModule(). This API can fail. Neal Norwitz <nnorwitz@gmail.com>* parents: 35449 diff changeset	2233 return;
22722 ba68dda15df0 Use the PyModule_() API instead of manipulating the module dictionary Fred Drake <fdrake@acm.org>* parents: 22124 diff changeset	2234
ba68dda15df0 Use the PyModule_() API instead of manipulating the module dictionary Fred Drake <fdrake@acm.org>* parents: 22124 diff changeset	2235 Py_INCREF((PyObject *)&Arraytype);
ba68dda15df0 Use the PyModule_() API instead of manipulating the module dictionary Fred Drake <fdrake@acm.org>* parents: 22124 diff changeset	2236 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	2237 Py_INCREF((PyObject *)&Arraytype);
ba68dda15df0 Use the PyModule_() API instead of manipulating the module dictionary Fred Drake <fdrake@acm.org>* parents: 22124 diff changeset	2238 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	2239 /* 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	2240 }

Mercurial > cpython-lru_cache-weakref

annotate Modules/arraymodule.c @ 58973:db86bf39ccaa legacy-trunk