manifests: push down expected node length into the parser
This strictly enforces the node length in the manifest lines according
to what the repository expects. One test case moves large hash testing
into the non-treemanifest part as treemanifests don't provide an
interface for overriding just the node length for now.
Differential Revision: https://phab.mercurial-scm.org/D10533
/*###########################################################################
#
# 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(
"mercurial.thirdparty.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