bool PythonScript::exec()
{
if (isFunction) compiled = notCompiled;
if (compiled != Script::isCompiled && !compile(false))
return false;
PyObject *pyret;
beginStdoutRedirect();
if (PyCallable_Check(PyCode)) {
PyObject *empty_tuple = PyTuple_New(0);
if (!empty_tuple) {
emit_error(env()->errorMsg(), 0);
return false;
}
pyret = PyObject_Call(PyCode,empty_tuple,localDict);
Py_DECREF(empty_tuple);
} else {
pyret = PyEval_EvalCode((PyCodeObject*)PyCode, env()->globalDict(), localDict);
//pyret = PyRun_String(Code, 0, env()->globalDict(), localDict);
}
endStdoutRedirect();
if (pyret) {
Py_DECREF(pyret);
return true;
}
emit_error(env()->errorMsg(), 0);
return false;
}
PyObject *
PyImport_ExecCodeModule(char *name, PyObject *co)
{
LOG("> PyImport_ExecCodeModule\n");
{
PyObject *m, *d, *v;
m = PyImport_AddModule(name);
if (m == NULL)
return NULL;
d = PyModule_GetDict(m);
if (PyDict_GetItemString(d, "__builtins__") == NULL) {
if (PyDict_SetItemString(d, "__builtins__", PyEval_GetBuiltins()) != 0) {
return NULL;
}
}
v = PyEval_EvalCode((PyCodeObject *)co, d, d);
if (v == NULL)
return NULL;
Py_DECREF(v);
LOG("< PyImport_ExecCodeModule\n");
return m;
}
}
void PyRun::trigger(const Eref& e, double input)
{
if (!runcompiled_){
return;
}
if (mode_ == 1){
return;
}
PyObject * value = PyDict_GetItemString(locals_, inputvar_.c_str());
if (value){
Py_DECREF(value);
}
value = PyFloat_FromDouble(input);
if (!value && PyErr_Occurred()){
PyErr_Print();
}
if (PyDict_SetItemString(locals_, inputvar_.c_str(), value)){
PyErr_Print();
}
PyEval_EvalCode(runcompiled_, globals_, locals_);
if (PyErr_Occurred()){
PyErr_Print ();
}
value = PyDict_GetItemString(locals_, outputvar_.c_str());
if (value){
double output = PyFloat_AsDouble(value);
if (PyErr_Occurred()){
PyErr_Print ();
} else {
outputOut()->send(e, output);
}
}
}
/**
* Add a Python variable of the workspace name
* to the current scope
* @param wsName The name of the workspace
* @param ws The ws ptr (unused)
*/
void PythonScript::addPythonReference(const std::string& wsName,const Mantid::API::Workspace_sptr ws)
{
UNUSED_ARG(ws);
// Compile a code object
const size_t length = wsName.length() * 2 + 10;
char * code = new char[length + 1];
const char * name = wsName.c_str();
sprintf(code, "%s = mtd['%s']", name, name);
PyObject *codeObj = Py_CompileString(code, "PythonScript::addPythonReference", Py_file_input);
if( codeObj )
{
PyObject *ret = PyEval_EvalCode((PyCodeObject*)codeObj,localDict, localDict);
Py_XDECREF(ret);
}
if( PyErr_Occurred() )
{
PyErr_Clear();
}
else
{
// Keep track of it
m_workspaceHandles.insert(m_workspaceHandles.end(), wsName);
}
Py_XDECREF(codeObj);
delete [] code;
}
void run_code(PyObject *code, PyObject *dict, const char *locale) {
if(script_loop_depth >= MAX_LOOP_DEPTH) {
// should we flag some sort of error, here?
//***********
// FINISH ME
//***********
script_ok = FALSE;
}
else {
listPush(locale_stack, strdupsafe(locale));
// try executing the code
script_ok = TRUE;
script_loop_depth++;
PyObject *retval = PyEval_EvalCode((PyCodeObject *)code, dict, dict);
script_loop_depth--;
// did we throw an error?
if(retval == NULL && PyErr_Occurred() != PyExc_SystemExit)
script_ok = FALSE;
// garbage collection
free(listPop(locale_stack));
Py_XDECREF(retval);
}
}
static void cmd_exec(const char *data)
{
PyObject *co;
PyObject *ret;
PyObject *d;
PyObject *m;
char *cmd;
if (!*data)
cmd_return_error(CMDERR_NOT_ENOUGH_PARAMS);
cmd = g_strconcat(data, "\n", NULL);
m = PyImport_AddModule("__main__");
if (!m)
goto error;
d = PyModule_GetDict(m);
if (!d)
goto error;
co = Py_CompileString(cmd, "<stdin>", Py_single_input);
if (!co)
goto error;
ret = PyEval_EvalCode((PyCodeObject *)co, d, d);
Py_DECREF(co);
Py_XDECREF(ret);
error:
g_free(cmd);
if (PyErr_Occurred())
PyErr_Print();
}
FB::variant PyHelloWorldAPI::hello_py()
{
PyObject* src = Py_CompileString("result = 'hello js!'", "hello_world.py", Py_single_input);
std::string result_str;
if (src != 0) /* compiled just fine - */
{
PyObject* locals = PyDict_New ();
PyObject* py_eval;
PyObject* py_result;
py_eval = PyEval_EvalCode((PyCodeObject *)src, globals, locals);
PyObject* res_key = PyString_FromString("result");
py_result = PyDict_GetItem(locals, res_key);
PyObject* py_str = PyObject_Str(py_result);
result_str = __convert_py_to_string(py_str);
Py_XDECREF(py_str);
Py_XDECREF(py_eval);
// crashes... don't know why this is not legal
//Py_XDECREF(locals);
} else {
result_str = "Compilation of python src failed.";
}
FB::variant result(result_str);
return result;
}
static PyObject *
run_pyc_file(FILE *fp, char *filename, PyObject *globals, PyObject *locals)
{
PyCodeObject *co;
PyObject *v;
long magic;
long PyImport_GetMagicNumber(void);
magic = PyMarshal_ReadLongFromFile(fp);
if (magic != PyImport_GetMagicNumber()) {
PyErr_SetString(PyExc_RuntimeError,
"Bad magic number in .pyc file");
return NULL;
}
(void) PyMarshal_ReadLongFromFile(fp);
v = PyMarshal_ReadObjectFromFile(fp);
fclose(fp);
if (v == NULL || !PyCode_Check(v)) {
Py_XDECREF(v);
PyErr_SetString(PyExc_RuntimeError,
"Bad code object in .pyc file");
return NULL;
}
co = (PyCodeObject *)v;
v = PyEval_EvalCode(co, globals, locals);
Py_DECREF(co);
return v;
}
int run_script(void)
{
int rc = 0;
/* load the code objects to execute */
PyObject *m=NULL, *d=NULL, *seq=NULL;
/* We execute then in the context of '__main__' */
m = PyImport_AddModule("__main__");
if (m) d = PyModule_GetDict(m);
if (d) seq = PyMarshal_ReadObjectFromString(pScript, numScriptBytes);
if (seq) {
Py_ssize_t i, max = PySequence_Length(seq);
for (i=0;i<max;i++) {
PyObject *sub = PySequence_GetItem(seq, i);
if (sub /*&& PyCode_Check(sub) */) {
PyObject *discard = PyEval_EvalCode((PyCodeObject *)sub,
d, d);
if (!discard) {
PyErr_Print();
rc = 255;
}
Py_XDECREF(discard);
/* keep going even if we fail */
}
Py_XDECREF(sub);
}
}
return rc;
}
static PyObject* runPythonFile(FILE* fp, char* pathname) {
PyCodeObject *co = parse_source_module(pathname, fp);
if (co == NULL)
return NULL;
//PyObject *m = PyImport_ExecCodeModuleEx("<pyinjected module>", (PyObject *)co, pathname);
PyObject *globals = PyDict_New();
if (PyDict_SetItemString(globals, "__builtins__",
PyEval_GetBuiltins()) != 0)
return NULL;
if (PyDict_SetItemString(globals, "__file__",
PyString_FromString(pathname)) != 0)
return NULL;
PyObject* v = PyEval_EvalCode((PyObject *)co, globals, globals);
Py_DECREF(globals);
Py_DECREF(co);
//return m;
return v;
}
//-----------------------------------------------------------------------------
// ExecuteScript()
// Execute the script found within the file.
//-----------------------------------------------------------------------------
static int ExecuteScript(
const char *fileName) // name of file containing Python code
{
PyObject *importer, *dict, *code, *temp;
if (SetExecutableName(fileName) < 0)
return -1;
if (SetPathToSearch() < 0)
return -1;
importer = NULL;
if (GetImporter(&importer) < 0)
return -1;
// create and populate dictionary for initscript module
dict = PyDict_New();
if (PopulateInitScriptDict(dict) < 0) {
Py_XDECREF(dict);
Py_DECREF(importer);
return -1;
}
// locate and execute script
code = PyObject_CallMethod(importer, "get_code", "s", "cx_Freeze__init__");
Py_DECREF(importer);
if (!code)
return FatalError("unable to locate initialization module");
temp = PyEval_EvalCode( (EvalCodeType*) code, dict, dict);
Py_DECREF(code);
Py_DECREF(dict);
if (!temp)
return FatalScriptError();
Py_DECREF(temp);
return 0;
}
void mat_eval_compiled_code(PyObject *code_obj, int parse_mode)
{
PyObject *code_executed;
DEBUG("eval_code: running PyEval_EvalCode")
// Evaluate the code.
code_executed = (PyObject *)PyEval_EvalCode(
(PyCodeObject *)code_obj,
interpreter_state->main_dict,
interpreter_state->main_dict);
if(!code_executed) {
DEBUG("eval_code: PyEval_EvalCode failed")
handle_error();
return;
}
DEBUG("eval_code: code executed")
DEBUG("eval_code: showing output")
if(parse_mode==Py_eval_input) {
// If the mode is Py_eval_input and the code evaluated
// successfully, an expression has been executed and the
// resulting value is the returned Python object.
// The interpreter will output a string representation of
// the object.
DEBUG("eval_code: showing repr")
python_to_mathematica_object(code_executed);
// Mathematica can only receive in one stream (no separate way of
// feeding stderr/stdour messages). If an object is returned, then
// any text printed, which would be otherwise returned as a string,
// is discarded.
flush_std(interpreter_state->capture_stdout);
// Free unneeded object.
Py_DECREF(code_executed);
return;
} else {
// Otherwise, the code evaluated was one or more statements
// which do not return a value, if any output has been
// produced, it will be available in the Capture instance
// The output is shown by the interpreter.
DEBUG("eval_code: showing stdout")
process_std(interpreter_state->capture_stdout);
return;
}
MLPutSymbol(stdlink, "Null");
return;
}
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;
}
main() {
int i;
char *cval;
PyObject *pcode1, *pcode2, *pcode3, *presult, *pdict;
char *codestr1, *codestr2, *codestr3;
printf("embed-bytecode\n");
Py_Initialize();
codestr1 = "import usermod\nprint usermod.message"; /* statements */
codestr2 = "usermod.transform(usermod.message)"; /* expression */
codestr3 = "print '%d:%d' % (X, X ** 2),"; /* use input X */
/* make new namespace dictionary */
pdict = PyDict_New();
if (pdict == NULL) return -1;
PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins());
/* precompile strings of code to bytecode objects */
pcode1 = Py_CompileString(codestr1, "<embed>", Py_file_input);
pcode2 = Py_CompileString(codestr2, "<embed>", Py_eval_input);
pcode3 = Py_CompileString(codestr3, "<embed>", Py_file_input);
/* run compiled bytecode in namespace dict */
if (pcode1 && pcode2 && pcode3) {
(void) PyEval_EvalCode((PyCodeObject *)pcode1, pdict, pdict);
presult = PyEval_EvalCode((PyCodeObject *)pcode2, pdict, pdict);
PyArg_Parse(presult, "s", &cval);
printf("%s\n", cval);
Py_DECREF(presult);
/* rerun code object repeatedly */
for (i = 0; i <= 10; i++) {
PyDict_SetItemString(pdict, "X", PyInt_FromLong(i));
(void) PyEval_EvalCode((PyCodeObject *)pcode3, pdict, pdict);
}
printf("\n");
}
/* free referenced objects */
Py_XDECREF(pdict);
Py_XDECREF(pcode1);
Py_XDECREF(pcode2);
Py_XDECREF(pcode3);
}
/**
* Executes the compiled code object. If NULL nothing happens
* @param compiledCode An object that has been compiled from a code fragment
* @return The result python object
*/
PyObject* PythonScript::executeCompiledCode(PyObject *compiledCode)
{
PyObject *result(NULL);
if(!compiledCode) return result;
InstallTrace traceInstall(*this);
beginStdoutRedirect();
result = PyEval_EvalCode((PyCodeObject*)compiledCode, localDict, localDict);
endStdoutRedirect();
return result;
}
void PyRun::reinit(const Eref& e, ProcPtr p)
{
PyObject * main_module;
if (globals_ == NULL){
main_module = PyImport_AddModule("__main__");
globals_ = PyModule_GetDict(main_module);
Py_XINCREF(globals_);
}
if (locals_ == NULL){
locals_ = PyDict_New();
if (!locals_){
cerr << "Could not initialize locals dict" << endl;
}
}
initcompiled_ = (PyCodeObject*)Py_CompileString(
initstr_.c_str(),
Py_GetProgramName(),
Py_file_input);
if (!initcompiled_){
cerr << "Error compiling initString" << endl;
handleError(true);
} else {
PyEval_EvalCode(initcompiled_, globals_, locals_);
if (PyErr_Occurred()){
PyErr_Print ();
}
}
runcompiled_ = (PyCodeObject*)Py_CompileString(
runstr_.c_str(),
Py_GetProgramName(),
Py_file_input);
if (!runcompiled_){
cerr << "Error compiling runString" << endl;
handleError(true);
} else {
PyEval_EvalCode(runcompiled_, globals_, locals_);
if (PyErr_Occurred()){
PyErr_Print ();
}
}
}
/// The normal PyRun_String method does not allow a filename to
/// be passed along for better error messages and trace backs.
/// This function does the same as PyRun_String but
/// also takes the filename where the string originated from.
inline PyObject *PyRun_StringFilename( const char *str,
const char *filename,
int start,
PyObject *globals,
PyObject *locals) {
PyCodeObject *co = (PyCodeObject *)Py_CompileString(str, filename, start);
if (co == NULL)
return NULL;
PyObject *v = PyEval_EvalCode(co, globals, locals);
Py_DECREF(co);
return v;
}
/* execute Python code, propagate Python errors to the backend */
static PyObject *
PLy_procedure_call(PLyProcedure *proc, const char *kargs, PyObject *vargs)
{
PyObject *rv;
int volatile save_subxact_level = list_length(explicit_subtransactions);
PyDict_SetItemString(proc->globals, kargs, vargs);
PG_TRY();
{
#if PY_VERSION_HEX >= 0x03020000
rv = PyEval_EvalCode(proc->code,
proc->globals, proc->globals);
#else
rv = PyEval_EvalCode((PyCodeObject *) proc->code,
proc->globals, proc->globals);
#endif
/*
* Since plpy will only let you close subtransactions that you
* started, you cannot *unnest* subtransactions, only *nest* them
* without closing.
*/
Assert(list_length(explicit_subtransactions) >= save_subxact_level);
}
PG_CATCH();
{
PLy_abort_open_subtransactions(save_subxact_level);
PG_RE_THROW();
}
PG_END_TRY();
PLy_abort_open_subtransactions(save_subxact_level);
/* If the Python code returned an error, propagate it */
if (rv == NULL)
PLy_elog(ERROR, NULL);
return rv;
}
static PyObject*
create_module(char *name, PyObject *co)
{
PyObject *m;
PyObject *d;
PyObject *v;
PyObject *err;
assert(name);
assert(co);
/*创建一个新的模块*/
m = PyModule_New(name);
if(m == NULL)
{
Ps_Log("create new module failed\n", Ps_LOG_WARING);
return NULL;
}
/*初始化这个新的模块*/
d = PyModule_GetDict(m);
if(PyDict_SetItemString(d, "__builtins__", PyEval_GetBuiltins()) != 0)
{
Ps_Log("Set new module builtin failed\n", Ps_LOG_WARING);
PyErr_SetString(PyExc_ImportError, "Cannot get builtin dict");
goto error;
}
v= ((PyCodeObject*)co)->co_filename;
Py_INCREF(v);
if(PyDict_SetItemString(d, "__file__", v) != 0)
PyErr_Clear();
Py_DECREF(v);
#ifdef IMPORT_DEBUG
Ps_Log("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n", Ps_LOG_NORMAL);
//Ps_LogObject(d, Ps_LOG_NORMAL);
Ps_Log("$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n", Ps_LOG_NORMAL);
#endif
/*执行字节码*/
v = PyEval_EvalCode((PyCodeObject*)co, d, d);
if(v == NULL || (err = PyErr_Occurred()))
{
Ps_LogObject(d, Ps_LOG_WARING);
Ps_Log("PyEval_EvalCode failed\n", Ps_LOG_WARING);
return NULL;
//goto error;
}
Py_XDECREF(v);
Py_INCREF(m);
return m;
error:
Py_DECREF(m);
return NULL;
}
static PyObject *
run_node(node *n, char *filename, PyObject *globals, PyObject *locals)
{
PyCodeObject *co;
PyObject *v;
co = PyNode_Compile(n, filename);
PyNode_Free(n);
if (co == NULL)
return NULL;
v = PyEval_EvalCode(co, globals, locals);
Py_DECREF(co);
return v;
}
static PyObject *
run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,
PyCompilerFlags *flags, PyArena *arena)
{
PyCodeObject *co;
PyObject *v;
co = PyAST_Compile(mod, filename, flags, arena);
if (co == NULL)
return NULL;
v = PyEval_EvalCode(co, globals, locals);
Py_DECREF(co);
return v;
}
static PyObject *
run_mod(mod_ty mod, const char *filename, PyObject *globals, PyObject *locals,
PyCompilerFlags *flags, PyArena *arena)
{
STACKLESS_GETARG();
PyCodeObject *co;
PyObject *v;
co = PyAST_Compile(mod, filename, flags, arena);
if (co == NULL)
return NULL;
STACKLESS_PROMOTE_ALL();
v = PyEval_EvalCode(co, globals, locals);
STACKLESS_ASSERT();
Py_DECREF(co);
return v;
}
//! evaluates code, using argDict (borrowed reference) as local dictionary or an empty one if argDict==NULL
//! name is the filename Python uses when reporting errors
//! returns a new reference; NULL means caller has to do exception handling
PyObject *PythonScripting::eval(const QString &code, PyObject *argDict, const char *name)
{
PyObject *args;
if (argDict)
{
Py_INCREF(argDict);
args = argDict;
} else
args = PyDict_New();
PyObject *ret=NULL;
PyObject *co = Py_CompileString(code.ascii(), name, Py_eval_input);
if (co)
{
ret = PyEval_EvalCode((PyCodeObject*)co, globals, args);
Py_DECREF(co);
}
Py_DECREF(args);
return ret;
}
ScriptResult PythonEngine::runPythonScript(const QString &script, const QString &fileName)
{
m_isRunning = true;
m_stdOut = "";
QSettings settings;
// enable user module deleter
if (settings.value("PythonEngine/UserModuleDeleter", true).toBool())
deleteUserModules();
runPythonHeader();
PyObject *output = NULL;
if (QFile::exists(fileName))
{
QString str = QString("from os import chdir; chdir(u'" + QFileInfo(fileName).absolutePath() + "')");
PyRun_String(str.toStdString().c_str(), Py_single_input, m_dict, m_dict);
}
// compile
PyObject *code = Py_CompileString(script.toStdString().c_str(), fileName.toStdString().c_str(), Py_file_input);
// run
if (code) output = PyEval_EvalCode((PyCodeObject *) code, m_dict, m_dict);
ScriptResult scriptResult;
if (output)
{
scriptResult.isError = false;
scriptResult.text = m_stdOut.trimmed();
}
else
{
scriptResult = parseError();
}
Py_XDECREF(output);
m_isRunning = false;
emit executedScript();
return scriptResult;
}
//! executes code, using argDict (borrowed reference) as local dictionary or an empty one if argDict==NULL
//! name is the filename Python uses when reporting errors
//! a false return value means caller has to do exception handling
bool PythonScripting::exec (const QString &code, PyObject *argDict, const char *name)
{
PyObject *args;
if (argDict)
{
Py_INCREF(argDict);
args = argDict;
} else
args = PyDict_New();
PyObject *tmp = NULL;
PyObject *co = Py_CompileString(code.ascii(), name, Py_file_input);
if (co)
{
tmp = PyEval_EvalCode((PyCodeObject*)co, globals, args);
Py_DECREF(co);
}
Py_DECREF(args);
if (!tmp) return false;
Py_DECREF(tmp);
return true;
}
static PyObject *
run_eval_code_obj(PyCodeObject *co, PyObject *globals, PyObject *locals)
{
PyObject *v;
/*
* We explicitly re-initialize _Py_UnhandledKeyboardInterrupt every eval
* _just in case_ someone is calling into an embedded Python where they
* don't care about an uncaught KeyboardInterrupt exception (why didn't they
* leave config.install_signal_handlers set to 0?!?) but then later call
* Py_Main() itself (which _checks_ this flag and dies with a signal after
* its interpreter exits). We don't want a previous embedded interpreter's
* uncaught exception to trigger an unexplained signal exit from a future
* Py_Main() based one.
*/
_Py_UnhandledKeyboardInterrupt = 0;
v = PyEval_EvalCode((PyObject*)co, globals, locals);
if (!v && PyErr_Occurred() == PyExc_KeyboardInterrupt) {
_Py_UnhandledKeyboardInterrupt = 1;
}
return v;
}
int
PP_Run_Bytecode(PyObject *codeobj, /* run compiled bytecode object */
const char *modname, /* in named module's namespace */
const char *resfmt, void *restarget)
{
PyObject *presult, *module, *dict;
if (! PyCode_Check(codeobj)) /* make sure it's bytecode */
return -1;
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;
if (PP_DEBUG)
presult = PP_Debug_Bytecode(codeobj, dict); /* run in pdb */
else
presult = PyEval_EvalCode((PyCodeObject *)codeobj, dict, dict);
return PP_Convert_Result(presult, resfmt, restarget); /* expr val to C */
}
void PyRun::process(const Eref & e, ProcPtr p)
{
// PyRun_String(runstr_.c_str(), 0, globals_, locals_);
// PyRun_SimpleString(runstr_.c_str());
if (!runcompiled_ || mode_ == 2){
return;
}
PyEval_EvalCode(runcompiled_, globals_, locals_);
if (PyErr_Occurred()){
PyErr_Print ();
}
PyObject * value = PyDict_GetItemString(locals_, outputvar_.c_str());
if (value){
double output = PyFloat_AsDouble(value);
if (PyErr_Occurred()){
PyErr_Print ();
} else {
outputOut()->send(e, output);
}
}
}
virtual void fire()
{
boost::python::handle<> aHandle(
PyEval_EvalCode(
reinterpret_cast< PyCodeObject* >( theCompiledExpression.get() ),
theGlobalNamespace.ptr(), theLocalNamespace.ptr() ) );
boost::python::object aResultObject( aHandle );
// do not use extract<double> for efficiency
if( ! PyFloat_Check( aResultObject.ptr() ) )
{
THROW_EXCEPTION_INSIDE( SimulationError,
asString() + ": "
"The expression gave a non-float object." );
}
const Real aFlux( PyFloat_AS_DOUBLE( aResultObject.ptr() ) );
setFlux( aFlux );
}
bool PythonScript::run(bool outputInfo) {
if (isCompileNeeded_ && !compile(outputInfo)) {
LogError("Failed to run script, script could not be compiled");
return false;
}
ivwAssert(byteCode_ != nullptr, "No byte code");
if (outputInfo) LogInfo("Running compiled script ...");
auto m = PyImport_AddModule("__main__");
if (m == NULL) return false;
auto d = PyModule_GetDict(m);
PyObject* copy = PyDict_Copy(d);
PyObject* ret = PyEval_EvalCode(BYTE_CODE, copy, copy);
bool success = checkRuntimeError();
Py_XDECREF(ret);
Py_XDECREF(copy);
return success;
}