_zope_interface_coptimizations.c
1726 lines
| 44.9 KiB
| text/x-c
|
CLexer
|
r37193 | /*########################################################################### | ||
# | ||||
# Copyright (c) 2003 Zope Foundation and Contributors. | ||||
# All Rights Reserved. | ||||
# | ||||
# This software is subject to the provisions of the Zope Public License, | ||||
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. | ||||
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED | ||||
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||||
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS | ||||
# FOR A PARTICULAR PURPOSE. | ||||
# | ||||
############################################################################*/ | ||||
#include "Python.h" | ||||
#include "structmember.h" | ||||
#define TYPE(O) ((PyTypeObject*)(O)) | ||||
#define OBJECT(O) ((PyObject*)(O)) | ||||
#define CLASSIC(O) ((PyClassObject*)(O)) | ||||
#ifndef PyVarObject_HEAD_INIT | ||||
#define PyVarObject_HEAD_INIT(a, b) PyObject_HEAD_INIT(a) b, | ||||
#endif | ||||
#ifndef Py_TYPE | ||||
#define Py_TYPE(o) ((o)->ob_type) | ||||
#endif | ||||
#if PY_MAJOR_VERSION >= 3 | ||||
#define PY3K | ||||
#endif | ||||
static PyObject *str__dict__, *str__implemented__, *strextends; | ||||
static PyObject *BuiltinImplementationSpecifications, *str__provides__; | ||||
static PyObject *str__class__, *str__providedBy__; | ||||
static PyObject *empty, *fallback, *str_implied, *str_cls, *str_implements; | ||||
static PyObject *str__conform__, *str_call_conform, *adapter_hooks; | ||||
static PyObject *str_uncached_lookup, *str_uncached_lookupAll; | ||||
static PyObject *str_uncached_subscriptions; | ||||
static PyObject *str_registry, *strro, *str_generation, *strchanged; | ||||
static PyTypeObject *Implements; | ||||
static int imported_declarations = 0; | ||||
static int | ||||
import_declarations(void) | ||||
{ | ||||
PyObject *declarations, *i; | ||||
declarations = PyImport_ImportModule("zope.interface.declarations"); | ||||
if (declarations == NULL) | ||||
return -1; | ||||
BuiltinImplementationSpecifications = PyObject_GetAttrString( | ||||
declarations, "BuiltinImplementationSpecifications"); | ||||
if (BuiltinImplementationSpecifications == NULL) | ||||
return -1; | ||||
empty = PyObject_GetAttrString(declarations, "_empty"); | ||||
if (empty == NULL) | ||||
return -1; | ||||
fallback = PyObject_GetAttrString(declarations, "implementedByFallback"); | ||||
if (fallback == NULL) | ||||
return -1; | ||||
i = PyObject_GetAttrString(declarations, "Implements"); | ||||
if (i == NULL) | ||||
return -1; | ||||
if (! PyType_Check(i)) | ||||
{ | ||||
PyErr_SetString(PyExc_TypeError, | ||||
"zope.interface.declarations.Implements is not a type"); | ||||
return -1; | ||||
} | ||||
Implements = (PyTypeObject *)i; | ||||
Py_DECREF(declarations); | ||||
imported_declarations = 1; | ||||
return 0; | ||||
} | ||||
static PyTypeObject SpecType; /* Forward */ | ||||
static PyObject * | ||||
implementedByFallback(PyObject *cls) | ||||
{ | ||||
if (imported_declarations == 0 && import_declarations() < 0) | ||||
return NULL; | ||||
return PyObject_CallFunctionObjArgs(fallback, cls, NULL); | ||||
} | ||||
static PyObject * | ||||
implementedBy(PyObject *ignored, PyObject *cls) | ||||
{ | ||||
/* Fast retrieval of implements spec, if possible, to optimize | ||||
common case. Use fallback code if we get stuck. | ||||
*/ | ||||
PyObject *dict = NULL, *spec; | ||||
if (PyType_Check(cls)) | ||||
{ | ||||
dict = TYPE(cls)->tp_dict; | ||||
Py_XINCREF(dict); | ||||
} | ||||
if (dict == NULL) | ||||
dict = PyObject_GetAttr(cls, str__dict__); | ||||
if (dict == NULL) | ||||
{ | ||||
/* Probably a security proxied class, use more expensive fallback code */ | ||||
PyErr_Clear(); | ||||
return implementedByFallback(cls); | ||||
} | ||||
spec = PyObject_GetItem(dict, str__implemented__); | ||||
Py_DECREF(dict); | ||||
if (spec) | ||||
{ | ||||
if (imported_declarations == 0 && import_declarations() < 0) | ||||
return NULL; | ||||
if (PyObject_TypeCheck(spec, Implements)) | ||||
return spec; | ||||
/* Old-style declaration, use more expensive fallback code */ | ||||
Py_DECREF(spec); | ||||
return implementedByFallback(cls); | ||||
} | ||||
PyErr_Clear(); | ||||
/* Maybe we have a builtin */ | ||||
if (imported_declarations == 0 && import_declarations() < 0) | ||||
return NULL; | ||||
spec = PyDict_GetItem(BuiltinImplementationSpecifications, cls); | ||||
if (spec != NULL) | ||||
{ | ||||
Py_INCREF(spec); | ||||
return spec; | ||||
} | ||||
/* We're stuck, use fallback */ | ||||
return implementedByFallback(cls); | ||||
} | ||||
static PyObject * | ||||
getObjectSpecification(PyObject *ignored, PyObject *ob) | ||||
{ | ||||
PyObject *cls, *result; | ||||
result = PyObject_GetAttr(ob, str__provides__); | ||||
if (result != NULL && PyObject_TypeCheck(result, &SpecType)) | ||||
return result; | ||||
PyErr_Clear(); | ||||
/* We do a getattr here so as not to be defeated by proxies */ | ||||
cls = PyObject_GetAttr(ob, str__class__); | ||||
if (cls == NULL) | ||||
{ | ||||
PyErr_Clear(); | ||||
if (imported_declarations == 0 && import_declarations() < 0) | ||||
return NULL; | ||||
Py_INCREF(empty); | ||||
return empty; | ||||
} | ||||
result = implementedBy(NULL, cls); | ||||
Py_DECREF(cls); | ||||
return result; | ||||
} | ||||
static PyObject * | ||||
providedBy(PyObject *ignored, PyObject *ob) | ||||
{ | ||||
PyObject *result, *cls, *cp; | ||||
result = PyObject_GetAttr(ob, str__providedBy__); | ||||
if (result == NULL) | ||||
{ | ||||
PyErr_Clear(); | ||||
return getObjectSpecification(NULL, ob); | ||||
} | ||||
/* We want to make sure we have a spec. We can't do a type check | ||||
because we may have a proxy, so we'll just try to get the | ||||
only attribute. | ||||
*/ | ||||
if (PyObject_TypeCheck(result, &SpecType) | ||||
|| | ||||
PyObject_HasAttr(result, strextends) | ||||
) | ||||
return result; | ||||
/* | ||||
The object's class doesn't understand descriptors. | ||||
Sigh. We need to get an object descriptor, but we have to be | ||||
careful. We want to use the instance's __provides__,l if | ||||
there is one, but only if it didn't come from the class. | ||||
*/ | ||||
Py_DECREF(result); | ||||
cls = PyObject_GetAttr(ob, str__class__); | ||||
if (cls == NULL) | ||||
return NULL; | ||||
result = PyObject_GetAttr(ob, str__provides__); | ||||
if (result == NULL) | ||||
{ | ||||
/* No __provides__, so just fall back to implementedBy */ | ||||
PyErr_Clear(); | ||||
result = implementedBy(NULL, cls); | ||||
Py_DECREF(cls); | ||||
return result; | ||||
} | ||||
cp = PyObject_GetAttr(cls, str__provides__); | ||||
if (cp == NULL) | ||||
{ | ||||
/* The the class has no provides, assume we're done: */ | ||||
PyErr_Clear(); | ||||
Py_DECREF(cls); | ||||
return result; | ||||
} | ||||
if (cp == result) | ||||
{ | ||||
/* | ||||
Oops, we got the provides from the class. This means | ||||
the object doesn't have it's own. We should use implementedBy | ||||
*/ | ||||
Py_DECREF(result); | ||||
result = implementedBy(NULL, cls); | ||||
} | ||||
Py_DECREF(cls); | ||||
Py_DECREF(cp); | ||||
return result; | ||||
} | ||||
/* | ||||
Get an attribute from an inst dict. Return a borrowed reference. | ||||
This has a number of advantages: | ||||
- It avoids layers of Python api | ||||
- It doesn't waste time looking for descriptors | ||||
- It fails wo raising an exception, although that shouldn't really | ||||
matter. | ||||
*/ | ||||
static PyObject * | ||||
inst_attr(PyObject *self, PyObject *name) | ||||
{ | ||||
PyObject **dictp, *v; | ||||
dictp = _PyObject_GetDictPtr(self); | ||||
if (dictp && *dictp && (v = PyDict_GetItem(*dictp, name))) | ||||
return v; | ||||
PyErr_SetObject(PyExc_AttributeError, name); | ||||
return NULL; | ||||
} | ||||
static PyObject * | ||||
Spec_extends(PyObject *self, PyObject *other) | ||||
{ | ||||
PyObject *implied; | ||||
implied = inst_attr(self, str_implied); | ||||
if (implied == NULL) | ||||
return NULL; | ||||
#ifdef Py_True | ||||
if (PyDict_GetItem(implied, other) != NULL) | ||||
{ | ||||
Py_INCREF(Py_True); | ||||
return Py_True; | ||||
} | ||||
Py_INCREF(Py_False); | ||||
return Py_False; | ||||
#else | ||||
return PyInt_FromLong(PyDict_GetItem(implied, other) != NULL); | ||||
#endif | ||||
} | ||||
static char Spec_extends__doc__[] = | ||||
"Test whether a specification is or extends another" | ||||
; | ||||
static char Spec_providedBy__doc__[] = | ||||
"Test whether an interface is implemented by the specification" | ||||
; | ||||
static PyObject * | ||||
Spec_call(PyObject *self, PyObject *args, PyObject *kw) | ||||
{ | ||||
PyObject *spec; | ||||
if (! PyArg_ParseTuple(args, "O", &spec)) | ||||
return NULL; | ||||
return Spec_extends(self, spec); | ||||
} | ||||
static PyObject * | ||||
Spec_providedBy(PyObject *self, PyObject *ob) | ||||
{ | ||||
PyObject *decl, *item; | ||||
decl = providedBy(NULL, ob); | ||||
if (decl == NULL) | ||||
return NULL; | ||||
if (PyObject_TypeCheck(decl, &SpecType)) | ||||
item = Spec_extends(decl, self); | ||||
else | ||||
/* decl is probably a security proxy. We have to go the long way | ||||
around. | ||||
*/ | ||||
item = PyObject_CallFunctionObjArgs(decl, self, NULL); | ||||
Py_DECREF(decl); | ||||
return item; | ||||
} | ||||
static char Spec_implementedBy__doc__[] = | ||||
"Test whether the specification is implemented by a class or factory.\n" | ||||
"Raise TypeError if argument is neither a class nor a callable." | ||||
; | ||||
static PyObject * | ||||
Spec_implementedBy(PyObject *self, PyObject *cls) | ||||
{ | ||||
PyObject *decl, *item; | ||||
decl = implementedBy(NULL, cls); | ||||
if (decl == NULL) | ||||
return NULL; | ||||
if (PyObject_TypeCheck(decl, &SpecType)) | ||||
item = Spec_extends(decl, self); | ||||
else | ||||
item = PyObject_CallFunctionObjArgs(decl, self, NULL); | ||||
Py_DECREF(decl); | ||||
return item; | ||||
} | ||||
static struct PyMethodDef Spec_methods[] = { | ||||
{"providedBy", | ||||
(PyCFunction)Spec_providedBy, METH_O, | ||||
Spec_providedBy__doc__}, | ||||
{"implementedBy", | ||||
(PyCFunction)Spec_implementedBy, METH_O, | ||||
Spec_implementedBy__doc__}, | ||||
{"isOrExtends", (PyCFunction)Spec_extends, METH_O, | ||||
Spec_extends__doc__}, | ||||
{NULL, NULL} /* sentinel */ | ||||
}; | ||||
static PyTypeObject SpecType = { | ||||
PyVarObject_HEAD_INIT(NULL, 0) | ||||
/* tp_name */ "_interface_coptimizations." | ||||
"SpecificationBase", | ||||
/* tp_basicsize */ 0, | ||||
/* tp_itemsize */ 0, | ||||
/* tp_dealloc */ (destructor)0, | ||||
/* tp_print */ (printfunc)0, | ||||
/* tp_getattr */ (getattrfunc)0, | ||||
/* tp_setattr */ (setattrfunc)0, | ||||
/* tp_compare */ 0, | ||||
/* tp_repr */ (reprfunc)0, | ||||
/* tp_as_number */ 0, | ||||
/* tp_as_sequence */ 0, | ||||
/* tp_as_mapping */ 0, | ||||
/* tp_hash */ (hashfunc)0, | ||||
/* tp_call */ (ternaryfunc)Spec_call, | ||||
/* tp_str */ (reprfunc)0, | ||||
/* tp_getattro */ (getattrofunc)0, | ||||
/* tp_setattro */ (setattrofunc)0, | ||||
/* tp_as_buffer */ 0, | ||||
/* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, | ||||
"Base type for Specification objects", | ||||
/* tp_traverse */ (traverseproc)0, | ||||
/* tp_clear */ (inquiry)0, | ||||
/* tp_richcompare */ (richcmpfunc)0, | ||||
/* tp_weaklistoffset */ (long)0, | ||||
/* tp_iter */ (getiterfunc)0, | ||||
/* tp_iternext */ (iternextfunc)0, | ||||
/* tp_methods */ Spec_methods, | ||||
}; | ||||
static PyObject * | ||||
OSD_descr_get(PyObject *self, PyObject *inst, PyObject *cls) | ||||
{ | ||||
PyObject *provides; | ||||
if (inst == NULL) | ||||
return getObjectSpecification(NULL, cls); | ||||
provides = PyObject_GetAttr(inst, str__provides__); | ||||
if (provides != NULL) | ||||
return provides; | ||||
PyErr_Clear(); | ||||
return implementedBy(NULL, cls); | ||||
} | ||||
static PyTypeObject OSDType = { | ||||
PyVarObject_HEAD_INIT(NULL, 0) | ||||
/* tp_name */ "_interface_coptimizations." | ||||
"ObjectSpecificationDescriptor", | ||||
/* tp_basicsize */ 0, | ||||
/* tp_itemsize */ 0, | ||||
/* tp_dealloc */ (destructor)0, | ||||
/* tp_print */ (printfunc)0, | ||||
/* tp_getattr */ (getattrfunc)0, | ||||
/* tp_setattr */ (setattrfunc)0, | ||||
/* tp_compare */ 0, | ||||
/* tp_repr */ (reprfunc)0, | ||||
/* tp_as_number */ 0, | ||||
/* tp_as_sequence */ 0, | ||||
/* tp_as_mapping */ 0, | ||||
/* tp_hash */ (hashfunc)0, | ||||
/* tp_call */ (ternaryfunc)0, | ||||
/* tp_str */ (reprfunc)0, | ||||
/* tp_getattro */ (getattrofunc)0, | ||||
/* tp_setattro */ (setattrofunc)0, | ||||
/* tp_as_buffer */ 0, | ||||
/* tp_flags */ Py_TPFLAGS_DEFAULT | ||||
| Py_TPFLAGS_BASETYPE , | ||||
"Object Specification Descriptor", | ||||
/* tp_traverse */ (traverseproc)0, | ||||
/* tp_clear */ (inquiry)0, | ||||
/* tp_richcompare */ (richcmpfunc)0, | ||||
/* tp_weaklistoffset */ (long)0, | ||||
/* tp_iter */ (getiterfunc)0, | ||||
/* tp_iternext */ (iternextfunc)0, | ||||
/* tp_methods */ 0, | ||||
/* tp_members */ 0, | ||||
/* tp_getset */ 0, | ||||
/* tp_base */ 0, | ||||
/* tp_dict */ 0, /* internal use */ | ||||
/* tp_descr_get */ (descrgetfunc)OSD_descr_get, | ||||
}; | ||||
static PyObject * | ||||
CPB_descr_get(PyObject *self, PyObject *inst, PyObject *cls) | ||||
{ | ||||
PyObject *mycls, *implements; | ||||
mycls = inst_attr(self, str_cls); | ||||
if (mycls == NULL) | ||||
return NULL; | ||||
if (cls == mycls) | ||||
{ | ||||
if (inst == NULL) | ||||
{ | ||||
Py_INCREF(self); | ||||
return OBJECT(self); | ||||
} | ||||
implements = inst_attr(self, str_implements); | ||||
Py_XINCREF(implements); | ||||
return implements; | ||||
} | ||||
PyErr_SetObject(PyExc_AttributeError, str__provides__); | ||||
return NULL; | ||||
} | ||||
static PyTypeObject CPBType = { | ||||
PyVarObject_HEAD_INIT(NULL, 0) | ||||
/* tp_name */ "_interface_coptimizations." | ||||
"ClassProvidesBase", | ||||
/* tp_basicsize */ 0, | ||||
/* tp_itemsize */ 0, | ||||
/* tp_dealloc */ (destructor)0, | ||||
/* tp_print */ (printfunc)0, | ||||
/* tp_getattr */ (getattrfunc)0, | ||||
/* tp_setattr */ (setattrfunc)0, | ||||
/* tp_compare */ 0, | ||||
/* tp_repr */ (reprfunc)0, | ||||
/* tp_as_number */ 0, | ||||
/* tp_as_sequence */ 0, | ||||
/* tp_as_mapping */ 0, | ||||
/* tp_hash */ (hashfunc)0, | ||||
/* tp_call */ (ternaryfunc)0, | ||||
/* tp_str */ (reprfunc)0, | ||||
/* tp_getattro */ (getattrofunc)0, | ||||
/* tp_setattro */ (setattrofunc)0, | ||||
/* tp_as_buffer */ 0, | ||||
/* tp_flags */ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, | ||||
"C Base class for ClassProvides", | ||||
/* tp_traverse */ (traverseproc)0, | ||||
/* tp_clear */ (inquiry)0, | ||||
/* tp_richcompare */ (richcmpfunc)0, | ||||
/* tp_weaklistoffset */ (long)0, | ||||
/* tp_iter */ (getiterfunc)0, | ||||
/* tp_iternext */ (iternextfunc)0, | ||||
/* tp_methods */ 0, | ||||
/* tp_members */ 0, | ||||
/* tp_getset */ 0, | ||||
/* tp_base */ &SpecType, | ||||
/* tp_dict */ 0, /* internal use */ | ||||
/* tp_descr_get */ (descrgetfunc)CPB_descr_get, | ||||
}; | ||||
/* ==================================================================== */ | ||||
/* ========== Begin: __call__ and __adapt__ =========================== */ | ||||
/* | ||||
def __adapt__(self, obj): | ||||
"""Adapt an object to the reciever | ||||
""" | ||||
if self.providedBy(obj): | ||||
return obj | ||||
for hook in adapter_hooks: | ||||
adapter = hook(self, obj) | ||||
if adapter is not None: | ||||
return adapter | ||||
*/ | ||||
static PyObject * | ||||
__adapt__(PyObject *self, PyObject *obj) | ||||
{ | ||||
PyObject *decl, *args, *adapter; | ||||
int implements, i, l; | ||||
decl = providedBy(NULL, obj); | ||||
if (decl == NULL) | ||||
return NULL; | ||||
if (PyObject_TypeCheck(decl, &SpecType)) | ||||
{ | ||||
PyObject *implied; | ||||
implied = inst_attr(decl, str_implied); | ||||
if (implied == NULL) | ||||
{ | ||||
Py_DECREF(decl); | ||||
return NULL; | ||||
} | ||||
implements = PyDict_GetItem(implied, self) != NULL; | ||||
Py_DECREF(decl); | ||||
} | ||||
else | ||||
{ | ||||
/* decl is probably a security proxy. We have to go the long way | ||||
around. | ||||
*/ | ||||
PyObject *r; | ||||
r = PyObject_CallFunctionObjArgs(decl, self, NULL); | ||||
Py_DECREF(decl); | ||||
if (r == NULL) | ||||
return NULL; | ||||
implements = PyObject_IsTrue(r); | ||||
Py_DECREF(r); | ||||
} | ||||
if (implements) | ||||
{ | ||||
Py_INCREF(obj); | ||||
return obj; | ||||
} | ||||
l = PyList_GET_SIZE(adapter_hooks); | ||||
args = PyTuple_New(2); | ||||
if (args == NULL) | ||||
return NULL; | ||||
Py_INCREF(self); | ||||
PyTuple_SET_ITEM(args, 0, self); | ||||
Py_INCREF(obj); | ||||
PyTuple_SET_ITEM(args, 1, obj); | ||||
for (i = 0; i < l; i++) | ||||
{ | ||||
adapter = PyObject_CallObject(PyList_GET_ITEM(adapter_hooks, i), args); | ||||
if (adapter == NULL || adapter != Py_None) | ||||
{ | ||||
Py_DECREF(args); | ||||
return adapter; | ||||
} | ||||
Py_DECREF(adapter); | ||||
} | ||||
Py_DECREF(args); | ||||
Py_INCREF(Py_None); | ||||
return Py_None; | ||||
} | ||||
static struct PyMethodDef ib_methods[] = { | ||||
{"__adapt__", (PyCFunction)__adapt__, METH_O, | ||||
"Adapt an object to the reciever"}, | ||||
{NULL, NULL} /* sentinel */ | ||||
}; | ||||
/* | ||||
def __call__(self, obj, alternate=_marker): | ||||
conform = getattr(obj, '__conform__', None) | ||||
if conform is not None: | ||||
adapter = self._call_conform(conform) | ||||
if adapter is not None: | ||||
return adapter | ||||
adapter = self.__adapt__(obj) | ||||
if adapter is not None: | ||||
return adapter | ||||
elif alternate is not _marker: | ||||
return alternate | ||||
else: | ||||
raise TypeError("Could not adapt", obj, self) | ||||
*/ | ||||
static PyObject * | ||||
ib_call(PyObject *self, PyObject *args, PyObject *kwargs) | ||||
{ | ||||
PyObject *conform, *obj, *alternate=NULL, *adapter; | ||||
static char *kwlist[] = {"obj", "alternate", NULL}; | ||||
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O", kwlist, | ||||
&obj, &alternate)) | ||||
return NULL; | ||||
conform = PyObject_GetAttr(obj, str__conform__); | ||||
if (conform != NULL) | ||||
{ | ||||
adapter = PyObject_CallMethodObjArgs(self, str_call_conform, | ||||
conform, NULL); | ||||
Py_DECREF(conform); | ||||
if (adapter == NULL || adapter != Py_None) | ||||
return adapter; | ||||
Py_DECREF(adapter); | ||||
} | ||||
else | ||||
PyErr_Clear(); | ||||
adapter = __adapt__(self, obj); | ||||
if (adapter == NULL || adapter != Py_None) | ||||
return adapter; | ||||
Py_DECREF(adapter); | ||||
if (alternate != NULL) | ||||
{ | ||||
Py_INCREF(alternate); | ||||
return alternate; | ||||
} | ||||
adapter = Py_BuildValue("sOO", "Could not adapt", obj, self); | ||||
if (adapter != NULL) | ||||
{ | ||||
PyErr_SetObject(PyExc_TypeError, adapter); | ||||
Py_DECREF(adapter); | ||||
} | ||||
return NULL; | ||||
} | ||||
static PyTypeObject InterfaceBase = { | ||||
PyVarObject_HEAD_INIT(NULL, 0) | ||||
/* tp_name */ "_zope_interface_coptimizations." | ||||
"InterfaceBase", | ||||
/* tp_basicsize */ 0, | ||||
/* tp_itemsize */ 0, | ||||
/* tp_dealloc */ (destructor)0, | ||||
/* tp_print */ (printfunc)0, | ||||
/* tp_getattr */ (getattrfunc)0, | ||||
/* tp_setattr */ (setattrfunc)0, | ||||
/* tp_compare */ 0, | ||||
/* tp_repr */ (reprfunc)0, | ||||
/* tp_as_number */ 0, | ||||
/* tp_as_sequence */ 0, | ||||
/* tp_as_mapping */ 0, | ||||
/* tp_hash */ (hashfunc)0, | ||||
/* tp_call */ (ternaryfunc)ib_call, | ||||
/* tp_str */ (reprfunc)0, | ||||
/* tp_getattro */ (getattrofunc)0, | ||||
/* tp_setattro */ (setattrofunc)0, | ||||
/* tp_as_buffer */ 0, | ||||
/* tp_flags */ Py_TPFLAGS_DEFAULT | ||||
| Py_TPFLAGS_BASETYPE , | ||||
/* tp_doc */ "Interface base type providing __call__ and __adapt__", | ||||
/* tp_traverse */ (traverseproc)0, | ||||
/* tp_clear */ (inquiry)0, | ||||
/* tp_richcompare */ (richcmpfunc)0, | ||||
/* tp_weaklistoffset */ (long)0, | ||||
/* tp_iter */ (getiterfunc)0, | ||||
/* tp_iternext */ (iternextfunc)0, | ||||
/* tp_methods */ ib_methods, | ||||
}; | ||||
/* =================== End: __call__ and __adapt__ ==================== */ | ||||
/* ==================================================================== */ | ||||
/* ==================================================================== */ | ||||
/* ========================== Begin: Lookup Bases ===================== */ | ||||
typedef struct { | ||||
PyObject_HEAD | ||||
PyObject *_cache; | ||||
PyObject *_mcache; | ||||
PyObject *_scache; | ||||
} lookup; | ||||
typedef struct { | ||||
PyObject_HEAD | ||||
PyObject *_cache; | ||||
PyObject *_mcache; | ||||
PyObject *_scache; | ||||
PyObject *_verify_ro; | ||||
PyObject *_verify_generations; | ||||
} verify; | ||||
static int | ||||
lookup_traverse(lookup *self, visitproc visit, void *arg) | ||||
{ | ||||
int vret; | ||||
if (self->_cache) { | ||||
vret = visit(self->_cache, arg); | ||||
if (vret != 0) | ||||
return vret; | ||||
} | ||||
if (self->_mcache) { | ||||
vret = visit(self->_mcache, arg); | ||||
if (vret != 0) | ||||
return vret; | ||||
} | ||||
if (self->_scache) { | ||||
vret = visit(self->_scache, arg); | ||||
if (vret != 0) | ||||
return vret; | ||||
} | ||||
return 0; | ||||
} | ||||
static int | ||||
lookup_clear(lookup *self) | ||||
{ | ||||
Py_CLEAR(self->_cache); | ||||
Py_CLEAR(self->_mcache); | ||||
Py_CLEAR(self->_scache); | ||||
return 0; | ||||
} | ||||
static void | ||||
lookup_dealloc(lookup *self) | ||||
{ | ||||
PyObject_GC_UnTrack((PyObject *)self); | ||||
lookup_clear(self); | ||||
Py_TYPE(self)->tp_free((PyObject*)self); | ||||
} | ||||
/* | ||||
def changed(self, ignored=None): | ||||
self._cache.clear() | ||||
self._mcache.clear() | ||||
self._scache.clear() | ||||
*/ | ||||
static PyObject * | ||||
lookup_changed(lookup *self, PyObject *ignored) | ||||
{ | ||||
lookup_clear(self); | ||||
Py_INCREF(Py_None); | ||||
return Py_None; | ||||
} | ||||
#define ASSURE_DICT(N) if (N == NULL) { N = PyDict_New(); \ | ||||
if (N == NULL) return NULL; \ | ||||
} | ||||
/* | ||||
def _getcache(self, provided, name): | ||||
cache = self._cache.get(provided) | ||||
if cache is None: | ||||
cache = {} | ||||
self._cache[provided] = cache | ||||
if name: | ||||
c = cache.get(name) | ||||
if c is None: | ||||
c = {} | ||||
cache[name] = c | ||||
cache = c | ||||
return cache | ||||
*/ | ||||
static PyObject * | ||||
_subcache(PyObject *cache, PyObject *key) | ||||
{ | ||||
PyObject *subcache; | ||||
subcache = PyDict_GetItem(cache, key); | ||||
if (subcache == NULL) | ||||
{ | ||||
int status; | ||||
subcache = PyDict_New(); | ||||
if (subcache == NULL) | ||||
return NULL; | ||||
status = PyDict_SetItem(cache, key, subcache); | ||||
Py_DECREF(subcache); | ||||
if (status < 0) | ||||
return NULL; | ||||
} | ||||
return subcache; | ||||
} | ||||
static PyObject * | ||||
_getcache(lookup *self, PyObject *provided, PyObject *name) | ||||
{ | ||||
PyObject *cache; | ||||
ASSURE_DICT(self->_cache); | ||||
cache = _subcache(self->_cache, provided); | ||||
if (cache == NULL) | ||||
return NULL; | ||||
if (name != NULL && PyObject_IsTrue(name)) | ||||
cache = _subcache(cache, name); | ||||
return cache; | ||||
} | ||||
/* | ||||
def lookup(self, required, provided, name=u'', default=None): | ||||
cache = self._getcache(provided, name) | ||||
if len(required) == 1: | ||||
result = cache.get(required[0], _not_in_mapping) | ||||
else: | ||||
result = cache.get(tuple(required), _not_in_mapping) | ||||
if result is _not_in_mapping: | ||||
result = self._uncached_lookup(required, provided, name) | ||||
if len(required) == 1: | ||||
cache[required[0]] = result | ||||
else: | ||||
cache[tuple(required)] = result | ||||
if result is None: | ||||
return default | ||||
return result | ||||
*/ | ||||
static PyObject * | ||||
tuplefy(PyObject *v) | ||||
{ | ||||
if (! PyTuple_Check(v)) | ||||
{ | ||||
v = PyObject_CallFunctionObjArgs(OBJECT(&PyTuple_Type), v, NULL); | ||||
if (v == NULL) | ||||
return NULL; | ||||
} | ||||
else | ||||
Py_INCREF(v); | ||||
return v; | ||||
} | ||||
static PyObject * | ||||
_lookup(lookup *self, | ||||
PyObject *required, PyObject *provided, PyObject *name, | ||||
PyObject *default_) | ||||
{ | ||||
PyObject *result, *key, *cache; | ||||
#ifdef PY3K | ||||
if ( name && !PyUnicode_Check(name) ) | ||||
#else | ||||
if ( name && !PyString_Check(name) && !PyUnicode_Check(name) ) | ||||
#endif | ||||
{ | ||||
PyErr_SetString(PyExc_ValueError, | ||||
"name is not a string or unicode"); | ||||
return NULL; | ||||
} | ||||
cache = _getcache(self, provided, name); | ||||
if (cache == NULL) | ||||
return NULL; | ||||
required = tuplefy(required); | ||||
if (required == NULL) | ||||
return NULL; | ||||
if (PyTuple_GET_SIZE(required) == 1) | ||||
key = PyTuple_GET_ITEM(required, 0); | ||||
else | ||||
key = required; | ||||
result = PyDict_GetItem(cache, key); | ||||
if (result == NULL) | ||||
{ | ||||
int status; | ||||
result = PyObject_CallMethodObjArgs(OBJECT(self), str_uncached_lookup, | ||||
required, provided, name, NULL); | ||||
if (result == NULL) | ||||
{ | ||||
Py_DECREF(required); | ||||
return NULL; | ||||
} | ||||
status = PyDict_SetItem(cache, key, result); | ||||
Py_DECREF(required); | ||||
if (status < 0) | ||||
{ | ||||
Py_DECREF(result); | ||||
return NULL; | ||||
} | ||||
} | ||||
else | ||||
{ | ||||
Py_INCREF(result); | ||||
Py_DECREF(required); | ||||
} | ||||
if (result == Py_None && default_ != NULL) | ||||
{ | ||||
Py_DECREF(Py_None); | ||||
Py_INCREF(default_); | ||||
return default_; | ||||
} | ||||
return result; | ||||
} | ||||
static PyObject * | ||||
lookup_lookup(lookup *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"required", "provided", "name", "default", NULL}; | ||||
PyObject *required, *provided, *name=NULL, *default_=NULL; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, | ||||
&required, &provided, &name, &default_)) | ||||
return NULL; | ||||
return _lookup(self, required, provided, name, default_); | ||||
} | ||||
/* | ||||
def lookup1(self, required, provided, name=u'', default=None): | ||||
cache = self._getcache(provided, name) | ||||
result = cache.get(required, _not_in_mapping) | ||||
if result is _not_in_mapping: | ||||
return self.lookup((required, ), provided, name, default) | ||||
if result is None: | ||||
return default | ||||
return result | ||||
*/ | ||||
static PyObject * | ||||
_lookup1(lookup *self, | ||||
PyObject *required, PyObject *provided, PyObject *name, | ||||
PyObject *default_) | ||||
{ | ||||
PyObject *result, *cache; | ||||
#ifdef PY3K | ||||
if ( name && !PyUnicode_Check(name) ) | ||||
#else | ||||
if ( name && !PyString_Check(name) && !PyUnicode_Check(name) ) | ||||
#endif | ||||
{ | ||||
PyErr_SetString(PyExc_ValueError, | ||||
"name is not a string or unicode"); | ||||
return NULL; | ||||
} | ||||
cache = _getcache(self, provided, name); | ||||
if (cache == NULL) | ||||
return NULL; | ||||
result = PyDict_GetItem(cache, required); | ||||
if (result == NULL) | ||||
{ | ||||
PyObject *tup; | ||||
tup = PyTuple_New(1); | ||||
if (tup == NULL) | ||||
return NULL; | ||||
Py_INCREF(required); | ||||
PyTuple_SET_ITEM(tup, 0, required); | ||||
result = _lookup(self, tup, provided, name, default_); | ||||
Py_DECREF(tup); | ||||
} | ||||
else | ||||
{ | ||||
if (result == Py_None && default_ != NULL) | ||||
{ | ||||
result = default_; | ||||
} | ||||
Py_INCREF(result); | ||||
} | ||||
return result; | ||||
} | ||||
static PyObject * | ||||
lookup_lookup1(lookup *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"required", "provided", "name", "default", NULL}; | ||||
PyObject *required, *provided, *name=NULL, *default_=NULL; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, | ||||
&required, &provided, &name, &default_)) | ||||
return NULL; | ||||
return _lookup1(self, required, provided, name, default_); | ||||
} | ||||
/* | ||||
def adapter_hook(self, provided, object, name=u'', default=None): | ||||
required = providedBy(object) | ||||
cache = self._getcache(provided, name) | ||||
factory = cache.get(required, _not_in_mapping) | ||||
if factory is _not_in_mapping: | ||||
factory = self.lookup((required, ), provided, name) | ||||
if factory is not None: | ||||
result = factory(object) | ||||
if result is not None: | ||||
return result | ||||
return default | ||||
*/ | ||||
static PyObject * | ||||
_adapter_hook(lookup *self, | ||||
PyObject *provided, PyObject *object, PyObject *name, | ||||
PyObject *default_) | ||||
{ | ||||
PyObject *required, *factory, *result; | ||||
#ifdef PY3K | ||||
if ( name && !PyUnicode_Check(name) ) | ||||
#else | ||||
if ( name && !PyString_Check(name) && !PyUnicode_Check(name) ) | ||||
#endif | ||||
{ | ||||
PyErr_SetString(PyExc_ValueError, | ||||
"name is not a string or unicode"); | ||||
return NULL; | ||||
} | ||||
required = providedBy(NULL, object); | ||||
if (required == NULL) | ||||
return NULL; | ||||
factory = _lookup1(self, required, provided, name, Py_None); | ||||
Py_DECREF(required); | ||||
if (factory == NULL) | ||||
return NULL; | ||||
if (factory != Py_None) | ||||
{ | ||||
result = PyObject_CallFunctionObjArgs(factory, object, NULL); | ||||
Py_DECREF(factory); | ||||
if (result == NULL || result != Py_None) | ||||
return result; | ||||
} | ||||
else | ||||
result = factory; /* None */ | ||||
if (default_ == NULL || default_ == result) /* No default specified, */ | ||||
return result; /* Return None. result is owned None */ | ||||
Py_DECREF(result); | ||||
Py_INCREF(default_); | ||||
return default_; | ||||
} | ||||
static PyObject * | ||||
lookup_adapter_hook(lookup *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"provided", "object", "name", "default", NULL}; | ||||
PyObject *object, *provided, *name=NULL, *default_=NULL; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, | ||||
&provided, &object, &name, &default_)) | ||||
return NULL; | ||||
return _adapter_hook(self, provided, object, name, default_); | ||||
} | ||||
static PyObject * | ||||
lookup_queryAdapter(lookup *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"object", "provided", "name", "default", NULL}; | ||||
PyObject *object, *provided, *name=NULL, *default_=NULL; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, | ||||
&object, &provided, &name, &default_)) | ||||
return NULL; | ||||
return _adapter_hook(self, provided, object, name, default_); | ||||
} | ||||
/* | ||||
def lookupAll(self, required, provided): | ||||
cache = self._mcache.get(provided) | ||||
if cache is None: | ||||
cache = {} | ||||
self._mcache[provided] = cache | ||||
required = tuple(required) | ||||
result = cache.get(required, _not_in_mapping) | ||||
if result is _not_in_mapping: | ||||
result = self._uncached_lookupAll(required, provided) | ||||
cache[required] = result | ||||
return result | ||||
*/ | ||||
static PyObject * | ||||
_lookupAll(lookup *self, PyObject *required, PyObject *provided) | ||||
{ | ||||
PyObject *cache, *result; | ||||
ASSURE_DICT(self->_mcache); | ||||
cache = _subcache(self->_mcache, provided); | ||||
if (cache == NULL) | ||||
return NULL; | ||||
required = tuplefy(required); | ||||
if (required == NULL) | ||||
return NULL; | ||||
result = PyDict_GetItem(cache, required); | ||||
if (result == NULL) | ||||
{ | ||||
int status; | ||||
result = PyObject_CallMethodObjArgs(OBJECT(self), str_uncached_lookupAll, | ||||
required, provided, NULL); | ||||
if (result == NULL) | ||||
{ | ||||
Py_DECREF(required); | ||||
return NULL; | ||||
} | ||||
status = PyDict_SetItem(cache, required, result); | ||||
Py_DECREF(required); | ||||
if (status < 0) | ||||
{ | ||||
Py_DECREF(result); | ||||
return NULL; | ||||
} | ||||
} | ||||
else | ||||
{ | ||||
Py_INCREF(result); | ||||
Py_DECREF(required); | ||||
} | ||||
return result; | ||||
} | ||||
static PyObject * | ||||
lookup_lookupAll(lookup *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"required", "provided", NULL}; | ||||
PyObject *required, *provided; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, | ||||
&required, &provided)) | ||||
return NULL; | ||||
return _lookupAll(self, required, provided); | ||||
} | ||||
/* | ||||
def subscriptions(self, required, provided): | ||||
cache = self._scache.get(provided) | ||||
if cache is None: | ||||
cache = {} | ||||
self._scache[provided] = cache | ||||
required = tuple(required) | ||||
result = cache.get(required, _not_in_mapping) | ||||
if result is _not_in_mapping: | ||||
result = self._uncached_subscriptions(required, provided) | ||||
cache[required] = result | ||||
return result | ||||
*/ | ||||
static PyObject * | ||||
_subscriptions(lookup *self, PyObject *required, PyObject *provided) | ||||
{ | ||||
PyObject *cache, *result; | ||||
ASSURE_DICT(self->_scache); | ||||
cache = _subcache(self->_scache, provided); | ||||
if (cache == NULL) | ||||
return NULL; | ||||
required = tuplefy(required); | ||||
if (required == NULL) | ||||
return NULL; | ||||
result = PyDict_GetItem(cache, required); | ||||
if (result == NULL) | ||||
{ | ||||
int status; | ||||
result = PyObject_CallMethodObjArgs( | ||||
OBJECT(self), str_uncached_subscriptions, | ||||
required, provided, NULL); | ||||
if (result == NULL) | ||||
{ | ||||
Py_DECREF(required); | ||||
return NULL; | ||||
} | ||||
status = PyDict_SetItem(cache, required, result); | ||||
Py_DECREF(required); | ||||
if (status < 0) | ||||
{ | ||||
Py_DECREF(result); | ||||
return NULL; | ||||
} | ||||
} | ||||
else | ||||
{ | ||||
Py_INCREF(result); | ||||
Py_DECREF(required); | ||||
} | ||||
return result; | ||||
} | ||||
static PyObject * | ||||
lookup_subscriptions(lookup *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"required", "provided", NULL}; | ||||
PyObject *required, *provided; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, | ||||
&required, &provided)) | ||||
return NULL; | ||||
return _subscriptions(self, required, provided); | ||||
} | ||||
static struct PyMethodDef lookup_methods[] = { | ||||
{"changed", (PyCFunction)lookup_changed, METH_O, ""}, | ||||
{"lookup", (PyCFunction)lookup_lookup, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"lookup1", (PyCFunction)lookup_lookup1, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"queryAdapter", (PyCFunction)lookup_queryAdapter, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"adapter_hook", (PyCFunction)lookup_adapter_hook, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"lookupAll", (PyCFunction)lookup_lookupAll, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"subscriptions", (PyCFunction)lookup_subscriptions, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{NULL, NULL} /* sentinel */ | ||||
}; | ||||
static PyTypeObject LookupBase = { | ||||
PyVarObject_HEAD_INIT(NULL, 0) | ||||
/* tp_name */ "_zope_interface_coptimizations." | ||||
"LookupBase", | ||||
/* tp_basicsize */ sizeof(lookup), | ||||
/* tp_itemsize */ 0, | ||||
/* tp_dealloc */ (destructor)&lookup_dealloc, | ||||
/* tp_print */ (printfunc)0, | ||||
/* tp_getattr */ (getattrfunc)0, | ||||
/* tp_setattr */ (setattrfunc)0, | ||||
/* tp_compare */ 0, | ||||
/* tp_repr */ (reprfunc)0, | ||||
/* tp_as_number */ 0, | ||||
/* tp_as_sequence */ 0, | ||||
/* tp_as_mapping */ 0, | ||||
/* tp_hash */ (hashfunc)0, | ||||
/* tp_call */ (ternaryfunc)0, | ||||
/* tp_str */ (reprfunc)0, | ||||
/* tp_getattro */ (getattrofunc)0, | ||||
/* tp_setattro */ (setattrofunc)0, | ||||
/* tp_as_buffer */ 0, | ||||
/* tp_flags */ Py_TPFLAGS_DEFAULT | ||||
| Py_TPFLAGS_BASETYPE | ||||
| Py_TPFLAGS_HAVE_GC, | ||||
/* tp_doc */ "", | ||||
/* tp_traverse */ (traverseproc)lookup_traverse, | ||||
/* tp_clear */ (inquiry)lookup_clear, | ||||
/* tp_richcompare */ (richcmpfunc)0, | ||||
/* tp_weaklistoffset */ (long)0, | ||||
/* tp_iter */ (getiterfunc)0, | ||||
/* tp_iternext */ (iternextfunc)0, | ||||
/* tp_methods */ lookup_methods, | ||||
}; | ||||
static int | ||||
verifying_traverse(verify *self, visitproc visit, void *arg) | ||||
{ | ||||
int vret; | ||||
vret = lookup_traverse((lookup *)self, visit, arg); | ||||
if (vret != 0) | ||||
return vret; | ||||
if (self->_verify_ro) { | ||||
vret = visit(self->_verify_ro, arg); | ||||
if (vret != 0) | ||||
return vret; | ||||
} | ||||
if (self->_verify_generations) { | ||||
vret = visit(self->_verify_generations, arg); | ||||
if (vret != 0) | ||||
return vret; | ||||
} | ||||
return 0; | ||||
} | ||||
static int | ||||
verifying_clear(verify *self) | ||||
{ | ||||
lookup_clear((lookup *)self); | ||||
Py_CLEAR(self->_verify_generations); | ||||
Py_CLEAR(self->_verify_ro); | ||||
return 0; | ||||
} | ||||
static void | ||||
verifying_dealloc(verify *self) | ||||
{ | ||||
PyObject_GC_UnTrack((PyObject *)self); | ||||
verifying_clear(self); | ||||
Py_TYPE(self)->tp_free((PyObject*)self); | ||||
} | ||||
/* | ||||
def changed(self, originally_changed): | ||||
super(VerifyingBasePy, self).changed(originally_changed) | ||||
self._verify_ro = self._registry.ro[1:] | ||||
self._verify_generations = [r._generation for r in self._verify_ro] | ||||
*/ | ||||
static PyObject * | ||||
_generations_tuple(PyObject *ro) | ||||
{ | ||||
int i, l; | ||||
PyObject *generations; | ||||
l = PyTuple_GET_SIZE(ro); | ||||
generations = PyTuple_New(l); | ||||
for (i=0; i < l; i++) | ||||
{ | ||||
PyObject *generation; | ||||
generation = PyObject_GetAttr(PyTuple_GET_ITEM(ro, i), str_generation); | ||||
if (generation == NULL) | ||||
{ | ||||
Py_DECREF(generations); | ||||
return NULL; | ||||
} | ||||
PyTuple_SET_ITEM(generations, i, generation); | ||||
} | ||||
return generations; | ||||
} | ||||
static PyObject * | ||||
verifying_changed(verify *self, PyObject *ignored) | ||||
{ | ||||
PyObject *t, *ro; | ||||
verifying_clear(self); | ||||
t = PyObject_GetAttr(OBJECT(self), str_registry); | ||||
if (t == NULL) | ||||
return NULL; | ||||
ro = PyObject_GetAttr(t, strro); | ||||
Py_DECREF(t); | ||||
if (ro == NULL) | ||||
return NULL; | ||||
t = PyObject_CallFunctionObjArgs(OBJECT(&PyTuple_Type), ro, NULL); | ||||
Py_DECREF(ro); | ||||
if (t == NULL) | ||||
return NULL; | ||||
ro = PyTuple_GetSlice(t, 1, PyTuple_GET_SIZE(t)); | ||||
Py_DECREF(t); | ||||
if (ro == NULL) | ||||
return NULL; | ||||
self->_verify_generations = _generations_tuple(ro); | ||||
if (self->_verify_generations == NULL) | ||||
{ | ||||
Py_DECREF(ro); | ||||
return NULL; | ||||
} | ||||
self->_verify_ro = ro; | ||||
Py_INCREF(Py_None); | ||||
return Py_None; | ||||
} | ||||
/* | ||||
def _verify(self): | ||||
if ([r._generation for r in self._verify_ro] | ||||
!= self._verify_generations): | ||||
self.changed(None) | ||||
*/ | ||||
static int | ||||
_verify(verify *self) | ||||
{ | ||||
PyObject *changed_result; | ||||
if (self->_verify_ro != NULL && self->_verify_generations != NULL) | ||||
{ | ||||
PyObject *generations; | ||||
int changed; | ||||
generations = _generations_tuple(self->_verify_ro); | ||||
if (generations == NULL) | ||||
return -1; | ||||
changed = PyObject_RichCompareBool(self->_verify_generations, | ||||
generations, Py_NE); | ||||
Py_DECREF(generations); | ||||
if (changed == -1) | ||||
return -1; | ||||
if (changed == 0) | ||||
return 0; | ||||
} | ||||
changed_result = PyObject_CallMethodObjArgs(OBJECT(self), strchanged, | ||||
Py_None, NULL); | ||||
if (changed_result == NULL) | ||||
return -1; | ||||
Py_DECREF(changed_result); | ||||
return 0; | ||||
} | ||||
static PyObject * | ||||
verifying_lookup(verify *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"required", "provided", "name", "default", NULL}; | ||||
PyObject *required, *provided, *name=NULL, *default_=NULL; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, | ||||
&required, &provided, &name, &default_)) | ||||
return NULL; | ||||
if (_verify(self) < 0) | ||||
return NULL; | ||||
return _lookup((lookup *)self, required, provided, name, default_); | ||||
} | ||||
static PyObject * | ||||
verifying_lookup1(verify *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"required", "provided", "name", "default", NULL}; | ||||
PyObject *required, *provided, *name=NULL, *default_=NULL; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, | ||||
&required, &provided, &name, &default_)) | ||||
return NULL; | ||||
if (_verify(self) < 0) | ||||
return NULL; | ||||
return _lookup1((lookup *)self, required, provided, name, default_); | ||||
} | ||||
static PyObject * | ||||
verifying_adapter_hook(verify *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"provided", "object", "name", "default", NULL}; | ||||
PyObject *object, *provided, *name=NULL, *default_=NULL; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, | ||||
&provided, &object, &name, &default_)) | ||||
return NULL; | ||||
if (_verify(self) < 0) | ||||
return NULL; | ||||
return _adapter_hook((lookup *)self, provided, object, name, default_); | ||||
} | ||||
static PyObject * | ||||
verifying_queryAdapter(verify *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"object", "provided", "name", "default", NULL}; | ||||
PyObject *object, *provided, *name=NULL, *default_=NULL; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO|OO", kwlist, | ||||
&object, &provided, &name, &default_)) | ||||
return NULL; | ||||
if (_verify(self) < 0) | ||||
return NULL; | ||||
return _adapter_hook((lookup *)self, provided, object, name, default_); | ||||
} | ||||
static PyObject * | ||||
verifying_lookupAll(verify *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"required", "provided", NULL}; | ||||
PyObject *required, *provided; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, | ||||
&required, &provided)) | ||||
return NULL; | ||||
if (_verify(self) < 0) | ||||
return NULL; | ||||
return _lookupAll((lookup *)self, required, provided); | ||||
} | ||||
static PyObject * | ||||
verifying_subscriptions(verify *self, PyObject *args, PyObject *kwds) | ||||
{ | ||||
static char *kwlist[] = {"required", "provided", NULL}; | ||||
PyObject *required, *provided; | ||||
if (! PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, | ||||
&required, &provided)) | ||||
return NULL; | ||||
if (_verify(self) < 0) | ||||
return NULL; | ||||
return _subscriptions((lookup *)self, required, provided); | ||||
} | ||||
static struct PyMethodDef verifying_methods[] = { | ||||
{"changed", (PyCFunction)verifying_changed, METH_O, ""}, | ||||
{"lookup", (PyCFunction)verifying_lookup, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"lookup1", (PyCFunction)verifying_lookup1, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"queryAdapter", (PyCFunction)verifying_queryAdapter, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"adapter_hook", (PyCFunction)verifying_adapter_hook, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"lookupAll", (PyCFunction)verifying_lookupAll, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{"subscriptions", (PyCFunction)verifying_subscriptions, METH_KEYWORDS | METH_VARARGS, ""}, | ||||
{NULL, NULL} /* sentinel */ | ||||
}; | ||||
static PyTypeObject VerifyingBase = { | ||||
PyVarObject_HEAD_INIT(NULL, 0) | ||||
/* tp_name */ "_zope_interface_coptimizations." | ||||
"VerifyingBase", | ||||
/* tp_basicsize */ sizeof(verify), | ||||
/* tp_itemsize */ 0, | ||||
/* tp_dealloc */ (destructor)&verifying_dealloc, | ||||
/* tp_print */ (printfunc)0, | ||||
/* tp_getattr */ (getattrfunc)0, | ||||
/* tp_setattr */ (setattrfunc)0, | ||||
/* tp_compare */ 0, | ||||
/* tp_repr */ (reprfunc)0, | ||||
/* tp_as_number */ 0, | ||||
/* tp_as_sequence */ 0, | ||||
/* tp_as_mapping */ 0, | ||||
/* tp_hash */ (hashfunc)0, | ||||
/* tp_call */ (ternaryfunc)0, | ||||
/* tp_str */ (reprfunc)0, | ||||
/* tp_getattro */ (getattrofunc)0, | ||||
/* tp_setattro */ (setattrofunc)0, | ||||
/* tp_as_buffer */ 0, | ||||
/* tp_flags */ Py_TPFLAGS_DEFAULT | ||||
| Py_TPFLAGS_BASETYPE | ||||
| Py_TPFLAGS_HAVE_GC, | ||||
/* tp_doc */ "", | ||||
/* tp_traverse */ (traverseproc)verifying_traverse, | ||||
/* tp_clear */ (inquiry)verifying_clear, | ||||
/* tp_richcompare */ (richcmpfunc)0, | ||||
/* tp_weaklistoffset */ (long)0, | ||||
/* tp_iter */ (getiterfunc)0, | ||||
/* tp_iternext */ (iternextfunc)0, | ||||
/* tp_methods */ verifying_methods, | ||||
/* tp_members */ 0, | ||||
/* tp_getset */ 0, | ||||
/* tp_base */ &LookupBase, | ||||
}; | ||||
/* ========================== End: Lookup Bases ======================= */ | ||||
/* ==================================================================== */ | ||||
static struct PyMethodDef m_methods[] = { | ||||
{"implementedBy", (PyCFunction)implementedBy, METH_O, | ||||
"Interfaces implemented by a class or factory.\n" | ||||
"Raises TypeError if argument is neither a class nor a callable."}, | ||||
{"getObjectSpecification", (PyCFunction)getObjectSpecification, METH_O, | ||||
"Get an object's interfaces (internal api)"}, | ||||
{"providedBy", (PyCFunction)providedBy, METH_O, | ||||
"Get an object's interfaces"}, | ||||
{NULL, (PyCFunction)NULL, 0, NULL} /* sentinel */ | ||||
}; | ||||
#if PY_MAJOR_VERSION >= 3 | ||||
static char module_doc[] = "C optimizations for zope.interface\n\n"; | ||||
static struct PyModuleDef _zic_module = { | ||||
PyModuleDef_HEAD_INIT, | ||||
"_zope_interface_coptimizations", | ||||
module_doc, | ||||
-1, | ||||
m_methods, | ||||
NULL, | ||||
NULL, | ||||
NULL, | ||||
NULL | ||||
}; | ||||
#endif | ||||
static PyObject * | ||||
init(void) | ||||
{ | ||||
PyObject *m; | ||||
#if PY_MAJOR_VERSION < 3 | ||||
#define DEFINE_STRING(S) \ | ||||
if(! (str ## S = PyString_FromString(# S))) return NULL | ||||
#else | ||||
#define DEFINE_STRING(S) \ | ||||
if(! (str ## S = PyUnicode_FromString(# S))) return NULL | ||||
#endif | ||||
DEFINE_STRING(__dict__); | ||||
DEFINE_STRING(__implemented__); | ||||
DEFINE_STRING(__provides__); | ||||
DEFINE_STRING(__class__); | ||||
DEFINE_STRING(__providedBy__); | ||||
DEFINE_STRING(extends); | ||||
DEFINE_STRING(_implied); | ||||
DEFINE_STRING(_implements); | ||||
DEFINE_STRING(_cls); | ||||
DEFINE_STRING(__conform__); | ||||
DEFINE_STRING(_call_conform); | ||||
DEFINE_STRING(_uncached_lookup); | ||||
DEFINE_STRING(_uncached_lookupAll); | ||||
DEFINE_STRING(_uncached_subscriptions); | ||||
DEFINE_STRING(_registry); | ||||
DEFINE_STRING(_generation); | ||||
DEFINE_STRING(ro); | ||||
DEFINE_STRING(changed); | ||||
#undef DEFINE_STRING | ||||
adapter_hooks = PyList_New(0); | ||||
if (adapter_hooks == NULL) | ||||
return NULL; | ||||
/* Initialize types: */ | ||||
SpecType.tp_new = PyBaseObject_Type.tp_new; | ||||
if (PyType_Ready(&SpecType) < 0) | ||||
return NULL; | ||||
OSDType.tp_new = PyBaseObject_Type.tp_new; | ||||
if (PyType_Ready(&OSDType) < 0) | ||||
return NULL; | ||||
CPBType.tp_new = PyBaseObject_Type.tp_new; | ||||
if (PyType_Ready(&CPBType) < 0) | ||||
return NULL; | ||||
InterfaceBase.tp_new = PyBaseObject_Type.tp_new; | ||||
if (PyType_Ready(&InterfaceBase) < 0) | ||||
return NULL; | ||||
LookupBase.tp_new = PyBaseObject_Type.tp_new; | ||||
if (PyType_Ready(&LookupBase) < 0) | ||||
return NULL; | ||||
VerifyingBase.tp_new = PyBaseObject_Type.tp_new; | ||||
if (PyType_Ready(&VerifyingBase) < 0) | ||||
return NULL; | ||||
#if PY_MAJOR_VERSION < 3 | ||||
/* Create the module and add the functions */ | ||||
m = Py_InitModule3("_zope_interface_coptimizations", m_methods, | ||||
"C optimizations for zope.interface\n\n"); | ||||
#else | ||||
m = PyModule_Create(&_zic_module); | ||||
#endif | ||||
if (m == NULL) | ||||
return NULL; | ||||
/* Add types: */ | ||||
if (PyModule_AddObject(m, "SpecificationBase", OBJECT(&SpecType)) < 0) | ||||
return NULL; | ||||
if (PyModule_AddObject(m, "ObjectSpecificationDescriptor", | ||||
(PyObject *)&OSDType) < 0) | ||||
return NULL; | ||||
if (PyModule_AddObject(m, "ClassProvidesBase", OBJECT(&CPBType)) < 0) | ||||
return NULL; | ||||
if (PyModule_AddObject(m, "InterfaceBase", OBJECT(&InterfaceBase)) < 0) | ||||
return NULL; | ||||
if (PyModule_AddObject(m, "LookupBase", OBJECT(&LookupBase)) < 0) | ||||
return NULL; | ||||
if (PyModule_AddObject(m, "VerifyingBase", OBJECT(&VerifyingBase)) < 0) | ||||
return NULL; | ||||
if (PyModule_AddObject(m, "adapter_hooks", adapter_hooks) < 0) | ||||
return NULL; | ||||
return m; | ||||
} | ||||
PyMODINIT_FUNC | ||||
#if PY_MAJOR_VERSION < 3 | ||||
init_zope_interface_coptimizations(void) | ||||
{ | ||||
init(); | ||||
} | ||||
#else | ||||
PyInit__zope_interface_coptimizations(void) | ||||
{ | ||||
return init(); | ||||
} | ||||
#endif | ||||