static mrb_value
hs_regexp_get_match_data(mrb_state *mrb, mrb_value self, const char *str)
{
mrb_value hs_match_data_cls, match_data;
struct mrb_hs_regexp *reg;
reg = (struct mrb_hs_regexp *)DATA_PTR(self);
hs_match_data_cls = mrb_const_get(mrb, mrb_obj_value(mrb->object_class), INTERN("HsMatchData"));
match_data = mrb_funcall_argv(mrb, hs_match_data_cls, INTERN("new"), 0, NULL);
mrb_iv_set(mrb, match_data, INTERN("@string"), mrb_str_new_cstr(mrb, str));
{
mrb_value args[2];
mrb_sym sym_push;
size_t i;
sym_push = INTERN("push");
for (i = 0; i < sizeof(reg->reg->startp)/sizeof(reg->reg->startp[0]); i++){
if (reg->reg->startp[i] && reg->reg->endp[i]){
args[0] = mrb_fixnum_value(reg->reg->startp[i] - str);
args[1] = mrb_fixnum_value(reg->reg->endp[i] - reg->reg->startp[i]);
mrb_funcall_argv(mrb, match_data, sym_push, sizeof(args)/sizeof(args[0]), &args[0]);
}else{
mrb_funcall_argv(mrb, match_data, sym_push, 0, NULL);
}
}
}
return match_data;
}
void SGMLName::init()
{
#define INTERN(n) intern(#n, NAMECASE);
INTERN(IMPLIED);
INTERN(CDATA);
INTERN(NOTATION);
INTERN(TOKEN);
INTERN(ENTITY);
}
static void
hs_regexp_init(mrb_state *mrb, mrb_value self, mrb_value str, unsigned char flag)
{
struct mrb_hs_regexp *reg;
regexp_info ri = { mrb, flag };
if (flag & ~REGEXP_FLAG_ALL){
mrb_raise(mrb, E_ARGUMENT_ERROR, "Invalid flag.");
}
if (!DATA_PTR(self)){
DATA_PTR(self) = mrb_malloc(mrb, sizeof(struct mrb_hs_regexp));
DATA_TYPE(self) = &mrb_hs_regexp_type;
reg = (struct mrb_hs_regexp *)DATA_PTR(self);
}else{
Data_Get_Struct(mrb, self, &mrb_hs_regexp_type, reg);
mrb_free(mrb, reg->reg);
}
reg->reg = hs_regcomp(&ri, RSTRING_PTR(str));
if (!reg->reg){
mrb_raisef(mrb, E_ARGUMENT_ERROR, "'%s' is an invalid regular expression because %s.",
RSTRING_PTR(str), ri.error_msg);
}
reg->flag = flag;
mrb_iv_set(mrb, self, INTERN("@source"), str);
}
static mrb_value
hs_regexp_equal(mrb_state *mrb, mrb_value self)
{
mrb_value other;
struct mrb_hs_regexp *self_reg, *other_reg;
mrb_get_args(mrb, "o", &other);
if (mrb_obj_equal(mrb, self, other)){
return mrb_true_value();
}
if (mrb_type(other) != MRB_TT_DATA || DATA_TYPE(other) != &mrb_hs_regexp_type){
return mrb_false_value();
}
self_reg = (struct mrb_hs_regexp *)DATA_PTR(self);
other_reg = (struct mrb_hs_regexp *)DATA_PTR(other);
if (!self_reg || !other_reg){
mrb_raise(mrb, E_RUNTIME_ERROR, "Invalid HsRegexp");
}
if (self_reg->flag != other_reg->flag){
return mrb_false_value();
}
return mrb_str_equal(mrb, mrb_iv_get(mrb, self, INTERN("@source")), mrb_iv_get(mrb, other, INTERN("@source"))) ?
mrb_true_value() : mrb_false_value();
}
static mrb_value
hs_regexp_match(mrb_state *mrb, mrb_value self)
{
const char *str;
struct mrb_hs_regexp *reg;
mrb_value m;
regexp_info ri = { mrb };
mrb_get_args(mrb, "z", &str);
Data_Get_Struct(mrb, self, &mrb_hs_regexp_type, reg);
if (!reg->reg){
mrb_raise(mrb, E_ARGUMENT_ERROR, "HsRegexp is not initialized.");
}
ri.flag = reg->flag;
if (hs_regexec(&ri, reg->reg, str)){
m = hs_regexp_get_match_data(mrb, self, str);
}else{
m = mrb_nil_value();
}
mrb_obj_iv_set(mrb, (struct RObject *)mrb_class_real(RDATA(self)->c), INTERN("@last_match"), m);
return m;
}
static int
changed(cPersistentObject *self)
{
if ((self->state == cPersistent_UPTODATE_STATE ||
self->state == cPersistent_STICKY_STATE)
&& self->jar)
{
PyObject *meth, *arg, *result;
static PyObject *s_register;
if (s_register == NULL)
s_register = INTERN("register");
meth = PyObject_GetAttr((PyObject *)self->jar, s_register);
if (meth == NULL)
return -1;
arg = PyTuple_New(1);
if (arg == NULL)
{
Py_DECREF(meth);
return -1;
}
Py_INCREF(self);
PyTuple_SET_ITEM(arg, 0, (PyObject *)self);
result = PyEval_CallObject(meth, arg);
Py_DECREF(arg);
Py_DECREF(meth);
if (result == NULL)
return -1;
Py_DECREF(result);
self->state = cPersistent_CHANGED_STATE;
}
return 0;
}
dbus_bool_t
dbus_py_init_abstract(void)
{
_dbus_py_variant_levels = PyDict_New();
if (!_dbus_py_variant_levels) return 0;
dbus_py__dbus_object_path__const = INTERN("__dbus_object_path__");
if (!dbus_py__dbus_object_path__const) return 0;
dbus_py_variant_level_const = INTERN("variant_level");
if (!dbus_py_variant_level_const) return 0;
dbus_py_signature_const = INTERN("signature");
if (!dbus_py_signature_const) return 0;
#ifdef PY3
DBusPyBytesBase_Type.tp_base = &PyBytes_Type;
if (PyType_Ready(&DBusPyBytesBase_Type) < 0) return 0;
DBusPyBytesBase_Type.tp_print = NULL;
#else
DBusPyIntBase_Type.tp_base = &PyInt_Type;
if (PyType_Ready(&DBusPyIntBase_Type) < 0) return 0;
/* disable the tp_print copied from PyInt_Type, so tp_repr gets called as
desired */
DBusPyIntBase_Type.tp_print = NULL;
#endif
DBusPyFloatBase_Type.tp_base = &PyFloat_Type;
if (PyType_Ready(&DBusPyFloatBase_Type) < 0) return 0;
DBusPyFloatBase_Type.tp_print = NULL;
DBusPyLongBase_Type.tp_base = &PyLong_Type;
if (PyType_Ready(&DBusPyLongBase_Type) < 0) return 0;
DBusPyLongBase_Type.tp_print = NULL;
DBusPyStrBase_Type.tp_base = &NATIVESTR_TYPE;
if (PyType_Ready(&DBusPyStrBase_Type) < 0) return 0;
DBusPyStrBase_Type.tp_print = NULL;
return 1;
}
static mrb_value
hs_regexp_initialize_copy(mrb_state *mrb, mrb_value copy)
{
mrb_value src;
struct mrb_hs_regexp *reg;
mrb_get_args(mrb, "o", &src);
if (mrb_obj_equal(mrb, copy, src)){
return copy;
}
if (!mrb_obj_is_instance_of(mrb, src, mrb_obj_class(mrb, copy))){
mrb_raise(mrb, E_TYPE_ERROR, "wrong argument class");
}
Data_Get_Struct(mrb, src, &mrb_hs_regexp_type, reg);
hs_regexp_init(mrb, copy, mrb_funcall_argv(mrb, src, INTERN("source"), 0, NULL), reg->flag);
return copy;
}
static int
readCurrent(cPersistentObject *self)
{
if ((self->state == cPersistent_UPTODATE_STATE ||
self->state == cPersistent_STICKY_STATE)
&& self->jar && self->oid)
{
static PyObject *s_readCurrent=NULL;
PyObject *r;
if (s_readCurrent == NULL)
s_readCurrent = INTERN("readCurrent");
r = PyObject_CallMethodObjArgs(self->jar, s_readCurrent, self, NULL);
if (r == NULL)
return -1;
Py_DECREF(r);
}
return 0;
}
static void
ghostify(cPersistentObject *self)
{
PyObject **dictptr, *slotnames;
/* are we already a ghost? */
if (self->state == cPersistent_GHOST_STATE)
return;
/* Is it ever possible to not have a cache? */
if (self->cache == NULL)
{
self->state = cPersistent_GHOST_STATE;
return;
}
if (self->ring.r_next == NULL)
{
/* There's no way to raise an error in this routine. */
#ifdef Py_DEBUG
fatal_1350(self, "ghostify", "claims to be in a cache but isn't");
#else
return;
#endif
}
/* If we're ghostifying an object, we better have some non-ghosts. */
assert(self->cache->non_ghost_count > 0);
self->cache->non_ghost_count--;
self->cache->total_estimated_size -=
_estimated_size_in_bytes(self->estimated_size);
ring_del(&self->ring);
self->state = cPersistent_GHOST_STATE;
/* clear __dict__ */
dictptr = _PyObject_GetDictPtr((PyObject *)self);
if (dictptr && *dictptr)
{
Py_DECREF(*dictptr);
*dictptr = NULL;
}
/* clear all slots besides _p_*
* ( for backward-compatibility reason we do this only if class does not
* override __new__ ) */
if (Py_TYPE(self)->tp_new == Pertype.tp_new)
{
slotnames = pickle_slotnames(Py_TYPE(self));
if (slotnames && slotnames != Py_None)
{
int i;
for (i = 0; i < PyList_GET_SIZE(slotnames); i++)
{
PyObject *name;
char *cname;
int is_special;
name = PyList_GET_ITEM(slotnames, i);
#ifdef PY3K
if (PyUnicode_Check(name))
{
PyObject *converted = convert_name(name);
cname = PyBytes_AS_STRING(converted);
#else
if (PyBytes_Check(name))
{
cname = PyBytes_AS_STRING(name);
#endif
is_special = !strncmp(cname, "_p_", 3);
#ifdef PY3K
Py_DECREF(converted);
#endif
if (is_special) /* skip persistent */
{
continue;
}
}
/* NOTE: this skips our delattr hook */
if (PyObject_GenericSetAttr((PyObject *)self, name, NULL) < 0)
/* delattr of non-set slot will raise AttributeError - we
* simply ignore. */
PyErr_Clear();
}
}
Py_XDECREF(slotnames);
}
/* We remove the reference to the just ghosted object that the ring
* holds. Note that the dictionary of oids->objects has an uncounted
* reference, so if the ring's reference was the only one, this frees
* the ghost object. Note further that the object's dealloc knows to
* inform the dictionary that it is going away.
*/
Py_DECREF(self);
}
static int
changed(cPersistentObject *self)
{
if ((self->state == cPersistent_UPTODATE_STATE ||
self->state == cPersistent_STICKY_STATE)
&& self->jar)
{
PyObject *meth, *arg, *result;
static PyObject *s_register;
if (s_register == NULL)
s_register = INTERN("register");
meth = PyObject_GetAttr((PyObject *)self->jar, s_register);
if (meth == NULL)
return -1;
arg = PyTuple_New(1);
if (arg == NULL)
{
Py_DECREF(meth);
return -1;
}
Py_INCREF(self);
PyTuple_SET_ITEM(arg, 0, (PyObject *)self);
result = PyEval_CallObject(meth, arg);
Py_DECREF(arg);
Py_DECREF(meth);
if (result == NULL)
return -1;
Py_DECREF(result);
self->state = cPersistent_CHANGED_STATE;
}
return 0;
}
static int
readCurrent(cPersistentObject *self)
{
if ((self->state == cPersistent_UPTODATE_STATE ||
self->state == cPersistent_STICKY_STATE)
&& self->jar && self->oid)
{
static PyObject *s_readCurrent=NULL;
PyObject *r;
if (s_readCurrent == NULL)
s_readCurrent = INTERN("readCurrent");
r = PyObject_CallMethodObjArgs(self->jar, s_readCurrent, self, NULL);
if (r == NULL)
return -1;
Py_DECREF(r);
}
return 0;
}
static PyObject *
Per__p_deactivate(cPersistentObject *self)
{
if (self->state == cPersistent_UPTODATE_STATE && self->jar)
{
PyObject **dictptr = _PyObject_GetDictPtr((PyObject *)self);
if (dictptr && *dictptr)
{
Py_DECREF(*dictptr);
*dictptr = NULL;
}
/* Note that we need to set to ghost state unless we are
called directly. Methods that override this need to
do the same! */
ghostify(self);
if (PyErr_Occurred())
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *
Per__p_activate(cPersistentObject *self)
{
if (unghostify(self) < 0)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
static int Per_set_changed(cPersistentObject *self, PyObject *v);
static PyObject *
Per__p_invalidate(cPersistentObject *self)
{
signed char old_state = self->state;
if (old_state != cPersistent_GHOST_STATE)
{
if (Per_set_changed(self, NULL) < 0)
return NULL;
ghostify(self);
if (PyErr_Occurred())
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
static void init_builtin_keywords()
{
#define STRING(s) SG_MAKE_STRING(s)
#define INTERN(s, i) \
Sg_BuiltinKeywords[i].name = STRING(s); \
Sg_HashTableSet(keywords.table, Sg_BuiltinKeywords[i].name, SG_OBJ(&Sg_BuiltinKeywords[i]), 0)
INTERN("lambda-list", 0);
INTERN("qualifier", 1);
INTERN("specializers", 2);
INTERN("generic", 3);
INTERN("procedure", 4);
INTERN("definition-name", 5);
INTERN("primary", 6);
INTERN("before", 7);
INTERN("after", 8);
INTERN("around", 9);
INTERN("init-value", 10);
INTERN("init-keyword", 11);
INTERN("init-thunk", 12);
INTERN("all", 13);
INTERN("export-reader-macro", 14);
INTERN("export-reader", 15);
INTERN("pipe", 16);
INTERN("stdin", 17);
INTERN("stdout", 18);
INTERN("stderr", 19);
INTERN("null", 20);
#undef INTERN
}
static PyObject*
module_init(void)
{
PyObject *module, *mod_dict, *interfaces, *conflicterr;
#ifdef KEY_TYPE_IS_PYOBJECT
object_ = PyTuple_GetItem(Py_TYPE(Py_None)->tp_bases, 0);
if (object_ == NULL)
return NULL;
#endif
sort_str = INTERN("sort");
if (!sort_str)
return NULL;
reverse_str = INTERN("reverse");
if (!reverse_str)
return NULL;
__setstate___str = INTERN("__setstate__");
if (!__setstate___str)
return NULL;
_bucket_type_str = INTERN("_bucket_type");
if (!_bucket_type_str)
return NULL;
/* Grab the ConflictError class */
interfaces = PyImport_ImportModule("BTrees.Interfaces");
if (interfaces != NULL)
{
conflicterr = PyObject_GetAttrString(interfaces, "BTreesConflictError");
if (conflicterr != NULL)
ConflictError = conflicterr;
Py_DECREF(interfaces);
}
if (ConflictError == NULL)
{
Py_INCREF(PyExc_ValueError);
ConflictError=PyExc_ValueError;
}
/* Initialize the PyPersist_C_API and the type objects. */
#ifdef PY3K
cPersistenceCAPI = (cPersistenceCAPIstruct *)PyCapsule_Import(
"persistent.cPersistence.CAPI", 0);
#else
cPersistenceCAPI = (cPersistenceCAPIstruct *)PyCObject_Import(
"persistent.cPersistence", "CAPI");
#endif
if (cPersistenceCAPI == NULL)
return NULL;
#ifdef PY3K
#define _SET_TYPE(typ) ((PyObject*)(&typ))->ob_type = &PyType_Type
#else
#define _SET_TYPE(typ) (typ).ob_type = &PyType_Type
#endif
_SET_TYPE(BTreeItemsType);
_SET_TYPE(BTreeIter_Type);
BTreeIter_Type.tp_getattro = PyObject_GenericGetAttr;
BucketType.tp_new = PyType_GenericNew;
SetType.tp_new = PyType_GenericNew;
BTreeType.tp_new = PyType_GenericNew;
TreeSetType.tp_new = PyType_GenericNew;
if (!init_persist_type(&BucketType))
return NULL;
if (!init_persist_type(&BTreeType))
return NULL;
if (!init_persist_type(&SetType))
return NULL;
if (!init_persist_type(&TreeSetType))
return NULL;
if (PyDict_SetItem(BTreeType.tp_dict, _bucket_type_str,
(PyObject *)&BucketType) < 0)
{
fprintf(stderr, "btree failed\n");
return NULL;
}
if (PyDict_SetItem(TreeSetType.tp_dict, _bucket_type_str,
(PyObject *)&SetType) < 0)
{
fprintf(stderr, "bucket failed\n");
return NULL;
}
/* Create the module and add the functions */
#ifdef PY3K
module = PyModule_Create(&moduledef);
#else
module = Py_InitModule4("_" MOD_NAME_PREFIX "BTree",
module_methods, BTree_module_documentation,
(PyObject *)NULL, PYTHON_API_VERSION);
#endif
/* Add some symbolic constants to the module */
mod_dict = PyModule_GetDict(module);
if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "Bucket",
(PyObject *)&BucketType) < 0)
return NULL;
if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "BTree",
(PyObject *)&BTreeType) < 0)
return NULL;
if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "Set",
(PyObject *)&SetType) < 0)
return NULL;
if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "TreeSet",
(PyObject *)&TreeSetType) < 0)
return NULL;
if (PyDict_SetItemString(mod_dict, MOD_NAME_PREFIX "TreeIterator",
(PyObject *)&BTreeIter_Type) < 0)
return NULL;
/* We also want to be able to access these constants without the prefix
* so that code can more easily exchange modules (particularly the integer
* and long modules, but also others). The TreeIterator is only internal,
* so we don't bother to expose that.
*/
if (PyDict_SetItemString(mod_dict, "Bucket",
(PyObject *)&BucketType) < 0)
return NULL;
if (PyDict_SetItemString(mod_dict, "BTree",
(PyObject *)&BTreeType) < 0)
return NULL;
if (PyDict_SetItemString(mod_dict, "Set",
(PyObject *)&SetType) < 0)
return NULL;
if (PyDict_SetItemString(mod_dict, "TreeSet",
(PyObject *)&TreeSetType) < 0)
return NULL;
#if defined(ZODB_64BIT_INTS) && defined(NEED_LONG_LONG_SUPPORT)
if (PyDict_SetItemString(mod_dict, "using64bits", Py_True) < 0)
return NULL;
#else
if (PyDict_SetItemString(mod_dict, "using64bits", Py_False) < 0)
return NULL;
#endif
return module;
}
