res = Py_False;		Py_INCREF(res);		return res;	} 	/* We have an item that differs -- shortcuts for EQ/NE */	if (op == Py_EQ) {		Py_INCREF(Py_False);		return Py_False;	}	if (op == Py_NE) {		Py_INCREF(Py_True);		return Py_True;	} 	/* Compare the final item again using the proper operator */	return PyObject_RichCompare(vt->ob_item[i], wt->ob_item[i], op);} static PyObject *tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds); static PyObject *tuple_new(PyTypeObject *type, PyObject *args, PyObject *kwds){	PyObject *arg = NULL;	static char *kwlist[] = {"sequence", 0}; 	if (type != &PyTuple_Type)		return tuple_subtype_new(type, args, kwds);	if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:tuple", kwlist, &arg))		return NULL; 	if (arg == NULL)		return PyTuple_New(0);	else		return PySequence_Tuple(arg);} static PyObject *tuple_subtype_new(PyTypeObject *type, PyObject *args, PyObject *kwds){	PyObject *tmp, *newobj, *item;	Py_ssize_t i, n; 	assert(PyType_IsSubtype(type, &PyTuple_Type));	tmp = tuple_new(&PyTuple_Type, args, kwds);	if (tmp == NULL)		return NULL;	assert(PyTuple_Check(tmp));	newobj = type->tp_alloc(type, n = PyTuple_GET_SIZE(tmp));	if (newobj == NULL)		return NULL;	for (i = 0; i < n; i++) {		item = PyTuple_GET_ITEM(tmp, i);		Py_INCREF(item);		PyTuple_SET_ITEM(newobj, i, item);	}	Py_DECREF(tmp);	return newobj;} PyDoc_STRVAR(tuple_doc,"tuple() -> an empty tuple\n""tuple(sequence) -> tuple initialized from sequence's items\n""\n""If the argument is a tuple, the return value is the same object."); static PySequenceMethods tuple_as_sequence = {	(lenfunc)tuplelength,			/* sq_length */	(binaryfunc)tupleconcat,		/* sq_concat */	(ssizeargfunc)tuplerepeat,		/* sq_repeat */	(ssizeargfunc)tupleitem,		/* sq_item */	(ssizessizeargfunc)tupleslice,		/* sq_slice */	0,					/* sq_ass_item */	0,					/* sq_ass_slice */	(objobjproc)tuplecontains,		/* sq_contains */}; static PyObject*tuplesubscript(PyTupleObject* self, PyObject* item){	if (PyIndex_Check(item)) {		Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);		if (i == -1 && PyErr_Occurred())			return NULL;		if (i < 0)			i += PyTuple_GET_SIZE(self);		return tupleitem(self, i);	}	else if (PySlice_Check(item)) {		Py_ssize_t start, stop, step, slicelength, cur, i;		PyObject* result;		PyObject* it;		PyObject **src, **dest; 		if (PySlice_GetIndicesEx((PySliceObject*)item,				 PyTuple_GET_SIZE(self),				 &start, &stop, &step, &slicelength) < 0) {			return NULL;		} 		if (slicelength <= 0) {			return PyTuple_New(0);		}		else {			result = PyTuple_New(slicelength);			if (!result) return NULL; 			src = self->ob_item;			dest = ((PyTupleObject *)result)->ob_item;			for (cur = start, i = 0; i < slicelength; 			     cur += step, i++) {				it = src[cur];				Py_INCREF(it);				dest[i] = it;			}						return result;		}	}	else {		PyErr_SetString(PyExc_TypeError, 				"tuple indices must be integers");		return NULL;	}} static PyObject *tuple_getnewargs(PyTupleObject *v){	return Py_BuildValue("(N)", tupleslice(v, 0, v->ob_size));	} static PyMethodDef tuple_methods[] = {	{"__getnewargs__",	(PyCFunction)tuple_getnewargs,	METH_NOARGS},	{NULL,		NULL}		/* sentinel */}; static PyMappingMethods tuple_as_mapping = {	(lenfunc)tuplelength,	(binaryfunc)tuplesubscript,	0}; static PyObject *tuple_iter(PyObject *seq); PyTypeObject PyTuple_Type = {	PyObject_HEAD_INIT(&PyType_Type)	0,	"tuple",	sizeof(PyTupleObject) - sizeof(PyObject *),	sizeof(PyObject *),	(destructor)tupledealloc,		/* tp_dealloc */	(printfunc)tupleprint,			/* tp_print */	0,					/* tp_getattr */	0,					/* tp_setattr */	0,					/* tp_compare */	(reprfunc)tuplerepr,			/* tp_repr */	0,					/* tp_as_number */	&tuple_as_sequence,			/* tp_as_sequence */	&tuple_as_mapping,			/* tp_as_mapping */	(hashfunc)tuplehash,			/* tp_hash */	0,					/* tp_call */	0,					/* tp_str */	PyObject_GenericGetAttr,		/* tp_getattro */	0,					/* tp_setattro */	0,					/* tp_as_buffer */	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |		Py_TPFLAGS_BASETYPE,		/* tp_flags */	tuple_doc,				/* tp_doc */ 	(traverseproc)tupletraverse,		/* tp_traverse */	0,					/* tp_clear */	tuplerichcompare,			/* tp_richcompare */	0,					/* tp_weaklistoffset */	tuple_iter,	    			/* tp_iter */	0,					/* tp_iternext */	tuple_methods,				/* tp_methods */	0,					/* tp_members */	0,					/* tp_getset */	0,					/* tp_base */	0,					/* tp_dict */	0,					/* tp_descr_get */	0,					/* tp_descr_set */	0,					/* tp_dictoffset */	0,					/* tp_init */	0,					/* tp_alloc */	tuple_new,				/* tp_new */	PyObject_GC_Del,        		/* tp_free */}; /* The following function breaks the notion that tuples are immutable:   it changes the size of a tuple.  We get away with this only if there   is only one module referencing the object.  You can also think of it   as creating a new tuple object and destroying the old one, only more   efficiently.  In any case, don't use this if the tuple may already be   known to some other part of the code. */ int_PyTuple_Resize(PyObject **pv, Py_ssize_t newsize){	register PyTupleObject *v;	register PyTupleObject *sv;	Py_ssize_t i;	Py_ssize_t oldsize; 	v = (PyTupleObject *) *pv;	if (v == NULL || v->ob_type != &PyTuple_Type ||	    (v->ob_size != 0 && v->ob_refcnt != 1)) {		*pv = 0;		Py_XDECREF(v);		PyErr_BadInternalCall();		return -1;	}	oldsize = v->ob_size;	if (oldsize == newsize)		return 0; 	if (oldsize == 0) {		/* Empty tuples are often shared, so we should never 		   resize them in-place even if we do own the only		   (current) reference */		Py_DECREF(v);		*pv = PyTuple_New(newsize);		return *pv == NULL ? -1 : 0;	} 	/* XXX UNREF/NEWREF interface should be more symmetrical */	_Py_DEC_REFTOTAL;	_PyObject_GC_UNTRACK(v);	_Py_ForgetReference((PyObject *) v);	/* DECREF items deleted by shrinkage */	for (i = newsize; i < oldsize; i++) {		Py_XDECREF(v->ob_item[i]);		v->ob_item[i] = NULL;	}	sv = PyObject_GC_Resize(PyTupleObject, v, newsize);	if (sv == NULL) {		*pv = NULL;		PyObject_GC_Del(v);		return -1;	}	_Py_NewReference((PyObject *) sv);	/* Zero out items added by growing */	if (newsize > oldsize)		memset(&sv->ob_item[oldsize], 0,		       sizeof(*sv->ob_item) * (newsize - oldsize));	*pv = (PyObject *) sv;	_PyObject_GC_TRACK(sv);	return 0;} voidPyTuple_Fini(void){#if MAXSAVESIZE > 0	int i; 	Py_XDECREF(free_tuples[0]);	free_tuples[0] = NULL; 	for (i = 1; i < MAXSAVESIZE; i++) {		PyTupleObject *p, *q;		p = free_tuples[i];		free_tuples[i] = NULL;		while (p) {			q = p;			p = (PyTupleObject *)(p->ob_item[0]);			PyObject_GC_Del(q);		}	}#endif} /*********************** Tuple Iterator **************************/ typedef struct {	PyObject_HEAD	long it_index;	PyTupleObject *it_seq; /* Set to NULL when iterator is exhausted */} tupleiterobject; static voidtupleiter_dealloc(tupleiterobject *it){	_PyObject_GC_UNTRACK(it);	Py_XDECREF(it->it_seq);	PyObject_GC_Del(it);} static inttupleiter_traverse(tupleiterobject *it, visitproc visit, void *arg){	Py_VISIT(it->it_seq);	return 0;} static PyObject *tupleiter_next(tupleiterobject *it){	PyTupleObject *seq;	PyObject *item; 	assert(it != NULL);	seq = it->it_seq;	if (seq == NULL)		return NULL;	assert(PyTuple_Check(seq)); 	if (it->it_index < PyTuple_GET_SIZE(seq)) {		item = PyTuple_GET_ITEM(seq, it->it_index);		++it->it_index;		Py_INCREF(item);		return item;	} 	Py_DECREF(seq);	it->it_seq = NULL;	return NULL;} static PyObject *tupleiter_len(tupleiterobject *it){	Py_ssize_t len = 0;	if (it->it_seq)		len = PyTuple_GET_SIZE(it->it_seq) - it->it_index;	return PyInt_FromSsize_t(len);} PyDoc_STRVAR(length_hint_doc, "Private method returning an estimate of len(list(it))."); static PyMethodDef tupleiter_methods[] = {	{"__length_hint__", (PyCFunction)tupleiter_len, METH_NOARGS, length_hint_doc}, 	{NULL,		NULL}		/* sentinel */}; PyTypeObject PyTupleIter_Type = {	PyObject_HEAD_INIT(&PyType_Type)	0,					/* ob_size */	"tupleiterator",			/* tp_name */	sizeof(tupleiterobject),		/* tp_basicsize */	0,					/* tp_itemsize */	/* methods */	(destructor)tupleiter_dealloc,		/* tp_dealloc */	0,					/* tp_print */	0,					/* tp_getattr */	0,					/* tp_setattr */	0,					/* tp_compare */	0,					/* tp_repr */	0,					/* tp_as_number */	0,					/* tp_as_sequence */	0,					/* tp_as_mapping */	0,					/* tp_hash */	0,					/* tp_call */	0,					/* tp_str */	PyObject_GenericGetAttr,		/* tp_getattro */	0,					/* tp_setattro */	0,					/* tp_as_buffer */	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */	0,					/* tp_doc */	(traverseproc)tupleiter_traverse,	/* tp_traverse */	0,					/* tp_clear */	0,					/* tp_richcompare */	0,					/* tp_weaklistoffset */	PyObject_SelfIter,			/* tp_iter */	(iternextfunc)tupleiter_next,		/* tp_iternext */	tupleiter_methods,			/* tp_methods */	0,}; static PyObject *tuple_iter(PyObject *seq){	tupleiterobject *it; 	if (!PyTuple_Check(seq)) {		PyErr_BadInternalCall();		return NULL;	}	it = PyObject_GC_New(tupleiterobject, &PyTupleIter_Type);	if (it == NULL)		return NULL;	it->it_index = 0;	Py_INCREF(seq);	it->it_seq = (PyTupleObject *)seq;	_PyObject_GC_TRACK(it);	return (PyObject *)it;}

Lines 501–890 of 890. Previous lines