Rooba
/
cpython
mirror of https://github.com/python/cpython.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cpython/Objects/classobject.c

1689 lines
39 KiB
C
Raw Blame History

/***********************************************************
Copyright (c) 2000, BeOpen.com.
Copyright (c) 1995-2000, Corporation for National Research Initiatives.
Copyright (c) 1990-1995, Stichting Mathematisch Centrum.
All rights reserved.
See the file "Misc/COPYRIGHT" for information on usage and
redistribution of this file, and for a DISCLAIMER OF ALL WARRANTIES.
******************************************************************/
/* Class object implementation */
#include "Python.h"
#include "structmember.h"
/* Forward */
static PyObject *class_lookup(PyClassObject *, PyObject *,
PyClassObject **);
static PyObject *instance_getattr1(PyInstanceObject *, PyObject *);
static PyObject *instance_getattr2(PyInstanceObject *, PyObject *);
static PyObject *getattrstr, *setattrstr, *delattrstr;
PyObject *
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_SystemError,
"PyClass_New: name must be a string");
return NULL;
}
if (dict == NULL || !PyDict_Check(dict)) {
PyErr_SetString(PyExc_SystemError,
"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 {
int i;
if (!PyTuple_Check(bases)) {
PyErr_SetString(PyExc_SystemError,
"PyClass_New: bases must be a tuple");
return NULL;
}
i = PyTuple_Size(bases);
while (--i >= 0) {
if (!PyClass_Check(PyTuple_GetItem(bases, i))) {
PyErr_SetString(PyExc_SystemError,
"PyClass_New: base must be a class");
return NULL;
}
}
Py_INCREF(bases);
}
op = PyObject_NEW(PyClassObject, &PyClass_Type);
if (op == NULL) {
Py_DECREF(bases);
return NULL;
}
op->cl_bases = bases;
Py_INCREF(dict);
op->cl_dict = dict;
Py_XINCREF(name);
op->cl_name = name;
if (getattrstr == NULL) {
getattrstr = PyString_InternFromString("__getattr__");
setattrstr = PyString_InternFromString("__setattr__");
delattrstr = PyString_InternFromString("__delattr__");
}
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_Init(op);
return (PyObject *) op;
}
/* Class methods */
static void
class_dealloc(PyClassObject *op)
{
PyObject_GC_Fini(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);
op = (PyClassObject *) PyObject_AS_GC(op);
PyObject_DEL(op);
}
static PyObject *
class_lookup(PyClassObject *cp, PyObject *name, PyClassObject **pclass)
{
int 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 *class;
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, &class);
if (v == NULL) {
PyErr_SetObject(PyExc_AttributeError, name);
return NULL;
}
Py_INCREF(v);
if (PyFunction_Check(v)) {
PyObject *w = PyMethod_New(v, (PyObject *)NULL,
(PyObject *)class);
Py_DECREF(v);
v = w;
}
return v;
}
static void
set_slot(PyObject **slot, PyObject *v)
{
PyObject *temp = *slot;
Py_XINCREF(v);
*slot = v;
Py_XDECREF(temp);
}
static void
set_attr_slots(PyClassObject *c)
{
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));
}
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 "";
}
static char *
set_bases(PyClassObject *c, PyObject *v)
{
int 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 "";
}
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 "";
}
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] == '_') {
int 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_SetString(PyExc_AttributeError,
"delete non-existing class attribute");
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 buf[140];
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))
sprintf(buf, "<class ?.%.100s at %p>", name, op);
else
sprintf(buf, "<class %.50s.%.50s at %p>",
PyString_AsString(mod),
name, op);
return PyString_FromString(buf);
}
static PyObject *
class_str(PyClassObject *op)
{
PyObject *mod = PyDict_GetItemString(op->cl_dict, "__module__");
PyObject *name = op->cl_name;
PyObject *res;
int 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_Size(mod);
n = PyString_Size(name);
res = PyString_FromStringAndSize((char *)NULL, m+1+n);
if (res != NULL) {
char *s = PyString_AsString(res);
memcpy(s, PyString_AsString(mod), m);
s += m;
*s++ = '.';
memcpy(s, PyString_AsString(name), n);
}
return res;
}
static int
class_traverse(PyClassObject *o, visitproc visit, void *arg)
{
int err;
if (o->cl_bases) {
err = visit(o->cl_bases, arg);
if (err)
return err;
}
if (o->cl_dict) {
err = visit(o->cl_dict, arg);
if (err)
return err;
}
if (o->cl_name) {
err = visit(o->cl_name, arg);
if (err)
return err;
}
if (o->cl_getattr) {
err = visit(o->cl_getattr, arg);
if (err)
return err;
}
if (o->cl_setattr) {
err = visit(o->cl_setattr, arg);
if (err)
return err;
}
if (o->cl_delattr) {
err = visit(o->cl_delattr, arg);
if (err)
return err;
}
return 0;
}
PyTypeObject PyClass_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
"class",
sizeof(PyClassObject) + PyGC_HEAD_SIZE,
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*/
0, /*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_GC, /*tp_flags*/
0, /* tp_doc */
(traverseproc)class_traverse, /* tp_traverse */
};
int
PyClass_IsSubclass(PyObject *class, PyObject *base)
{
int i, n;
PyClassObject *cp;
if (class == base)
return 1;
if (class == NULL || !PyClass_Check(class))
return 0;
cp = (PyClassObject *)class;
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;
}
/* Instance objects */
PyObject *
PyInstance_New(PyObject *class, PyObject *arg, PyObject *kw)
{
register PyInstanceObject *inst;
PyObject *init;
static PyObject *initstr;
if (!PyClass_Check(class)) {
PyErr_BadInternalCall();
return NULL;
}
inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
if (inst == NULL)
return NULL;
inst->in_dict = PyDict_New();
PyObject_GC_Init(inst);
if (inst->in_dict == NULL) {
inst = (PyInstanceObject *) PyObject_AS_GC(inst);
PyObject_DEL(inst);
return NULL;
}
Py_INCREF(class);
inst->in_class = (PyClassObject *)class;
if (initstr == NULL)
initstr = PyString_InternFromString("__init__");
init = instance_getattr2(inst, initstr);
if (init == 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 */
static void
instance_dealloc(register PyInstanceObject *inst)
{
PyObject *error_type, *error_value, *error_traceback;
PyObject *del;
static PyObject *delstr;
#ifdef Py_TRACE_REFS
extern long _Py_RefTotal;
#endif
PyObject_GC_Fini(inst);
/* Call the __del__ method if it exists. First temporarily
revive the object and save the current exception, if any. */
#ifdef Py_TRACE_REFS
/* much too complicated if Py_TRACE_REFS defined */
inst->ob_type = &PyInstance_Type;
_Py_NewReference((PyObject *)inst);
_Py_RefTotal--; /* compensate for increment in NEWREF */
#ifdef COUNT_ALLOCS
inst->ob_type->tp_alloc--; /* ditto */
#endif
#else /* !Py_TRACE_REFS */
Py_INCREF(inst);
#endif /* !Py_TRACE_REFS */
PyErr_Fetch(&error_type, &error_value, &error_traceback);
if (delstr == NULL)
delstr = PyString_InternFromString("__del__");
if ((del = instance_getattr2(inst, delstr)) != NULL) {
PyObject *res = PyEval_CallObject(del, (PyObject *)NULL);
if (res == NULL) {
PyObject *f, *t, *v, *tb;
PyErr_Fetch(&t, &v, &tb);
f = PySys_GetObject("stderr");
if (f != NULL) {
PyFile_WriteString("Exception ", f);
if (t) {
PyFile_WriteObject(t, f, Py_PRINT_RAW);
if (v && v != Py_None) {
PyFile_WriteString(": ", f);
PyFile_WriteObject(v, f, 0);
}
}
PyFile_WriteString(" in ", f);
PyFile_WriteObject(del, f, 0);
PyFile_WriteString(" ignored\n", f);
PyErr_Clear(); /* Just in case */
}
Py_XDECREF(t);
Py_XDECREF(v);
Py_XDECREF(tb);
}
else
Py_DECREF(res);
Py_DECREF(del);
}
/* Restore the saved exception and undo the temporary revival */
PyErr_Restore(error_type, error_value, error_traceback);
/* Can't use DECREF here, it would cause a recursive call */
if (--inst->ob_refcnt > 0) {
#ifdef COUNT_ALLOCS
inst->ob_type->tp_free--;
#endif
PyObject_GC_Init((PyObject *)inst);
return; /* __del__ added a reference; don't delete now */
}
#ifdef Py_TRACE_REFS
#ifdef COUNT_ALLOCS
inst->ob_type->tp_free--; /* compensate for increment in UNREF */
#endif
_Py_ForgetReference((PyObject *)inst);
#ifndef WITH_CYCLE_GC
inst->ob_type = NULL;
#endif
#endif /* Py_TRACE_REFS */
Py_DECREF(inst->in_class);
Py_XDECREF(inst->in_dict);
inst = (PyInstanceObject *) PyObject_AS_GC(inst);
PyObject_DEL(inst);
}
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_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 *class;
class = NULL;
v = PyDict_GetItem(inst->in_dict, name);
if (v == NULL) {
v = class_lookup(inst->in_class, name, &class);
if (v == NULL)
return v;
}
Py_INCREF(v);
if (class != NULL) {
if (PyFunction_Check(v)) {
PyObject *w = PyMethod_New(v, (PyObject *)inst,
(PyObject *)class);
Py_DECREF(v);
v = w;
}
else if (PyMethod_Check(v)) {
PyObject *im_class = PyMethod_Class(v);
/* Only if classes are compatible */
if (PyClass_IsSubclass((PyObject *)class, im_class)) {
PyObject *im_func = PyMethod_Function(v);
PyObject *w = PyMethod_New(im_func,
(PyObject *)inst, im_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;
PyErr_Clear();
args = Py_BuildValue("(OO)", inst, name);
if (args == NULL)
return NULL;
res = PyEval_CallObject(func, args);
Py_DECREF(args);
}
return res;
}
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_SetString(PyExc_AttributeError,
"delete non-existing instance attribute");
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] == '_') {
int 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 = Py_BuildValue("(OO)", inst, name);
else
args = Py_BuildValue("(OOO)", 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;
if (reprstr == NULL)
reprstr = PyString_InternFromString("__repr__");
func = instance_getattr(inst, reprstr);
if (func == NULL) {
char buf[140];
PyObject *classname = inst->in_class->cl_name;
PyObject *mod = PyDict_GetItemString(
inst->in_class->cl_dict, "__module__");
char *cname;
if (classname != NULL && PyString_Check(classname))
cname = PyString_AsString(classname);
else
cname = "?";
PyErr_Clear();
if (mod == NULL || !PyString_Check(mod))
sprintf(buf, "<?.%.100s instance at %p>",
cname, inst);
else
sprintf(buf, "<%.50s.%.50s instance at %p>",
PyString_AsString(mod),
cname, inst);
return PyString_FromString(buf);
}
res = PyEval_CallObject(func, (PyObject *)NULL);
Py_DECREF(func);
return res;
}
static PyObject *
instance_compare1(PyObject *inst, PyObject *other)
{
return PyInstance_DoBinOp(inst, other, "__cmp__", "__rcmp__",
instance_compare1);
}
static int
instance_compare(PyObject *inst, PyObject *other)
{
PyObject *result;
long outcome;
result = instance_compare1(inst, other);
if (result == NULL)
return -1;
if (!PyInt_Check(result)) {
Py_DECREF(result);
PyErr_SetString(PyExc_TypeError,
"comparison did not return an int");
return -1;
}
outcome = PyInt_AsLong(result);
Py_DECREF(result);
if (outcome < 0)
return -1;
else if (outcome > 0)
return 1;
return 0;
}
static long
instance_hash(PyInstanceObject *inst)
{
PyObject *func;
PyObject *res;
long outcome;
static PyObject *hashstr, *cmpstr;
if (hashstr == NULL)
hashstr = PyString_InternFromString("__hash__");
func = instance_getattr(inst, hashstr);
if (func == NULL) {
/* If there is no __cmp__ method, we hash on the address.
If a __cmp__ method exists, there must be a __hash__. */
PyErr_Clear();
if (cmpstr == NULL)
cmpstr = PyString_InternFromString("__cmp__");
func = instance_getattr(inst, cmpstr);
if (func == NULL) {
PyErr_Clear();
return _Py_HashPointer(inst);
}
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)) {
outcome = PyInt_AsLong(res);
if (outcome == -1)
outcome = -2;
}
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)
{
int err;
if (o->in_class) {
err = visit((PyObject *)(o->in_class), arg);
if (err)
return err;
}
if (o->in_dict) {
err = visit(o->in_dict, arg);
if (err)
return err;
}
return 0;
}
static PyObject *getitemstr, *setitemstr, *delitemstr, *lenstr;
static int
instance_length(PyInstanceObject *inst)
{
PyObject *func;
PyObject *res;
int outcome;
if (lenstr == NULL)
lenstr = PyString_InternFromString("__len__");
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_AsLong(res);
if (outcome < 0)
PyErr_SetString(PyExc_ValueError,
"__len__() should return >= 0");
}
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;
if (getitemstr == NULL)
getitemstr = PyString_InternFromString("__getitem__");
func = instance_getattr(inst, getitemstr);
if (func == NULL)
return NULL;
arg = Py_BuildValue("(O)", 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;
if (value == NULL) {
if (delitemstr == NULL)
delitemstr = PyString_InternFromString("__delitem__");
func = instance_getattr(inst, delitemstr);
}
else {
if (setitemstr == NULL)
setitemstr = PyString_InternFromString("__setitem__");
func = instance_getattr(inst, setitemstr);
}
if (func == NULL)
return -1;
if (value == NULL)
arg = Py_BuildValue("(O)", key);
else
arg = Py_BuildValue("(OO)", 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 = {
(inquiry)instance_length, /*mp_length*/
(binaryfunc)instance_subscript, /*mp_subscript*/
(objobjargproc)instance_ass_subscript, /*mp_ass_subscript*/
};
static PyObject *
instance_item(PyInstanceObject *inst, int i)
{
PyObject *func, *arg, *res;
if (getitemstr == NULL)
getitemstr = PyString_InternFromString("__getitem__");
func = instance_getattr(inst, getitemstr);
if (func == NULL)
return NULL;
arg = Py_BuildValue("(i)", i);
if (arg == NULL) {
Py_DECREF(func);
return NULL;
}
res = PyEval_CallObject(func, arg);
Py_DECREF(func);
Py_DECREF(arg);
return res;
}
static PyObject *
instance_slice(PyInstanceObject *inst, int i, int j)
{
PyObject *func, *arg, *res;
static PyObject *getslicestr;
if (getslicestr == NULL)
getslicestr = PyString_InternFromString("__getslice__");
func = instance_getattr(inst, getslicestr);
if (func == NULL)
return NULL;
arg = Py_BuildValue("(ii)", i, j);
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, int i, PyObject *item)
{
PyObject *func, *arg, *res;
if (item == NULL) {
if (delitemstr == NULL)
delitemstr = PyString_InternFromString("__delitem__");
func = instance_getattr(inst, delitemstr);
}
else {
if (setitemstr == NULL)
setitemstr = PyString_InternFromString("__setitem__");
func = instance_getattr(inst, setitemstr);
}
if (func == NULL)
return -1;
if (item == NULL)
arg = Py_BuildValue("i", i);
else
arg = Py_BuildValue("(iO)", 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, int i, int j, PyObject *value)
{
PyObject *func, *arg, *res;
static PyObject *setslicestr, *delslicestr;
if (value == NULL) {
if (delslicestr == NULL)
delslicestr =
PyString_InternFromString("__delslice__");
func = instance_getattr(inst, delslicestr);
}
else {
if (setslicestr == NULL)
setslicestr =
PyString_InternFromString("__setslice__");
func = instance_getattr(inst, setslicestr);
}
if (func == NULL)
return -1;
if (value == NULL)
arg = Py_BuildValue("(ii)", i, j);
else
arg = Py_BuildValue("(iiO)", 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, *arg, *res;
int ret;
if(__contains__ == NULL) {
__contains__ = PyString_InternFromString("__contains__");
if(__contains__ == NULL)
return -1;
}
func = instance_getattr(inst, __contains__);
if(func == NULL) {
/* fall back to previous behavior */
int i, cmp_res;
if(!PyErr_ExceptionMatches(PyExc_AttributeError))
return -1;
PyErr_Clear();
for(i=0;;i++) {
PyObject *obj = instance_item(inst, i);
int ret = 0;
if(obj == NULL) {
if(!PyErr_ExceptionMatches(PyExc_IndexError))
return -1;
PyErr_Clear();
return 0;
}
if(PyObject_Cmp(obj, member, &cmp_res) == -1)
ret = -1;
if(cmp_res == 0)
ret = 1;
Py_DECREF(obj);
if(ret)
return ret;
}
}
arg = Py_BuildValue("(O)", 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;
}
static PySequenceMethods
instance_as_sequence = {
(inquiry)instance_length, /*sq_length*/
0, /*sq_concat*/
0, /*sq_repeat*/
(intargfunc)instance_item, /*sq_item*/
(intintargfunc)instance_slice, /*sq_slice*/
(intobjargproc)instance_ass_item, /*sq_ass_item*/
(intintobjargproc)instance_ass_slice, /*sq_ass_slice*/
(objobjproc)instance_contains, /* sq_contains */
};
static PyObject *
generic_unary_op(PyInstanceObject *self, PyObject *methodname)
{
PyObject *func, *res;
if ((func = instance_getattr(self, methodname)) == NULL)
return NULL;
res = PyEval_CallObject(func, (PyObject *)NULL);
Py_DECREF(func);
return res;
}
/* Forward */
static int
halfbinop(PyObject *, PyObject *, char *, PyObject **,
PyObject * (*)(PyObject *, PyObject *), int);
/* Implement a binary operator involving at least one class instance. */
PyObject *
PyInstance_DoBinOp(PyObject *v, PyObject *w, char *opname, char *ropname,
PyObject * (*thisfunc)(PyObject *, PyObject *))
{
char buf[256];
PyObject *result = NULL;
if (halfbinop(v, w, opname, &result, thisfunc, 0) <= 0)
return result;
if (halfbinop(w, v, ropname, &result, thisfunc, 1) <= 0)
return result;
/* Sigh -- special case for comparisons */
if (strcmp(opname, "__cmp__") == 0) {
long c = (v < w) ? -1 : (v > w) ? 1 : 0;
return PyInt_FromLong(c);
}
sprintf(buf, "%s nor %s defined for these operands", opname, ropname);
PyErr_SetString(PyExc_TypeError, buf);
return NULL;
}
/* Try one half of a binary operator involving a class instance.
Return value:
-1 if an exception is to be reported right away
0 if we have a valid result
1 if we could try another operation
*/
static PyObject *coerce_obj;
static int
halfbinop(PyObject *v, PyObject *w, char *opname, PyObject **r_result,
PyObject * (*thisfunc)(PyObject *, PyObject *), int swapped)
{
PyObject *func;
PyObject *args;
PyObject *coercefunc;
PyObject *coerced = NULL;
PyObject *v1;
if (!PyInstance_Check(v))
return 1;
if (coerce_obj == NULL) {
coerce_obj = PyString_InternFromString("__coerce__");
if (coerce_obj == NULL)
return -1;
}
coercefunc = PyObject_GetAttr(v, coerce_obj);
if (coercefunc == NULL) {
PyErr_Clear();
}
else {
args = Py_BuildValue("(O)", w);
if (args == NULL) {
return -1;
}
coerced = PyEval_CallObject(coercefunc, args);
Py_DECREF(args);
Py_DECREF(coercefunc);
if (coerced == NULL) {
return -1;
}
if (coerced == Py_None) {
Py_DECREF(coerced);
return 1;
}
if (!PyTuple_Check(coerced) || PyTuple_Size(coerced) != 2) {
Py_DECREF(coerced);
PyErr_SetString(PyExc_TypeError,
"coercion should return None or 2-tuple");
return -1;
}
v1 = PyTuple_GetItem(coerced, 0);
w = PyTuple_GetItem(coerced, 1);
if (v1 != v) {
v = v1;
if (!PyInstance_Check(v) && !PyInstance_Check(w)) {
if (swapped)
*r_result = (*thisfunc)(w, v);
else
*r_result = (*thisfunc)(v, w);
Py_DECREF(coerced);
return *r_result == NULL ? -1 : 0;
}
}
}
func = PyObject_GetAttrString(v, opname);
if (func == NULL) {
Py_XDECREF(coerced);
if (!PyErr_ExceptionMatches(PyExc_AttributeError))
return -1;
PyErr_Clear();
return 1;
}
args = Py_BuildValue("(O)", w);
if (args == NULL) {
Py_DECREF(func);
Py_XDECREF(coerced);
return -1;
}
*r_result = PyEval_CallObject(func, args);
Py_DECREF(args);
Py_DECREF(func);
Py_XDECREF(coerced);
return *r_result == NULL ? -1 : 0;
}
static int
instance_coerce(PyObject **pv, PyObject **pw)
{
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: always OK */
PyErr_Clear();
Py_INCREF(v);
Py_INCREF(w);
return 0;
}
/* Has __coerce__ method: call it */
args = Py_BuildValue("(O)", 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) {
/* __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); \
return generic_unary_op(self, o); \
}
UNARY(instance_neg, "__neg__")
UNARY(instance_pos, "__pos__")
UNARY(instance_abs, "__abs__")
static int
instance_nonzero(PyInstanceObject *self)
{
PyObject *func, *res;
long outcome;
static PyObject *nonzerostr;
if (nonzerostr == NULL)
nonzerostr = PyString_InternFromString("__nonzero__");
if ((func = instance_getattr(self, nonzerostr)) == NULL) {
PyErr_Clear();
if (lenstr == NULL)
lenstr = PyString_InternFromString("__len__");
if ((func = instance_getattr(self, lenstr)) == NULL) {
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;
}
UNARY(instance_invert, "__invert__")
UNARY(instance_int, "__int__")
UNARY(instance_long, "__long__")
UNARY(instance_float, "__float__")
UNARY(instance_oct, "__oct__")
UNARY(instance_hex, "__hex__")
/* This version is for ternary calls only (z != None) */
static PyObject *
instance_pow(PyObject *v, PyObject *w, PyObject *z)
{
/* XXX Doesn't do coercions... */
PyObject *func;
PyObject *args;
PyObject *result;
static PyObject *powstr;
if (powstr == NULL)
powstr = PyString_InternFromString("__pow__");
func = PyObject_GetAttr(v, powstr);
if (func == NULL)
return NULL;
args = Py_BuildValue("(OO)", w, z);
if (args == NULL) {
Py_DECREF(func);
return NULL;
}
result = PyEval_CallObject(func, args);
Py_DECREF(func);
Py_DECREF(args);
return result;
}
static PyNumberMethods instance_as_number = {
0, /*nb_add*/
0, /*nb_subtract*/
0, /*nb_multiply*/
0, /*nb_divide*/
0, /*nb_remainder*/
0, /*nb_divmod*/
(ternaryfunc)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*/
0, /*nb_lshift*/
0, /*nb_rshift*/
0, /*nb_and*/
0, /*nb_xor*/
0, /*nb_or*/
(coercion)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*/
};
PyTypeObject PyInstance_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
"instance",
sizeof(PyInstanceObject) + PyGC_HEAD_SIZE,
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*/
0, /*tp_call*/
0, /*tp_str*/
(getattrofunc)instance_getattr, /*tp_getattro*/
(setattrofunc)instance_setattr, /*tp_setattro*/
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, /*tp_flags*/
0, /* tp_doc */
(traverseproc)instance_traverse, /* tp_traverse */
};
/* Instance method objects are used for two purposes:
(a) as bound instance methods (returned by instancename.methodname)
(b) as unbound methods (returned by ClassName.methodname)
In case (b), im_self is NULL
*/
static PyMethodObject *free_list;
PyObject *
PyMethod_New(PyObject *func, PyObject *self, PyObject *class)
{
register PyMethodObject *im;
if (!PyCallable_Check(func)) {
PyErr_BadInternalCall();
return NULL;
}
im = free_list;
if (im != NULL) {
free_list = (PyMethodObject *)(im->im_self);
PyObject_INIT(im, &PyMethod_Type);
}
else {
im = PyObject_NEW(PyMethodObject, &PyMethod_Type);
if (im == NULL)
return NULL;
}
Py_INCREF(func);
im->im_func = func;
Py_XINCREF(self);
im->im_self = self;
Py_INCREF(class);
im->im_class = class;
PyObject_GC_Init(im);
return (PyObject *)im;
}
PyObject *
PyMethod_Function(register PyObject *im)
{
if (!PyMethod_Check(im)) {
PyErr_BadInternalCall();
return NULL;
}
return ((PyMethodObject *)im)->im_func;
}
PyObject *
PyMethod_Self(register PyObject *im)
{
if (!PyMethod_Check(im)) {
PyErr_BadInternalCall();
return NULL;
}
return ((PyMethodObject *)im)->im_self;
}
PyObject *
PyMethod_Class(register PyObject *im)
{
if (!PyMethod_Check(im)) {
PyErr_BadInternalCall();
return NULL;
}
return ((PyMethodObject *)im)->im_class;
}
/* Class method methods */
#define OFF(x) offsetof(PyMethodObject, x)
static struct memberlist instancemethod_memberlist[] = {
{"im_func", T_OBJECT, OFF(im_func)},
{"im_self", T_OBJECT, OFF(im_self)},
{"im_class", T_OBJECT, OFF(im_class)},
/* Dummies that are not handled by getattr() except for __members__ */
{"__doc__", T_INT, 0},
{"__name__", T_INT, 0},
{NULL} /* Sentinel */
};
static PyObject *
instancemethod_getattr(register PyMethodObject *im, PyObject *name)
{
char *sname = PyString_AsString(name);
if (sname[0] == '_') {
/* Inherit __name__ and __doc__ from the callable object
implementing the method */
if (strcmp(sname, "__name__") == 0 ||
strcmp(sname, "__doc__") == 0)
return PyObject_GetAttr(im->im_func, name);
}
if (PyEval_GetRestricted()) {
PyErr_SetString(PyExc_RuntimeError,
"instance-method attributes not accessible in restricted mode");
return NULL;
}
return PyMember_Get((char *)im, instancemethod_memberlist, sname);
}
static void
instancemethod_dealloc(register PyMethodObject *im)
{
PyObject_GC_Fini(im);
Py_DECREF(im->im_func);
Py_XDECREF(im->im_self);
Py_DECREF(im->im_class);
im->im_self = (PyObject *)free_list;
free_list = im;
}
static int
instancemethod_compare(PyMethodObject *a, PyMethodObject *b)
{
if (a->im_self != b->im_self)
return (a->im_self < b->im_self) ? -1 : 1;
return PyObject_Compare(a->im_func, b->im_func);
}
static PyObject *
instancemethod_repr(PyMethodObject *a)
{
char buf[240];
PyInstanceObject *self = (PyInstanceObject *)(a->im_self);
PyObject *func = a->im_func;
PyClassObject *class = (PyClassObject *)(a->im_class);
PyObject *fclassname, *iclassname, *funcname;
char *fcname, *icname, *fname;
fclassname = class->cl_name;
if (PyFunction_Check(func)) {
funcname = ((PyFunctionObject *)func)->func_name;
Py_INCREF(funcname);
}
else {
funcname = PyObject_GetAttrString(func,"__name__");
if (funcname == NULL)
PyErr_Clear();
}
if (funcname != NULL && PyString_Check(funcname))
fname = PyString_AS_STRING(funcname);
else
fname = "?";
if (fclassname != NULL && PyString_Check(fclassname))
fcname = PyString_AsString(fclassname);
else
fcname = "?";
if (self == NULL)
sprintf(buf, "<unbound method %.100s.%.100s>", fcname, fname);
else {
iclassname = self->in_class->cl_name;
if (iclassname != NULL && PyString_Check(iclassname))
icname = PyString_AsString(iclassname);
else
icname = "?";
sprintf(buf, "<method %.60s.%.60s of %.60s instance at %p>",
fcname, fname, icname, self);
}
Py_XDECREF(funcname);
return PyString_FromString(buf);
}
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;
return x ^ y;
}
static int
instancemethod_traverse(PyMethodObject *im, visitproc visit, void *arg)
{
int err;
if (im->im_func) {
err = visit(im->im_func, arg);
if (err)
return err;
}
if (im->im_self) {
err = visit(im->im_self, arg);
if (err)
return err;
}
if (im->im_class) {
err = visit(im->im_class, arg);
if (err)
return err;
}
return 0;
}
PyTypeObject PyMethod_Type = {
PyObject_HEAD_INIT(&PyType_Type)
0,
"instance method",
sizeof(PyMethodObject) + PyGC_HEAD_SIZE,
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*/
0, /*tp_call*/
0, /*tp_str*/
(getattrofunc)instancemethod_getattr, /*tp_getattro*/
0, /*tp_setattro*/
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT | Py_TPFLAGS_GC, /*tp_flags*/
0, /* tp_doc */
(traverseproc)instancemethod_traverse, /* tp_traverse */
};
/* Clear out the free list */
void
PyMethod_Fini(void)
{
while (free_list) {
PyMethodObject *im = free_list;
free_list = (PyMethodObject *)(im->im_self);
im = (PyMethodObject *) PyObject_AS_GC(im);
PyObject_DEL(im);
}
}
Reference in New Issue View Git Blame Copy Permalink