Untabify C files. Will watch buildbots.
diff --git a/Objects/classobject.c b/Objects/classobject.c
index 032d354..0832531 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -18,7 +18,7 @@
/* Forward */
static PyObject *class_lookup(PyClassObject *, PyObject *,
- PyClassObject **);
+ PyClassObject **);
static PyObject *instance_getattr1(PyInstanceObject *, PyObject *);
static PyObject *instance_getattr2(PyInstanceObject *, PyObject *);
@@ -29,140 +29,140 @@
PyClass_New(PyObject *bases, PyObject *dict, PyObject *name)
/* bases is NULL or tuple of classobjects! */
{
- PyClassObject *op, *dummy;
- static PyObject *docstr, *modstr, *namestr;
- if (docstr == NULL) {
- docstr= PyString_InternFromString("__doc__");
- if (docstr == NULL)
- return NULL;
- }
- if (modstr == NULL) {
- modstr= PyString_InternFromString("__module__");
- if (modstr == NULL)
- return NULL;
- }
- if (namestr == NULL) {
- namestr= PyString_InternFromString("__name__");
- if (namestr == NULL)
- return NULL;
- }
- if (name == NULL || !PyString_Check(name)) {
- PyErr_SetString(PyExc_TypeError,
- "PyClass_New: name must be a string");
- return NULL;
- }
- if (dict == NULL || !PyDict_Check(dict)) {
- PyErr_SetString(PyExc_TypeError,
- "PyClass_New: dict must be a dictionary");
- return NULL;
- }
- if (PyDict_GetItem(dict, docstr) == NULL) {
- if (PyDict_SetItem(dict, docstr, Py_None) < 0)
- return NULL;
- }
- if (PyDict_GetItem(dict, modstr) == NULL) {
- PyObject *globals = PyEval_GetGlobals();
- if (globals != NULL) {
- PyObject *modname = PyDict_GetItem(globals, namestr);
- if (modname != NULL) {
- if (PyDict_SetItem(dict, modstr, modname) < 0)
- return NULL;
- }
- }
- }
- if (bases == NULL) {
- bases = PyTuple_New(0);
- if (bases == NULL)
- return NULL;
- }
- else {
- Py_ssize_t i, n;
- PyObject *base;
- if (!PyTuple_Check(bases)) {
- PyErr_SetString(PyExc_TypeError,
- "PyClass_New: bases must be a tuple");
- return NULL;
- }
- n = PyTuple_Size(bases);
- for (i = 0; i < n; i++) {
- base = PyTuple_GET_ITEM(bases, i);
- if (!PyClass_Check(base)) {
- if (PyCallable_Check(
- (PyObject *) base->ob_type))
- return PyObject_CallFunctionObjArgs(
- (PyObject *) base->ob_type,
- name, bases, dict, NULL);
- PyErr_SetString(PyExc_TypeError,
- "PyClass_New: base must be a class");
- return NULL;
- }
- }
- Py_INCREF(bases);
- }
+ PyClassObject *op, *dummy;
+ static PyObject *docstr, *modstr, *namestr;
+ if (docstr == NULL) {
+ docstr= PyString_InternFromString("__doc__");
+ if (docstr == NULL)
+ return NULL;
+ }
+ if (modstr == NULL) {
+ modstr= PyString_InternFromString("__module__");
+ if (modstr == NULL)
+ return NULL;
+ }
+ if (namestr == NULL) {
+ namestr= PyString_InternFromString("__name__");
+ if (namestr == NULL)
+ return NULL;
+ }
+ if (name == NULL || !PyString_Check(name)) {
+ PyErr_SetString(PyExc_TypeError,
+ "PyClass_New: name must be a string");
+ return NULL;
+ }
+ if (dict == NULL || !PyDict_Check(dict)) {
+ PyErr_SetString(PyExc_TypeError,
+ "PyClass_New: dict must be a dictionary");
+ return NULL;
+ }
+ if (PyDict_GetItem(dict, docstr) == NULL) {
+ if (PyDict_SetItem(dict, docstr, Py_None) < 0)
+ return NULL;
+ }
+ if (PyDict_GetItem(dict, modstr) == NULL) {
+ PyObject *globals = PyEval_GetGlobals();
+ if (globals != NULL) {
+ PyObject *modname = PyDict_GetItem(globals, namestr);
+ if (modname != NULL) {
+ if (PyDict_SetItem(dict, modstr, modname) < 0)
+ return NULL;
+ }
+ }
+ }
+ if (bases == NULL) {
+ bases = PyTuple_New(0);
+ if (bases == NULL)
+ return NULL;
+ }
+ else {
+ Py_ssize_t i, n;
+ PyObject *base;
+ if (!PyTuple_Check(bases)) {
+ PyErr_SetString(PyExc_TypeError,
+ "PyClass_New: bases must be a tuple");
+ return NULL;
+ }
+ n = PyTuple_Size(bases);
+ for (i = 0; i < n; i++) {
+ base = PyTuple_GET_ITEM(bases, i);
+ if (!PyClass_Check(base)) {
+ if (PyCallable_Check(
+ (PyObject *) base->ob_type))
+ return PyObject_CallFunctionObjArgs(
+ (PyObject *) base->ob_type,
+ name, bases, dict, NULL);
+ PyErr_SetString(PyExc_TypeError,
+ "PyClass_New: base must be a class");
+ return NULL;
+ }
+ }
+ Py_INCREF(bases);
+ }
- if (getattrstr == NULL) {
- getattrstr = PyString_InternFromString("__getattr__");
- if (getattrstr == NULL)
- goto alloc_error;
- setattrstr = PyString_InternFromString("__setattr__");
- if (setattrstr == NULL)
- goto alloc_error;
- delattrstr = PyString_InternFromString("__delattr__");
- if (delattrstr == NULL)
- goto alloc_error;
- }
+ if (getattrstr == NULL) {
+ getattrstr = PyString_InternFromString("__getattr__");
+ if (getattrstr == NULL)
+ goto alloc_error;
+ setattrstr = PyString_InternFromString("__setattr__");
+ if (setattrstr == NULL)
+ goto alloc_error;
+ delattrstr = PyString_InternFromString("__delattr__");
+ if (delattrstr == NULL)
+ goto alloc_error;
+ }
- op = PyObject_GC_New(PyClassObject, &PyClass_Type);
- if (op == NULL) {
+ op = PyObject_GC_New(PyClassObject, &PyClass_Type);
+ if (op == NULL) {
alloc_error:
- Py_DECREF(bases);
- return NULL;
- }
- op->cl_bases = bases;
- Py_INCREF(dict);
- op->cl_dict = dict;
- Py_XINCREF(name);
- op->cl_name = name;
- op->cl_weakreflist = NULL;
+ Py_DECREF(bases);
+ return NULL;
+ }
+ op->cl_bases = bases;
+ Py_INCREF(dict);
+ op->cl_dict = dict;
+ Py_XINCREF(name);
+ op->cl_name = name;
+ op->cl_weakreflist = NULL;
- op->cl_getattr = class_lookup(op, getattrstr, &dummy);
- op->cl_setattr = class_lookup(op, setattrstr, &dummy);
- op->cl_delattr = class_lookup(op, delattrstr, &dummy);
- Py_XINCREF(op->cl_getattr);
- Py_XINCREF(op->cl_setattr);
- Py_XINCREF(op->cl_delattr);
- _PyObject_GC_TRACK(op);
- return (PyObject *) op;
+ op->cl_getattr = class_lookup(op, getattrstr, &dummy);
+ op->cl_setattr = class_lookup(op, setattrstr, &dummy);
+ op->cl_delattr = class_lookup(op, delattrstr, &dummy);
+ Py_XINCREF(op->cl_getattr);
+ Py_XINCREF(op->cl_setattr);
+ Py_XINCREF(op->cl_delattr);
+ _PyObject_GC_TRACK(op);
+ return (PyObject *) op;
}
PyObject *
PyMethod_Function(PyObject *im)
{
- if (!PyMethod_Check(im)) {
- PyErr_BadInternalCall();
- return NULL;
- }
- return ((PyMethodObject *)im)->im_func;
+ if (!PyMethod_Check(im)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ return ((PyMethodObject *)im)->im_func;
}
PyObject *
PyMethod_Self(PyObject *im)
{
- if (!PyMethod_Check(im)) {
- PyErr_BadInternalCall();
- return NULL;
- }
- return ((PyMethodObject *)im)->im_self;
+ if (!PyMethod_Check(im)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ return ((PyMethodObject *)im)->im_self;
}
PyObject *
PyMethod_Class(PyObject *im)
{
- if (!PyMethod_Check(im)) {
- PyErr_BadInternalCall();
- return NULL;
- }
- return ((PyMethodObject *)im)->im_class;
+ if (!PyMethod_Check(im)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ return ((PyMethodObject *)im)->im_class;
}
PyDoc_STRVAR(class_doc,
@@ -174,13 +174,13 @@
static PyObject *
class_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
- PyObject *name, *bases, *dict;
- static char *kwlist[] = {"name", "bases", "dict", 0};
+ PyObject *name, *bases, *dict;
+ static char *kwlist[] = {"name", "bases", "dict", 0};
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "SOO", kwlist,
- &name, &bases, &dict))
- return NULL;
- return PyClass_New(bases, dict, name);
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "SOO", kwlist,
+ &name, &bases, &dict))
+ return NULL;
+ return PyClass_New(bases, dict, name);
}
/* Class methods */
@@ -188,315 +188,315 @@
static void
class_dealloc(PyClassObject *op)
{
- _PyObject_GC_UNTRACK(op);
- if (op->cl_weakreflist != NULL)
- PyObject_ClearWeakRefs((PyObject *) op);
- Py_DECREF(op->cl_bases);
- Py_DECREF(op->cl_dict);
- Py_XDECREF(op->cl_name);
- Py_XDECREF(op->cl_getattr);
- Py_XDECREF(op->cl_setattr);
- Py_XDECREF(op->cl_delattr);
- PyObject_GC_Del(op);
+ _PyObject_GC_UNTRACK(op);
+ if (op->cl_weakreflist != NULL)
+ PyObject_ClearWeakRefs((PyObject *) op);
+ Py_DECREF(op->cl_bases);
+ Py_DECREF(op->cl_dict);
+ Py_XDECREF(op->cl_name);
+ Py_XDECREF(op->cl_getattr);
+ Py_XDECREF(op->cl_setattr);
+ Py_XDECREF(op->cl_delattr);
+ PyObject_GC_Del(op);
}
static PyObject *
class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass)
{
- Py_ssize_t i, n;
- PyObject *value = PyDict_GetItem(cp->cl_dict, name);
- if (value != NULL) {
- *pclass = cp;
- return value;
- }
- n = PyTuple_Size(cp->cl_bases);
- for (i = 0; i < n; i++) {
- /* XXX What if one of the bases is not a class? */
- PyObject *v = class_lookup(
- (PyClassObject *)
- PyTuple_GetItem(cp->cl_bases, i), name, pclass);
- if (v != NULL)
- return v;
- }
- return NULL;
+ Py_ssize_t i, n;
+ PyObject *value = PyDict_GetItem(cp->cl_dict, name);
+ if (value != NULL) {
+ *pclass = cp;
+ return value;
+ }
+ n = PyTuple_Size(cp->cl_bases);
+ for (i = 0; i < n; i++) {
+ /* XXX What if one of the bases is not a class? */
+ PyObject *v = class_lookup(
+ (PyClassObject *)
+ PyTuple_GetItem(cp->cl_bases, i), name, pclass);
+ if (v != NULL)
+ return v;
+ }
+ return NULL;
}
static PyObject *
class_getattr(register PyClassObject *op, PyObject *name)
{
- register PyObject *v;
- register char *sname = PyString_AsString(name);
- PyClassObject *klass;
- descrgetfunc f;
+ register PyObject *v;
+ register char *sname = PyString_AsString(name);
+ PyClassObject *klass;
+ descrgetfunc f;
- if (sname[0] == '_' && sname[1] == '_') {
- if (strcmp(sname, "__dict__") == 0) {
- if (PyEval_GetRestricted()) {
- PyErr_SetString(PyExc_RuntimeError,
- "class.__dict__ not accessible in restricted mode");
- return NULL;
- }
- Py_INCREF(op->cl_dict);
- return op->cl_dict;
- }
- if (strcmp(sname, "__bases__") == 0) {
- Py_INCREF(op->cl_bases);
- return op->cl_bases;
- }
- if (strcmp(sname, "__name__") == 0) {
- if (op->cl_name == NULL)
- v = Py_None;
- else
- v = op->cl_name;
- Py_INCREF(v);
- return v;
- }
- }
- v = class_lookup(op, name, &klass);
- if (v == NULL) {
- PyErr_Format(PyExc_AttributeError,
- "class %.50s has no attribute '%.400s'",
- PyString_AS_STRING(op->cl_name), sname);
- return NULL;
- }
- f = TP_DESCR_GET(v->ob_type);
- if (f == NULL)
- Py_INCREF(v);
- else
- v = f(v, (PyObject *)NULL, (PyObject *)op);
- return v;
+ if (sname[0] == '_' && sname[1] == '_') {
+ if (strcmp(sname, "__dict__") == 0) {
+ if (PyEval_GetRestricted()) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "class.__dict__ not accessible in restricted mode");
+ return NULL;
+ }
+ Py_INCREF(op->cl_dict);
+ return op->cl_dict;
+ }
+ if (strcmp(sname, "__bases__") == 0) {
+ Py_INCREF(op->cl_bases);
+ return op->cl_bases;
+ }
+ if (strcmp(sname, "__name__") == 0) {
+ if (op->cl_name == NULL)
+ v = Py_None;
+ else
+ v = op->cl_name;
+ Py_INCREF(v);
+ return v;
+ }
+ }
+ v = class_lookup(op, name, &klass);
+ if (v == NULL) {
+ PyErr_Format(PyExc_AttributeError,
+ "class %.50s has no attribute '%.400s'",
+ PyString_AS_STRING(op->cl_name), sname);
+ return NULL;
+ }
+ f = TP_DESCR_GET(v->ob_type);
+ if (f == NULL)
+ Py_INCREF(v);
+ else
+ v = f(v, (PyObject *)NULL, (PyObject *)op);
+ return v;
}
static void
set_slot(PyObject **slot, PyObject *v)
{
- PyObject *temp = *slot;
- Py_XINCREF(v);
- *slot = v;
- Py_XDECREF(temp);
+ PyObject *temp = *slot;
+ Py_XINCREF(v);
+ *slot = v;
+ Py_XDECREF(temp);
}
static void
set_attr_slots(PyClassObject *c)
{
- PyClassObject *dummy;
+ PyClassObject *dummy;
- set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));
- set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));
- set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));
+ set_slot(&c->cl_getattr, class_lookup(c, getattrstr, &dummy));
+ set_slot(&c->cl_setattr, class_lookup(c, setattrstr, &dummy));
+ set_slot(&c->cl_delattr, class_lookup(c, delattrstr, &dummy));
}
static char *
set_dict(PyClassObject *c, PyObject *v)
{
- if (v == NULL || !PyDict_Check(v))
- return "__dict__ must be a dictionary object";
- set_slot(&c->cl_dict, v);
- set_attr_slots(c);
- return "";
+ if (v == NULL || !PyDict_Check(v))
+ return "__dict__ must be a dictionary object";
+ set_slot(&c->cl_dict, v);
+ set_attr_slots(c);
+ return "";
}
static char *
set_bases(PyClassObject *c, PyObject *v)
{
- Py_ssize_t i, n;
+ Py_ssize_t i, n;
- if (v == NULL || !PyTuple_Check(v))
- return "__bases__ must be a tuple object";
- n = PyTuple_Size(v);
- for (i = 0; i < n; i++) {
- PyObject *x = PyTuple_GET_ITEM(v, i);
- if (!PyClass_Check(x))
- return "__bases__ items must be classes";
- if (PyClass_IsSubclass(x, (PyObject *)c))
- return "a __bases__ item causes an inheritance cycle";
- }
- set_slot(&c->cl_bases, v);
- set_attr_slots(c);
- return "";
+ if (v == NULL || !PyTuple_Check(v))
+ return "__bases__ must be a tuple object";
+ n = PyTuple_Size(v);
+ for (i = 0; i < n; i++) {
+ PyObject *x = PyTuple_GET_ITEM(v, i);
+ if (!PyClass_Check(x))
+ return "__bases__ items must be classes";
+ if (PyClass_IsSubclass(x, (PyObject *)c))
+ return "a __bases__ item causes an inheritance cycle";
+ }
+ set_slot(&c->cl_bases, v);
+ set_attr_slots(c);
+ return "";
}
static char *
set_name(PyClassObject *c, PyObject *v)
{
- if (v == NULL || !PyString_Check(v))
- return "__name__ must be a string object";
- if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
- return "__name__ must not contain null bytes";
- set_slot(&c->cl_name, v);
- return "";
+ if (v == NULL || !PyString_Check(v))
+ return "__name__ must be a string object";
+ if (strlen(PyString_AS_STRING(v)) != (size_t)PyString_GET_SIZE(v))
+ return "__name__ must not contain null bytes";
+ set_slot(&c->cl_name, v);
+ return "";
}
static int
class_setattr(PyClassObject *op, PyObject *name, PyObject *v)
{
- char *sname;
- if (PyEval_GetRestricted()) {
- PyErr_SetString(PyExc_RuntimeError,
- "classes are read-only in restricted mode");
- return -1;
- }
- sname = PyString_AsString(name);
- if (sname[0] == '_' && sname[1] == '_') {
- Py_ssize_t n = PyString_Size(name);
- if (sname[n-1] == '_' && sname[n-2] == '_') {
- char *err = NULL;
- if (strcmp(sname, "__dict__") == 0)
- err = set_dict(op, v);
- else if (strcmp(sname, "__bases__") == 0)
- err = set_bases(op, v);
- else if (strcmp(sname, "__name__") == 0)
- err = set_name(op, v);
- else if (strcmp(sname, "__getattr__") == 0)
- set_slot(&op->cl_getattr, v);
- else if (strcmp(sname, "__setattr__") == 0)
- set_slot(&op->cl_setattr, v);
- else if (strcmp(sname, "__delattr__") == 0)
- set_slot(&op->cl_delattr, v);
- /* For the last three, we fall through to update the
- dictionary as well. */
- if (err != NULL) {
- if (*err == '\0')
- return 0;
- PyErr_SetString(PyExc_TypeError, err);
- return -1;
- }
- }
- }
- if (v == NULL) {
- int rv = PyDict_DelItem(op->cl_dict, name);
- if (rv < 0)
- PyErr_Format(PyExc_AttributeError,
- "class %.50s has no attribute '%.400s'",
- PyString_AS_STRING(op->cl_name), sname);
- return rv;
- }
- else
- return PyDict_SetItem(op->cl_dict, name, v);
+ char *sname;
+ if (PyEval_GetRestricted()) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "classes are read-only in restricted mode");
+ return -1;
+ }
+ sname = PyString_AsString(name);
+ if (sname[0] == '_' && sname[1] == '_') {
+ Py_ssize_t n = PyString_Size(name);
+ if (sname[n-1] == '_' && sname[n-2] == '_') {
+ char *err = NULL;
+ if (strcmp(sname, "__dict__") == 0)
+ err = set_dict(op, v);
+ else if (strcmp(sname, "__bases__") == 0)
+ err = set_bases(op, v);
+ else if (strcmp(sname, "__name__") == 0)
+ err = set_name(op, v);
+ else if (strcmp(sname, "__getattr__") == 0)
+ set_slot(&op->cl_getattr, v);
+ else if (strcmp(sname, "__setattr__") == 0)
+ set_slot(&op->cl_setattr, v);
+ else if (strcmp(sname, "__delattr__") == 0)
+ set_slot(&op->cl_delattr, v);
+ /* For the last three, we fall through to update the
+ dictionary as well. */
+ if (err != NULL) {
+ if (*err == '\0')
+ return 0;
+ PyErr_SetString(PyExc_TypeError, err);
+ return -1;
+ }
+ }
+ }
+ if (v == NULL) {
+ int rv = PyDict_DelItem(op->cl_dict, name);
+ if (rv < 0)
+ PyErr_Format(PyExc_AttributeError,
+ "class %.50s has no attribute '%.400s'",
+ PyString_AS_STRING(op->cl_name), sname);
+ return rv;
+ }
+ else
+ return PyDict_SetItem(op->cl_dict, name, v);
}
static PyObject *
class_repr(PyClassObject *op)
{
- PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
- char *name;
- if (op->cl_name == NULL || !PyString_Check(op->cl_name))
- name = "?";
- else
- name = PyString_AsString(op->cl_name);
- if (mod == NULL || !PyString_Check(mod))
- return PyString_FromFormat("<class ?.%s at %p>", name, op);
- else
- return PyString_FromFormat("<class %s.%s at %p>",
- PyString_AsString(mod),
- name, op);
+ PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
+ char *name;
+ if (op->cl_name == NULL || !PyString_Check(op->cl_name))
+ name = "?";
+ else
+ name = PyString_AsString(op->cl_name);
+ if (mod == NULL || !PyString_Check(mod))
+ return PyString_FromFormat("<class ?.%s at %p>", name, op);
+ else
+ return PyString_FromFormat("<class %s.%s at %p>",
+ PyString_AsString(mod),
+ name, op);
}
static PyObject *
class_str(PyClassObject *op)
{
- PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
- PyObject *name = op->cl_name;
- PyObject *res;
- Py_ssize_t m, n;
+ PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
+ PyObject *name = op->cl_name;
+ PyObject *res;
+ Py_ssize_t m, n;
- if (name == NULL || !PyString_Check(name))
- return class_repr(op);
- if (mod == NULL || !PyString_Check(mod)) {
- Py_INCREF(name);
- return name;
- }
- m = PyString_GET_SIZE(mod);
- n = PyString_GET_SIZE(name);
- res = PyString_FromStringAndSize((char *)NULL, m+1+n);
- if (res != NULL) {
- char *s = PyString_AS_STRING(res);
- memcpy(s, PyString_AS_STRING(mod), m);
- s += m;
- *s++ = '.';
- memcpy(s, PyString_AS_STRING(name), n);
- }
- return res;
+ if (name == NULL || !PyString_Check(name))
+ return class_repr(op);
+ if (mod == NULL || !PyString_Check(mod)) {
+ Py_INCREF(name);
+ return name;
+ }
+ m = PyString_GET_SIZE(mod);
+ n = PyString_GET_SIZE(name);
+ res = PyString_FromStringAndSize((char *)NULL, m+1+n);
+ if (res != NULL) {
+ char *s = PyString_AS_STRING(res);
+ memcpy(s, PyString_AS_STRING(mod), m);
+ s += m;
+ *s++ = '.';
+ memcpy(s, PyString_AS_STRING(name), n);
+ }
+ return res;
}
static int
class_traverse(PyClassObject *o, visitproc visit, void *arg)
{
- Py_VISIT(o->cl_bases);
- Py_VISIT(o->cl_dict);
- Py_VISIT(o->cl_name);
- Py_VISIT(o->cl_getattr);
- Py_VISIT(o->cl_setattr);
- Py_VISIT(o->cl_delattr);
- return 0;
+ Py_VISIT(o->cl_bases);
+ Py_VISIT(o->cl_dict);
+ Py_VISIT(o->cl_name);
+ Py_VISIT(o->cl_getattr);
+ Py_VISIT(o->cl_setattr);
+ Py_VISIT(o->cl_delattr);
+ return 0;
}
PyTypeObject PyClass_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
- 0,
- "classobj",
- sizeof(PyClassObject),
- 0,
- (destructor)class_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- 0, /* tp_getattr */
- 0, /* tp_setattr */
- 0, /* tp_compare */
- (reprfunc)class_repr, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- 0, /* tp_hash */
- PyInstance_New, /* tp_call */
- (reprfunc)class_str, /* tp_str */
- (getattrofunc)class_getattr, /* tp_getattro */
- (setattrofunc)class_setattr, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
- class_doc, /* tp_doc */
- (traverseproc)class_traverse, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- offsetof(PyClassObject, cl_weakreflist), /* tp_weaklistoffset */
- 0, /* tp_iter */
- 0, /* tp_iternext */
- 0, /* 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 */
- class_new, /* tp_new */
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0,
+ "classobj",
+ sizeof(PyClassObject),
+ 0,
+ (destructor)class_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ (reprfunc)class_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ PyInstance_New, /* tp_call */
+ (reprfunc)class_str, /* tp_str */
+ (getattrofunc)class_getattr, /* tp_getattro */
+ (setattrofunc)class_setattr, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,/* tp_flags */
+ class_doc, /* tp_doc */
+ (traverseproc)class_traverse, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ offsetof(PyClassObject, cl_weakreflist), /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ 0, /* 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 */
+ class_new, /* tp_new */
};
int
PyClass_IsSubclass(PyObject *klass, PyObject *base)
{
- Py_ssize_t i, n;
- PyClassObject *cp;
- if (klass == base)
- return 1;
- if (PyTuple_Check(base)) {
- n = PyTuple_GET_SIZE(base);
- for (i = 0; i < n; i++) {
- if (PyClass_IsSubclass(klass, PyTuple_GET_ITEM(base, i)))
- return 1;
- }
- return 0;
- }
- if (klass == NULL || !PyClass_Check(klass))
- return 0;
- cp = (PyClassObject *)klass;
- n = PyTuple_Size(cp->cl_bases);
- for (i = 0; i < n; i++) {
- if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
- return 1;
- }
- return 0;
+ Py_ssize_t i, n;
+ PyClassObject *cp;
+ if (klass == base)
+ return 1;
+ if (PyTuple_Check(base)) {
+ n = PyTuple_GET_SIZE(base);
+ for (i = 0; i < n; i++) {
+ if (PyClass_IsSubclass(klass, PyTuple_GET_ITEM(base, i)))
+ return 1;
+ }
+ return 0;
+ }
+ if (klass == NULL || !PyClass_Check(klass))
+ return 0;
+ cp = (PyClassObject *)klass;
+ n = PyTuple_Size(cp->cl_bases);
+ for (i = 0; i < n; i++) {
+ if (PyClass_IsSubclass(PyTuple_GetItem(cp->cl_bases, i), base))
+ return 1;
+ }
+ return 0;
}
@@ -505,86 +505,86 @@
PyObject *
PyInstance_NewRaw(PyObject *klass, PyObject *dict)
{
- PyInstanceObject *inst;
+ PyInstanceObject *inst;
- if (!PyClass_Check(klass)) {
- PyErr_BadInternalCall();
- return NULL;
- }
- if (dict == NULL) {
- dict = PyDict_New();
- if (dict == NULL)
- return NULL;
- }
- else {
- if (!PyDict_Check(dict)) {
- PyErr_BadInternalCall();
- return NULL;
- }
- Py_INCREF(dict);
- }
- inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);
- if (inst == NULL) {
- Py_DECREF(dict);
- return NULL;
- }
- inst->in_weakreflist = NULL;
- Py_INCREF(klass);
- inst->in_class = (PyClassObject *)klass;
- inst->in_dict = dict;
- _PyObject_GC_TRACK(inst);
- return (PyObject *)inst;
+ if (!PyClass_Check(klass)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ if (dict == NULL) {
+ dict = PyDict_New();
+ if (dict == NULL)
+ return NULL;
+ }
+ else {
+ if (!PyDict_Check(dict)) {
+ PyErr_BadInternalCall();
+ return NULL;
+ }
+ Py_INCREF(dict);
+ }
+ inst = PyObject_GC_New(PyInstanceObject, &PyInstance_Type);
+ if (inst == NULL) {
+ Py_DECREF(dict);
+ return NULL;
+ }
+ inst->in_weakreflist = NULL;
+ Py_INCREF(klass);
+ inst->in_class = (PyClassObject *)klass;
+ inst->in_dict = dict;
+ _PyObject_GC_TRACK(inst);
+ return (PyObject *)inst;
}
PyObject *
PyInstance_New(PyObject *klass, PyObject *arg, PyObject *kw)
{
- register PyInstanceObject *inst;
- PyObject *init;
- static PyObject *initstr;
+ register PyInstanceObject *inst;
+ PyObject *init;
+ static PyObject *initstr;
- if (initstr == NULL) {
- initstr = PyString_InternFromString("__init__");
- if (initstr == NULL)
- return NULL;
- }
- inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);
- if (inst == NULL)
- return NULL;
- init = instance_getattr2(inst, initstr);
- if (init == NULL) {
- if (PyErr_Occurred()) {
- Py_DECREF(inst);
- return NULL;
- }
- if ((arg != NULL && (!PyTuple_Check(arg) ||
- PyTuple_Size(arg) != 0))
- || (kw != NULL && (!PyDict_Check(kw) ||
- PyDict_Size(kw) != 0))) {
- PyErr_SetString(PyExc_TypeError,
- "this constructor takes no arguments");
- Py_DECREF(inst);
- inst = NULL;
- }
- }
- else {
- PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
- Py_DECREF(init);
- if (res == NULL) {
- Py_DECREF(inst);
- inst = NULL;
- }
- else {
- if (res != Py_None) {
- PyErr_SetString(PyExc_TypeError,
- "__init__() should return None");
- Py_DECREF(inst);
- inst = NULL;
- }
- Py_DECREF(res);
- }
- }
- return (PyObject *)inst;
+ if (initstr == NULL) {
+ initstr = PyString_InternFromString("__init__");
+ if (initstr == NULL)
+ return NULL;
+ }
+ inst = (PyInstanceObject *) PyInstance_NewRaw(klass, NULL);
+ if (inst == NULL)
+ return NULL;
+ init = instance_getattr2(inst, initstr);
+ if (init == NULL) {
+ if (PyErr_Occurred()) {
+ Py_DECREF(inst);
+ return NULL;
+ }
+ if ((arg != NULL && (!PyTuple_Check(arg) ||
+ PyTuple_Size(arg) != 0))
+ || (kw != NULL && (!PyDict_Check(kw) ||
+ PyDict_Size(kw) != 0))) {
+ PyErr_SetString(PyExc_TypeError,
+ "this constructor takes no arguments");
+ Py_DECREF(inst);
+ inst = NULL;
+ }
+ }
+ else {
+ PyObject *res = PyEval_CallObjectWithKeywords(init, arg, kw);
+ Py_DECREF(init);
+ if (res == NULL) {
+ Py_DECREF(inst);
+ inst = NULL;
+ }
+ else {
+ if (res != Py_None) {
+ PyErr_SetString(PyExc_TypeError,
+ "__init__() should return None");
+ Py_DECREF(inst);
+ inst = NULL;
+ }
+ Py_DECREF(res);
+ }
+ }
+ return (PyObject *)inst;
}
/* Instance methods */
@@ -599,174 +599,174 @@
static PyObject *
instance_new(PyTypeObject* type, PyObject* args, PyObject *kw)
{
- PyObject *klass;
- PyObject *dict = Py_None;
+ PyObject *klass;
+ PyObject *dict = Py_None;
- if (!PyArg_ParseTuple(args, "O!|O:instance",
- &PyClass_Type, &klass, &dict))
- return NULL;
+ if (!PyArg_ParseTuple(args, "O!|O:instance",
+ &PyClass_Type, &klass, &dict))
+ return NULL;
- if (dict == Py_None)
- dict = NULL;
- else if (!PyDict_Check(dict)) {
- PyErr_SetString(PyExc_TypeError,
- "instance() second arg must be dictionary or None");
- return NULL;
- }
- return PyInstance_NewRaw(klass, dict);
+ if (dict == Py_None)
+ dict = NULL;
+ else if (!PyDict_Check(dict)) {
+ PyErr_SetString(PyExc_TypeError,
+ "instance() second arg must be dictionary or None");
+ return NULL;
+ }
+ return PyInstance_NewRaw(klass, dict);
}
static void
instance_dealloc(register PyInstanceObject *inst)
{
- PyObject *error_type, *error_value, *error_traceback;
- PyObject *del;
- static PyObject *delstr;
+ PyObject *error_type, *error_value, *error_traceback;
+ PyObject *del;
+ static PyObject *delstr;
- _PyObject_GC_UNTRACK(inst);
- if (inst->in_weakreflist != NULL)
- PyObject_ClearWeakRefs((PyObject *) inst);
+ _PyObject_GC_UNTRACK(inst);
+ if (inst->in_weakreflist != NULL)
+ PyObject_ClearWeakRefs((PyObject *) inst);
- /* Temporarily resurrect the object. */
- assert(inst->ob_type == &PyInstance_Type);
- assert(inst->ob_refcnt == 0);
- inst->ob_refcnt = 1;
+ /* Temporarily resurrect the object. */
+ assert(inst->ob_type == &PyInstance_Type);
+ assert(inst->ob_refcnt == 0);
+ inst->ob_refcnt = 1;
- /* Save the current exception, if any. */
- PyErr_Fetch(&error_type, &error_value, &error_traceback);
- /* Execute __del__ method, if any. */
- if (delstr == NULL) {
- delstr = PyString_InternFromString("__del__");
- if (delstr == NULL)
- PyErr_WriteUnraisable((PyObject*)inst);
- }
- if (delstr && (del = instance_getattr2(inst, delstr)) != NULL) {
- PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
- if (res == NULL)
- PyErr_WriteUnraisable(del);
- else
- Py_DECREF(res);
- Py_DECREF(del);
- }
- /* Restore the saved exception. */
- PyErr_Restore(error_type, error_value, error_traceback);
+ /* Save the current exception, if any. */
+ PyErr_Fetch(&error_type, &error_value, &error_traceback);
+ /* Execute __del__ method, if any. */
+ if (delstr == NULL) {
+ delstr = PyString_InternFromString("__del__");
+ if (delstr == NULL)
+ PyErr_WriteUnraisable((PyObject*)inst);
+ }
+ if (delstr && (del = instance_getattr2(inst, delstr)) != NULL) {
+ PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
+ if (res == NULL)
+ PyErr_WriteUnraisable(del);
+ else
+ Py_DECREF(res);
+ Py_DECREF(del);
+ }
+ /* Restore the saved exception. */
+ PyErr_Restore(error_type, error_value, error_traceback);
- /* Undo the temporary resurrection; can't use DECREF here, it would
- * cause a recursive call.
- */
- assert(inst->ob_refcnt > 0);
- if (--inst->ob_refcnt == 0) {
+ /* Undo the temporary resurrection; can't use DECREF here, it would
+ * cause a recursive call.
+ */
+ assert(inst->ob_refcnt > 0);
+ if (--inst->ob_refcnt == 0) {
- /* New weakrefs could be created during the finalizer call.
- If this occurs, clear them out without calling their
- finalizers since they might rely on part of the object
- being finalized that has already been destroyed. */
- while (inst->in_weakreflist != NULL) {
- _PyWeakref_ClearRef((PyWeakReference *)
- (inst->in_weakreflist));
- }
+ /* New weakrefs could be created during the finalizer call.
+ If this occurs, clear them out without calling their
+ finalizers since they might rely on part of the object
+ being finalized that has already been destroyed. */
+ while (inst->in_weakreflist != NULL) {
+ _PyWeakref_ClearRef((PyWeakReference *)
+ (inst->in_weakreflist));
+ }
- Py_DECREF(inst->in_class);
- Py_XDECREF(inst->in_dict);
- PyObject_GC_Del(inst);
- }
- else {
- Py_ssize_t refcnt = inst->ob_refcnt;
- /* __del__ resurrected it! Make it look like the original
- * Py_DECREF never happened.
- */
- _Py_NewReference((PyObject *)inst);
- inst->ob_refcnt = refcnt;
- _PyObject_GC_TRACK(inst);
- /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
- * we need to undo that. */
- _Py_DEC_REFTOTAL;
- /* If Py_TRACE_REFS, _Py_NewReference re-added self to the
- * object chain, so no more to do there.
- * If COUNT_ALLOCS, the original decref bumped tp_frees, and
- * _Py_NewReference bumped tp_allocs: both of those need to be
- * undone.
- */
+ Py_DECREF(inst->in_class);
+ Py_XDECREF(inst->in_dict);
+ PyObject_GC_Del(inst);
+ }
+ else {
+ Py_ssize_t refcnt = inst->ob_refcnt;
+ /* __del__ resurrected it! Make it look like the original
+ * Py_DECREF never happened.
+ */
+ _Py_NewReference((PyObject *)inst);
+ inst->ob_refcnt = refcnt;
+ _PyObject_GC_TRACK(inst);
+ /* If Py_REF_DEBUG, _Py_NewReference bumped _Py_RefTotal, so
+ * we need to undo that. */
+ _Py_DEC_REFTOTAL;
+ /* If Py_TRACE_REFS, _Py_NewReference re-added self to the
+ * object chain, so no more to do there.
+ * If COUNT_ALLOCS, the original decref bumped tp_frees, and
+ * _Py_NewReference bumped tp_allocs: both of those need to be
+ * undone.
+ */
#ifdef COUNT_ALLOCS
- --inst->ob_type->tp_frees;
- --inst->ob_type->tp_allocs;
+ --inst->ob_type->tp_frees;
+ --inst->ob_type->tp_allocs;
#endif
- }
+ }
}
static PyObject *
instance_getattr1(register PyInstanceObject *inst, PyObject *name)
{
- register PyObject *v;
- register char *sname = PyString_AsString(name);
- if (sname[0] == '_' && sname[1] == '_') {
- if (strcmp(sname, "__dict__") == 0) {
- if (PyEval_GetRestricted()) {
- PyErr_SetString(PyExc_RuntimeError,
- "instance.__dict__ not accessible in restricted mode");
- return NULL;
- }
- Py_INCREF(inst->in_dict);
- return inst->in_dict;
- }
- if (strcmp(sname, "__class__") == 0) {
- Py_INCREF(inst->in_class);
- return (PyObject *)inst->in_class;
- }
- }
- v = instance_getattr2(inst, name);
- if (v == NULL && !PyErr_Occurred()) {
- PyErr_Format(PyExc_AttributeError,
- "%.50s instance has no attribute '%.400s'",
- PyString_AS_STRING(inst->in_class->cl_name), sname);
- }
- return v;
+ register PyObject *v;
+ register char *sname = PyString_AsString(name);
+ if (sname[0] == '_' && sname[1] == '_') {
+ if (strcmp(sname, "__dict__") == 0) {
+ if (PyEval_GetRestricted()) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "instance.__dict__ not accessible in restricted mode");
+ return NULL;
+ }
+ Py_INCREF(inst->in_dict);
+ return inst->in_dict;
+ }
+ if (strcmp(sname, "__class__") == 0) {
+ Py_INCREF(inst->in_class);
+ return (PyObject *)inst->in_class;
+ }
+ }
+ v = instance_getattr2(inst, name);
+ if (v == NULL && !PyErr_Occurred()) {
+ PyErr_Format(PyExc_AttributeError,
+ "%.50s instance has no attribute '%.400s'",
+ PyString_AS_STRING(inst->in_class->cl_name), sname);
+ }
+ return v;
}
static PyObject *
instance_getattr2(register PyInstanceObject *inst, PyObject *name)
{
- register PyObject *v;
- PyClassObject *klass;
- descrgetfunc f;
+ register PyObject *v;
+ PyClassObject *klass;
+ descrgetfunc f;
- v = PyDict_GetItem(inst->in_dict, name);
- if (v != NULL) {
- Py_INCREF(v);
- return v;
- }
- v = class_lookup(inst->in_class, name, &klass);
- if (v != NULL) {
- Py_INCREF(v);
- f = TP_DESCR_GET(v->ob_type);
- if (f != NULL) {
- PyObject *w = f(v, (PyObject *)inst,
- (PyObject *)(inst->in_class));
- Py_DECREF(v);
- v = w;
- }
- }
- return v;
+ v = PyDict_GetItem(inst->in_dict, name);
+ if (v != NULL) {
+ Py_INCREF(v);
+ return v;
+ }
+ v = class_lookup(inst->in_class, name, &klass);
+ if (v != NULL) {
+ Py_INCREF(v);
+ f = TP_DESCR_GET(v->ob_type);
+ if (f != NULL) {
+ PyObject *w = f(v, (PyObject *)inst,
+ (PyObject *)(inst->in_class));
+ Py_DECREF(v);
+ v = w;
+ }
+ }
+ return v;
}
static PyObject *
instance_getattr(register PyInstanceObject *inst, PyObject *name)
{
- register PyObject *func, *res;
- res = instance_getattr1(inst, name);
- if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
- PyObject *args;
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- args = PyTuple_Pack(2, inst, name);
- if (args == NULL)
- return NULL;
- res = PyEval_CallObject(func, args);
- Py_DECREF(args);
- }
- return res;
+ register PyObject *func, *res;
+ res = instance_getattr1(inst, name);
+ if (res == NULL && (func = inst->in_class->cl_getattr) != NULL) {
+ PyObject *args;
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ args = PyTuple_Pack(2, inst, name);
+ if (args == NULL)
+ return NULL;
+ res = PyEval_CallObject(func, args);
+ Py_DECREF(args);
+ }
+ return res;
}
/* See classobject.h comments: this only does dict lookups, and is always
@@ -775,235 +775,235 @@
PyObject *
_PyInstance_Lookup(PyObject *pinst, PyObject *name)
{
- PyObject *v;
- PyClassObject *klass;
- PyInstanceObject *inst; /* pinst cast to the right type */
+ PyObject *v;
+ PyClassObject *klass;
+ PyInstanceObject *inst; /* pinst cast to the right type */
- assert(PyInstance_Check(pinst));
- inst = (PyInstanceObject *)pinst;
+ assert(PyInstance_Check(pinst));
+ inst = (PyInstanceObject *)pinst;
- assert(PyString_Check(name));
+ assert(PyString_Check(name));
- v = PyDict_GetItem(inst->in_dict, name);
- if (v == NULL)
- v = class_lookup(inst->in_class, name, &klass);
- return v;
+ v = PyDict_GetItem(inst->in_dict, name);
+ if (v == NULL)
+ v = class_lookup(inst->in_class, name, &klass);
+ return v;
}
static int
instance_setattr1(PyInstanceObject *inst, PyObject *name, PyObject *v)
{
- if (v == NULL) {
- int rv = PyDict_DelItem(inst->in_dict, name);
- if (rv < 0)
- PyErr_Format(PyExc_AttributeError,
- "%.50s instance has no attribute '%.400s'",
- PyString_AS_STRING(inst->in_class->cl_name),
- PyString_AS_STRING(name));
- return rv;
- }
- else
- return PyDict_SetItem(inst->in_dict, name, v);
+ if (v == NULL) {
+ int rv = PyDict_DelItem(inst->in_dict, name);
+ if (rv < 0)
+ PyErr_Format(PyExc_AttributeError,
+ "%.50s instance has no attribute '%.400s'",
+ PyString_AS_STRING(inst->in_class->cl_name),
+ PyString_AS_STRING(name));
+ return rv;
+ }
+ else
+ return PyDict_SetItem(inst->in_dict, name, v);
}
static int
instance_setattr(PyInstanceObject *inst, PyObject *name, PyObject *v)
{
- PyObject *func, *args, *res, *tmp;
- char *sname = PyString_AsString(name);
- if (sname[0] == '_' && sname[1] == '_') {
- Py_ssize_t n = PyString_Size(name);
- if (sname[n-1] == '_' && sname[n-2] == '_') {
- if (strcmp(sname, "__dict__") == 0) {
- if (PyEval_GetRestricted()) {
- PyErr_SetString(PyExc_RuntimeError,
- "__dict__ not accessible in restricted mode");
- return -1;
- }
- if (v == NULL || !PyDict_Check(v)) {
- PyErr_SetString(PyExc_TypeError,
- "__dict__ must be set to a dictionary");
- return -1;
- }
- tmp = inst->in_dict;
- Py_INCREF(v);
- inst->in_dict = v;
- Py_DECREF(tmp);
- return 0;
- }
- if (strcmp(sname, "__class__") == 0) {
- if (PyEval_GetRestricted()) {
- PyErr_SetString(PyExc_RuntimeError,
- "__class__ not accessible in restricted mode");
- return -1;
- }
- if (v == NULL || !PyClass_Check(v)) {
- PyErr_SetString(PyExc_TypeError,
- "__class__ must be set to a class");
- return -1;
- }
- tmp = (PyObject *)(inst->in_class);
- Py_INCREF(v);
- inst->in_class = (PyClassObject *)v;
- Py_DECREF(tmp);
- return 0;
- }
- }
- }
- if (v == NULL)
- func = inst->in_class->cl_delattr;
- else
- func = inst->in_class->cl_setattr;
- if (func == NULL)
- return instance_setattr1(inst, name, v);
- if (v == NULL)
- args = PyTuple_Pack(2, inst, name);
- else
- args = PyTuple_Pack(3, inst, name, v);
- if (args == NULL)
- return -1;
- res = PyEval_CallObject(func, args);
- Py_DECREF(args);
- if (res == NULL)
- return -1;
- Py_DECREF(res);
- return 0;
+ PyObject *func, *args, *res, *tmp;
+ char *sname = PyString_AsString(name);
+ if (sname[0] == '_' && sname[1] == '_') {
+ Py_ssize_t n = PyString_Size(name);
+ if (sname[n-1] == '_' && sname[n-2] == '_') {
+ if (strcmp(sname, "__dict__") == 0) {
+ if (PyEval_GetRestricted()) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "__dict__ not accessible in restricted mode");
+ return -1;
+ }
+ if (v == NULL || !PyDict_Check(v)) {
+ PyErr_SetString(PyExc_TypeError,
+ "__dict__ must be set to a dictionary");
+ return -1;
+ }
+ tmp = inst->in_dict;
+ Py_INCREF(v);
+ inst->in_dict = v;
+ Py_DECREF(tmp);
+ return 0;
+ }
+ if (strcmp(sname, "__class__") == 0) {
+ if (PyEval_GetRestricted()) {
+ PyErr_SetString(PyExc_RuntimeError,
+ "__class__ not accessible in restricted mode");
+ return -1;
+ }
+ if (v == NULL || !PyClass_Check(v)) {
+ PyErr_SetString(PyExc_TypeError,
+ "__class__ must be set to a class");
+ return -1;
+ }
+ tmp = (PyObject *)(inst->in_class);
+ Py_INCREF(v);
+ inst->in_class = (PyClassObject *)v;
+ Py_DECREF(tmp);
+ return 0;
+ }
+ }
+ }
+ if (v == NULL)
+ func = inst->in_class->cl_delattr;
+ else
+ func = inst->in_class->cl_setattr;
+ if (func == NULL)
+ return instance_setattr1(inst, name, v);
+ if (v == NULL)
+ args = PyTuple_Pack(2, inst, name);
+ else
+ args = PyTuple_Pack(3, inst, name, v);
+ if (args == NULL)
+ return -1;
+ res = PyEval_CallObject(func, args);
+ Py_DECREF(args);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return 0;
}
static PyObject *
instance_repr(PyInstanceObject *inst)
{
- PyObject *func;
- PyObject *res;
- static PyObject *reprstr;
+ PyObject *func;
+ PyObject *res;
+ static PyObject *reprstr;
- if (reprstr == NULL) {
- reprstr = PyString_InternFromString("__repr__");
- if (reprstr == NULL)
- return NULL;
- }
- func = instance_getattr(inst, reprstr);
- if (func == NULL) {
- PyObject *classname, *mod;
- char *cname;
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- classname = inst->in_class->cl_name;
- mod = PyDict_GetItemString(inst->in_class->cl_dict,
- "__module__");
- if (classname != NULL && PyString_Check(classname))
- cname = PyString_AsString(classname);
- else
- cname = "?";
- if (mod == NULL || !PyString_Check(mod))
- return PyString_FromFormat("<?.%s instance at %p>",
- cname, inst);
- else
- return PyString_FromFormat("<%s.%s instance at %p>",
- PyString_AsString(mod),
- cname, inst);
- }
- res = PyEval_CallObject(func, (PyObject *)NULL);
- Py_DECREF(func);
- return res;
+ if (reprstr == NULL) {
+ reprstr = PyString_InternFromString("__repr__");
+ if (reprstr == NULL)
+ return NULL;
+ }
+ func = instance_getattr(inst, reprstr);
+ if (func == NULL) {
+ PyObject *classname, *mod;
+ char *cname;
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ classname = inst->in_class->cl_name;
+ mod = PyDict_GetItemString(inst->in_class->cl_dict,
+ "__module__");
+ if (classname != NULL && PyString_Check(classname))
+ cname = PyString_AsString(classname);
+ else
+ cname = "?";
+ if (mod == NULL || !PyString_Check(mod))
+ return PyString_FromFormat("<?.%s instance at %p>",
+ cname, inst);
+ else
+ return PyString_FromFormat("<%s.%s instance at %p>",
+ PyString_AsString(mod),
+ cname, inst);
+ }
+ res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ return res;
}
static PyObject *
instance_str(PyInstanceObject *inst)
{
- PyObject *func;
- PyObject *res;
- static PyObject *strstr;
+ PyObject *func;
+ PyObject *res;
+ static PyObject *strstr;
- if (strstr == NULL) {
- strstr = PyString_InternFromString("__str__");
- if (strstr == NULL)
- return NULL;
- }
- func = instance_getattr(inst, strstr);
- if (func == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- return instance_repr(inst);
- }
- res = PyEval_CallObject(func, (PyObject *)NULL);
- Py_DECREF(func);
- return res;
+ if (strstr == NULL) {
+ strstr = PyString_InternFromString("__str__");
+ if (strstr == NULL)
+ return NULL;
+ }
+ func = instance_getattr(inst, strstr);
+ if (func == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ return instance_repr(inst);
+ }
+ res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ return res;
}
static long
instance_hash(PyInstanceObject *inst)
{
- PyObject *func;
- PyObject *res;
- long outcome;
- static PyObject *hashstr, *eqstr, *cmpstr;
+ PyObject *func;
+ PyObject *res;
+ long outcome;
+ static PyObject *hashstr, *eqstr, *cmpstr;
- if (hashstr == NULL) {
- hashstr = PyString_InternFromString("__hash__");
- if (hashstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, hashstr);
- if (func == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return -1;
- PyErr_Clear();
- /* If there is no __eq__ and no __cmp__ method, we hash on the
- address. If an __eq__ or __cmp__ method exists, there must
- be a __hash__. */
- if (eqstr == NULL) {
- eqstr = PyString_InternFromString("__eq__");
- if (eqstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, eqstr);
- if (func == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return -1;
- PyErr_Clear();
- if (cmpstr == NULL) {
- cmpstr = PyString_InternFromString("__cmp__");
- if (cmpstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, cmpstr);
- if (func == NULL) {
- if (!PyErr_ExceptionMatches(
- PyExc_AttributeError))
- return -1;
- PyErr_Clear();
- return _Py_HashPointer(inst);
- }
- }
- Py_XDECREF(func);
- PyErr_SetString(PyExc_TypeError, "unhashable instance");
- return -1;
- }
- res = PyEval_CallObject(func, (PyObject *)NULL);
- Py_DECREF(func);
- if (res == NULL)
- return -1;
- if (PyInt_Check(res) || PyLong_Check(res))
- /* This already converts a -1 result to -2. */
- outcome = res->ob_type->tp_hash(res);
- else {
- PyErr_SetString(PyExc_TypeError,
- "__hash__() should return an int");
- outcome = -1;
- }
- Py_DECREF(res);
- return outcome;
+ if (hashstr == NULL) {
+ hashstr = PyString_InternFromString("__hash__");
+ if (hashstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, hashstr);
+ if (func == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return -1;
+ PyErr_Clear();
+ /* If there is no __eq__ and no __cmp__ method, we hash on the
+ address. If an __eq__ or __cmp__ method exists, there must
+ be a __hash__. */
+ if (eqstr == NULL) {
+ eqstr = PyString_InternFromString("__eq__");
+ if (eqstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, eqstr);
+ if (func == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return -1;
+ PyErr_Clear();
+ if (cmpstr == NULL) {
+ cmpstr = PyString_InternFromString("__cmp__");
+ if (cmpstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, cmpstr);
+ if (func == NULL) {
+ if (!PyErr_ExceptionMatches(
+ PyExc_AttributeError))
+ return -1;
+ PyErr_Clear();
+ return _Py_HashPointer(inst);
+ }
+ }
+ Py_XDECREF(func);
+ PyErr_SetString(PyExc_TypeError, "unhashable instance");
+ return -1;
+ }
+ res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ if (res == NULL)
+ return -1;
+ if (PyInt_Check(res) || PyLong_Check(res))
+ /* This already converts a -1 result to -2. */
+ outcome = res->ob_type->tp_hash(res);
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "__hash__() should return an int");
+ outcome = -1;
+ }
+ Py_DECREF(res);
+ return outcome;
}
static int
instance_traverse(PyInstanceObject *o, visitproc visit, void *arg)
{
- Py_VISIT(o->in_class);
- Py_VISIT(o->in_dict);
- return 0;
+ Py_VISIT(o->in_class);
+ Py_VISIT(o->in_dict);
+ return 0;
}
static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;
@@ -1012,413 +1012,413 @@
static Py_ssize_t
instance_length(PyInstanceObject *inst)
{
- PyObject *func;
- PyObject *res;
- Py_ssize_t outcome;
+ PyObject *func;
+ PyObject *res;
+ Py_ssize_t outcome;
- if (lenstr == NULL) {
- lenstr = PyString_InternFromString("__len__");
- if (lenstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, lenstr);
- if (func == NULL)
- return -1;
- res = PyEval_CallObject(func, (PyObject *)NULL);
- Py_DECREF(func);
- if (res == NULL)
- return -1;
- if (PyInt_Check(res)) {
- outcome = PyInt_AsSsize_t(res);
- if (outcome == -1 && PyErr_Occurred()) {
- Py_DECREF(res);
- return -1;
- }
+ if (lenstr == NULL) {
+ lenstr = PyString_InternFromString("__len__");
+ if (lenstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, lenstr);
+ if (func == NULL)
+ return -1;
+ res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ if (res == NULL)
+ return -1;
+ if (PyInt_Check(res)) {
+ outcome = PyInt_AsSsize_t(res);
+ if (outcome == -1 && PyErr_Occurred()) {
+ Py_DECREF(res);
+ return -1;
+ }
#if SIZEOF_SIZE_T < SIZEOF_INT
- /* Overflow check -- range of PyInt is more than C int */
- if (outcome != (int)outcome) {
- PyErr_SetString(PyExc_OverflowError,
- "__len__() should return 0 <= outcome < 2**31");
- outcome = -1;
- }
- else
+ /* Overflow check -- range of PyInt is more than C int */
+ if (outcome != (int)outcome) {
+ PyErr_SetString(PyExc_OverflowError,
+ "__len__() should return 0 <= outcome < 2**31");
+ outcome = -1;
+ }
+ else
#endif
- if (outcome < 0) {
- PyErr_SetString(PyExc_ValueError,
- "__len__() should return >= 0");
- outcome = -1;
- }
- }
- else {
- PyErr_SetString(PyExc_TypeError,
- "__len__() should return an int");
- outcome = -1;
- }
- Py_DECREF(res);
- return outcome;
+ if (outcome < 0) {
+ PyErr_SetString(PyExc_ValueError,
+ "__len__() should return >= 0");
+ outcome = -1;
+ }
+ }
+ else {
+ PyErr_SetString(PyExc_TypeError,
+ "__len__() should return an int");
+ outcome = -1;
+ }
+ Py_DECREF(res);
+ return outcome;
}
static PyObject *
instance_subscript(PyInstanceObject *inst, PyObject *key)
{
- PyObject *func;
- PyObject *arg;
- PyObject *res;
+ PyObject *func;
+ PyObject *arg;
+ PyObject *res;
- if (getitemstr == NULL) {
- getitemstr = PyString_InternFromString("__getitem__");
- if (getitemstr == NULL)
- return NULL;
- }
- func = instance_getattr(inst, getitemstr);
- if (func == NULL)
- return NULL;
- arg = PyTuple_Pack(1, key);
- if (arg == NULL) {
- Py_DECREF(func);
- return NULL;
- }
- res = PyEval_CallObject(func, arg);
- Py_DECREF(func);
- Py_DECREF(arg);
- return res;
+ if (getitemstr == NULL) {
+ getitemstr = PyString_InternFromString("__getitem__");
+ if (getitemstr == NULL)
+ return NULL;
+ }
+ func = instance_getattr(inst, getitemstr);
+ if (func == NULL)
+ return NULL;
+ arg = PyTuple_Pack(1, key);
+ if (arg == NULL) {
+ Py_DECREF(func);
+ return NULL;
+ }
+ res = PyEval_CallObject(func, arg);
+ Py_DECREF(func);
+ Py_DECREF(arg);
+ return res;
}
static int
instance_ass_subscript(PyInstanceObject *inst, PyObject *key, PyObject *value)
{
- PyObject *func;
- PyObject *arg;
- PyObject *res;
+ PyObject *func;
+ PyObject *arg;
+ PyObject *res;
- if (value == NULL) {
- if (delitemstr == NULL) {
- delitemstr = PyString_InternFromString("__delitem__");
- if (delitemstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, delitemstr);
- }
- else {
- if (setitemstr == NULL) {
- setitemstr = PyString_InternFromString("__setitem__");
- if (setitemstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, setitemstr);
- }
- if (func == NULL)
- return -1;
- if (value == NULL)
- arg = PyTuple_Pack(1, key);
- else
- arg = PyTuple_Pack(2, key, value);
- if (arg == NULL) {
- Py_DECREF(func);
- return -1;
- }
- res = PyEval_CallObject(func, arg);
- Py_DECREF(func);
- Py_DECREF(arg);
- if (res == NULL)
- return -1;
- Py_DECREF(res);
- return 0;
+ if (value == NULL) {
+ if (delitemstr == NULL) {
+ delitemstr = PyString_InternFromString("__delitem__");
+ if (delitemstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, delitemstr);
+ }
+ else {
+ if (setitemstr == NULL) {
+ setitemstr = PyString_InternFromString("__setitem__");
+ if (setitemstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, setitemstr);
+ }
+ if (func == NULL)
+ return -1;
+ if (value == NULL)
+ arg = PyTuple_Pack(1, key);
+ else
+ arg = PyTuple_Pack(2, key, value);
+ if (arg == NULL) {
+ Py_DECREF(func);
+ return -1;
+ }
+ res = PyEval_CallObject(func, arg);
+ Py_DECREF(func);
+ Py_DECREF(arg);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return 0;
}
static PyMappingMethods instance_as_mapping = {
- (lenfunc)instance_length, /* mp_length */
- (binaryfunc)instance_subscript, /* mp_subscript */
- (objobjargproc)instance_ass_subscript, /* mp_ass_subscript */
+ (lenfunc)instance_length, /* mp_length */
+ (binaryfunc)instance_subscript, /* mp_subscript */
+ (objobjargproc)instance_ass_subscript, /* mp_ass_subscript */
};
static PyObject *
instance_item(PyInstanceObject *inst, Py_ssize_t i)
{
- PyObject *func, *res;
+ PyObject *func, *res;
- if (getitemstr == NULL) {
- getitemstr = PyString_InternFromString("__getitem__");
- if (getitemstr == NULL)
- return NULL;
- }
- func = instance_getattr(inst, getitemstr);
- if (func == NULL)
- return NULL;
- res = PyObject_CallFunction(func, "n", i);
- Py_DECREF(func);
- return res;
+ if (getitemstr == NULL) {
+ getitemstr = PyString_InternFromString("__getitem__");
+ if (getitemstr == NULL)
+ return NULL;
+ }
+ func = instance_getattr(inst, getitemstr);
+ if (func == NULL)
+ return NULL;
+ res = PyObject_CallFunction(func, "n", i);
+ Py_DECREF(func);
+ return res;
}
static PyObject *
instance_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j)
{
- PyObject *func, *arg, *res;
- static PyObject *getslicestr;
+ PyObject *func, *arg, *res;
+ static PyObject *getslicestr;
- if (getslicestr == NULL) {
- getslicestr = PyString_InternFromString("__getslice__");
- if (getslicestr == NULL)
- return NULL;
- }
- func = instance_getattr(inst, getslicestr);
+ if (getslicestr == NULL) {
+ getslicestr = PyString_InternFromString("__getslice__");
+ if (getslicestr == NULL)
+ return NULL;
+ }
+ func = instance_getattr(inst, getslicestr);
- if (func == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
+ if (func == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
- if (getitemstr == NULL) {
- getitemstr = PyString_InternFromString("__getitem__");
- if (getitemstr == NULL)
- return NULL;
- }
- func = instance_getattr(inst, getitemstr);
- if (func == NULL)
- return NULL;
- arg = Py_BuildValue("(N)", _PySlice_FromIndices(i, j));
- }
- else {
- if (PyErr_WarnPy3k("in 3.x, __getslice__ has been removed; "
- "use __getitem__", 1) < 0) {
- Py_DECREF(func);
- return NULL;
- }
- arg = Py_BuildValue("(nn)", i, j);
- }
+ if (getitemstr == NULL) {
+ getitemstr = PyString_InternFromString("__getitem__");
+ if (getitemstr == NULL)
+ return NULL;
+ }
+ func = instance_getattr(inst, getitemstr);
+ if (func == NULL)
+ return NULL;
+ arg = Py_BuildValue("(N)", _PySlice_FromIndices(i, j));
+ }
+ else {
+ if (PyErr_WarnPy3k("in 3.x, __getslice__ has been removed; "
+ "use __getitem__", 1) < 0) {
+ Py_DECREF(func);
+ return NULL;
+ }
+ arg = Py_BuildValue("(nn)", i, j);
+ }
- if (arg == NULL) {
- Py_DECREF(func);
- return NULL;
- }
- res = PyEval_CallObject(func, arg);
- Py_DECREF(func);
- Py_DECREF(arg);
- return res;
+ if (arg == NULL) {
+ Py_DECREF(func);
+ return NULL;
+ }
+ res = PyEval_CallObject(func, arg);
+ Py_DECREF(func);
+ Py_DECREF(arg);
+ return res;
}
static int
instance_ass_item(PyInstanceObject *inst, Py_ssize_t i, PyObject *item)
{
- PyObject *func, *arg, *res;
+ PyObject *func, *arg, *res;
- if (item == NULL) {
- if (delitemstr == NULL) {
- delitemstr = PyString_InternFromString("__delitem__");
- if (delitemstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, delitemstr);
- }
- else {
- if (setitemstr == NULL) {
- setitemstr = PyString_InternFromString("__setitem__");
- if (setitemstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, setitemstr);
- }
- if (func == NULL)
- return -1;
- if (item == NULL)
- arg = PyInt_FromSsize_t(i);
- else
- arg = Py_BuildValue("(nO)", i, item);
- if (arg == NULL) {
- Py_DECREF(func);
- return -1;
- }
- res = PyEval_CallObject(func, arg);
- Py_DECREF(func);
- Py_DECREF(arg);
- if (res == NULL)
- return -1;
- Py_DECREF(res);
- return 0;
+ if (item == NULL) {
+ if (delitemstr == NULL) {
+ delitemstr = PyString_InternFromString("__delitem__");
+ if (delitemstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, delitemstr);
+ }
+ else {
+ if (setitemstr == NULL) {
+ setitemstr = PyString_InternFromString("__setitem__");
+ if (setitemstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, setitemstr);
+ }
+ if (func == NULL)
+ return -1;
+ if (item == NULL)
+ arg = PyInt_FromSsize_t(i);
+ else
+ arg = Py_BuildValue("(nO)", i, item);
+ if (arg == NULL) {
+ Py_DECREF(func);
+ return -1;
+ }
+ res = PyEval_CallObject(func, arg);
+ Py_DECREF(func);
+ Py_DECREF(arg);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return 0;
}
static int
instance_ass_slice(PyInstanceObject *inst, Py_ssize_t i, Py_ssize_t j, PyObject *value)
{
- PyObject *func, *arg, *res;
- static PyObject *setslicestr, *delslicestr;
+ PyObject *func, *arg, *res;
+ static PyObject *setslicestr, *delslicestr;
- if (value == NULL) {
- if (delslicestr == NULL) {
- delslicestr =
- PyString_InternFromString("__delslice__");
- if (delslicestr == NULL)
- return -1;
- }
- func = instance_getattr(inst, delslicestr);
- if (func == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return -1;
- PyErr_Clear();
- if (delitemstr == NULL) {
- delitemstr =
- PyString_InternFromString("__delitem__");
- if (delitemstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, delitemstr);
- if (func == NULL)
- return -1;
+ if (value == NULL) {
+ if (delslicestr == NULL) {
+ delslicestr =
+ PyString_InternFromString("__delslice__");
+ if (delslicestr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, delslicestr);
+ if (func == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return -1;
+ PyErr_Clear();
+ if (delitemstr == NULL) {
+ delitemstr =
+ PyString_InternFromString("__delitem__");
+ if (delitemstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, delitemstr);
+ if (func == NULL)
+ return -1;
- arg = Py_BuildValue("(N)",
- _PySlice_FromIndices(i, j));
- }
- else {
- if (PyErr_WarnPy3k("in 3.x, __delslice__ has been "
- "removed; use __delitem__", 1) < 0) {
- Py_DECREF(func);
- return -1;
- }
- arg = Py_BuildValue("(nn)", i, j);
- }
- }
- else {
- if (setslicestr == NULL) {
- setslicestr =
- PyString_InternFromString("__setslice__");
- if (setslicestr == NULL)
- return -1;
- }
- func = instance_getattr(inst, setslicestr);
- if (func == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return -1;
- PyErr_Clear();
- if (setitemstr == NULL) {
- setitemstr =
- PyString_InternFromString("__setitem__");
- if (setitemstr == NULL)
- return -1;
- }
- func = instance_getattr(inst, setitemstr);
- if (func == NULL)
- return -1;
+ arg = Py_BuildValue("(N)",
+ _PySlice_FromIndices(i, j));
+ }
+ else {
+ if (PyErr_WarnPy3k("in 3.x, __delslice__ has been "
+ "removed; use __delitem__", 1) < 0) {
+ Py_DECREF(func);
+ return -1;
+ }
+ arg = Py_BuildValue("(nn)", i, j);
+ }
+ }
+ else {
+ if (setslicestr == NULL) {
+ setslicestr =
+ PyString_InternFromString("__setslice__");
+ if (setslicestr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, setslicestr);
+ if (func == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return -1;
+ PyErr_Clear();
+ if (setitemstr == NULL) {
+ setitemstr =
+ PyString_InternFromString("__setitem__");
+ if (setitemstr == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, setitemstr);
+ if (func == NULL)
+ return -1;
- arg = Py_BuildValue("(NO)",
- _PySlice_FromIndices(i, j), value);
- }
- else {
- if (PyErr_WarnPy3k("in 3.x, __setslice__ has been "
- "removed; use __setitem__", 1) < 0) {
- Py_DECREF(func);
- return -1;
- }
- arg = Py_BuildValue("(nnO)", i, j, value);
- }
- }
- if (arg == NULL) {
- Py_DECREF(func);
- return -1;
- }
- res = PyEval_CallObject(func, arg);
- Py_DECREF(func);
- Py_DECREF(arg);
- if (res == NULL)
- return -1;
- Py_DECREF(res);
- return 0;
+ arg = Py_BuildValue("(NO)",
+ _PySlice_FromIndices(i, j), value);
+ }
+ else {
+ if (PyErr_WarnPy3k("in 3.x, __setslice__ has been "
+ "removed; use __setitem__", 1) < 0) {
+ Py_DECREF(func);
+ return -1;
+ }
+ arg = Py_BuildValue("(nnO)", i, j, value);
+ }
+ }
+ if (arg == NULL) {
+ Py_DECREF(func);
+ return -1;
+ }
+ res = PyEval_CallObject(func, arg);
+ Py_DECREF(func);
+ Py_DECREF(arg);
+ if (res == NULL)
+ return -1;
+ Py_DECREF(res);
+ return 0;
}
static int
instance_contains(PyInstanceObject *inst, PyObject *member)
{
- static PyObject *__contains__;
- PyObject *func;
+ static PyObject *__contains__;
+ PyObject *func;
- /* Try __contains__ first.
- * If that can't be done, try iterator-based searching.
- */
+ /* Try __contains__ first.
+ * If that can't be done, try iterator-based searching.
+ */
- if(__contains__ == NULL) {
- __contains__ = PyString_InternFromString("__contains__");
- if(__contains__ == NULL)
- return -1;
- }
- func = instance_getattr(inst, __contains__);
- if (func) {
- PyObject *res;
- int ret;
- PyObject *arg = PyTuple_Pack(1, member);
- if(arg == NULL) {
- Py_DECREF(func);
- return -1;
- }
- res = PyEval_CallObject(func, arg);
- Py_DECREF(func);
- Py_DECREF(arg);
- if(res == NULL)
- return -1;
- ret = PyObject_IsTrue(res);
- Py_DECREF(res);
- return ret;
- }
+ if(__contains__ == NULL) {
+ __contains__ = PyString_InternFromString("__contains__");
+ if(__contains__ == NULL)
+ return -1;
+ }
+ func = instance_getattr(inst, __contains__);
+ if (func) {
+ PyObject *res;
+ int ret;
+ PyObject *arg = PyTuple_Pack(1, member);
+ if(arg == NULL) {
+ Py_DECREF(func);
+ return -1;
+ }
+ res = PyEval_CallObject(func, arg);
+ Py_DECREF(func);
+ Py_DECREF(arg);
+ if(res == NULL)
+ return -1;
+ ret = PyObject_IsTrue(res);
+ Py_DECREF(res);
+ return ret;
+ }
- /* Couldn't find __contains__. */
- if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
- Py_ssize_t rc;
- /* Assume the failure was simply due to that there is no
- * __contains__ attribute, and try iterating instead.
- */
- PyErr_Clear();
- rc = _PySequence_IterSearch((PyObject *)inst, member,
- PY_ITERSEARCH_CONTAINS);
- if (rc >= 0)
- return rc > 0;
- }
- return -1;
+ /* Couldn't find __contains__. */
+ if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
+ Py_ssize_t rc;
+ /* Assume the failure was simply due to that there is no
+ * __contains__ attribute, and try iterating instead.
+ */
+ PyErr_Clear();
+ rc = _PySequence_IterSearch((PyObject *)inst, member,
+ PY_ITERSEARCH_CONTAINS);
+ if (rc >= 0)
+ return rc > 0;
+ }
+ return -1;
}
static PySequenceMethods
instance_as_sequence = {
- (lenfunc)instance_length, /* sq_length */
- 0, /* sq_concat */
- 0, /* sq_repeat */
- (ssizeargfunc)instance_item, /* sq_item */
- (ssizessizeargfunc)instance_slice, /* sq_slice */
- (ssizeobjargproc)instance_ass_item, /* sq_ass_item */
- (ssizessizeobjargproc)instance_ass_slice,/* sq_ass_slice */
- (objobjproc)instance_contains, /* sq_contains */
+ (lenfunc)instance_length, /* sq_length */
+ 0, /* sq_concat */
+ 0, /* sq_repeat */
+ (ssizeargfunc)instance_item, /* sq_item */
+ (ssizessizeargfunc)instance_slice, /* sq_slice */
+ (ssizeobjargproc)instance_ass_item, /* sq_ass_item */
+ (ssizessizeobjargproc)instance_ass_slice,/* sq_ass_slice */
+ (objobjproc)instance_contains, /* sq_contains */
};
static PyObject *
generic_unary_op(PyInstanceObject *self, PyObject *methodname)
{
- PyObject *func, *res;
+ PyObject *func, *res;
- if ((func = instance_getattr(self, methodname)) == NULL)
- return NULL;
- res = PyEval_CallObject(func, (PyObject *)NULL);
- Py_DECREF(func);
- return res;
+ if ((func = instance_getattr(self, methodname)) == NULL)
+ return NULL;
+ res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ return res;
}
static PyObject *
generic_binary_op(PyObject *v, PyObject *w, char *opname)
{
- PyObject *result;
- PyObject *args;
- PyObject *func = PyObject_GetAttrString(v, opname);
- if (func == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
- }
- args = PyTuple_Pack(1, w);
- if (args == NULL) {
- Py_DECREF(func);
- return NULL;
- }
- result = PyEval_CallObject(func, args);
- Py_DECREF(args);
- Py_DECREF(func);
- return result;
+ PyObject *result;
+ PyObject *args;
+ PyObject *func = PyObject_GetAttrString(v, opname);
+ if (func == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+ }
+ args = PyTuple_Pack(1, w);
+ if (args == NULL) {
+ Py_DECREF(func);
+ return NULL;
+ }
+ result = PyEval_CallObject(func, args);
+ Py_DECREF(args);
+ Py_DECREF(func);
+ return result;
}
@@ -1427,70 +1427,70 @@
/* Try one half of a binary operator involving a class instance. */
static PyObject *
half_binop(PyObject *v, PyObject *w, char *opname, binaryfunc thisfunc,
- int swapped)
+ int swapped)
{
- PyObject *args;
- PyObject *coercefunc;
- PyObject *coerced = NULL;
- PyObject *v1;
- PyObject *result;
+ PyObject *args;
+ PyObject *coercefunc;
+ PyObject *coerced = NULL;
+ PyObject *v1;
+ PyObject *result;
- if (!PyInstance_Check(v)) {
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
- }
+ if (!PyInstance_Check(v)) {
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
+ }
- if (coerce_obj == NULL) {
- coerce_obj = PyString_InternFromString("__coerce__");
- if (coerce_obj == NULL)
- return NULL;
- }
- coercefunc = PyObject_GetAttr(v, coerce_obj);
- if (coercefunc == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- return generic_binary_op(v, w, opname);
- }
+ if (coerce_obj == NULL) {
+ coerce_obj = PyString_InternFromString("__coerce__");
+ if (coerce_obj == NULL)
+ return NULL;
+ }
+ coercefunc = PyObject_GetAttr(v, coerce_obj);
+ if (coercefunc == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ return generic_binary_op(v, w, opname);
+ }
- args = PyTuple_Pack(1, w);
- if (args == NULL) {
- Py_DECREF(coercefunc);
- return NULL;
- }
- coerced = PyEval_CallObject(coercefunc, args);
- Py_DECREF(args);
- Py_DECREF(coercefunc);
- if (coerced == NULL) {
- return NULL;
- }
- if (coerced == Py_None || coerced == Py_NotImplemented) {
- Py_DECREF(coerced);
- return generic_binary_op(v, w, opname);
- }
- if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
- Py_DECREF(coerced);
- PyErr_SetString(PyExc_TypeError,
- "coercion should return None or 2-tuple");
- return NULL;
- }
- v1 = PyTuple_GetItem(coerced, 0);
- w = PyTuple_GetItem(coerced, 1);
- if (v1->ob_type == v->ob_type && PyInstance_Check(v)) {
- /* prevent recursion if __coerce__ returns self as the first
- * argument */
- result = generic_binary_op(v1, w, opname);
- } else {
- if (Py_EnterRecursiveCall(" after coercion"))
- return NULL;
- if (swapped)
- result = (thisfunc)(w, v1);
- else
- result = (thisfunc)(v1, w);
- Py_LeaveRecursiveCall();
- }
- Py_DECREF(coerced);
- return result;
+ args = PyTuple_Pack(1, w);
+ if (args == NULL) {
+ Py_DECREF(coercefunc);
+ return NULL;
+ }
+ coerced = PyEval_CallObject(coercefunc, args);
+ Py_DECREF(args);
+ Py_DECREF(coercefunc);
+ if (coerced == NULL) {
+ return NULL;
+ }
+ if (coerced == Py_None || coerced == Py_NotImplemented) {
+ Py_DECREF(coerced);
+ return generic_binary_op(v, w, opname);
+ }
+ if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
+ Py_DECREF(coerced);
+ PyErr_SetString(PyExc_TypeError,
+ "coercion should return None or 2-tuple");
+ return NULL;
+ }
+ v1 = PyTuple_GetItem(coerced, 0);
+ w = PyTuple_GetItem(coerced, 1);
+ if (v1->ob_type == v->ob_type && PyInstance_Check(v)) {
+ /* prevent recursion if __coerce__ returns self as the first
+ * argument */
+ result = generic_binary_op(v1, w, opname);
+ } else {
+ if (Py_EnterRecursiveCall(" after coercion"))
+ return NULL;
+ if (swapped)
+ result = (thisfunc)(w, v1);
+ else
+ result = (thisfunc)(v1, w);
+ Py_LeaveRecursiveCall();
+ }
+ Py_DECREF(coerced);
+ return result;
}
/* Implement a binary operator involving at least one class instance. */
@@ -1498,110 +1498,110 @@
do_binop(PyObject *v, PyObject *w, char *opname, char *ropname,
binaryfunc thisfunc)
{
- PyObject *result = half_binop(v, w, opname, thisfunc, 0);
- if (result == Py_NotImplemented) {
- Py_DECREF(result);
- result = half_binop(w, v, ropname, thisfunc, 1);
- }
- return result;
+ PyObject *result = half_binop(v, w, opname, thisfunc, 0);
+ if (result == Py_NotImplemented) {
+ Py_DECREF(result);
+ result = half_binop(w, v, ropname, thisfunc, 1);
+ }
+ return result;
}
static PyObject *
do_binop_inplace(PyObject *v, PyObject *w, char *iopname, char *opname,
- char *ropname, binaryfunc thisfunc)
+ char *ropname, binaryfunc thisfunc)
{
- PyObject *result = half_binop(v, w, iopname, thisfunc, 0);
- if (result == Py_NotImplemented) {
- Py_DECREF(result);
- result = do_binop(v, w, opname, ropname, thisfunc);
- }
- return result;
+ PyObject *result = half_binop(v, w, iopname, thisfunc, 0);
+ if (result == Py_NotImplemented) {
+ Py_DECREF(result);
+ result = do_binop(v, w, opname, ropname, thisfunc);
+ }
+ return result;
}
static int
instance_coerce(PyObject **pv, PyObject **pw)
{
- PyObject *v = *pv;
- PyObject *w = *pw;
- PyObject *coercefunc;
- PyObject *args;
- PyObject *coerced;
+ PyObject *v = *pv;
+ PyObject *w = *pw;
+ PyObject *coercefunc;
+ PyObject *args;
+ PyObject *coerced;
- if (coerce_obj == NULL) {
- coerce_obj = PyString_InternFromString("__coerce__");
- if (coerce_obj == NULL)
- return -1;
- }
- coercefunc = PyObject_GetAttr(v, coerce_obj);
- if (coercefunc == NULL) {
- /* No __coerce__ method */
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return -1;
- PyErr_Clear();
- return 1;
- }
- /* Has __coerce__ method: call it */
- args = PyTuple_Pack(1, w);
- if (args == NULL) {
- return -1;
- }
- coerced = PyEval_CallObject(coercefunc, args);
- Py_DECREF(args);
- Py_DECREF(coercefunc);
- if (coerced == NULL) {
- /* __coerce__ call raised an exception */
- return -1;
- }
- if (coerced == Py_None || coerced == Py_NotImplemented) {
- /* __coerce__ says "I can't do it" */
- Py_DECREF(coerced);
- return 1;
- }
- if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
- /* __coerce__ return value is malformed */
- Py_DECREF(coerced);
- PyErr_SetString(PyExc_TypeError,
- "coercion should return None or 2-tuple");
- return -1;
- }
- /* __coerce__ returned two new values */
- *pv = PyTuple_GetItem(coerced, 0);
- *pw = PyTuple_GetItem(coerced, 1);
- Py_INCREF(*pv);
- Py_INCREF(*pw);
- Py_DECREF(coerced);
- return 0;
+ if (coerce_obj == NULL) {
+ coerce_obj = PyString_InternFromString("__coerce__");
+ if (coerce_obj == NULL)
+ return -1;
+ }
+ coercefunc = PyObject_GetAttr(v, coerce_obj);
+ if (coercefunc == NULL) {
+ /* No __coerce__ method */
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return -1;
+ PyErr_Clear();
+ return 1;
+ }
+ /* Has __coerce__ method: call it */
+ args = PyTuple_Pack(1, w);
+ if (args == NULL) {
+ return -1;
+ }
+ coerced = PyEval_CallObject(coercefunc, args);
+ Py_DECREF(args);
+ Py_DECREF(coercefunc);
+ if (coerced == NULL) {
+ /* __coerce__ call raised an exception */
+ return -1;
+ }
+ if (coerced == Py_None || coerced == Py_NotImplemented) {
+ /* __coerce__ says "I can't do it" */
+ Py_DECREF(coerced);
+ return 1;
+ }
+ if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
+ /* __coerce__ return value is malformed */
+ Py_DECREF(coerced);
+ PyErr_SetString(PyExc_TypeError,
+ "coercion should return None or 2-tuple");
+ return -1;
+ }
+ /* __coerce__ returned two new values */
+ *pv = PyTuple_GetItem(coerced, 0);
+ *pw = PyTuple_GetItem(coerced, 1);
+ Py_INCREF(*pv);
+ Py_INCREF(*pw);
+ Py_DECREF(coerced);
+ return 0;
}
#define UNARY(funcname, methodname) \
static PyObject *funcname(PyInstanceObject *self) { \
- static PyObject *o; \
- if (o == NULL) { o = PyString_InternFromString(methodname); \
- if (o == NULL) return NULL; } \
- return generic_unary_op(self, o); \
+ static PyObject *o; \
+ if (o == NULL) { o = PyString_InternFromString(methodname); \
+ if (o == NULL) return NULL; } \
+ return generic_unary_op(self, o); \
}
/* unary function with a fallback */
#define UNARY_FB(funcname, methodname, funcname_fb) \
static PyObject *funcname(PyInstanceObject *self) { \
- static PyObject *o; \
- if (o == NULL) { o = PyString_InternFromString(methodname); \
- if (o == NULL) return NULL; } \
- if (PyObject_HasAttr((PyObject*)self, o)) \
- return generic_unary_op(self, o); \
- else \
- return funcname_fb(self); \
+ static PyObject *o; \
+ if (o == NULL) { o = PyString_InternFromString(methodname); \
+ if (o == NULL) return NULL; } \
+ if (PyObject_HasAttr((PyObject*)self, o)) \
+ return generic_unary_op(self, o); \
+ else \
+ return funcname_fb(self); \
}
#define BINARY(f, m, n) \
static PyObject *f(PyObject *v, PyObject *w) { \
- return do_binop(v, w, "__" m "__", "__r" m "__", n); \
+ return do_binop(v, w, "__" m "__", "__r" m "__", n); \
}
#define BINARY_INPLACE(f, m, n) \
static PyObject *f(PyObject *v, PyObject *w) { \
- return do_binop_inplace(v, w, "__i" m "__", "__" m "__", \
- "__r" m "__", n); \
+ return do_binop_inplace(v, w, "__i" m "__", "__" m "__", \
+ "__r" m "__", n); \
}
UNARY(instance_neg, "__neg__")
@@ -1645,55 +1645,55 @@
static int
half_cmp(PyObject *v, PyObject *w)
{
- static PyObject *cmp_obj;
- PyObject *args;
- PyObject *cmp_func;
- PyObject *result;
- long l;
+ static PyObject *cmp_obj;
+ PyObject *args;
+ PyObject *cmp_func;
+ PyObject *result;
+ long l;
- assert(PyInstance_Check(v));
+ assert(PyInstance_Check(v));
- if (cmp_obj == NULL) {
- cmp_obj = PyString_InternFromString("__cmp__");
- if (cmp_obj == NULL)
- return -2;
- }
+ if (cmp_obj == NULL) {
+ cmp_obj = PyString_InternFromString("__cmp__");
+ if (cmp_obj == NULL)
+ return -2;
+ }
- cmp_func = PyObject_GetAttr(v, cmp_obj);
- if (cmp_func == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return -2;
- PyErr_Clear();
- return 2;
- }
+ cmp_func = PyObject_GetAttr(v, cmp_obj);
+ if (cmp_func == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return -2;
+ PyErr_Clear();
+ return 2;
+ }
- args = PyTuple_Pack(1, w);
- if (args == NULL) {
- Py_DECREF(cmp_func);
- return -2;
- }
+ args = PyTuple_Pack(1, w);
+ if (args == NULL) {
+ Py_DECREF(cmp_func);
+ return -2;
+ }
- result = PyEval_CallObject(cmp_func, args);
- Py_DECREF(args);
- Py_DECREF(cmp_func);
+ result = PyEval_CallObject(cmp_func, args);
+ Py_DECREF(args);
+ Py_DECREF(cmp_func);
- if (result == NULL)
- return -2;
+ if (result == NULL)
+ return -2;
- if (result == Py_NotImplemented) {
- Py_DECREF(result);
- return 2;
- }
+ if (result == Py_NotImplemented) {
+ Py_DECREF(result);
+ return 2;
+ }
- l = PyInt_AsLong(result);
- Py_DECREF(result);
- if (l == -1 && PyErr_Occurred()) {
- PyErr_SetString(PyExc_TypeError,
- "comparison did not return an int");
- return -2;
- }
+ l = PyInt_AsLong(result);
+ Py_DECREF(result);
+ if (l == -1 && PyErr_Occurred()) {
+ PyErr_SetString(PyExc_TypeError,
+ "comparison did not return an int");
+ return -2;
+ }
- return l < 0 ? -1 : l > 0 ? 1 : 0;
+ return l < 0 ? -1 : l > 0 ? 1 : 0;
}
/* Try a 3-way comparison, returning an int; either v or w is an instance.
@@ -1708,124 +1708,124 @@
static int
instance_compare(PyObject *v, PyObject *w)
{
- int c;
+ int c;
- c = PyNumber_CoerceEx(&v, &w);
- if (c < 0)
- return -2;
- if (c == 0) {
- /* If neither is now an instance, use regular comparison */
- if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
- c = PyObject_Compare(v, w);
- Py_DECREF(v);
- Py_DECREF(w);
- if (PyErr_Occurred())
- return -2;
- return c < 0 ? -1 : c > 0 ? 1 : 0;
- }
- }
- else {
- /* The coercion didn't do anything.
- Treat this the same as returning v and w unchanged. */
- Py_INCREF(v);
- Py_INCREF(w);
- }
+ c = PyNumber_CoerceEx(&v, &w);
+ if (c < 0)
+ return -2;
+ if (c == 0) {
+ /* If neither is now an instance, use regular comparison */
+ if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
+ c = PyObject_Compare(v, w);
+ Py_DECREF(v);
+ Py_DECREF(w);
+ if (PyErr_Occurred())
+ return -2;
+ return c < 0 ? -1 : c > 0 ? 1 : 0;
+ }
+ }
+ else {
+ /* The coercion didn't do anything.
+ Treat this the same as returning v and w unchanged. */
+ Py_INCREF(v);
+ Py_INCREF(w);
+ }
- if (PyInstance_Check(v)) {
- c = half_cmp(v, w);
- if (c <= 1) {
- Py_DECREF(v);
- Py_DECREF(w);
- return c;
- }
- }
- if (PyInstance_Check(w)) {
- c = half_cmp(w, v);
- if (c <= 1) {
- Py_DECREF(v);
- Py_DECREF(w);
- if (c >= -1)
- c = -c;
- return c;
- }
- }
- Py_DECREF(v);
- Py_DECREF(w);
- return 2;
+ if (PyInstance_Check(v)) {
+ c = half_cmp(v, w);
+ if (c <= 1) {
+ Py_DECREF(v);
+ Py_DECREF(w);
+ return c;
+ }
+ }
+ if (PyInstance_Check(w)) {
+ c = half_cmp(w, v);
+ if (c <= 1) {
+ Py_DECREF(v);
+ Py_DECREF(w);
+ if (c >= -1)
+ c = -c;
+ return c;
+ }
+ }
+ Py_DECREF(v);
+ Py_DECREF(w);
+ return 2;
}
static int
instance_nonzero(PyInstanceObject *self)
{
- PyObject *func, *res;
- long outcome;
- static PyObject *nonzerostr;
+ PyObject *func, *res;
+ long outcome;
+ static PyObject *nonzerostr;
- if (nonzerostr == NULL) {
- nonzerostr = PyString_InternFromString("__nonzero__");
- if (nonzerostr == NULL)
- return -1;
- }
- if ((func = instance_getattr(self, nonzerostr)) == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return -1;
- PyErr_Clear();
- if (lenstr == NULL) {
- lenstr = PyString_InternFromString("__len__");
- if (lenstr == NULL)
- return -1;
- }
- if ((func = instance_getattr(self, lenstr)) == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return -1;
- PyErr_Clear();
- /* Fall back to the default behavior:
- all instances are nonzero */
- return 1;
- }
- }
- res = PyEval_CallObject(func, (PyObject *)NULL);
- Py_DECREF(func);
- if (res == NULL)
- return -1;
- if (!PyInt_Check(res)) {
- Py_DECREF(res);
- PyErr_SetString(PyExc_TypeError,
- "__nonzero__ should return an int");
- return -1;
- }
- outcome = PyInt_AsLong(res);
- Py_DECREF(res);
- if (outcome < 0) {
- PyErr_SetString(PyExc_ValueError,
- "__nonzero__ should return >= 0");
- return -1;
- }
- return outcome > 0;
+ if (nonzerostr == NULL) {
+ nonzerostr = PyString_InternFromString("__nonzero__");
+ if (nonzerostr == NULL)
+ return -1;
+ }
+ if ((func = instance_getattr(self, nonzerostr)) == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return -1;
+ PyErr_Clear();
+ if (lenstr == NULL) {
+ lenstr = PyString_InternFromString("__len__");
+ if (lenstr == NULL)
+ return -1;
+ }
+ if ((func = instance_getattr(self, lenstr)) == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return -1;
+ PyErr_Clear();
+ /* Fall back to the default behavior:
+ all instances are nonzero */
+ return 1;
+ }
+ }
+ res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ if (res == NULL)
+ return -1;
+ if (!PyInt_Check(res)) {
+ Py_DECREF(res);
+ PyErr_SetString(PyExc_TypeError,
+ "__nonzero__ should return an int");
+ return -1;
+ }
+ outcome = PyInt_AsLong(res);
+ Py_DECREF(res);
+ if (outcome < 0) {
+ PyErr_SetString(PyExc_ValueError,
+ "__nonzero__ should return >= 0");
+ return -1;
+ }
+ return outcome > 0;
}
static PyObject *
instance_index(PyInstanceObject *self)
{
- PyObject *func, *res;
- static PyObject *indexstr = NULL;
+ PyObject *func, *res;
+ static PyObject *indexstr = NULL;
- if (indexstr == NULL) {
- indexstr = PyString_InternFromString("__index__");
- if (indexstr == NULL)
- return NULL;
- }
- if ((func = instance_getattr(self, indexstr)) == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- PyErr_SetString(PyExc_TypeError,
- "object cannot be interpreted as an index");
- return NULL;
- }
- res = PyEval_CallObject(func, (PyObject *)NULL);
- Py_DECREF(func);
- return res;
+ if (indexstr == NULL) {
+ indexstr = PyString_InternFromString("__index__");
+ if (indexstr == NULL)
+ return NULL;
+ }
+ if ((func = instance_getattr(self, indexstr)) == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ PyErr_SetString(PyExc_TypeError,
+ "object cannot be interpreted as an index");
+ return NULL;
+ }
+ res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ return res;
}
@@ -1835,22 +1835,22 @@
static PyObject *
instance_int(PyInstanceObject *self)
{
- PyObject *truncated;
- static PyObject *int_name;
- if (int_name == NULL) {
- int_name = PyString_InternFromString("__int__");
- if (int_name == NULL)
- return NULL;
- }
- if (PyObject_HasAttr((PyObject*)self, int_name))
- return generic_unary_op(self, int_name);
+ PyObject *truncated;
+ static PyObject *int_name;
+ if (int_name == NULL) {
+ int_name = PyString_InternFromString("__int__");
+ if (int_name == NULL)
+ return NULL;
+ }
+ if (PyObject_HasAttr((PyObject*)self, int_name))
+ return generic_unary_op(self, int_name);
- truncated = _instance_trunc(self);
- /* __trunc__ is specified to return an Integral type, but
- int() needs to return an int. */
- return _PyNumber_ConvertIntegralToInt(
- truncated,
- "__trunc__ returned non-Integral (type %.200s)");
+ truncated = _instance_trunc(self);
+ /* __trunc__ is specified to return an Integral type, but
+ int() needs to return an int. */
+ return _PyNumber_ConvertIntegralToInt(
+ truncated,
+ "__trunc__ returned non-Integral (type %.200s)");
}
UNARY_FB(instance_long, "__long__", instance_int)
@@ -1861,74 +1861,74 @@
static PyObject *
bin_power(PyObject *v, PyObject *w)
{
- return PyNumber_Power(v, w, Py_None);
+ return PyNumber_Power(v, w, Py_None);
}
/* This version is for ternary calls only (z != None) */
static PyObject *
instance_pow(PyObject *v, PyObject *w, PyObject *z)
{
- if (z == Py_None) {
- return do_binop(v, w, "__pow__", "__rpow__", bin_power);
- }
- else {
- PyObject *func;
- PyObject *args;
- PyObject *result;
+ if (z == Py_None) {
+ return do_binop(v, w, "__pow__", "__rpow__", bin_power);
+ }
+ else {
+ PyObject *func;
+ PyObject *args;
+ PyObject *result;
- /* XXX Doesn't do coercions... */
- func = PyObject_GetAttrString(v, "__pow__");
- if (func == NULL)
- return NULL;
- args = PyTuple_Pack(2, w, z);
- if (args == NULL) {
- Py_DECREF(func);
- return NULL;
- }
- result = PyEval_CallObject(func, args);
- Py_DECREF(func);
- Py_DECREF(args);
- return result;
- }
+ /* XXX Doesn't do coercions... */
+ func = PyObject_GetAttrString(v, "__pow__");
+ if (func == NULL)
+ return NULL;
+ args = PyTuple_Pack(2, w, z);
+ if (args == NULL) {
+ Py_DECREF(func);
+ return NULL;
+ }
+ result = PyEval_CallObject(func, args);
+ Py_DECREF(func);
+ Py_DECREF(args);
+ return result;
+ }
}
static PyObject *
bin_inplace_power(PyObject *v, PyObject *w)
{
- return PyNumber_InPlacePower(v, w, Py_None);
+ return PyNumber_InPlacePower(v, w, Py_None);
}
static PyObject *
instance_ipow(PyObject *v, PyObject *w, PyObject *z)
{
- if (z == Py_None) {
- return do_binop_inplace(v, w, "__ipow__", "__pow__",
- "__rpow__", bin_inplace_power);
- }
- else {
- /* XXX Doesn't do coercions... */
- PyObject *func;
- PyObject *args;
- PyObject *result;
+ if (z == Py_None) {
+ return do_binop_inplace(v, w, "__ipow__", "__pow__",
+ "__rpow__", bin_inplace_power);
+ }
+ else {
+ /* XXX Doesn't do coercions... */
+ PyObject *func;
+ PyObject *args;
+ PyObject *result;
- func = PyObject_GetAttrString(v, "__ipow__");
- if (func == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- return instance_pow(v, w, z);
- }
- args = PyTuple_Pack(2, w, z);
- if (args == NULL) {
- Py_DECREF(func);
- return NULL;
- }
- result = PyEval_CallObject(func, args);
- Py_DECREF(func);
- Py_DECREF(args);
- return result;
- }
+ func = PyObject_GetAttrString(v, "__ipow__");
+ if (func == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ return instance_pow(v, w, z);
+ }
+ args = PyTuple_Pack(2, w, z);
+ if (args == NULL) {
+ Py_DECREF(func);
+ return NULL;
+ }
+ result = PyEval_CallObject(func, args);
+ Py_DECREF(func);
+ Py_DECREF(args);
+ return result;
+ }
}
@@ -1939,93 +1939,93 @@
static int
init_name_op(void)
{
- int i;
- char *_name_op[] = {
- "__lt__",
- "__le__",
- "__eq__",
- "__ne__",
- "__gt__",
- "__ge__",
- };
+ int i;
+ char *_name_op[] = {
+ "__lt__",
+ "__le__",
+ "__eq__",
+ "__ne__",
+ "__gt__",
+ "__ge__",
+ };
- name_op = (PyObject **)malloc(sizeof(PyObject *) * NAME_OPS);
- if (name_op == NULL)
- return -1;
- for (i = 0; i < NAME_OPS; ++i) {
- name_op[i] = PyString_InternFromString(_name_op[i]);
- if (name_op[i] == NULL)
- return -1;
- }
- return 0;
+ name_op = (PyObject **)malloc(sizeof(PyObject *) * NAME_OPS);
+ if (name_op == NULL)
+ return -1;
+ for (i = 0; i < NAME_OPS; ++i) {
+ name_op[i] = PyString_InternFromString(_name_op[i]);
+ if (name_op[i] == NULL)
+ return -1;
+ }
+ return 0;
}
static PyObject *
half_richcompare(PyObject *v, PyObject *w, int op)
{
- PyObject *method;
- PyObject *args;
- PyObject *res;
+ PyObject *method;
+ PyObject *args;
+ PyObject *res;
- assert(PyInstance_Check(v));
+ assert(PyInstance_Check(v));
- if (name_op == NULL) {
- if (init_name_op() < 0)
- return NULL;
- }
- /* If the instance doesn't define an __getattr__ method, use
- instance_getattr2 directly because it will not set an
- exception on failure. */
- if (((PyInstanceObject *)v)->in_class->cl_getattr == NULL)
- method = instance_getattr2((PyInstanceObject *)v,
- name_op[op]);
- else
- method = PyObject_GetAttr(v, name_op[op]);
- if (method == NULL) {
- if (PyErr_Occurred()) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- }
- res = Py_NotImplemented;
- Py_INCREF(res);
- return res;
- }
+ if (name_op == NULL) {
+ if (init_name_op() < 0)
+ return NULL;
+ }
+ /* If the instance doesn't define an __getattr__ method, use
+ instance_getattr2 directly because it will not set an
+ exception on failure. */
+ if (((PyInstanceObject *)v)->in_class->cl_getattr == NULL)
+ method = instance_getattr2((PyInstanceObject *)v,
+ name_op[op]);
+ else
+ method = PyObject_GetAttr(v, name_op[op]);
+ if (method == NULL) {
+ if (PyErr_Occurred()) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ }
+ res = Py_NotImplemented;
+ Py_INCREF(res);
+ return res;
+ }
- args = PyTuple_Pack(1, w);
- if (args == NULL) {
- Py_DECREF(method);
- return NULL;
- }
+ args = PyTuple_Pack(1, w);
+ if (args == NULL) {
+ Py_DECREF(method);
+ return NULL;
+ }
- res = PyEval_CallObject(method, args);
- Py_DECREF(args);
- Py_DECREF(method);
+ res = PyEval_CallObject(method, args);
+ Py_DECREF(args);
+ Py_DECREF(method);
- return res;
+ return res;
}
static PyObject *
instance_richcompare(PyObject *v, PyObject *w, int op)
{
- PyObject *res;
+ PyObject *res;
- if (PyInstance_Check(v)) {
- res = half_richcompare(v, w, op);
- if (res != Py_NotImplemented)
- return res;
- Py_DECREF(res);
- }
+ if (PyInstance_Check(v)) {
+ res = half_richcompare(v, w, op);
+ if (res != Py_NotImplemented)
+ return res;
+ Py_DECREF(res);
+ }
- if (PyInstance_Check(w)) {
- res = half_richcompare(w, v, _Py_SwappedOp[op]);
- if (res != Py_NotImplemented)
- return res;
- Py_DECREF(res);
- }
+ if (PyInstance_Check(w)) {
+ res = half_richcompare(w, v, _Py_SwappedOp[op]);
+ if (res != Py_NotImplemented)
+ return res;
+ Py_DECREF(res);
+ }
- Py_INCREF(Py_NotImplemented);
- return Py_NotImplemented;
+ Py_INCREF(Py_NotImplemented);
+ return Py_NotImplemented;
}
@@ -2033,42 +2033,42 @@
static PyObject *
instance_getiter(PyInstanceObject *self)
{
- PyObject *func;
+ PyObject *func;
- if (iterstr == NULL) {
- iterstr = PyString_InternFromString("__iter__");
- if (iterstr == NULL)
- return NULL;
- }
- if (getitemstr == NULL) {
- getitemstr = PyString_InternFromString("__getitem__");
- if (getitemstr == NULL)
- return NULL;
- }
+ if (iterstr == NULL) {
+ iterstr = PyString_InternFromString("__iter__");
+ if (iterstr == NULL)
+ return NULL;
+ }
+ if (getitemstr == NULL) {
+ getitemstr = PyString_InternFromString("__getitem__");
+ if (getitemstr == NULL)
+ return NULL;
+ }
- if ((func = instance_getattr(self, iterstr)) != NULL) {
- PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
- Py_DECREF(func);
- if (res != NULL && !PyIter_Check(res)) {
- PyErr_Format(PyExc_TypeError,
- "__iter__ returned non-iterator "
- "of type '%.100s'",
- res->ob_type->tp_name);
- Py_DECREF(res);
- res = NULL;
- }
- return res;
- }
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- if ((func = instance_getattr(self, getitemstr)) == NULL) {
- PyErr_SetString(PyExc_TypeError,
- "iteration over non-sequence");
- return NULL;
- }
- Py_DECREF(func);
- return PySeqIter_New((PyObject *)self);
+ if ((func = instance_getattr(self, iterstr)) != NULL) {
+ PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ if (res != NULL && !PyIter_Check(res)) {
+ PyErr_Format(PyExc_TypeError,
+ "__iter__ returned non-iterator "
+ "of type '%.100s'",
+ res->ob_type->tp_name);
+ Py_DECREF(res);
+ res = NULL;
+ }
+ return res;
+ }
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ if ((func = instance_getattr(self, getitemstr)) == NULL) {
+ PyErr_SetString(PyExc_TypeError,
+ "iteration over non-sequence");
+ return NULL;
+ }
+ Py_DECREF(func);
+ return PySeqIter_New((PyObject *)self);
}
@@ -2076,146 +2076,146 @@
static PyObject *
instance_iternext(PyInstanceObject *self)
{
- PyObject *func;
+ PyObject *func;
- if (nextstr == NULL) {
- nextstr = PyString_InternFromString("next");
- if (nextstr == NULL)
- return NULL;
- }
+ if (nextstr == NULL) {
+ nextstr = PyString_InternFromString("next");
+ if (nextstr == NULL)
+ return NULL;
+ }
- if ((func = instance_getattr(self, nextstr)) != NULL) {
- PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
- Py_DECREF(func);
- if (res != NULL) {
- return res;
- }
- if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
- PyErr_Clear();
- return NULL;
- }
- return NULL;
- }
- PyErr_SetString(PyExc_TypeError, "instance has no next() method");
- return NULL;
+ if ((func = instance_getattr(self, nextstr)) != NULL) {
+ PyObject *res = PyEval_CallObject(func, (PyObject *)NULL);
+ Py_DECREF(func);
+ if (res != NULL) {
+ return res;
+ }
+ if (PyErr_ExceptionMatches(PyExc_StopIteration)) {
+ PyErr_Clear();
+ return NULL;
+ }
+ return NULL;
+ }
+ PyErr_SetString(PyExc_TypeError, "instance has no next() method");
+ return NULL;
}
static PyObject *
instance_call(PyObject *func, PyObject *arg, PyObject *kw)
{
- PyObject *res, *call = PyObject_GetAttrString(func, "__call__");
- if (call == NULL) {
- PyInstanceObject *inst = (PyInstanceObject*) func;
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- PyErr_Format(PyExc_AttributeError,
- "%.200s instance has no __call__ method",
- PyString_AsString(inst->in_class->cl_name));
- return NULL;
- }
- /* We must check and increment the recursion depth here. Scenario:
- class A:
- pass
- A.__call__ = A() # that's right
- a = A() # ok
- a() # infinite recursion
- This bounces between instance_call() and PyObject_Call() without
- ever hitting eval_frame() (which has the main recursion check). */
- if (Py_EnterRecursiveCall(" in __call__")) {
- res = NULL;
- }
- else {
- res = PyObject_Call(call, arg, kw);
- Py_LeaveRecursiveCall();
- }
- Py_DECREF(call);
- return res;
+ PyObject *res, *call = PyObject_GetAttrString(func, "__call__");
+ if (call == NULL) {
+ PyInstanceObject *inst = (PyInstanceObject*) func;
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ PyErr_Format(PyExc_AttributeError,
+ "%.200s instance has no __call__ method",
+ PyString_AsString(inst->in_class->cl_name));
+ return NULL;
+ }
+ /* We must check and increment the recursion depth here. Scenario:
+ class A:
+ pass
+ A.__call__ = A() # that's right
+ a = A() # ok
+ a() # infinite recursion
+ This bounces between instance_call() and PyObject_Call() without
+ ever hitting eval_frame() (which has the main recursion check). */
+ if (Py_EnterRecursiveCall(" in __call__")) {
+ res = NULL;
+ }
+ else {
+ res = PyObject_Call(call, arg, kw);
+ Py_LeaveRecursiveCall();
+ }
+ Py_DECREF(call);
+ return res;
}
static PyNumberMethods instance_as_number = {
- instance_add, /* nb_add */
- instance_sub, /* nb_subtract */
- instance_mul, /* nb_multiply */
- instance_div, /* nb_divide */
- instance_mod, /* nb_remainder */
- instance_divmod, /* nb_divmod */
- instance_pow, /* nb_power */
- (unaryfunc)instance_neg, /* nb_negative */
- (unaryfunc)instance_pos, /* nb_positive */
- (unaryfunc)instance_abs, /* nb_absolute */
- (inquiry)instance_nonzero, /* nb_nonzero */
- (unaryfunc)instance_invert, /* nb_invert */
- instance_lshift, /* nb_lshift */
- instance_rshift, /* nb_rshift */
- instance_and, /* nb_and */
- instance_xor, /* nb_xor */
- instance_or, /* nb_or */
- instance_coerce, /* nb_coerce */
- (unaryfunc)instance_int, /* nb_int */
- (unaryfunc)instance_long, /* nb_long */
- (unaryfunc)instance_float, /* nb_float */
- (unaryfunc)instance_oct, /* nb_oct */
- (unaryfunc)instance_hex, /* nb_hex */
- instance_iadd, /* nb_inplace_add */
- instance_isub, /* nb_inplace_subtract */
- instance_imul, /* nb_inplace_multiply */
- instance_idiv, /* nb_inplace_divide */
- instance_imod, /* nb_inplace_remainder */
- instance_ipow, /* nb_inplace_power */
- instance_ilshift, /* nb_inplace_lshift */
- instance_irshift, /* nb_inplace_rshift */
- instance_iand, /* nb_inplace_and */
- instance_ixor, /* nb_inplace_xor */
- instance_ior, /* nb_inplace_or */
- instance_floordiv, /* nb_floor_divide */
- instance_truediv, /* nb_true_divide */
- instance_ifloordiv, /* nb_inplace_floor_divide */
- instance_itruediv, /* nb_inplace_true_divide */
- (unaryfunc)instance_index, /* nb_index */
+ instance_add, /* nb_add */
+ instance_sub, /* nb_subtract */
+ instance_mul, /* nb_multiply */
+ instance_div, /* nb_divide */
+ instance_mod, /* nb_remainder */
+ instance_divmod, /* nb_divmod */
+ instance_pow, /* nb_power */
+ (unaryfunc)instance_neg, /* nb_negative */
+ (unaryfunc)instance_pos, /* nb_positive */
+ (unaryfunc)instance_abs, /* nb_absolute */
+ (inquiry)instance_nonzero, /* nb_nonzero */
+ (unaryfunc)instance_invert, /* nb_invert */
+ instance_lshift, /* nb_lshift */
+ instance_rshift, /* nb_rshift */
+ instance_and, /* nb_and */
+ instance_xor, /* nb_xor */
+ instance_or, /* nb_or */
+ instance_coerce, /* nb_coerce */
+ (unaryfunc)instance_int, /* nb_int */
+ (unaryfunc)instance_long, /* nb_long */
+ (unaryfunc)instance_float, /* nb_float */
+ (unaryfunc)instance_oct, /* nb_oct */
+ (unaryfunc)instance_hex, /* nb_hex */
+ instance_iadd, /* nb_inplace_add */
+ instance_isub, /* nb_inplace_subtract */
+ instance_imul, /* nb_inplace_multiply */
+ instance_idiv, /* nb_inplace_divide */
+ instance_imod, /* nb_inplace_remainder */
+ instance_ipow, /* nb_inplace_power */
+ instance_ilshift, /* nb_inplace_lshift */
+ instance_irshift, /* nb_inplace_rshift */
+ instance_iand, /* nb_inplace_and */
+ instance_ixor, /* nb_inplace_xor */
+ instance_ior, /* nb_inplace_or */
+ instance_floordiv, /* nb_floor_divide */
+ instance_truediv, /* nb_true_divide */
+ instance_ifloordiv, /* nb_inplace_floor_divide */
+ instance_itruediv, /* nb_inplace_true_divide */
+ (unaryfunc)instance_index, /* nb_index */
};
PyTypeObject PyInstance_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
- 0,
- "instance",
- sizeof(PyInstanceObject),
- 0,
- (destructor)instance_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- 0, /* tp_getattr */
- 0, /* tp_setattr */
- instance_compare, /* tp_compare */
- (reprfunc)instance_repr, /* tp_repr */
- &instance_as_number, /* tp_as_number */
- &instance_as_sequence, /* tp_as_sequence */
- &instance_as_mapping, /* tp_as_mapping */
- (hashfunc)instance_hash, /* tp_hash */
- instance_call, /* tp_call */
- (reprfunc)instance_str, /* tp_str */
- (getattrofunc)instance_getattr, /* tp_getattro */
- (setattrofunc)instance_setattr, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES,/*tp_flags*/
- instance_doc, /* tp_doc */
- (traverseproc)instance_traverse, /* tp_traverse */
- 0, /* tp_clear */
- instance_richcompare, /* tp_richcompare */
- offsetof(PyInstanceObject, in_weakreflist), /* tp_weaklistoffset */
- (getiterfunc)instance_getiter, /* tp_iter */
- (iternextfunc)instance_iternext, /* tp_iternext */
- 0, /* 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 */
- instance_new, /* tp_new */
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0,
+ "instance",
+ sizeof(PyInstanceObject),
+ 0,
+ (destructor)instance_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ instance_compare, /* tp_compare */
+ (reprfunc)instance_repr, /* tp_repr */
+ &instance_as_number, /* tp_as_number */
+ &instance_as_sequence, /* tp_as_sequence */
+ &instance_as_mapping, /* tp_as_mapping */
+ (hashfunc)instance_hash, /* tp_hash */
+ instance_call, /* tp_call */
+ (reprfunc)instance_str, /* tp_str */
+ (getattrofunc)instance_getattr, /* tp_getattro */
+ (setattrofunc)instance_setattr, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_CHECKTYPES,/*tp_flags*/
+ instance_doc, /* tp_doc */
+ (traverseproc)instance_traverse, /* tp_traverse */
+ 0, /* tp_clear */
+ instance_richcompare, /* tp_richcompare */
+ offsetof(PyInstanceObject, in_weakreflist), /* tp_weaklistoffset */
+ (getiterfunc)instance_getiter, /* tp_iter */
+ (iternextfunc)instance_iternext, /* tp_iternext */
+ 0, /* 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 */
+ instance_new, /* tp_new */
};
@@ -2228,27 +2228,27 @@
PyObject *
PyMethod_New(PyObject *func, PyObject *self, PyObject *klass)
{
- register PyMethodObject *im;
- im = free_list;
- if (im != NULL) {
- free_list = (PyMethodObject *)(im->im_self);
- PyObject_INIT(im, &PyMethod_Type);
- numfree--;
- }
- else {
- im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
- if (im == NULL)
- return NULL;
- }
- im->im_weakreflist = NULL;
- Py_INCREF(func);
- im->im_func = func;
- Py_XINCREF(self);
- im->im_self = self;
- Py_XINCREF(klass);
- im->im_class = klass;
- _PyObject_GC_TRACK(im);
- return (PyObject *)im;
+ register PyMethodObject *im;
+ im = free_list;
+ if (im != NULL) {
+ free_list = (PyMethodObject *)(im->im_self);
+ PyObject_INIT(im, &PyMethod_Type);
+ numfree--;
+ }
+ else {
+ im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
+ if (im == NULL)
+ return NULL;
+ }
+ im->im_weakreflist = NULL;
+ Py_INCREF(func);
+ im->im_func = func;
+ Py_XINCREF(self);
+ im->im_self = self;
+ Py_XINCREF(klass);
+ im->im_class = klass;
+ _PyObject_GC_TRACK(im);
+ return (PyObject *)im;
}
/* Descriptors for PyMethod attributes */
@@ -2258,17 +2258,17 @@
#define OFF(x) offsetof(PyMethodObject, x)
static PyMemberDef instancemethod_memberlist[] = {
- {"im_class", T_OBJECT, OFF(im_class), READONLY|RESTRICTED,
- "the class associated with a method"},
- {"im_func", T_OBJECT, OFF(im_func), READONLY|RESTRICTED,
- "the function (or other callable) implementing a method"},
- {"__func__", T_OBJECT, OFF(im_func), READONLY|RESTRICTED,
- "the function (or other callable) implementing a method"},
- {"im_self", T_OBJECT, OFF(im_self), READONLY|RESTRICTED,
- "the instance to which a method is bound; None for unbound methods"},
- {"__self__", T_OBJECT, OFF(im_self), READONLY|RESTRICTED,
- "the instance to which a method is bound; None for unbound methods"},
- {NULL} /* Sentinel */
+ {"im_class", T_OBJECT, OFF(im_class), READONLY|RESTRICTED,
+ "the class associated with a method"},
+ {"im_func", T_OBJECT, OFF(im_func), READONLY|RESTRICTED,
+ "the function (or other callable) implementing a method"},
+ {"__func__", T_OBJECT, OFF(im_func), READONLY|RESTRICTED,
+ "the function (or other callable) implementing a method"},
+ {"im_self", T_OBJECT, OFF(im_self), READONLY|RESTRICTED,
+ "the instance to which a method is bound; None for unbound methods"},
+ {"__self__", T_OBJECT, OFF(im_self), READONLY|RESTRICTED,
+ "the instance to which a method is bound; None for unbound methods"},
+ {NULL} /* Sentinel */
};
/* Christian Tismer argued convincingly that method attributes should
@@ -2279,46 +2279,46 @@
static PyObject *
instancemethod_get_doc(PyMethodObject *im, void *context)
{
- static PyObject *docstr;
- if (docstr == NULL) {
- docstr= PyString_InternFromString("__doc__");
- if (docstr == NULL)
- return NULL;
- }
- return PyObject_GetAttr(im->im_func, docstr);
+ static PyObject *docstr;
+ if (docstr == NULL) {
+ docstr= PyString_InternFromString("__doc__");
+ if (docstr == NULL)
+ return NULL;
+ }
+ return PyObject_GetAttr(im->im_func, docstr);
}
static PyGetSetDef instancemethod_getset[] = {
- {"__doc__", (getter)instancemethod_get_doc, NULL, NULL},
- {0}
+ {"__doc__", (getter)instancemethod_get_doc, NULL, NULL},
+ {0}
};
static PyObject *
instancemethod_getattro(PyObject *obj, PyObject *name)
{
- PyMethodObject *im = (PyMethodObject *)obj;
- PyTypeObject *tp = obj->ob_type;
- PyObject *descr = NULL;
+ PyMethodObject *im = (PyMethodObject *)obj;
+ PyTypeObject *tp = obj->ob_type;
+ PyObject *descr = NULL;
- if (PyType_HasFeature(tp, Py_TPFLAGS_HAVE_CLASS)) {
- if (tp->tp_dict == NULL) {
- if (PyType_Ready(tp) < 0)
- return NULL;
- }
- descr = _PyType_Lookup(tp, name);
- }
+ if (PyType_HasFeature(tp, Py_TPFLAGS_HAVE_CLASS)) {
+ if (tp->tp_dict == NULL) {
+ if (PyType_Ready(tp) < 0)
+ return NULL;
+ }
+ descr = _PyType_Lookup(tp, name);
+ }
- if (descr != NULL) {
- descrgetfunc f = TP_DESCR_GET(descr->ob_type);
- if (f != NULL)
- return f(descr, obj, (PyObject *)obj->ob_type);
- else {
- Py_INCREF(descr);
- return descr;
- }
- }
+ if (descr != NULL) {
+ descrgetfunc f = TP_DESCR_GET(descr->ob_type);
+ if (f != NULL)
+ return f(descr, obj, (PyObject *)obj->ob_type);
+ else {
+ Py_INCREF(descr);
+ return descr;
+ }
+ }
- return PyObject_GetAttr(im->im_func, name);
+ return PyObject_GetAttr(im->im_func, name);
}
PyDoc_STRVAR(instancemethod_doc,
@@ -2329,323 +2329,323 @@
static PyObject *
instancemethod_new(PyTypeObject* type, PyObject* args, PyObject *kw)
{
- PyObject *func;
- PyObject *self;
- PyObject *classObj = NULL;
+ PyObject *func;
+ PyObject *self;
+ PyObject *classObj = NULL;
- if (!_PyArg_NoKeywords("instancemethod", kw))
- return NULL;
- if (!PyArg_UnpackTuple(args, "instancemethod", 2, 3,
- &func, &self, &classObj))
- return NULL;
- if (!PyCallable_Check(func)) {
- PyErr_SetString(PyExc_TypeError,
- "first argument must be callable");
- return NULL;
- }
- if (self == Py_None)
- self = NULL;
- if (self == NULL && classObj == NULL) {
- PyErr_SetString(PyExc_TypeError,
- "unbound methods must have non-NULL im_class");
- return NULL;
- }
+ if (!_PyArg_NoKeywords("instancemethod", kw))
+ return NULL;
+ if (!PyArg_UnpackTuple(args, "instancemethod", 2, 3,
+ &func, &self, &classObj))
+ return NULL;
+ if (!PyCallable_Check(func)) {
+ PyErr_SetString(PyExc_TypeError,
+ "first argument must be callable");
+ return NULL;
+ }
+ if (self == Py_None)
+ self = NULL;
+ if (self == NULL && classObj == NULL) {
+ PyErr_SetString(PyExc_TypeError,
+ "unbound methods must have non-NULL im_class");
+ return NULL;
+ }
- return PyMethod_New(func, self, classObj);
+ return PyMethod_New(func, self, classObj);
}
static void
instancemethod_dealloc(register PyMethodObject *im)
{
- _PyObject_GC_UNTRACK(im);
- if (im->im_weakreflist != NULL)
- PyObject_ClearWeakRefs((PyObject *)im);
- Py_DECREF(im->im_func);
- Py_XDECREF(im->im_self);
- Py_XDECREF(im->im_class);
- if (numfree < PyMethod_MAXFREELIST) {
- im->im_self = (PyObject *)free_list;
- free_list = im;
- numfree++;
- }
- else {
- PyObject_GC_Del(im);
- }
+ _PyObject_GC_UNTRACK(im);
+ if (im->im_weakreflist != NULL)
+ PyObject_ClearWeakRefs((PyObject *)im);
+ Py_DECREF(im->im_func);
+ Py_XDECREF(im->im_self);
+ Py_XDECREF(im->im_class);
+ if (numfree < PyMethod_MAXFREELIST) {
+ im->im_self = (PyObject *)free_list;
+ free_list = im;
+ numfree++;
+ }
+ else {
+ PyObject_GC_Del(im);
+ }
}
static int
instancemethod_compare(PyMethodObject *a, PyMethodObject *b)
{
- int cmp;
- cmp = PyObject_Compare(a->im_func, b->im_func);
- if (cmp)
- return cmp;
+ int cmp;
+ cmp = PyObject_Compare(a->im_func, b->im_func);
+ if (cmp)
+ return cmp;
- if (a->im_self == b->im_self)
- return 0;
- if (a->im_self == NULL || b->im_self == NULL)
- return (a->im_self < b->im_self) ? -1 : 1;
- else
- return PyObject_Compare(a->im_self, b->im_self);
+ if (a->im_self == b->im_self)
+ return 0;
+ if (a->im_self == NULL || b->im_self == NULL)
+ return (a->im_self < b->im_self) ? -1 : 1;
+ else
+ return PyObject_Compare(a->im_self, b->im_self);
}
static PyObject *
instancemethod_repr(PyMethodObject *a)
{
- PyObject *self = a->im_self;
- PyObject *func = a->im_func;
- PyObject *klass = a->im_class;
- PyObject *funcname = NULL, *klassname = NULL, *result = NULL;
- char *sfuncname = "?", *sklassname = "?";
+ PyObject *self = a->im_self;
+ PyObject *func = a->im_func;
+ PyObject *klass = a->im_class;
+ PyObject *funcname = NULL, *klassname = NULL, *result = NULL;
+ char *sfuncname = "?", *sklassname = "?";
- funcname = PyObject_GetAttrString(func, "__name__");
- if (funcname == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- }
- else if (!PyString_Check(funcname)) {
- Py_DECREF(funcname);
- funcname = NULL;
- }
- else
- sfuncname = PyString_AS_STRING(funcname);
- if (klass == NULL)
- klassname = NULL;
- else {
- klassname = PyObject_GetAttrString(klass, "__name__");
- if (klassname == NULL) {
- if (!PyErr_ExceptionMatches(PyExc_AttributeError))
- return NULL;
- PyErr_Clear();
- }
- else if (!PyString_Check(klassname)) {
- Py_DECREF(klassname);
- klassname = NULL;
- }
- else
- sklassname = PyString_AS_STRING(klassname);
- }
- if (self == NULL)
- result = PyString_FromFormat("<unbound method %s.%s>",
- sklassname, sfuncname);
- else {
- /* XXX Shouldn't use repr() here! */
- PyObject *selfrepr = PyObject_Repr(self);
- if (selfrepr == NULL)
- goto fail;
- if (!PyString_Check(selfrepr)) {
- Py_DECREF(selfrepr);
- goto fail;
- }
- result = PyString_FromFormat("<bound method %s.%s of %s>",
- sklassname, sfuncname,
- PyString_AS_STRING(selfrepr));
- Py_DECREF(selfrepr);
- }
+ funcname = PyObject_GetAttrString(func, "__name__");
+ if (funcname == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ }
+ else if (!PyString_Check(funcname)) {
+ Py_DECREF(funcname);
+ funcname = NULL;
+ }
+ else
+ sfuncname = PyString_AS_STRING(funcname);
+ if (klass == NULL)
+ klassname = NULL;
+ else {
+ klassname = PyObject_GetAttrString(klass, "__name__");
+ if (klassname == NULL) {
+ if (!PyErr_ExceptionMatches(PyExc_AttributeError))
+ return NULL;
+ PyErr_Clear();
+ }
+ else if (!PyString_Check(klassname)) {
+ Py_DECREF(klassname);
+ klassname = NULL;
+ }
+ else
+ sklassname = PyString_AS_STRING(klassname);
+ }
+ if (self == NULL)
+ result = PyString_FromFormat("<unbound method %s.%s>",
+ sklassname, sfuncname);
+ else {
+ /* XXX Shouldn't use repr() here! */
+ PyObject *selfrepr = PyObject_Repr(self);
+ if (selfrepr == NULL)
+ goto fail;
+ if (!PyString_Check(selfrepr)) {
+ Py_DECREF(selfrepr);
+ goto fail;
+ }
+ result = PyString_FromFormat("<bound method %s.%s of %s>",
+ sklassname, sfuncname,
+ PyString_AS_STRING(selfrepr));
+ Py_DECREF(selfrepr);
+ }
fail:
- Py_XDECREF(funcname);
- Py_XDECREF(klassname);
- return result;
+ Py_XDECREF(funcname);
+ Py_XDECREF(klassname);
+ return result;
}
static long
instancemethod_hash(PyMethodObject *a)
{
- long x, y;
- if (a->im_self == NULL)
- x = PyObject_Hash(Py_None);
- else
- x = PyObject_Hash(a->im_self);
- if (x == -1)
- return -1;
- y = PyObject_Hash(a->im_func);
- if (y == -1)
- return -1;
- x = x ^ y;
- if (x == -1)
- x = -2;
- return x;
+ long x, y;
+ if (a->im_self == NULL)
+ x = PyObject_Hash(Py_None);
+ else
+ x = PyObject_Hash(a->im_self);
+ if (x == -1)
+ return -1;
+ y = PyObject_Hash(a->im_func);
+ if (y == -1)
+ return -1;
+ x = x ^ y;
+ if (x == -1)
+ x = -2;
+ return x;
}
static int
instancemethod_traverse(PyMethodObject *im, visitproc visit, void *arg)
{
- Py_VISIT(im->im_func);
- Py_VISIT(im->im_self);
- Py_VISIT(im->im_class);
- return 0;
+ Py_VISIT(im->im_func);
+ Py_VISIT(im->im_self);
+ Py_VISIT(im->im_class);
+ return 0;
}
static void
getclassname(PyObject *klass, char *buf, int bufsize)
{
- PyObject *name;
+ PyObject *name;
- assert(bufsize > 1);
- strcpy(buf, "?"); /* Default outcome */
- if (klass == NULL)
- return;
- name = PyObject_GetAttrString(klass, "__name__");
- if (name == NULL) {
- /* This function cannot return an exception */
- PyErr_Clear();
- return;
- }
- if (PyString_Check(name)) {
- strncpy(buf, PyString_AS_STRING(name), bufsize);
- buf[bufsize-1] = '\0';
- }
- Py_DECREF(name);
+ assert(bufsize > 1);
+ strcpy(buf, "?"); /* Default outcome */
+ if (klass == NULL)
+ return;
+ name = PyObject_GetAttrString(klass, "__name__");
+ if (name == NULL) {
+ /* This function cannot return an exception */
+ PyErr_Clear();
+ return;
+ }
+ if (PyString_Check(name)) {
+ strncpy(buf, PyString_AS_STRING(name), bufsize);
+ buf[bufsize-1] = '\0';
+ }
+ Py_DECREF(name);
}
static void
getinstclassname(PyObject *inst, char *buf, int bufsize)
{
- PyObject *klass;
+ PyObject *klass;
- if (inst == NULL) {
- assert(bufsize > 0 && (size_t)bufsize > strlen("nothing"));
- strcpy(buf, "nothing");
- return;
- }
+ if (inst == NULL) {
+ assert(bufsize > 0 && (size_t)bufsize > strlen("nothing"));
+ strcpy(buf, "nothing");
+ return;
+ }
- klass = PyObject_GetAttrString(inst, "__class__");
- if (klass == NULL) {
- /* This function cannot return an exception */
- PyErr_Clear();
- klass = (PyObject *)(inst->ob_type);
- Py_INCREF(klass);
- }
- getclassname(klass, buf, bufsize);
- Py_XDECREF(klass);
+ klass = PyObject_GetAttrString(inst, "__class__");
+ if (klass == NULL) {
+ /* This function cannot return an exception */
+ PyErr_Clear();
+ klass = (PyObject *)(inst->ob_type);
+ Py_INCREF(klass);
+ }
+ getclassname(klass, buf, bufsize);
+ Py_XDECREF(klass);
}
static PyObject *
instancemethod_call(PyObject *func, PyObject *arg, PyObject *kw)
{
- PyObject *self = PyMethod_GET_SELF(func);
- PyObject *klass = PyMethod_GET_CLASS(func);
- PyObject *result;
+ PyObject *self = PyMethod_GET_SELF(func);
+ PyObject *klass = PyMethod_GET_CLASS(func);
+ PyObject *result;
- func = PyMethod_GET_FUNCTION(func);
- if (self == NULL) {
- /* Unbound methods must be called with an instance of
- the class (or a derived class) as first argument */
- int ok;
- if (PyTuple_Size(arg) >= 1)
- self = PyTuple_GET_ITEM(arg, 0);
- if (self == NULL)
- ok = 0;
- else {
- ok = PyObject_IsInstance(self, klass);
- if (ok < 0)
- return NULL;
- }
- if (!ok) {
- char clsbuf[256];
- char instbuf[256];
- getclassname(klass, clsbuf, sizeof(clsbuf));
- getinstclassname(self, instbuf, sizeof(instbuf));
- PyErr_Format(PyExc_TypeError,
- "unbound method %s%s must be called with "
- "%s instance as first argument "
- "(got %s%s instead)",
- PyEval_GetFuncName(func),
- PyEval_GetFuncDesc(func),
- clsbuf,
- instbuf,
- self == NULL ? "" : " instance");
- return NULL;
- }
- Py_INCREF(arg);
- }
- else {
- Py_ssize_t argcount = PyTuple_Size(arg);
- PyObject *newarg = PyTuple_New(argcount + 1);
- int i;
- if (newarg == NULL)
- return NULL;
- Py_INCREF(self);
- PyTuple_SET_ITEM(newarg, 0, self);
- for (i = 0; i < argcount; i++) {
- PyObject *v = PyTuple_GET_ITEM(arg, i);
- Py_XINCREF(v);
- PyTuple_SET_ITEM(newarg, i+1, v);
- }
- arg = newarg;
- }
- result = PyObject_Call((PyObject *)func, arg, kw);
- Py_DECREF(arg);
- return result;
+ func = PyMethod_GET_FUNCTION(func);
+ if (self == NULL) {
+ /* Unbound methods must be called with an instance of
+ the class (or a derived class) as first argument */
+ int ok;
+ if (PyTuple_Size(arg) >= 1)
+ self = PyTuple_GET_ITEM(arg, 0);
+ if (self == NULL)
+ ok = 0;
+ else {
+ ok = PyObject_IsInstance(self, klass);
+ if (ok < 0)
+ return NULL;
+ }
+ if (!ok) {
+ char clsbuf[256];
+ char instbuf[256];
+ getclassname(klass, clsbuf, sizeof(clsbuf));
+ getinstclassname(self, instbuf, sizeof(instbuf));
+ PyErr_Format(PyExc_TypeError,
+ "unbound method %s%s must be called with "
+ "%s instance as first argument "
+ "(got %s%s instead)",
+ PyEval_GetFuncName(func),
+ PyEval_GetFuncDesc(func),
+ clsbuf,
+ instbuf,
+ self == NULL ? "" : " instance");
+ return NULL;
+ }
+ Py_INCREF(arg);
+ }
+ else {
+ Py_ssize_t argcount = PyTuple_Size(arg);
+ PyObject *newarg = PyTuple_New(argcount + 1);
+ int i;
+ if (newarg == NULL)
+ return NULL;
+ Py_INCREF(self);
+ PyTuple_SET_ITEM(newarg, 0, self);
+ for (i = 0; i < argcount; i++) {
+ PyObject *v = PyTuple_GET_ITEM(arg, i);
+ Py_XINCREF(v);
+ PyTuple_SET_ITEM(newarg, i+1, v);
+ }
+ arg = newarg;
+ }
+ result = PyObject_Call((PyObject *)func, arg, kw);
+ Py_DECREF(arg);
+ return result;
}
static PyObject *
instancemethod_descr_get(PyObject *meth, PyObject *obj, PyObject *cls)
{
- /* Don't rebind an already bound method, or an unbound method
- of a class that's not a base class of cls. */
+ /* Don't rebind an already bound method, or an unbound method
+ of a class that's not a base class of cls. */
- if (PyMethod_GET_SELF(meth) != NULL) {
- /* Already bound */
- Py_INCREF(meth);
- return meth;
- }
- /* No, it is an unbound method */
- if (PyMethod_GET_CLASS(meth) != NULL && cls != NULL) {
- /* Do subclass test. If it fails, return meth unchanged. */
- int ok = PyObject_IsSubclass(cls, PyMethod_GET_CLASS(meth));
- if (ok < 0)
- return NULL;
- if (!ok) {
- Py_INCREF(meth);
- return meth;
- }
- }
- /* Bind it to obj */
- return PyMethod_New(PyMethod_GET_FUNCTION(meth), obj, cls);
+ if (PyMethod_GET_SELF(meth) != NULL) {
+ /* Already bound */
+ Py_INCREF(meth);
+ return meth;
+ }
+ /* No, it is an unbound method */
+ if (PyMethod_GET_CLASS(meth) != NULL && cls != NULL) {
+ /* Do subclass test. If it fails, return meth unchanged. */
+ int ok = PyObject_IsSubclass(cls, PyMethod_GET_CLASS(meth));
+ if (ok < 0)
+ return NULL;
+ if (!ok) {
+ Py_INCREF(meth);
+ return meth;
+ }
+ }
+ /* Bind it to obj */
+ return PyMethod_New(PyMethod_GET_FUNCTION(meth), obj, cls);
}
PyTypeObject PyMethod_Type = {
- PyObject_HEAD_INIT(&PyType_Type)
- 0,
- "instancemethod",
- sizeof(PyMethodObject),
- 0,
- (destructor)instancemethod_dealloc, /* tp_dealloc */
- 0, /* tp_print */
- 0, /* tp_getattr */
- 0, /* tp_setattr */
- (cmpfunc)instancemethod_compare, /* tp_compare */
- (reprfunc)instancemethod_repr, /* tp_repr */
- 0, /* tp_as_number */
- 0, /* tp_as_sequence */
- 0, /* tp_as_mapping */
- (hashfunc)instancemethod_hash, /* tp_hash */
- instancemethod_call, /* tp_call */
- 0, /* tp_str */
- instancemethod_getattro, /* tp_getattro */
- PyObject_GenericSetAttr, /* tp_setattro */
- 0, /* tp_as_buffer */
- Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
- instancemethod_doc, /* tp_doc */
- (traverseproc)instancemethod_traverse, /* tp_traverse */
- 0, /* tp_clear */
- 0, /* tp_richcompare */
- offsetof(PyMethodObject, im_weakreflist), /* tp_weaklistoffset */
- 0, /* tp_iter */
- 0, /* tp_iternext */
- 0, /* tp_methods */
- instancemethod_memberlist, /* tp_members */
- instancemethod_getset, /* tp_getset */
- 0, /* tp_base */
- 0, /* tp_dict */
- instancemethod_descr_get, /* tp_descr_get */
- 0, /* tp_descr_set */
- 0, /* tp_dictoffset */
- 0, /* tp_init */
- 0, /* tp_alloc */
- instancemethod_new, /* tp_new */
+ PyObject_HEAD_INIT(&PyType_Type)
+ 0,
+ "instancemethod",
+ sizeof(PyMethodObject),
+ 0,
+ (destructor)instancemethod_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ (cmpfunc)instancemethod_compare, /* tp_compare */
+ (reprfunc)instancemethod_repr, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ (hashfunc)instancemethod_hash, /* tp_hash */
+ instancemethod_call, /* tp_call */
+ 0, /* tp_str */
+ instancemethod_getattro, /* tp_getattro */
+ PyObject_GenericSetAttr, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_WEAKREFS, /* tp_flags */
+ instancemethod_doc, /* tp_doc */
+ (traverseproc)instancemethod_traverse, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ offsetof(PyMethodObject, im_weakreflist), /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ 0, /* tp_methods */
+ instancemethod_memberlist, /* tp_members */
+ instancemethod_getset, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ instancemethod_descr_get, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0, /* tp_init */
+ 0, /* tp_alloc */
+ instancemethod_new, /* tp_new */
};
/* Clear out the free list */
@@ -2653,20 +2653,20 @@
int
PyMethod_ClearFreeList(void)
{
- int freelist_size = numfree;
-
- while (free_list) {
- PyMethodObject *im = free_list;
- free_list = (PyMethodObject *)(im->im_self);
- PyObject_GC_Del(im);
- numfree--;
- }
- assert(numfree == 0);
- return freelist_size;
+ int freelist_size = numfree;
+
+ while (free_list) {
+ PyMethodObject *im = free_list;
+ free_list = (PyMethodObject *)(im->im_self);
+ PyObject_GC_Del(im);
+ numfree--;
+ }
+ assert(numfree == 0);
+ return freelist_size;
}
void
PyMethod_Fini(void)
{
- (void)PyMethod_ClearFreeList();
+ (void)PyMethod_ClearFreeList();
}