static PyObject *
bytes_mod_install(PyObject *self, PyObject *args) {
if (! PyBytes_Type.tp_as_number) {
PyBytes_Type.tp_as_number = &bytes_as_number;
PyType_Modified(&PyBytes_Type);
}
Py_RETURN_NONE;
}
static int __Pyx_setup_reduce(PyObject* type_obj) {
int ret = 0;
PyObject* builtin_object = NULL;
static PyObject *object_reduce = NULL;
static PyObject *object_reduce_ex = NULL;
PyObject *reduce = NULL;
PyObject *reduce_ex = NULL;
PyObject *reduce_cython = NULL;
PyObject *setstate = NULL;
PyObject *setstate_cython = NULL;
if (PyObject_HasAttrString(type_obj, "__getstate__")) goto GOOD;
if (object_reduce_ex == NULL) {
__Pyx_setup_reduce_GET_ATTR_OR_BAD(builtin_object, __pyx_b, "object");
__Pyx_setup_reduce_GET_ATTR_OR_BAD(object_reduce, builtin_object, "__reduce__");
__Pyx_setup_reduce_GET_ATTR_OR_BAD(object_reduce_ex, builtin_object, "__reduce_ex__");
}
__Pyx_setup_reduce_GET_ATTR_OR_BAD(reduce_ex, type_obj, "__reduce_ex__");
if (reduce_ex == object_reduce_ex) {
__Pyx_setup_reduce_GET_ATTR_OR_BAD(reduce, type_obj, "__reduce__");
if (object_reduce == reduce
|| (strcmp(reduce->ob_type->tp_name, "method_descriptor") == 0
&& strcmp(((PyMethodDescrObject*)reduce)->d_method->ml_name, "__reduce_cython__") == 0)) {
__Pyx_setup_reduce_GET_ATTR_OR_BAD(reduce_cython, type_obj, "__reduce_cython__");
ret = PyDict_SetItemString(((PyTypeObject*)type_obj)->tp_dict, "__reduce__", reduce_cython); if (ret < 0) goto BAD;
ret = PyDict_DelItemString(((PyTypeObject*)type_obj)->tp_dict, "__reduce_cython__"); if (ret < 0) goto BAD;
setstate = PyObject_GetAttrString(type_obj, "__setstate__");
if (!setstate) PyErr_Clear();
if (!setstate
|| (strcmp(setstate->ob_type->tp_name, "method_descriptor") == 0
&& strcmp(((PyMethodDescrObject*)setstate)->d_method->ml_name, "__setstate_cython__") == 0)) {
__Pyx_setup_reduce_GET_ATTR_OR_BAD(setstate_cython, type_obj, "__setstate_cython__");
ret = PyDict_SetItemString(((PyTypeObject*)type_obj)->tp_dict, "__setstate__", setstate_cython); if (ret < 0) goto BAD;
ret = PyDict_DelItemString(((PyTypeObject*)type_obj)->tp_dict, "__setstate_cython__"); if (ret < 0) goto BAD;
}
PyType_Modified((PyTypeObject*)type_obj);
}
}
goto GOOD;
BAD:
if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name);
ret = -1;
GOOD:
Py_XDECREF(builtin_object);
Py_XDECREF(reduce);
Py_XDECREF(reduce_ex);
Py_XDECREF(reduce_cython);
Py_XDECREF(setstate);
Py_XDECREF(setstate_cython);
return ret;
}
static int
EC_setattro(PyTypeObject *type, PyObject *name, PyObject *value)
{
/* We want to allow setting attributes of builti-in types, because
EC did in the past and there's code that relies on it.
We can't really set slots though, but I don't think we need to.
There's no good way to spot slots. We could use a lame rule like
names that begin and end with __s and have just 4 _s smell too
much like slots.
*/
if (! (type->tp_flags & Py_TPFLAGS_HEAPTYPE))
{
char *cname;
int l;
cname = PyString_AsString(name);
if (cname == NULL)
return -1;
l = PyString_GET_SIZE(name);
if (l > 4
&& cname[0] == '_' && cname[1] == '_'
&& cname[l-1] == '_' && cname[l-2] == '_'
)
{
char *c;
c = strchr(cname+2, '_');
if (c != NULL && (c - cname) >= (l-2))
{
PyErr_Format
(PyExc_TypeError,
"can't set attributes of built-in/extension type '%s' if the "
"attribute name begins and ends with __ and contains only "
"4 _ characters",
type->tp_name
);
return -1;
}
}
if (PyObject_GenericSetAttr(OBJECT(type), name, value) < 0)
return -1;
}
else if (PyType_Type.tp_setattro(OBJECT(type), name, value) < 0)
return -1;
#ifdef Py_TPFLAGS_HAVE_VERSION_TAG
PyType_Modified(type);
#endif
return 0;
}
static int
PyExtensionClass_Export_(PyObject *dict, char *name, PyTypeObject *typ)
{
long ecflags = 0;
PyMethodDef *pure_methods = NULL, *mdef = NULL;
PyObject *m;
if (typ->tp_flags == 0)
{
/* Old-style EC */
if (typ->tp_traverse)
{
/* ExtensionClasses stick there methods in the tp_traverse slot */
mdef = (PyMethodDef *)typ->tp_traverse;
if (typ->tp_basicsize <= sizeof(_emptyobject))
/* Pure mixin. We want rebindable methods */
pure_methods = mdef;
else
typ->tp_methods = mdef;
typ->tp_traverse = NULL;
/* Look for __init__ method */
for (; mdef->ml_name; mdef++)
{
if (strcmp(mdef->ml_name, "__init__") == 0)
{
/* we have an old-style __init__, install a special slot */
typ->tp_init = ec_init;
break;
}
}
}
if (typ->tp_clear)
{
/* ExtensionClasses stick there flags in the tp_clear slot */
ecflags = (long)(typ->tp_clear);
/* Some old-style flags were set */
if ((ecflags & EXTENSIONCLASS_BINDABLE_FLAG)
&& typ->tp_descr_get == NULL)
/* We have __of__-style binding */
typ->tp_descr_get = of_get;
}
typ->tp_clear = NULL;
typ->tp_flags = Py_TPFLAGS_DEFAULT
| Py_TPFLAGS_BASETYPE;
if (typ->tp_dealloc != NULL)
typ->tp_new = ec_new_for_custom_dealloc;
}
typ->ob_type = ECExtensionClassType;
if (ecflags & EXTENSIONCLASS_NOINSTDICT_FLAG)
typ->tp_base = &NoInstanceDictionaryBaseType;
else
typ->tp_base = &BaseType;
typ->tp_basicsize += typ->tp_base->tp_basicsize;
if (typ->tp_new == NULL)
typ->tp_new = PyType_GenericNew;
if (PyType_Ready(typ) < 0)
return -1;
if (pure_methods)
{
/* We had pure methods. We want to be able to rebind these, so
we'll make them ordinary method wrappers around method descrs
*/
for (; pure_methods->ml_name; pure_methods++)
{
m = PyDescr_NewMethod(ECBaseType, pure_methods);
if (! m)
return -1;
m = PyMethod_New((PyObject *)m, NULL, (PyObject *)ECBaseType);
if (! m)
return -1;
if (PyDict_SetItemString(typ->tp_dict, pure_methods->ml_name, m)
< 0)
return -1;
}
#ifdef Py_TPFLAGS_HAVE_VERSION_TAG
PyType_Modified(typ);
#endif
}
else if (mdef && mdef->ml_name)
{
/* Blast, we have to stick __init__ in the dict ourselves
because PyType_Ready probably stuck a wrapper for ec_init in
instead.
*/
m = PyDescr_NewMethod(typ, mdef);
if (! m)
return -1;
if (PyDict_SetItemString(typ->tp_dict, mdef->ml_name, m) < 0)
return -1;
#ifdef Py_TPFLAGS_HAVE_VERSION_TAG
PyType_Modified(typ);
#endif
}
if (PyMapping_SetItemString(dict, name, (PyObject*)typ) < 0)
return -1;
return 0;
}
