extern "C" int PyCallable_Check(PyObject* x) { if (x == NULL) return 0; static const std::string call_attr("__call__"); return typeLookup(x->cls, call_attr, NULL) != NULL; }
Box* objectNew(BoxedClass* cls, BoxedTuple* args) { assert(isSubclass(cls->cls, type_cls)); assert(args->cls == tuple_cls); if (args->elts.size() != 0) { if (typeLookup(cls, "__init__", NULL, NULL) == NULL) raiseExcHelper(TypeError, "object.__new__() takes no parameters"); } assert(cls->instance_size >= sizeof(Box)); void* mem = rt_alloc(cls->instance_size); Box* rtn = ::new (mem) Box(&object_flavor, cls); initUserAttrs(rtn, cls); return rtn; }
Box* superGetattribute(Box* _s, Box* _attr) { RELEASE_ASSERT(_s->cls == super_cls, ""); BoxedSuper* s = static_cast<BoxedSuper*>(_s); RELEASE_ASSERT(_attr->cls == str_cls, ""); BoxedString* attr = static_cast<BoxedString*>(_attr); bool skip = s->obj_type == NULL; if (!skip) { // Looks like __class__ is supposed to be "super", not the class of the the proxied object. skip = (attr->s() == class_str); } if (!skip) { PyObject* mro, *res, *tmp, *dict; PyTypeObject* starttype; descrgetfunc f; Py_ssize_t i, n; starttype = s->obj_type; mro = starttype->tp_mro; if (mro == NULL) n = 0; else { assert(PyTuple_Check(mro)); n = PyTuple_GET_SIZE(mro); } for (i = 0; i < n; i++) { if ((PyObject*)(s->type) == PyTuple_GET_ITEM(mro, i)) break; } i++; res = NULL; for (; i < n; i++) { tmp = PyTuple_GET_ITEM(mro, i); // Pyston change: #if 0 if (PyType_Check(tmp)) dict = ((PyTypeObject *)tmp)->tp_dict; else if (PyClass_Check(tmp)) dict = ((PyClassObject *)tmp)->cl_dict; else continue; res = PyDict_GetItem(dict, name); #endif res = tmp->getattr(attr); if (res != NULL) { // Pyston change: #if 0 Py_INCREF(res); f = Py_TYPE(res)->tp_descr_get; if (f != NULL) { tmp = f(res, /* Only pass 'obj' param if this is instance-mode sper (See SF ID #743627) */ (s->obj == (PyObject *) s->obj_type ? (PyObject *)NULL : s->obj), (PyObject *)starttype); Py_DECREF(res); res = tmp; } #endif return processDescriptor(res, (s->obj == s->obj_type ? None : s->obj), s->obj_type); } } } Box* r = typeLookup(s->cls, attr, NULL); // TODO implement this RELEASE_ASSERT(r, "should call the equivalent of objectGetattr here"); return processDescriptor(r, s, s->cls); }