Mercurial > cpython-lru_cache-weakref
annotate Objects/tupleobject.c @ 32527:0da660e05e69 legacy-trunk
"#if WITH_THREAD" is incorrect; must be #ifdef instead; WITH_THREAD
isn't always set to an integer value when it's defined.
| author | Tim Peters <tim.peters@gmail.com> |
|---|---|
| date | Wed, 07 Jul 2004 20:42:07 +0000 |
| parents | 418a0c6bdc7d |
| children | e43d5d2ca50a e22334b1da67 |
| rev | line source |
|---|---|
| 145 | 1 |
| 6 | 2 /* Tuple object implementation */ |
| 3 | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
4 #include "Python.h" |
| 6 | 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 */ |
|
1352
4d1a15fc4748
intobject.c: Save references to small integers, so that they can be
Sjoerd Mullender <sjoerd@acm.org>
parents:
1347
diff
changeset
|
7 #ifndef MAXSAVESIZE |
|
12439
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
8 #define MAXSAVESIZE 20 /* Largest tuple to save on free list */ |
|
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 |
|
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
10 #ifndef MAXSAVEDTUPLES |
|
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
11 #define MAXSAVEDTUPLES 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 |
|
4d1a15fc4748
intobject.c: Save references to small integers, so that they can be
Sjoerd Mullender <sjoerd@acm.org>
parents:
1347
diff
changeset
|
14 #if MAXSAVESIZE > 0 |
|
12439
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
15 /* Entries 1 up to 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 */ |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
18 static PyTupleObject *free_tuples[MAXSAVESIZE]; |
|
12439
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
19 static int num_free_tuples[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 * |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
27 PyTuple_New(register int size) |
| 6 | 28 { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
29 register PyTupleObject *op; |
| 31759 | 30 int i; |
| 6 | 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 | 33 return NULL; |
| 34 } | |
|
1352
4d1a15fc4748
intobject.c: Save references to small integers, so that they can be
Sjoerd Mullender <sjoerd@acm.org>
parents:
1347
diff
changeset
|
35 #if MAXSAVESIZE > 0 |
|
1380
a4aa83012af3
Fixed bugs in resizetuple and extended the interface.
Sjoerd Mullender <sjoerd@acm.org>
parents:
1369
diff
changeset
|
36 if (size == 0 && free_tuples[0]) { |
|
a4aa83012af3
Fixed bugs in resizetuple and extended the interface.
Sjoerd Mullender <sjoerd@acm.org>
parents:
1369
diff
changeset
|
37 op = free_tuples[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 } |
|
31663
3f693a772694
Eliminate an unnecessary test on a common code path.
Raymond Hettinger <python@rcn.com>
parents:
31633
diff
changeset
|
44 if (size < MAXSAVESIZE && (op = free_tuples[size]) != NULL) { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
45 free_tuples[size] = (PyTupleObject *) op->ob_item[0]; |
|
12439
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
46 num_free_tuples[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 |
|
12576
1c7c2dd1beb1
Vladimir Marangozov's long-awaited malloc restructuring.
Guido van Rossum <guido@python.org>
parents:
12516
diff
changeset
|
52 op->ob_size = size; |
|
9632
ac5345814ba0
When tracing references, reset the type and size of tuples allocated
Guido van Rossum <guido@python.org>
parents:
9484
diff
changeset
|
53 op->ob_type = &PyTuple_Type; |
|
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 { |
|
11127
9a20038f0b99
Appropriate overflow checks so that things like sys.maxint*(1,) can't
Guido van Rossum <guido@python.org>
parents:
9632
diff
changeset
|
60 int nbytes = size * sizeof(PyObject *); |
|
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 || |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
63 (nbytes += 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 <= 0) |
|
9a20038f0b99
Appropriate overflow checks so that things like sys.maxint*(1,) can't
Guido van Rossum <guido@python.org>
parents:
9632
diff
changeset
|
65 { |
|
9a20038f0b99
Appropriate overflow checks so that things like sys.maxint*(1,) can't
Guido van Rossum <guido@python.org>
parents:
9632
diff
changeset
|
66 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
|
67 } |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
68 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
|
69 if (op == NULL) |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
70 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
|
71 } |
| 31759 | 72 for (i=0; i < size; i++) |
| 73 op->ob_item[i] = NULL; | |
|
1352
4d1a15fc4748
intobject.c: Save references to small integers, so that they can be
Sjoerd Mullender <sjoerd@acm.org>
parents:
1347
diff
changeset
|
74 #if MAXSAVESIZE > 0 |
|
4d1a15fc4748
intobject.c: Save references to small integers, so that they can be
Sjoerd Mullender <sjoerd@acm.org>
parents:
1347
diff
changeset
|
75 if (size == 0) { |
|
1380
a4aa83012af3
Fixed bugs in resizetuple and extended the interface.
Sjoerd Mullender <sjoerd@acm.org>
parents:
1369
diff
changeset
|
76 free_tuples[0] = 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
|
77 ++num_free_tuples[0]; |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
78 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
|
79 } |
|
4d1a15fc4748
intobject.c: Save references to small integers, so that they can be
Sjoerd Mullender <sjoerd@acm.org>
parents:
1347
diff
changeset
|
80 #endif |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
81 _PyObject_GC_TRACK(op); |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
82 return (PyObject *) op; |
| 6 | 83 } |
| 84 | |
| 85 int | |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
86 PyTuple_Size(register PyObject *op) |
| 6 | 87 { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
88 if (!PyTuple_Check(op)) { |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
89 PyErr_BadInternalCall(); |
| 6 | 90 return -1; |
| 91 } | |
| 92 else | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
93 return ((PyTupleObject *)op)->ob_size; |
| 6 | 94 } |
| 95 | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
96 PyObject * |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
97 PyTuple_GetItem(register PyObject *op, register int i) |
| 6 | 98 { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
99 if (!PyTuple_Check(op)) { |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
100 PyErr_BadInternalCall(); |
| 6 | 101 return NULL; |
| 102 } | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
103 if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) { |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
104 PyErr_SetString(PyExc_IndexError, "tuple index out of range"); |
| 6 | 105 return NULL; |
| 106 } | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
107 return ((PyTupleObject *)op) -> ob_item[i]; |
| 6 | 108 } |
| 109 | |
| 110 int | |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
111 PyTuple_SetItem(register PyObject *op, register int i, PyObject *newitem) |
| 6 | 112 { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
113 register PyObject *olditem; |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
114 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
|
115 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
|
116 Py_XDECREF(newitem); |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
117 PyErr_BadInternalCall(); |
| 27 | 118 return -1; |
| 6 | 119 } |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
120 if (i < 0 || i >= ((PyTupleObject *)op) -> ob_size) { |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
121 Py_XDECREF(newitem); |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
122 PyErr_SetString(PyExc_IndexError, |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
123 "tuple assignment index out of range"); |
| 27 | 124 return -1; |
| 6 | 125 } |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
126 p = ((PyTupleObject *)op) -> ob_item + i; |
|
2504
425835b88099
a few peephole optimizations
Guido van Rossum <guido@python.org>
parents:
2059
diff
changeset
|
127 olditem = *p; |
|
425835b88099
a few peephole optimizations
Guido van Rossum <guido@python.org>
parents:
2059
diff
changeset
|
128 *p = newitem; |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
129 Py_XDECREF(olditem); |
| 6 | 130 return 0; |
| 131 } | |
| 132 | |
|
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
|
133 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
|
134 PyTuple_Pack(int 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
|
135 { |
|
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 int 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
|
137 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
|
138 PyObject *result; |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
139 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
|
140 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
|
141 |
|
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 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
|
143 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
|
144 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
|
145 return NULL; |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
146 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
|
147 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
|
148 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
|
149 Py_INCREF(o); |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
150 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
|
151 } |
|
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 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
|
153 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
|
154 } |
|
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 |
| 6 | 157 /* Methods */ |
| 158 | |
| 159 static void | |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
160 tupledealloc(register PyTupleObject *op) |
| 6 | 161 { |
| 162 register int i; | |
|
12439
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
163 register int len = op->ob_size; |
| 22626 | 164 PyObject_GC_UnTrack(op); |
|
11999
c94247b5c355
Christian Tismer's "trashcan" patch:
Guido van Rossum <guido@python.org>
parents:
11673
diff
changeset
|
165 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
|
166 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
|
167 i = len; |
| 31759 | 168 while (--i >= 0) |
| 169 Py_XDECREF(op->ob_item[i]); | |
|
1352
4d1a15fc4748
intobject.c: Save references to small integers, so that they can be
Sjoerd Mullender <sjoerd@acm.org>
parents:
1347
diff
changeset
|
170 #if MAXSAVESIZE > 0 |
|
19612
c396afef1aa9
More stuff discovered while writing the simplest of testcases:
Guido van Rossum <guido@python.org>
parents:
19592
diff
changeset
|
171 if (len < MAXSAVESIZE && |
|
c396afef1aa9
More stuff discovered while writing the simplest of testcases:
Guido van Rossum <guido@python.org>
parents:
19592
diff
changeset
|
172 num_free_tuples[len] < MAXSAVEDTUPLES && |
|
c396afef1aa9
More stuff discovered while writing the simplest of testcases:
Guido van Rossum <guido@python.org>
parents:
19592
diff
changeset
|
173 op->ob_type == &PyTuple_Type) |
|
c396afef1aa9
More stuff discovered while writing the simplest of testcases:
Guido van Rossum <guido@python.org>
parents:
19592
diff
changeset
|
174 { |
|
12439
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
175 op->ob_item[0] = (PyObject *) free_tuples[len]; |
|
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
176 num_free_tuples[len]++; |
|
456869eaa7d5
Patch by Charles G Waldman to avoid a sneaky memory leak in
Guido van Rossum <guido@python.org>
parents:
11999
diff
changeset
|
177 free_tuples[len] = op; |
|
11999
c94247b5c355
Christian Tismer's "trashcan" patch:
Guido van Rossum <guido@python.org>
parents:
11673
diff
changeset
|
178 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
|
179 } |
|
1352
4d1a15fc4748
intobject.c: Save references to small integers, so that they can be
Sjoerd Mullender <sjoerd@acm.org>
parents:
1347
diff
changeset
|
180 #endif |
|
8559
92267838feb9
Slight rearrangement of some code to make it faster, by Vladimir
Guido van Rossum <guido@python.org>
parents:
6083
diff
changeset
|
181 } |
|
20277
2983b54256c7
Enable GC for new-style instances. This touches lots of files, since
Guido van Rossum <guido@python.org>
parents:
19872
diff
changeset
|
182 op->ob_type->tp_free((PyObject *)op); |
|
11999
c94247b5c355
Christian Tismer's "trashcan" patch:
Guido van Rossum <guido@python.org>
parents:
11673
diff
changeset
|
183 done: |
|
c94247b5c355
Christian Tismer's "trashcan" patch:
Guido van Rossum <guido@python.org>
parents:
11673
diff
changeset
|
184 Py_TRASHCAN_SAFE_END(op) |
| 6 | 185 } |
| 186 | |
|
288
9b43a983124c
printobject now returns an error code
Guido van Rossum <guido@python.org>
parents:
258
diff
changeset
|
187 static int |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
188 tupleprint(PyTupleObject *op, FILE *fp, int flags) |
| 6 | 189 { |
| 190 int i; | |
| 191 fprintf(fp, "("); | |
|
288
9b43a983124c
printobject now returns an error code
Guido van Rossum <guido@python.org>
parents:
258
diff
changeset
|
192 for (i = 0; i < op->ob_size; i++) { |
|
9b43a983124c
printobject now returns an error code
Guido van Rossum <guido@python.org>
parents:
258
diff
changeset
|
193 if (i > 0) |
| 6 | 194 fprintf(fp, ", "); |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
195 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
|
196 return -1; |
| 6 | 197 } |
| 198 if (op->ob_size == 1) | |
| 199 fprintf(fp, ","); | |
| 200 fprintf(fp, ")"); | |
|
288
9b43a983124c
printobject now returns an error code
Guido van Rossum <guido@python.org>
parents:
258
diff
changeset
|
201 return 0; |
| 6 | 202 } |
| 203 | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
204 static PyObject * |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
205 tuplerepr(PyTupleObject *v) |
| 6 | 206 { |
|
18129
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
207 int i, n; |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
208 PyObject *s, *temp; |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
209 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
|
210 |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
211 n = v->ob_size; |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
212 if (n == 0) |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
213 return PyString_FromString("()"); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
214 |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
215 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
|
216 if (pieces == NULL) |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
217 return NULL; |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
218 |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
219 /* 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
|
220 for (i = 0; i < n; ++i) { |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
221 s = PyObject_Repr(v->ob_item[i]); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
222 if (s == NULL) |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
223 goto Done; |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
224 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
|
225 } |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
226 |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
227 /* 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
|
228 assert(n > 0); |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
229 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
|
230 if (s == NULL) |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
231 goto Done; |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
232 temp = PyTuple_GET_ITEM(pieces, 0); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
233 PyString_ConcatAndDel(&s, temp); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
234 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
|
235 if (s == NULL) |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
236 goto Done; |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
237 |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
238 s = PyString_FromString(n == 1 ? ",)" : ")"); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
239 if (s == NULL) |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
240 goto Done; |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
241 temp = PyTuple_GET_ITEM(pieces, n-1); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
242 PyString_ConcatAndDel(&temp, s); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
243 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
|
244 if (temp == NULL) |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
245 goto Done; |
|
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 /* Paste them all together with ", " between. */ |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
248 s = PyString_FromString(", "); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
249 if (s == NULL) |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
250 goto Done; |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
251 result = _PyString_Join(s, pieces); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
252 Py_DECREF(s); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
253 |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
254 Done: |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
255 Py_DECREF(pieces); |
|
9d533ae574d2
SF bug 433228: repr(list) woes when len(list) big.
Tim Peters <tim.peters@gmail.com>
parents:
17979
diff
changeset
|
256 return result; |
| 6 | 257 } |
| 258 | |
|
32242
0bdb49a5a8fa
Replaced arbitrary addend in tuple_hash with one that is known to generate
Raymond Hettinger <python@rcn.com>
parents:
32171
diff
changeset
|
259 /* 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
|
260 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
|
261 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
|
262 |
|
0bdb49a5a8fa
Replaced arbitrary addend in tuple_hash with one that is known to generate
Raymond Hettinger <python@rcn.com>
parents:
32171
diff
changeset
|
263 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
|
264 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
|
265 */ |
|
0bdb49a5a8fa
Replaced arbitrary addend in tuple_hash with one that is known to generate
Raymond Hettinger <python@rcn.com>
parents:
32171
diff
changeset
|
266 |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
267 static long |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
268 tuplehash(PyTupleObject *v) |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
269 { |
|
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
270 register long x, y; |
|
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
271 register int len = v->ob_size; |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
272 register PyObject **p; |
|
32171
97b908a9971a
SF bug #942952: Weakness in tuple hash
Raymond Hettinger <python@rcn.com>
parents:
31759
diff
changeset
|
273 long mult = 1000003L; |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
274 x = 0x345678L; |
|
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
275 p = v->ob_item; |
|
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
276 while (--len >= 0) { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
277 y = PyObject_Hash(*p++); |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
278 if (y == -1) |
|
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
279 return -1; |
|
32171
97b908a9971a
SF bug #942952: Weakness in tuple hash
Raymond Hettinger <python@rcn.com>
parents:
31759
diff
changeset
|
280 x = (x ^ y) * mult; |
|
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 mult += 82520L + len + len; |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
282 } |
|
32318
418a0c6bdc7d
Add a final permutation step to the tuple hash function.
Raymond Hettinger <python@rcn.com>
parents:
32242
diff
changeset
|
283 x += 97531L; |
|
1257
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
284 if (x == -1) |
|
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
285 x = -2; |
|
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
286 return x; |
|
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
287 } |
|
1cabc2b6c970
* Changed all copyright messages to include 1993.
Guido van Rossum <guido@python.org>
parents:
795
diff
changeset
|
288 |
| 6 | 289 static int |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
290 tuplelength(PyTupleObject *a) |
| 6 | 291 { |
| 292 return a->ob_size; | |
| 293 } | |
| 294 | |
|
12516
e6e914d5b207
add list_contains and tuplecontains: efficient implementations of tp_contains
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12439
diff
changeset
|
295 static int |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
296 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
|
297 { |
|
e6e914d5b207
add list_contains and tuplecontains: efficient implementations of tp_contains
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12439
diff
changeset
|
298 int i, cmp; |
|
e6e914d5b207
add list_contains and tuplecontains: efficient implementations of tp_contains
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12439
diff
changeset
|
299 |
|
25125
172845c09afe
Micro-optimization for list_contains. Factored double if test
Raymond Hettinger <python@rcn.com>
parents:
24898
diff
changeset
|
300 for (i = 0, cmp = 0 ; cmp == 0 && i < a->ob_size; ++i) |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
301 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
|
302 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
|
303 return cmp; |
|
12516
e6e914d5b207
add list_contains and tuplecontains: efficient implementations of tp_contains
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12439
diff
changeset
|
304 } |
|
e6e914d5b207
add list_contains and tuplecontains: efficient implementations of tp_contains
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12439
diff
changeset
|
305 |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
306 static PyObject * |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
307 tupleitem(register PyTupleObject *a, register int i) |
| 6 | 308 { |
| 309 if (i < 0 || i >= a->ob_size) { | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
310 PyErr_SetString(PyExc_IndexError, "tuple index out of range"); |
| 6 | 311 return NULL; |
| 312 } | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
313 Py_INCREF(a->ob_item[i]); |
| 6 | 314 return a->ob_item[i]; |
| 315 } | |
| 316 | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
317 static PyObject * |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
318 tupleslice(register PyTupleObject *a, register int ilow, register int ihigh) |
| 6 | 319 { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
320 register PyTupleObject *np; |
|
31623
d34e7eaf4cd6
Optimize tuple_slice() and make further improvements to list_slice()
Raymond Hettinger <python@rcn.com>
parents:
30682
diff
changeset
|
321 PyObject **src, **dest; |
| 6 | 322 register int i; |
|
31623
d34e7eaf4cd6
Optimize tuple_slice() and make further improvements to list_slice()
Raymond Hettinger <python@rcn.com>
parents:
30682
diff
changeset
|
323 int len; |
| 6 | 324 if (ilow < 0) |
| 325 ilow = 0; | |
| 326 if (ihigh > a->ob_size) | |
| 327 ihigh = a->ob_size; | |
| 328 if (ihigh < ilow) | |
| 329 ihigh = ilow; | |
|
19872
51363348dcfa
The endless 460020 bug.
Tim Peters <tim.peters@gmail.com>
parents:
19657
diff
changeset
|
330 if (ilow == 0 && ihigh == a->ob_size && PyTuple_CheckExact(a)) { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
331 Py_INCREF(a); |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
332 return (PyObject *)a; |
| 6 | 333 } |
|
31623
d34e7eaf4cd6
Optimize tuple_slice() and make further improvements to list_slice()
Raymond Hettinger <python@rcn.com>
parents:
30682
diff
changeset
|
334 len = ihigh - ilow; |
|
d34e7eaf4cd6
Optimize tuple_slice() and make further improvements to list_slice()
Raymond Hettinger <python@rcn.com>
parents:
30682
diff
changeset
|
335 np = (PyTupleObject *)PyTuple_New(len); |
| 6 | 336 if (np == NULL) |
| 337 return NULL; | |
|
31623
d34e7eaf4cd6
Optimize tuple_slice() and make further improvements to list_slice()
Raymond Hettinger <python@rcn.com>
parents:
30682
diff
changeset
|
338 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
|
339 dest = np->ob_item; |
|
d34e7eaf4cd6
Optimize tuple_slice() and make further improvements to list_slice()
Raymond Hettinger <python@rcn.com>
parents:
30682
diff
changeset
|
340 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
|
341 PyObject *v = src[i]; |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
342 Py_INCREF(v); |
|
31623
d34e7eaf4cd6
Optimize tuple_slice() and make further improvements to list_slice()
Raymond Hettinger <python@rcn.com>
parents:
30682
diff
changeset
|
343 dest[i] = v; |
| 6 | 344 } |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
345 return (PyObject *)np; |
| 6 | 346 } |
| 347 | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
348 PyObject * |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
349 PyTuple_GetSlice(PyObject *op, int i, int j) |
|
599
a347933a6d92
New function gettupleslice(v, i, j).
Guido van Rossum <guido@python.org>
parents:
288
diff
changeset
|
350 { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
351 if (op == NULL || !PyTuple_Check(op)) { |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
352 PyErr_BadInternalCall(); |
|
599
a347933a6d92
New function gettupleslice(v, i, j).
Guido van Rossum <guido@python.org>
parents:
288
diff
changeset
|
353 return NULL; |
|
a347933a6d92
New function gettupleslice(v, i, j).
Guido van Rossum <guido@python.org>
parents:
288
diff
changeset
|
354 } |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
355 return tupleslice((PyTupleObject *)op, i, j); |
|
599
a347933a6d92
New function gettupleslice(v, i, j).
Guido van Rossum <guido@python.org>
parents:
288
diff
changeset
|
356 } |
|
a347933a6d92
New function gettupleslice(v, i, j).
Guido van Rossum <guido@python.org>
parents:
288
diff
changeset
|
357 |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
358 static PyObject * |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
359 tupleconcat(register PyTupleObject *a, register PyObject *bb) |
| 6 | 360 { |
| 361 register int size; | |
| 362 register int i; | |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
363 PyObject **src, **dest; |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
364 PyTupleObject *np; |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
365 if (!PyTuple_Check(bb)) { |
|
12816
4272b368bf69
Michael Hudson <mwh21@cam.ac.uk>:
Fred Drake <fdrake@acm.org>
parents:
12576
diff
changeset
|
366 PyErr_Format(PyExc_TypeError, |
|
12929
2eef636ba1b6
Michael Hudson <mwh21@cam.ac.uk>:
Marc-André Lemburg <mal@egenix.com>
parents:
12925
diff
changeset
|
367 "can only concatenate tuple (not \"%.200s\") to tuple", |
|
12816
4272b368bf69
Michael Hudson <mwh21@cam.ac.uk>:
Fred Drake <fdrake@acm.org>
parents:
12576
diff
changeset
|
368 bb->ob_type->tp_name); |
| 6 | 369 return NULL; |
| 370 } | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
371 #define b ((PyTupleObject *)bb) |
| 6 | 372 size = a->ob_size + b->ob_size; |
|
25740
70f9026a2b16
Add checks for size overflow on list*n, list+list, tuple+tuple.
Guido van Rossum <guido@python.org>
parents:
25128
diff
changeset
|
373 if (size < 0) |
|
70f9026a2b16
Add checks for size overflow on list*n, list+list, tuple+tuple.
Guido van Rossum <guido@python.org>
parents:
25128
diff
changeset
|
374 return PyErr_NoMemory(); |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
375 np = (PyTupleObject *) PyTuple_New(size); |
| 6 | 376 if (np == NULL) { |
|
288
9b43a983124c
printobject now returns an error code
Guido van Rossum <guido@python.org>
parents:
258
diff
changeset
|
377 return NULL; |
| 6 | 378 } |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
379 src = a->ob_item; |
|
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
380 dest = np->ob_item; |
| 6 | 381 for (i = 0; i < a->ob_size; i++) { |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
382 PyObject *v = src[i]; |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
383 Py_INCREF(v); |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
384 dest[i] = v; |
| 6 | 385 } |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
386 src = b->ob_item; |
|
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
387 dest = np->ob_item + a->ob_size; |
| 6 | 388 for (i = 0; i < b->ob_size; i++) { |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
389 PyObject *v = src[i]; |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
390 Py_INCREF(v); |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
391 dest[i] = v; |
| 6 | 392 } |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
393 return (PyObject *)np; |
| 6 | 394 #undef b |
| 395 } | |
| 396 | |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
397 static PyObject * |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
398 tuplerepeat(PyTupleObject *a, int n) |
|
258
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
399 { |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
400 int i, j; |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
401 int size; |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
402 PyTupleObject *np; |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
403 PyObject **p, **items; |
|
258
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
404 if (n < 0) |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
405 n = 0; |
|
11127
9a20038f0b99
Appropriate overflow checks so that things like sys.maxint*(1,) can't
Guido van Rossum <guido@python.org>
parents:
9632
diff
changeset
|
406 if (a->ob_size == 0 || n == 1) { |
|
19872
51363348dcfa
The endless 460020 bug.
Tim Peters <tim.peters@gmail.com>
parents:
19657
diff
changeset
|
407 if (PyTuple_CheckExact(a)) { |
|
51363348dcfa
The endless 460020 bug.
Tim Peters <tim.peters@gmail.com>
parents:
19657
diff
changeset
|
408 /* Since tuples are immutable, we can return a shared |
|
51363348dcfa
The endless 460020 bug.
Tim Peters <tim.peters@gmail.com>
parents:
19657
diff
changeset
|
409 copy in this case */ |
|
51363348dcfa
The endless 460020 bug.
Tim Peters <tim.peters@gmail.com>
parents:
19657
diff
changeset
|
410 Py_INCREF(a); |
|
51363348dcfa
The endless 460020 bug.
Tim Peters <tim.peters@gmail.com>
parents:
19657
diff
changeset
|
411 return (PyObject *)a; |
|
51363348dcfa
The endless 460020 bug.
Tim Peters <tim.peters@gmail.com>
parents:
19657
diff
changeset
|
412 } |
|
51363348dcfa
The endless 460020 bug.
Tim Peters <tim.peters@gmail.com>
parents:
19657
diff
changeset
|
413 if (a->ob_size == 0) |
|
51363348dcfa
The endless 460020 bug.
Tim Peters <tim.peters@gmail.com>
parents:
19657
diff
changeset
|
414 return PyTuple_New(0); |
|
258
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
415 } |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
416 size = a->ob_size * n; |
|
11128
a4b7242a4b74
Mark Favas was quick to note that the last checkin divides by zero
Guido van Rossum <guido@python.org>
parents:
11127
diff
changeset
|
417 if (size/a->ob_size != 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
|
418 return PyErr_NoMemory(); |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
419 np = (PyTupleObject *) PyTuple_New(size); |
|
258
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
420 if (np == NULL) |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
421 return NULL; |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
422 p = np->ob_item; |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
423 items = a->ob_item; |
|
258
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
424 for (i = 0; i < n; i++) { |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
425 for (j = 0; j < a->ob_size; j++) { |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
426 *p = items[j]; |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
427 Py_INCREF(*p); |
|
258
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
428 p++; |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
429 } |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
430 } |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
431 return (PyObject *) np; |
|
258
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
432 } |
|
3b93bcea10f6
Finally implement tuple*number. From now on all sequence types
Guido van Rossum <guido@python.org>
parents:
145
diff
changeset
|
433 |
|
12990
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
434 static int |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
435 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
|
436 { |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
437 int i, err; |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
438 PyObject *x; |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
439 |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
440 for (i = o->ob_size; --i >= 0; ) { |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
441 x = o->ob_item[i]; |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
442 if (x != NULL) { |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
443 err = visit(x, arg); |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
444 if (err) |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
445 return err; |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
446 } |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
447 } |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
448 return 0; |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
449 } |
|
e615596c5c47
Round 1 of Neil Schemenauer's GC patches:
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
12929
diff
changeset
|
450 |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
451 static PyObject * |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
452 tuplerichcompare(PyObject *v, PyObject *w, int op) |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
453 { |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
454 PyTupleObject *vt, *wt; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
455 int i; |
|
17841
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
456 int vlen, wlen; |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
457 |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
458 if (!PyTuple_Check(v) || !PyTuple_Check(w)) { |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
459 Py_INCREF(Py_NotImplemented); |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
460 return Py_NotImplemented; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
461 } |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
462 |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
463 vt = (PyTupleObject *)v; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
464 wt = (PyTupleObject *)w; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
465 |
|
17841
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
466 vlen = vt->ob_size; |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
467 wlen = wt->ob_size; |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
468 |
|
17841
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
469 /* 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
|
470 * 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
|
471 * 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
|
472 * 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
|
473 * have cost without benefit. |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
474 */ |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
475 |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
476 /* 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
|
477 * 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
|
478 * vlen and wlen across the comparison calls. |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
479 */ |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
480 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
|
481 int k = PyObject_RichCompareBool(vt->ob_item[i], |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
482 wt->ob_item[i], Py_EQ); |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
483 if (k < 0) |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
484 return NULL; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
485 if (!k) |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
486 break; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
487 } |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
488 |
|
17841
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
489 if (i >= vlen || i >= wlen) { |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
490 /* No more items to compare -- compare sizes */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
491 int cmp; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
492 PyObject *res; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
493 switch (op) { |
|
17841
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
494 case Py_LT: cmp = vlen < wlen; break; |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
495 case Py_LE: cmp = vlen <= wlen; break; |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
496 case Py_EQ: cmp = vlen == wlen; break; |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
497 case Py_NE: cmp = vlen != wlen; break; |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
498 case Py_GT: cmp = vlen > wlen; break; |
|
2b5a9bff1b11
Speed tuple comparisons in two ways:
Tim Peters <tim.peters@gmail.com>
parents:
15973
diff
changeset
|
499 case Py_GE: cmp = vlen >= wlen; break; |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
500 default: return NULL; /* cannot happen */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
501 } |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
502 if (cmp) |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
503 res = Py_True; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
504 else |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
505 res = Py_False; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
506 Py_INCREF(res); |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
507 return res; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
508 } |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
509 |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
510 /* 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
|
511 if (op == Py_EQ) { |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
512 Py_INCREF(Py_False); |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
513 return Py_False; |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
514 } |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
515 if (op == Py_NE) { |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
516 Py_INCREF(Py_True); |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
517 return Py_True; |
|
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 |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
520 /* 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
|
521 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
|
522 } |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
523 |
|
24280
1598a1e473e2
staticforward bites the dust.
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
24184
diff
changeset
|
524 static PyObject * |
|
19592
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
525 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
|
526 |
|
18933
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
527 static PyObject * |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
528 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
|
529 { |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
530 PyObject *arg = NULL; |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
531 static char *kwlist[] = {"sequence", 0}; |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
532 |
|
19592
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
533 if (type != &PyTuple_Type) |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
534 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
|
535 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
|
536 return NULL; |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
537 |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
538 if (arg == NULL) |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
539 return PyTuple_New(0); |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
540 else |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
541 return PySequence_Tuple(arg); |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
542 } |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
543 |
|
19592
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
544 static PyObject * |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
545 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
|
546 { |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
547 PyObject *tmp, *new, *item; |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
548 int i, n; |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
549 |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
550 assert(PyType_IsSubtype(type, &PyTuple_Type)); |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
551 tmp = tuple_new(&PyTuple_Type, args, kwds); |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
552 if (tmp == NULL) |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
553 return NULL; |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
554 assert(PyTuple_Check(tmp)); |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
555 new = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp)); |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
556 if (new == NULL) |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
557 return NULL; |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
558 for (i = 0; i < n; i++) { |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
559 item = PyTuple_GET_ITEM(tmp, i); |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
560 Py_INCREF(item); |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
561 PyTuple_SET_ITEM(new, i, item); |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
562 } |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
563 Py_DECREF(tmp); |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
564 return new; |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
565 } |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
566 |
|
23832
ed1ba37a46b7
Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents:
23778
diff
changeset
|
567 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
|
568 "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
|
569 "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
|
570 "\n" |
|
23832
ed1ba37a46b7
Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents:
23778
diff
changeset
|
571 "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
|
572 |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
573 static PySequenceMethods tuple_as_sequence = { |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
574 (inquiry)tuplelength, /* sq_length */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
575 (binaryfunc)tupleconcat, /* sq_concat */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
576 (intargfunc)tuplerepeat, /* sq_repeat */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
577 (intargfunc)tupleitem, /* sq_item */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
578 (intintargfunc)tupleslice, /* sq_slice */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
579 0, /* sq_ass_item */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
580 0, /* sq_ass_slice */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
581 (objobjproc)tuplecontains, /* sq_contains */ |
| 6 | 582 }; |
| 583 | |
|
23778
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
584 static PyObject* |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
585 tuplesubscript(PyTupleObject* self, PyObject* item) |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
586 { |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
587 if (PyInt_Check(item)) { |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
588 long i = PyInt_AS_LONG(item); |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
589 if (i < 0) |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
590 i += PyTuple_GET_SIZE(self); |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
591 return tupleitem(self, i); |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
592 } |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
593 else if (PyLong_Check(item)) { |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
594 long i = PyLong_AsLong(item); |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
595 if (i == -1 && PyErr_Occurred()) |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
596 return NULL; |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
597 if (i < 0) |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
598 i += PyTuple_GET_SIZE(self); |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
599 return tupleitem(self, i); |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
600 } |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
601 else if (PySlice_Check(item)) { |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
602 int start, stop, step, slicelength, cur, i; |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
603 PyObject* result; |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
604 PyObject* it; |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
605 PyObject **src, **dest; |
|
23778
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
606 |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
607 if (PySlice_GetIndicesEx((PySliceObject*)item, |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
608 PyTuple_GET_SIZE(self), |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
609 &start, &stop, &step, &slicelength) < 0) { |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
610 return NULL; |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
611 } |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
612 |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
613 if (slicelength <= 0) { |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
614 return PyTuple_New(0); |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
615 } |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
616 else { |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
617 result = PyTuple_New(slicelength); |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
618 |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
619 src = self->ob_item; |
|
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
620 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
|
621 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
|
622 cur += step, i++) { |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
623 it = src[cur]; |
|
23778
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
624 Py_INCREF(it); |
|
31633
5bd455638c7a
Optimize inner loops for subscript, repeat, and concat.
Raymond Hettinger <python@rcn.com>
parents:
31623
diff
changeset
|
625 dest[i] = it; |
|
23778
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
626 } |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
627 |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
628 return result; |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
629 } |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
630 } |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
631 else { |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
632 PyErr_SetString(PyExc_TypeError, |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
633 "tuple indices must be integers"); |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
634 return NULL; |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
635 } |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
636 } |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
637 |
|
27521
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
638 static PyObject * |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
639 tuple_getnewargs(PyTupleObject *v) |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
640 { |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
641 return Py_BuildValue("(N)", tupleslice(v, 0, v->ob_size)); |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
642 |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
643 } |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
644 |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
645 static PyMethodDef tuple_methods[] = { |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
646 {"__getnewargs__", (PyCFunction)tuple_getnewargs, METH_NOARGS}, |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
647 {NULL, NULL} /* sentinel */ |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
648 }; |
|
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
649 |
|
23778
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
650 static PyMappingMethods tuple_as_mapping = { |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
651 (inquiry)tuplelength, |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
652 (binaryfunc)tuplesubscript, |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
653 0 |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
654 }; |
|
245224d1b8c9
This is my nearly two year old patch
Michael W. Hudson <mwh@python.net>
parents:
22979
diff
changeset
|
655 |
|
24683
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
656 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
|
657 |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
658 PyTypeObject PyTuple_Type = { |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
659 PyObject_HEAD_INIT(&PyType_Type) |
| 6 | 660 0, |
| 661 "tuple", | |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
662 sizeof(PyTupleObject) - sizeof(PyObject *), |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
663 sizeof(PyObject *), |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
664 (destructor)tupledealloc, /* tp_dealloc */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
665 (printfunc)tupleprint, /* tp_print */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
666 0, /* tp_getattr */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
667 0, /* tp_setattr */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
668 0, /* tp_compare */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
669 (reprfunc)tuplerepr, /* tp_repr */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
670 0, /* tp_as_number */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
671 &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
|
672 &tuple_as_mapping, /* tp_as_mapping */ |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
673 (hashfunc)tuplehash, /* tp_hash */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
674 0, /* tp_call */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
675 0, /* tp_str */ |
|
18933
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
676 PyObject_GenericGetAttr, /* tp_getattro */ |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
677 0, /* tp_setattro */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
678 0, /* tp_as_buffer */ |
|
19592
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
679 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | |
|
85765e61deb0
Make str and tuple types subclassable.
Guido van Rossum <guido@python.org>
parents:
19581
diff
changeset
|
680 Py_TPFLAGS_BASETYPE, /* tp_flags */ |
|
18933
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
681 tuple_doc, /* tp_doc */ |
|
15973
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
682 (traverseproc)tupletraverse, /* tp_traverse */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
683 0, /* tp_clear */ |
|
72139263f8a7
Same treatment as listobject.c:
Guido van Rossum <guido@python.org>
parents:
15037
diff
changeset
|
684 tuplerichcompare, /* tp_richcompare */ |
|
18933
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
685 0, /* tp_weaklistoffset */ |
|
24683
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
686 tuple_iter, /* tp_iter */ |
|
18933
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
687 0, /* tp_iternext */ |
|
27521
17bfd5dbc0f1
Implement appropriate __getnewargs__ for all immutable subclassable builtin
Guido van Rossum <guido@python.org>
parents:
25740
diff
changeset
|
688 tuple_methods, /* tp_methods */ |
|
18933
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
689 0, /* tp_members */ |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
690 0, /* tp_getset */ |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
691 0, /* tp_base */ |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
692 0, /* tp_dict */ |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
693 0, /* tp_descr_get */ |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
694 0, /* tp_descr_set */ |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
695 0, /* tp_dictoffset */ |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
696 0, /* tp_init */ |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
697 0, /* tp_alloc */ |
|
09df3254b49d
Merge of descr-branch back into trunk.
Tim Peters <tim.peters@gmail.com>
parents:
18129
diff
changeset
|
698 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
|
699 PyObject_GC_Del, /* tp_free */ |
| 6 | 700 }; |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
701 |
|
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
702 /* 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
|
703 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
|
704 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
|
705 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
|
706 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
|
707 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
|
708 |
|
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
709 int |
|
17976
d579a5d8b3fe
Cruft cleanup: Removed the unused last_is_sticky argument from the internal
Tim Peters <tim.peters@gmail.com>
parents:
17975
diff
changeset
|
710 _PyTuple_Resize(PyObject **pv, int newsize) |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
711 { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
712 register PyTupleObject *v; |
|
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
713 register PyTupleObject *sv; |
|
1380
a4aa83012af3
Fixed bugs in resizetuple and extended the interface.
Sjoerd Mullender <sjoerd@acm.org>
parents:
1369
diff
changeset
|
714 int i; |
|
21293
b810c30b4aa1
_PyTuple_Resize(): this dumped core on tuple(globals()) for me. Turns
Guido van Rossum <guido@python.org>
parents:
20277
diff
changeset
|
715 int oldsize; |
|
1380
a4aa83012af3
Fixed bugs in resizetuple and extended the interface.
Sjoerd Mullender <sjoerd@acm.org>
parents:
1369
diff
changeset
|
716 |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
717 v = (PyTupleObject *) *pv; |
|
19612
c396afef1aa9
More stuff discovered while writing the simplest of testcases:
Guido van Rossum <guido@python.org>
parents:
19592
diff
changeset
|
718 if (v == NULL || v->ob_type != &PyTuple_Type || |
|
17975
527d0ffdf099
_PyTuple_Resize: take into account the empty tuple. There can be only one.
Thomas Wouters <thomas@python.org>
parents:
17841
diff
changeset
|
719 (v->ob_size != 0 && v->ob_refcnt != 1)) { |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
720 *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
|
721 Py_XDECREF(v); |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
722 PyErr_BadInternalCall(); |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
723 return -1; |
|
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
724 } |
|
21293
b810c30b4aa1
_PyTuple_Resize(): this dumped core on tuple(globals()) for me. Turns
Guido van Rossum <guido@python.org>
parents:
20277
diff
changeset
|
725 oldsize = v->ob_size; |
|
b810c30b4aa1
_PyTuple_Resize(): this dumped core on tuple(globals()) for me. Turns
Guido van Rossum <guido@python.org>
parents:
20277
diff
changeset
|
726 if (oldsize == newsize) |
|
1380
a4aa83012af3
Fixed bugs in resizetuple and extended the interface.
Sjoerd Mullender <sjoerd@acm.org>
parents:
1369
diff
changeset
|
727 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
|
728 |
|
21293
b810c30b4aa1
_PyTuple_Resize(): this dumped core on tuple(globals()) for me. Turns
Guido van Rossum <guido@python.org>
parents:
20277
diff
changeset
|
729 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
|
730 /* 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
|
731 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
|
732 (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
|
733 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
|
734 *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
|
735 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
|
736 } |
|
527d0ffdf099
_PyTuple_Resize: take into account the empty tuple. There can be only one.
Thomas Wouters <thomas@python.org>
parents:
17841
diff
changeset
|
737 |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
738 /* 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
|
739 _Py_DEC_REFTOTAL; |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
740 _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
|
741 _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
|
742 /* 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
|
743 for (i = newsize; i < oldsize; i++) { |
|
5396
d1447950fa04
Quickly renamed the last directory.
Guido van Rossum <guido@python.org>
parents:
4733
diff
changeset
|
744 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
|
745 v->ob_item[i] = NULL; |
|
a4aa83012af3
Fixed bugs in resizetuple and extended the interface.
Sjoerd Mullender <sjoerd@acm.org>
parents:
1369
diff
changeset
|
746 } |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
747 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
|
748 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
|
749 *pv = NULL; |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
750 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
|
751 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
|
752 } |
|
15037
c7d46eae95d8
Simplify _PyTuple_Resize by not using the tuple free list and dropping
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
14584
diff
changeset
|
753 _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
|
754 /* Zero out items added by growing */ |
|
23834
8ae26d9be1b4
SF #561244 Micro optimizations
Neal Norwitz <nnorwitz@gmail.com>
parents:
23832
diff
changeset
|
755 if (newsize > oldsize) |
|
23952
3834cb0e7be6
Fix for SF bug 571885
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
23834
diff
changeset
|
756 memset(&sv->ob_item[oldsize], 0, |
|
3834cb0e7be6
Fix for SF bug 571885
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
23834
diff
changeset
|
757 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
|
758 *pv = (PyObject *) sv; |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
759 _PyObject_GC_TRACK(sv); |
|
1369
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
760 return 0; |
|
89e1e5d9ccbf
* compile.[ch]: support for lambda()
Guido van Rossum <guido@python.org>
parents:
1352
diff
changeset
|
761 } |
|
5936
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
762 |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
763 void |
|
13459
0f95c93f200b
ANSI-fication of the sources.
Fred Drake <fdrake@acm.org>
parents:
13265
diff
changeset
|
764 PyTuple_Fini(void) |
|
5936
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
765 { |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
766 #if MAXSAVESIZE > 0 |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
767 int i; |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
768 |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
769 Py_XDECREF(free_tuples[0]); |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
770 free_tuples[0] = NULL; |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
771 |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
772 for (i = 1; i < MAXSAVESIZE; i++) { |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
773 PyTupleObject *p, *q; |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
774 p = free_tuples[i]; |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
775 free_tuples[i] = NULL; |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
776 while (p) { |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
777 q = p; |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
778 p = (PyTupleObject *)(p->ob_item[0]); |
|
19581
fd48a55ac364
Use new GC API.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents:
18933
diff
changeset
|
779 PyObject_GC_Del(q); |
|
5936
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
780 } |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
781 } |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
782 #endif |
|
80d24364b932
Added _Fini() routines to free up some memory
Guido van Rossum <guido@python.org>
parents:
5396
diff
changeset
|
783 } |
|
24683
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
784 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
785 /*********************** Tuple Iterator **************************/ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
786 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
787 typedef struct { |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
788 PyObject_HEAD |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
789 long it_index; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
790 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
|
791 } tupleiterobject; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
792 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
793 PyTypeObject PyTupleIter_Type; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
794 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
795 static PyObject * |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
796 tuple_iter(PyObject *seq) |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
797 { |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
798 tupleiterobject *it; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
799 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
800 if (!PyTuple_Check(seq)) { |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
801 PyErr_BadInternalCall(); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
802 return NULL; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
803 } |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
804 it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
805 if (it == NULL) |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
806 return NULL; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
807 it->it_index = 0; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
808 Py_INCREF(seq); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
809 it->it_seq = (PyTupleObject *)seq; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
810 _PyObject_GC_TRACK(it); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
811 return (PyObject *)it; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
812 } |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
813 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
814 static void |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
815 tupleiter_dealloc(tupleiterobject *it) |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
816 { |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
817 _PyObject_GC_UNTRACK(it); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
818 Py_XDECREF(it->it_seq); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
819 PyObject_GC_Del(it); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
820 } |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
821 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
822 static int |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
823 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
|
824 { |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
825 if (it->it_seq == NULL) |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
826 return 0; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
827 return visit((PyObject *)it->it_seq, arg); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
828 } |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
829 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
830 static PyObject * |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
831 tupleiter_next(tupleiterobject *it) |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
832 { |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
833 PyTupleObject *seq; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
834 PyObject *item; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
835 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
836 assert(it != NULL); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
837 seq = it->it_seq; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
838 if (seq == NULL) |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
839 return NULL; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
840 assert(PyTuple_Check(seq)); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
841 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
842 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
|
843 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
|
844 ++it->it_index; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
845 Py_INCREF(item); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
846 return item; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
847 } |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
848 |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
849 Py_DECREF(seq); |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
850 it->it_seq = NULL; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
851 return NULL; |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
852 } |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
853 |
|
31686
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
854 static int |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
855 tupleiter_len(tupleiterobject *it) |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
856 { |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
857 if (it->it_seq) |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
858 return PyTuple_GET_SIZE(it->it_seq) - it->it_index; |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
859 return 0; |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
860 } |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
861 |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
862 static PySequenceMethods tupleiter_as_sequence = { |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
863 (inquiry)tupleiter_len, /* sq_length */ |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
864 0, /* sq_concat */ |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
865 }; |
|
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
866 |
|
24683
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
867 PyTypeObject PyTupleIter_Type = { |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
868 PyObject_HEAD_INIT(&PyType_Type) |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
869 0, /* ob_size */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
870 "tupleiterator", /* tp_name */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
871 sizeof(tupleiterobject), /* tp_basicsize */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
872 0, /* tp_itemsize */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
873 /* methods */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
874 (destructor)tupleiter_dealloc, /* tp_dealloc */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
875 0, /* tp_print */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
876 0, /* tp_getattr */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
877 0, /* tp_setattr */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
878 0, /* tp_compare */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
879 0, /* tp_repr */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
880 0, /* tp_as_number */ |
|
31686
823279ae43eb
Make iterators length transparent where possible.
Raymond Hettinger <python@rcn.com>
parents:
31663
diff
changeset
|
881 &tupleiter_as_sequence, /* tp_as_sequence */ |
|
24683
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
882 0, /* tp_as_mapping */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
883 0, /* tp_hash */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
884 0, /* tp_call */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
885 0, /* tp_str */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
886 PyObject_GenericGetAttr, /* tp_getattro */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
887 0, /* tp_setattro */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
888 0, /* tp_as_buffer */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
889 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
|
890 0, /* tp_doc */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
891 (traverseproc)tupleiter_traverse, /* tp_traverse */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
892 0, /* tp_clear */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
893 0, /* tp_richcompare */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
894 0, /* tp_weaklistoffset */ |
|
28320
fd5ef7003469
Renamed PyObject_GenericGetIter to PyObject_SelfIter
Raymond Hettinger <python@rcn.com>
parents:
28308
diff
changeset
|
895 PyObject_SelfIter, /* tp_iter */ |
|
24683
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
896 (iternextfunc)tupleiter_next, /* tp_iternext */ |
|
567704bfa595
Moved special case for tuples from iterobject.c to
Raymond Hettinger <python@rcn.com>
parents:
24280
diff
changeset
|
897 }; |