void * weechat_python_exec (struct t_plugin_script *script, int ret_type, const char *function, char *format, void **argv) { struct t_plugin_script *old_python_current_script; PyThreadState *old_interpreter; PyObject *evMain, *evDict, *evFunc, *rc; void *argv2[16], *ret_value; int i, argc, *ret_int; /* PyEval_AcquireLock (); */ old_python_current_script = python_current_script; old_interpreter = NULL; if (script->interpreter) { old_interpreter = PyThreadState_Swap (NULL); PyThreadState_Swap (script->interpreter); } evMain = PyImport_AddModule ((char *) "__main__"); evDict = PyModule_GetDict (evMain); evFunc = PyDict_GetItemString (evDict, function); if ( !(evFunc && PyCallable_Check (evFunc)) ) { weechat_printf (NULL, weechat_gettext ("%s%s: unable to run function \"%s\""), weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function); /* PyEval_ReleaseThread (python_current_script->interpreter); */ if (old_interpreter) PyThreadState_Swap (old_interpreter); return NULL; } python_current_script = script; if (argv && argv[0]) { argc = strlen (format); for (i = 0; i < 16; i++) { argv2[i] = (i < argc) ? argv[i] : NULL; } rc = PyObject_CallFunction (evFunc, format, argv2[0], argv2[1], argv2[2], argv2[3], argv2[4], argv2[5], argv2[6], argv2[7], argv2[8], argv2[9], argv2[10], argv2[11], argv2[12], argv2[13], argv2[14], argv2[15]); } else { rc = PyObject_CallFunction (evFunc, NULL); } ret_value = NULL; /* * ugly hack : rc = NULL while 'return weechat.WEECHAT_RC_OK .... * because of '#define WEECHAT_RC_OK 0' */ if (rc == NULL) rc = PyLong_FromLong ((long)0); if (PyErr_Occurred()) { PyErr_Print (); Py_XDECREF(rc); } else if ((ret_type == WEECHAT_SCRIPT_EXEC_STRING) && (PyUnicode_Check (rc))) { ret_value = weechat_python_unicode_to_string (rc); Py_XDECREF(rc); } else if ((ret_type == WEECHAT_SCRIPT_EXEC_STRING) && (PyBytes_Check (rc))) { if (PyBytes_AsString (rc)) ret_value = strdup (PyBytes_AsString (rc)); else ret_value = NULL; Py_XDECREF(rc); } else if ((ret_type == WEECHAT_SCRIPT_EXEC_INT) && (PY_INTEGER_CHECK(rc))) { ret_int = malloc (sizeof (*ret_int)); if (ret_int) *ret_int = (int) PyLong_AsLong (rc); ret_value = ret_int; Py_XDECREF(rc); } else if (ret_type == WEECHAT_SCRIPT_EXEC_HASHTABLE) { ret_value = weechat_python_dict_to_hashtable (rc, WEECHAT_SCRIPT_HASHTABLE_DEFAULT_SIZE, WEECHAT_HASHTABLE_STRING, WEECHAT_HASHTABLE_STRING); Py_XDECREF(rc); } else { weechat_printf (NULL, weechat_gettext ("%s%s: function \"%s\" must return " "a valid value"), weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function); } if (!ret_value) { weechat_printf (NULL, weechat_gettext ("%s%s: error in function \"%s\""), weechat_prefix ("error"), PYTHON_PLUGIN_NAME, function); } /* PyEval_ReleaseThread (python_current_script->interpreter); */ python_current_script = old_python_current_script; if (old_interpreter) PyThreadState_Swap (old_interpreter); return ret_value; }
/* Implementation of '_guide_builder' */ static char __pyx_k____main__[] = "__main__"; static char __pyx_k____test__[] = "__test__"; static PyObject *__pyx_n_s____main__; static PyObject *__pyx_n_s____test__; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { #if PY_VERSION_HEX < 0x03020000 { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, #else PyModuleDef_HEAD_INIT, #endif __Pyx_NAMESTR("_guide_builder"), 0, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s____main__, __pyx_k____main__, sizeof(__pyx_k____main__), 0, 0, 1, 1}, {&__pyx_n_s____test__, __pyx_k____test__, sizeof(__pyx_k____test__), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { return 0; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC init_guide_builder(void); /*proto*/ PyMODINIT_FUNC init_guide_builder(void) #else PyMODINIT_FUNC PyInit__guide_builder(void); /*proto*/ PyMODINIT_FUNC PyInit__guide_builder(void) #endif { PyObject *__pyx_t_1 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit__guide_builder(void)", 0); if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __Pyx_CyFunction_USED if (__Pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4(__Pyx_NAMESTR("_guide_builder"), __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (!PyDict_GetItemString(modules, "_guide_builder")) { if (unlikely(PyDict_SetItemString(modules, "_guide_builder", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } } #endif __pyx_b = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME)); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if CYTHON_COMPILING_IN_PYPY Py_INCREF(__pyx_b); #endif if (__Pyx_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_module_is_main__guide_builder) { if (__Pyx_SetAttrString(__pyx_m, "__name__", __pyx_n_s____main__) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; } /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "_guide_builder.pxd":1 * from _base_types cimport BaseType # <<<<<<<<<<<<<< * from _dawg cimport Dawg * from _dictionary cimport Dictionary */ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(((PyObject *)__pyx_t_1)); if (PyObject_SetAttr(__pyx_m, __pyx_n_s____test__, ((PyObject *)__pyx_t_1)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); if (__pyx_m) { __Pyx_AddTraceback("init _guide_builder", __pyx_clineno, __pyx_lineno, __pyx_filename); Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init _guide_builder"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif }
/* "cython_struct.pyx":12 * initStruct(&mst) * showStruct(&mst) * return mst # <<<<<<<<<<<<<< * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_convert__to_py_myStruct(__pyx_v_mst); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 12; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("cython_struct.test_struct", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, __Pyx_NAMESTR("cython_struct"), 0, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s____main__, __pyx_k____main__, sizeof(__pyx_k____main__), 0, 0, 1, 1}, {&__pyx_n_s____test__, __pyx_k____test__, sizeof(__pyx_k____test__), 0, 0, 1, 1}, {&__pyx_n_s__a, __pyx_k__a, sizeof(__pyx_k__a), 0, 0, 1, 1}, {&__pyx_n_s__cython_struct, __pyx_k__cython_struct, sizeof(__pyx_k__cython_struct), 0, 0, 1, 1}, {&__pyx_n_s__test_struct, __pyx_k__test_struct, sizeof(__pyx_k__test_struct), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { return 0; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants"); __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC initcython_struct(void); /*proto*/ PyMODINIT_FUNC initcython_struct(void) #else PyMODINIT_FUNC PyInit_cython_struct(void); /*proto*/ PyMODINIT_FUNC PyInit_cython_struct(void) #endif { PyObject *__pyx_t_1 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_cython_struct(void)"); if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __pyx_binding_PyCFunctionType_USED if (__pyx_binding_PyCFunctionType_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4(__Pyx_NAMESTR("cython_struct"), __pyx_methods, 0, 0, PYTHON_API_VERSION); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (!__pyx_m) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; #if PY_MAJOR_VERSION < 3 Py_INCREF(__pyx_m); #endif __pyx_b = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME)); if (!__pyx_b) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; if (__Pyx_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_module_is_main_cython_struct) { if (__Pyx_SetAttrString(__pyx_m, "__name__", __pyx_n_s____main__) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; } /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "cython_struct.pyx":8 * cdef void showStruct(myStruct *mst) * * def test_struct(): # <<<<<<<<<<<<<< * cdef myStruct mst * initStruct(&mst) */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_13cython_struct_test_struct, NULL, __pyx_n_s__cython_struct); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyObject_SetAttr(__pyx_m, __pyx_n_s__test_struct, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "cython_struct.pyx":1 * cdef extern from "struct_test.h": # <<<<<<<<<<<<<< * ctypedef struct myStruct: * int a */ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(((PyObject *)__pyx_t_1)); if (PyObject_SetAttr(__pyx_m, __pyx_n_s____test__, ((PyObject *)__pyx_t_1)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); if (__pyx_m) { __Pyx_AddTraceback("init cython_struct", __pyx_clineno, __pyx_lineno, __pyx_filename); Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init cython_struct"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif }
py_state_t *py_state_new(const char *script, unsigned is_file, const char *pyclass) { RARCH_LOG("Initializing Python runtime ...\n"); PyImport_AppendInittab("rarch", &PyInit_Retro); Py_Initialize(); RARCH_LOG("Initialized Python runtime.\n"); py_state_t *handle = (py_state_t*)calloc(1, sizeof(*handle)); PyObject *hook = NULL; handle->main = PyImport_AddModule("__main__"); if (!handle->main) goto error; Py_INCREF(handle->main); if (is_file) { // Have to hack around the fact that the // FILE struct isn't standardized across environments. // PyRun_SimpleFile() breaks on Windows because it's compiled with MSVC. char *script_ = NULL; if (read_file(script, (void**)&script_) < 0) { RARCH_ERR("Python: Failed to read script\n"); goto error; } PyRun_SimpleString(script_); free(script_); } else { char *script_ = align_program(script); if (script_) { PyRun_SimpleString(script_); free(script_); } } RARCH_LOG("Python: Script loaded.\n"); handle->dict = PyModule_GetDict(handle->main); if (!handle->dict) { RARCH_ERR("Python: PyModule_GetDict() failed.\n"); goto error; } Py_INCREF(handle->dict); hook = PyDict_GetItemString(handle->dict, pyclass); if (!hook) { RARCH_ERR("Python: PyDict_GetItemString() failed.\n"); goto error; } handle->inst = PyObject_CallFunction(hook, NULL); if (!handle->inst) { RARCH_ERR("Python: PyObject_CallFunction() failed.\n"); goto error; } Py_INCREF(handle->inst); return handle; error: PyErr_Print(); PyErr_Clear(); py_state_free(handle); return NULL; }
Model buildModel(const std::string & filename, const std::string & model_name, bool verbose) throw (bp::error_already_set) { Py_Initialize(); bp::object main_module = bp::import("__main__"); // Get a dict for the global namespace to exec further python code with bp::dict globals = bp::extract<bp::dict>(main_module.attr("__dict__")); // We need to link to the pinocchio PyWrap. We delegate the dynamic loading to the python interpreter. bp::object cpp_module( (bp::handle<>(bp::borrowed(PyImport_AddModule("libpinocchio_pywrap")))) ); // That's it, you can exec your python script, starting with a model you // can update as you want. try { // Boost 1.58 #if BOOST_VERSION / 100 % 1000 == 58 // Avoid a segv with exec_file // See: https://github.com/boostorg/python/pull/15 std::ifstream t(filename.c_str()); std::stringstream buffer; buffer << t.rdbuf(); bp::exec(buffer.str().c_str(), globals); #else // default implementation bp::exec_file((bp::str)filename, globals); #endif } catch (bp::error_already_set & e) { PyErr_PrintEx(0); } Model model; try { bp::object obj_model = globals[model_name]; model = bp::extract<Model>(obj_model); } catch (bp::error_already_set & e) { PyErr_PrintEx(0); } if (verbose) { std::cout << "Your model has been built. It has " << model.nv; std::cout << " degrees of freedom." << std::endl; } // close the interpreter // cf. https://github.com/numpy/numpy/issues/8097 #if PY_MAJOR_VERSION < 3 Py_Finalize(); #else PyObject * poMainModule = PyImport_AddModule("__main__"); PyObject * poAttrList = PyObject_Dir(poMainModule); PyObject * poAttrIter = PyObject_GetIter(poAttrList); PyObject * poAttrName; while ((poAttrName = PyIter_Next(poAttrIter)) != NULL) { std::string oAttrName = PyUnicode_AS_DATA(poAttrName); // Make sure we don't delete any private objects. if (!boost::starts_with(oAttrName, "__") || !boost::ends_with(oAttrName, "__")) { PyObject * poAttr = PyObject_GetAttr(poMainModule, poAttrName); // Make sure we don't delete any module objects. if (poAttr && poAttr->ob_type != poMainModule->ob_type) PyObject_SetAttr(poMainModule, poAttrName, NULL); Py_DecRef(poAttr); } Py_DecRef(poAttrName); } Py_DecRef(poAttrIter); Py_DecRef(poAttrList); #endif return model; }
mitk::Image::Pointer mitk::PythonService::CopySimpleItkImageFromPython(const std::string &stdvarName) { double*ds = NULL; // access python module PyObject *pyMod = PyImport_AddModule((char*)"__main__"); // global dictionarry PyObject *pyDict = PyModule_GetDict(pyMod); mitk::Image::Pointer mitkImage = mitk::Image::New(); mitk::Vector3D spacing; mitk::Point3D origin; QString command; QString varName = QString::fromStdString( stdvarName ); command.append( QString("%1_numpy_array = sitk.GetArrayFromImage(%1)\n").arg(varName) ); command.append( QString("%1_spacing = numpy.asarray(%1.GetSpacing())\n").arg(varName) ); command.append( QString("%1_origin = numpy.asarray(%1.GetOrigin())\n").arg(varName) ); command.append( QString("%1_dtype = %1_numpy_array.dtype.name").arg(varName) ); MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString(); this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND ); PyObject* py_dtype = PyDict_GetItemString(pyDict,QString("%1_dtype").arg(varName).toStdString().c_str() ); std::string dtype = PyString_AsString(py_dtype); PyArrayObject* py_data = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_numpy_array").arg(varName).toStdString().c_str() ); PyArrayObject* py_spacing = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_spacing").arg(varName).toStdString().c_str() ); PyArrayObject* py_origin = (PyArrayObject*) PyDict_GetItemString(pyDict,QString("%1_origin").arg(varName).toStdString().c_str() ); size_t sz = sizeof(short); mitk::PixelType pixelType = MakeScalarPixelType<short>(); if( dtype.compare("float64") == 0 ) { pixelType = MakeScalarPixelType<double>(); sz = sizeof(double); } else if( dtype.compare("float32") == 0 ) { pixelType = MakeScalarPixelType<float>(); sz = sizeof(float); } else if( dtype.compare("int16") == 0) { pixelType = MakeScalarPixelType<short>(); sz = sizeof(short); } else if( dtype.compare("int8") == 0 ) { pixelType = MakeScalarPixelType<char>(); sz = sizeof(char); } else if( dtype.compare("int32") == 0 ) { pixelType = MakeScalarPixelType<int>(); sz = sizeof(int); } else if( dtype.compare("int64") == 0 ) { pixelType = MakeScalarPixelType<long>(); sz = sizeof(long); } else if( dtype.compare("uint8") == 0 ) { pixelType = MakeScalarPixelType<unsigned char>(); sz = sizeof(unsigned char); } else if( dtype.compare("uint32") == 0 ) { pixelType = MakeScalarPixelType<unsigned int>(); sz = sizeof(unsigned int); } else if( dtype.compare("uint64") == 0 ) { pixelType = MakeScalarPixelType<unsigned long>(); sz = sizeof(unsigned long); } else if( dtype.compare("uint16") == 0 ) { pixelType = MakeScalarPixelType<unsigned short>(); sz = sizeof(unsigned short); } unsigned int* dimensions = new unsigned int[py_data->nd]; // fill backwards , nd data saves dimensions in opposite direction for( int i = 0; i < py_data->nd; ++i ) { dimensions[i] = py_data->dimensions[py_data->nd - 1 - i]; sz *= dimensions[i]; } mitkImage->Initialize(pixelType, py_data->nd, dimensions); mitkImage->SetChannel(py_data->data); ds = (double*)py_spacing->data; spacing[0] = ds[0]; spacing[1] = ds[1]; spacing[2] = ds[2]; mitkImage->GetGeometry()->SetSpacing(spacing); ds = (double*)py_origin->data; origin[0] = ds[0]; origin[1] = ds[1]; origin[2] = ds[2]; mitkImage->GetGeometry()->SetOrigin(origin); // cleanup command.clear(); command.append( QString("del %1_numpy_array\n").arg(varName) ); command.append( QString("del %1_dtype\n").arg(varName) ); command.append( QString("del %1_spacing\n").arg(varName) ); command.append( QString("del %1_origin").arg(varName) ); MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString(); this->Execute(command.toStdString(), IPythonService::MULTI_LINE_COMMAND ); delete[] dimensions; return mitkImage; }
bool get_plots(const std::string& python_file, std::vector<Plot>& plots) { plots.clear(); std::FILE* f = std::fopen(python_file.c_str(), "r"); if (!f) { std::cerr << "Failed to open '" << python_file << "'" <<std::endl; return false; } const std::string PLOTS_KEY_NAME = "plots"; // Get a reference to the main module // and global dictionary PyObject* main_module = PyImport_AddModule("__main__"); PyObject* global_dict = PyModule_GetDict(main_module); // If PyROOT is used inside the script, it performs some cleanups when the python env. is destroyed. This cleanup makes ROOT unusable afterwards. // The cleanup function is registered with the `atexit` module. // The solution is to not execute the cleanup function. For that, before destroying the python env, we check the list of exit functions, // and delete the one from PyROOT if found // Ensure the module is loaded PyObject* atexit_module = PyImport_ImportModule("atexit"); // Execute the script PyObject* script_result = PyRun_File(f, python_file.c_str(), Py_file_input, global_dict, global_dict); if (! script_result) { PyErr_Print(); return false; } else { PyObject* py_plots = PyDict_GetItemString(global_dict, "plots"); if (!py_plots) { std::cerr << "No 'plots' variable declared in python script" << std::endl; return false; } if (! PyList_Check(py_plots)) { std::cerr << "The 'plots' variable is not a list" << std::endl; return false; } size_t l = PyList_Size(py_plots); if (! l) return true; for (size_t i = 0; i < l; i++) { PyObject* item = PyList_GetItem(py_plots, i); Plot plot; if (plot_from_PyObject(item, plot)) { plots.push_back(plot); } } } PyObject* atexit_exithandlers = PyObject_GetAttrString(atexit_module, "_exithandlers"); for (size_t i = 0; i < PySequence_Size(atexit_exithandlers); i++) { PyObject* tuple = PySequence_GetItem(atexit_exithandlers, i); PyObject* f = PySequence_GetItem(tuple, 0); PyObject* module = PyFunction_GetModule(f); if (module && strcmp(PyString_AsString(module), "ROOT") == 0) { PySequence_DelItem(atexit_exithandlers, i); break; } } return true; }
bool py_execute(PyCodeObject* py_func, DSMSession* sc_sess, DSMCondition::EventType event, map<string,string>* event_params, bool expect_int_result) { // acquire the GIL PYLOCK; bool py_res = false; DBG("add main \n"); PyObject* m = PyImport_AddModule("__main__"); if (m == NULL) { ERROR("getting main module\n"); return false; } DBG("get globals \n"); PyObject* globals = PyModule_GetDict(m); PyObject* locals = getPyLocals(sc_sess); PyObject* params = PyDict_New(); if (NULL != event_params) { for (map<string,string>::iterator it=event_params->begin(); it != event_params->end(); it++) { PyObject* v = PyString_FromString(it->second.c_str()); PyDict_SetItemString(params, it->first.c_str(), v); Py_DECREF(v); } } PyDict_SetItemString(locals, "params", params); PyObject *t = PyInt_FromLong(event); PyDict_SetItemString(locals, "type", t); PyObject* py_sc_sess = PyCObject_FromVoidPtr(sc_sess,NULL); PyObject* ts_dict = PyThreadState_GetDict(); PyDict_SetItemString(ts_dict, "_dsm_sess_", py_sc_sess); Py_DECREF(py_sc_sess); // call the function PyObject* res = PyEval_EvalCode((PyCodeObject*)py_func, globals, locals); if(PyErr_Occurred()) PyErr_Print(); PyDict_DelItemString(locals, "params"); PyDict_Clear(params); Py_DECREF(params); PyDict_DelItemString(locals, "type"); Py_DECREF(t); // ts_dict = PyThreadState_GetDict(); // should be the same as before PyDict_DelItemString(ts_dict, "_dsm_sess_"); if (NULL == res) { ERROR("evaluating python code\n"); } else if (PyBool_Check(res)) { py_res = PyInt_AsLong(res); Py_DECREF(res); } else { if (expect_int_result) { ERROR("unknown result from python code\n"); } Py_DECREF(res); } return py_res; }
uint32_t mainThread(int argc, char *argv[], bool so) { int rc = 0; PyObject *m=NULL, *d=NULL, *seq=NULL; PyObject *mod; char * ppath; FILE * f; uintptr_t cookie = 0; PyGILState_STATE restore_state; if(!Py_IsInitialized) { int res=0; if(!_load_python( "libpython2.7.so", resources_python27_so_start, resources_python27_so_size)) { dprint("loading libpython2.7.so from memory failed\n"); return -1; } } dprint("calling PyEval_InitThreads() ...\n"); PyEval_InitThreads(); dprint("PyEval_InitThreads() called\n"); if(!Py_IsInitialized()) { dprint("Py_IsInitialized\n"); Py_IgnoreEnvironmentFlag = 1; Py_NoSiteFlag = 1; /* remove site.py auto import */ dprint("INVOCATION NAME: %s\n", program_invocation_name); Py_SetProgramName(program_invocation_name); dprint("Initializing python.. (%p)\n", Py_Initialize); Py_InitializeEx(0); dprint("SET ARGV\n"); if (argc > 0) { if (so) { if (argc > 2 && !strcmp(argv[1], "--pass-args")) { argv[1] = argv[0]; PySys_SetArgvEx(argc - 1, argv + 1, 0); } else { PySys_SetArgvEx(1, argv, 0); } } else { PySys_SetArgvEx(argc, argv, 0); } } PySys_SetPath("."); #ifndef DEBUG PySys_SetObject("frozen", PyBool_FromLong(1)); #endif dprint("Py_Initialize() complete\n"); } restore_state=PyGILState_Ensure(); init_memimporter(); dprint("init_memimporter()\n"); initpupy(); dprint("initpupy()\n"); #ifdef _PYZLIB_DYNLOAD dprint("load zlib\n"); if (!import_module("initzlib", "zlib", resources_zlib_so_start, resources_zlib_so_size)) { dprint("ZLib load failed.\n"); } #endif /* We execute then in the context of '__main__' */ dprint("starting evaluating python code ...\n"); m = PyImport_AddModule("__main__"); if (m) d = PyModule_GetDict(m); if (d) seq = PyMarshal_ReadObjectFromString( resources_bootloader_pyc_start, resources_bootloader_pyc_size ); if (seq) { Py_ssize_t i, max = PySequence_Length(seq); for (i=0;i<max;i++) { dprint("LOAD SEQUENCE %d\n", i); PyObject *sub = PySequence_GetItem(seq, i); if (seq) { PyObject *discard = PyEval_EvalCode((PyCodeObject *)sub, d, d); if (!discard) { dprint("discard\n"); PyErr_Print(); rc = 255; } Py_XDECREF(discard); /* keep going even if we fail */ } Py_XDECREF(sub); } } dprint("complete ...\n"); PyGILState_Release(restore_state); Py_Finalize(); dprint("exit ...\n"); return 0; }
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(addon); 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; URIUtils::GetDirectory(_P(m_source), scriptDir); URIUtils::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) #ifdef TARGET_WINDOWS { CStdString strTmp(_P(addons[i]->LibPath())); g_charsetConverter.utf8ToStringCharset(strTmp); path += PY_PATH_SEP + strTmp; } #else path += PY_PATH_SEP + _P(addons[i]->LibPath()); #endif // and add on whatever our default path is path += PY_PATH_SEP; // we want to use sys.path so it includes site-packages // if this fails, default to using Py_GetPath PyObject *sysMod(PyImport_ImportModule((char*)"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 // 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); if (!stopping) { if (m_type == 'F') { // run script from file // We need to have python open the file because on Windows the DLL that python // is linked against may not be the DLL that xbmc is linked against so // passing a FILE* to python from an fopen has the potential to crash. PyObject* file = PyFile_FromString((char *) _P(m_source).c_str(), (char*)"r"); FILE *fp = PyFile_AsFile(file); if (fp) { PyObject *f = PyString_FromString(_P(m_source).c_str()); PyDict_SetItemString(moduleDict, "__file__", f); if (addon.get() != NULL) { PyObject *pyaddonid = PyString_FromString(addon->ID().c_str()); PyDict_SetItemString(moduleDict, "__xbmcaddonid__", pyaddonid); CStdString version = ADDON::GetXbmcApiVersionDependency(addon); PyObject *pyxbmcapiversion = PyString_FromString(version.c_str()); PyDict_SetItemString(moduleDict, "__xbmcapiversion__", pyxbmcapiversion); CLog::Log(LOGDEBUG,"Instantiating addon using automatically obtained id of \"%s\" dependent on version %s of the xbmc.python api",addon->ID().c_str(),version.c_str()); } Py_DECREF(f); PyRun_FileExFlags(fp, _P(m_source).c_str(), m_Py_file_input, moduleDict, moduleDict,1,NULL); } 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; URIUtils::Split(m_source, path, script); if (script.Equals("default.py")) { CStdString path2; URIUtils::RemoveSlashAtEnd(path); URIUtils::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; } CPyThreadState pyState; Sleep(100); pyState.Restore(); 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(); }
void Python_script::execute(const std::string grid_name, const std::vector<std::string> prop_names) const { PyRun_SimpleString("" "import redirect\n" "class CoutLogger:\n" " def __init__(self):\n" " self.buf = []\n" " def write(self, data):\n" " self.buf.append(data)\n" " if data.endswith('\\n'):\n" " redirect.sgems_cout(''.join(self.buf))\n" " self.buf = []\n" "\n" "class CerrLogger:\n" " def __init__(self):\n" " self.buf = []\n" " def write(self, data):\n" " self.buf.append(data)\n" " if data.endswith('\\n'):\n" " redirect.sgems_cerr(''.join(self.buf))\n" " self.buf = []\n" "\n" "import sys\n" "sys.stdout = CoutLogger()\n" "sys.stderr = CerrLogger()\n" ""); FILE* fp = fopen(filename_.c_str(), "r"); if (!fp) { GsTLcerr << "can't open file " << filename_ << gstlIO::end; return; } PyObject* module = PyImport_AddModule("__main__"); PyObject* dictionary = PyModule_GetDict(module); PyObject* dictionary_copy = PyDict_Copy(dictionary); PyRun_File(fp, filename_.c_str(), Py_file_input, dictionary_copy, dictionary_copy); PyObject* function = PyDict_GetItemString(dictionary_copy, "sgems_execute_action"); if (PyCallable_Check(function)) { // PyObject* properties = Py_BuildValue("[ss]", prop_names.at(0).c_str(), prop_names.at(0).c_str()); // if (NULL == properties) // { // std::cout << "building value failed\n"; // } // PyObject* properties = PyList_New(prop_names.size()); // for (int i = 0; i < prop_names.size(); ++i) // { // PyList_SetItem(properties, i, PyString_FromString(prop_names.at(i).c_str())); // } // PyObject* result = PyObject_CallFunction(function, "s[o]", grid_name.c_str(), properties); PyObject* result = NULL; switch (prop_names.size()) { case 1: result = PyObject_CallFunction(function, "s[s]", grid_name.c_str(), prop_names.at(0).c_str()); break; case 2: result = PyObject_CallFunction(function, "s[ss]", grid_name.c_str(), prop_names.at(0).c_str(), prop_names.at(1).c_str()); break; default: GsTLcerr << "Execution of python script failed.\n Cannot have more than 2 properties selected\n" << gstlIO::end; break; } // if (NULL == result) // { // std::cout << "execution failed\n"; // } Py_XDECREF(result); } Py_XDECREF(dictionary_copy); fclose(fp); }
void XBPyThread::stop() { CSingleLock lock(m_critSec); if(m_stopping) return; m_stopping = true; if (m_threadState) { PyEval_AcquireLock(); PyThreadState* old = PyThreadState_Swap((PyThreadState*)m_threadState); //tell xbmc.Monitor to call onAbortRequested() if (addon) g_pythonParser.OnAbortRequested(addon->ID()); PyObject *m; m = PyImport_AddModule((char*)"xbmc"); if(!m || PyObject_SetAttrString(m, (char*)"abortRequested", PyBool_FromLong(1))) CLog::Log(LOGERROR, "XBPyThread::stop - failed to set abortRequested"); PyThreadState_Swap(old); old = NULL; PyEval_ReleaseLock(); XbmcThreads::EndTime timeout(PYTHON_SCRIPT_TIMEOUT); while (!stoppedEvent.WaitMSec(15)) { if (timeout.IsTimePast()) { CLog::Log(LOGERROR, "XBPyThread::stop - script %s didn't stop in %d seconds - let's kill it", m_source, PYTHON_SCRIPT_TIMEOUT / 1000); break; } // We can't empty-spin in the main thread and expect scripts to be able to // dismantle themselves. Python dialogs aren't normal XBMC dialogs, they rely // on TMSG_GUI_PYTHON_DIALOG messages, so pump the message loop. if (g_application.IsCurrentThread()) { CSingleExit ex(g_graphicsContext); CApplicationMessenger::Get().ProcessMessages(); } } // Useful for add-on performance metrics if (!timeout.IsTimePast()) CLog::Log(LOGDEBUG, "XBPyThread::stop - script termination took %dms", PYTHON_SCRIPT_TIMEOUT - timeout.MillisLeft()); //everything which didn't exit by now gets killed { // grabbing the PyLock while holding the m_critSec is asking for a deadlock CSingleExit ex2(m_critSec); PyEval_AcquireLock(); } // Since we released the m_critSec it's possible that the state is cleaned up // so we need to recheck for m_threadState == NULL if (m_threadState) { old = PyThreadState_Swap((PyThreadState*)m_threadState); for(PyThreadState* state = ((PyThreadState*)m_threadState)->interp->tstate_head; state; state = state->next) { // Raise a SystemExit exception in python threads Py_XDECREF(state->async_exc); state->async_exc = PyExc_SystemExit; Py_XINCREF(state->async_exc); } // If a dialog entered its doModal(), we need to wake it to see the exception g_pythonParser.PulseGlobalEvent(); } if (old != NULL) PyThreadState_Swap(old); lock.Leave(); PyEval_ReleaseLock(); } }
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); XBMCAddon::AddonClass::Ref<XBMCAddon::Python::LanguageHook> languageHook(new XBMCAddon::Python::LanguageHook(state->interp)); languageHook->RegisterMe(); m_pExecuter->InitializeInterpreter(addon); 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; URIUtils::GetDirectory(CSpecialProtocol::TranslatePath(m_source), scriptDir); URIUtils::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) #ifdef TARGET_WINDOWS { CStdString strTmp(CSpecialProtocol::TranslatePath(addons[i]->LibPath())); g_charsetConverter.utf8ToSystem(strTmp); path += PY_PATH_SEP + strTmp; } #else path += PY_PATH_SEP + CSpecialProtocol::TranslatePath(addons[i]->LibPath()); #endif // and add on whatever our default path is path += PY_PATH_SEP; // we want to use sys.path so it includes site-packages // if this fails, default to using Py_GetPath PyObject *sysMod(PyImport_ImportModule((char*)"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 // 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_critSec); m_threadState = state; stopping = m_stopping; } PyEval_AcquireLock(); PyThreadState_Swap(state); if (!stopping) { try { if (m_type == 'F') { // run script from file // We need to have python open the file because on Windows the DLL that python // is linked against may not be the DLL that xbmc is linked against so // passing a FILE* to python from an fopen has the potential to crash. PyObject* file = PyFile_FromString((char *) CSpecialProtocol::TranslatePath(m_source).c_str(), (char*)"r"); FILE *fp = PyFile_AsFile(file); if (fp) { PyObject *f = PyString_FromString(CSpecialProtocol::TranslatePath(m_source).c_str()); PyDict_SetItemString(moduleDict, "__file__", f); if (addon.get() != NULL) { PyObject *pyaddonid = PyString_FromString(addon->ID().c_str()); PyDict_SetItemString(moduleDict, "__xbmcaddonid__", pyaddonid); CStdString version = ADDON::GetXbmcApiVersionDependency(addon); PyObject *pyxbmcapiversion = PyString_FromString(version.c_str()); PyDict_SetItemString(moduleDict, "__xbmcapiversion__", pyxbmcapiversion); CLog::Log(LOGDEBUG,"Instantiating addon using automatically obtained id of \"%s\" dependent on version %s of the xbmc.python api",addon->ID().c_str(),version.c_str()); } Py_DECREF(f); XBMCAddon::Python::PyContext pycontext; // this is a guard class that marks this callstack as being in a python context PyRun_FileExFlags(fp, CSpecialProtocol::TranslatePath(m_source).c_str(), m_Py_file_input, moduleDict, moduleDict,1,NULL); } else CLog::Log(LOGERROR, "%s not found!", m_source); } else { //run script PyRun_String(m_source, m_Py_file_input, moduleDict, moduleDict); } } catch (const XbmcCommons::Exception& e) { e.LogThrowMessage(); } catch (...) { CLog::Log(LOGERROR, "failure in %s", m_source); } } bool systemExitThrown = false; if (!PyErr_Occurred()) CLog::Log(LOGINFO, "Scriptresult: Success"); else if (PyErr_ExceptionMatches(PyExc_SystemExit)) { systemExitThrown = true; CLog::Log(LOGINFO, "Scriptresult: Aborted"); } else { PythonBindings::PythonToCppException e; e.LogThrowMessage(); { CPyThreadState releaseGil; CSingleLock gc(g_graphicsContext); CGUIDialogKaiToast *pDlgToast = (CGUIDialogKaiToast*)g_windowManager.GetWindow(WINDOW_DIALOG_KAI_TOAST); if (pDlgToast) { CStdString desc; CStdString path; CStdString script; URIUtils::Split(m_source, path, script); if (script.Equals("default.py")) { CStdString path2; URIUtils::RemoveSlashAtEnd(path); URIUtils::Split(path, path2, script); } desc.Format(g_localizeStrings.Get(2100), script); pDlgToast->QueueNotification(CGUIDialogKaiToast::Error, g_localizeStrings.Get(257), desc); } } } 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; } CPyThreadState pyState; Sleep(100); pyState.Restore(); s = state->interp->tstate_head; } // pending calls must be cleared out XBMCAddon::RetardedAsynchCallbackHandler::clearPendingCalls(state); PyThreadState_Swap(NULL); PyEval_ReleaseLock(); //set stopped event - this allows ::stop to run and kill remaining threads //this event has to be fired without holding m_critSec // //Also the GIL (PyEval_AcquireLock) must not be held //if not obeyed there is still no deadlock because ::stop waits with timeout (smart one!) stoppedEvent.Set(); { CSingleLock lock(m_critSec); m_threadState = NULL; } PyEval_AcquireLock(); PyThreadState_Swap(state); m_pExecuter->DeInitializeInterpreter(); // run the gc before finishing // // if the script exited by throwing a SystemExit excepton then going back // into the interpreter causes this python bug to get hit: // http://bugs.python.org/issue10582 // and that causes major failures. So we are not going to go back in // to run the GC if that's the case. if (!m_stopping && languageHook->HasRegisteredAddonClasses() && !systemExitThrown && PyRun_SimpleString(GC_SCRIPT) == -1) CLog::Log(LOGERROR,"Failed to run the gc to clean up after running prior to shutting down the Interpreter %s",m_source); Py_EndInterpreter(state); // If we still have objects left around, produce an error message detailing what's been left behind if (languageHook->HasRegisteredAddonClasses()) CLog::Log(LOGWARNING, "The python script \"%s\" has left several " "classes in memory that we couldn't clean up. The classes include: %s", m_source, getListOfAddonClassesAsString(languageHook).c_str()); // unregister the language hook languageHook->UnregisterMe(); PyEval_ReleaseLock(); }
/* Implementation of cforfromloop */ static struct PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; static void __pyx_init_filenames(void); /*proto*/ PyMODINIT_FUNC initcforfromloop(void); /*proto*/ PyMODINIT_FUNC initcforfromloop(void) { long __pyx_1; PyObject *__pyx_2 = 0; long __pyx_3; int __pyx_4; __pyx_init_filenames(); __pyx_m = Py_InitModule4("cforfromloop", __pyx_methods, 0, 0, PYTHON_API_VERSION); if (!__pyx_m) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;}; Py_INCREF(__pyx_m); __pyx_b = PyImport_AddModule("__builtin__"); if (!__pyx_b) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;}; if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;}; if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; goto __pyx_L1;}; __pyx_v_12cforfromloop_a = Py_None; Py_INCREF(Py_None); __pyx_v_12cforfromloop_b = Py_None; Py_INCREF(Py_None); __pyx_v_12cforfromloop_x = Py_None; Py_INCREF(Py_None); /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":4 */ for (__pyx_v_12cforfromloop_i = 0; __pyx_v_12cforfromloop_i < 10; ++__pyx_v_12cforfromloop_i) { } /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":7 */ for (__pyx_v_12cforfromloop_i = 0+1; __pyx_v_12cforfromloop_i <= 10; ++__pyx_v_12cforfromloop_i) { } /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":10 */ for (__pyx_v_12cforfromloop_i = 10; __pyx_v_12cforfromloop_i > 0; --__pyx_v_12cforfromloop_i) { } /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":13 */ for (__pyx_v_12cforfromloop_i = 10-1; __pyx_v_12cforfromloop_i >= 0; --__pyx_v_12cforfromloop_i) { } /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":16 */ for (__pyx_1 = 0; __pyx_1 <= 10; ++__pyx_1) { __pyx_2 = PyInt_FromLong(__pyx_1); if (!__pyx_2) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 16; goto __pyx_L1;} Py_DECREF(__pyx_v_12cforfromloop_x); __pyx_v_12cforfromloop_x = __pyx_2; __pyx_2 = 0; } /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":19 */ __pyx_1 = PyInt_AsLong(__pyx_v_12cforfromloop_a); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 19; goto __pyx_L1;} __pyx_3 = PyInt_AsLong(__pyx_v_12cforfromloop_b); if (PyErr_Occurred()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 19; goto __pyx_L1;} for (__pyx_v_12cforfromloop_i = __pyx_1; __pyx_v_12cforfromloop_i <= __pyx_3; ++__pyx_v_12cforfromloop_i) { } /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":22 */ for (__pyx_v_12cforfromloop_i = __pyx_v_12cforfromloop_k; __pyx_v_12cforfromloop_i <= __pyx_v_12cforfromloop_j; ++__pyx_v_12cforfromloop_i) { } /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":25 */ __pyx_1 = (__pyx_v_12cforfromloop_j / 18); for (__pyx_v_12cforfromloop_i = (__pyx_v_12cforfromloop_k * 42); __pyx_v_12cforfromloop_i <= __pyx_1; ++__pyx_v_12cforfromloop_i) { } /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":28 */ while (1) { __pyx_4 = __pyx_v_12cforfromloop_j; if (!__pyx_4) break; for (__pyx_v_12cforfromloop_i = 0; __pyx_v_12cforfromloop_i <= 10; ++__pyx_v_12cforfromloop_i) { /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":30 */ goto __pyx_L20; /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":31 */ goto __pyx_L21; __pyx_L20:; } /*else*/ { /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":33 */ goto __pyx_L18; /* "/Local/Projects/D/Pyrex/Source/Tests/7/cforfromloop.pyx":34 */ goto __pyx_L19; } __pyx_L21:; __pyx_L18:; } __pyx_L19:; return; __pyx_L1:; Py_XDECREF(__pyx_2); __Pyx_AddTraceback("cforfromloop"); }
static void run_interpreter(FILE *input, FILE *output) { PyThreadState *tstate; PyObject *new_stdin, *new_stdout; PyObject *mainmod, *globals; char buffer[1000]; char *p, *q; int n, end; PyEval_AcquireLock(); tstate = Py_NewInterpreter(); if (tstate == NULL) { fprintf(output, "Sorry -- can't create an interpreter\n"); return; } mainmod = PyImport_AddModule("__main__"); globals = PyModule_GetDict(mainmod); Py_INCREF(globals); new_stdin = PyFile_FromFile(input, "<socket-in>", "r", NULL); new_stdout = PyFile_FromFile(output, "<socket-out>", "w", NULL); PySys_SetObject("stdin", new_stdin); PySys_SetObject("stdout", new_stdout); PySys_SetObject("stderr", new_stdout); for (n = 1; !PyErr_Occurred(); n++) { Py_BEGIN_ALLOW_THREADS fprintf(output, "%d> ", n); p = fgets(buffer, sizeof buffer, input); Py_END_ALLOW_THREADS if (p == NULL) break; if (p[0] == '\377' && p[1] == '\354') break; q = strrchr(p, '\r'); if (q && q[1] == '\n' && q[2] == '\0') { *q++ = '\n'; *q++ = '\0'; } while (*p && isspace(*p)) p++; if (p[0] == '#' || p[0] == '\0') continue; end = run_command(buffer, globals); if (end < 0) PyErr_Print(); if (end) break; } Py_XDECREF(globals); Py_XDECREF(new_stdin); Py_XDECREF(new_stdout); Py_EndInterpreter(tstate); PyEval_ReleaseLock(); fprintf(output, "Goodbye!\n"); }
PyObject *uwsgi_pyimport_by_filename(char *name, char *filename) { #ifdef UWSGI_PYPY uwsgi_log("import by filename is currently not supported on PyPy !!!\n"); return NULL; #else FILE *pyfile; struct _node *py_file_node = NULL; PyObject *py_compiled_node, *py_file_module; int is_a_package = 0; struct stat pystat; char *real_filename = filename; if (!uwsgi_check_scheme(filename)) { pyfile = fopen(filename, "r"); if (!pyfile) { uwsgi_log("failed to open python file %s\n", filename); return NULL; } if (fstat(fileno(pyfile), &pystat)) { uwsgi_error("fstat()"); return NULL; } if (S_ISDIR(pystat.st_mode)) { is_a_package = 1; fclose(pyfile); real_filename = uwsgi_concat2(filename, "/__init__.py"); pyfile = fopen(real_filename, "r"); if (!pyfile) { uwsgi_error_open(real_filename); free(real_filename); return NULL; } } py_file_node = PyParser_SimpleParseFile(pyfile, real_filename, Py_file_input); if (!py_file_node) { PyErr_Print(); uwsgi_log("failed to parse file %s\n", real_filename); if (is_a_package) free(real_filename); fclose(pyfile); return NULL; } fclose(pyfile); } else { int pycontent_size = 0; char *pycontent = uwsgi_open_and_read(filename, &pycontent_size, 1, NULL); if (pycontent) { py_file_node = PyParser_SimpleParseString(pycontent, Py_file_input); if (!py_file_node) { PyErr_Print(); uwsgi_log("failed to parse url %s\n", real_filename); return NULL; } } } py_compiled_node = (PyObject *) PyNode_Compile(py_file_node, real_filename); if (!py_compiled_node) { PyErr_Print(); uwsgi_log("failed to compile python file %s\n", real_filename); return NULL; } if (is_a_package) { py_file_module = PyImport_AddModule(name); if (py_file_module) { PyModule_AddObject(py_file_module, "__path__", Py_BuildValue("[O]", PyString_FromString(filename))); } free(real_filename); } py_file_module = PyImport_ExecCodeModule(name, py_compiled_node); if (!py_file_module) { PyErr_Print(); return NULL; } Py_DECREF(py_compiled_node); return py_file_module; #endif }
bool mitk::PythonService::CopyToPythonAsSimpleItkImage(mitk::Image *image, const std::string &stdvarName) { QString varName = QString::fromStdString( stdvarName ); QString command; unsigned int* imgDim = image->GetDimensions(); int npy_nd = 1; npy_intp* npy_dims = new npy_intp[1]; npy_dims[0] = imgDim[0] * imgDim[1] * imgDim[2]; // access python module PyObject *pyMod = PyImport_AddModule((char*)"__main__"); // global dictionarry PyObject *pyDict = PyModule_GetDict(pyMod); const mitk::Vector3D spacing = image->GetGeometry()->GetSpacing(); const mitk::Point3D origin = image->GetGeometry()->GetOrigin(); mitk::PixelType pixelType = image->GetPixelType(); itk::ImageIOBase::IOPixelType ioPixelType = image->GetPixelType().GetPixelType(); PyObject* npyArray = NULL; mitk::ImageReadAccessor racc(image); void* array = (void*) racc.GetData(); // default pixeltype: unsigned short NPY_TYPES npy_type = NPY_USHORT; std::string sitk_type = "sitkUInt8"; if( ioPixelType == itk::ImageIOBase::SCALAR ) { if( pixelType.GetComponentType() == itk::ImageIOBase::DOUBLE ) { npy_type = NPY_DOUBLE; sitk_type = "sitkFloat64"; } else if( pixelType.GetComponentType() == itk::ImageIOBase::FLOAT ) { npy_type = NPY_FLOAT; sitk_type = "sitkFloat32"; } else if( pixelType.GetComponentType() == itk::ImageIOBase::SHORT) { npy_type = NPY_SHORT; sitk_type = "sitkInt16"; } else if( pixelType.GetComponentType() == itk::ImageIOBase::CHAR ) { npy_type = NPY_BYTE; sitk_type = "sitkInt8"; } else if( pixelType.GetComponentType() == itk::ImageIOBase::INT ) { npy_type = NPY_INT; sitk_type = "sitkInt32"; } else if( pixelType.GetComponentType() == itk::ImageIOBase::LONG ) { npy_type = NPY_LONG; sitk_type = "sitkInt64"; } else if( pixelType.GetComponentType() == itk::ImageIOBase::UCHAR ) { npy_type = NPY_UBYTE; sitk_type = "sitkUInt8"; } else if( pixelType.GetComponentType() == itk::ImageIOBase::UINT ) { npy_type = NPY_UINT; sitk_type = "sitkUInt32"; } else if( pixelType.GetComponentType() == itk::ImageIOBase::ULONG ) { npy_type = NPY_LONG; sitk_type = "sitkUInt64"; } else if( pixelType.GetComponentType() == itk::ImageIOBase::USHORT ) { npy_type = NPY_USHORT; sitk_type = "sitkUInt16"; } } else { MITK_WARN << "not a scalar pixeltype"; return false; } // creating numpy array import_array1 (true); npyArray = PyArray_SimpleNewFromData(npy_nd,npy_dims,npy_type,array); // add temp array it to the python dictionary to access it in python code const int status = PyDict_SetItemString( pyDict,QString("%1_numpy_array") .arg(varName).toStdString().c_str(), npyArray ); // sanity check if ( status != 0 ) return false; command.append( QString("%1 = sitk.Image(%2,%3,%4,sitk.%5)\n").arg(varName) .arg(QString::number(imgDim[0])) .arg(QString::number(imgDim[1])) .arg(QString::number(imgDim[2])) .arg(QString(sitk_type.c_str())) ); command.append( QString("%1.SetSpacing([%2,%3,%4])\n").arg(varName) .arg(QString::number(spacing[0])) .arg(QString::number(spacing[1])) .arg(QString::number(spacing[2])) ); command.append( QString("%1.SetOrigin([%2,%3,%4])\n").arg(varName) .arg(QString::number(origin[0])) .arg(QString::number(origin[1])) .arg(QString::number(origin[2])) ); // directly access the cpp api from the lib command.append( QString("_SimpleITK._SetImageFromArray(%1_numpy_array,%1)\n").arg(varName) ); command.append( QString("del %1_numpy_array").arg(varName) ); MITK_DEBUG("PythonService") << "Issuing python command " << command.toStdString(); this->Execute( command.toStdString(), IPythonService::MULTI_LINE_COMMAND ); return true; }
void init_uwsgi_embedded_module() { PyObject *new_uwsgi_module, *zero; int i; PyType_Ready(&uwsgi_InputType); /* initialize for stats */ up.workers_tuple = PyTuple_New(uwsgi.numproc); for (i = 0; i < uwsgi.numproc; i++) { zero = PyDict_New(); Py_INCREF(zero); PyTuple_SetItem(up.workers_tuple, i, zero); } #ifdef PYTHREE PyImport_AppendInittab("uwsgi", init_uwsgi3); new_uwsgi_module = PyImport_AddModule("uwsgi"); #else new_uwsgi_module = Py_InitModule3("uwsgi", NULL, uwsgi_py_doc); #endif if (new_uwsgi_module == NULL) { uwsgi_log("could not initialize the uwsgi python module\n"); exit(1); } Py_INCREF((PyObject *) &uwsgi_InputType); up.embedded_dict = PyModule_GetDict(new_uwsgi_module); if (!up.embedded_dict) { uwsgi_log("could not get uwsgi module __dict__\n"); exit(1); } // just for safety Py_INCREF(up.embedded_dict); if (PyDict_SetItemString(up.embedded_dict, "version", PyString_FromString(UWSGI_VERSION))) { PyErr_Print(); exit(1); } PyObject *uwsgi_py_version_info = PyTuple_New(5); PyTuple_SetItem(uwsgi_py_version_info, 0, PyInt_FromLong(UWSGI_VERSION_BASE)); PyTuple_SetItem(uwsgi_py_version_info, 1, PyInt_FromLong(UWSGI_VERSION_MAJOR)); PyTuple_SetItem(uwsgi_py_version_info, 2, PyInt_FromLong(UWSGI_VERSION_MINOR)); PyTuple_SetItem(uwsgi_py_version_info, 3, PyInt_FromLong(UWSGI_VERSION_REVISION)); PyTuple_SetItem(uwsgi_py_version_info, 4, PyString_FromString(UWSGI_VERSION_CUSTOM)); if (PyDict_SetItemString(up.embedded_dict, "version_info", uwsgi_py_version_info)) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "hostname", PyString_FromStringAndSize(uwsgi.hostname, uwsgi.hostname_len))) { PyErr_Print(); exit(1); } if (uwsgi.mode) { if (PyDict_SetItemString(up.embedded_dict, "mode", PyString_FromString(uwsgi.mode))) { PyErr_Print(); exit(1); } } if (uwsgi.pidfile) { if (PyDict_SetItemString(up.embedded_dict, "pidfile", PyString_FromString(uwsgi.pidfile))) { PyErr_Print(); exit(1); } } #ifdef UWSGI_SPOOLER if (uwsgi.spoolers) { int sc = 0; struct uwsgi_spooler *uspool = uwsgi.spoolers; while(uspool) { sc++; uspool = uspool->next;} PyObject *py_spooler_tuple = PyTuple_New(sc); uspool = uwsgi.spoolers; sc = 0; while(uspool) { PyTuple_SetItem(py_spooler_tuple, sc, PyString_FromString(uspool->dir)); sc++; uspool = uspool->next; } if (PyDict_SetItemString(up.embedded_dict, "spoolers", py_spooler_tuple)) { PyErr_Print(); exit(1); } } #endif if (PyDict_SetItemString(up.embedded_dict, "SPOOL_RETRY", PyInt_FromLong(-1))) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "SPOOL_OK", PyInt_FromLong(-2))) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "SPOOL_IGNORE", PyInt_FromLong(0))) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "numproc", PyInt_FromLong(uwsgi.numproc))) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "has_threads", PyInt_FromLong(uwsgi.has_threads))) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "cores", PyInt_FromLong(uwsgi.cores))) { PyErr_Print(); exit(1); } if (uwsgi.loop) { if (PyDict_SetItemString(up.embedded_dict, "loop", PyString_FromString(uwsgi.loop))) { PyErr_Print(); exit(1); } } else { PyDict_SetItemString(up.embedded_dict, "loop", Py_None); } PyObject *py_opt_dict = PyDict_New(); for (i = 0; i < uwsgi.exported_opts_cnt; i++) { if (PyDict_Contains(py_opt_dict, PyString_FromString(uwsgi.exported_opts[i]->key))) { PyObject *py_opt_item = PyDict_GetItemString(py_opt_dict, uwsgi.exported_opts[i]->key); if (PyList_Check(py_opt_item)) { if (uwsgi.exported_opts[i]->value == NULL) { PyList_Append(py_opt_item, Py_True); } else { PyList_Append(py_opt_item, PyString_FromString(uwsgi.exported_opts[i]->value)); } } else { PyObject *py_opt_list = PyList_New(0); PyList_Append(py_opt_list, py_opt_item); if (uwsgi.exported_opts[i]->value == NULL) { PyList_Append(py_opt_list, Py_True); } else { PyList_Append(py_opt_list, PyString_FromString(uwsgi.exported_opts[i]->value)); } PyDict_SetItemString(py_opt_dict, uwsgi.exported_opts[i]->key, py_opt_list); } } else { if (uwsgi.exported_opts[i]->value == NULL) { PyDict_SetItemString(py_opt_dict, uwsgi.exported_opts[i]->key, Py_True); } else { PyDict_SetItemString(py_opt_dict, uwsgi.exported_opts[i]->key, PyString_FromString(uwsgi.exported_opts[i]->value)); } } } if (PyDict_SetItemString(up.embedded_dict, "opt", py_opt_dict)) { PyErr_Print(); exit(1); } PyObject *py_magic_table = PyDict_New(); uint8_t mtk; for (i = 0; i <= 0xff; i++) { // a bit of magic :P mtk = i; if (uwsgi.magic_table[i]) { if (uwsgi.magic_table[i][0] != 0) { PyDict_SetItem(py_magic_table, PyString_FromStringAndSize((char *) &mtk, 1), PyString_FromString(uwsgi.magic_table[i])); } } } if (PyDict_SetItemString(up.embedded_dict, "magic_table", py_magic_table)) { PyErr_Print(); exit(1); } #ifdef UNBIT if (PyDict_SetItemString(up.embedded_dict, "unbit", Py_True)) { #else if (PyDict_SetItemString(up.embedded_dict, "unbit", Py_None)) { #endif PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "buffer_size", PyInt_FromLong(uwsgi.buffer_size))) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "started_on", PyInt_FromLong(uwsgi.start_tv.tv_sec))) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "start_response", up.wsgi_spitout)) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "applications", Py_None)) { PyErr_Print(); exit(1); } if (uwsgi.is_a_reload) { if (PyDict_SetItemString(up.embedded_dict, "is_a_reload", Py_True)) { PyErr_Print(); exit(1); } } else { if (PyDict_SetItemString(up.embedded_dict, "is_a_reload", Py_False)) { PyErr_Print(); exit(1); } } up.embedded_args = PyTuple_New(2); if (!up.embedded_args) { PyErr_Print(); exit(1); } if (PyDict_SetItemString(up.embedded_dict, "message_manager_marshal", Py_None)) { PyErr_Print(); exit(1); } init_uwsgi_module_advanced(new_uwsgi_module); #ifdef UWSGI_SPOOLER if (uwsgi.spoolers) { init_uwsgi_module_spooler(new_uwsgi_module); } #endif if (uwsgi.sharedareasize > 0 && uwsgi.sharedarea) { init_uwsgi_module_sharedarea(new_uwsgi_module); } if (uwsgi.cache_max_items > 0) { init_uwsgi_module_cache(new_uwsgi_module); } if (uwsgi.queue_size > 0) { init_uwsgi_module_queue(new_uwsgi_module); } #ifdef UWSGI_SNMP if (uwsgi.snmp) { init_uwsgi_module_snmp(new_uwsgi_module); } #endif if (up.extension) { up.extension(); } } #endif int uwsgi_python_magic(char *mountpoint, char *lazy) { char *qc = strchr(lazy, ':'); if (qc) { qc[0] = 0; up.callable = qc + 1; } if (!strcmp(lazy + strlen(lazy) - 3, ".py")) { up.file_config = lazy; return 1; } else if (!strcmp(lazy + strlen(lazy) - 5, ".wsgi")) { up.file_config = lazy; return 1; } else if (qc && strchr(lazy, '.')) { up.wsgi_config = lazy; return 1; } // reset lazy if (qc) { qc[0] = ':'; } return 0; }
static int Python_Init(void) { if (!initialised) { #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000 PyObject *site; #endif #ifdef DYNAMIC_PYTHON if (!python_enabled(TRUE)) { EMSG(_("E263: Sorry, this command is disabled, the Python library could not be loaded.")); goto fail; } #endif #ifdef PYTHON_HOME # ifdef DYNAMIC_PYTHON if (mch_getenv((char_u *)"PYTHONHOME") == NULL) # endif Py_SetPythonHome(PYTHON_HOME); #endif init_structs(); #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000 /* Disable implicit 'import site', because it may cause Vim to exit * when it can't be found. */ Py_NoSiteFlag++; #endif #if !defined(MACOS) || defined(MACOS_X_UNIX) Py_Initialize(); #else PyMac_Initialize(); #endif #if defined(PY_VERSION_HEX) && PY_VERSION_HEX >= 0x02070000 /* 'import site' explicitly. */ site = PyImport_ImportModule("site"); if (site == NULL) { EMSG(_("E887: Sorry, this command is disabled, the Python's site module could not be loaded.")); goto fail; } Py_DECREF(site); #endif /* Initialise threads, and below save the state using * PyEval_SaveThread. Without the call to PyEval_SaveThread, thread * specific state (such as the system trace hook), will be lost * between invocations of Python code. */ PyEval_InitThreads(); #ifdef DYNAMIC_PYTHON get_exceptions(); #endif if (PythonIO_Init_io()) goto fail; if (PythonMod_Init()) goto fail; globals = PyModule_GetDict(PyImport_AddModule("__main__")); /* Remove the element from sys.path that was added because of our * argv[0] value in PythonMod_Init(). Previously we used an empty * string, but depending on the OS we then get an empty entry or * the current directory in sys.path. */ PyRun_SimpleString("import sys; sys.path = filter(lambda x: x != '/must>not&exist', sys.path)"); /* lock is created and acquired in PyEval_InitThreads() and thread * state is created in Py_Initialize() * there _PyGILState_NoteThreadState() also sets gilcounter to 1 * (python must have threads enabled!) * so the following does both: unlock GIL and save thread state in TLS * without deleting thread state */ #ifndef PY_CAN_RECURSE saved_python_thread = #endif PyEval_SaveThread(); initialised = 1; } return 0; fail: /* We call PythonIO_Flush() here to print any Python errors. * This is OK, as it is possible to call this function even * if PythonIO_Init_io() has not completed successfully (it will * not do anything in this case). */ PythonIO_Flush(); return -1; }
/* "zmq/utils/initthreads.pyx":21 * # If we don't have this, pyzmq will segfault. * def init_threads(): * PyEval_InitThreads() # <<<<<<<<<<<<<< * * __all__ = ['init_threads'] */ PyEval_InitThreads(); __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, __Pyx_NAMESTR("initthreads"), __Pyx_DOCSTR(__pyx_k_1), /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_n_s_2, __pyx_k_2, sizeof(__pyx_k_2), 0, 0, 1, 1}, {&__pyx_n_s____all__, __pyx_k____all__, sizeof(__pyx_k____all__), 0, 0, 1, 1}, {&__pyx_n_s____main__, __pyx_k____main__, sizeof(__pyx_k____main__), 0, 0, 1, 1}, {&__pyx_n_s____test__, __pyx_k____test__, sizeof(__pyx_k____test__), 0, 0, 1, 1}, {&__pyx_n_s__init_threads, __pyx_k__init_threads, sizeof(__pyx_k__init_threads), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { return 0; } static int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants"); __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC initinitthreads(void); /*proto*/ PyMODINIT_FUNC initinitthreads(void) #else PyMODINIT_FUNC PyInit_initthreads(void); /*proto*/ PyMODINIT_FUNC PyInit_initthreads(void) #endif { PyObject *__pyx_t_1 = NULL; __Pyx_RefNannyDeclarations #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_initthreads(void)"); if ( __Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #ifdef __pyx_binding_PyCFunctionType_USED if (__pyx_binding_PyCFunctionType_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4(__Pyx_NAMESTR("initthreads"), __pyx_methods, __Pyx_DOCSTR(__pyx_k_1), 0, PYTHON_API_VERSION); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (!__pyx_m) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; #if PY_MAJOR_VERSION < 3 Py_INCREF(__pyx_m); #endif __pyx_b = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME)); if (!__pyx_b) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; if (__Pyx_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_module_is_main_zmq__utils__initthreads) { if (__Pyx_SetAttrString(__pyx_m, "__name__", __pyx_n_s____main__) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; } /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Constants init code ---*/ if (unlikely(__Pyx_InitCachedConstants() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ /*--- Variable export code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ /*--- Type import code ---*/ /*--- Variable import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "zmq/utils/initthreads.pyx":20 * # by hand to get threads initialized. Not clear why this is the case though. * # If we don't have this, pyzmq will segfault. * def init_threads(): # <<<<<<<<<<<<<< * PyEval_InitThreads() * */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_3zmq_5utils_11initthreads_init_threads, NULL, __pyx_n_s_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 20; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(__pyx_t_1); if (PyObject_SetAttr(__pyx_m, __pyx_n_s__init_threads, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 20; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "zmq/utils/initthreads.pyx":23 * PyEval_InitThreads() * * __all__ = ['init_threads'] # <<<<<<<<<<<<<< */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 23; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __Pyx_INCREF(((PyObject *)__pyx_n_s__init_threads)); PyList_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_n_s__init_threads)); __Pyx_GIVEREF(((PyObject *)__pyx_n_s__init_threads)); if (PyObject_SetAttr(__pyx_m, __pyx_n_s____all__, ((PyObject *)__pyx_t_1)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 23; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0; /* "zmq/utils/initthreads.pyx":1 * """Utility to initialize threads.""" # <<<<<<<<<<<<<< * * #----------------------------------------------------------------------------- */ __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(((PyObject *)__pyx_t_1)); if (PyObject_SetAttr(__pyx_m, __pyx_n_s____test__, ((PyObject *)__pyx_t_1)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); if (__pyx_m) { __Pyx_AddTraceback("init zmq.utils.initthreads", __pyx_clineno, __pyx_lineno, __pyx_filename); Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init zmq.utils.initthreads"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif }
/* Load and return the module named by 'fullname'. */ static PyObject * zipimporter_load_module(PyObject *obj, PyObject *args) { ZipImporter *self = (ZipImporter *)obj; PyObject *code, *mod, *dict; char *fullname, *modpath; int ispackage; if (!PyArg_ParseTuple(args, "s:zipimporter.load_module", &fullname)) return NULL; code = get_module_code(self, fullname, &ispackage, &modpath); if (code == NULL) return NULL; mod = PyImport_AddModule(fullname); if (mod == NULL) { Py_DECREF(code); return NULL; } dict = PyModule_GetDict(mod); /* mod.__loader__ = self */ if (PyDict_SetItemString(dict, "__loader__", (PyObject *)self) != 0) goto error; if (ispackage) { /* add __path__ to the module *before* the code gets executed */ PyObject *pkgpath, *fullpath; char *prefix = PyString_AsString(self->prefix); char *subname = get_subname(fullname); int err; fullpath = PyString_FromFormat("%s%c%s%s", PyString_AsString(self->archive), SEP, *prefix ? prefix : "", subname); if (fullpath == NULL) goto error; pkgpath = Py_BuildValue("[O]", fullpath); Py_DECREF(fullpath); if (pkgpath == NULL) goto error; err = PyDict_SetItemString(dict, "__path__", pkgpath); Py_DECREF(pkgpath); if (err != 0) goto error; } mod = PyImport_ExecCodeModuleEx(fullname, code, modpath); Py_DECREF(code); if (Py_VerboseFlag) PySys_WriteStderr("import %s # loaded from Zip %s\n", fullname, modpath); return mod; error: Py_DECREF(code); Py_DECREF(mod); return NULL; }
int csl_execute(char *code, size_t size, const char *func_name, struct pack *pak, char **resptr, int *reslen) { PyObject *pCode, *pModule, *pDict, *pFunc, *pValue, *pStr; PyObject *pArgs, *pkArgs; PyMethodDef *meth; node *n; int arg_count; PyObject *argNames; pModule = PyImport_AddModule("__builtin__"); pDict = PyModule_GetDict(pModule); for (meth = methods; meth->ml_name; meth++) { pCode = PyCFunction_New(meth, NULL); PyDict_SetItemString(pDict, meth->ml_name, pCode); } if (size == 0) { n = PyParser_SimpleParseString(code, Py_file_input); if (!n) { log_exception(); return CSL_BADCODE; } pCode = (PyObject *) PyNode_Compile(n, "lala"); PyNode_Free(n); if (!pCode) { log_exception(); return CSL_BADCODE; } } else { pCode = PyMarshal_ReadObjectFromString(code, size); if (!pCode) { log_exception(); return CSL_BADCODE; } } pModule = PyImport_ExecCodeModule("csl", pCode); Py_DECREF(pCode); if (!pModule || !PyModule_Check(pModule)) { return CSL_BADCODE; } pDict = PyModule_GetDict(pModule); if (!pDict) { Py_DECREF(pModule); return CSL_BADCODE; } pFunc = PyDict_GetItemString(pDict, func_name); if (!pFunc || !PyCallable_Check(pFunc)) { Py_DECREF(pModule); return CSL_NOFUNC; } { PyObject *tempCode, *temp; tempCode = PyObject_GetAttrString(pFunc, "func_code"); temp = PyObject_GetAttrString(tempCode, "co_argcount"); arg_count = PyInt_AsLong(temp); argNames = PyObject_GetAttrString(tempCode, "co_varnames"); } pArgs = NULL; pkArgs = PyDict_New(); while (arg_count && pak) { PyObject *p; char *t, *t2; size_t sz; if (pack_get(pak, &t, &sz) == 0) break; if (pack_get(pak, &t2, &sz) == 0) { pArgs = PyTuple_New(1); PyTuple_SetItem(pArgs, 0, PyString_FromString(t)); Py_DECREF(pkArgs); break; } p = PyString_FromString(t); if (PySequence_Contains(argNames, p) == 1) { p = PyString_FromStringAndSize(t2, sz); PyDict_SetItemString(pkArgs, t, p); } } if (!pArgs) pArgs = PyTuple_New(0); pValue = PyObject_Call(pFunc, pArgs, pkArgs); if (!pValue) { log_exception(); Py_DECREF(pModule); return CSL_FUNCERR; } pStr = PyObject_Str(pValue); Py_DECREF(pValue); Py_DECREF(pModule); // is return value asked? if (resptr == NULL) return 0; *reslen = PyString_Size(pStr); *resptr = malloc((*reslen) + 1); if (!*resptr) { Py_DECREF(pStr); return CSL_NOMEM; } memcpy(*resptr, PyString_AsString(pStr), *reslen); (*resptr)[*reslen] = '\0'; return 0; }
void wrapper_434f2e3471bb55ffb2ed175a1ab61e17() { std::string name_7bbff48d109853e88270b3595c663a99 = boost::python::extract< std::string >(boost::python::scope().attr("__name__") + ".clang"); boost::python::object module_7bbff48d109853e88270b3595c663a99(boost::python::handle< >(boost::python::borrowed(PyImport_AddModule(name_7bbff48d109853e88270b3595c663a99.c_str())))); boost::python::scope().attr("clang") = module_7bbff48d109853e88270b3595c663a99; boost::python::scope scope_7bbff48d109853e88270b3595c663a99 = module_7bbff48d109853e88270b3595c663a99; bool (*method_pointer_5d576199986b55b081c058881f24ff9a)(class ::clang::Type const *) = ::clang::EnumType::classof; class ::clang::QualType (::clang::EnumType::*method_pointer_65856217fa025db9b502338cc8f0ef07)() const = &::clang::EnumType::desugar; class ::clang::EnumDecl * (::clang::EnumType::*method_pointer_d79e44c9fda352689b2eace9392ec780)() const = &::clang::EnumType::getDecl; bool (::clang::EnumType::*method_pointer_abcee1187b6e5523b6e7fe0f06c02cfe)() const = &::clang::EnumType::isSugared; boost::python::class_< class ::clang::EnumType, autowig::HeldType< class ::clang::EnumType >, boost::python::bases< class ::clang::TagType >, boost::noncopyable > class_434f2e3471bb55ffb2ed175a1ab61e17("EnumType", "", boost::python::no_init); class_434f2e3471bb55ffb2ed175a1ab61e17.def("classof", method_pointer_5d576199986b55b081c058881f24ff9a, ""); class_434f2e3471bb55ffb2ed175a1ab61e17.def("desugar", method_pointer_65856217fa025db9b502338cc8f0ef07, ""); class_434f2e3471bb55ffb2ed175a1ab61e17.def("get_decl", method_pointer_d79e44c9fda352689b2eace9392ec780, boost::python::return_value_policy< boost::python::reference_existing_object >(), ""); class_434f2e3471bb55ffb2ed175a1ab61e17.def("is_sugared", method_pointer_abcee1187b6e5523b6e7fe0f06c02cfe, ""); class_434f2e3471bb55ffb2ed175a1ab61e17.staticmethod("classof"); if(std::is_class< autowig::HeldType< class ::clang::EnumType > >::value) { boost::python::implicitly_convertible< autowig::HeldType< class ::clang::EnumType >, autowig::HeldType< class ::clang::TagType > >(); } }
void wrapper_e763e0d8384558ef98fffcc5e4c39e65() { std::string name_7bbff48d109853e88270b3595c663a99 = boost::python::extract< std::string >(boost::python::scope().attr("__name__") + ".clang"); boost::python::object module_7bbff48d109853e88270b3595c663a99(boost::python::handle< >(boost::python::borrowed(PyImport_AddModule(name_7bbff48d109853e88270b3595c663a99.c_str())))); boost::python::scope().attr("clang") = module_7bbff48d109853e88270b3595c663a99; boost::python::scope scope_7bbff48d109853e88270b3595c663a99 = module_7bbff48d109853e88270b3595c663a99; class ::clang::ImportDecl * (*method_pointer_8856b72b572b5ad2ab9f74a82e460af6)(class ::clang::ASTContext &, unsigned int , unsigned int ) = ::clang::ImportDecl::CreateDeserialized; bool (*method_pointer_7f563d7f517358d8b8fb0c386e57cfb2)(class ::clang::Decl const *) = ::clang::ImportDecl::classof; bool (*method_pointer_a9a32192380151c2a5b448a8faa409f5)(enum ::clang::Decl::Kind ) = ::clang::ImportDecl::classofKind; boost::python::class_< class ::clang::ImportDecl, autowig::HeldType< class ::clang::ImportDecl >, boost::python::bases< class ::clang::Decl >, boost::noncopyable > class_e763e0d8384558ef98fffcc5e4c39e65("ImportDecl", "", boost::python::no_init); class_e763e0d8384558ef98fffcc5e4c39e65.def("create_deserialized", method_pointer_8856b72b572b5ad2ab9f74a82e460af6, boost::python::return_value_policy< boost::python::reference_existing_object >(), ""); class_e763e0d8384558ef98fffcc5e4c39e65.def("classof", method_pointer_7f563d7f517358d8b8fb0c386e57cfb2, ""); class_e763e0d8384558ef98fffcc5e4c39e65.def("classof_kind", method_pointer_a9a32192380151c2a5b448a8faa409f5, ""); class_e763e0d8384558ef98fffcc5e4c39e65.staticmethod("classof_kind"); class_e763e0d8384558ef98fffcc5e4c39e65.staticmethod("create_deserialized"); class_e763e0d8384558ef98fffcc5e4c39e65.staticmethod("classof"); if(std::is_class< autowig::HeldType< class ::clang::ImportDecl > >::value) { boost::python::implicitly_convertible< autowig::HeldType< class ::clang::ImportDecl >, autowig::HeldType< class ::clang::Decl > >(); } }
void wrapper_9e52028d1c305f31bd87257e6d3ccc53() { std::string name_7bbff48d109853e88270b3595c663a99 = boost::python::extract< std::string >(boost::python::scope().attr("__name__") + ".clang"); boost::python::object module_7bbff48d109853e88270b3595c663a99(boost::python::handle< >(boost::python::borrowed(PyImport_AddModule(name_7bbff48d109853e88270b3595c663a99.c_str())))); boost::python::scope().attr("clang") = module_7bbff48d109853e88270b3595c663a99; boost::python::scope scope_7bbff48d109853e88270b3595c663a99 = module_7bbff48d109853e88270b3595c663a99; void (::clang::SourceManager::*method_pointer_e253bcd881cb5795ba6b2c3a11fd6e76)(class ::clang::SourceLocation , unsigned int , int ) = &::clang::SourceManager::AddLineNote; void (::clang::SourceManager::*method_pointer_f1cc4088b9c25c80a06ba87923cc4866)(class ::clang::SourceLocation , unsigned int , int , bool , bool , bool , bool ) = &::clang::SourceManager::AddLineNote; void (::clang::SourceManager::*method_pointer_6487f3f2e58e5f799238920d04fb411d)() const = &::clang::SourceManager::PrintStats; void (::clang::SourceManager::*method_pointer_f52a1e2320575bc29db5b9373f73ca5a)() = &::clang::SourceManager::clearIDTables; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_a4bc4c9bd7f75ee69f9971e003ae73b9)(class ::clang::SourceLocation , class ::clang::SourceLocation , class ::clang::SourceLocation , unsigned int , int , unsigned int ) = &::clang::SourceManager::createExpansionLoc; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_41f8fa04198b5f90a2fb89621a7ed56e)(class ::clang::SourceLocation , class ::clang::SourceLocation , unsigned int ) = &::clang::SourceManager::createMacroArgExpansionLoc; void (::clang::SourceManager::*method_pointer_90329136ed6d56c0a2df8b42e24c6d1a)() const = &::clang::SourceManager::dump; unsigned long int (::clang::SourceManager::*method_pointer_b3c1ce3e64cf599dac9e6d953e9fc8d1)() const = &::clang::SourceManager::getContentCacheSize; unsigned long int (::clang::SourceManager::*method_pointer_29af9405f1c154f9b9ecd7e61a15ddfb)() const = &::clang::SourceManager::getDataStructureSizes; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_bb365fb9f3eb580aaa1c914252810d0e)(class ::clang::SourceLocation ) const = &::clang::SourceManager::getExpansionLoc; class ::clang::FileID (::clang::SourceManager::*method_pointer_dbb4f9f83ad55272adeedb74edf17210)(class ::clang::SourceLocation ) const = &::clang::SourceManager::getFileID; unsigned int (::clang::SourceManager::*method_pointer_0d6c5c4769f451618cdcfe8e929227e9)(class ::clang::FileID ) const = &::clang::SourceManager::getFileIDSize; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_4040e9abb67d5163b503c2dc456ad462)(class ::clang::SourceLocation ) const = &::clang::SourceManager::getFileLoc; unsigned int (::clang::SourceManager::*method_pointer_1269fd03101654f59cb5ecc699bebf5a)(class ::clang::SourceLocation ) const = &::clang::SourceManager::getFileOffset; class ::llvm::StringRef (::clang::SourceManager::*method_pointer_a3f84c2ab6a556f998dd7c78647afb23)(class ::clang::SourceLocation ) const = &::clang::SourceManager::getFilename; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_101519ccdc3b556595a844cf5a489201)(class ::clang::SourceLocation ) const = &::clang::SourceManager::getImmediateMacroCallerLoc; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_f1cf1a7a4e12557e83e3ef06d162e1df)(class ::clang::SourceLocation ) const = &::clang::SourceManager::getImmediateSpellingLoc; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_bac9124d08315a21acbd6b35a72c893d)(class ::clang::FileID ) const = &::clang::SourceManager::getIncludeLoc; unsigned int (::clang::SourceManager::*method_pointer_ca7a77f251435747bdd13332527bdd95)(class ::llvm::StringRef ) = &::clang::SourceManager::getLineTableFilenameID; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_c89ab88a33f45c299e7ac8e7f3ba470f)(class ::clang::FileID ) const = &::clang::SourceManager::getLocForEndOfFile; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_caaeb8aa45075dcaa4c572e8bf805ad4)(class ::clang::FileID ) const = &::clang::SourceManager::getLocForStartOfFile; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_ce762ffaceb25e6c8ee01f965db5ca9d)(class ::clang::SourceLocation ) const = &::clang::SourceManager::getMacroArgExpandedLocation; class ::clang::FileID (::clang::SourceManager::*method_pointer_95ef03f146395e49bca16d532ff72535)() const = &::clang::SourceManager::getMainFileID; unsigned int (::clang::SourceManager::*method_pointer_90e4e48dd58257c790ba1451fce51c21)() const = &::clang::SourceManager::getNextLocalOffset; unsigned int (::clang::SourceManager::*method_pointer_fd1c1f57a8d756258c6862029f2f80d7)(class ::clang::FileID ) const = &::clang::SourceManager::getNumCreatedFIDsForFileID; class ::clang::FileID (::clang::SourceManager::*method_pointer_79b6650bfc385d8abf3fc00ec395bd24)() const = &::clang::SourceManager::getPreambleFileID; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_6d27e9e4de665becadef954fd026a660)(class ::clang::SourceLocation ) const = &::clang::SourceManager::getSpellingLoc; bool (::clang::SourceManager::*method_pointer_80063b28eee8545893a3d13929c2fe78)() const = &::clang::SourceManager::hasLineTable; bool (::clang::SourceManager::*method_pointer_3aa8b33033d857108eabe087de8ef976)(class ::clang::SourceLocation , class ::clang::SourceLocation *) const = &::clang::SourceManager::isAtEndOfImmediateMacroExpansion; bool (::clang::SourceManager::*method_pointer_596cf4eff4cf529a941f8960f184fb6e)(class ::clang::SourceLocation , class ::clang::SourceLocation *) const = &::clang::SourceManager::isAtStartOfImmediateMacroExpansion; bool (::clang::SourceManager::*method_pointer_f6b2c00d85db57acb92c47eb23b75dbd)(class ::clang::SourceLocation , class ::clang::SourceLocation ) const = &::clang::SourceManager::isBeforeInSLocAddrSpace; bool (::clang::SourceManager::*method_pointer_5d3f386f62f45af883cba728207609bf)(class ::clang::SourceLocation , unsigned int ) const = &::clang::SourceManager::isBeforeInSLocAddrSpace; bool (::clang::SourceManager::*method_pointer_9d2ff1a6b00e57aca9f14372e0fa244b)(class ::clang::SourceLocation , class ::clang::SourceLocation ) const = &::clang::SourceManager::isBeforeInTranslationUnit; bool (::clang::SourceManager::*method_pointer_b1fd10e9363b5642ac33cbe89f25f8e3)(class ::clang::SourceLocation ) const = &::clang::SourceManager::isInExternCSystemHeader; bool (::clang::SourceManager::*method_pointer_880a26fb1f3953f99283ca77f55d3c97)(class ::clang::SourceLocation ) const = &::clang::SourceManager::isInMainFile; bool (::clang::SourceManager::*method_pointer_457a725e02955d4c8f9ba4cca569c58a)(class ::clang::SourceLocation ) const = &::clang::SourceManager::isInSystemHeader; bool (::clang::SourceManager::*method_pointer_0f20c5ed07785c0c998a69cae245886d)(class ::clang::SourceLocation ) = &::clang::SourceManager::isInSystemMacro; bool (::clang::SourceManager::*method_pointer_38b133f29e0a514699d53ca269850594)(class ::clang::FileID ) const = &::clang::SourceManager::isLoadedFileID; bool (::clang::SourceManager::*method_pointer_180f85141ded56589af79b35ce1829ae)(class ::clang::SourceLocation ) const = &::clang::SourceManager::isLoadedSourceLocation; bool (::clang::SourceManager::*method_pointer_ce164472197150549f8e67667568928d)(class ::clang::FileID ) const = &::clang::SourceManager::isLocalFileID; bool (::clang::SourceManager::*method_pointer_d1333484ab3e5639bcaeaf9571ad840a)(class ::clang::SourceLocation ) const = &::clang::SourceManager::isLocalSourceLocation; bool (::clang::SourceManager::*method_pointer_f02621f3848b51cf99df32e6b9181a86)(class ::clang::SourceLocation , class ::clang::SourceLocation *) const = &::clang::SourceManager::isMacroArgExpansion; bool (::clang::SourceManager::*method_pointer_af094ac23446548ebae5dc844d449ff7)(class ::clang::SourceLocation ) const = &::clang::SourceManager::isMacroBodyExpansion; bool (::clang::SourceManager::*method_pointer_86a6a44013e15f77a8ecf3e19aad3b7e)(class ::clang::SourceLocation ) const = &::clang::SourceManager::isWrittenInMainFile; bool (::clang::SourceManager::*method_pointer_8b2f18864d62527b9e514ea35490a281)(class ::clang::SourceLocation , class ::clang::SourceLocation ) const = &::clang::SourceManager::isWrittenInSameFile; unsigned int (::clang::SourceManager::*method_pointer_977c27d1e2f85b4097789973ea2b313c)() const = &::clang::SourceManager::loaded_sloc_entry_size; unsigned int (::clang::SourceManager::*method_pointer_dc96db91538758fe8371a1e0a18721ea)() const = &::clang::SourceManager::local_sloc_entry_size; void (::clang::SourceManager::*method_pointer_462ae1ae54055596a7eb3924d39998bb)(bool ) = &::clang::SourceManager::setAllFilesAreTransient; void (::clang::SourceManager::*method_pointer_b4e764ebba55507d93ea4c19b7b33e83)(class ::clang::FileID ) = &::clang::SourceManager::setMainFileID; void (::clang::SourceManager::*method_pointer_2f4aa114b60951698429a683806dfaa6)(class ::clang::FileID , unsigned int ) const = &::clang::SourceManager::setNumCreatedFIDsForFileID; void (::clang::SourceManager::*method_pointer_afea19c8ae8250d1a626f77f8612b9fb)(bool ) = &::clang::SourceManager::setOverridenFilesKeepOriginalName; void (::clang::SourceManager::*method_pointer_5f482aebf78d5c4598fe4f2559fce43a)(class ::clang::FileID ) = &::clang::SourceManager::setPreambleFileID; class ::clang::SourceLocation (::clang::SourceManager::*method_pointer_bc74e81ddb5253e388333f84c60f2859)(class ::clang::FileID , unsigned int , unsigned int ) const = &::clang::SourceManager::translateLineCol; bool (::clang::SourceManager::*method_pointer_b568db2bdce75e1885bf2382348fda68)() const = &::clang::SourceManager::userFilesAreVolatile; boost::python::class_< class ::clang::SourceManager, autowig::HeldType< class ::clang::SourceManager >, boost::noncopyable > class_9e52028d1c305f31bd87257e6d3ccc53("SourceManager", "", boost::python::no_init); class_9e52028d1c305f31bd87257e6d3ccc53.def("add_line_note", method_pointer_e253bcd881cb5795ba6b2c3a11fd6e76, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("add_line_note", method_pointer_f1cc4088b9c25c80a06ba87923cc4866, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("print_stats", method_pointer_6487f3f2e58e5f799238920d04fb411d, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("clear_id_tables", method_pointer_f52a1e2320575bc29db5b9373f73ca5a, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("create_expansion_loc", method_pointer_a4bc4c9bd7f75ee69f9971e003ae73b9, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("create_macro_arg_expansion_loc", method_pointer_41f8fa04198b5f90a2fb89621a7ed56e, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("dump", method_pointer_90329136ed6d56c0a2df8b42e24c6d1a, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_content_cache_size", method_pointer_b3c1ce3e64cf599dac9e6d953e9fc8d1, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_data_structure_sizes", method_pointer_29af9405f1c154f9b9ecd7e61a15ddfb, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_expansion_loc", method_pointer_bb365fb9f3eb580aaa1c914252810d0e, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_file_id", method_pointer_dbb4f9f83ad55272adeedb74edf17210, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_file_id_size", method_pointer_0d6c5c4769f451618cdcfe8e929227e9, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_file_loc", method_pointer_4040e9abb67d5163b503c2dc456ad462, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_file_offset", method_pointer_1269fd03101654f59cb5ecc699bebf5a, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_filename", method_pointer_a3f84c2ab6a556f998dd7c78647afb23, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_immediate_macro_caller_loc", method_pointer_101519ccdc3b556595a844cf5a489201, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_immediate_spelling_loc", method_pointer_f1cf1a7a4e12557e83e3ef06d162e1df, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_include_loc", method_pointer_bac9124d08315a21acbd6b35a72c893d, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_line_table_filename_id", method_pointer_ca7a77f251435747bdd13332527bdd95, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_loc_for_end_of_file", method_pointer_c89ab88a33f45c299e7ac8e7f3ba470f, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_loc_for_start_of_file", method_pointer_caaeb8aa45075dcaa4c572e8bf805ad4, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_macro_arg_expanded_location", method_pointer_ce762ffaceb25e6c8ee01f965db5ca9d, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_main_file_id", method_pointer_95ef03f146395e49bca16d532ff72535, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_next_local_offset", method_pointer_90e4e48dd58257c790ba1451fce51c21, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_num_created_fi_ds_for_file_id", method_pointer_fd1c1f57a8d756258c6862029f2f80d7, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_preamble_file_id", method_pointer_79b6650bfc385d8abf3fc00ec395bd24, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("get_spelling_loc", method_pointer_6d27e9e4de665becadef954fd026a660, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("has_line_table", method_pointer_80063b28eee8545893a3d13929c2fe78, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_at_end_of_immediate_macro_expansion", method_pointer_3aa8b33033d857108eabe087de8ef976, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_at_start_of_immediate_macro_expansion", method_pointer_596cf4eff4cf529a941f8960f184fb6e, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_before_in_s_loc_addr_space", method_pointer_f6b2c00d85db57acb92c47eb23b75dbd, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_before_in_s_loc_addr_space", method_pointer_5d3f386f62f45af883cba728207609bf, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_before_in_translation_unit", method_pointer_9d2ff1a6b00e57aca9f14372e0fa244b, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_in_extern_c_system_header", method_pointer_b1fd10e9363b5642ac33cbe89f25f8e3, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_in_main_file", method_pointer_880a26fb1f3953f99283ca77f55d3c97, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_in_system_header", method_pointer_457a725e02955d4c8f9ba4cca569c58a, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_in_system_macro", method_pointer_0f20c5ed07785c0c998a69cae245886d, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_loaded_file_id", method_pointer_38b133f29e0a514699d53ca269850594, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_loaded_source_location", method_pointer_180f85141ded56589af79b35ce1829ae, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_local_file_id", method_pointer_ce164472197150549f8e67667568928d, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_local_source_location", method_pointer_d1333484ab3e5639bcaeaf9571ad840a, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_macro_arg_expansion", method_pointer_f02621f3848b51cf99df32e6b9181a86, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_macro_body_expansion", method_pointer_af094ac23446548ebae5dc844d449ff7, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_written_in_main_file", method_pointer_86a6a44013e15f77a8ecf3e19aad3b7e, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("is_written_in_same_file", method_pointer_8b2f18864d62527b9e514ea35490a281, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("loaded_sloc_entry_size", method_pointer_977c27d1e2f85b4097789973ea2b313c, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("local_sloc_entry_size", method_pointer_dc96db91538758fe8371a1e0a18721ea, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("set_all_files_are_transient", method_pointer_462ae1ae54055596a7eb3924d39998bb, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("set_main_file_id", method_pointer_b4e764ebba55507d93ea4c19b7b33e83, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("set_num_created_fi_ds_for_file_id", method_pointer_2f4aa114b60951698429a683806dfaa6, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("set_overriden_files_keep_original_name", method_pointer_afea19c8ae8250d1a626f77f8612b9fb, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("set_preamble_file_id", method_pointer_5f482aebf78d5c4598fe4f2559fce43a, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("translate_line_col", method_pointer_bc74e81ddb5253e388333f84c60f2859, ""); class_9e52028d1c305f31bd87257e6d3ccc53.def("user_files_are_volatile", method_pointer_b568db2bdce75e1885bf2382348fda68, ""); }
static void* pythonThreadFunc(void* ctx) { #ifdef WIN32 std::string ctxPath((const char*)ctx); std::string soPath1 = ctxPath + PATHDELIM + "python2.6"; std::string soPath2 = soPath1 + PATHDELIM + "lib-tk"; std::string soPath3 = soPath1 + PATHDELIM + "plat-win"; std::string soPath4 = soPath1 + PATHDELIM + "site-packages"; AppendPythonPath_BeforeInit(ctxPath); AppendPythonPath_BeforeInit(soPath1); AppendPythonPath_BeforeInit(soPath2); AppendPythonPath_BeforeInit(soPath3); AppendPythonPath_BeforeInit(soPath4); #else // WIN32 std::string ctxPath((const char*)ctx); std::string soPath1 = ctxPath + PATHDELIM + "python2.6"; std::string soPath2 = soPath1 + PATHDELIM + "lib-old"; std::string soPath3 = soPath1 + PATHDELIM + "lib-tk"; std::string soPath4 = soPath1 + PATHDELIM + "plat-darwin"; std::string soPath5 = soPath1 + PATHDELIM + "plat-mac"; std::string soPath6 = soPath1 + PATHDELIM + "plat-mac" + "lib-scriptpackages"; std::string soPath7 = soPath1 + PATHDELIM + "site-packages"; AppendPythonPath_BeforeInit(ctxPath); AppendPythonPath_BeforeInit(soPath1); AppendPythonPath_BeforeInit(soPath2); AppendPythonPath_BeforeInit(soPath3); AppendPythonPath_BeforeInit(soPath4); AppendPythonPath_BeforeInit(soPath5); AppendPythonPath_BeforeInit(soPath6); AppendPythonPath_BeforeInit(soPath7); #endif // WIN32 s_argv = (char**)calloc(2, sizeof(char*)); s_argv[0] = "BrowserPlus Embedded Python"; s_argv[1] = NULL; // Still unclear wether this is all right. Probably performed in // a thread spawned at allocation time. Py_SetProgramName(s_argv[0]); Py_Initialize(); PySys_SetArgv(s_argc, s_argv); bp_load_builtins(); #ifdef WIN32 AppendPythonPath_AfterInit(ctxPath); AppendPythonPath_AfterInit(soPath1); AppendPythonPath_AfterInit(soPath2); AppendPythonPath_AfterInit(soPath3); AppendPythonPath_AfterInit(soPath4); #else // WIN32 AppendPythonPath_AfterInit(ctxPath); AppendPythonPath_AfterInit(soPath1); AppendPythonPath_AfterInit(soPath2); AppendPythonPath_AfterInit(soPath3); AppendPythonPath_AfterInit(soPath4); AppendPythonPath_AfterInit(soPath5); AppendPythonPath_AfterInit(soPath6); AppendPythonPath_AfterInit(soPath7); #endif // WIN32 PyObject* bpModule = PyImport_ImportModule("browserplus_internal"); // Let's release the spawning thread. s_pythonLock.lock(); s_running = true; s_pythonCond.signal(); s_pythonLock.unlock(); // Allocate a stack based container for managing anonymous object lifetime. python::GCArray gcArray; // Now we'll block and wait for work. while (s_running) { // Pop an item off the queue and process it, // outside of the global data structure lock. python::Work* work = NULL; { s_pythonLock.lock(); if (s_workQueue.size() > 0) { work = *(s_workQueue.begin()); s_workQueue.erase(s_workQueue.begin()); } s_pythonLock.unlock(); } if (work != NULL) { if (work->m_type == python::Work::T_LoadService) { // First lets update require path. std::string serviceDir = file::dirname(work->sarg); AppendPythonPath_AfterInit(serviceDir); // Read python source file. std::string source = file::basefilename(work->sarg); PyObject* result = PyImport_ImportModule(source.c_str()); if (result == NULL && result == Py_None) { work->m_error = true; PyObject *resultString = PyObject_Str(result); Py_XDECREF(resultString); work->m_verboseError = PyString_AsString(resultString); } else { // Now it's time to pull out the global symbol // BrowserPlusEntryPointClass // and call its to_service_description method // and we'll get a python data structure we can // traverse to discover the python interface work->m_desc = python::extractDefinition(work->m_verboseError); if (work->m_desc == NULL) { work->m_error = true; } } Py_XDECREF(result); } else if (work->m_type == python::Work::T_AllocateInstance) { PyObject *m = PyImport_AddModule("browserplus"); PyObject *klass = PyObject_GetAttrString(m, python::BP_GLOBAL_DEF_SYM); // NEEDSWORK!!! Do we need to check if __init__ takes args and pass NULL if not? work->m_instance = PyObject_CallObject(klass, NULL); if (work->m_instance == NULL) { work->m_error = true; work->m_verboseError = python::getLastError(); } else { gcArray.Register(work->m_instance); } Py_XDECREF(klass); } else if (work->m_type == python::Work::T_InvokeMethod) { int error = 0; PyObject* args = Py_BuildValue("l", work->m_tid); PyObject* kwds = Py_BuildValue(""); // NEEDSWORK!!! Is there a way to allocate and initialize a PyTypeObject instance in one call?? PyObject* trans = PyType_GenericNew((PyTypeObject*)bp_py_cTransaction, args, kwds); python::invokeMethod(trans, "__init__", &error, 1, PyLong_FromLong(work->m_tid)); Py_XDECREF(kwds); Py_XDECREF(args); g_bpCoreFunctions->log(BP_DEBUG, "executing func '%s'", work->sarg.c_str()); python::invokeMethod(work->m_instance, work->sarg.c_str(), &error, 2, trans, bpObjectToPython(work->m_obj, work->m_tid)); if (error) { g_bpCoreFunctions->postError(work->m_tid, "python.evalError", python::getLastError().c_str()); } if (work->m_obj) { delete work->m_obj; work->m_obj = NULL; } } else if (work->m_type == python::Work::T_ReleaseInstance) { int error = 0; (void)python::invokeFunction(work->m_instance, "destroy", &error, 0); gcArray.Unregister(work->m_instance); Py_XDECREF(work->m_instance); } // Presence of syncLock indicates synchronous operation // (client freed). if (work->m_syncLock != NULL) { work->m_syncLock->lock(); work->m_done = true; work->m_syncCond->signal(); work->m_syncLock->unlock(); } else { delete work; } } } Py_XDECREF(bpModule); // Now we'll block and wait for work. s_pythonLock.unlock(); return NULL; }
/* Implementation of hellow */ static char __pyx_k_1[] = "Hello World"; static char __pyx_k____main__[] = "__main__"; static char __pyx_k____test__[] = "__test__"; static PyObject *__pyx_kp_s_1; static PyObject *__pyx_n_s____main__; static PyObject *__pyx_n_s____test__; static struct PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; static void __pyx_init_filenames(void); /*proto*/ #if PY_MAJOR_VERSION >= 3 static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, __Pyx_NAMESTR("hellow"), 0, /* m_doc */ -1, /* m_size */ __pyx_methods /* m_methods */, NULL, /* m_reload */ NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_s_1, __pyx_k_1, sizeof(__pyx_k_1), 0, 0, 1, 0}, {&__pyx_n_s____main__, __pyx_k____main__, sizeof(__pyx_k____main__), 0, 0, 1, 1}, {&__pyx_n_s____test__, __pyx_k____test__, sizeof(__pyx_k____test__), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static int __Pyx_InitCachedBuiltins(void) { return 0; return -1; } static int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; return 0; __pyx_L1_error:; return -1; } #if PY_MAJOR_VERSION < 3 PyMODINIT_FUNC inithellow(void); /*proto*/ PyMODINIT_FUNC inithellow(void) #else PyMODINIT_FUNC PyInit_hellow(void); /*proto*/ PyMODINIT_FUNC PyInit_hellow(void) #endif { PyObject *__pyx_t_1 = NULL; #if CYTHON_REFNANNY void* __pyx_refnanny = NULL; __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } __pyx_refnanny = __Pyx_RefNanny->SetupContext("PyMODINIT_FUNC PyInit_hellow(void)", __LINE__, __FILE__); #endif __pyx_init_filenames(); __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #if PY_MAJOR_VERSION < 3 __pyx_empty_bytes = PyString_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #else __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4(__Pyx_NAMESTR("hellow"), __pyx_methods, 0, 0, PYTHON_API_VERSION); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (!__pyx_m) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; #if PY_MAJOR_VERSION < 3 Py_INCREF(__pyx_m); #endif __pyx_b = PyImport_AddModule(__Pyx_NAMESTR(__Pyx_BUILTIN_MODULE_NAME)); if (!__pyx_b) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; if (__Pyx_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; /*--- Initialize various global constants etc. ---*/ if (unlikely(__Pyx_InitGlobals() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} if (__pyx_module_is_main_hellow) { if (__Pyx_SetAttrString(__pyx_m, "__name__", __pyx_n_s____main__) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; } /*--- Builtin init code ---*/ if (unlikely(__Pyx_InitCachedBuiltins() < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} /*--- Global init code ---*/ /*--- Function export code ---*/ /*--- Type init code ---*/ /*--- Type import code ---*/ /*--- Function import code ---*/ /*--- Execution code ---*/ /* "C:\Documents and Settings\wflynn\My Documents\workspace\spinwaves_git\spinwaves\cross_section\util\hellow.pyx":1 * print "Hello World" # <<<<<<<<<<<<<< */ if (__Pyx_PrintOne(((PyObject *)__pyx_kp_s_1)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_GOTREF(((PyObject *)__pyx_t_1)); if (PyObject_SetAttr(__pyx_m, __pyx_n_s____test__, ((PyObject *)__pyx_t_1)) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} __Pyx_DECREF(((PyObject *)__pyx_t_1)); __pyx_t_1 = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); if (__pyx_m) { __Pyx_AddTraceback("init hellow"); Py_DECREF(__pyx_m); __pyx_m = 0; } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init hellow"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if PY_MAJOR_VERSION < 3 return; #else return __pyx_m; #endif }
/* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":49 * if not self._collections: * self._collections = self._read_collections() * return self._collections # <<<<<<<<<<<<<< * * def __getitem__(self, name): */ Py_INCREF(((struct __pyx_obj_4mill_9workspace_Workspace *)__pyx_v_self)->_collections); __pyx_r = ((struct __pyx_obj_4mill_9workspace_Workspace *)__pyx_v_self)->_collections; goto __pyx_L0; __pyx_r = Py_None; Py_INCREF(Py_None); goto __pyx_L0; __pyx_L1:; Py_XDECREF(__pyx_3); Py_XDECREF(__pyx_4); __Pyx_AddTraceback("mill.workspace.Workspace.collections.__get__"); __pyx_r = NULL; __pyx_L0:; Py_DECREF(__pyx_v_self); return __pyx_r; } static PyObject *__pyx_n_collections; static PyObject *__pyx_pf_4mill_9workspace_9Workspace___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_name); /*proto*/ static PyObject *__pyx_pf_4mill_9workspace_9Workspace___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_name) { PyObject *__pyx_r; PyObject *__pyx_1 = 0; PyObject *__pyx_2 = 0; PyObject *__pyx_3 = 0; Py_INCREF(__pyx_v_self); Py_INCREF(__pyx_v_name); __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_collections); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; goto __pyx_L1;} __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n___getitem__); if (unlikely(!__pyx_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; goto __pyx_L1;} Py_DECREF(__pyx_1); __pyx_1 = 0; __pyx_1 = PyTuple_New(1); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; goto __pyx_L1;} Py_INCREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_1, 0, __pyx_v_name); __pyx_3 = PyObject_CallObject(__pyx_2, __pyx_1); if (unlikely(!__pyx_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; goto __pyx_L1;} Py_DECREF(__pyx_2); __pyx_2 = 0; Py_DECREF(__pyx_1); __pyx_1 = 0; __pyx_r = __pyx_3; __pyx_3 = 0; goto __pyx_L0; __pyx_r = Py_None; Py_INCREF(Py_None); goto __pyx_L0; __pyx_L1:; Py_XDECREF(__pyx_1); Py_XDECREF(__pyx_2); Py_XDECREF(__pyx_3); __Pyx_AddTraceback("mill.workspace.Workspace.__getitem__"); __pyx_r = NULL; __pyx_L0:; Py_DECREF(__pyx_v_self); Py_DECREF(__pyx_v_name); return __pyx_r; } static PyObject *__pyx_pf_4mill_9workspace_9Workspace_keys(PyObject *__pyx_v_self, PyObject *unused); /*proto*/ static PyObject *__pyx_pf_4mill_9workspace_9Workspace_keys(PyObject *__pyx_v_self, PyObject *unused) { PyObject *__pyx_r; PyObject *__pyx_1 = 0; PyObject *__pyx_2 = 0; Py_INCREF(__pyx_v_self); __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_collections); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 55; goto __pyx_L1;} __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_keys); if (unlikely(!__pyx_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 55; goto __pyx_L1;} Py_DECREF(__pyx_1); __pyx_1 = 0; __pyx_1 = PyObject_CallObject(__pyx_2, 0); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 55; goto __pyx_L1;} Py_DECREF(__pyx_2); __pyx_2 = 0; __pyx_r = __pyx_1; __pyx_1 = 0; goto __pyx_L0; __pyx_r = Py_None; Py_INCREF(Py_None); goto __pyx_L0; __pyx_L1:; Py_XDECREF(__pyx_1); Py_XDECREF(__pyx_2); __Pyx_AddTraceback("mill.workspace.Workspace.keys"); __pyx_r = NULL; __pyx_L0:; Py_DECREF(__pyx_v_self); return __pyx_r; } static PyObject *__pyx_pf_4mill_9workspace_9Workspace_values(PyObject *__pyx_v_self, PyObject *unused); /*proto*/ static PyObject *__pyx_pf_4mill_9workspace_9Workspace_values(PyObject *__pyx_v_self, PyObject *unused) { PyObject *__pyx_r; PyObject *__pyx_1 = 0; PyObject *__pyx_2 = 0; Py_INCREF(__pyx_v_self); __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_collections); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 58; goto __pyx_L1;} __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_values); if (unlikely(!__pyx_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 58; goto __pyx_L1;} Py_DECREF(__pyx_1); __pyx_1 = 0; __pyx_1 = PyObject_CallObject(__pyx_2, 0); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 58; goto __pyx_L1;} Py_DECREF(__pyx_2); __pyx_2 = 0; __pyx_r = __pyx_1; __pyx_1 = 0; goto __pyx_L0; __pyx_r = Py_None; Py_INCREF(Py_None); goto __pyx_L0; __pyx_L1:; Py_XDECREF(__pyx_1); Py_XDECREF(__pyx_2); __Pyx_AddTraceback("mill.workspace.Workspace.values"); __pyx_r = NULL; __pyx_L0:; Py_DECREF(__pyx_v_self); return __pyx_r; } static PyObject *__pyx_pf_4mill_9workspace_9Workspace_items(PyObject *__pyx_v_self, PyObject *unused); /*proto*/ static PyObject *__pyx_pf_4mill_9workspace_9Workspace_items(PyObject *__pyx_v_self, PyObject *unused) { PyObject *__pyx_r; PyObject *__pyx_1 = 0; PyObject *__pyx_2 = 0; Py_INCREF(__pyx_v_self); __pyx_1 = PyObject_GetAttr(__pyx_v_self, __pyx_n_collections); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 61; goto __pyx_L1;} __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_items); if (unlikely(!__pyx_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 61; goto __pyx_L1;} Py_DECREF(__pyx_1); __pyx_1 = 0; __pyx_1 = PyObject_CallObject(__pyx_2, 0); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 61; goto __pyx_L1;} Py_DECREF(__pyx_2); __pyx_2 = 0; __pyx_r = __pyx_1; __pyx_1 = 0; goto __pyx_L0; __pyx_r = Py_None; Py_INCREF(Py_None); goto __pyx_L0; __pyx_L1:; Py_XDECREF(__pyx_1); Py_XDECREF(__pyx_2); __Pyx_AddTraceback("mill.workspace.Workspace.items"); __pyx_r = NULL; __pyx_L0:; Py_DECREF(__pyx_v_self); return __pyx_r; } static PyObject *__pyx_pf_4mill_9workspace_workspace(PyObject *__pyx_self, PyObject *__pyx_v_path); /*proto*/ static PyObject *__pyx_pf_4mill_9workspace_workspace(PyObject *__pyx_self, PyObject *__pyx_v_path) { PyObject *__pyx_r; PyObject *__pyx_1 = 0; PyObject *__pyx_2 = 0; Py_INCREF(__pyx_v_path); __pyx_1 = PyTuple_New(1); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 65; goto __pyx_L1;} Py_INCREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_1, 0, __pyx_v_path); __pyx_2 = PyObject_CallObject(((PyObject*)__pyx_ptype_4mill_9workspace_Workspace), __pyx_1); if (unlikely(!__pyx_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 65; goto __pyx_L1;} Py_DECREF(__pyx_1); __pyx_1 = 0; __pyx_r = __pyx_2; __pyx_2 = 0; goto __pyx_L0; __pyx_r = Py_None; Py_INCREF(Py_None); goto __pyx_L0; __pyx_L1:; Py_XDECREF(__pyx_1); Py_XDECREF(__pyx_2); __Pyx_AddTraceback("mill.workspace.workspace"); __pyx_r = NULL; __pyx_L0:; Py_DECREF(__pyx_v_path); return __pyx_r; } static __Pyx_InternTabEntry __pyx_intern_tab[] = { {&__pyx_n_Collection, "Collection"}, {&__pyx_n___getitem__, "__getitem__"}, {&__pyx_n___init__, "__init__"}, {&__pyx_n__read_collections, "_read_collections"}, {&__pyx_n_collections, "collections"}, {&__pyx_n_items, "items"}, {&__pyx_n_keys, "keys"}, {&__pyx_n_mill, "mill"}, {&__pyx_n_ogrinit, "ogrinit"}, {&__pyx_n_range, "range"}, {&__pyx_n_values, "values"}, {0, 0} }; static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_k3p, __pyx_k3, sizeof(__pyx_k3), 0}, {0, 0, 0, 0} }; static PyObject *__pyx_tp_new_4mill_9workspace_Workspace(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_4mill_9workspace_Workspace *p; PyObject *o = (*t->tp_alloc)(t, 0); if (!o) return 0; p = ((struct __pyx_obj_4mill_9workspace_Workspace *)o); p->path = Py_None; Py_INCREF(Py_None); p->_collections = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_4mill_9workspace_Workspace(PyObject *o) { struct __pyx_obj_4mill_9workspace_Workspace *p = (struct __pyx_obj_4mill_9workspace_Workspace *)o; Py_XDECREF(p->path); Py_XDECREF(p->_collections); (*o->ob_type->tp_free)(o); } static int __pyx_tp_traverse_4mill_9workspace_Workspace(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_4mill_9workspace_Workspace *p = (struct __pyx_obj_4mill_9workspace_Workspace *)o; if (p->path) { e = (*v)(p->path, a); if (e) return e; } if (p->_collections) { e = (*v)(p->_collections, a); if (e) return e; } return 0; } static int __pyx_tp_clear_4mill_9workspace_Workspace(PyObject *o) { struct __pyx_obj_4mill_9workspace_Workspace *p = (struct __pyx_obj_4mill_9workspace_Workspace *)o; Py_XDECREF(p->path); p->path = Py_None; Py_INCREF(Py_None); Py_XDECREF(p->_collections); p->_collections = Py_None; Py_INCREF(Py_None); return 0; } static PyObject *__pyx_sq_item_4mill_9workspace_Workspace(PyObject *o, Py_ssize_t i) { PyObject *r; PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; r = o->ob_type->tp_as_mapping->mp_subscript(o, x); Py_DECREF(x); return r; } static PyObject *__pyx_getprop_4mill_9workspace_9Workspace_collections(PyObject *o, void *x) { return __pyx_pf_4mill_9workspace_9Workspace_11collections___get__(o); } static struct PyMethodDef __pyx_methods_4mill_9workspace_Workspace[] = { {"_read_collections", (PyCFunction)__pyx_pf_4mill_9workspace_9Workspace__read_collections, METH_NOARGS, 0}, {"__getitem__", (PyCFunction)__pyx_pf_4mill_9workspace_9Workspace___getitem__, METH_O|METH_COEXIST, 0}, {"keys", (PyCFunction)__pyx_pf_4mill_9workspace_9Workspace_keys, METH_NOARGS, 0}, {"values", (PyCFunction)__pyx_pf_4mill_9workspace_9Workspace_values, METH_NOARGS, 0}, {"items", (PyCFunction)__pyx_pf_4mill_9workspace_9Workspace_items, METH_NOARGS, 0}, {0, 0, 0, 0} }; static struct PyMemberDef __pyx_members_4mill_9workspace_Workspace[] = { {"path", T_OBJECT, offsetof(struct __pyx_obj_4mill_9workspace_Workspace, path), 0, 0}, {0, 0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_4mill_9workspace_Workspace[] = { {"collections", __pyx_getprop_4mill_9workspace_9Workspace_collections, 0, 0, 0}, {0, 0, 0, 0, 0} }; static PyNumberMethods __pyx_tp_as_number_Workspace = { 0, /*nb_add*/ 0, /*nb_subtract*/ 0, /*nb_multiply*/ 0, /*nb_divide*/ 0, /*nb_remainder*/ 0, /*nb_divmod*/ 0, /*nb_power*/ 0, /*nb_negative*/ 0, /*nb_positive*/ 0, /*nb_absolute*/ 0, /*nb_nonzero*/ 0, /*nb_invert*/ 0, /*nb_lshift*/ 0, /*nb_rshift*/ 0, /*nb_and*/ 0, /*nb_xor*/ 0, /*nb_or*/ 0, /*nb_coerce*/ 0, /*nb_int*/ 0, /*nb_long*/ 0, /*nb_float*/ 0, /*nb_oct*/ 0, /*nb_hex*/ 0, /*nb_inplace_add*/ 0, /*nb_inplace_subtract*/ 0, /*nb_inplace_multiply*/ 0, /*nb_inplace_divide*/ 0, /*nb_inplace_remainder*/ 0, /*nb_inplace_power*/ 0, /*nb_inplace_lshift*/ 0, /*nb_inplace_rshift*/ 0, /*nb_inplace_and*/ 0, /*nb_inplace_xor*/ 0, /*nb_inplace_or*/ 0, /*nb_floor_divide*/ 0, /*nb_true_divide*/ 0, /*nb_inplace_floor_divide*/ 0, /*nb_inplace_true_divide*/ #if Py_TPFLAGS_DEFAULT & Py_TPFLAGS_HAVE_INDEX 0, /*nb_index*/ #endif }; static PySequenceMethods __pyx_tp_as_sequence_Workspace = { 0, /*sq_length*/ 0, /*sq_concat*/ 0, /*sq_repeat*/ __pyx_sq_item_4mill_9workspace_Workspace, /*sq_item*/ 0, /*sq_slice*/ 0, /*sq_ass_item*/ 0, /*sq_ass_slice*/ 0, /*sq_contains*/ 0, /*sq_inplace_concat*/ 0, /*sq_inplace_repeat*/ }; static PyMappingMethods __pyx_tp_as_mapping_Workspace = { 0, /*mp_length*/ __pyx_pf_4mill_9workspace_9Workspace___getitem__, /*mp_subscript*/ 0, /*mp_ass_subscript*/ }; static PyBufferProcs __pyx_tp_as_buffer_Workspace = { 0, /*bf_getreadbuffer*/ 0, /*bf_getwritebuffer*/ 0, /*bf_getsegcount*/ 0, /*bf_getcharbuffer*/ }; PyTypeObject __pyx_type_4mill_9workspace_Workspace = { PyObject_HEAD_INIT(0) 0, /*ob_size*/ "mill.workspace.Workspace", /*tp_name*/ sizeof(struct __pyx_obj_4mill_9workspace_Workspace), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4mill_9workspace_Workspace, /*tp_dealloc*/ 0, /*tp_print*/ 0, /*tp_getattr*/ 0, /*tp_setattr*/ 0, /*tp_compare*/ 0, /*tp_repr*/ &__pyx_tp_as_number_Workspace, /*tp_as_number*/ &__pyx_tp_as_sequence_Workspace, /*tp_as_sequence*/ &__pyx_tp_as_mapping_Workspace, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ &__pyx_tp_as_buffer_Workspace, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_4mill_9workspace_Workspace, /*tp_traverse*/ __pyx_tp_clear_4mill_9workspace_Workspace, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_4mill_9workspace_Workspace, /*tp_methods*/ __pyx_members_4mill_9workspace_Workspace, /*tp_members*/ __pyx_getsets_4mill_9workspace_Workspace, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pf_4mill_9workspace_9Workspace___init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4mill_9workspace_Workspace, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ }; static struct PyMethodDef __pyx_methods[] = { {"workspace", (PyCFunction)__pyx_pf_4mill_9workspace_workspace, METH_O, 0}, {0, 0, 0, 0} }; static void __pyx_init_filenames(void); /*proto*/ PyMODINIT_FUNC initworkspace(void); /*proto*/ PyMODINIT_FUNC initworkspace(void) { PyObject *__pyx_1 = 0; PyObject *__pyx_2 = 0; /*--- Libary function declarations ---*/ __pyx_init_filenames(); /*--- Module creation code ---*/ __pyx_m = Py_InitModule4("workspace", __pyx_methods, 0, 0, PYTHON_API_VERSION); if (!__pyx_m) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; goto __pyx_L1;}; __pyx_b = PyImport_AddModule("__builtin__"); if (!__pyx_b) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; goto __pyx_L1;}; if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; goto __pyx_L1;}; /*--- Intern code ---*/ if (__Pyx_InternStrings(__pyx_intern_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; goto __pyx_L1;}; /*--- String init code ---*/ if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; goto __pyx_L1;}; /*--- Builtin init code ---*/ __pyx_builtin_range = __Pyx_GetName(__pyx_b, __pyx_n_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 32; goto __pyx_L1;} /*--- Global init code ---*/ /*--- Function export code ---*/ /*--- Function import code ---*/ /*--- Type init code ---*/ __pyx_type_4mill_9workspace_Workspace.tp_free = _PyObject_GC_Del; if (PyType_Ready(&__pyx_type_4mill_9workspace_Workspace) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 11; goto __pyx_L1;} if (PyObject_SetAttrString(__pyx_m, "Workspace", (PyObject *)&__pyx_type_4mill_9workspace_Workspace) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 11; goto __pyx_L1;} __pyx_ptype_4mill_9workspace_Workspace = &__pyx_type_4mill_9workspace_Workspace; /*--- Type import code ---*/ /*--- Execution code ---*/ /* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":7 * cimport ograpi * * from mill import ogrinit # <<<<<<<<<<<<<< * from mill.collection import Collection * */ __pyx_1 = PyList_New(1); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 7; goto __pyx_L1;} Py_INCREF(__pyx_n_ogrinit); PyList_SET_ITEM(__pyx_1, 0, __pyx_n_ogrinit); __pyx_2 = __Pyx_Import(__pyx_n_mill, __pyx_1); if (unlikely(!__pyx_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 7; goto __pyx_L1;} Py_DECREF(__pyx_1); __pyx_1 = 0; __pyx_1 = PyObject_GetAttr(__pyx_2, __pyx_n_ogrinit); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 7; goto __pyx_L1;} if (PyObject_SetAttr(__pyx_m, __pyx_n_ogrinit, __pyx_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 7; goto __pyx_L1;} Py_DECREF(__pyx_1); __pyx_1 = 0; Py_DECREF(__pyx_2); __pyx_2 = 0; /* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":8 * * from mill import ogrinit * from mill.collection import Collection # <<<<<<<<<<<<<< * * */ __pyx_2 = PyList_New(1); if (unlikely(!__pyx_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; goto __pyx_L1;} Py_INCREF(__pyx_n_Collection); PyList_SET_ITEM(__pyx_2, 0, __pyx_n_Collection); __pyx_1 = __Pyx_Import(__pyx_k3p, __pyx_2); if (unlikely(!__pyx_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; goto __pyx_L1;} Py_DECREF(__pyx_2); __pyx_2 = 0; __pyx_2 = PyObject_GetAttr(__pyx_1, __pyx_n_Collection); if (unlikely(!__pyx_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; goto __pyx_L1;} if (PyObject_SetAttr(__pyx_m, __pyx_n_Collection, __pyx_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 8; goto __pyx_L1;} Py_DECREF(__pyx_2); __pyx_2 = 0; Py_DECREF(__pyx_1); __pyx_1 = 0; /* "/home/sean/Projects/WorldMill/src/mill/workspace.pyx":64 * * * def workspace(path): # <<<<<<<<<<<<<< * return Workspace(path) * */ if (__Pyx_RegisterCleanup()) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 5; goto __pyx_L1;}; return; __pyx_L1:; Py_XDECREF(__pyx_1); Py_XDECREF(__pyx_2); __Pyx_AddTraceback("mill.workspace"); }
//------------------------------------------------------------------------ // Helper function to get globals for the __main__ module // Note: The references are borrowed. No need to free them. static PyObject *GetMainGlobals() { PyObject *module = PyImport_AddModule("__main__"); return module == NULL ? NULL : PyModule_GetDict(module); }
python_persistency(std::string file_name) { // changed to skip installation of signal handlers [PS] // Py_InitializeEx(0); // Py_Initialize(); // char string_main[]="__main__"; boost::python::object main_module((boost::python::handle<>(boost::python::borrowed(PyImport_AddModule(string_main))))); main_namespace = main_module.attr("__dict__"); FILE* file = fopen(file_name.c_str(),"r"); if (file == 0) { std::cerr << "no file of name: " << file_name << std::endl; exit(-1); } PyRun_SimpleFile(file, file_name.c_str()); };