From 38fff8c4e4276e4e57660a78f305e68bfa87874b Mon Sep 17 00:00:00 2001
From: Guido van Rossum <guido@python.org>
Date: Tue, 7 Mar 2006 18:50:55 +0000
Subject: Checking in the code for PEP 357. This was mostly written by Travis
 Oliphant. I've inspected it all; Neal Norwitz and MvL have also looked at it
 (in an earlier incarnation).

---
 Doc/api/abstract.tex    |  5 ++++
 Doc/lib/liboperator.tex |  5 ++++
 Doc/ref/ref3.tex        |  7 +++++
 Include/abstract.h      |  8 ++++++
 Include/object.h        |  9 +++++-
 Lib/test/test_index.py  |  0
 Modules/arraymodule.c   | 29 +++++++------------
 Modules/mmapmodule.c    | 25 ++++++----------
 Modules/operator.c      | 15 ++++++++++
 Objects/abstract.c      | 76 +++++++++++++++++++++----------------------------
 Objects/classobject.c   | 38 +++++++++++++++++++++++++
 Objects/intobject.c     |  1 +
 Objects/listobject.c    | 18 ++++++------
 Objects/longobject.c    | 49 ++++++++++++++++++++++++++-----
 Objects/stringobject.c  |  9 ++++--
 Objects/tupleobject.c   |  7 +++--
 Objects/typeobject.c    | 43 ++++++++++++++++++++++++++++
 Objects/unicodeobject.c |  7 +++--
 Python/ceval.c          | 68 ++++++++++++++-----------------------------
 19 files changed, 269 insertions(+), 150 deletions(-)
 create mode 100644 Lib/test/test_index.py

diff --git a/Doc/api/abstract.tex b/Doc/api/abstract.tex
index c543563..320275c 100644
--- a/Doc/api/abstract.tex
+++ b/Doc/api/abstract.tex
@@ -346,6 +346,7 @@ determination.
   either the sequence and mapping protocols, the sequence length is
   returned.  On error, \code{-1} is returned.  This is the equivalent
   to the Python expression \samp{len(\var{o})}.\bifuncindex{len}
+  \versionadded{2.5}
 \end{cfuncdesc}
 
 
@@ -689,6 +690,10 @@ determination.
   \samp{float(\var{o})}.\bifuncindex{float}
 \end{cfuncdesc}
 
+\begin{cfuncdesc}{Py_ssize_t}{PyNumber_Index}{PyObject *o}
+  Returns the \var{o} converted to a Py_ssize_t integer on success, or
+  -1 with an exception raised on failure.
+\end{cfuncdesc}
 
 \section{Sequence Protocol \label{sequence}}
 
diff --git a/Doc/lib/liboperator.tex b/Doc/lib/liboperator.tex
index 11e004a..41da9b7 100644
--- a/Doc/lib/liboperator.tex
+++ b/Doc/lib/liboperator.tex
@@ -171,6 +171,11 @@ effect.  This is also known as ``true'' division.
 Return the bitwise exclusive or of \var{a} and \var{b}.
 \end{funcdesc}
 
+\begin{funcdesc}{index}{a}
+\funcline{__index__}{a}
+Return \var{a} converted to an integer.  Equivalent to \var{a}\code{.__index__()}.
+\versionadded{2.5}
+\end{funcdesc}
 
 Operations which work with sequences include:
 
diff --git a/Doc/ref/ref3.tex b/Doc/ref/ref3.tex
index 5b78f1c..737b861 100644
--- a/Doc/ref/ref3.tex
+++ b/Doc/ref/ref3.tex
@@ -1978,6 +1978,13 @@ Called to implement the built-in functions
 \function{hex()}\bifuncindex{hex}.  Should return a string value.
 \end{methoddesc}
 
+\begin{methoddesc}[numeric object]{__index__}{self}
+Called to implement operator.index().  Also called whenever Python
+needs an integer object (such as in slicing).  Must return an integer
+(int or long).
+\versionadded{2.5}
+\end{methoddesc}
+
 \begin{methoddesc}[numeric object]{__coerce__}{self, other}
 Called to implement ``mixed-mode'' numeric arithmetic.  Should either
 return a 2-tuple containing \var{self} and \var{other} converted to
diff --git a/Include/abstract.h b/Include/abstract.h
index 73dc91d..9ec18fa 100644
--- a/Include/abstract.h
+++ b/Include/abstract.h
@@ -748,6 +748,14 @@ xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx*/
 
        */
 
+     PyAPI_FUNC(Py_ssize_t) PyNumber_Index(PyObject *);
+
+       /*
+	 Returns the object converted to Py_ssize_t on success 
+	 or -1 with an error raised on failure.
+       */
+
+
      PyAPI_FUNC(PyObject *) PyNumber_Int(PyObject *o);
 
        /*
diff --git a/Include/object.h b/Include/object.h
index 2eb2b44..131812f 100644
--- a/Include/object.h
+++ b/Include/object.h
@@ -206,6 +206,9 @@ typedef struct {
 	binaryfunc nb_true_divide;
 	binaryfunc nb_inplace_floor_divide;
 	binaryfunc nb_inplace_true_divide;
+
+	/* Added in release 2.5 */
+	lenfunc nb_index;
 } PyNumberMethods;
 
 typedef struct {
@@ -503,13 +506,16 @@ given type object has a specified feature.
 /* Objects support garbage collection (see objimp.h) */
 #define Py_TPFLAGS_HAVE_GC (1L<<14)
 
-/* These two bits are preserved for Stackless Python, next after this is 16 */
+/* These two bits are preserved for Stackless Python, next after this is 17 */
 #ifdef STACKLESS
 #define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3L<<15)
 #else
 #define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0
 #endif
 
+/* Objects support nb_index in PyNumberMethods */
+#define Py_TPFLAGS_HAVE_INDEX (1L<<17)
+
 #define Py_TPFLAGS_DEFAULT  ( \
                              Py_TPFLAGS_HAVE_GETCHARBUFFER | \
                              Py_TPFLAGS_HAVE_SEQUENCE_IN | \
@@ -519,6 +525,7 @@ given type object has a specified feature.
                              Py_TPFLAGS_HAVE_ITER | \
                              Py_TPFLAGS_HAVE_CLASS | \
                              Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \
+                             Py_TPFLAGS_HAVE_INDEX | \
                             0)
 
 #define PyType_HasFeature(t,f)  (((t)->tp_flags & (f)) != 0)
diff --git a/Lib/test/test_index.py b/Lib/test/test_index.py
new file mode 100644
index 0000000..e69de29
diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index 2318739..1650ff2 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -1569,19 +1569,17 @@ array_repr(arrayobject *a)
 	return s;
 }
 
+#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
+
 static PyObject*
 array_subscr(arrayobject* self, PyObject* item)
 {
-	if (PyInt_Check(item)) {
-		Py_ssize_t i = PyInt_AS_LONG(item);
-		if (i < 0)
-			i += self->ob_size;
-		return array_item(self, i);
-	}
-	else if (PyLong_Check(item)) {
-		Py_ssize_t i = PyInt_AsSsize_t(item);
-		if (i == -1 && PyErr_Occurred())
+	PyNumberMethods *nb = item->ob_type->tp_as_number;
+	if (nb != NULL && HASINDEX(item) && nb->nb_index != NULL) {
+		Py_ssize_t i = nb->nb_index(item);
+		if (i==-1 && PyErr_Occurred()) {
 			return NULL;
+		}
 		if (i < 0)
 			i += self->ob_size;
 		return array_item(self, i);
@@ -1626,15 +1624,10 @@ array_subscr(arrayobject* self, PyObject* item)
 static int
 array_ass_subscr(arrayobject* self, PyObject* item, PyObject* value)
 {
-	if (PyInt_Check(item)) {
-		Py_ssize_t i = PyInt_AS_LONG(item);
-		if (i < 0)
-			i += self->ob_size;
-		return array_ass_item(self, i, value);
-	}
-	else if (PyLong_Check(item)) {
-		Py_ssize_t i = PyInt_AsSsize_t(item);
-		if (i == -1 && PyErr_Occurred())
+	PyNumberMethods *nb = item->ob_type->tp_as_number;
+	if (nb != NULL && HASINDEX(item) && nb->nb_index != NULL) {
+		Py_ssize_t i = nb->nb_index(item);
+		if (i==-1 && PyErr_Occurred()) 
 			return -1;
 		if (i < 0)
 			i += self->ob_size;
diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index 7c3c3e4..2e34a9f 100644
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -815,6 +815,8 @@ static PyTypeObject mmap_object_type = {
 };
 
 
+#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
+
 /* extract the map size from the given PyObject
 
    Returns -1 on error, with an appropriate Python exception raised. On
@@ -822,26 +824,15 @@ static PyTypeObject mmap_object_type = {
 static Py_ssize_t
 _GetMapSize(PyObject *o)
 {
-	if (PyInt_Check(o)) {
-		long i = PyInt_AsLong(o);
-		if (PyErr_Occurred())
+	PyNumberMethods *nb = o->ob_type->tp_as_number;
+	if (nb != NULL && HASINDEX(o) && nb->nb_index != NULL) {
+		Py_ssize_t i = nb->nb_index(o);
+		if (i==-1 && PyErr_Occurred()) 
 			return -1;
 		if (i < 0)
 			goto onnegoverflow;
-		return i;
-	}
-	else if (PyLong_Check(o)) {
-		Py_ssize_t i = PyInt_AsSsize_t(o);
-		if (PyErr_Occurred()) {
-			/* yes negative overflow is mistaken for positive overflow
-			   but not worth the trouble to check sign of 'i' */
-			if (PyErr_ExceptionMatches(PyExc_OverflowError))
-				goto onposoverflow;
-			else
-				return -1;
-		}
-		if (i < 0)
-			goto onnegoverflow;
+		if (i==PY_SSIZE_T_MAX)
+			goto onposoverflow;
 		return i;
 	}
 	else {
diff --git a/Modules/operator.c b/Modules/operator.c
index 1a2ef85..53144f1 100644
--- a/Modules/operator.c
+++ b/Modules/operator.c
@@ -130,6 +130,20 @@ op_ipow(PyObject *s, PyObject *a)
 	return NULL;
 }
 
+static PyObject *
+op_index(PyObject *s, PyObject *a)
+{
+	Py_ssize_t i;
+	PyObject *a1;
+	if (!PyArg_UnpackTuple(a,"index", 1, 1, &a1))
+		return NULL;		
+	i = PyNumber_Index(a1);
+	if (i == -1 && PyErr_Occurred())
+		return NULL;
+	else
+		return PyInt_FromSsize_t(i);
+}
+
 static PyObject*
 is_(PyObject *s, PyObject *a)
 {
@@ -229,6 +243,7 @@ spam1o(isMappingType,
 
 spam1(is_, "is_(a, b) -- Same as a is b.")
 spam1(is_not, "is_not(a, b) -- Same as a is not b.")
+spam2(index, __index__, "index(a) -- Same as a.__index__()")
 spam2(add,__add__, "add(a, b) -- Same as a + b.")
 spam2(sub,__sub__, "sub(a, b) -- Same as a - b.")
 spam2(mul,__mul__, "mul(a, b) -- Same as a * b.")
diff --git a/Objects/abstract.c b/Objects/abstract.c
index 7ded61a..399656f 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -8,6 +8,8 @@
 #define NEW_STYLE_NUMBER(o) PyType_HasFeature((o)->ob_type, \
 				Py_TPFLAGS_CHECKTYPES)
 
+#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
+
 /* Shorthands to return certain errors */
 
 static PyObject *
@@ -119,10 +121,9 @@ PyObject_GetItem(PyObject *o, PyObject *key)
 		return m->mp_subscript(o, key);
 
 	if (o->ob_type->tp_as_sequence) {
-		if (PyInt_Check(key))
-			return PySequence_GetItem(o, PyInt_AsLong(key));
-		else if (PyLong_Check(key)) {
-			long key_value = PyLong_AsLong(key);
+		PyNumberMethods *nb = key->ob_type->tp_as_number;
+		if (nb != NULL && HASINDEX(key) && nb->nb_index != NULL) {
+			Py_ssize_t key_value = nb->nb_index(key);
 			if (key_value == -1 && PyErr_Occurred())
 				return NULL;
 			return PySequence_GetItem(o, key_value);
@@ -148,10 +149,9 @@ PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)
 		return m->mp_ass_subscript(o, key, value);
 
 	if (o->ob_type->tp_as_sequence) {
-		if (PyInt_Check(key))
-			return PySequence_SetItem(o, PyInt_AsLong(key), value);
-		else if (PyLong_Check(key)) {
-			long key_value = PyLong_AsLong(key);
+		PyNumberMethods *nb = key->ob_type->tp_as_number;
+		if (nb != NULL && HASINDEX(key) && nb->nb_index != NULL) {
+			Py_ssize_t key_value = nb->nb_index(key);
 			if (key_value == -1 && PyErr_Occurred())
 				return -1;
 			return PySequence_SetItem(o, key_value, value);
@@ -180,10 +180,9 @@ PyObject_DelItem(PyObject *o, PyObject *key)
 		return m->mp_ass_subscript(o, key, (PyObject*)NULL);
 
 	if (o->ob_type->tp_as_sequence) {
-		if (PyInt_Check(key))
-			return PySequence_DelItem(o, PyInt_AsLong(key));
-		else if (PyLong_Check(key)) {
-			long key_value = PyLong_AsLong(key);
+		PyNumberMethods *nb = key->ob_type->tp_as_number;
+		if (nb != NULL && HASINDEX(key) && nb->nb_index != NULL) {
+			Py_ssize_t key_value = nb->nb_index(key);
 			if (key_value == -1 && PyErr_Occurred())
 				return -1;
 			return PySequence_DelItem(o, key_value);
@@ -647,12 +646,10 @@ PyNumber_Add(PyObject *v, PyObject *w)
 static PyObject *
 sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
 {
-	long count;
-	if (PyInt_Check(n)) {
-		count  = PyInt_AsLong(n);
-	}
-	else if (PyLong_Check(n)) {
-		count = PyLong_AsLong(n);
+	Py_ssize_t count;
+	PyNumberMethods *nb = n->ob_type->tp_as_number;
+	if (nb != NULL && HASINDEX(n) && nb->nb_index != NULL) {
+		count = nb->nb_index(n);
 		if (count == -1 && PyErr_Occurred())
 			return NULL;
 	}
@@ -660,32 +657,7 @@ sequence_repeat(ssizeargfunc repeatfunc, PyObject *seq, PyObject *n)
 		return type_error(
 			"can't multiply sequence by non-int");
 	}
-#if LONG_MAX != INT_MAX
-	if (count > INT_MAX) {
-		PyErr_SetString(PyExc_ValueError,
-				"sequence repeat count too large");
-		return NULL;
-	}
-	else if (count < INT_MIN)
-		count = INT_MIN;
-	/* XXX Why don't I either
-
-	   - set count to -1 whenever it's negative (after all,
-	     sequence repeat usually treats negative numbers
-	     as zero(); or
-
-	   - raise an exception when it's less than INT_MIN?
-
-	   I'm thinking about a hypothetical use case where some
-	   sequence type might use a negative value as a flag of
-	   some kind.  In those cases I don't want to break the
-	   code by mapping all negative values to -1.  But I also
-	   don't want to break e.g. []*(-sys.maxint), which is
-	   perfectly safe, returning [].  As a compromise, I do
-	   map out-of-range negative values.
-	*/
-#endif
-	return (*repeatfunc)(seq, (int)count);
+	return (*repeatfunc)(seq, count);
 }
 
 PyObject *
@@ -960,6 +932,22 @@ int_from_string(const char *s, Py_ssize_t len)
 	return x;
 }
 
+/* Return a Py_ssize_t integer from the object item */
+Py_ssize_t 
+PyNumber_Index(PyObject *item)
+{
+	Py_ssize_t value = -1;
+	PyNumberMethods *nb = item->ob_type->tp_as_number;
+	if (nb != NULL && HASINDEX(item) && nb->nb_index != NULL) {
+		value = nb->nb_index(item);
+	}
+	else {
+		PyErr_SetString(PyExc_IndexError, 
+				"object cannot be interpreted as an index");
+	}
+	return value;
+}
+
 PyObject *
 PyNumber_Int(PyObject *o)
 {
diff --git a/Objects/classobject.c b/Objects/classobject.c
index 34afb9e..037252d 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -1733,6 +1733,43 @@ instance_nonzero(PyInstanceObject *self)
 	return outcome > 0;
 }
 
+static Py_ssize_t
+instance_index(PyInstanceObject *self)
+{
+	PyObject *func, *res;
+	Py_ssize_t outcome;
+	static PyObject *indexstr = NULL;
+
+	if (indexstr == NULL) {
+		indexstr = PyString_InternFromString("__index__");
+		if (indexstr == NULL)
+			return -1;
+	}	
+	if ((func = instance_getattr(self, indexstr)) == NULL) {
+		if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+			return -1;
+		PyErr_Clear();
+		PyErr_SetString(PyExc_TypeError, 
+				"object cannot be interpreted as an index");
+		return -1;
+	}
+	res = PyEval_CallObject(func, (PyObject *)NULL);
+	Py_DECREF(func);
+	if (res == NULL)
+		return -1;
+	if (PyInt_Check(res) || PyLong_Check(res)) {
+		outcome = res->ob_type->tp_as_number->nb_index(res);
+	}
+	else {
+		PyErr_SetString(PyExc_TypeError, 
+				"__index__ must return an int or a long");
+		outcome = -1;
+	}
+	Py_DECREF(res);
+	return outcome;
+}
+
+
 UNARY(instance_invert, "__invert__")
 UNARY(instance_int, "__int__")
 UNARY(instance_long, "__long__")
@@ -2052,6 +2089,7 @@ static PyNumberMethods instance_as_number = {
 	(binaryfunc)instance_truediv,		/* nb_true_divide */
 	(binaryfunc)instance_ifloordiv,		/* nb_inplace_floor_divide */
 	(binaryfunc)instance_itruediv,		/* nb_inplace_true_divide */
+	(lenfunc)instance_index,		/* nb_index */
 };
 
 PyTypeObject PyInstance_Type = {
diff --git a/Objects/intobject.c b/Objects/intobject.c
index d7a64be..86e2e8c 100644
--- a/Objects/intobject.c
+++ b/Objects/intobject.c
@@ -1069,6 +1069,7 @@ static PyNumberMethods int_as_number = {
 	int_true_divide,	/* nb_true_divide */
 	0,			/* nb_inplace_floor_divide */
 	0,			/* nb_inplace_true_divide */
+	(lenfunc)PyInt_AsSsize_t, /* nb_index */
 };
 
 PyTypeObject PyInt_Type = {
diff --git a/Objects/listobject.c b/Objects/listobject.c
index 0ff61e2..966d659 100644
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -2452,11 +2452,14 @@ PyDoc_STRVAR(list_doc,
 "list() -> new list\n"
 "list(sequence) -> new list initialized from sequence's items");
 
+#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
+
 static PyObject *
 list_subscript(PyListObject* self, PyObject* item)
 {
-	if (PyInt_Check(item) || PyLong_Check(item)) {
-		Py_ssize_t i = PyInt_AsSsize_t(item);
+	PyNumberMethods *nb = item->ob_type->tp_as_number;	
+	if (nb != NULL && HASINDEX(item) && nb->nb_index != NULL) {
+		Py_ssize_t i = nb->nb_index(item);
 		if (i == -1 && PyErr_Occurred())
 			return NULL;
 		if (i < 0)
@@ -2503,14 +2506,9 @@ list_subscript(PyListObject* self, PyObject* item)
 static int
 list_ass_subscript(PyListObject* self, PyObject* item, PyObject* value)
 {
-	if (PyInt_Check(item)) {
-		Py_ssize_t i = PyInt_AS_LONG(item);
-		if (i < 0)
-			i += PyList_GET_SIZE(self);
-		return list_ass_item(self, i, value);
-	}
-	else if (PyLong_Check(item)) {
-		Py_ssize_t i = PyInt_AsSsize_t(item);
+	PyNumberMethods *nb = item->ob_type->tp_as_number;
+	if (nb != NULL && HASINDEX(item) && nb->nb_index != NULL) {
+		Py_ssize_t i = nb->nb_index(item);
 		if (i == -1 && PyErr_Occurred())
 			return -1;
 		if (i < 0)
diff --git a/Objects/longobject.c b/Objects/longobject.c
index 9032656..e47c292 100644
--- a/Objects/longobject.c
+++ b/Objects/longobject.c
@@ -241,12 +241,8 @@ PyLong_AsLong(PyObject *vv)
 	return -1;
 }
 
-/* Get a Py_ssize_t from a long int object.
-   Returns -1 and sets an error condition if overflow occurs. */
-
-Py_ssize_t
-_PyLong_AsSsize_t(PyObject *vv)
-{
+static Py_ssize_t
+_long_as_ssize_t(PyObject *vv) {
 	register PyLongObject *v;
 	size_t x, prev;
 	Py_ssize_t i;
@@ -282,7 +278,45 @@ _PyLong_AsSsize_t(PyObject *vv)
  overflow:
 	PyErr_SetString(PyExc_OverflowError,
 			"long int too large to convert to int");
-	return -1;
+	if (sign > 0) 
+		return PY_SSIZE_T_MAX;
+	else 
+		return -PY_SSIZE_T_MAX-1;
+}
+
+/* Get a Py_ssize_t from a long int object.
+   Returns -1 and sets an error condition if overflow occurs. */
+
+Py_ssize_t
+_PyLong_AsSsize_t(PyObject *vv)
+{
+	Py_ssize_t x;
+
+	x = _long_as_ssize_t(vv);
+	if (PyErr_Occurred()) return -1;
+	return x;
+}
+
+
+/* Get a Py_ssize_t from a long int object.
+   Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
+   and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
+   Return 0 on error, 1 on success.
+*/
+
+static Py_ssize_t
+long_index(PyObject *vv)
+{
+	Py_ssize_t x;
+
+	x = _long_as_ssize_t(vv);
+	if (PyErr_Occurred()) {
+		/* If overflow error, ignore the error */
+		if (x != -1) {
+			PyErr_Clear();
+		}
+	}
+	return x;
 }
 
 /* Get a C unsigned long int from a long int object.
@@ -3131,6 +3165,7 @@ static PyNumberMethods long_as_number = {
 	long_true_divide,		/* nb_true_divide */
 	0,				/* nb_inplace_floor_divide */
 	0,				/* nb_inplace_true_divide */
+	(lenfunc)long_index,            /* nb_index */
 };
 
 PyTypeObject PyLong_Type = {
diff --git a/Objects/stringobject.c b/Objects/stringobject.c
index e2b7603..16d542a 100644
--- a/Objects/stringobject.c
+++ b/Objects/stringobject.c
@@ -1187,16 +1187,19 @@ string_hash(PyStringObject *a)
 	return x;
 }
 
+#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
+
 static PyObject*
 string_subscript(PyStringObject* self, PyObject* item)
 {
-	if (PyInt_Check(item) || PyLong_Check(item)) {
-		Py_ssize_t i = PyInt_AsSsize_t(item);
+	PyNumberMethods *nb = item->ob_type->tp_as_number;
+	if (nb != NULL && HASINDEX(item) && nb->nb_index != NULL) {
+		Py_ssize_t i = nb->nb_index(item);
 		if (i == -1 && PyErr_Occurred())
 			return NULL;
 		if (i < 0)
 			i += PyString_GET_SIZE(self);
-		return string_item(self,i);
+		return string_item(self, i);
 	}
 	else if (PySlice_Check(item)) {
 		Py_ssize_t start, stop, step, slicelength, cur, i;
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index c0383a1..384b355 100644
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -584,11 +584,14 @@ static PySequenceMethods tuple_as_sequence = {
 	(objobjproc)tuplecontains,		/* sq_contains */
 };
 
+#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
+
 static PyObject*
 tuplesubscript(PyTupleObject* self, PyObject* item)
 {
-	if (PyInt_Check(item) || PyLong_Check(item)) {
-		Py_ssize_t i = PyInt_AsSsize_t(item);
+	PyNumberMethods *nb = item->ob_type->tp_as_number;
+	if (nb != NULL && HASINDEX(item) && nb->nb_index != NULL) {
+		Py_ssize_t i = nb->nb_index(item);
 		if (i == -1 && PyErr_Occurred())
 			return NULL;
 		if (i < 0)
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 9837e38..681fb21 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -3051,6 +3051,9 @@ inherit_slots(PyTypeObject *type, PyTypeObject *base)
 			COPYNUM(nb_inplace_true_divide);
 			COPYNUM(nb_inplace_floor_divide);
 		}
+		if (base->tp_flags & Py_TPFLAGS_HAVE_INDEX) {
+			COPYNUM(nb_index);
+		}
 	}
 
 	if (type->tp_as_sequence != NULL && base->tp_as_sequence != NULL) {
@@ -4344,6 +4347,44 @@ slot_nb_nonzero(PyObject *self)
 	return result;
 }
 
+
+static Py_ssize_t 
+slot_nb_index(PyObject *self)
+{
+	PyObject *func, *args;
+	static PyObject *index_str;
+	Py_ssize_t result = -1;
+
+	func = lookup_maybe(self, "__index__", &index_str);
+	if (func == NULL) {
+		if (!PyErr_Occurred()) {
+			PyErr_SetString(PyExc_TypeError, 
+				"object cannot be interpreted as an index");
+		}
+		return -1;
+ 	}
+	args = PyTuple_New(0);
+	if (args != NULL) {
+		PyObject *temp = PyObject_Call(func, args, NULL);
+		Py_DECREF(args);
+		if (temp != NULL) {
+			if (PyInt_Check(temp) || PyLong_Check(temp)) {
+				result =
+                                  temp->ob_type->tp_as_number->nb_index(temp);
+			}
+			else {
+ 				PyErr_SetString(PyExc_TypeError, 
+				    "__index__ must return an int or a long");
+				result = -1;
+			}
+			Py_DECREF(temp);
+		}
+	}
+	Py_DECREF(func);
+	return result;
+}
+
+
 SLOT0(slot_nb_invert, "__invert__")
 SLOT1BIN(slot_nb_lshift, nb_lshift, "__lshift__", "__rlshift__")
 SLOT1BIN(slot_nb_rshift, nb_rshift, "__rshift__", "__rrshift__")
@@ -5069,6 +5110,8 @@ static slotdef slotdefs[] = {
 	       "oct(x)"),
 	UNSLOT("__hex__", nb_hex, slot_nb_hex, wrap_unaryfunc,
 	       "hex(x)"),
+	NBSLOT("__index__", nb_index, slot_nb_index, wrap_lenfunc, 
+	       "x[y:z] <==> x[y.__index__():z.__index__()]"),
 	IBSLOT("__iadd__", nb_inplace_add, slot_nb_inplace_add,
 	       wrap_binaryfunc, "+"),
 	IBSLOT("__isub__", nb_inplace_subtract, slot_nb_inplace_subtract,
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
index 4146f1d..a0d3de9 100644
--- a/Objects/unicodeobject.c
+++ b/Objects/unicodeobject.c
@@ -6460,11 +6460,14 @@ static PySequenceMethods unicode_as_sequence = {
     (objobjproc)PyUnicode_Contains, 	/*sq_contains*/
 };
 
+#define HASINDEX(o) PyType_HasFeature((o)->ob_type, Py_TPFLAGS_HAVE_INDEX)
+
 static PyObject*
 unicode_subscript(PyUnicodeObject* self, PyObject* item)
 {
-    if (PyInt_Check(item) || PyLong_Check(item)) {
-        Py_ssize_t i = PyInt_AsSsize_t(item);
+    PyNumberMethods *nb = item->ob_type->tp_as_number;
+    if (nb != NULL && HASINDEX(item) && nb->nb_index != NULL) {
+        Py_ssize_t i = nb->nb_index(item);
         if (i == -1 && PyErr_Occurred())
             return NULL;
         if (i < 0)
diff --git a/Python/ceval.c b/Python/ceval.c
index b069c77..e7fb875 100644
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -3916,9 +3916,10 @@ ext_do_call(PyObject *func, PyObject ***pp_stack, int flags, int na, int nk)
 	return result;
 }
 
-/* Extract a slice index from a PyInt or PyLong, and store in *pi.
-   Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX, 
-   and silently boost values less than -PY_SSIZE_T_MAX to 0.  
+/* Extract a slice index from a PyInt or PyLong or an object with the
+   nb_index slot defined, and store in *pi.
+   Silently reduce values larger than PY_SSIZE_T_MAX to PY_SSIZE_T_MAX,
+   and silently boost values less than -PY_SSIZE_T_MAX-1 to -PY_SSIZE_T_MAX-1.
    Return 0 on error, 1 on success.
 */
 /* Note:  If v is NULL, return success without storing into *pi.  This
@@ -3932,46 +3933,18 @@ _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
 		Py_ssize_t x;
 		if (PyInt_Check(v)) {
 			x = PyInt_AsLong(v);
-		} else if (PyLong_Check(v)) {
-			x = PyInt_AsSsize_t(v);
-			if (x==-1 && PyErr_Occurred()) {
-				PyObject *long_zero;
-				int cmp;
-
-				if (!PyErr_ExceptionMatches(
-					PyExc_OverflowError)) {
-					/* It's not an overflow error, so just
-					   signal an error */
-					return 0;
-				}
-
-				/* Clear the OverflowError */
-				PyErr_Clear();
-
-				/* It's an overflow error, so we need to
-				   check the sign of the long integer,
-				   set the value to PY_SSIZE_T_MAX or 
-				   -PY_SSIZE_T_MAX, and clear the error. */
-
-				/* Create a long integer with a value of 0 */
-				long_zero = PyLong_FromLong(0L);
-				if (long_zero == NULL)
-					return 0;
-
-				/* Check sign */
-				cmp = PyObject_RichCompareBool(v, long_zero,
-							       Py_GT);
-				Py_DECREF(long_zero);
-				if (cmp < 0)
-					return 0;
-				else if (cmp)
-					x = PY_SSIZE_T_MAX;
-				else
-					x = -PY_SSIZE_T_MAX;
-			}
-		} else {
+		} 
+		else if (v->ob_type->tp_as_number &&
+			 PyType_HasFeature(v->ob_type, Py_TPFLAGS_HAVE_INDEX)
+			 && v->ob_type->tp_as_number->nb_index) {
+			x = v->ob_type->tp_as_number->nb_index(v);
+			if (x == -1 && PyErr_Occurred())
+				return 0;
+		}
+		else {
 			PyErr_SetString(PyExc_TypeError,
-					"slice indices must be integers or None");
+					"slice indices must be integers or "
+					"None or have an __index__ method");
 			return 0;
 		}
 		*pi = x;
@@ -3979,8 +3952,11 @@ _PyEval_SliceIndex(PyObject *v, Py_ssize_t *pi)
 	return 1;
 }
 
-#undef ISINT
-#define ISINT(x) ((x) == NULL || PyInt_Check(x) || PyLong_Check(x))
+#undef ISINDEX
+#define ISINDEX(x) ((x) == NULL || PyInt_Check(x) || PyLong_Check(x) || \
+		    ((x)->ob_type->tp_as_number && \
+                     PyType_HasFeature((x)->ob_type, Py_TPFLAGS_HAVE_INDEX) \
+		     && (x)->ob_type->tp_as_number->nb_index))
 
 static PyObject *
 apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
@@ -3988,7 +3964,7 @@ apply_slice(PyObject *u, PyObject *v, PyObject *w) /* return u[v:w] */
 	PyTypeObject *tp = u->ob_type;
 	PySequenceMethods *sq = tp->tp_as_sequence;
 
-	if (sq && sq->sq_slice && ISINT(v) && ISINT(w)) {
+	if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
 		Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
 		if (!_PyEval_SliceIndex(v, &ilow))
 			return NULL;
@@ -4015,7 +3991,7 @@ assign_slice(PyObject *u, PyObject *v, PyObject *w, PyObject *x)
 	PyTypeObject *tp = u->ob_type;
 	PySequenceMethods *sq = tp->tp_as_sequence;
 
-	if (sq && sq->sq_slice && ISINT(v) && ISINT(w)) {
+	if (sq && sq->sq_slice && ISINDEX(v) && ISINDEX(w)) {
 		Py_ssize_t ilow = 0, ihigh = PY_SSIZE_T_MAX;
 		if (!_PyEval_SliceIndex(v, &ilow))
 			return -1;
-- 
cgit v0.12

