Iterators phase 1. This comprises:
new slot tp_iter in type object, plus new flag Py_TPFLAGS_HAVE_ITER
new C API PyObject_GetIter(), calls tp_iter
new builtin iter(), with two forms: iter(obj), and iter(function, sentinel)
new internal object types iterobject and calliterobject
new exception StopIteration
new opcodes for "for" loops, GET_ITER and FOR_ITER (also supported by dis.py)
new magic number for .pyc files
new special method for instances: __iter__() returns an iterator
iteration over dictionaries: "for x in dict" iterates over the keys
iteration over files: "for x in file" iterates over lines
TODO:
documentation
test suite
decide whether to use a different way to spell iter(function, sentinal)
decide whether "for key in dict" is a good idea
use iterators in map/filter/reduce, min/max, and elsewhere (in/not in?)
speed tuning (make next() a slot tp_next???)
diff --git a/Objects/abstract.c b/Objects/abstract.c
index 3ccac71..8a6df76 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -1738,3 +1738,20 @@
return retval;
}
+
+PyObject *
+PyObject_GetIter(PyObject *o)
+{
+ PyTypeObject *t = o->ob_type;
+ getiterfunc f = NULL;
+ if (PyType_HasFeature(t, Py_TPFLAGS_HAVE_ITER))
+ f = t->tp_iter;
+ if (f == NULL) {
+ if (PySequence_Check(o))
+ return PyIter_New(o);
+ PyErr_SetString(PyExc_TypeError, "iter() of non-sequence");
+ return NULL;
+ }
+ else
+ return (*f)(o);
+}
diff --git a/Objects/classobject.c b/Objects/classobject.c
index fa71c4e..742e472 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -848,7 +848,7 @@
return 0;
}
-static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;
+static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr, *iterstr;
static int
instance_length(PyInstanceObject *inst)
@@ -1712,6 +1712,32 @@
}
+/* Get the iterator */
+static PyObject *
+instance_getiter(PyInstanceObject *self)
+{
+ PyObject *func;
+
+ if (iterstr == NULL)
+ iterstr = PyString_InternFromString("__iter__");
+ if (getitemstr == NULL)
+ getitemstr = PyString_InternFromString("__getitem__");
+
+ if ((func = instance_getattr(self, iterstr)) != NULL) {
+ PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ return res;
+ }
+ PyErr_Clear();
+ if ((func = instance_getattr(self, getitemstr)) == NULL) {
+ PyErr_SetString(PyExc_TypeError, "iter() of non-sequence");
+ return NULL;
+ }
+ Py_DECREF(func);
+ return PyIter_New((PyObject *)self);
+}
+
+
static PyNumberMethods instance_as_number = {
(binaryfunc)instance_add, /* nb_add */
(binaryfunc)instance_sub, /* nb_subtract */
@@ -1775,7 +1801,8 @@
(traverseproc)instance_traverse, /* tp_traverse */
0, /* tp_clear */
instance_richcompare, /* tp_richcompare */
- offsetof(PyInstanceObject, in_weakreflist) /* tp_weaklistoffset */
+ offsetof(PyInstanceObject, in_weakreflist), /* tp_weaklistoffset */
+ (getiterfunc)instance_getiter, /* tp_iter */
};
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 95d5b71..17b6a04 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -1324,6 +1324,8 @@
0, /* sq_inplace_repeat */
};
+staticforward PyObject *dictiter_new(dictobject *);
+
PyTypeObject PyDict_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
@@ -1350,6 +1352,8 @@
(traverseproc)dict_traverse, /* tp_traverse */
(inquiry)dict_tp_clear, /* tp_clear */
0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ (getiterfunc)dictiter_new, /* tp_iter */
};
/* For backward compatibility with old dictionary interface */
@@ -1392,3 +1396,102 @@
Py_DECREF(kv);
return err;
}
+
+/* Dictionary iterator type */
+
+extern PyTypeObject PyDictIter_Type; /* Forward */
+
+typedef struct {
+ PyObject_HEAD
+ dictobject *di_dict;
+ int di_size;
+ int di_pos;
+} dictiterobject;
+
+static PyObject *
+dictiter_new(dictobject *dict)
+{
+ dictiterobject *di;
+ di = PyObject_NEW(dictiterobject, &PyDictIter_Type);
+ if (di == NULL)
+ return NULL;
+ Py_INCREF(dict);
+ di->di_dict = dict;
+ di->di_size = dict->ma_size;
+ di->di_pos = 0;
+ return (PyObject *)di;
+}
+
+static void
+dictiter_dealloc(dictiterobject *di)
+{
+ Py_DECREF(di->di_dict);
+ PyObject_DEL(di);
+}
+
+static PyObject *
+dictiter_next(dictiterobject *di, PyObject *args)
+{
+ PyObject *key;
+ if (di->di_size != di->di_dict->ma_size) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "dictionary changed size during iteration");
+ return NULL;
+ }
+ if (PyDict_Next((PyObject *)(di->di_dict), &di->di_pos, &key, NULL)) {
+ Py_INCREF(key);
+ return key;
+ }
+ PyErr_SetObject(PyExc_StopIteration, Py_None);
+ return NULL;
+}
+
+static PyObject *
+dictiter_getiter(PyObject *it)
+{
+ Py_INCREF(it);
+ return it;
+}
+
+static PyMethodDef dictiter_methods[] = {
+ {"next", (PyCFunction)dictiter_next, METH_VARARGS,
+ "it.next() -- get the next value, or raise StopIteration"},
+ {NULL, NULL} /* sentinel */
+};
+
+static PyObject *
+dictiter_getattr(dictiterobject *it, char *name)
+{
+ return Py_FindMethod(dictiter_methods, (PyObject *)it, name);
+}
+
+PyTypeObject PyDictIter_Type = {
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0, /* ob_size */
+ "dictionary-iterator", /* tp_name */
+ sizeof(dictiterobject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ /* methods */
+ (destructor)dictiter_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ (getattrfunc)dictiter_getattr, /* 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 */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
+ 0, /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ (getiterfunc)dictiter_getiter, /* tp_iter */
+};
diff --git a/Objects/stringobject.c b/Objects/stringobject.c
index 1701b2f..861cade 100644
--- a/Objects/stringobject.c
+++ b/Objects/stringobject.c
@@ -3232,6 +3232,8 @@
void _Py_ReleaseInternedStrings(void)
{
if (interned) {
+ fprintf(stderr, "releasing interned strings\n");
+ PyDict_Clear(interned);
Py_DECREF(interned);
interned = NULL;
}