static PyObject *pair_is_proper(PyObject *self, PyObject *_noargs) { // checked return PyBool_FromLong(SibPair_IsProper(self)); }
PyObject* PyObjectPlus::pyattr_get_invalid(void *self_v, const KX_PYATTRIBUTE_DEF *attrdef) { return PyBool_FromLong(self_v ? 0:1); }
static PyObject* pyLeafController_hasEaseControllers(pyLeafController* self) { return PyBool_FromLong(self->fThis->hasEaseControllers() ? 1 : 0); }
static PyObject *PyNick_gone_get(PyNick *self, void *closure) { RET_NULL_IF_INVALID(self->data); return PyBool_FromLong(self->data->gone); }
static PyObject * _get_handles_eof(ImagingDecoderObject *decoder) { return PyBool_FromLong(decoder->handles_eof); }
static PyObject * rlock_acquire(rlockobject *self, PyObject *args, PyObject *kwds) { char *kwlist[] = {"blocking", "timeout", NULL}; int blocking = 1; double timeout = -1; PY_TIMEOUT_T microseconds; long tid; PyLockStatus r = PY_LOCK_ACQUIRED; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|id:acquire", kwlist, &blocking, &timeout)) return NULL; if (!blocking && timeout != -1) { PyErr_SetString(PyExc_ValueError, "can't specify a timeout " "for a non-blocking call"); return NULL; } if (timeout < 0 && timeout != -1) { PyErr_SetString(PyExc_ValueError, "timeout value must be " "strictly positive"); return NULL; } if (!blocking) microseconds = 0; else if (timeout == -1) microseconds = -1; else { timeout *= 1e6; if (timeout >= (double) PY_TIMEOUT_MAX) { PyErr_SetString(PyExc_OverflowError, "timeout value is too large"); return NULL; } microseconds = (PY_TIMEOUT_T) timeout; } tid = PyThread_get_thread_ident(); if (self->rlock_count > 0 && tid == self->rlock_owner) { unsigned long count = self->rlock_count + 1; if (count <= self->rlock_count) { PyErr_SetString(PyExc_OverflowError, "Internal lock count overflowed"); return NULL; } self->rlock_count = count; Py_RETURN_TRUE; } if (self->rlock_count > 0 || !PyThread_acquire_lock(self->rlock_lock, 0)) { if (microseconds == 0) { Py_RETURN_FALSE; } r = acquire_timed(self->rlock_lock, microseconds); } if (r == PY_LOCK_ACQUIRED) { assert(self->rlock_count == 0); self->rlock_owner = tid; self->rlock_count = 1; } else if (r == PY_LOCK_INTR) { return NULL; } return PyBool_FromLong(r == PY_LOCK_ACQUIRED); }
static PyObject* _wrap_g_type_is_interface(PyGTypeWrapper *self) { return PyBool_FromLong(G_TYPE_IS_INTERFACE(self->type)); }
static PyObject * pygpgme_context_get_textmode(PyGpgmeContext *self) { return PyBool_FromLong(gpgme_get_textmode(self->ctx)); }
void XBPyThread::Process() { CLog::Log(LOGDEBUG,"Python thread: start processing"); int m_Py_file_input = Py_file_input; // get the global lock PyEval_AcquireLock(); PyThreadState* state = Py_NewInterpreter(); if (!state) { PyEval_ReleaseLock(); CLog::Log(LOGERROR,"Python thread: FAILED to get thread state!"); return; } // swap in my thread state PyThreadState_Swap(state); m_pExecuter->InitializeInterpreter(); CLog::Log(LOGDEBUG, "%s - The source file to load is %s", __FUNCTION__, m_source); // get path from script file name and add python path's // this is used for python so it will search modules from script path first CStdString scriptDir; CUtil::GetDirectory(_P(m_source), scriptDir); CUtil::RemoveSlashAtEnd(scriptDir); CStdString path = scriptDir; // add on any addon modules the user has installed ADDON::VECADDONS addons; ADDON::CAddonMgr::Get().GetAddons(ADDON::ADDON_SCRIPT_MODULE, addons); for (unsigned int i = 0; i < addons.size(); ++i) path += PY_PATH_SEP + _P(addons[i]->LibPath()); // and add on whatever our default path is path += PY_PATH_SEP; #if (defined USE_EXTERNAL_PYTHON) { // we want to use sys.path so it includes site-packages // if this fails, default to using Py_GetPath PyObject *sysMod(PyImport_ImportModule("sys")); // must call Py_DECREF when finished PyObject *sysModDict(PyModule_GetDict(sysMod)); // borrowed ref, no need to delete PyObject *pathObj(PyDict_GetItemString(sysModDict, "path")); // borrowed ref, no need to delete if( pathObj && PyList_Check(pathObj) ) { for( int i = 0; i < PyList_Size(pathObj); i++ ) { PyObject *e = PyList_GetItem(pathObj, i); // borrowed ref, no need to delete if( e && PyString_Check(e) ) { path += PyString_AsString(e); // returns internal data, don't delete or modify path += PY_PATH_SEP; } } } else { path += Py_GetPath(); } Py_DECREF(sysMod); // release ref to sysMod } #else path += Py_GetPath(); #endif // set current directory and python's path. if (m_argv != NULL) PySys_SetArgv(m_argc, m_argv); CLog::Log(LOGDEBUG, "%s - Setting the Python path to %s", __FUNCTION__, path.c_str()); PySys_SetPath((char *)path.c_str()); CLog::Log(LOGDEBUG, "%s - Entering source directory %s", __FUNCTION__, scriptDir.c_str()); PyObject* module = PyImport_AddModule((char*)"__main__"); PyObject* moduleDict = PyModule_GetDict(module); // when we are done initing we store thread state so we can be aborted PyThreadState_Swap(NULL); PyEval_ReleaseLock(); // we need to check if we was asked to abort before we had inited bool stopping = false; { CSingleLock lock(m_pExecuter->m_critSection); m_threadState = state; stopping = m_stopping; } PyEval_AcquireLock(); PyThreadState_Swap(state); xbp_chdir(scriptDir.c_str()); if (!stopping) { if (m_type == 'F') { // run script from file FILE *fp = fopen_utf8(_P(m_source).c_str(), "r"); if (fp) { PyObject *f = PyString_FromString(_P(m_source).c_str()); PyDict_SetItemString(moduleDict, "__file__", f); Py_DECREF(f); PyRun_File(fp, _P(m_source).c_str(), m_Py_file_input, moduleDict, moduleDict); fclose(fp); } else CLog::Log(LOGERROR, "%s not found!", m_source); } else { //run script PyRun_String(m_source, m_Py_file_input, moduleDict, moduleDict); } } if (!PyErr_Occurred()) CLog::Log(LOGINFO, "Scriptresult: Success"); else if (PyErr_ExceptionMatches(PyExc_SystemExit)) CLog::Log(LOGINFO, "Scriptresult: Aborted"); else { PyObject* exc_type; PyObject* exc_value; PyObject* exc_traceback; PyObject* pystring; pystring = NULL; PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); if (exc_type == 0 && exc_value == 0 && exc_traceback == 0) { CLog::Log(LOGINFO, "Strange: No Python exception occured"); } else { if (exc_type != NULL && (pystring = PyObject_Str(exc_type)) != NULL && (PyString_Check(pystring))) { PyObject *tracebackModule; CLog::Log(LOGINFO, "-->Python script returned the following error<--"); CLog::Log(LOGERROR, "Error Type: %s", PyString_AsString(PyObject_Str(exc_type))); if (PyObject_Str(exc_value)) CLog::Log(LOGERROR, "Error Contents: %s", PyString_AsString(PyObject_Str(exc_value))); tracebackModule = PyImport_ImportModule((char*)"traceback"); if (tracebackModule != NULL) { PyObject *tbList, *emptyString, *strRetval; tbList = PyObject_CallMethod(tracebackModule, (char*)"format_exception", (char*)"OOO", exc_type, exc_value == NULL ? Py_None : exc_value, exc_traceback == NULL ? Py_None : exc_traceback); emptyString = PyString_FromString(""); strRetval = PyObject_CallMethod(emptyString, (char*)"join", (char*)"O", tbList); CLog::Log(LOGERROR, "%s", PyString_AsString(strRetval)); Py_DECREF(tbList); Py_DECREF(emptyString); Py_DECREF(strRetval); Py_DECREF(tracebackModule); } CLog::Log(LOGINFO, "-->End of Python script error report<--"); } else { pystring = NULL; CLog::Log(LOGINFO, "<unknown exception type>"); } CGUIDialogKaiToast *pDlgToast = (CGUIDialogKaiToast*)g_windowManager.GetWindow(WINDOW_DIALOG_KAI_TOAST); if (pDlgToast) { CStdString desc; CStdString path; CStdString script; CUtil::Split(m_source, path, script); if (script.Equals("default.py")) { CStdString path2; CUtil::RemoveSlashAtEnd(path); CUtil::Split(path, path2, script); } desc.Format(g_localizeStrings.Get(2100), script); pDlgToast->QueueNotification(CGUIDialogKaiToast::Error, g_localizeStrings.Get(257), desc); } } Py_XDECREF(exc_type); Py_XDECREF(exc_value); // caller owns all 3 Py_XDECREF(exc_traceback); // already NULL'd out Py_XDECREF(pystring); } PyObject *m = PyImport_AddModule((char*)"xbmc"); if(!m || PyObject_SetAttrString(m, (char*)"abortRequested", PyBool_FromLong(1))) CLog::Log(LOGERROR, "Scriptresult: failed to set abortRequested"); // make sure all sub threads have finished for(PyThreadState* s = state->interp->tstate_head, *old = NULL; s;) { if(s == state) { s = s->next; continue; } if(old != s) { CLog::Log(LOGINFO, "Scriptresult: Waiting on thread %"PRIu64, (uint64_t)s->thread_id); old = s; } Py_BEGIN_ALLOW_THREADS Sleep(100); Py_END_ALLOW_THREADS s = state->interp->tstate_head; } // pending calls must be cleared out PyXBMC_ClearPendingCalls(state); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); { CSingleLock lock(m_pExecuter->m_critSection); m_threadState = NULL; } PyEval_AcquireLock(); PyThreadState_Swap(state); m_pExecuter->DeInitializeInterpreter(); Py_EndInterpreter(state); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); }
static PyObject* IvrDialogBase_queueIsEmpty(IvrDialogBase* self, PyObject* args) { assert(self->p_dlg); return PyBool_FromLong(self->p_dlg->playlist.isEmpty()); }
static PyObject* pyPickedEventData_getEnabled(pyPickedEventData* self, void*) { return PyBool_FromLong(self->fThis->isEnabled()); }
static PyObject * Alphabet_getflag(Alphabet *self, void *closure) { long f = self->alphabet->flags & *(u32*)closure; return PyBool_FromLong(f); }
static PyObject *pair_is_recursive(PyObject *self, PyObject *_noargs) { // checked return PyBool_FromLong(SibPair_IsRecursive(self)); }
//------------------------------------------------------------------------------------- PyObject* Array::__py_append(PyObject* self, PyObject* args, PyObject* kwargs) { Array* ary = static_cast<Array*>(self); uint32 seq_size = ary->length(); return PyBool_FromLong(seq_ass_slice(self, seq_size, seq_size, &*args) == 0); }
static PyObject* _wrap_g_type_is_classed(PyGTypeWrapper *self) { return PyBool_FromLong(G_TYPE_IS_CLASSED(self->type)); }
static PyObject *PyDccSend_gotalldata_get(PyDccSend *self, void *closure) { RET_NULL_IF_INVALID(self->data); return PyBool_FromLong(DCC_SEND_CAST(self->data)->gotalldata); }
static PyObject* _wrap_g_type_is_instantiatable(PyGTypeWrapper *self) { return PyBool_FromLong(G_TYPE_IS_INSTANTIATABLE(self->type)); }
PyObject * PyMember_GetOne(const char *addr, PyMemberDef *l) { PyObject *v; if ((l->flags & READ_RESTRICTED) && PyEval_GetRestricted()) { PyErr_SetString(PyExc_RuntimeError, "restricted attribute"); return NULL; } addr += l->offset; switch (l->type) { case T_BOOL: v = PyBool_FromLong(*(char*)addr); break; case T_BYTE: v = PyInt_FromLong(*(char*)addr); break; case T_UBYTE: v = PyLong_FromUnsignedLong(*(unsigned char*)addr); break; case T_SHORT: v = PyInt_FromLong(*(short*)addr); break; case T_USHORT: v = PyLong_FromUnsignedLong(*(unsigned short*)addr); break; case T_INT: v = PyInt_FromLong(*(int*)addr); break; case T_UINT: v = PyLong_FromUnsignedLong(*(unsigned int*)addr); break; case T_LONG: v = PyInt_FromLong(*(long*)addr); break; case T_ULONG: v = PyLong_FromUnsignedLong(*(unsigned long*)addr); break; case T_PYSSIZET: v = PyInt_FromSsize_t(*(Py_ssize_t*)addr); break; case T_FLOAT: v = PyFloat_FromDouble((double)*(float*)addr); break; case T_DOUBLE: v = PyFloat_FromDouble(*(double*)addr); break; case T_STRING: if (*(char**)addr == NULL) { Py_INCREF(Py_None); v = Py_None; } else v = PyString_FromString(*(char**)addr); break; case T_STRING_INPLACE: v = PyString_FromString((char*)addr); break; case T_CHAR: v = PyString_FromStringAndSize((char*)addr, 1); break; case T_OBJECT: v = *(PyObject **)addr; if (v == NULL) v = Py_None; Py_INCREF(v); break; case T_OBJECT_EX: v = *(PyObject **)addr; if (v == NULL) PyErr_SetString(PyExc_AttributeError, l->name); Py_XINCREF(v); break; #ifdef HAVE_LONG_LONG case T_LONGLONG: v = PyLong_FromLongLong(*(PY_LONG_LONG *)addr); break; case T_ULONGLONG: v = PyLong_FromUnsignedLongLong(*(unsigned PY_LONG_LONG *)addr); break; #endif /* HAVE_LONG_LONG */ default: PyErr_SetString(PyExc_SystemError, "bad memberdescr type"); v = NULL; } return v; }
static PyObject* _wrap_g_type_is_deep_derivable(PyGTypeWrapper *self) { return PyBool_FromLong(G_TYPE_IS_DEEP_DERIVABLE(self->type)); }
static PyObject * _get_pulls_fd(ImagingDecoderObject *decoder) { return PyBool_FromLong(decoder->pulls_fd); }
static PyObject* _wrap_g_type_is_value_abstract(PyGTypeWrapper *self) { return PyBool_FromLong(G_TYPE_IS_VALUE_ABSTRACT(self->type)); }
//------------------------------------------------------------------------------------- bool InitProgressHandler::process() { if(error_) { Baseapp::getSingleton().dispatcher().breakProcessing(); return false; } Network::Channel* pChannel = Components::getSingleton().getBaseappmgrChannel(); if(pChannel == NULL) return true; if(Baseapp::getSingleton().idClient().size() == 0) return true; if(delayTicks_++ < 1) return true; // 只有第一个baseapp上会创建EntityAutoLoader来自动加载数据库实体 if(g_componentGroupOrder == 1) { if(autoLoadState_ == -1) { autoLoadState_ = 0; pEntityAutoLoader_ = new EntityAutoLoader(networkInterface_, this); return true; } else if(autoLoadState_ == 0) { // 必须等待EntityAutoLoader执行完毕 // EntityAutoLoader执行完毕会设置autoLoadState_ = 1 if(!pEntityAutoLoader_->process()) setAutoLoadState(1); return true; } } pEntityAutoLoader_ = NULL; if(!baseappReady_) { baseappReady_ = true; SCOPED_PROFILE(SCRIPTCALL_PROFILE); // 所有脚本都加载完毕 PyObject* pyResult = PyObject_CallMethod(Baseapp::getSingleton().getEntryScript().get(), const_cast<char*>("onBaseAppReady"), const_cast<char*>("O"), PyBool_FromLong((g_componentGroupOrder == 1) ? 1 : 0)); if(pyResult != NULL) Py_DECREF(pyResult); else SCRIPT_ERROR_CHECK(); return true; } float v = 0.0f; bool completed = false; if(PyObject_HasAttrString(Baseapp::getSingleton().getEntryScript().get(), "onReadyForLogin") > 0) { SCOPED_PROFILE(SCRIPTCALL_PROFILE); // 回调获得是否能够登录 PyObject* pyResult = PyObject_CallMethod(Baseapp::getSingleton().getEntryScript().get(), const_cast<char*>("onReadyForLogin"), const_cast<char*>("O"), PyBool_FromLong((g_componentGroupOrder == 1) ? 1 : 0)); if(pyResult != NULL) { completed = (pyResult == Py_True); if(!completed) { v = (float)PyFloat_AsDouble(pyResult); if (PyErr_Occurred()) { SCRIPT_ERROR_CHECK(); Py_DECREF(pyResult); return true; } } else { v = 100.f; } Py_DECREF(pyResult); } else { SCRIPT_ERROR_CHECK(); return true; } } else { v = 100.f; completed = true; } if(v >= 0.9999f) { v = 100.f; completed = true; } Network::Bundle* pBundle = Network::Bundle::createPoolObject(); (*pBundle).newMessage(BaseappmgrInterface::onBaseappInitProgress); (*pBundle) << g_componentID << v; pChannel->send(pBundle); if(completed) { delete this; return false; } return true; }
static PyObject* _wrap_g_type_is_value_type(PyGTypeWrapper *self) { return PyBool_FromLong(G_TYPE_IS_VALUE_TYPE(self->type)); }
static PyObject *PyNick_send_massjoin_get(PyNick *self, void *closure) { RET_NULL_IF_INVALID(self->data); return PyBool_FromLong(self->data->send_massjoin); }
static PyObject* _wrap_g_type_has_value_table(PyGTypeWrapper *self) { return PyBool_FromLong(G_TYPE_HAS_VALUE_TABLE(self->type)); }
int yara_callback( int message, YR_RULE* rule, void* data) { YR_STRING* string; YR_MATCH* m; YR_META* meta; char* tag_name; size_t tag_length; PyObject* tag_list = NULL; PyObject* string_list = NULL; PyObject* meta_list = NULL; PyObject* match; PyObject* callback_dict; PyObject* object; PyObject* tuple; PyObject* matches = ((CALLBACK_DATA*) data)->matches; PyObject* callback = ((CALLBACK_DATA*) data)->callback; PyObject* callback_result; PyGILState_STATE gil_state; int result = CALLBACK_CONTINUE; if (message == CALLBACK_MSG_SCAN_FINISHED) return CALLBACK_CONTINUE; if (message == CALLBACK_MSG_RULE_NOT_MATCHING && callback == NULL) return CALLBACK_CONTINUE; gil_state = PyGILState_Ensure(); tag_list = PyList_New(0); string_list = PyList_New(0); meta_list = PyDict_New(); if (tag_list == NULL || string_list == NULL || meta_list == NULL) { Py_XDECREF(tag_list); Py_XDECREF(string_list); Py_XDECREF(meta_list); PyGILState_Release(gil_state); return CALLBACK_ERROR; } tag_name = rule->tags; tag_length = tag_name != NULL ? strlen(tag_name) : 0; while (tag_length > 0) { object = PY_STRING(tag_name); PyList_Append(tag_list, object); Py_DECREF(object); tag_name += tag_length + 1; tag_length = strlen(tag_name); } meta = rule->metas; while(!META_IS_NULL(meta)) { if (meta->type == META_TYPE_INTEGER) object = Py_BuildValue("I", meta->integer); else if (meta->type == META_TYPE_BOOLEAN) object = PyBool_FromLong(meta->integer); else object = PY_STRING(meta->string); PyDict_SetItemString(meta_list, meta->identifier, object); Py_DECREF(object); meta++; } string = rule->strings; while (!STRING_IS_NULL(string)) { if (STRING_FOUND(string)) { m = STRING_MATCHES(string).head; while (m != NULL) { object = PyBytes_FromStringAndSize((char*) m->data, m->length); tuple = Py_BuildValue( "(L,s,O)", m->offset, string->identifier, object); PyList_Append(string_list, tuple); Py_DECREF(object); Py_DECREF(tuple); m = m->next; } } string++; } if (message == CALLBACK_MSG_RULE_MATCHING) { match = Match_NEW( rule->identifier, rule->ns->name, tag_list, meta_list, string_list); if (match != NULL) { PyList_Append(matches, match); Py_DECREF(match); } else { Py_DECREF(tag_list); Py_DECREF(string_list); Py_DECREF(meta_list); PyGILState_Release(gil_state); return CALLBACK_ERROR; } } if (callback != NULL) { Py_INCREF(callback); callback_dict = PyDict_New(); object = PyBool_FromLong(message == CALLBACK_MSG_RULE_MATCHING); PyDict_SetItemString(callback_dict, "matches", object); Py_DECREF(object); object = PY_STRING(rule->identifier); PyDict_SetItemString(callback_dict, "rule", object); Py_DECREF(object); object = PY_STRING(rule->ns->name); PyDict_SetItemString(callback_dict, "namespace", object); Py_DECREF(object); PyDict_SetItemString(callback_dict, "tags", tag_list); PyDict_SetItemString(callback_dict, "meta", meta_list); PyDict_SetItemString(callback_dict, "strings", string_list); callback_result = PyObject_CallFunctionObjArgs( callback, callback_dict, NULL); if (callback_result != NULL) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(callback_result)) #else if (PyLong_Check(callback_result) || PyInt_Check(callback_result)) #endif { result = (int) PyLong_AsLong(callback_result); } Py_DECREF(callback_result); } else { result = CALLBACK_ERROR; } Py_DECREF(callback_dict); Py_DECREF(callback); } Py_DECREF(tag_list); Py_DECREF(string_list); Py_DECREF(meta_list); PyGILState_Release(gil_state); return result; }
static PyObject *make_ffmpeg_info(void) { PyObject *ffmpeg_info; int pos = 0; #ifdef WITH_FFMPEG int curversion; #endif ffmpeg_info = PyStructSequence_New(&BlenderAppFFmpegType); if (ffmpeg_info == NULL) { return NULL; } #if 0 // UNUSED #define SetIntItem(flag) \ PyStructSequence_SET_ITEM(ffmpeg_info, pos++, PyLong_FromLong(flag)) #endif #define SetStrItem(str) \ PyStructSequence_SET_ITEM(ffmpeg_info, pos++, PyUnicode_FromString(str)) #define SetObjItem(obj) \ PyStructSequence_SET_ITEM(ffmpeg_info, pos++, obj) #ifdef WITH_FFMPEG # define FFMPEG_LIB_VERSION(lib) { \ curversion = lib ## _version(); \ SetObjItem(Py_BuildValue("(iii)", \ curversion >> 16, (curversion >> 8) % 256, curversion % 256)); \ SetObjItem(PyUnicode_FromFormat("%2d, %2d, %2d", \ curversion >> 16, (curversion >> 8) % 256, curversion % 256)); \ } (void)0 #else # define FFMPEG_LIB_VERSION(lib) { \ SetStrItem("Unknown"); \ SetStrItem("Unknown"); \ } (void)0 #endif #ifdef WITH_FFMPEG SetObjItem(PyBool_FromLong(1)); #else SetObjItem(PyBool_FromLong(0)); #endif FFMPEG_LIB_VERSION(avcodec); FFMPEG_LIB_VERSION(avdevice); FFMPEG_LIB_VERSION(avformat); FFMPEG_LIB_VERSION(avutil); FFMPEG_LIB_VERSION(swscale); #undef FFMPEG_LIB_VERSION if (PyErr_Occurred()) { Py_CLEAR(ffmpeg_info); return NULL; } // #undef SetIntItem #undef SetStrItem #undef SetObjItem return ffmpeg_info; }