cpython-lru_cache-weakref: Objects/tupleobject.c annotate

annotate Objects/tupleobject.c @ 49955:878d40468c4e legacy-trunk

Issue #4384: Added logging integration with warnings module using captureWarnings(). This change includes a NullHandler which does nothing; it will be of use to library developers who want to avoid the "No handlers could be found for logger XXX" message which can appear if the library user doesn't configure logging.

author	Vinay Sajip <vinay_sajip@yahoo.co.uk>
date	Wed, 03 Dec 2008 23:22:58 +0000
parents	2e794757bdc8
children	0265cdc8d5bb f0e0c3536e22

rev	line source
145 853b736a6a9e Added copyright notice. Guido van Rossum <guido@python.org> parents: 86 diff changeset	1
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	2 /* Tuple object implementation */
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	3
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	4 #include "Python.h"
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	5
12439 456869eaa7d5 Patch by Charles G Waldman to avoid a sneaky memory leak in Guido van Rossum <guido@python.org> parents: 11999 diff changeset	6 /* Speed optimization to avoid frequent malloc/free of small tuples */
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	7 #ifndef PyTuple_MAXSAVESIZE
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	8 #define PyTuple_MAXSAVESIZE 20 /* Largest tuple to save on free list */
12439 456869eaa7d5 Patch by Charles G Waldman to avoid a sneaky memory leak in Guido van Rossum <guido@python.org> parents: 11999 diff changeset	9 #endif
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	10 #ifndef PyTuple_MAXFREELIST
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	11 #define PyTuple_MAXFREELIST 2000 /* Maximum number of tuples of each size to save */
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	12 #endif
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	13
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	14 #if PyTuple_MAXSAVESIZE > 0
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	15 /* Entries 1 up to PyTuple_MAXSAVESIZE are free lists, entry 0 is the empty
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	16 tuple () of which at most one instance will be allocated.
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	17 */
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	18 static PyTupleObject *free_list[PyTuple_MAXSAVESIZE];
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	19 static int numfree[PyTuple_MAXSAVESIZE];
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	20 #endif
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	21 #ifdef COUNT_ALLOCS
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	22 int fast_tuple_allocs;
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	23 int tuple_zero_allocs;
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	24 #endif
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	25
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	26 PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	27 PyTuple_New(register Py_ssize_t size)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	28 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	29 register PyTupleObject *op;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	30 Py_ssize_t i;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	31 if (size < 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	32 PyErr_BadInternalCall();
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	33 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	34 }
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	35 #if PyTuple_MAXSAVESIZE > 0
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	36 if (size == 0 && free_list[0]) {
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	37 op = free_list[0];
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	38 Py_INCREF(op);
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	39 #ifdef COUNT_ALLOCS
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	40 tuple_zero_allocs++;
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	41 #endif
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	42 return (PyObject *) op;
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	43 }
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	44 if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	45 free_list[size] = (PyTupleObject *) op->ob_item[0];
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	46 numfree[size]--;
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	47 #ifdef COUNT_ALLOCS
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	48 fast_tuple_allocs++;
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	49 #endif
24898 a869d2de536f Call me anal, but there was a particular phrase that was speading to Guido van Rossum <guido@python.org> parents: 24683 diff changeset	50 /* Inline PyObject_InitVar */
9632 ac5345814ba0 When tracing references, reset the type and size of tuples allocated Guido van Rossum <guido@python.org> parents: 9484 diff changeset	51 #ifdef Py_TRACE_REFS
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: 43452 diff changeset	52 Py_SIZE(op) = size;
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: 43452 diff changeset	53 Py_TYPE(op) = &PyTuple_Type;
9632 ac5345814ba0 When tracing references, reset the type and size of tuples allocated Guido van Rossum <guido@python.org> parents: 9484 diff changeset	54 #endif
12576 1c7c2dd1beb1 Vladimir Marangozov's long-awaited malloc restructuring. Guido van Rossum <guido@python.org> parents: 12516 diff changeset	55 _Py_NewReference((PyObject *)op);
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	56 }
80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	57 else
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	58 #endif
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	59 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	60 Py_ssize_t nbytes = size * sizeof(PyObject *);
11127 9a20038f0b99 Appropriate overflow checks so that things like sys.maxint(1,) can't Guido van Rossum <guido@python.org>* parents: 9632 diff changeset	61 /* Check for overflow */
9a20038f0b99 Appropriate overflow checks so that things like sys.maxint(1,) can't Guido van Rossum <guido@python.org>* parents: 9632 diff changeset	62 if (nbytes / sizeof(PyObject *) != (size_t)size \|\|
48114 c4d24fc8ba8a Security patches from Apple: prevent int overflow when allocating memory Neal Norwitz <nnorwitz@gmail.com> parents: 47682 diff changeset	63 (nbytes > PY_SSIZE_T_MAX - sizeof(PyTupleObject) - sizeof(PyObject *)))
11127 9a20038f0b99 Appropriate overflow checks so that things like sys.maxint(1,) can't Guido van Rossum <guido@python.org>* parents: 9632 diff changeset	64 {
9a20038f0b99 Appropriate overflow checks so that things like sys.maxint(1,) can't Guido van Rossum <guido@python.org>* parents: 9632 diff changeset	65 return PyErr_NoMemory();
9a20038f0b99 Appropriate overflow checks so that things like sys.maxint(1,) can't Guido van Rossum <guido@python.org>* parents: 9632 diff changeset	66 }
48114 c4d24fc8ba8a Security patches from Apple: prevent int overflow when allocating memory Neal Norwitz <nnorwitz@gmail.com> parents: 47682 diff changeset	67 nbytes += sizeof(PyTupleObject) - sizeof(PyObject *);
c4d24fc8ba8a Security patches from Apple: prevent int overflow when allocating memory Neal Norwitz <nnorwitz@gmail.com> parents: 47682 diff changeset	68
19581 fd48a55ac364 Use new GC API. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 18933 diff changeset	69 op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	70 if (op == NULL)
19581 fd48a55ac364 Use new GC API. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 18933 diff changeset	71 return NULL;
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	72 }
31759 be5d2a07bc26 Restored revision 2.87. Armin Rigo <arigo@tunes.org> parents: 31756 diff changeset	73 for (i=0; i < size; i++)
be5d2a07bc26 Restored revision 2.87. Armin Rigo <arigo@tunes.org> parents: 31756 diff changeset	74 op->ob_item[i] = NULL;
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	75 #if PyTuple_MAXSAVESIZE > 0
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	76 if (size == 0) {
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	77 free_list[0] = op;
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	78 ++numfree[0];
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	79 Py_INCREF(op); /* extra INCREF so that this is never freed */
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	80 }
4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	81 #endif
19581 fd48a55ac364 Use new GC API. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 18933 diff changeset	82 _PyObject_GC_TRACK(op);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	83 return (PyObject *) op;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	84 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	85
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	86 Py_ssize_t
13459 0f95c93f200b ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13265 diff changeset	87 PyTuple_Size(register PyObject *op)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	88 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	89 if (!PyTuple_Check(op)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	90 PyErr_BadInternalCall();
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	91 return -1;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	92 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	93 else
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: 43452 diff changeset	94 return Py_SIZE(op);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	95 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	96
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	97 PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	98 PyTuple_GetItem(register PyObject *op, register Py_ssize_t i)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	99 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	100 if (!PyTuple_Check(op)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	101 PyErr_BadInternalCall();
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	102 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	103 }
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: 43452 diff changeset	104 if (i < 0 \|\| i >= Py_SIZE(op)) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	105 PyErr_SetString(PyExc_IndexError, "tuple index out of range");
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	106 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	107 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	108 return ((PyTupleObject *)op) -> ob_item[i];
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	109 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	110
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	111 int
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	112 PyTuple_SetItem(register PyObject op, register Py_ssize_t i, PyObject newitem)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	113 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	114 register PyObject *olditem;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	115 register PyObject **p;
6083 f159044530b1 PyTuple_SetItem should require that the tuple's refcnt is one! Guido van Rossum <guido@python.org> parents: 5936 diff changeset	116 if (!PyTuple_Check(op) \|\| op->ob_refcnt != 1) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	117 Py_XDECREF(newitem);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	118 PyErr_BadInternalCall();
27 82c7bab78bb1 New errors. Guido van Rossum <guido@python.org> parents: 6 diff changeset	119 return -1;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	120 }
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: 43452 diff changeset	121 if (i < 0 \|\| i >= Py_SIZE(op)) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	122 Py_XDECREF(newitem);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	123 PyErr_SetString(PyExc_IndexError,
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	124 "tuple assignment index out of range");
27 82c7bab78bb1 New errors. Guido van Rossum <guido@python.org> parents: 6 diff changeset	125 return -1;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	126 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	127 p = ((PyTupleObject *)op) -> ob_item + i;
2504 425835b88099 a few peephole optimizations Guido van Rossum <guido@python.org> parents: 2059 diff changeset	128 olditem = *p;
425835b88099 a few peephole optimizations Guido van Rossum <guido@python.org> parents: 2059 diff changeset	129 *p = newitem;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	130 Py_XDECREF(olditem);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	131 return 0;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	132 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	133
30682 473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	134 PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	135 PyTuple_Pack(Py_ssize_t n, ...)
30682 473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	136 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	137 Py_ssize_t i;
30682 473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	138 PyObject *o;
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	139 PyObject *result;
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	140 PyObject **items;
30682 473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	141 va_list vargs;
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	142
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	143 va_start(vargs, n);
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	144 result = PyTuple_New(n);
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	145 if (result == NULL)
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	146 return NULL;
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	147 items = ((PyTupleObject *)result)->ob_item;
30682 473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	148 for (i = 0; i < n; i++) {
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	149 o = va_arg(vargs, PyObject *);
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	150 Py_INCREF(o);
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	151 items[i] = o;
30682 473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	152 }
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	153 va_end(vargs);
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	154 return result;
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	155 }
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	156
473f4e2959a8 Extended tuple's C API to include a new function, PyTuple_Pack() that is Raymond Hettinger <python@rcn.com> parents: 29008 diff changeset	157
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	158 /* Methods */
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	159
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	160 static void
13459 0f95c93f200b ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13265 diff changeset	161 tupledealloc(register PyTupleObject *op)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	162 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	163 register 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: 43452 diff changeset	164 register Py_ssize_t len = Py_SIZE(op);
22626 0446eeb787b7 Backport to 2.2.1: Guido van Rossum <guido@python.org> parents: 21293 diff changeset	165 PyObject_GC_UnTrack(op);
11999 c94247b5c355 Christian Tismer's "trashcan" patch: Guido van Rossum <guido@python.org> parents: 11673 diff changeset	166 Py_TRASHCAN_SAFE_BEGIN(op)
12439 456869eaa7d5 Patch by Charles G Waldman to avoid a sneaky memory leak in Guido van Rossum <guido@python.org> parents: 11999 diff changeset	167 if (len > 0) {
456869eaa7d5 Patch by Charles G Waldman to avoid a sneaky memory leak in Guido van Rossum <guido@python.org> parents: 11999 diff changeset	168 i = len;
31759 be5d2a07bc26 Restored revision 2.87. Armin Rigo <arigo@tunes.org> parents: 31756 diff changeset	169 while (--i >= 0)
be5d2a07bc26 Restored revision 2.87. Armin Rigo <arigo@tunes.org> parents: 31756 diff changeset	170 Py_XDECREF(op->ob_item[i]);
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	171 #if PyTuple_MAXSAVESIZE > 0
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	172 if (len < PyTuple_MAXSAVESIZE &&
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	173 numfree[len] < PyTuple_MAXFREELIST &&
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: 43452 diff changeset	174 Py_TYPE(op) == &PyTuple_Type)
19612 c396afef1aa9 More stuff discovered while writing the simplest of testcases: Guido van Rossum <guido@python.org> parents: 19592 diff changeset	175 {
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	176 op->ob_item[0] = (PyObject *) free_list[len];
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	177 numfree[len]++;
920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	178 free_list[len] = op;
11999 c94247b5c355 Christian Tismer's "trashcan" patch: Guido van Rossum <guido@python.org> parents: 11673 diff changeset	179 goto done; /* return */
8559 92267838feb9 Slight rearrangement of some code to make it faster, by Vladimir Guido van Rossum <guido@python.org> parents: 6083 diff changeset	180 }
1352 4d1a15fc4748 intobject.c: Save references to small integers, so that they can be Sjoerd Mullender <sjoerd@acm.org> parents: 1347 diff changeset	181 #endif
8559 92267838feb9 Slight rearrangement of some code to make it faster, by Vladimir Guido van Rossum <guido@python.org> parents: 6083 diff changeset	182 }
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: 43452 diff changeset	183 Py_TYPE(op)->tp_free((PyObject *)op);
11999 c94247b5c355 Christian Tismer's "trashcan" patch: Guido van Rossum <guido@python.org> parents: 11673 diff changeset	184 done:
c94247b5c355 Christian Tismer's "trashcan" patch: Guido van Rossum <guido@python.org> parents: 11673 diff changeset	185 Py_TRASHCAN_SAFE_END(op)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	186 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	187
288 9b43a983124c printobject now returns an error code Guido van Rossum <guido@python.org> parents: 258 diff changeset	188 static int
13459 0f95c93f200b ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13265 diff changeset	189 tupleprint(PyTupleObject op, FILE fp, int flags)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	190 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	191 Py_ssize_t i;
43378 7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for Brett Cannon <bcannon@gmail.com> parents: 42951 diff changeset	192 Py_BEGIN_ALLOW_THREADS
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	193 fprintf(fp, "(");
43378 7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for Brett Cannon <bcannon@gmail.com> parents: 42951 diff changeset	194 Py_END_ALLOW_THREADS
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: 43452 diff changeset	195 for (i = 0; i < Py_SIZE(op); i++) {
43378 7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for Brett Cannon <bcannon@gmail.com> parents: 42951 diff changeset	196 if (i > 0) {
7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for Brett Cannon <bcannon@gmail.com> parents: 42951 diff changeset	197 Py_BEGIN_ALLOW_THREADS
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	198 fprintf(fp, ", ");
43378 7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for Brett Cannon <bcannon@gmail.com> parents: 42951 diff changeset	199 Py_END_ALLOW_THREADS
7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for Brett Cannon <bcannon@gmail.com> parents: 42951 diff changeset	200 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	201 if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
288 9b43a983124c printobject now returns an error code Guido van Rossum <guido@python.org> parents: 258 diff changeset	202 return -1;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	203 }
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: 43452 diff changeset	204 i = Py_SIZE(op);
43378 7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for Brett Cannon <bcannon@gmail.com> parents: 42951 diff changeset	205 Py_BEGIN_ALLOW_THREADS
7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for Brett Cannon <bcannon@gmail.com> parents: 42951 diff changeset	206 if (i == 1)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	207 fprintf(fp, ",");
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	208 fprintf(fp, ")");
43378 7630248b593c Add a bunch of GIL release/acquire points in tp_print implementations and for Brett Cannon <bcannon@gmail.com> parents: 42951 diff changeset	209 Py_END_ALLOW_THREADS
288 9b43a983124c printobject now returns an error code Guido van Rossum <guido@python.org> parents: 258 diff changeset	210 return 0;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	211 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	212
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	213 static PyObject *
13459 0f95c93f200b ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13265 diff changeset	214 tuplerepr(PyTupleObject *v)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	215 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	216 Py_ssize_t i, n;
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	217 PyObject s, temp;
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	218 PyObject pieces, result = NULL;
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	219
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: 43452 diff changeset	220 n = Py_SIZE(v);
43452 106a71c51477 Fix error introduced by r58288; if a tuple is length 0 return its repr and Brett Cannon <bcannon@gmail.com> parents: 43451 diff changeset	221 if (n == 0)
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	222 return PyString_FromString("()");
43452 106a71c51477 Fix error introduced by r58288; if a tuple is length 0 return its repr and Brett Cannon <bcannon@gmail.com> parents: 43451 diff changeset	223
43451 381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	224 /* While not mutable, it is still possible to end up with a cycle in a
381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	225 tuple through an object that stores itself within a tuple (and thus
381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	226 infinitely asks for the repr of itself). This should only be
381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	227 possible within a type. */
381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	228 i = Py_ReprEnter((PyObject *)v);
381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	229 if (i != 0) {
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	230 return i > 0 ? PyString_FromString("(...)") : NULL;
43451 381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	231 }
381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	232
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	233 pieces = PyTuple_New(n);
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	234 if (pieces == NULL)
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	235 return NULL;
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	236
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	237 /* Do repr() on each element. */
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	238 for (i = 0; i < n; ++i) {
43451 381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	239 if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	240 goto Done;
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	241 s = PyObject_Repr(v->ob_item[i]);
43451 381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	242 Py_LeaveRecursiveCall();
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	243 if (s == NULL)
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	244 goto Done;
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	245 PyTuple_SET_ITEM(pieces, i, s);
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	246 }
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	247
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	248 /* Add "()" decorations to the first and last items. */
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	249 assert(n > 0);
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	250 s = PyString_FromString("(");
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	251 if (s == NULL)
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	252 goto Done;
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	253 temp = PyTuple_GET_ITEM(pieces, 0);
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	254 PyString_ConcatAndDel(&s, temp);
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	255 PyTuple_SET_ITEM(pieces, 0, s);
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	256 if (s == NULL)
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	257 goto Done;
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	258
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	259 s = PyString_FromString(n == 1 ? ",)" : ")");
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	260 if (s == NULL)
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	261 goto Done;
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	262 temp = PyTuple_GET_ITEM(pieces, n-1);
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	263 PyString_ConcatAndDel(&temp, s);
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	264 PyTuple_SET_ITEM(pieces, n-1, temp);
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	265 if (temp == NULL)
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	266 goto Done;
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	267
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	268 /* Paste them all together with ", " between. */
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	269 s = PyString_FromString(", ");
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	270 if (s == NULL)
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	271 goto Done;
47527 52294af4b663 This reverts r63675 based on the discussion in this thread: Gregory P. Smith <greg@mad-scientist.com> parents: 47294 diff changeset	272 result = _PyString_Join(s, pieces);
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	273 Py_DECREF(s);
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	274
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	275 Done:
9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	276 Py_DECREF(pieces);
43451 381ed41003e7 tuple.__repr__ did not consider a reference loop as it is not possible from Brett Cannon <bcannon@gmail.com> parents: 43378 diff changeset	277 Py_ReprLeave((PyObject *)v);
18129 9d533ae574d2 SF bug 433228: repr(list) woes when len(list) big. Tim Peters <tim.peters@gmail.com> parents: 17979 diff changeset	278 return result;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	279 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	280
32242 0bdb49a5a8fa Replaced arbitrary addend in tuple_hash with one that is known to generate Raymond Hettinger <python@rcn.com> parents: 32171 diff changeset	281 /* The addend 82520, was selected from the range(0, 1000000) for
0bdb49a5a8fa Replaced arbitrary addend in tuple_hash with one that is known to generate Raymond Hettinger <python@rcn.com> parents: 32171 diff changeset	282 generating the greatest number of prime multipliers for tuples
0bdb49a5a8fa Replaced arbitrary addend in tuple_hash with one that is known to generate Raymond Hettinger <python@rcn.com> parents: 32171 diff changeset	283 upto length eight:
0bdb49a5a8fa Replaced arbitrary addend in tuple_hash with one that is known to generate Raymond Hettinger <python@rcn.com> parents: 32171 diff changeset	284
0bdb49a5a8fa Replaced arbitrary addend in tuple_hash with one that is known to generate Raymond Hettinger <python@rcn.com> parents: 32171 diff changeset	285 1082527, 1165049, 1082531, 1165057, 1247581, 1330103, 1082533,
0bdb49a5a8fa Replaced arbitrary addend in tuple_hash with one that is known to generate Raymond Hettinger <python@rcn.com> parents: 32171 diff changeset	286 1330111, 1412633, 1165069, 1247599, 1495177, 1577699
0bdb49a5a8fa Replaced arbitrary addend in tuple_hash with one that is known to generate Raymond Hettinger <python@rcn.com> parents: 32171 diff changeset	287 */
0bdb49a5a8fa Replaced arbitrary addend in tuple_hash with one that is known to generate Raymond Hettinger <python@rcn.com> parents: 32171 diff changeset	288
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	289 static long
13459 0f95c93f200b ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13265 diff changeset	290 tuplehash(PyTupleObject *v)
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	291 {
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	292 register long x, y;
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: 43452 diff changeset	293 register Py_ssize_t len = Py_SIZE(v);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	294 register PyObject **p;
32171 97b908a9971a SF bug #942952: Weakness in tuple hash Raymond Hettinger <python@rcn.com> parents: 31759 diff changeset	295 long mult = 1000003L;
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	296 x = 0x345678L;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	297 p = v->ob_item;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	298 while (--len >= 0) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	299 y = PyObject_Hash(*p++);
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	300 if (y == -1)
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	301 return -1;
32171 97b908a9971a SF bug #942952: Weakness in tuple hash Raymond Hettinger <python@rcn.com> parents: 31759 diff changeset	302 x = (x ^ y) * mult;
36519 d6d415df0df0 Use Py_ssize_t for counts and sizes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	303 /* the cast might truncate len; that doesn't change hash stability */
d6d415df0df0 Use Py_ssize_t for counts and sizes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	304 mult += (long)(82520L + len + len);
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	305 }
32318 418a0c6bdc7d Add a final permutation step to the tuple hash function. Raymond Hettinger <python@rcn.com> parents: 32242 diff changeset	306 x += 97531L;
1257 1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	307 if (x == -1)
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	308 x = -2;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	309 return x;
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	310 }
1cabc2b6c970 * Changed all copyright messages to include 1993. Guido van Rossum <guido@python.org> parents: 795 diff changeset	311
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	312 static Py_ssize_t
13459 0f95c93f200b ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13265 diff changeset	313 tuplelength(PyTupleObject *a)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	314 {
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: 43452 diff changeset	315 return Py_SIZE(a);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	316 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	317
12516 e6e914d5b207 add list_contains and tuplecontains: efficient implementations of tp_contains Jeremy Hylton <jeremy@alum.mit.edu> parents: 12439 diff changeset	318 static int
13459 0f95c93f200b ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13265 diff changeset	319 tuplecontains(PyTupleObject a, PyObject el)
12516 e6e914d5b207 add list_contains and tuplecontains: efficient implementations of tp_contains Jeremy Hylton <jeremy@alum.mit.edu> parents: 12439 diff changeset	320 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	321 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	322 int cmp;
12516 e6e914d5b207 add list_contains and tuplecontains: efficient implementations of tp_contains Jeremy Hylton <jeremy@alum.mit.edu> parents: 12439 diff changeset	323
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: 43452 diff changeset	324 for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	325 cmp = PyObject_RichCompareBool(el, PyTuple_GET_ITEM(a, i),
25125 172845c09afe Micro-optimization for list_contains. Factored double if test Raymond Hettinger <python@rcn.com> parents: 24898 diff changeset	326 Py_EQ);
25128 f1c69c32c42b PyObject_RichCompareBool() already returns -1, 0, or 1, so return its value Neal Norwitz <nnorwitz@gmail.com> parents: 25125 diff changeset	327 return cmp;
12516 e6e914d5b207 add list_contains and tuplecontains: efficient implementations of tp_contains Jeremy Hylton <jeremy@alum.mit.edu> parents: 12439 diff changeset	328 }
e6e914d5b207 add list_contains and tuplecontains: efficient implementations of tp_contains Jeremy Hylton <jeremy@alum.mit.edu> parents: 12439 diff changeset	329
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	330 static PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	331 tupleitem(register PyTupleObject *a, register Py_ssize_t i)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	332 {
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: 43452 diff changeset	333 if (i < 0 \|\| i >= Py_SIZE(a)) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	334 PyErr_SetString(PyExc_IndexError, "tuple index out of range");
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	335 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	336 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	337 Py_INCREF(a->ob_item[i]);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	338 return a->ob_item[i];
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	339 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	340
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	341 static PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	342 tupleslice(register PyTupleObject *a, register Py_ssize_t ilow,
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	343 register Py_ssize_t ihigh)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	344 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	345 register PyTupleObject *np;
31623 d34e7eaf4cd6 Optimize tuple_slice() and make further improvements to list_slice() Raymond Hettinger <python@rcn.com> parents: 30682 diff changeset	346 PyObject src, dest;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	347 register Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	348 Py_ssize_t len;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	349 if (ilow < 0)
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	350 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: 43452 diff changeset	351 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: 43452 diff changeset	352 ihigh = Py_SIZE(a);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	353 if (ihigh < ilow)
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	354 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: 43452 diff changeset	355 if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	356 Py_INCREF(a);
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	357 return (PyObject *)a;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	358 }
31623 d34e7eaf4cd6 Optimize tuple_slice() and make further improvements to list_slice() Raymond Hettinger <python@rcn.com> parents: 30682 diff changeset	359 len = ihigh - ilow;
d34e7eaf4cd6 Optimize tuple_slice() and make further improvements to list_slice() Raymond Hettinger <python@rcn.com> parents: 30682 diff changeset	360 np = (PyTupleObject *)PyTuple_New(len);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	361 if (np == NULL)
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	362 return NULL;
31623 d34e7eaf4cd6 Optimize tuple_slice() and make further improvements to list_slice() Raymond Hettinger <python@rcn.com> parents: 30682 diff changeset	363 src = a->ob_item + ilow;
d34e7eaf4cd6 Optimize tuple_slice() and make further improvements to list_slice() Raymond Hettinger <python@rcn.com> parents: 30682 diff changeset	364 dest = np->ob_item;
d34e7eaf4cd6 Optimize tuple_slice() and make further improvements to list_slice() Raymond Hettinger <python@rcn.com> parents: 30682 diff changeset	365 for (i = 0; i < len; i++) {
d34e7eaf4cd6 Optimize tuple_slice() and make further improvements to list_slice() Raymond Hettinger <python@rcn.com> parents: 30682 diff changeset	366 PyObject *v = src[i];
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	367 Py_INCREF(v);
31623 d34e7eaf4cd6 Optimize tuple_slice() and make further improvements to list_slice() Raymond Hettinger <python@rcn.com> parents: 30682 diff changeset	368 dest[i] = v;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	369 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	370 return (PyObject *)np;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	371 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	372
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	373 PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	374 PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)
599 a347933a6d92 New function gettupleslice(v, i, j). Guido van Rossum <guido@python.org> parents: 288 diff changeset	375 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	376 if (op == NULL \|\| !PyTuple_Check(op)) {
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	377 PyErr_BadInternalCall();
599 a347933a6d92 New function gettupleslice(v, i, j). Guido van Rossum <guido@python.org> parents: 288 diff changeset	378 return NULL;
a347933a6d92 New function gettupleslice(v, i, j). Guido van Rossum <guido@python.org> parents: 288 diff changeset	379 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	380 return tupleslice((PyTupleObject *)op, i, j);
599 a347933a6d92 New function gettupleslice(v, i, j). Guido van Rossum <guido@python.org> parents: 288 diff changeset	381 }
a347933a6d92 New function gettupleslice(v, i, j). Guido van Rossum <guido@python.org> parents: 288 diff changeset	382
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	383 static PyObject *
13459 0f95c93f200b ANSI-fication of the sources. Fred Drake <fdrake@acm.org> parents: 13265 diff changeset	384 tupleconcat(register PyTupleObject a, register PyObject bb)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	385 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	386 register Py_ssize_t size;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	387 register Py_ssize_t i;
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	388 PyObject src, dest;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	389 PyTupleObject *np;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	390 if (!PyTuple_Check(bb)) {
12816 4272b368bf69 Michael Hudson <mwh21@cam.ac.uk>: Fred Drake <fdrake@acm.org> parents: 12576 diff changeset	391 PyErr_Format(PyExc_TypeError,
12929 2eef636ba1b6 Michael Hudson <mwh21@cam.ac.uk>: Marc-André Lemburg <mal@egenix.com> parents: 12925 diff changeset	392 "can only concatenate tuple (not \"%.200s\") to tuple",
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: 43452 diff changeset	393 Py_TYPE(bb)->tp_name);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	394 return NULL;
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	395 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	396 #define b ((PyTupleObject *)bb)
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: 43452 diff changeset	397 size = Py_SIZE(a) + Py_SIZE(b);
25740 70f9026a2b16 Add checks for size overflow on listn, list+list, tuple+tuple. Guido van Rossum <guido@python.org>* parents: 25128 diff changeset	398 if (size < 0)
70f9026a2b16 Add checks for size overflow on listn, list+list, tuple+tuple. Guido van Rossum <guido@python.org>* parents: 25128 diff changeset	399 return PyErr_NoMemory();
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	400 np = (PyTupleObject *) PyTuple_New(size);
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	401 if (np == NULL) {
288 9b43a983124c printobject now returns an error code Guido van Rossum <guido@python.org> parents: 258 diff changeset	402 return NULL;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	403 }
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	404 src = a->ob_item;
5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	405 dest = 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: 43452 diff changeset	406 for (i = 0; i < Py_SIZE(a); i++) {
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	407 PyObject *v = src[i];
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	408 Py_INCREF(v);
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	409 dest[i] = v;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	410 }
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	411 src = b->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: 43452 diff changeset	412 dest = np->ob_item + 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: 43452 diff changeset	413 for (i = 0; i < Py_SIZE(b); i++) {
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	414 PyObject *v = src[i];
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	415 Py_INCREF(v);
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	416 dest[i] = v;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	417 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	418 return (PyObject *)np;
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	419 #undef b
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	420 }
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	421
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	422 static PyObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	423 tuplerepeat(PyTupleObject *a, Py_ssize_t n)
258 3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	424 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	425 Py_ssize_t i, j;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	426 Py_ssize_t size;
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	427 PyTupleObject *np;
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	428 PyObject p, items;
258 3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	429 if (n < 0)
3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	430 n = 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: 43452 diff changeset	431 if (Py_SIZE(a) == 0 \|\| n == 1) {
19872 51363348dcfa The endless 460020 bug. Tim Peters <tim.peters@gmail.com> parents: 19657 diff changeset	432 if (PyTuple_CheckExact(a)) {
51363348dcfa The endless 460020 bug. Tim Peters <tim.peters@gmail.com> parents: 19657 diff changeset	433 /* Since tuples are immutable, we can return a shared
51363348dcfa The endless 460020 bug. Tim Peters <tim.peters@gmail.com> parents: 19657 diff changeset	434 copy in this case */
51363348dcfa The endless 460020 bug. Tim Peters <tim.peters@gmail.com> parents: 19657 diff changeset	435 Py_INCREF(a);
51363348dcfa The endless 460020 bug. Tim Peters <tim.peters@gmail.com> parents: 19657 diff changeset	436 return (PyObject *)a;
51363348dcfa The endless 460020 bug. Tim Peters <tim.peters@gmail.com> parents: 19657 diff changeset	437 }
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: 43452 diff changeset	438 if (Py_SIZE(a) == 0)
19872 51363348dcfa The endless 460020 bug. Tim Peters <tim.peters@gmail.com> parents: 19657 diff changeset	439 return PyTuple_New(0);
258 3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	440 }
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: 43452 diff changeset	441 size = Py_SIZE(a) * 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: 43452 diff changeset	442 if (size/Py_SIZE(a) != n)
11127 9a20038f0b99 Appropriate overflow checks so that things like sys.maxint(1,) can't Guido van Rossum <guido@python.org>* parents: 9632 diff changeset	443 return PyErr_NoMemory();
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	444 np = (PyTupleObject *) PyTuple_New(size);
258 3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	445 if (np == NULL)
3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	446 return NULL;
3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	447 p = np->ob_item;
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	448 items = a->ob_item;
258 3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	449 for (i = 0; i < n; 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: 43452 diff changeset	450 for (j = 0; j < Py_SIZE(a); j++) {
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	451 *p = items[j];
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	452 Py_INCREF(*p);
258 3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	453 p++;
3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	454 }
3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	455 }
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	456 return (PyObject *) np;
258 3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	457 }
3b93bcea10f6 Finally implement tuplenumber. From now on all sequence types Guido van Rossum <guido@python.org>* parents: 145 diff changeset	458
45207 3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	459 static PyObject *
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	460 tupleindex(PyTupleObject self, PyObject args)
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	461 {
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	462 Py_ssize_t i, start=0, stop=Py_SIZE(self);
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	463 PyObject *v;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	464
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	465 if (!PyArg_ParseTuple(args, "O\|O&O&:index", &v,
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	466 _PyEval_SliceIndex, &start,
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	467 _PyEval_SliceIndex, &stop))
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	468 return NULL;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	469 if (start < 0) {
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	470 start += Py_SIZE(self);
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	471 if (start < 0)
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	472 start = 0;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	473 }
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	474 if (stop < 0) {
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	475 stop += Py_SIZE(self);
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	476 if (stop < 0)
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	477 stop = 0;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	478 }
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	479 for (i = start; i < stop && i < Py_SIZE(self); i++) {
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	480 int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	481 if (cmp > 0)
45210 0958cc46b33f Return ints instead of longs for tuple.count() and tuple.index(). Raymond Hettinger <python@rcn.com> parents: 45207 diff changeset	482 return PyInt_FromSsize_t(i);
45207 3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	483 else if (cmp < 0)
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	484 return NULL;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	485 }
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	486 PyErr_SetString(PyExc_ValueError, "tuple.index(x): x not in list");
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	487 return NULL;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	488 }
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	489
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	490 static PyObject *
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	491 tuplecount(PyTupleObject self, PyObject v)
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	492 {
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	493 Py_ssize_t count = 0;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	494 Py_ssize_t i;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	495
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	496 for (i = 0; i < Py_SIZE(self); i++) {
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	497 int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	498 if (cmp > 0)
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	499 count++;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	500 else if (cmp < 0)
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	501 return NULL;
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	502 }
45210 0958cc46b33f Return ints instead of longs for tuple.count() and tuple.index(). Raymond Hettinger <python@rcn.com> parents: 45207 diff changeset	503 return PyInt_FromSsize_t(count);
45207 3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	504 }
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	505
12990 e615596c5c47 Round 1 of Neil Schemenauer's GC patches: Jeremy Hylton <jeremy@alum.mit.edu> parents: 12929 diff changeset	506 static int
e615596c5c47 Round 1 of Neil Schemenauer's GC patches: Jeremy Hylton <jeremy@alum.mit.edu> parents: 12929 diff changeset	507 tupletraverse(PyTupleObject o, visitproc visit, void arg)
e615596c5c47 Round 1 of Neil Schemenauer's GC patches: Jeremy Hylton <jeremy@alum.mit.edu> parents: 12929 diff changeset	508 {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	509 Py_ssize_t i;
12990 e615596c5c47 Round 1 of Neil Schemenauer's GC patches: Jeremy Hylton <jeremy@alum.mit.edu> parents: 12929 diff changeset	510
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: 43452 diff changeset	511 for (i = Py_SIZE(o); --i >= 0; )
37756 7b2e436a4a21 Use Py_VISIT in all tp_traverse methods, instead of traversing manually or Thomas Wouters <thomas@python.org> parents: 37602 diff changeset	512 Py_VISIT(o->ob_item[i]);
12990 e615596c5c47 Round 1 of Neil Schemenauer's GC patches: Jeremy Hylton <jeremy@alum.mit.edu> parents: 12929 diff changeset	513 return 0;
e615596c5c47 Round 1 of Neil Schemenauer's GC patches: Jeremy Hylton <jeremy@alum.mit.edu> parents: 12929 diff changeset	514 }
e615596c5c47 Round 1 of Neil Schemenauer's GC patches: Jeremy Hylton <jeremy@alum.mit.edu> parents: 12929 diff changeset	515
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	516 static PyObject *
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	517 tuplerichcompare(PyObject v, PyObject w, int op)
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	518 {
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	519 PyTupleObject vt, wt;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	520 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	521 Py_ssize_t vlen, wlen;
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	522
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	523 if (!PyTuple_Check(v) \|\| !PyTuple_Check(w)) {
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	524 Py_INCREF(Py_NotImplemented);
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	525 return Py_NotImplemented;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	526 }
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	527
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	528 vt = (PyTupleObject *)v;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	529 wt = (PyTupleObject *)w;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	530
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: 43452 diff changeset	531 vlen = Py_SIZE(vt);
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: 43452 diff changeset	532 wlen = Py_SIZE(wt);
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	533
17841 2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	534 /* Note: the corresponding code for lists has an "early out" test
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	535 * here when op is EQ or NE and the lengths differ. That pays there,
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	536 * but Tim was unable to find any real code where EQ/NE tuple
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	537 * compares don't have the same length, so testing for it here would
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	538 * have cost without benefit.
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	539 */
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	540
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	541 /* Search for the first index where items are different.
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	542 * Note that because tuples are immutable, it's safe to reuse
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	543 * vlen and wlen across the comparison calls.
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	544 */
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	545 for (i = 0; i < vlen && i < wlen; i++) {
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	546 int k = PyObject_RichCompareBool(vt->ob_item[i],
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	547 wt->ob_item[i], Py_EQ);
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	548 if (k < 0)
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	549 return NULL;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	550 if (!k)
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	551 break;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	552 }
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	553
17841 2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	554 if (i >= vlen \|\| i >= wlen) {
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	555 /* No more items to compare -- compare sizes */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	556 int cmp;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	557 PyObject *res;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	558 switch (op) {
17841 2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	559 case Py_LT: cmp = vlen < wlen; break;
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	560 case Py_LE: cmp = vlen <= wlen; break;
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	561 case Py_EQ: cmp = vlen == wlen; break;
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	562 case Py_NE: cmp = vlen != wlen; break;
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	563 case Py_GT: cmp = vlen > wlen; break;
2b5a9bff1b11 Speed tuple comparisons in two ways: Tim Peters <tim.peters@gmail.com> parents: 15973 diff changeset	564 case Py_GE: cmp = vlen >= wlen; break;
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	565 default: return NULL; /* cannot happen */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	566 }
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	567 if (cmp)
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	568 res = Py_True;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	569 else
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	570 res = Py_False;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	571 Py_INCREF(res);
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	572 return res;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	573 }
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	574
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	575 /* We have an item that differs -- shortcuts for EQ/NE */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	576 if (op == Py_EQ) {
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	577 Py_INCREF(Py_False);
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	578 return Py_False;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	579 }
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	580 if (op == Py_NE) {
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	581 Py_INCREF(Py_True);
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	582 return Py_True;
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	583 }
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	584
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	585 /* Compare the final item again using the proper operator */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	586 return PyObject_RichCompare(vt->ob_item[i], wt->ob_item[i], op);
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	587 }
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	588
24280 1598a1e473e2 staticforward bites the dust. Jeremy Hylton <jeremy@alum.mit.edu> parents: 24184 diff changeset	589 static PyObject *
19592 85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	590 tuple_subtype_new(PyTypeObject type, PyObject args, PyObject *kwds);
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	591
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	592 static PyObject *
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	593 tuple_new(PyTypeObject type, PyObject args, PyObject *kwds)
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	594 {
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	595 PyObject *arg = NULL;
36675 dba6494735d0 Revert backwards-incompatible const changes. Martin v. Löwis <martin@v.loewis.de> parents: 36519 diff changeset	596 static char *kwlist[] = {"sequence", 0};
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	597
19592 85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	598 if (type != &PyTuple_Type)
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	599 return tuple_subtype_new(type, args, kwds);
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	600 if (!PyArg_ParseTupleAndKeywords(args, kwds, "\|O:tuple", kwlist, &arg))
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	601 return NULL;
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	602
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	603 if (arg == NULL)
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	604 return PyTuple_New(0);
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	605 else
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	606 return PySequence_Tuple(arg);
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	607 }
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	608
19592 85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	609 static PyObject *
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	610 tuple_subtype_new(PyTypeObject type, PyObject args, PyObject *kwds)
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	611 {
37596 1b078493d538 More low-hanging fruit. Still need to re-arrange some code (or find a better Anthony Baxter <anthonybaxter@gmail.com> parents: 37067 diff changeset	612 PyObject tmp, newobj, *item;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	613 Py_ssize_t i, n;
19592 85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	614
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	615 assert(PyType_IsSubtype(type, &PyTuple_Type));
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	616 tmp = tuple_new(&PyTuple_Type, args, kwds);
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	617 if (tmp == NULL)
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	618 return NULL;
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	619 assert(PyTuple_Check(tmp));
37596 1b078493d538 More low-hanging fruit. Still need to re-arrange some code (or find a better Anthony Baxter <anthonybaxter@gmail.com> parents: 37067 diff changeset	620 newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));
1b078493d538 More low-hanging fruit. Still need to re-arrange some code (or find a better Anthony Baxter <anthonybaxter@gmail.com> parents: 37067 diff changeset	621 if (newobj == NULL)
19592 85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	622 return NULL;
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	623 for (i = 0; i < n; i++) {
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	624 item = PyTuple_GET_ITEM(tmp, i);
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	625 Py_INCREF(item);
37596 1b078493d538 More low-hanging fruit. Still need to re-arrange some code (or find a better Anthony Baxter <anthonybaxter@gmail.com> parents: 37067 diff changeset	626 PyTuple_SET_ITEM(newobj, i, item);
19592 85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	627 }
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	628 Py_DECREF(tmp);
37596 1b078493d538 More low-hanging fruit. Still need to re-arrange some code (or find a better Anthony Baxter <anthonybaxter@gmail.com> parents: 37067 diff changeset	629 return newobj;
19592 85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	630 }
85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	631
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23778 diff changeset	632 PyDoc_STRVAR(tuple_doc,
19657 937965516b54 Rewrite the tuple() docstring to parallel the list() docstring. Tim Peters <tim.peters@gmail.com> parents: 19656 diff changeset	633 "tuple() -> an empty tuple\n"
937965516b54 Rewrite the tuple() docstring to parallel the list() docstring. Tim Peters <tim.peters@gmail.com> parents: 19656 diff changeset	634 "tuple(sequence) -> tuple initialized from sequence's items\n"
937965516b54 Rewrite the tuple() docstring to parallel the list() docstring. Tim Peters <tim.peters@gmail.com> parents: 19656 diff changeset	635 "\n"
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23778 diff changeset	636 "If the argument is a tuple, the return value is the same object.");
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	637
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	638 static PySequenceMethods tuple_as_sequence = {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	639 (lenfunc)tuplelength, /* sq_length */
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	640 (binaryfunc)tupleconcat, /* sq_concat */
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	641 (ssizeargfunc)tuplerepeat, /* sq_repeat */
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	642 (ssizeargfunc)tupleitem, /* sq_item */
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	643 (ssizessizeargfunc)tupleslice, /* sq_slice */
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	644 0, /* sq_ass_item */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	645 0, /* sq_ass_slice */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	646 (objobjproc)tuplecontains, /* sq_contains */
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	647 };
fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	648
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	649 static PyObject*
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	650 tuplesubscript(PyTupleObject* self, PyObject* item)
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	651 {
39463 6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 37756 diff changeset	652 if (PyIndex_Check(item)) {
6cafdc81cfde Patch #1538606, Patch to fix __index__() clipping. Neal Norwitz <nnorwitz@gmail.com> parents: 37756 diff changeset	653 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	654 if (i == -1 && PyErr_Occurred())
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	655 return NULL;
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	656 if (i < 0)
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	657 i += PyTuple_GET_SIZE(self);
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	658 return tupleitem(self, i);
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	659 }
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	660 else if (PySlice_Check(item)) {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	661 Py_ssize_t start, stop, step, slicelength, cur, i;
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	662 PyObject* result;
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	663 PyObject* it;
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	664 PyObject src, dest;
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	665
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	666 if (PySlice_GetIndicesEx((PySliceObject*)item,
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	667 PyTuple_GET_SIZE(self),
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	668 &start, &stop, &step, &slicelength) < 0) {
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	669 return NULL;
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	670 }
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	671
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	672 if (slicelength <= 0) {
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	673 return PyTuple_New(0);
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	674 }
42951 9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	675 else if (start == 0 && step == 1 &&
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	676 slicelength == PyTuple_GET_SIZE(self) &&
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	677 PyTuple_CheckExact(self)) {
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	678 Py_INCREF(self);
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	679 return (PyObject *)self;
9620134010a5 Improve extended slicing support in builtin types and classes. Specifically: Thomas Wouters <thomas@python.org> parents: 42333 diff changeset	680 }
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	681 else {
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	682 result = PyTuple_New(slicelength);
37067 1f4549865aad Fix some missing checks after PyTuple_New, PyList_New, PyDict_New Georg Brandl <georg@python.org> parents: 36882 diff changeset	683 if (!result) return NULL;
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	684
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	685 src = self->ob_item;
5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	686 dest = ((PyTupleObject *)result)->ob_item;
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	687 for (cur = start, i = 0; i < slicelength;
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	688 cur += step, i++) {
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	689 it = src[cur];
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	690 Py_INCREF(it);
31633 5bd455638c7a Optimize inner loops for subscript, repeat, and concat. Raymond Hettinger <python@rcn.com> parents: 31623 diff changeset	691 dest[i] = it;
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	692 }
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	693
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	694 return result;
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	695 }
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	696 }
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	697 else {
40357 b871e7bd8355 Patch [ 1586791 ] better error msgs for some TypeErrors Georg Brandl <georg@python.org> parents: 39463 diff changeset	698 PyErr_Format(PyExc_TypeError,
b871e7bd8355 Patch [ 1586791 ] better error msgs for some TypeErrors Georg Brandl <georg@python.org> parents: 39463 diff changeset	699 "tuple indices must be integers, 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: 43452 diff changeset	700 Py_TYPE(item)->tp_name);
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	701 return NULL;
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	702 }
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	703 }
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	704
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	705 static PyObject *
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	706 tuple_getnewargs(PyTupleObject *v)
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	707 {
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: 43452 diff changeset	708 return Py_BuildValue("(N)", tupleslice(v, 0, Py_SIZE(v)));
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	709
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	710 }
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	711
47682 2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	712 static PyObject *
2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	713 tuple_sizeof(PyTupleObject *self)
2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	714 {
2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	715 Py_ssize_t res;
2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	716
2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	717 res = PyTuple_Type.tp_basicsize + Py_SIZE(self) * sizeof(PyObject *);
2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	718 return PyInt_FromSsize_t(res);
2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	719 }
2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	720
45207 3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	721 PyDoc_STRVAR(index_doc,
49431 2e794757bdc8 Merged revisions 66766-66767,66771-66772,66774,66776,66783-66787,66790,66793,66797 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 48114 diff changeset	722 "T.index(value, [start, [stop]]) -> integer -- return first index of value.\n"
2e794757bdc8 Merged revisions 66766-66767,66771-66772,66774,66776,66783-66787,66790,66793,66797 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 48114 diff changeset	723 "Raises ValueError if the value is not present."
2e794757bdc8 Merged revisions 66766-66767,66771-66772,66774,66776,66783-66787,66790,66793,66797 via svnmerge from Benjamin Peterson <benjamin@python.org> parents: 48114 diff changeset	724 );
45207 3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	725 PyDoc_STRVAR(count_doc,
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	726 "T.count(value) -> integer -- return number of occurrences of value");
47682 2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	727 PyDoc_STRVAR(sizeof_doc,
2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	728 "T.__sizeof__() -- size of T in memory, in bytes");
45207 3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	729
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	730 static PyMethodDef tuple_methods[] = {
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	731 {"__getnewargs__", (PyCFunction)tuple_getnewargs, METH_NOARGS},
47682 2dfaa0683be8 Fixed: sys.getsizeof does not take the actual length of the tuples into account. Robert Schuppenies <okkotonushi@googlemail.com> parents: 47527 diff changeset	732 {"__sizeof__", (PyCFunction)tuple_sizeof, METH_NOARGS, sizeof_doc},
45207 3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	733 {"index", (PyCFunction)tupleindex, METH_VARARGS, index_doc},
3f124975e099 Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. Raymond Hettinger <python@rcn.com> parents: 45191 diff changeset	734 {"count", (PyCFunction)tuplecount, METH_O, count_doc},
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	735 {NULL, NULL} /* sentinel */
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	736 };
17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	737
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	738 static PyMappingMethods tuple_as_mapping = {
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	739 (lenfunc)tuplelength,
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	740 (binaryfunc)tuplesubscript,
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	741 0
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	742 };
245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	743
24683 567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	744 static PyObject tuple_iter(PyObject seq);
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	745
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	746 PyTypeObject PyTuple_Type = {
42333 6620a510e9a9 PEP 3123: Provide forward compatibility with Python 3.0, while keeping Martin v. Löwis <martin@v.loewis.de> parents: 40908 diff changeset	747 PyVarObject_HEAD_INIT(&PyType_Type, 0)
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	748 "tuple",
19581 fd48a55ac364 Use new GC API. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 18933 diff changeset	749 sizeof(PyTupleObject) - sizeof(PyObject *),
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	750 sizeof(PyObject *),
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	751 (destructor)tupledealloc, /* tp_dealloc */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	752 (printfunc)tupleprint, /* tp_print */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	753 0, /* tp_getattr */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	754 0, /* tp_setattr */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	755 0, /* tp_compare */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	756 (reprfunc)tuplerepr, /* tp_repr */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	757 0, /* tp_as_number */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	758 &tuple_as_sequence, /* tp_as_sequence */
23778 245224d1b8c9 This is my nearly two year old patch Michael W. Hudson <mwh@python.net> parents: 22979 diff changeset	759 &tuple_as_mapping, /* tp_as_mapping */
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	760 (hashfunc)tuplehash, /* tp_hash */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	761 0, /* tp_call */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	762 0, /* tp_str */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	763 PyObject_GenericGetAttr, /* tp_getattro */
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	764 0, /* tp_setattro */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	765 0, /* tp_as_buffer */
19592 85765e61deb0 Make str and tuple types subclassable. Guido van Rossum <guido@python.org> parents: 19581 diff changeset	766 Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC \|
40908 d01bd37bf5ce Variation of patch # 1624059 to speed up checking if an object is a subclass Neal Norwitz <nnorwitz@gmail.com> parents: 40357 diff changeset	767 Py_TPFLAGS_BASETYPE \| Py_TPFLAGS_TUPLE_SUBCLASS, /* tp_flags */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	768 tuple_doc, /* tp_doc */
15973 72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	769 (traverseproc)tupletraverse, /* tp_traverse */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	770 0, /* tp_clear */
72139263f8a7 Same treatment as listobject.c: Guido van Rossum <guido@python.org> parents: 15037 diff changeset	771 tuplerichcompare, /* tp_richcompare */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	772 0, /* tp_weaklistoffset */
24683 567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	773 tuple_iter, /* tp_iter */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	774 0, /* tp_iternext */
27521 17bfd5dbc0f1 Implement appropriate __getnewargs__ for all immutable subclassable builtin Guido van Rossum <guido@python.org> parents: 25740 diff changeset	775 tuple_methods, /* tp_methods */
18933 09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	776 0, /* tp_members */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	777 0, /* tp_getset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	778 0, /* tp_base */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	779 0, /* tp_dict */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	780 0, /* tp_descr_get */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	781 0, /* tp_descr_set */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	782 0, /* tp_dictoffset */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	783 0, /* tp_init */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	784 0, /* tp_alloc */
09df3254b49d Merge of descr-branch back into trunk. Tim Peters <tim.peters@gmail.com> parents: 18129 diff changeset	785 tuple_new, /* tp_new */
22979 9fe94c01eaf1 PyObject_GC_Del can now be used as a function designator. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22626 diff changeset	786 PyObject_GC_Del, /* tp_free */
6 fc6fcd7df4f7 Initial revision Guido van Rossum <guido@python.org> parents: diff changeset	787 };
1369 89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	788
89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	789 /* The following function breaks the notion that tuples are immutable:
89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	790 it changes the size of a tuple. We get away with this only if there
89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	791 is only one module referencing the object. You can also think of it
15037 c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	792 as creating a new tuple object and destroying the old one, only more
c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	793 efficiently. In any case, don't use this if the tuple may already be
17976 d579a5d8b3fe Cruft cleanup: Removed the unused last_is_sticky argument from the internal Tim Peters <tim.peters@gmail.com> parents: 17975 diff changeset	794 known to some other part of the code. */
1369 89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	795
89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	796 int
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	797 _PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
1369 89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	798 {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	799 register PyTupleObject *v;
d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	800 register PyTupleObject *sv;
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	801 Py_ssize_t i;
7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36484 diff changeset	802 Py_ssize_t oldsize;
1380 a4aa83012af3 Fixed bugs in resizetuple and extended the interface. Sjoerd Mullender <sjoerd@acm.org> parents: 1369 diff changeset	803
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	804 v = (PyTupleObject ) pv;
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: 43452 diff changeset	805 if (v == NULL \|\| Py_TYPE(v) != &PyTuple_Type \|\|
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: 43452 diff changeset	806 (Py_SIZE(v) != 0 && Py_REFCNT(v) != 1)) {
1369 89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	807 *pv = 0;
15037 c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	808 Py_XDECREF(v);
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	809 PyErr_BadInternalCall();
1369 89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	810 return -1;
89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	811 }
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: 43452 diff changeset	812 oldsize = Py_SIZE(v);
21293 b810c30b4aa1 _PyTuple_Resize(): this dumped core on tuple(globals()) for me. Turns Guido van Rossum <guido@python.org> parents: 20277 diff changeset	813 if (oldsize == newsize)
1380 a4aa83012af3 Fixed bugs in resizetuple and extended the interface. Sjoerd Mullender <sjoerd@acm.org> parents: 1369 diff changeset	814 return 0;
15037 c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	815
21293 b810c30b4aa1 _PyTuple_Resize(): this dumped core on tuple(globals()) for me. Turns Guido van Rossum <guido@python.org> parents: 20277 diff changeset	816 if (oldsize == 0) {
17975 527d0ffdf099 _PyTuple_Resize: take into account the empty tuple. There can be only one. Thomas Wouters <thomas@python.org> parents: 17841 diff changeset	817 /* Empty tuples are often shared, so we should never
527d0ffdf099 _PyTuple_Resize: take into account the empty tuple. There can be only one. Thomas Wouters <thomas@python.org> parents: 17841 diff changeset	818 resize them in-place even if we do own the only
527d0ffdf099 _PyTuple_Resize: take into account the empty tuple. There can be only one. Thomas Wouters <thomas@python.org> parents: 17841 diff changeset	819 (current) reference */
527d0ffdf099 _PyTuple_Resize: take into account the empty tuple. There can be only one. Thomas Wouters <thomas@python.org> parents: 17841 diff changeset	820 Py_DECREF(v);
527d0ffdf099 _PyTuple_Resize: take into account the empty tuple. There can be only one. Thomas Wouters <thomas@python.org> parents: 17841 diff changeset	821 *pv = PyTuple_New(newsize);
17979 192d36869445 _PyTuple_Resize: guard against PyTuple_New() returning NULL, using Tim's Thomas Wouters <thomas@python.org> parents: 17976 diff changeset	822 return *pv == NULL ? -1 : 0;
17975 527d0ffdf099 _PyTuple_Resize: take into account the empty tuple. There can be only one. Thomas Wouters <thomas@python.org> parents: 17841 diff changeset	823 }
527d0ffdf099 _PyTuple_Resize: take into account the empty tuple. There can be only one. Thomas Wouters <thomas@python.org> parents: 17841 diff changeset	824
1369 89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	825 /* XXX UNREF/NEWREF interface should be more symmetrical */
24184 c4dcb80f48ea object.h special-build macro minefield: renamed all the new lexical Tim Peters <tim.peters@gmail.com> parents: 23952 diff changeset	826 _Py_DEC_REFTOTAL;
19581 fd48a55ac364 Use new GC API. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 18933 diff changeset	827 _PyObject_GC_UNTRACK(v);
15037 c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	828 _Py_ForgetReference((PyObject *) v);
21293 b810c30b4aa1 _PyTuple_Resize(): this dumped core on tuple(globals()) for me. Turns Guido van Rossum <guido@python.org> parents: 20277 diff changeset	829 /* DECREF items deleted by shrinkage */
b810c30b4aa1 _PyTuple_Resize(): this dumped core on tuple(globals()) for me. Turns Guido van Rossum <guido@python.org> parents: 20277 diff changeset	830 for (i = newsize; i < oldsize; i++) {
5396 d1447950fa04 Quickly renamed the last directory. Guido van Rossum <guido@python.org> parents: 4733 diff changeset	831 Py_XDECREF(v->ob_item[i]);
1380 a4aa83012af3 Fixed bugs in resizetuple and extended the interface. Sjoerd Mullender <sjoerd@acm.org> parents: 1369 diff changeset	832 v->ob_item[i] = NULL;
a4aa83012af3 Fixed bugs in resizetuple and extended the interface. Sjoerd Mullender <sjoerd@acm.org> parents: 1369 diff changeset	833 }
19581 fd48a55ac364 Use new GC API. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 18933 diff changeset	834 sv = PyObject_GC_Resize(PyTupleObject, v, newsize);
15037 c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	835 if (sv == NULL) {
c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	836 *pv = NULL;
19581 fd48a55ac364 Use new GC API. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 18933 diff changeset	837 PyObject_GC_Del(v);
15037 c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	838 return -1;
12439 456869eaa7d5 Patch by Charles G Waldman to avoid a sneaky memory leak in Guido van Rossum <guido@python.org> parents: 11999 diff changeset	839 }
15037 c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	840 _Py_NewReference((PyObject *) sv);
21293 b810c30b4aa1 _PyTuple_Resize(): this dumped core on tuple(globals()) for me. Turns Guido van Rossum <guido@python.org> parents: 20277 diff changeset	841 /* Zero out items added by growing */
23834 8ae26d9be1b4 SF #561244 Micro optimizations Neal Norwitz <nnorwitz@gmail.com> parents: 23832 diff changeset	842 if (newsize > oldsize)
23952 3834cb0e7be6 Fix for SF bug 571885 Jeremy Hylton <jeremy@alum.mit.edu> parents: 23834 diff changeset	843 memset(&sv->ob_item[oldsize], 0,
3834cb0e7be6 Fix for SF bug 571885 Jeremy Hylton <jeremy@alum.mit.edu> parents: 23834 diff changeset	844 sizeof(sv->ob_item) (newsize - oldsize));
15037 c7d46eae95d8 Simplify _PyTuple_Resize by not using the tuple free list and dropping Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14584 diff changeset	845 pv = (PyObject ) sv;
19581 fd48a55ac364 Use new GC API. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 18933 diff changeset	846 _PyObject_GC_TRACK(sv);
1369 89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	847 return 0;
89e1e5d9ccbf * compile.[ch]: support for lambda() Guido van Rossum <guido@python.org> parents: 1352 diff changeset	848 }
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	849
45341 65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	850 int
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	851 PyTuple_ClearFreeList(void)
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	852 {
45341 65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	853 int freelist_size = 0;
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	854 #if PyTuple_MAXSAVESIZE > 0
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	855 int i;
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	856 for (i = 1; i < PyTuple_MAXSAVESIZE; i++) {
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	857 PyTupleObject p, q;
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	858 p = free_list[i];
45341 65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	859 freelist_size += numfree[i];
45191 920a7633ae08 Unified naming convention for free lists and their limits. All free lists Christian Heimes <christian@cheimes.de> parents: 44350 diff changeset	860 free_list[i] = NULL;
45341 65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	861 numfree[i] = 0;
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	862 while (p) {
80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	863 q = p;
80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	864 p = (PyTupleObject *)(p->ob_item[0]);
19581 fd48a55ac364 Use new GC API. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 18933 diff changeset	865 PyObject_GC_Del(q);
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	866 }
80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	867 }
80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	868 #endif
45341 65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	869 return freelist_size;
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	870 }
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	871
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	872 void
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	873 PyTuple_Fini(void)
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	874 {
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	875 #if PyTuple_MAXSAVESIZE > 0
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	876 /* empty tuples are used all over the place and applications may
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	877 * rely on the fact that an empty tuple is a singleton. */
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	878 Py_XDECREF(free_list[0]);
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	879 free_list[0] = NULL;
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	880
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	881 (void)PyTuple_ClearFreeList();
65ae68c7aca3 Implemented Martin's suggestion to clear the free lists during the garbage collection of the highest generation. Christian Heimes <christian@cheimes.de> parents: 45210 diff changeset	882 #endif
5936 80d24364b932 Added _Fini() routines to free up some memory Guido van Rossum <guido@python.org> parents: 5396 diff changeset	883 }
24683 567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	884
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	885 /********************* Tuple Iterator ************************/
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	886
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	887 typedef struct {
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	888 PyObject_HEAD
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	889 long it_index;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	890 PyTupleObject it_seq; / Set to NULL when iterator is exhausted */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	891 } tupleiterobject;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	892
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	893 static void
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	894 tupleiter_dealloc(tupleiterobject *it)
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	895 {
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	896 _PyObject_GC_UNTRACK(it);
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	897 Py_XDECREF(it->it_seq);
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	898 PyObject_GC_Del(it);
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	899 }
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	900
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	901 static int
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	902 tupleiter_traverse(tupleiterobject it, visitproc visit, void arg)
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	903 {
37756 7b2e436a4a21 Use Py_VISIT in all tp_traverse methods, instead of traversing manually or Thomas Wouters <thomas@python.org> parents: 37602 diff changeset	904 Py_VISIT(it->it_seq);
7b2e436a4a21 Use Py_VISIT in all tp_traverse methods, instead of traversing manually or Thomas Wouters <thomas@python.org> parents: 37602 diff changeset	905 return 0;
24683 567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	906 }
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	907
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	908 static PyObject *
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	909 tupleiter_next(tupleiterobject *it)
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	910 {
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	911 PyTupleObject *seq;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	912 PyObject *item;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	913
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	914 assert(it != NULL);
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	915 seq = it->it_seq;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	916 if (seq == NULL)
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	917 return NULL;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	918 assert(PyTuple_Check(seq));
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	919
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	920 if (it->it_index < PyTuple_GET_SIZE(seq)) {
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	921 item = PyTuple_GET_ITEM(seq, it->it_index);
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	922 ++it->it_index;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	923 Py_INCREF(item);
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	924 return item;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	925 }
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	926
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	927 Py_DECREF(seq);
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	928 it->it_seq = NULL;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	929 return NULL;
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	930 }
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	931
35636 e22334b1da67 Convert iterator __len__() methods to a private API. Raymond Hettinger <python@rcn.com> parents: 32318 diff changeset	932 static PyObject *
31686 823279ae43eb Make iterators length transparent where possible. Raymond Hettinger <python@rcn.com> parents: 31663 diff changeset	933 tupleiter_len(tupleiterobject *it)
823279ae43eb Make iterators length transparent where possible. Raymond Hettinger <python@rcn.com> parents: 31663 diff changeset	934 {
36519 d6d415df0df0 Use Py_ssize_t for counts and sizes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	935 Py_ssize_t len = 0;
31686 823279ae43eb Make iterators length transparent where possible. Raymond Hettinger <python@rcn.com> parents: 31663 diff changeset	936 if (it->it_seq)
35636 e22334b1da67 Convert iterator __len__() methods to a private API. Raymond Hettinger <python@rcn.com> parents: 32318 diff changeset	937 len = PyTuple_GET_SIZE(it->it_seq) - it->it_index;
36519 d6d415df0df0 Use Py_ssize_t for counts and sizes. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	938 return PyInt_FromSsize_t(len);
31686 823279ae43eb Make iterators length transparent where possible. Raymond Hettinger <python@rcn.com> parents: 31663 diff changeset	939 }
823279ae43eb Make iterators length transparent where possible. Raymond Hettinger <python@rcn.com> parents: 31663 diff changeset	940
36484 20f75d5e79e9 Renamed _length_cue() to __length_hint__(). See: Armin Rigo <arigo@tunes.org> parents: 35999 diff changeset	941 PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
35636 e22334b1da67 Convert iterator __len__() methods to a private API. Raymond Hettinger <python@rcn.com> parents: 32318 diff changeset	942
e22334b1da67 Convert iterator __len__() methods to a private API. Raymond Hettinger <python@rcn.com> parents: 32318 diff changeset	943 static PyMethodDef tupleiter_methods[] = {
36484 20f75d5e79e9 Renamed _length_cue() to __length_hint__(). See: Armin Rigo <arigo@tunes.org> parents: 35999 diff changeset	944 {"__length_hint__", (PyCFunction)tupleiter_len, METH_NOARGS, length_hint_doc},
35636 e22334b1da67 Convert iterator __len__() methods to a private API. Raymond Hettinger <python@rcn.com> parents: 32318 diff changeset	945 {NULL, NULL} /* sentinel */
31686 823279ae43eb Make iterators length transparent where possible. Raymond Hettinger <python@rcn.com> parents: 31663 diff changeset	946 };
823279ae43eb Make iterators length transparent where possible. Raymond Hettinger <python@rcn.com> parents: 31663 diff changeset	947
24683 567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	948 PyTypeObject PyTupleIter_Type = {
42333 6620a510e9a9 PEP 3123: Provide forward compatibility with Python 3.0, while keeping Martin v. Löwis <martin@v.loewis.de> parents: 40908 diff changeset	949 PyVarObject_HEAD_INIT(&PyType_Type, 0)
24683 567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	950 "tupleiterator", /* tp_name */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	951 sizeof(tupleiterobject), /* tp_basicsize */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	952 0, /* tp_itemsize */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	953 /* methods */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	954 (destructor)tupleiter_dealloc, /* tp_dealloc */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	955 0, /* tp_print */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	956 0, /* tp_getattr */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	957 0, /* tp_setattr */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	958 0, /* tp_compare */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	959 0, /* tp_repr */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	960 0, /* tp_as_number */
35636 e22334b1da67 Convert iterator __len__() methods to a private API. Raymond Hettinger <python@rcn.com> parents: 32318 diff changeset	961 0, /* tp_as_sequence */
24683 567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	962 0, /* tp_as_mapping */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	963 0, /* tp_hash */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	964 0, /* tp_call */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	965 0, /* tp_str */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	966 PyObject_GenericGetAttr, /* tp_getattro */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	967 0, /* tp_setattro */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	968 0, /* tp_as_buffer */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	969 Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_GC,/* tp_flags */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	970 0, /* tp_doc */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	971 (traverseproc)tupleiter_traverse, /* tp_traverse */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	972 0, /* tp_clear */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	973 0, /* tp_richcompare */
567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	974 0, /* tp_weaklistoffset */
28320 fd5ef7003469 Renamed PyObject_GenericGetIter to PyObject_SelfIter Raymond Hettinger <python@rcn.com> parents: 28308 diff changeset	975 PyObject_SelfIter, /* tp_iter */
24683 567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	976 (iternextfunc)tupleiter_next, /* tp_iternext */
35636 e22334b1da67 Convert iterator __len__() methods to a private API. Raymond Hettinger <python@rcn.com> parents: 32318 diff changeset	977 tupleiter_methods, /* tp_methods */
e22334b1da67 Convert iterator __len__() methods to a private API. Raymond Hettinger <python@rcn.com> parents: 32318 diff changeset	978 0,
24683 567704bfa595 Moved special case for tuples from iterobject.c to Raymond Hettinger <python@rcn.com> parents: 24280 diff changeset	979 };
37602 ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	980
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	981 static PyObject *
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	982 tuple_iter(PyObject *seq)
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	983 {
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	984 tupleiterobject *it;
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	985
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	986 if (!PyTuple_Check(seq)) {
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	987 PyErr_BadInternalCall();
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	988 return NULL;
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	989 }
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	990 it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type);
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	991 if (it == NULL)
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	992 return NULL;
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	993 it->it_index = 0;
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	994 Py_INCREF(seq);
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	995 it->it_seq = (PyTupleObject *)seq;
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	996 _PyObject_GC_TRACK(it);
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	997 return (PyObject *)it;
ca95ad5b0fbc Remove "static forward" declaration. Move constructors Martin v. Löwis <martin@v.loewis.de> parents: 37596 diff changeset	998 }

Mercurial > cpython-lru_cache-weakref

annotate Objects/tupleobject.c @ 49955:878d40468c4e legacy-trunk