//------------------------------------------------------------------------------------- int Script::run_simpleString(const char* command, std::string* retBufferPtr) { if(command == NULL) { ERROR_MSG("Script::Run_SimpleString: command is NULL!\n"); return 0; } ScriptStdOutErrHook* pStdouterrHook = new ScriptStdOutErrHook(); if(retBufferPtr != NULL) { DebugHelper::getSingleton().resetScriptMsgType(); if(!pStdouterrHook->install()){ ERROR_MSG("Script::Run_SimpleString: pyStdouterrHook_->install() is failed!\n"); SCRIPT_ERROR_CHECK(); delete pStdouterrHook; return -1; } pStdouterrHook->setHookBuffer(retBufferPtr); //PyRun_SimpleString(command); PyObject *m, *d, *v; m = PyImport_AddModule("__main__"); if (m == NULL) { SCRIPT_ERROR_CHECK(); pStdouterrHook->uninstall(); delete pStdouterrHook; return -1; } d = PyModule_GetDict(m); v = PyRun_String(command, Py_single_input, d, d); if (v == NULL) { PyErr_Print(); pStdouterrHook->uninstall(); delete pStdouterrHook; return -1; } Py_DECREF(v); SCRIPT_ERROR_CHECK(); pStdouterrHook->uninstall(); delete pStdouterrHook; return 0; } PyRun_SimpleString(command); SCRIPT_ERROR_CHECK(); delete pStdouterrHook; return 0; }
/** @param persist: If true, retain the Python interpreter, else finalize it @param code: The multiline string of Python code. The last line is evaluated to the returned result @param output: Store result pointer here @return Tcl error code */ static int python_eval(bool persist, const char* code, const char* expression, Tcl_Obj** output) { int rc; char* result = python_result_default; // Initialize: rc = python_init(); TCL_CHECK(rc); // Execute code: DEBUG_TCL_TURBINE("python: code: %s", code); PyObject* localDictionary = PyDict_New(); PyRun_String(code, Py_file_input, main_dict, localDictionary); if (PyErr_Occurred()) return handle_python_exception(); // Evaluate expression: DEBUG_TCL_TURBINE("python: expression: %s", expression); PyObject* o = PyRun_String(expression, Py_eval_input, main_dict, localDictionary); if (o == NULL) return handle_python_exception(); // Convert Python result to C string, then to Tcl string: rc = PyArg_Parse(o, "s", &result); if (rc != 1) return handle_python_non_string(o); DEBUG_TCL_TURBINE("python: result: %s\n", result); *output = Tcl_NewStringObj(result, -1); // Clean up and return: Py_DECREF(o); if (!persist) python_finalize(); return TCL_OK; }
void PythonEngine::init() { m_isRunning = false; m_stdOut = ""; // connect stdout connect(this, SIGNAL(pythonShowMessage(QString)), this, SLOT(stdOut(QString))); // init python Py_Initialize(); // read functions m_functions = readFileContent(datadir() + "/functions.py"); m_dict = PyDict_New(); PyDict_SetItemString(m_dict, "__builtins__", PyEval_GetBuiltins()); // init engine extensions Py_InitModule("pythonlab", pythonEngineFuntions); addCustomExtensions(); // custom modules PyRun_String(QString("import sys; sys.path.insert(0, \"" + datadir() + "/resources/python" + "\")").toStdString().c_str(), Py_file_input, m_dict, m_dict); // functions.py PyRun_String(m_functions.toStdString().c_str(), Py_file_input, m_dict, m_dict); }
QStringList PythonEngine::codePyFlakes(const QString& fileName) { QStringList out; QString exp = QString("result_pyflakes_pythonlab = python_engine_pyflakes_check(\"%1\")").arg(fileName); PyRun_String(exp.toLatin1().data(), Py_single_input, m_dict, m_dict); // parse result PyObject *result = PyDict_GetItemString(m_dict, "result_pyflakes_pythonlab"); if (result) { Py_INCREF(result); PyObject *list; if (PyArg_Parse(result, "O", &list)) { int count = PyList_Size(list); for (int i = 0; i < count; i++) { PyObject *item = PyList_GetItem(list, i); QString str = PyString_AsString(item); out.append(str); } } Py_DECREF(result); } PyRun_String("del result_pyflakes_pythonlab", Py_single_input, m_dict, m_dict); return out; }
bool PythonScript::compile(bool for_eval) { if(Context->isA("Table")) { PyDict_SetItemString(localDict,"__builtins__",PyDict_GetItemString(env()->globalDict(),"__builtins__")); PyObject *ret = PyRun_String("def col(c,*arg):\n\ttry: return self.cell(c,arg[0])\n\texcept(IndexError): return self.cell(c,i)\n",Py_file_input,localDict,localDict); if (ret) Py_DECREF(ret); else PyErr_Print(); } else if(Context->isA("Matrix")) { PyDict_SetItemString(localDict,"__builtins__",PyDict_GetItemString(env()->globalDict(),"__builtins__")); PyObject *ret = PyRun_String("def cell(*arg):\n\ttry: return self.cell(arg[0],arg[1])\n\texcept(IndexError): return self.cell(i,j)\n",Py_file_input,localDict,localDict); if (ret) Py_DECREF(ret); else PyErr_Print(); } bool success=false; Py_XDECREF(PyCode); PyCode = Py_CompileString(Code.ascii(),Name,Py_eval_input); if (PyCode) { // code is a single expression success = true; } else if (for_eval) { // code contains statements PyErr_Clear(); PyObject *key, *value; int i=0; QString signature = ""; while(PyDict_Next(localDict, &i, &key, &value)) signature.append(PyString_AsString(key)).append(","); signature.truncate(signature.length()-1); QString fdef = "def __doit__("+signature+"):\n"; fdef.append(Code); fdef.replace('\n',"\n\t"); PyCode = Py_CompileString(fdef,Name,Py_file_input); if (PyCode) { PyObject *tmp = PyDict_New(); Py_XDECREF(PyEval_EvalCode((PyCodeObject*)PyCode, env()->globalDict(), tmp)); Py_DECREF(PyCode); PyCode = PyDict_GetItemString(tmp,"__doit__"); Py_XINCREF(PyCode); Py_DECREF(tmp); } success = PyCode != NULL; } else { PyErr_Clear(); PyCode = Py_CompileString(Code.ascii(),Name,Py_file_input); success = PyCode != NULL; } if (!success) { compiled = compileErr; emit_error(env()->errorMsg(), 0); } else compiled = isCompiled; return success; }
ExpressionResult PythonEngine::runPythonExpression(const QString &expression, bool returnValue) { runPythonHeader(); QString exp; if (returnValue) exp = QString("result_pythonlab = %1").arg(expression); else exp = expression; PyObject *output = PyRun_String(exp.toLatin1().data(), Py_single_input, m_dict, m_dict); ExpressionResult expressionResult; if (output) { PyObject *type = NULL, *value = NULL, *traceback = NULL, *str = NULL; PyErr_Fetch(&type, &value, &traceback); if (type != NULL && (str = PyObject_Str(type)) != NULL && (PyString_Check(str))) { Py_INCREF(str); expressionResult.error = PyString_AsString(str); Py_XDECREF(type); Py_XDECREF(str); } else { // parse result if (returnValue) { PyObject *result = PyDict_GetItemString(m_dict, "result_pythonlab"); if (result) { Py_INCREF(result); PyArg_Parse(result, "d", &expressionResult.value); if (fabs(expressionResult.value) < EPS_ZERO) expressionResult.value = 0.0; Py_DECREF(result); } } } if (returnValue) PyRun_String("del result_pythonlab", Py_single_input, m_dict, m_dict); } else { ScriptResult error = parseError(); expressionResult.error = error.text; expressionResult.traceback = error.traceback; } Py_XDECREF(output); emit executedExpression(); return expressionResult; }
QStringList PythonEngine::codeCompletion(const QString& command) { QStringList out; runPythonHeader(); #pragma omp critical(completion) { PyObject *output = PyRun_String(command.toLatin1().data(), Py_single_input, m_dict, m_dict); // parse result if (output) { PyObject *result = PyDict_GetItemString(m_dict, "result_jedi_pythonlab"); if (result) { Py_INCREF(result); PyObject *list; if (PyArg_Parse(result, "O", &list)) { int count = PyList_Size(list); for (int i = 0; i < count; i++) { PyObject *item = PyList_GetItem(list, i); QString str = PyString_AsString(item); // remove builtin methods if (!str.startsWith("__")) { //qDebug() << str; out.append(str); } } } Py_DECREF(result); } PyObject *del = PyRun_String("del result_jedi_pythonlab", Py_single_input, m_dict, m_dict); Py_XDECREF(del); } else { PyErr_Clear(); } Py_XDECREF(output); } return out; }
int interpreterGetConditionValue(Interpreter *interpreter, char *condition) { char* bufferCondition, *cval; int result; //PyEval_AcquireThread(interpreter->threadPythonState); PyEval_RestoreThread(interpreter->threadPythonState); bufferCondition = (char*) malloc(sizeof(char) * 2048); memset(bufferCondition, 0, sizeof bufferCondition); sprintf(bufferCondition, "result = str(%s)", condition); PyRun_String(bufferCondition, Py_file_input, interpreter->pdict, interpreter->pdict); interpreter->pval = PyDict_GetItemString(interpreter->pdict, "result"); PyArg_Parse(interpreter->pval, "s", &cval); result = (cval != NULL && strcmp("True", cval) == 0); free(bufferCondition); //PyEval_ReleaseThread(interpreter->threadPythonState) ; PyEval_SaveThread(); return result; }
GList *PyMySQLGetDatabaseList(const char *user, const char *password) { PyObject *rs; if (PyMySQLConnect("", user, password) < 0) return NULL; rs = PyRun_String("PyUpdateCommandReturn(\"Show databases\")", Py_eval_input, pdict, pdict); if (rs) { unsigned int i; GList *glist = NULL; RowSet* list = ConvertPythonToRowset(rs); if (!list) return NULL; for (i = 0; i < list->rows; i++) glist = g_list_append(glist, g_strdup(list->data[i][0])); FreeRowset(list); return glist; } else { PyErr_Print(); return NULL; } }
static int PySQLiteConnect(const char *dbfilename, const char *user, const char *password) { PyObject *con; char *name, *filename, *buf; int exists; name = g_strdup_printf("%s.db", dbfilename); filename = g_build_filename (szHomeDirectory, name, NULL); exists = g_file_test(filename, G_FILE_TEST_EXISTS); buf = g_strdup_printf("PySQLiteConnect(r'%s')", filename); /* Connect to database*/ con = PyRun_String(buf, Py_eval_input, pdict, pdict); g_free(name); g_free(filename); g_free(buf); if (con == NULL) { PyErr_Print(); return -1; } else if (con == Py_None) { outputl( _("Error connecting to database") ); return -1; } if (!exists) { /* Empty database file created - create tables */ return 0; } else return 1; }
// eval the first parameter, return the value of the variable passed as second parameter // for example you eval "x = 2" and want the value of x, you do pynerl:eval("x = 2", "x") static ERL_NIF_TERM pynerl_eval(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) { Py_Initialize(); char buff[BUFF_SIZE]; PyObject *pResult=NULL, *pdict, *pval; ERL_NIF_TERM eResult; // TODO: error checking enif_get_string(env, argv[0], buff, BUFF_SIZE, ERL_NIF_LATIN1); pdict = PyDict_New(); PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins()); pResult = PyRun_String(buff, Py_file_input, pdict, pdict); if (pResult == NULL) { eResult = pynerl_make_error(env, "exception", "Exception while running eval"); } else { enif_get_string(env, argv[1], buff, BUFF_SIZE, ERL_NIF_LATIN1); pval = PyDict_GetItemString(pdict, buff); eResult = pynerl_obj_to_term(env, pval); Py_DECREF(pResult); } Py_DECREF(pdict); Py_Finalize(); return eResult; }
main() { /* run strings with low-level calls */ char *cstr; PyObject *pstr, *pmod, *pdict; /* with error tests */ Py_Initialize(); /* result = string.upper('spam') + '!' */ pmod = PyImport_ImportModule("string"); /* fetch module */ if (pmod == NULL) /* for name-space */ error("Can't import module"); pdict = PyModule_GetDict(pmod); /* string.__dict__ */ Py_DECREF(pmod); if (pdict == NULL) error("Can't get module dict"); pstr = PyRun_String("upper('spam') + '!'", Py_eval_input, pdict, pdict); if (pstr == NULL) error("Error while running string"); /* convert result to C */ if (!PyArg_Parse(pstr, "s", &cstr)) error("Bad result type"); printf("%s\n", cstr); Py_DECREF(pstr); /* free exported objects, not pdict */ }
int PEVENT_PLUGIN_LOADER(struct pevent *pevent) { PyObject *globals, *m, *py_pevent, *str, *res; Py_Initialize(); m = PyImport_AddModule("__main__"); globals = PyModule_GetDict(m); res = PyRun_String(pypath, Py_file_input, globals, globals); if (!res) { PyErr_Print(); return -1; } else Py_DECREF(res); str = PyString_FromString("pevent"); if (!str) return -ENOMEM; py_pevent = PyLong_FromUnsignedLong((unsigned long)pevent); if (!py_pevent) return -ENOMEM; if (PyDict_SetItem(globals, str, py_pevent)) fprintf(stderr, "failed to insert pevent\n"); Py_DECREF(py_pevent); Py_DECREF(str); trace_util_load_plugins(pevent, ".py", load_plugin, globals); return 0; }
static void load_plugin(struct pevent *pevent, const char *path, const char *name, void *data) { PyObject *globals = data; int len = strlen(path) + strlen(name) + 2; int nlen = strlen(name) + 1; char *full = malloc(len); char *n = malloc(nlen); char *load; PyObject *res; if (!full || !n) return; strcpy(full, path); strcat(full, "/"); strcat(full, name); strcpy(n, name); n[nlen - 4] = '\0'; asprintf(&load, pyload, full, n); if (!load) return; res = PyRun_String(load, Py_file_input, globals, globals); if (!res) { fprintf(stderr, "failed loading %s\n", full); PyErr_Print(); } else Py_DECREF(res); free(load); }
bool LoadInitialModules(PyVis* pyVis) { std::string scriptName("EmbeddedBinding"); std::string scriptNameShorthand("eb"); if(!pyVis->LoadModule(scriptName)) { return false; } PyErr_Print(); // So far this seems to be necessary to use EmbeddedBinding from the // PyRun_SimpleString context, but they are still referencing the same module std::string importToSimple = std::string("import ") + scriptName; PyRun_SimpleString(importToSimple.c_str()); // Same, but now even more convenient! So like "eb.ScriptStep()" std::string importToSimpleShorthand = std::string("import ") + scriptName + std::string(" as ") + scriptNameShorthand; PyRun_SimpleString(importToSimpleShorthand.c_str()); PyRun_SimpleString("import numpy"); // handy, was already loaded above anyway PyObject* scriptDict = pyVis->GetDict(scriptName); PyRun_String("ScriptCreate()", Py_eval_input, pyVis->consoleGlobalContextDict, scriptDict); pyVis->consoleLocalContextDict = scriptDict; PyObject* scriptStep = PyDict_GetItemString(scriptDict, "ScriptStep"); // borrowed ref pyVis->scriptStep = scriptStep; // borrowed ref if(!scriptStep || !PyCallable_Check(scriptStep)) { printf("Error loading python potential step function linkage: no ScriptStep()\n"); PyErr_Print(); return false; } return true; }
bool EventListener::Compile() { Rocket::Core::String function_name(64, "Event_%x", this); Rocket::Core::String function_code(64, "def %s():", function_name.CString()); Rocket::Core::StringList lines; Rocket::Core::StringUtilities::ExpandString(lines, source_code, ';'); for (size_t i = 0; i < lines.size(); i++) { // Python doesn't handle \r's, strip em and indent the code correctly function_code += Rocket::Core::String(1024, "\n\t%s", lines[i].CString()).Replace("\r", ""); } ROCKET_ASSERT(element != NULL); PyObject* py_namespace = GetGlobalNamespace(); // Add our function to the namespace PyObject* result = PyRun_String(function_code.CString(), Py_file_input, py_namespace, py_namespace); if (!result) { Rocket::Core::Python::Utilities::PrintError(); return false; } Py_DECREF(result); // Get a handle to our function callable = PyDict_GetItemString(py_namespace, function_name.CString()); Py_INCREF(callable); return true; }
void OutputHook::call(std::string name, boost::python::object obj) { Hooks::checkName(name); auto repr_ = PyObject_Repr(obj.ptr()); if (PyErr_Occurred()) { PyErr_Clear(); throw Hooks::Exception("Failed to get __repr__ of argument"); } auto repr = std::string(PyUnicode_AsUTF8(repr_)); Py_DECREF(repr_); PyObject* g = Py_BuildValue( "{sO}", "__builtins__", PyEval_GetBuiltins()); node->parent->loadDatumHooks(g); auto out = PyRun_String(repr.c_str(), Py_eval_input, g, g); Py_DECREF(g); Py_XDECREF(out); if (PyErr_Occurred()) { PyErr_Clear(); throw Hooks::Exception("Could not evaluate __repr__ of output"); } const bool result = node->makeDatum( name, obj.ptr()->ob_type, Datum::SIGIL_OUTPUT + repr, true); if (!result) throw Hooks::Exception("Datum was already defined in this script."); }
PyObject* getFileData(int argc, char *argv[]) { PyObject *BioModule = PyImport_ImportModule("Bio"); const char *filename, *filetype, *pycmdToRun; filename = (const char *)PyUnicode_DecodeFSDefault(argv[1]); filetype = (const char *)PyUnicode_DecodeFSDefault(argv[2]); std::string cmdToRun = "import Bio\nBio.SeqIO.parse("; cmdToRun = cmdToRun + filename + std::string(",") + filetype; pycmdToRun = cmdToRun.c_str(); wchar_t *program = Py_DecodeLocale(argv[0], NULL); if (program == NULL) { fprintf(stderr, "Fatal error: cannot decode argv[0]\n"); exit(1); } Py_SetProgramName(program); /* optional but recommended */ Py_Initialize(); PyObject* filedata; filedata = PyRun_String(pycmdToRun, 0, NULL, NULL); Py_DECREF(filename); Py_DECREF(filetype); Py_Finalize(); PyMem_RawFree(program); return filedata; }
PyObject* runSingleString_(const String& str, int mode) { // clear previous errors PyErr_Clear(); error_message_ = ""; // run the string through the interpreter PyObject* result = PyRun_String(const_cast<char*>(str.c_str()), mode, context_, context_); if (PyErr_Occurred()) { PyObject* type; PyObject* value; PyObject* range; char* message; error_message_ = "ERROR: "; PyErr_Fetch(&type, &value, &range); if (PyArg_Parse(value, "s", &message)) { error_message_ += message; } else { error_message_ += " (error message could not be parsed)"; } PyErr_Print(); error_message_ += "\n"; return 0; } return result; }
std::string evalForString(const char * stmt,bool * ok = nullptr) { if (ok != 0) *ok = false; PyObject* result = 0; run ([stmt,&result]() { PyObject* main = PyImport_AddModule("__main__"); if (main == 0) { return; } PyObject* globalDictionary = PyModule_GetDict(main); if (globalDictionary == 0) { return ; } PyObject* localDictionary = PyDict_New(); if (localDictionary == 0) { return ; } result = PyRun_String(stmt, Py_file_input, globalDictionary, localDictionary); }); if (result == 0) return ""; bool lok = false; std::string ret = convert<std::string>(result,ok?*ok:lok); Py_DecRef(result); return ret; }
int PP_Run_Codestr(PPStringModes mode, const char *code, /* expr or stmt string */ const char *modname, /* loads module if needed */ const char *resfmt, void *cresult) /* converts expr result to C */ { /* run a string of Python code */ int parse_mode; /* "eval(code, d, d)", or */ PyObject *module, *dict, *presult; /* "exec code in d, d" */ module = PP_Load_Module(modname); /* get module, init python */ if (module == NULL) /* not incref'd */ return -1; dict = PyModule_GetDict(module); /* get dict namespace */ if (dict == NULL) /* not incref'd */ return -1; parse_mode = (mode == PP_EXPRESSION ? Py_eval_input : Py_file_input); if (PP_DEBUG) presult = PP_Debug_Codestr(mode, code, dict); /* run in pdb */ else presult = PyRun_String(code, parse_mode, dict, dict); /* eval direct */ /* increfs res */ if (mode == PP_STATEMENT) { int result = (presult == NULL? -1 : 0); /* stmt: 'None' */ Py_XDECREF(presult); /* ignore result */ return result; } return PP_Convert_Result(presult, resfmt, cresult); /* expr val to C */ }
PyMODINIT_FUNC PYENTRY_FUNC_NAME(void) { PyObject *module = NULL; #ifdef PY3K module = PyModule_Create(&wsql_module); #else module = Py_InitModule3(#MODULE_NAME, wsql_methods, wsql__doc__); #endif if (!module) PY_MOD_RETURN(NULL); /* this really should never happen */ /* Populate final object settings */ if (PyType_Ready(&wsql_connection_t) < 0) goto on_error; if (PyType_Ready(&wsql_result_t) < 0) goto on_error; if (PyType_Ready(&wsql_field_t) < 0) goto on_error; /* Module constants */ if (PyModule_AddObject(module, "version_info", PyRun_String(STRINGIFY(MODULE_VERSION_INFO), Py_eval_input, PyModule_GetDict(module), PyModule_GetDict(module))) < 0) goto on_error; if (PyModule_AddStringConstant(module, "__version__", STRINGIFY(MODULE_VERSION)) < 0) goto on_error; if (wsql_exceptions_init(module) < 0) goto on_error; if (wsql_constants_init(module) < 0) goto on_error; PY_MOD_RETURN(module); on_error: Py_XDECREF(module); PY_MOD_RETURN(NULL); }
RowSet *PySelect(const char* str) { PyObject *rs; char *buf = g_strdup_printf("PySelect(\"%s\")", str); /* Remove any new lines from query string */ char *ppch = buf; while (*ppch) { if (strchr( "\t\n\r\v\f", *ppch ) ) *ppch = ' '; ppch++; } /* Run select */ rs = PyRun_String(buf, Py_eval_input, pdict, pdict); g_free(buf); if (rs) { return ConvertPythonToRowset(rs); } else { PyErr_Print(); return NULL; } }
__declspec(dllexport) __stdcall char * _ExPyEval(const char *cmd, int stoken) { PyGILState_STATE state; PyObject *m=NULL, *d=NULL; check_init(); state = PyGILState_Ensure(); m = PyImport_ImportModule("__main__"); if (m) d = PyModule_GetDict(m); if (d) { PyObject *res = PyRun_String(cmd, stoken, d, d); if (! res) { PyErr_Print(); } char *rres=PyString_AsString(PyObject_Str(res)); /* Note that the count of the PyObject_Str object is not decremented here*/ Py_XDECREF(res); Py_XDECREF(m); return rres; } else { SystemError(1, "could not import __main__"); } return NULL; }
void SceneDeserializer::deserializeDatum(QJsonObject in, Node* node, Info* info) { // Lazy initialization of globals dictionary static PyObject* globals = NULL; if (!globals) { globals = Py_BuildValue("{sO}", "__builtins__", PyEval_GetBuiltins()); PyDict_SetItemString(globals, "_fabtypes", PyImport_ImportModule("_fabtypes")); } // Evaluate the type string in the Python interpreter, // getting a type object out. auto t = PyRun_String( in["type"].toString().toStdString().c_str(), Py_eval_input, globals, globals); Q_ASSERT(t); Q_ASSERT(PyType_Check(t)); auto datum = new Datum(in["name"].toString().toStdString(), in["uid"].toDouble(), in["expr"].toString().toStdString(), (PyTypeObject*)t, node); if (info && in.contains("subdatum")) { auto i = in["subdatum"].toArray(); info->frames.subdatum[datum] = QPointF(i[0].toDouble(), i[1].toDouble()); } }
void init_interpreter(void) { PyObject *code_executed; #ifdef READLINE rl_initialize(); (char*(*)(const char*, int))rl_completion_entry_function = (char*(*)(const char*, int))rl_python_completion_function; #endif Py_Initialize(); interpreter_state = (InterpreterState *)malloc(sizeof(InterpreterState)); // Get the main dictionary interpreter_state->main_module = PyImport_AddModule("__main__"); interpreter_state->main_dict = PyModule_GetDict( interpreter_state->main_module); code_executed = PyRun_String( interpreter_initialization_code, Py_file_input, interpreter_state->main_dict, NULL); interpreter_state->capture_stdout = PyMapping_GetItemString( interpreter_state->main_dict, "capture_stdout"); interpreter_state->capture_stderr = PyMapping_GetItemString( interpreter_state->main_dict, "capture_stderr"); Py_DECREF(code_executed); return; }
void PythonEngine::deleteUserModules() { // delete all user modules // // When working with Python scripts interactively, one must keep in mind that Python // import a module from its source code (on disk) only when parsing the first corresponding // import statement. During this first import, the byte code is generated (.pyc file) // if necessary and the imported module code object is cached in sys.modules. Then, when // re-importing the same module, this cached code object will be directly used even // if the source code file (.py[w] file) has changed meanwhile. // // This behavior is sometimes unexpected when working with the Python interpreter in // interactive mode, because one must either always restart the interpreter or remove manually the .pyc // files to be sure that changes made in imported modules were taken into account. QStringList filter_name; filter_name << "pythonlab" << "agros2d" << "sys"; QList<PythonVariable> list = variableList(); foreach (PythonVariable variable, list) { if (variable.type == "module") { if (filter_name.contains(variable.name)) continue; QString exp = QString("del %1; del sys.modules[\"%1\"]").arg(variable.name); // qDebug() << exp; PyRun_String(exp.toLatin1().data(), Py_single_input, m_dict, m_dict); } } PyErr_Clear(); }
void configParserStruct::pythonParser::runString( const std::string &Program ) { std::string PrefixString; for ( std::map<std::string,std::string>::const_iterator i = ExternalVariables.begin(); i != ExternalVariables.end(); ++i ) PrefixString += i->first + " = " + i->second + "\n"; PyRun_String( ( PrefixString + Program ).c_str(), Py_file_input, castToPyObject(Dictionary), castToPyObject(Dictionary) ); }
object BOOST_PYTHON_DECL exec(str string, object global, object local) { // should be 'char const *' but older python versions don't use 'const' yet. char *s = python::extract<char *>(string); PyObject* result = PyRun_String(s, Py_file_input, global.ptr(), local.ptr()); if (!result) throw_error_already_set(); return object(detail::new_reference(result)); }
python::object LocalPythonInterpreter::execsingle(python::str code) { setupLocalNamespaceBindings(); char *s = python::extract<char *>(code); PyObject* result = PyRun_String(s, Py_single_input, m_globalNamespace.ptr(), m_localNamespace.ptr()); if (!result) python::throw_error_already_set(); return python::object(python::detail::new_reference(result)); }