Index: Objects/rangeobject.c =================================================================== --- Objects/rangeobject.c (revision 62635) +++ Objects/rangeobject.c (working copy) @@ -1,6 +1,7 @@ /* Range object implementation */ #include "Python.h" +#include "structmember.h" /* Support objects whose length is > PY_SSIZE_T_MAX. @@ -14,6 +15,7 @@ PyObject *start; PyObject *stop; PyObject *step; + PyObject *length; } rangeobject; /* Helper function for validating step. Always returns a new reference or @@ -43,6 +45,9 @@ return step; } +static PyObject* range_compute_length(PyObject *start, + PyObject *stop, PyObject *step); + /* XXX(nnorwitz): should we error check if the user passes any empty ranges? range(-10) range(0, -5) @@ -52,7 +57,7 @@ range_new(PyTypeObject *type, PyObject *args, PyObject *kw) { rangeobject *obj = NULL; - PyObject *start = NULL, *stop = NULL, *step = NULL; + PyObject *start = NULL, *stop = NULL, *step = NULL, *length = NULL; if (!_PyArg_NoKeywords("range()", kw)) return NULL; @@ -81,25 +86,31 @@ goto Fail; } + length = range_compute_length(start, stop, step); + if (length == NULL) + goto Fail; obj = PyObject_New(rangeobject, &PyRange_Type); if (obj == NULL) goto Fail; obj->start = start; obj->stop = stop; obj->step = step; + obj->length = length; return (PyObject *) obj; Fail: Py_XDECREF(start); Py_XDECREF(stop); Py_XDECREF(step); + Py_XDECREF(length); return NULL; } PyDoc_STRVAR(range_doc, "range([start,] stop[, step]) -> range object\n\ \n\ -Returns an iterator that generates the numbers in the range on demand."); +Return an arithmetic progression of numbers from start " + "to stop (exclusive) by step."); static void range_dealloc(rangeobject *r) @@ -107,17 +118,12 @@ Py_DECREF(r->start); Py_DECREF(r->stop); Py_DECREF(r->step); + Py_DECREF(r->length); PyObject_Del(r); } -/* Return number of items in range (lo, hi, step), when arguments are - * PyInt or PyLong objects. step > 0 required. Return a value < 0 if - * & only if the true value is too large to fit in a signed long. - * Arguments MUST return 1 with either PyLong_Check() or - * PyLong_Check(). Return -1 when there is an error. - */ -static PyObject* -range_length_obj(rangeobject *r) +static PyObject * +range_compute_length(PyObject *start, PyObject *stop, PyObject *step) { /* ------------------------------------------------------------- Algorithm is equal to that of get_len_of_range(), but it operates @@ -125,7 +131,6 @@ ---------------------------------------------------------------*/ int cmp_result, cmp_call; PyObject *lo, *hi; - PyObject *step = NULL; PyObject *diff = NULL; PyObject *one = NULL; PyObject *tmp1 = NULL, *tmp2 = NULL, *result; @@ -134,23 +139,22 @@ PyObject *zero = PyLong_FromLong(0); if (zero == NULL) return NULL; - cmp_call = PyObject_Cmp(r->step, zero, &cmp_result); + cmp_call = PyObject_Cmp(step, zero, &cmp_result); Py_DECREF(zero); if (cmp_call == -1) return NULL; assert(cmp_result != 0); if (cmp_result > 0) { - lo = r->start; - hi = r->stop; - step = r->step; + lo = start; + hi = stop; Py_INCREF(step); } else { - lo = r->stop; - hi = r->start; - step = PyNumber_Negative(r->step); + lo = stop; + hi = start; + step = PyNumber_Negative(step); if (!step) - return NULL; + goto Fail; } /* if (lo >= hi), return length of 0. */ @@ -190,48 +194,18 @@ return NULL; } -static Py_ssize_t -range_length(rangeobject *r) +static PyObject * +range_length_hint(rangeobject *r) { - PyObject *len = range_length_obj(r); - Py_ssize_t result = -1; - if (len) { - result = PyLong_AsSsize_t(len); - Py_DECREF(len); - } - return result; + Py_INCREF(r->length); + return r->length; } -/* range(...)[x] is necessary for: seq[:] = range(...) */ +PyDoc_STRVAR(range_length_hint_doc, +"__length_hint__() -> int\n" +"Return a estimate of len(list(range))."); -static PyObject * -range_item(rangeobject *r, Py_ssize_t i) -{ - Py_ssize_t len = range_length(r); - PyObject *rem, *incr, *result; - /* XXX(nnorwitz): should negative indices be supported? */ - /* XXX(nnorwitz): should support range[x] where x > PY_SSIZE_T_MAX? */ - if (i < 0 || i >= len) { - if (!PyErr_Occurred()) - PyErr_SetString(PyExc_IndexError, - "range object index out of range"); - return NULL; - } - - /* XXX(nnorwitz): optimize for short ints. */ - rem = PyLong_FromSsize_t(i); - if (!rem) - return NULL; - incr = PyNumber_Multiply(rem, r->step); - Py_DECREF(rem); - if (!incr) - return NULL; - result = PyNumber_Add(r->start, incr); - Py_DECREF(incr); - return result; -} - static PyObject * range_repr(rangeobject *r) { @@ -252,12 +226,11 @@ r->start, r->stop, r->step); } -static PySequenceMethods range_as_sequence = { - (lenfunc)range_length, /* sq_length */ - 0, /* sq_concat */ - 0, /* sq_repeat */ - (ssizeargfunc)range_item, /* sq_item */ - 0, /* sq_slice */ +static PyMemberDef range_members[] = { + {"start", T_OBJECT, offsetof(rangeobject, start), READONLY}, + {"stop", T_OBJECT, offsetof(rangeobject, stop), READONLY}, + {"step", T_OBJECT, offsetof(rangeobject, step), READONLY}, + {0} }; static PyObject * range_iter(PyObject *seq); @@ -269,6 +242,8 @@ static PyMethodDef range_methods[] = { {"__reversed__", (PyCFunction)range_reverse, METH_NOARGS, reverse_doc}, + {"__length_hint__", (PyCFunction)range_length_hint, METH_NOARGS, + range_length_hint_doc}, {NULL, NULL} /* sentinel */ }; @@ -284,8 +259,8 @@ 0, /* tp_compare */ (reprfunc)range_repr, /* tp_repr */ 0, /* tp_as_number */ - &range_as_sequence, /* tp_as_sequence */ - 0, /* tp_as_mapping */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ 0, /* tp_hash */ 0, /* tp_call */ 0, /* tp_str */ @@ -301,8 +276,8 @@ range_iter, /* tp_iter */ 0, /* tp_iternext */ range_methods, /* tp_methods */ - 0, /* tp_members */ - 0, /* tp_getset */ + range_members, /* tp_members */ + 0, /* tp_getset */ 0, /* tp_base */ 0, /* tp_dict */ 0, /* tp_descr_get */ @@ -347,13 +322,13 @@ PyObject *index; PyObject *start; PyObject *step; - PyObject *len; + PyObject *length; } longrangeiterobject; static PyObject * longrangeiter_len(longrangeiterobject *r, PyObject *no_args) { - return PyNumber_Subtract(r->len, r->index); + return PyNumber_Subtract(r->length, r->index); } static PyObject *rangeiter_new(PyTypeObject *, PyObject *args, PyObject *kw); @@ -481,7 +456,7 @@ Py_XDECREF(r->index); Py_XDECREF(r->start); Py_XDECREF(r->step); - Py_XDECREF(r->len); + Py_XDECREF(r->length); PyObject_Del(r); } @@ -489,7 +464,7 @@ longrangeiter_next(longrangeiterobject *r) { PyObject *one, *product, *new_index, *result; - if (PyObject_RichCompareBool(r->index, r->len, Py_LT) != 1) + if (PyObject_RichCompareBool(r->index, r->length, Py_LT) != 1) return NULL; one = PyLong_FromLong(1); @@ -557,7 +532,6 @@ { rangeobject *r = (rangeobject *)seq; longrangeiterobject *it; - PyObject *tmp, *len; long lstart, lstop, lstep; assert(PyRange_Check(seq)); @@ -586,17 +560,8 @@ Py_INCREF(it->start); Py_INCREF(it->step); - it->len = it->index = NULL; - - /* Calculate length: (r->stop - r->start) / r->step */ - tmp = PyNumber_Subtract(r->stop, r->start); - if (!tmp) - goto create_failure; - len = PyNumber_FloorDivide(tmp, r->step); - Py_DECREF(tmp); - if (!len) - goto create_failure; - it->len = len; + Py_INCREF(r->length); + it->length = r->length; it->index = PyLong_FromLong(0); if (!it->index) goto create_failure; @@ -647,9 +612,8 @@ return NULL; /* start + (len - 1) * step */ - len = range_length_obj(range); - if (!len) - goto create_failure; + Py_INCREF(range->length); + len = range->length; one = PyLong_FromLong(1); if (!one) @@ -677,7 +641,7 @@ } /* Steal reference to len. */ - it->len = len; + it->length = len; it->index = PyLong_FromLong(0); if (!it->index) { Index: Lib/test/test_range.py =================================================================== --- Lib/test/test_range.py (revision 62635) +++ Lib/test/test_range.py (working copy) @@ -51,16 +51,25 @@ self.assertRaises(TypeError, range, 0, "spam") self.assertRaises(TypeError, range, 0, 42, "spam") - self.assertEqual(len(range(0, sys.maxsize, sys.maxsize-1)), 2) - - r = range(-sys.maxsize, sys.maxsize, 2) - self.assertEqual(len(r), sys.maxsize) - def test_repr(self): self.assertEqual(repr(range(1)), 'range(0, 1)') self.assertEqual(repr(range(1, 2)), 'range(1, 2)') self.assertEqual(repr(range(1, 2, 3)), 'range(1, 2, 3)') + def test_attributes(self): + r = range(0, 10, 2) + self.assertEqual(r.start, 0) + self.assertEqual(r.stop, 10) + self.assertEqual(r.step, 2) + r = range(10) + self.assertEqual(r.start, 0) + self.assertEqual(r.stop, 10) + self.assertEqual(r.step, 1) + r = range(10, 0, 4) + self.assertEqual(r.start, 10) + self.assertEqual(r.stop, 0) + self.assertEqual(r.step, 4) + def test_main(): test.test_support.run_unittest(RangeTest) Index: Lib/test/test_builtin.py =================================================================== --- Lib/test/test_builtin.py (revision 62635) +++ Lib/test/test_builtin.py (working copy) @@ -1593,8 +1593,6 @@ #NEAL self.assertRaises(OverflowError, range, -sys.maxsize, sys.maxsize) #NEAL self.assertRaises(OverflowError, range, 0, 2*sys.maxsize) - self.assertRaises(OverflowError, len, range(0, sys.maxsize**10)) - def test_input(self): self.write_testfile() fp = open(TESTFN, 'r')