//! i18n method, used in scripts
static PyObject *
c_i18n(PyObject *self, PyObject *args)
{
PyObject *py_dict;
PyObject *py_value;
if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &py_dict)) {
return NULL;
}
PyObject *py_lang = PyString_FromString(sender_language());
if (!PyDict_Contains(py_dict, py_lang)) {
py_lang = PyString_FromString("en");
}
if (PyDict_Contains(py_dict, py_lang)) {
py_value = PyDict_GetItem(py_dict, py_lang);
Py_INCREF(py_value);
return py_value;
}
else {
PyErr_Format(PyExc_COMAR_Script, "'en' locale string should be provided by default in COMAR scripts.");
return NULL;
}
}
//-------------------------------------------------------------------------------------
void Base::addPersistentsDataToStream(uint32 flags, MemoryStream* s)
{
std::vector<ENTITY_PROPERTY_UID> log;
// 再将base中存储属性取出
PyObject* pydict = PyObject_GetAttrString(this, "__dict__");
// 先将celldata中的存储属性取出
ScriptDefModule::PROPERTYDESCRIPTION_MAP& propertyDescrs = scriptModule_->getPersistentPropertyDescriptions();
ScriptDefModule::PROPERTYDESCRIPTION_MAP::const_iterator iter = propertyDescrs.begin();
for(; iter != propertyDescrs.end(); iter++)
{
PropertyDescription* propertyDescription = iter->second;
std::vector<ENTITY_PROPERTY_UID>::const_iterator finditer = std::find(log.begin(), log.end(), propertyDescription->getUType());
if(finditer != log.end())
continue;
const char* attrname = propertyDescription->getName();
if(propertyDescription->isPersistent() && (flags & propertyDescription->getFlags()) > 0)
{
PyObject *key = PyUnicode_FromString(attrname);
if(PyDict_Contains(cellDataDict_, key) > 0)
{
PyObject* pyVal = PyDict_GetItemString(cellDataDict_, attrname);
(*s) << propertyDescription->getUType();
log.push_back(propertyDescription->getUType());
propertyDescription->getDataType()->addToStream(s, pyVal);
DEBUG_PERSISTENT_PROPERTY("addCellPersistentsDataToStream", attrname);
}
else if(PyDict_Contains(pydict, key) > 0)
{
(*s) << propertyDescription->getUType();
log.push_back(propertyDescription->getUType());
propertyDescription->getDataType()->addToStream(s, PyDict_GetItem(pydict, key));
DEBUG_PERSISTENT_PROPERTY("addBasePersistentsDataToStream", attrname);
}
else
{
CRITICAL_MSG("%s::addPersistentsDataToStream: %d not found Persistent[%s].\n",
this->getScriptName(), this->getID(), attrname);
}
Py_DECREF(key);
}
}
Py_XDECREF(pydict);
}
static int PyBobIpGaborSimilarity_init(PyBobIpGaborSimilarityObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist1 = Similarity_doc.kwlist(1);
char** kwlist2 = Similarity_doc.kwlist(0);
// two ways to call
PyObject* k = Py_BuildValue("s", kwlist1[0]);
auto k_ = make_safe(k);
if (
(kwargs && PyDict_Contains(kwargs, k)) ||
(args && PyTuple_Size(args) == 1 && PyBobIoHDF5File_Check(PyTuple_GetItem(args, 0)))
){
PyBobIoHDF5FileObject* hdf5;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&", kwlist1, &PyBobIoHDF5File_Converter, &hdf5)) return -1;
auto hdf5_ = make_safe(hdf5);
self->cxx.reset(new bob::ip::gabor::Similarity(*hdf5->f));
} else {
const char* name = 0;
PyBobIpGaborTransformObject* gwt = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|O!", kwlist2, &name, &PyBobIpGaborTransform_Type, &gwt)) return -1;
if (gwt)
self->cxx.reset(new bob::ip::gabor::Similarity(bob::ip::gabor::Similarity::name_to_type(name), gwt->cxx));
else
self->cxx.reset(new bob::ip::gabor::Similarity(bob::ip::gabor::Similarity::name_to_type(name)));
}
return 0;
BOB_CATCH_MEMBER("Similarity constructor", -1)
}
static PyObject *app_translations_py_messages_register(BlenderAppTranslations *self, PyObject *args, PyObject *kw)
{
#ifdef WITH_INTERNATIONAL
static const char *kwlist[] = {"module_name", "translations_dict", NULL};
PyObject *module_name, *uuid_dict;
if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!:bpy.app.translations.register", (char **)kwlist, &PyUnicode_Type,
&module_name, &PyDict_Type, &uuid_dict))
{
return NULL;
}
if (PyDict_Contains(self->py_messages, module_name)) {
PyErr_Format(PyExc_ValueError,
"bpy.app.translations.register: translations message cache already contains some data for "
"addon '%s'", (const char *)_PyUnicode_AsString(module_name));
return NULL;
}
PyDict_SetItem(self->py_messages, module_name, uuid_dict);
/* Clear cached messages dict! */
_clear_translations_cache();
#else
(void)self;
(void)args;
(void)kw;
#endif
/* And we are done! */
Py_RETURN_NONE;
}
PyObject* loadModule_(const QString& name)
{
PyObject* module_dict = PyImport_GetModuleDict();
if(!module_dict)
{
Log.error() << "Could not obtain module dictionary" << std::endl;
return 0;
}
PyObject* mod_name = PyString_FromString(name.toAscii().data());
PyObject* module = 0;
if(PyDict_Contains(module_dict, mod_name))
{
module = PyDict_GetItem(module_dict, mod_name);
}
else
{
//This could leak the imported module. Need to check...
module = PyImport_ImportModule(name.toAscii().data());
}
Py_XDECREF(mod_name);
if(!module || PyErr_Occurred())
{
PyErr_Print();
return 0;
}
return module;
}
static PyObject *app_translations_py_messages_unregister(BlenderAppTranslations *self, PyObject *args, PyObject *kw)
{
#ifdef WITH_INTERNATIONAL
static const char *kwlist[] = {"module_name", NULL};
PyObject *module_name;
if (!PyArg_ParseTupleAndKeywords(args, kw, "O!:bpy.app.translations.unregister", (char **)kwlist, &PyUnicode_Type,
&module_name))
{
return NULL;
}
if (PyDict_Contains(self->py_messages, module_name)) {
PyDict_DelItem(self->py_messages, module_name);
/* Clear cached messages ghash! */
_clear_translations_cache();
}
#else
(void)self;
(void)args;
(void)kw;
#endif
/* And we are done! */
Py_RETURN_NONE;
}
qd_error_t qd_entity_set_map_key_value_string(qd_entity_t *entity, const char *attribute, const char *key, const char *value)
{
if (!key)
return QD_ERROR_VALUE;
PyObject *py_key = PyString_FromString(key);
PyObject *py_value = PyString_FromString(value);
PyObject *py_attribute = PyString_FromString(attribute);
qd_error_t ret = QD_ERROR_NONE;
if (PyDict_Contains((PyObject*)entity, py_attribute) == 1) {
PyObject* dict = PyDict_GetItem((PyObject*)entity, py_attribute);
if (PyDict_SetItem(dict, py_key, py_value) < 0)
ret = QD_ERROR_PYTHON;
}
else
ret = QD_ERROR_VALUE;
Py_XDECREF(py_key);
Py_XDECREF(py_value);
Py_XDECREF(py_attribute);
return ret;
}
static PyObject *
proxy_has_key(proxyobject *pp, PyObject *key)
{
int res = PyDict_Contains(pp->dict, key);
if (res < 0)
return NULL;
return PyBool_FromLong(res);
}
//=============================================================================
// METHOD: SPELLvariableMonitor::getVariableRef
//=============================================================================
PyObject* SPELLvariableMonitor::getVariableRef( const std::string& name )
{
if (PyDict_Contains(m_frame->f_globals, SSTRPY(name)))
{
return PyDict_GetItemString(m_frame->f_globals, name.c_str());
}
return NULL;
}
static PyObject *pair_repr(PyObject *self) {
PyObject *tmp = NULL;
PyObject *col = PyList_New(0);
PyObject *found = PyDict_New();
size_t index = 0;
PyObject *rest = self;
PyObject *rest_id;
PyList_Append(col, _str_cons_paren);
while (rest->ob_type == &SibPairType) {
rest_id = PyLong_FromVoidPtr(rest);
if (PyDict_Contains(found, rest_id)) {
/* recursive pair detected */
PyList_Append(col, _str_recursive_true);
if (rest != self) {
tmp = PyDict_GetItem(found, rest_id);
PyList_Insert(col, PyLong_AsSize_t(tmp) - 1, _str_cons_paren);
PyList_Append(col, _str_close_paren);
}
Py_DECREF(rest_id);
rest = NULL;
break;
} else {
index += 2;
tmp = PyLong_FromSize_t(index);
PyDict_SetItem(found, rest_id, tmp);
Py_DECREF(tmp);
tmp = PyObject_Repr(SibPair_CAR(rest));
PyList_Append(col, tmp);
PyList_Append(col, _str_comma_space);
Py_DECREF(tmp);
rest = SibPair_CDR(rest);
Py_DECREF(rest_id);
}
}
if (rest) {
PyList_Append(col, PyObject_Repr(rest));
}
PyList_Append(col, _str_close_paren);
tmp = PyUnicode_Join(_str_empty, col);
Py_DECREF(col);
Py_DECREF(found);
return tmp;
}
static int get_common_objects(PyObject *cookie,
const void *key,
size_t nkey,
lcb_error_t err,
pycbc_ConnectionObject **conn,
pycbc_ResultBaseObject **res,
int restype,
pycbc_MultiResultObject **mres)
{
PyObject *hkey;
int rv;
assert(Py_TYPE(cookie) == &pycbc_MultiResultType);
*mres = (pycbc_MultiResultObject*)cookie;
*conn = (*mres)->parent;
CB_THR_END(*conn);
rv = pycbc_tc_decode_key(*conn, key, nkey, &hkey);
if (rv < 0) {
push_fatal_error(*mres);
return -1;
}
/**
* Now, get/set the result object
*/
if (restype == RESTYPE_BASE) {
*res = (pycbc_ResultBaseObject*)pycbc_result_new(*conn);
} else if (restype == RESTYPE_OPERATION) {
*res = (pycbc_ResultBaseObject*)pycbc_opresult_new(*conn);
} else if (restype == RESTYPE_VALUE) {
*res = (pycbc_ResultBaseObject*)pycbc_valresult_new(*conn);
} else {
abort();
}
assert(PyDict_Contains((PyObject*)*mres, hkey) == 0);
PyDict_SetItem((PyObject*)*mres, hkey, (PyObject*)*res);
Py_DECREF(*res);
(*res)->key = hkey;
(*res)->rc = err;
if (err != LCB_SUCCESS) {
(*mres)->all_ok = 0;
}
return 0;
}
static s_bool MapPyValPresent(const SMap *self, const char *key, s_erc *error)
{
SMapPy *pMap = (SMapPy*)self;
PyObject *pKey = NULL;
int rv;
S_CLR_ERR(error);
S_CHECK_PY_MAP(pMap, "MapPyValPresent");
pKey = s_set_pyobject_str(key, error);
if (S_CHK_ERR(error, S_CONTERR,
"MapPyValPresent",
"Call to \"s_set_pyobject_str\" failed"))
return FALSE;
rv = PyDict_Contains(S_PY_DICT(pMap), pKey);
if (rv == -1)
{
char *py_error = s_get_python_error_str();
if (py_error)
{
S_CTX_ERR(error, S_FAILURE,
"MapPyValPresent",
"Call to \"PyDict_Contains\" failed. Reported error: %s",
py_error);
S_FREE(py_error);
}
else
{
S_CTX_ERR(error, S_FAILURE,
"MapPyValPresent",
"Call to \"PyDict_Contains\" failed");
}
/* decrement reference of pKey */
Py_XDECREF(pKey);
return FALSE;
}
/* decrement reference of pKey */
Py_XDECREF(pKey);
if (rv == 1)
return TRUE;
return FALSE;
/* for S_CHECK_PY_MAP */
failure:
return FALSE;
}
/**
* @brief Removes all the entries from the dictionary related to the given user
*
* pythonInit() must have been called before or an error will occur (the module is not loaded)
* @param user Name of the user whose entries will be removed
* @return 1 on success, or 0 otherwise
*/
int dictionaryRemoveUserEntries(const char* user){
PyObject *dictionary;
if((dictionary = getDictionary()) == Py_None){
return 0;
}
if(PyDict_Contains(PyDict_GetItemString(dictionary, "incoming"), PyUnicode_FromString(user))){
PyDict_DelItemString(PyDict_GetItemString(dictionary, "incoming"), user);
}
if(PyDict_Contains(PyDict_GetItemString(dictionary, "outgoing"), PyUnicode_FromString(user))){
PyDict_DelItemString(PyDict_GetItemString(dictionary, "outgoing"), user);
}
setDictionary(dictionary);
Py_XDECREF(dictionary);
return 1;
}
//=============================================================================
// METHOD: SPELLvariableMonitor::retrieveLocalVariables()
//=============================================================================
void SPELLvariableMonitor::retrieveLocalVariables(std::vector<SPELLvarInfo>& vars)
{
DEBUG("[VM] Retrieve Locals");
/*
* Bottom stack frame is discarded,
* as globals and locals are the same dictionary
*/
if (m_frame->f_back == NULL) return;
/*
* Get the names defined in the current code, including arguments
*/
std::vector<std::string> varNames = retrieveNames();
/*
* Iterate over the locals dictionary, retrieving the names contained in
* varNames
*/
PyFrame_FastToLocals(m_frame);
PyObject* dict = m_frame->f_locals;
DEBUG("[VM] Frame: " + PYCREPR(m_frame));
for( unsigned int index = 0; index< varNames.size(); index++)
{
std::string varName = varNames[index];
PyObject* pyVarName = SSTRPY(varName);
if (PyDict_Contains( dict, pyVarName ))
{
PyObject* object = PyDict_GetItem( dict, pyVarName );
if (!SPELLpythonHelper::instance().isInstance(object, "Database", "spell.lib.adapter.databases.database"))
{
if (PyCallable_Check(object)) continue;
if (PyClass_Check(object)) continue;
if (PyModule_Check(object)) continue;
if (PyInstance_Check(object)) continue;
}
DEBUG("[VM] Processing " + varName);
std::string type = PYSSTR( PyObject_Type(object) );
DEBUG("[VM] Type : " + type);
std::string value = PYREPR( object );
DEBUG("[VM] Value : " + value);
DEBUG("[VM] Global : " + BSTR(false));
DEBUG("[VM] Registered: " + BSTR(isRegistered(varName)));
// Mark empty values (empty strings) as "<empty>"
if (value == "") value = EMPTY_STRING;
vars.push_back( SPELLvarInfo(varName, type, value, false, isRegistered(varName)) );
}
}
PyFrame_LocalsToFast(m_frame,0);
}
static PyObject *PyKAdminPrincipal_get_keys(PyKAdminPrincipalObject *self, void *closure) {
/*
key structure:
{
kvno: [("enctype", "salt"), ("enctype", "salt")],
kvno: ...
}
*/
PyObject *kvno = NULL;
PyObject *enctype = NULL;
PyObject *salttype = NULL;
PyObject *tuple = NULL;
PyObject *list = NULL;
PyObject *keys = PyDict_New();
ssize_t index = 0;
for (; index < self->entry.n_key_data; index++) {
krb5_key_data *key_data = &self->entry.key_data[index];
kvno = PyUnifiedLongInt_FromLong(key_data->key_data_kvno);
enctype = pykadmin_key_enctype_name(key_data);
salttype = pykadmin_key_salttype_name(key_data);
tuple = PyTuple_Pack(2, enctype, salttype);
if (kvno) {
if (PyDict_Contains(keys, kvno)) {
list = PyDict_GetItem(keys, kvno);
} else {
list = PyList_New(0);
PyDict_SetItem(keys, kvno, list);
}
}
if (list && tuple) {
PyList_Append(list, tuple);
}
}
return keys;
}
static PyObject *
pymongoc_client_pool_tp_new (PyTypeObject *self,
PyObject *args,
PyObject *kwargs)
{
pymongoc_client_pool_t *pyclient_pool;
mongoc_uri_t *uri;
const char *uri_str;
PyObject *key = NULL;
PyObject *pyuri = NULL;
PyObject *ret = NULL;
if (kwargs) {
key = PyString_FromStringAndSize("uri", 3);
if (PyDict_Contains(kwargs, key)) {
if (!(pyuri = PyDict_GetItem(kwargs, key))) {
goto cleanup;
} else if (!PyString_Check(pyuri)) {
PyErr_SetString(PyExc_TypeError, "uri must be a string.");
goto cleanup;
}
}
}
uri_str = pyuri ? PyString_AsString(pyuri) : NULL;
uri = mongoc_uri_new (uri_str);
pyclient_pool = (pymongoc_client_pool_t *)
PyType_GenericNew (&pymongoc_client_pool_type, NULL, NULL);
if (!pyclient_pool) {
goto cleanup;
}
pyclient_pool->client_pool = mongoc_client_pool_new (uri);
if (!pyclient_pool->client_pool) {
PyErr_SetString (PyExc_TypeError, "Invalid URI string.");
Py_DECREF (pyclient_pool);
pyclient_pool = NULL;
goto cleanup;
}
ret = (PyObject *)pyclient_pool;
cleanup:
if (uri) {
mongoc_uri_destroy (uri);
}
Py_XDECREF (key);
Py_XDECREF (pyuri);
return ret;
}
static PyObject *
LRU_contains(LRU *self, PyObject *args)
{
PyObject *key;
if (!PyArg_ParseTuple(args, "O", &key))
return NULL;
if (PyDict_Contains(self->dict, key)) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
//! i18n method, used in scripts
static PyObject *
c_i18n(PyObject *self, PyObject *args)
{
PyObject *py_dict;
if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &py_dict)) {
return NULL;
}
PyObject *py_lang = PyString_FromString(sender_language());
if (!PyDict_Contains(py_dict, py_lang)) {
py_lang = PyString_FromString("en");
}
if (PyDict_Contains(py_dict, py_lang)) {
return PyDict_GetItem(py_dict, py_lang);
}
else {
PyErr_Format(PyExc_COMAR_Script, "Script is lack of default ('en') locale string.");
return NULL;
}
}
PyObject *term_to_nametuple(const char *s, int arity, term_t t) {
PyObject *o;
#if PY_MAJOR_VERSION >= 3
PyTypeObject *typp;
PyObject *key = PyUnicode_FromString(s);
if (py_F2P && PyDict_Contains(py_F2P, key)) {
typp = (PyTypeObject *)PyDict_GetItem(py_F2P, key);
} else {
typp = PyMem_Malloc(sizeof(PyTypeObject));
PyStructSequence_Desc *desc = PyMem_Malloc(sizeof(PyStructSequence_Desc));
desc->name = PyUnicode_AsUTF8(key);
desc->doc = "YAPTerm";
desc->fields = pnull;
desc->n_in_sequence = 32;
if (PyStructSequence_InitType2(typp, desc) < 0)
return NULL;
typp->tp_str = structseq_str;
typp->tp_repr = structseq_repr;
// typp = PyStructSequence_NewType(desc);
Py_INCREF(typp);
// typp->tp_flags |= Py_TPFLAGS_HEAPTYPE;
PyModule_AddObject(py_Yapex, s, (PyObject *)typp);
if (py_F2P)
PyDict_SetItem(py_F2P, key, (PyObject *)typp);
}
o = PyTuple_New(typp);
#else
o = PyTuple_New(arity);
#endif
term_t tleft = PL_new_term_ref();
int i;
for (i = 0; i < arity; i++) {
PyObject *pArg;
if (!PL_get_arg(i + 1, t, tleft))
return NULL;
pArg = term_to_python(tleft, false);
if (pArg == NULL)
return NULL;
#if PY_MAJOR_VERSION >= 3
/* pArg reference stolen here: */
PyStructSequence_SET_ITEM(o, i, pArg);
}
((PyStructSequence *)o)->ob_base.ob_size = arity;
return o;
#else
/* pArg reference stolen here: */
PyTuple_SET_ITEM(o, i, pArg);
}
static PyObject* __Pyx_Globals(void) {
Py_ssize_t i;
//PyObject *d;
PyObject *names = NULL;
PyObject *globals = PyObject_GetAttrString($module_cname, "__dict__");
if (!globals) {
PyErr_SetString(PyExc_TypeError,
"current module must have __dict__ attribute");
goto bad;
}
names = PyObject_Dir($module_cname);
if (!names)
goto bad;
for (i = PyList_GET_SIZE(names)-1; i >= 0; i--) {
#if CYTHON_COMPILING_IN_PYPY
PyObject* name = PySequence_GetItem(names, i);
if (!name)
goto bad;
#else
PyObject* name = PyList_GET_ITEM(names, i);
#endif
if (!PyDict_Contains(globals, name)) {
PyObject* value = PyObject_GetAttr($module_cname, name);
if (!value) {
#if CYTHON_COMPILING_IN_PYPY
Py_DECREF(name);
#endif
goto bad;
}
if (PyDict_SetItem(globals, name, value) < 0) {
#if CYTHON_COMPILING_IN_PYPY
Py_DECREF(name);
#endif
Py_DECREF(value);
goto bad;
}
}
#if CYTHON_COMPILING_IN_PYPY
Py_DECREF(name);
#endif
}
Py_DECREF(names);
return globals;
// d = PyDictProxy_New(globals);
// Py_DECREF(globals);
// return d;
bad:
Py_XDECREF(names);
Py_XDECREF(globals);
return NULL;
}
//! Tells if model.member is defined in model database
int
validate_model_member(const char *model, const char *member, int type)
{
/*!
* Tells if model.member is defined in model database.
*
* @model Model name
* @member Member (method or signal name)
* @type 0 if member is a method, 1 if member is a signal
* @return 0 if valid, -1 if invalid
*
*/
if (PyDict_Contains(PyDict_GetItemString(py_core, "models"), PyString_FromString(model))) {
PyObject *py_dict_model = PyDict_GetItemString(PyDict_GetItemString(py_core, "models"), model);
if (PyDict_Contains(py_dict_model, PyString_FromString(member))) {
PyObject *py_tuple = PyDict_GetItemString(py_dict_model, member);
if (PyInt_AsLong(PyTuple_GetItem(py_tuple, 0)) == (long) type) {
return 0;
}
}
}
return -1;
}
/**
* @brief Checks whether the dictionary contains language pair information for a given user
*
* pythonInit() must have been called before or an error will occur (the module is not loaded)
* @param user Name of the user to look for
* @param direction Direction to look for the user in ("incoming" or "outgoing")
* @return 1 if there is a language pair for the user, or 0 otherwise
*/
int dictionaryHasUser(const char* user, const char* direction){
int has_user;
PyObject *dictionary;
if((dictionary = getDictionary()) == Py_None){
return 0;
}
has_user = PyDict_Contains(
PyDict_GetItemString(dictionary, direction),
PyUnicode_FromString(user));
Py_XDECREF(dictionary);
return has_user;
}
/* Does this path represent a directory?
on error, return < 0
if not a dir, return 0
if a dir, return 1
*/
static int
check_is_directory(ZipImporter *self, PyObject* prefix, PyObject *path)
{
PyObject *dirpath;
int res;
/* See if this is a "directory". If so, it's eligible to be part
of a namespace package. We test by seeing if the name, with an
appended path separator, exists. */
dirpath = PyUnicode_FromFormat("%U%U%c", prefix, path, SEP);
if (dirpath == NULL)
return -1;
/* If dirpath is present in self->files, we have a directory. */
res = PyDict_Contains(self->files, dirpath);
Py_DECREF(dirpath);
return res;
}
inline struct IPData *FindIp(uint32_t ipaddr)
{
unsigned int Counter;
static time_t last_error = 0;
#ifndef HAVE_PYTHON
for (Counter=0; Counter < IpCount; Counter++)
if (IpTable[Counter].ip == ipaddr)
return (&IpTable[Counter]);
#else
PyObject *oIP;
PyObject *oCounter;
oIP=PyInt_FromLong(ipaddr);
Counter=PyDict_Contains(IpTableDict, oIP);
if (Counter==-1){
printf("PyDict_Contains had an error.\n");
abort();
}
if (Counter){
Counter=PyInt_AsLong(PyDict_GetItem(IpTableDict, oIP));
Py_DECREF(oIP);
return &IpTable[Counter];
}
#endif
if (IpCount >= IP_NUM)
{
time_t current_error = time(NULL);
if (current_error > last_error + 30)
{
last_error = current_error;
syslog(LOG_ERR, "Maximum tracked IP's (%d) is too low, some ips will be ignored. Possible network scan?", IP_NUM);
}
return(NULL);
}
#ifndef HAVE_PYTHON
IpTable[IpCount].ip = ipaddr;
return (&IpTable[IpCount++]);
#else
oCounter=PyInt_FromLong(IpCount);
IpTable[IpCount].ip = ipaddr;
PyDict_SetItem(IpTableDict, oIP, oCounter);
Py_DECREF(oCounter);
Py_DECREF(oIP);
return (&IpTable[IpCount++]);
#endif
}
/**
* Construct python user object from IRCLib user.
* @param user IRCLib user structure
* @return Python user class instance
*/
PyObject *pyplugin_user_object(IRCLib_User user) {
if (user == NULL) return NULL;
PyObject *user_name = PyString_FromString(user->host->nick);
// Test if user is already in dictionary, if so, return it instead
// of creating new object.
if (
PyDict_Contains(
python_plugin_data->user_dict,
user_name
)
) {
Py_DECREF(user_name);
return PyDict_GetItem(python_plugin_data->user_dict, user_name);
}
// Channel is not in dictionary, create new one.
PyObject *result = pyplugin_user_new(
&(user_PyTypeObject),
NULL,
NULL
);
PyObject *temp = ((user_PyObject *)result)->nick;
((user_PyObject *)result)->nick = PyString_FromString(user->host->nick);
Py_XDECREF(temp);
temp = ((user_PyObject *)result)->user;
((user_PyObject *)result)->user = PyString_FromString(user->host->user);
Py_XDECREF(temp);
temp = ((user_PyObject *)result)->hostname;
((user_PyObject *)result)->hostname = PyString_FromString(user->host->host);
Py_XDECREF(temp);
// ToDo: Fill in channels tuple
// Add channel to dictionary
PyDict_SetItem(python_plugin_data->user_dict, user_name, result);
return result;
} // pyplugin_user_object
/* false if bind is not successfull. */
bool PyFunction::bind(const bp::object& dict, std::string funcname)
{
#if BOOST_VERSION >= 104100
if(bp::extract<bool>(dict.contains(funcname)))
#else
if(PyDict_Contains(dict.ptr(), bp::object(funcname).ptr()))
#endif
{
_func = dict[funcname];
_isValid = true;
}
else
{
_isValid = false;
std::cerr << "[PyFunction] Error binding function '" << funcname << "'." << std::endl;
}
return _isValid;
}
static PyObject* __Pyx_Globals(void) {
Py_ssize_t i;
PyObject *names;
PyObject *globals = $moddict_cname;
Py_INCREF(globals);
names = PyObject_Dir($module_cname);
if (!names)
goto bad;
for (i = PyList_GET_SIZE(names)-1; i >= 0; i--) {
#if CYTHON_COMPILING_IN_PYPY
PyObject* name = PySequence_GetItem(names, i);
if (!name)
goto bad;
#else
PyObject* name = PyList_GET_ITEM(names, i);
#endif
if (!PyDict_Contains(globals, name)) {
PyObject* value = __Pyx_GetAttr($module_cname, name);
if (!value) {
#if CYTHON_COMPILING_IN_PYPY
Py_DECREF(name);
#endif
goto bad;
}
if (PyDict_SetItem(globals, name, value) < 0) {
#if CYTHON_COMPILING_IN_PYPY
Py_DECREF(name);
#endif
Py_DECREF(value);
goto bad;
}
}
#if CYTHON_COMPILING_IN_PYPY
Py_DECREF(name);
#endif
}
Py_DECREF(names);
return globals;
bad:
Py_XDECREF(names);
Py_XDECREF(globals);
return NULL;
}
static inline int ExistsInIntHash(int key)
{
PyObject * py_int_key = PyInt_FromLong(key); /* leak */
// PyObject* value = PyDict_GetItem(hash, py_int_key);
int value = PyDict_Contains(hash, py_int_key);
Py_DECREF(py_int_key);
// if(value == NULL)
if(value == 0)
{
// fprintf(stderr, "item not found for key %d\n", key);
return 0;
}
else
{
// fprintf(stderr, "item foun for key %d\n", key);
return 1;
}
}
/*
* Retrieves a number value with the specified key from the specified
* dictionary.
*/
static PyObject *
get_dict_number(PyObject *dict, const char *key_str)
{
PyObject *ret = NULL;
PyObject *value;
PyObject *key = Py_BuildValue("s", key_str);
if (!PyDict_Contains(dict, key)) {
PyErr_Format(DiscsimInputError, "'%s' not specified", key_str);
goto out;
}
value = PyDict_GetItem(dict, key);
if (!PyNumber_Check(value)) {
PyErr_Format(DiscsimInputError, "'%s' is not number", key_str);
goto out;
}
ret = value;
out:
Py_DECREF(key);
return ret;
}
static PyObject *
cnter_inner_product(PyObject *dd, PyObject *other)
{
Py_ssize_t i;
PyObject *key, *value;
if (!NlpCounter_Check(dd) || !NlpCounter_Check(other)) {
PyErr_SetString(PyExc_ValueError, "Counter inner_product requires two counters");
return NULL;
}
double ret = 0.0;
/* Walk through all the keys in other and add value * dd->default if they're not in dd */
i = 0;
while (PyDict_Next(other, &i, &key, &value)) {
int contains = PyDict_Contains(dd, key);
if (contains == 0) {
ret += ((cnterobject*)dd)->default_value * PyFloat_AsDouble(value);
}
else if (contains < 0) {
return NULL;
}
}
i = 0;
while (PyDict_Next(dd, &i, &key, &value)) {
PyObject *otherValue = PyDict_GetItem(other, key);
if (otherValue != NULL) {
ret += PyFloat_AsDouble(PyDict_GetItem(other, key)) * PyFloat_AsDouble(value);
}
else {
ret += ((cnterobject*)other)->default_value * PyFloat_AsDouble(value);
}
}
return PyFloat_FromDouble(ret);;
}
