/Objects/tupleobject.c

  1
  2/* Tuple object implementation */
  3
  4#include "Python.h"
  5
  6/* Speed optimization to avoid frequent malloc/free of small tuples */
  7#ifndef PyTuple_MAXSAVESIZE
  8#define PyTuple_MAXSAVESIZE	20  /* Largest tuple to save on free list */
  9#endif
 10#ifndef PyTuple_MAXFREELIST 
 11#define PyTuple_MAXFREELIST  2000  /* Maximum number of tuples of each size to save */
 12#endif
 13
 14#if PyTuple_MAXSAVESIZE > 0
 15/* Entries 1 up to PyTuple_MAXSAVESIZE are free lists, entry 0 is the empty
 16   tuple () of which at most one instance will be allocated.
 17*/
 18static PyTupleObject *free_list[PyTuple_MAXSAVESIZE];
 19static int numfree[PyTuple_MAXSAVESIZE];
 20#endif
 21#ifdef COUNT_ALLOCS
 22int fast_tuple_allocs;
 23int tuple_zero_allocs;
 24#endif
 25
 26PyObject *
 27PyTuple_New(register Py_ssize_t size)
 28{
 29	register PyTupleObject *op;
 30	Py_ssize_t i;
 31	if (size < 0) {
 32		PyErr_BadInternalCall();
 33		return NULL;
 34	}
 35#if PyTuple_MAXSAVESIZE > 0
 36	if (size == 0 && free_list[0]) {
 37		op = free_list[0];
 38		Py_INCREF(op);
 39#ifdef COUNT_ALLOCS
 40		tuple_zero_allocs++;
 41#endif
 42		return (PyObject *) op;
 43	}
 44	if (size < PyTuple_MAXSAVESIZE && (op = free_list[size]) != NULL) {
 45		free_list[size] = (PyTupleObject *) op->ob_item[0];
 46		numfree[size]--;
 47#ifdef COUNT_ALLOCS
 48		fast_tuple_allocs++;
 49#endif
 50		/* Inline PyObject_InitVar */
 51#ifdef Py_TRACE_REFS
 52		Py_SIZE(op) = size;
 53		Py_TYPE(op) = &PyTuple_Type;
 54#endif
 55		_Py_NewReference((PyObject *)op);
 56	}
 57	else
 58#endif
 59	{
 60		Py_ssize_t nbytes = size * sizeof(PyObject *);
 61		/* Check for overflow */
 62		if (nbytes / sizeof(PyObject *) != (size_t)size ||
 63		    (nbytes > PY_SSIZE_T_MAX - sizeof(PyTupleObject) - sizeof(PyObject *)))
 64		{
 65			return PyErr_NoMemory();
 66		}
 67		nbytes += sizeof(PyTupleObject) - sizeof(PyObject *);
 68
 69		op = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
 70		if (op == NULL)
 71			return NULL;
 72	}
 73	for (i=0; i < size; i++)
 74		op->ob_item[i] = NULL;
 75#if PyTuple_MAXSAVESIZE > 0
 76	if (size == 0) {
 77		free_list[0] = op;
 78		++numfree[0];
 79		Py_INCREF(op);	/* extra INCREF so that this is never freed */
 80	}
 81#endif
 82	_PyObject_GC_TRACK(op);
 83	return (PyObject *) op;
 84}
 85
 86Py_ssize_t
 87PyTuple_Size(register PyObject *op)
 88{
 89	if (!PyTuple_Check(op)) {
 90		PyErr_BadInternalCall();
 91		return -1;
 92	}
 93	else
 94		return Py_SIZE(op);
 95}
 96
 97PyObject *
 98PyTuple_GetItem(register PyObject *op, register Py_ssize_t i)
 99{
100	if (!PyTuple_Check(op)) {
101		PyErr_BadInternalCall();
102		return NULL;
103	}
104	if (i < 0 || i >= Py_SIZE(op)) {
105		PyErr_SetString(PyExc_IndexError, "tuple index out of range");
106		return NULL;
107	}
108	return ((PyTupleObject *)op) -> ob_item[i];
109}
110
111int
112PyTuple_SetItem(register PyObject *op, register Py_ssize_t i, PyObject *newitem)
113{
114	register PyObject *olditem;
115	register PyObject **p;
116	if (!PyTuple_Check(op) || op->ob_refcnt != 1) {
117		Py_XDECREF(newitem);
118		PyErr_BadInternalCall();
119		return -1;
120	}
121	if (i < 0 || i >= Py_SIZE(op)) {
122		Py_XDECREF(newitem);
123		PyErr_SetString(PyExc_IndexError,
124				"tuple assignment index out of range");
125		return -1;
126	}
127	p = ((PyTupleObject *)op) -> ob_item + i;
128	olditem = *p;
129	*p = newitem;
130	Py_XDECREF(olditem);
131	return 0;
132}
133
134PyObject *
135PyTuple_Pack(Py_ssize_t n, ...)
136{
137	Py_ssize_t i;
138	PyObject *o;
139	PyObject *result;
140	PyObject **items;
141	va_list vargs;
142
143	va_start(vargs, n);
144	result = PyTuple_New(n);
145	if (result == NULL)
146		return NULL;
147	items = ((PyTupleObject *)result)->ob_item;
148	for (i = 0; i < n; i++) {
149		o = va_arg(vargs, PyObject *);
150		Py_INCREF(o);
151		items[i] = o;
152	}
153	va_end(vargs);
154	return result;
155}
156
157
158/* Methods */
159
160static void
161tupledealloc(register PyTupleObject *op)
162{
163	register Py_ssize_t i;
164	register Py_ssize_t len =  Py_SIZE(op);
165	PyObject_GC_UnTrack(op);
166	Py_TRASHCAN_SAFE_BEGIN(op)
167	if (len > 0) {
168		i = len;
169		while (--i >= 0)
170			Py_XDECREF(op->ob_item[i]);
171#if PyTuple_MAXSAVESIZE > 0
172		if (len < PyTuple_MAXSAVESIZE &&
173		    numfree[len] < PyTuple_MAXFREELIST &&
174		    Py_TYPE(op) == &PyTuple_Type)
175		{
176			op->ob_item[0] = (PyObject *) free_list[len];
177			numfree[len]++;
178			free_list[len] = op;
179			goto done; /* return */
180		}
181#endif
182	}
183	Py_TYPE(op)->tp_free((PyObject *)op);
184done:
185	Py_TRASHCAN_SAFE_END(op)
186}
187
188static int
189tupleprint(PyTupleObject *op, FILE *fp, int flags)
190{
191	Py_ssize_t i;
192	Py_BEGIN_ALLOW_THREADS
193	fprintf(fp, "(");
194	Py_END_ALLOW_THREADS
195	for (i = 0; i < Py_SIZE(op); i++) {
196		if (i > 0) {
197			Py_BEGIN_ALLOW_THREADS
198			fprintf(fp, ", ");
199			Py_END_ALLOW_THREADS
200		}
201		if (PyObject_Print(op->ob_item[i], fp, 0) != 0)
202			return -1;
203	}
204	i = Py_SIZE(op);
205	Py_BEGIN_ALLOW_THREADS
206	if (i == 1)
207		fprintf(fp, ",");
208	fprintf(fp, ")");
209	Py_END_ALLOW_THREADS
210	return 0;
211}
212
213static PyObject *
214tuplerepr(PyTupleObject *v)
215{
216	Py_ssize_t i, n;
217	PyObject *s, *temp;
218	PyObject *pieces, *result = NULL;
219
220	n = Py_SIZE(v);
221	if (n == 0)
222		return PyString_FromString("()");
223
224	/* While not mutable, it is still possible to end up with a cycle in a
225	   tuple through an object that stores itself within a tuple (and thus
226	   infinitely asks for the repr of itself). This should only be
227	   possible within a type. */
228	i = Py_ReprEnter((PyObject *)v);
229	if (i != 0) {
230		return i > 0 ? PyString_FromString("(...)") : NULL;
231	}
232
233	pieces = PyTuple_New(n);
234	if (pieces == NULL)
235		return NULL;
236
237	/* Do repr() on each element. */
238	for (i = 0; i < n; ++i) {
239		if (Py_EnterRecursiveCall(" while getting the repr of a tuple"))
240			goto Done;
241		s = PyObject_Repr(v->ob_item[i]);
242		Py_LeaveRecursiveCall();
243		if (s == NULL)
244			goto Done;
245		PyTuple_SET_ITEM(pieces, i, s);
246	}
247
248	/* Add "()" decorations to the first and last items. */
249	assert(n > 0);
250	s = PyString_FromString("(");
251	if (s == NULL)
252		goto Done;
253	temp = PyTuple_GET_ITEM(pieces, 0);
254	PyString_ConcatAndDel(&s, temp);
255	PyTuple_SET_ITEM(pieces, 0, s);
256	if (s == NULL)
257		goto Done;
258
259	s = PyString_FromString(n == 1 ? ",)" : ")");
260	if (s == NULL)
261		goto Done;
262	temp = PyTuple_GET_ITEM(pieces, n-1);
263	PyString_ConcatAndDel(&temp, s);
264	PyTuple_SET_ITEM(pieces, n-1, temp);
265	if (temp == NULL)
266		goto Done;
267
268	/* Paste them all together with ", " between. */
269	s = PyString_FromString(", ");
270	if (s == NULL)
271		goto Done;
272	result = _PyString_Join(s, pieces);
273	Py_DECREF(s);	
274
275Done:
276	Py_DECREF(pieces);
277	Py_ReprLeave((PyObject *)v);
278	return result;
279}
280
281/* The addend 82520, was selected from the range(0, 1000000) for 
282   generating the greatest number of prime multipliers for tuples 
283   upto length eight:
284
285     1082527, 1165049, 1082531, 1165057, 1247581, 1330103, 1082533, 
286     1330111, 1412633, 1165069, 1247599, 1495177, 1577699
287*/
288
289static long
290tuplehash(PyTupleObject *v)
291{
292	register long x, y;
293	register Py_ssize_t len = Py_SIZE(v);
294	register PyObject **p;
295	long mult = 1000003L;
296	x = 0x345678L;
297	p = v->ob_item;
298	while (--len >= 0) {
299		y = PyObject_Hash(*p++);
300		if (y == -1)
301			return -1;
302		x = (x ^ y) * mult;
303		/* the cast might truncate len; that doesn't change hash stability */
304		mult += (long)(82520L + len + len);
305	}
306	x += 97531L;
307	if (x == -1)
308		x = -2;
309	return x;
310}
311
312static Py_ssize_t
313tuplelength(PyTupleObject *a)
314{
315	return Py_SIZE(a);
316}
317
318static int
319tuplecontains(PyTupleObject *a, PyObject *el)
320{
321	Py_ssize_t i;
322	int cmp;
323
324	for (i = 0, cmp = 0 ; cmp == 0 && i < Py_SIZE(a); ++i)
325		cmp = PyObject_RichCompareBool(el, PyTuple_GET_ITEM(a, i),
326						   Py_EQ);
327	return cmp;
328}
329
330static PyObject *
331tupleitem(register PyTupleObject *a, register Py_ssize_t i)
332{
333	if (i < 0 || i >= Py_SIZE(a)) {
334		PyErr_SetString(PyExc_IndexError, "tuple index out of range");
335		return NULL;
336	}
337	Py_INCREF(a->ob_item[i]);
338	return a->ob_item[i];
339}
340
341static PyObject *
342tupleslice(register PyTupleObject *a, register Py_ssize_t ilow, 
343	   register Py_ssize_t ihigh)
344{
345	register PyTupleObject *np;
346	PyObject **src, **dest;
347	register Py_ssize_t i;
348	Py_ssize_t len;
349	if (ilow < 0)
350		ilow = 0;
351	if (ihigh > Py_SIZE(a))
352		ihigh = Py_SIZE(a);
353	if (ihigh < ilow)
354		ihigh = ilow;
355	if (ilow == 0 && ihigh == Py_SIZE(a) && PyTuple_CheckExact(a)) {
356		Py_INCREF(a);
357		return (PyObject *)a;
358	}
359	len = ihigh - ilow;
360	np = (PyTupleObject *)PyTuple_New(len);
361	if (np == NULL)
362		return NULL;
363	src = a->ob_item + ilow;
364	dest = np->ob_item;
365	for (i = 0; i < len; i++) {
366		PyObject *v = src[i];
367		Py_INCREF(v);
368		dest[i] = v;
369	}
370	return (PyObject *)np;
371}
372
373PyObject *
374PyTuple_GetSlice(PyObject *op, Py_ssize_t i, Py_ssize_t j)
375{
376	if (op == NULL || !PyTuple_Check(op)) {
377		PyErr_BadInternalCall();
378		return NULL;
379	}
380	return tupleslice((PyTupleObject *)op, i, j);
381}
382
383static PyObject *
384tupleconcat(register PyTupleObject *a, register PyObject *bb)
385{
386	register Py_ssize_t size;
387	register Py_ssize_t i;
388	PyObject **src, **dest;
389	PyTupleObject *np;
390	if (!PyTuple_Check(bb)) {
391		PyErr_Format(PyExc_TypeError,
392       		     "can only concatenate tuple (not \"%.200s\") to tuple",
393			     Py_TYPE(bb)->tp_name);
394		return NULL;
395	}
396#define b ((PyTupleObject *)bb)
397	size = Py_SIZE(a) + Py_SIZE(b);
398	if (size < 0)
399		return PyErr_NoMemory();
400	np = (PyTupleObject *) PyTuple_New(size);
401	if (np == NULL) {
402		return NULL;
403	}
404	src = a->ob_item;
405	dest = np->ob_item;
406	for (i = 0; i < Py_SIZE(a); i++) {
407		PyObject *v = src[i];
408		Py_INCREF(v);
409		dest[i] = v;
410	}
411	src = b->ob_item;
412	dest = np->ob_item + Py_SIZE(a);
413	for (i = 0; i < Py_SIZE(b); i++) {
414		PyObject *v = src[i];
415		Py_INCREF(v);
416		dest[i] = v;
417	}
418	return (PyObject *)np;
419#undef b
420}
421
422static PyObject *
423tuplerepeat(PyTupleObject *a, Py_ssize_t n)
424{
425	Py_ssize_t i, j;
426	Py_ssize_t size;
427	PyTupleObject *np;
428	PyObject **p, **items;
429	if (n < 0)
430		n = 0;
431	if (Py_SIZE(a) == 0 || n == 1) {
432		if (PyTuple_CheckExact(a)) {
433			/* Since tuples are immutable, we can return a shared
434			   copy in this case */
435			Py_INCREF(a);
436			return (PyObject *)a;
437		}
438		if (Py_SIZE(a) == 0)
439			return PyTuple_New(0);
440	}
441	size = Py_SIZE(a) * n;
442	if (size/Py_SIZE(a) != n)
443		return PyErr_NoMemory();
444	np = (PyTupleObject *) PyTuple_New(size);
445	if (np == NULL)
446		return NULL;
447	p = np->ob_item;
448	items = a->ob_item;
449	for (i = 0; i < n; i++) {
450		for (j = 0; j < Py_SIZE(a); j++) {
451			*p = items[j];
452			Py_INCREF(*p);
453			p++;
454		}
455	}
456	return (PyObject *) np;
457}
458
459static PyObject *
460tupleindex(PyTupleObject *self, PyObject *args)
461{
462	Py_ssize_t i, start=0, stop=Py_SIZE(self);
463	PyObject *v;
464
465	if (!PyArg_ParseTuple(args, "O|O&O&:index", &v,
466	                            _PyEval_SliceIndex, &start,
467	                            _PyEval_SliceIndex, &stop))
468		return NULL;
469	if (start < 0) {
470		start += Py_SIZE(self);
471		if (start < 0)
472			start = 0;
473	}
474	if (stop < 0) {
475		stop += Py_SIZE(self);
476		if (stop < 0)
477			stop = 0;
478	}
479	for (i = start; i < stop && i < Py_SIZE(self); i++) {
480		int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
481		if (cmp > 0)
482			return PyInt_FromSsize_t(i);
483		else if (cmp < 0)
484			return NULL;
485	}
486	PyErr_SetString(PyExc_ValueError, "tuple.index(x): x not in list");
487	return NULL;
488}
489
490static PyObject *
491tuplecount(PyTupleObject *self, PyObject *v)
492{
493	Py_ssize_t count = 0;
494	Py_ssize_t i;
495
496	for (i = 0; i < Py_SIZE(self); i++) {
497		int cmp = PyObject_RichCompareBool(self->ob_item[i], v, Py_EQ);
498		if (cmp > 0)
499			count++;
500		else if (cmp < 0)
501			return NULL;
502	}
503	return PyInt_FromSsize_t(count);
504}
505
506static int
507tupletraverse(PyTupleObject *o, visitproc visit, void *arg)
508{
509	Py_ssize_t i;
510
511	for (i = Py_SIZE(o); --i >= 0; )
512		Py_VISIT(o->ob_item[i]);
513	return 0;
514}
515
516static PyObject *
517tuplerichcompare(PyObject *v, PyObject *w, int op)
518{
519	PyTupleObject *vt, *wt;
520	Py_ssize_t i;
521	Py_ssize_t vlen, wlen;
522
523	if (!PyTuple_Check(v) || !PyTuple_Check(w)) {
524		Py_INCREF(Py_NotImplemented);
525		return Py_NotImplemented;
526	}
527
528	vt = (PyTupleObject *)v;
529	wt = (PyTupleObject *)w;
530
531	vlen = Py_SIZE(vt);
532	wlen = Py_SIZE(wt);
533
534	/* Note:  the corresponding code for lists has an "early out" test
535	 * here when op is EQ or NE and the lengths differ.  That pays there,
536	 * but Tim was unable to find any real code where EQ/NE tuple
537	 * compares don't have the same length, so testing for it here would
538	 * have cost without benefit.
539	 */
540
541	/* Search for the first index where items are different.
542	 * Note that because tuples are immutable, it's safe to reuse
543	 * vlen and wlen across the comparison calls.
544	 */
545	for (i = 0; i < vlen && i < wlen; i++) {
546		int k = PyObject_RichCompareBool(vt->ob_item[i],
547						 wt->ob_item[i], Py_EQ);
548		if (k < 0)
549			return NULL;
550		if (!k)
551			break;
552	}
553
554	if (i >= vlen || i >= wlen) {
555		/* No more items to compare -- compare sizes */
556		int cmp;
557		PyObject *res;
558		switch (op) {
559		case Py_LT: cmp = vlen <  wlen; break;
560		case Py_LE: cmp = vlen <= wlen; break;
561		case Py_EQ: cmp = vlen == wlen; break;
562		case Py_NE: cmp = vlen != wlen; break;
563		case Py_GT: cmp = vlen >  wlen; break;
564		case Py_GE: cmp = vlen >= wlen; break;
565		default: return NULL; /* cannot happen */
566		}
567		if (cmp)
568			res = Py_True;
569		else
570			res = Py_False;
571		Py_INCREF(res);
572		return res;
573	}
574
575	/* We have an item that differs -- shortcuts for EQ/NE */
576	if (op == Py_EQ) {
577		Py_INCREF(Py_False);
578		return Py_False;
579	}
580	if (op == Py_NE) {
581		Py_INCREF(Py_True);
582		return Py_True;
583	}
584
585	/* Compare the final item again using the proper operator */
586	return PyObject_RichCompare(vt->ob_item[i], wt->ob_item[i], op);
587}
588
589static PyObject *
590tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
591
592static PyObject *
593tuple_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
594{
595	PyObject *arg = NULL;
596	static char *kwlist[] = {"sequence", 0};
597
598	if (type != &PyTuple_Type)
599		return tuple_subtype_new(type, args, kwds);
600	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:tuple", kwlist, &arg))
601		return NULL;
602
603	if (arg == NULL)
604		return PyTuple_New(0);
605	else
606		return PySequence_Tuple(arg);
607}
608
609static PyObject *
610tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
611{
612	PyObject *tmp, *newobj, *item;
613	Py_ssize_t i, n;
614
615	assert(PyType_IsSubtype(type, &PyTuple_Type));
616	tmp = tuple_new(&PyTuple_Type, args, kwds);
617	if (tmp == NULL)
618		return NULL;
619	assert(PyTuple_Check(tmp));
620	newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));
621	if (newobj == NULL)
622		return NULL;
623	for (i = 0; i < n; i++) {
624		item = PyTuple_GET_ITEM(tmp, i);
625		Py_INCREF(item);
626		PyTuple_SET_ITEM(newobj, i, item);
627	}
628	Py_DECREF(tmp);
629	return newobj;
630}
631
632PyDoc_STRVAR(tuple_doc,
633"tuple() -> an empty tuple\n"
634"tuple(sequence) -> tuple initialized from sequence's items\n"
635"\n"
636"If the argument is a tuple, the return value is the same object.");
637
638static PySequenceMethods tuple_as_sequence = {
639	(lenfunc)tuplelength,			/* sq_length */
640	(binaryfunc)tupleconcat,		/* sq_concat */
641	(ssizeargfunc)tuplerepeat,		/* sq_repeat */
642	(ssizeargfunc)tupleitem,		/* sq_item */
643	(ssizessizeargfunc)tupleslice,		/* sq_slice */
644	0,					/* sq_ass_item */
645	0,					/* sq_ass_slice */
646	(objobjproc)tuplecontains,		/* sq_contains */
647};
648
649static PyObject*
650tuplesubscript(PyTupleObject* self, PyObject* item)
651{
652	if (PyIndex_Check(item)) {
653		Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
654		if (i == -1 && PyErr_Occurred())
655			return NULL;
656		if (i < 0)
657			i += PyTuple_GET_SIZE(self);
658		return tupleitem(self, i);
659	}
660	else if (PySlice_Check(item)) {
661		Py_ssize_t start, stop, step, slicelength, cur, i;
662		PyObject* result;
663		PyObject* it;
664		PyObject **src, **dest;
665
666		if (PySlice_GetIndicesEx((PySliceObject*)item,
667				 PyTuple_GET_SIZE(self),
668				 &start, &stop, &step, &slicelength) < 0) {
669			return NULL;
670		}
671
672		if (slicelength <= 0) {
673			return PyTuple_New(0);
674		}
675		else if (start == 0 && step == 1 &&
676			 slicelength == PyTuple_GET_SIZE(self) &&
677			 PyTuple_CheckExact(self)) {
678			Py_INCREF(self);
679			return (PyObject *)self;
680		}
681		else {
682			result = PyTuple_New(slicelength);
683			if (!result) return NULL;
684
685			src = self->ob_item;
686			dest = ((PyTupleObject *)result)->ob_item;
687			for (cur = start, i = 0; i < slicelength; 
688			     cur += step, i++) {
689				it = src[cur];
690				Py_INCREF(it);
691				dest[i] = it;
692			}
693			
694			return result;
695		}
696	}
697	else {
698		PyErr_Format(PyExc_TypeError, 
699			     "tuple indices must be integers, not %.200s",
700			     Py_TYPE(item)->tp_name);
701		return NULL;
702	}
703}
704
705static PyObject *
706tuple_getnewargs(PyTupleObject *v)
707{
708	return Py_BuildValue("(N)", tupleslice(v, 0, Py_SIZE(v)));
709	
710}
711
712static PyObject *
713tuple_sizeof(PyTupleObject *self)
714{
715	Py_ssize_t res;
716
717	res = PyTuple_Type.tp_basicsize + Py_SIZE(self) * sizeof(PyObject *);
718	return PyInt_FromSsize_t(res);
719}
720
721PyDoc_STRVAR(index_doc,
722"T.index(value, [start, [stop]]) -> integer -- return first index of value.\n"
723"Raises ValueError if the value is not present."
724);
725PyDoc_STRVAR(count_doc,
726"T.count(value) -> integer -- return number of occurrences of value");
727PyDoc_STRVAR(sizeof_doc,
728"T.__sizeof__() -- size of T in memory, in bytes");
729
730static PyMethodDef tuple_methods[] = {
731	{"__getnewargs__",	(PyCFunction)tuple_getnewargs,	METH_NOARGS},
732	{"__sizeof__",	(PyCFunction)tuple_sizeof, METH_NOARGS, sizeof_doc},
733	{"index",	(PyCFunction)tupleindex,  METH_VARARGS, index_doc},
734	{"count",	(PyCFunction)tuplecount,  METH_O, count_doc},
735	{NULL,		NULL}		/* sentinel */
736};
737
738static PyMappingMethods tuple_as_mapping = {
739	(lenfunc)tuplelength,
740	(binaryfunc)tuplesubscript,
741	0
742};
743
744static PyObject *tuple_iter(PyObject *seq);
745
746PyTypeObject PyTuple_Type = {
747	PyVarObject_HEAD_INIT(&PyType_Type, 0)
748	"tuple",
749	sizeof(PyTupleObject) - sizeof(PyObject *),
750	sizeof(PyObject *),
751	(destructor)tupledealloc,		/* tp_dealloc */
752	(printfunc)tupleprint,			/* tp_print */
753	0,					/* tp_getattr */
754	0,					/* tp_setattr */
755	0,					/* tp_compare */
756	(reprfunc)tuplerepr,			/* tp_repr */
757	0,					/* tp_as_number */
758	&tuple_as_sequence,			/* tp_as_sequence */
759	&tuple_as_mapping,			/* tp_as_mapping */
760	(hashfunc)tuplehash,			/* tp_hash */
761	0,					/* tp_call */
762	0,					/* tp_str */
763	PyObject_GenericGetAttr,		/* tp_getattro */
764	0,					/* tp_setattro */
765	0,					/* tp_as_buffer */
766	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
767		Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS, /* tp_flags */
768	tuple_doc,				/* tp_doc */
769 	(traverseproc)tupletraverse,		/* tp_traverse */
770	0,					/* tp_clear */
771	tuplerichcompare,			/* tp_richcompare */
772	0,					/* tp_weaklistoffset */
773	tuple_iter,	    			/* tp_iter */
774	0,					/* tp_iternext */
775	tuple_methods,				/* tp_methods */
776	0,					/* tp_members */
777	0,					/* tp_getset */
778	0,					/* tp_base */
779	0,					/* tp_dict */
780	0,					/* tp_descr_get */
781	0,					/* tp_descr_set */
782	0,					/* tp_dictoffset */
783	0,					/* tp_init */
784	0,					/* tp_alloc */
785	tuple_new,				/* tp_new */
786	PyObject_GC_Del,        		/* tp_free */
787};
788
789/* The following function breaks the notion that tuples are immutable:
790   it changes the size of a tuple.  We get away with this only if there
791   is only one module referencing the object.  You can also think of it
792   as creating a new tuple object and destroying the old one, only more
793   efficiently.  In any case, don't use this if the tuple may already be
794   known to some other part of the code. */
795
796int
797_PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
798{
799	register PyTupleObject *v;
800	register PyTupleObject *sv;
801	Py_ssize_t i;
802	Py_ssize_t oldsize;
803
804	v = (PyTupleObject *) *pv;
805	if (v == NULL || Py_TYPE(v) != &PyTuple_Type ||
806	    (Py_SIZE(v) != 0 && Py_REFCNT(v) != 1)) {
807		*pv = 0;
808		Py_XDECREF(v);
809		PyErr_BadInternalCall();
810		return -1;
811	}
812	oldsize = Py_SIZE(v);
813	if (oldsize == newsize)
814		return 0;
815
816	if (oldsize == 0) {
817		/* Empty tuples are often shared, so we should never 
818		   resize them in-place even if we do own the only
819		   (current) reference */
820		Py_DECREF(v);
821		*pv = PyTuple_New(newsize);
822		return *pv == NULL ? -1 : 0;
823	}
824
825	/* XXX UNREF/NEWREF interface should be more symmetrical */
826	_Py_DEC_REFTOTAL;
827	_PyObject_GC_UNTRACK(v);
828	_Py_ForgetReference((PyObject *) v);
829	/* DECREF items deleted by shrinkage */
830	for (i = newsize; i < oldsize; i++) {
831		Py_XDECREF(v->ob_item[i]);
832		v->ob_item[i] = NULL;
833	}
834	sv = PyObject_GC_Resize(PyTupleObject, v, newsize);
835	if (sv == NULL) {
836		*pv = NULL;
837		PyObject_GC_Del(v);
838		return -1;
839	}
840	_Py_NewReference((PyObject *) sv);
841	/* Zero out items added by growing */
842	if (newsize > oldsize)
843		memset(&sv->ob_item[oldsize], 0,
844		       sizeof(*sv->ob_item) * (newsize - oldsize));
845	*pv = (PyObject *) sv;
846	_PyObject_GC_TRACK(sv);
847	return 0;
848}
849
850int
851PyTuple_ClearFreeList(void)
852{
853	int freelist_size = 0;
854#if PyTuple_MAXSAVESIZE > 0
855	int i;
856	for (i = 1; i < PyTuple_MAXSAVESIZE; i++) {
857		PyTupleObject *p, *q;
858		p = free_list[i];
859		freelist_size += numfree[i];
860		free_list[i] = NULL;
861		numfree[i] = 0;
862		while (p) {
863			q = p;
864			p = (PyTupleObject *)(p->ob_item[0]);
865			PyObject_GC_Del(q);
866		}
867	}
868#endif
869	return freelist_size;
870}
871	
872void
873PyTuple_Fini(void)
874{
875#if PyTuple_MAXSAVESIZE > 0
876	/* empty tuples are used all over the place and applications may
877	 * rely on the fact that an empty tuple is a singleton. */
878	Py_XDECREF(free_list[0]);
879	free_list[0] = NULL;
880
881	(void)PyTuple_ClearFreeList();
882#endif
883}
884
885/*********************** Tuple Iterator **************************/
886
887typedef struct {
888	PyObject_HEAD
889	long it_index;
890	PyTupleObject *it_seq; /* Set to NULL when iterator is exhausted */
891} tupleiterobject;
892
893static void
894tupleiter_dealloc(tupleiterobject *it)
895{
896	_PyObject_GC_UNTRACK(it);
897	Py_XDECREF(it->it_seq);
898	PyObject_GC_Del(it);
899}
900
901static int
902tupleiter_traverse(tupleiterobject *it, visitproc visit, void *arg)
903{
904	Py_VISIT(it->it_seq);
905	return 0;
906}
907
908static PyObject *
909tupleiter_next(tupleiterobject *it)
910{
911	PyTupleObject *seq;
912	PyObject *item;
913
914	assert(it != NULL);
915	seq = it->it_seq;
916	if (seq == NULL)
917		return NULL;
918	assert(PyTuple_Check(seq));
919
920	if (it->it_index < PyTuple_GET_SIZE(seq)) {
921		item = PyTuple_GET_ITEM(seq, it->it_index);
922		++it->it_index;
923		Py_INCREF(item);
924		return item;
925	}
926
927	Py_DECREF(seq);
928	it->it_seq = NULL;
929	return NULL;
930}
931
932static PyObject *
933tupleiter_len(tupleiterobject *it)
934{
935	Py_ssize_t len = 0;
936	if (it->it_seq)
937		len = PyTuple_GET_SIZE(it->it_seq) - it->it_index;
938	return PyInt_FromSsize_t(len);
939}
940
941PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it)).");
942
943static PyMethodDef tupleiter_methods[] = {
944	{"__length_hint__", (PyCFunction)tupleiter_len, METH_NOARGS, length_hint_doc},
945 	{NULL,		NULL}		/* sentinel */
946};
947
948PyTypeObject PyTupleIter_Type = {
949	PyVarObject_HEAD_INIT(&PyType_Type, 0)
950	"tupleiterator",			/* tp_name */
951	sizeof(tupleiterobject),		/* tp_basicsize */
952	0,					/* tp_itemsize */
953	/* methods */
954	(destructor)tupleiter_dealloc,		/* tp_dealloc */
955	0,					/* tp_print */
956	0,					/* tp_getattr */
957	0,					/* tp_setattr */
958	0,					/* tp_compare */
959	0,					/* tp_repr */
960	0,					/* tp_as_number */
961	0,					/* tp_as_sequence */
962	0,					/* tp_as_mapping */
963	0,					/* tp_hash */
964	0,					/* tp_call */
965	0,					/* tp_str */
966	PyObject_GenericGetAttr,		/* tp_getattro */
967	0,					/* tp_setattro */
968	0,					/* tp_as_buffer */
969	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
970	0,					/* tp_doc */
971	(traverseproc)tupleiter_traverse,	/* tp_traverse */
972	0,					/* tp_clear */
973	0,					/* tp_richcompare */
974	0,					/* tp_weaklistoffset */
975	PyObject_SelfIter,			/* tp_iter */
976	(iternextfunc)tupleiter_next,		/* tp_iternext */
977	tupleiter_methods,			/* tp_methods */
978	0,
979};
980
981static PyObject *
982tuple_iter(PyObject *seq)
983{
984	tupleiterobject *it;
985
986	if (!PyTuple_Check(seq)) {
987		PyErr_BadInternalCall();
988		return NULL;
989	}
990	it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type);
991	if (it == NULL)
992		return NULL;
993	it->it_index = 0;
994	Py_INCREF(seq);
995	it->it_seq = (PyTupleObject *)seq;
996	_PyObject_GC_TRACK(it);
997	return (PyObject *)it;
998}