int VetteData_get_year(int arg0) { ElString __vetteRunString = elStrNew(); int retVal; vette_assertInitialized(); elStrAppendString( __vetteRunString, "__vetteObj" ); elStrAppendString( __vetteRunString, " = __vetteObj" ); elStrAppendInt( __vetteRunString, arg0 ); elStrAppendString( __vetteRunString, ".get_year( " ); elStrAppendString( __vetteRunString, " )" ); if( elDEBUG ) printf( "PYTHON CALL: %s\n", elStrGet( __vetteRunString ) ); PyRun_SimpleString( elStrGet( __vetteRunString ) ); __vetteEvalModule = PyImport_AddModule( (char*)"__main__" ); __vetteEvalDict = PyModule_GetDict( __vetteEvalModule ); __vetteEvalVal = PyDict_GetItemString( __vetteEvalDict, "__vetteObj" ); if( __vetteEvalVal == NULL ) { char* elDebugVar = getenv( "EDEBUG" ); if( (elDebugVar != NULL) && (strcmp( "1", elDebugVar ) == 0) || elDEBUG ) { PyErr_Print(); } exit( 1 ); } if( __vetteEvalVal == NULL ) { retVal = 0; } else { retVal = (int)PyInt_AsLong( __vetteEvalVal ); } if( Py_FlushLine() ) { PyErr_Clear(); } elStrDestroy( __vetteRunString ); return retVal; }
int CaRun_SimpleFileExFlags(FILE* fp, const char* filename, int closeit, CaCompilerFlags* flags) { #if 0 PyObject *m, *d, *v; const char *ext; int set_file_name = 0, len, ret = -1; m = PyImport_AddModule("__main__"); if (m == NULL) return -1; Py_INCREF(m); d = PyModule_GetDict(m); if (PyDict_GetItemString(d, "__file__") == NULL) { PyObject *f = PyString_FromString(filename); if (f == NULL) goto done; if (PyDict_SetItemString(d, "__file__", f) < 0) { Py_DECREF(f); goto done; } set_file_name = 1; Py_DECREF(f); } len = strlen(filename); ext = filename + len - (len > 4 ? 4 : 0); if (maybe_pyc_file(fp, filename, ext, closeit)) { /* Try to run a pyc file. First, re-open in binary */ if (closeit) fclose(fp); if ((fp = fopen(filename, "rb")) == NULL) { fprintf(stderr, "python: Can't reopen .pyc file\n"); goto done; } /* Turn on optimization if a .pyo file is given */ if (strcmp(ext, ".pyo") == 0) Py_OptimizeFlag = 1; v = run_pyc_file(fp, filename, d, d, flags); } else { v = PyRun_FileExFlags(fp, filename, Py_file_input, d, d, closeit, flags); } if (v == NULL) { PyErr_Print(); goto done; } Py_DECREF(v); if (Py_FlushLine()) PyErr_Clear(); ret = 0; done: if (set_file_name && PyDict_DelItemString(d, "__file__")) PyErr_Clear(); Py_DECREF(m); return ret; #endif return 0; }
static PyObject* sys_displayhook(PyObject* self, PyObject* o) noexcept { PyObject* outf; // Pyston change: we currently hardcode the builtins module /* PyInterpreterState* interp = PyThreadState_GET()->interp; PyObject* modules = interp->modules; PyObject* builtins = PyDict_GetItemString(modules, "__builtin__"); if (builtins == NULL) { PyErr_SetString(PyExc_RuntimeError, "lost __builtin__"); return NULL; } */ PyObject* builtins = builtins_module; /* Print value except if None */ /* After printing, also assign to '_' */ /* Before, set '_' to None to avoid recursion */ if (o == Py_None) { Py_INCREF(Py_None); return Py_None; } if (PyObject_SetAttrString(builtins, "_", Py_None) != 0) return NULL; if (Py_FlushLine() != 0) return NULL; outf = PySys_GetObject("stdout"); if (outf == NULL) { PyErr_SetString(PyExc_RuntimeError, "lost sys.stdout"); return NULL; } if (PyFile_WriteObject(o, outf, 0) != 0) return NULL; PyFile_SoftSpace(outf, 1); if (Py_FlushLine() != 0) return NULL; if (PyObject_SetAttrString(builtins, "_", o) != 0) return NULL; Py_INCREF(Py_None); return Py_None; }
static int py_run(lua_State *L, int eval) { const char *s; char *buffer = NULL; PyObject *m, *d, *o; int ret = 0; int len; s = luaL_checkstring(L, 1); if (!s) return 0; if (!eval) { len = strlen(s)+1; buffer = (char *) malloc(len+1); if (!buffer) { luaL_error(L, "Failed allocating buffer for execution"); return 0; } strcpy(buffer, s); buffer[len-1] = '\n'; buffer[len] = '\0'; s = buffer; } m = PyImport_AddModule("__main__"); if (!m) { free(buffer); luaL_error(L, "Can't get __main__ module"); return 0; } d = PyModule_GetDict(m); o = PyRun_StringFlags(s, eval ? Py_eval_input : Py_single_input, d, d, NULL); free(buffer); if (!o) { PyErr_Print(); return 0; } if (py_convert(L, o, 0)) ret = 1; Py_DECREF(o); if (Py_FlushLine()) PyErr_Clear(); return ret; }
int PyRun_InteractiveOne(FILE *fp, char *filename) { PyObject *m, *d, *v, *w; node *n; perrdetail err; char *ps1 = "", *ps2 = ""; v = PySys_GetObject("ps1"); if (v != NULL) { v = PyObject_Str(v); if (v == NULL) PyErr_Clear(); else if (PyString_Check(v)) ps1 = PyString_AsString(v); } w = PySys_GetObject("ps2"); if (w != NULL) { w = PyObject_Str(w); if (w == NULL) PyErr_Clear(); else if (PyString_Check(w)) ps2 = PyString_AsString(w); } n = PyParser_ParseFile(fp, filename, &_PyParser_Grammar, Py_single_input, ps1, ps2, &err); Py_XDECREF(v); Py_XDECREF(w); if (n == NULL) { if (err.error == E_EOF) { if (err.text) PyMem_DEL(err.text); return E_EOF; } err_input(&err); PyErr_Print(); return err.error; } m = PyImport_AddModule("__main__"); if (m == NULL) return -1; d = PyModule_GetDict(m); v = run_node(n, filename, d, d); if (v == NULL) { PyErr_Print(); return -1; } Py_DECREF(v); if (Py_FlushLine()) PyErr_Clear(); return 0; }
int PyRun_SimpleString(char *command) { PyObject *m, *d, *v; m = PyImport_AddModule("__main__"); if (m == NULL) return -1; d = PyModule_GetDict(m); v = PyRun_String(command, Py_file_input, d, d); if (v == NULL) { PyErr_Print(); return -1; } Py_DECREF(v); if (Py_FlushLine()) PyErr_Clear(); return 0; }
static int py_run(lua_State *L, int eval) { const char *s; char *buffer = NULL; PyObject *m, *d, *o; Conversion ret; size_t len; s = luaL_check_string(L, 1); if (!s) return 0; if (!eval) { len = strlen(s) + 1; buffer = (char *) malloc(len + 1); if (!buffer) { lua_error(L, "Failed allocating buffer for execution"); } strcpy(buffer, s); buffer[len - 1] = '\n'; buffer[len] = '\0'; s = buffer; } m = PyImport_AddModule("__main__"); if (!m) { free(buffer); lua_error(L, "Can't get __main__ module"); } d = PyModule_GetDict(m); o = PyRun_StringFlags(s, eval ? Py_eval_input : Py_single_input, d, d, NULL); free(buffer); if (!o) { lua_new_error(L, "run custom code"); return 0; } if ((ret = py_convert(L, o)) == CONVERTED) { Py_DECREF(o); } #if PY_MAJOR_VERSION < 3 if (Py_FlushLine()) #endif PyErr_Clear(); return ret; }
static void handle_system_exit(void) { PyObject *exception, *value, *tb; int exitcode = 0; PyErr_Fetch(&exception, &value, &tb); if (Py_FlushLine()) PyErr_Clear(); fflush(stdout); if (value == NULL || value == Py_None) goto done; if (PyExceptionInstance_Check(value)) { /* The error code should be in the `code' attribute. */ PyObject *code = PyObject_GetAttrString(value, "code"); if (code) { Py_DECREF(value); value = code; if (value == Py_None) goto done; } /* If we failed to dig out the 'code' attribute, just let the else clause below print the error. */ } if (PyInt_Check(value)) exitcode = (int)PyInt_AsLong(value); else { PyObject_Print(value, stderr, Py_PRINT_RAW); PySys_WriteStderr("\n"); exitcode = 1; } done: /* Restore and clear the exception info, in order to properly decref * the exception, value, and traceback. If we just exit instead, * these leak, which confuses PYTHONDUMPREFS output, and may prevent * some finalizers from running. */ PyErr_Restore(exception, value, tb); PyErr_Clear(); Py_Exit(exitcode); /* NOTREACHED */ }
int CaRun_SimpleStringFlags(const char* command, CaCompilerFlags* flags) { #if 0 PyObject *m, *d, *v; m = PyImport_AddModule("__main__"); if (m == NULL) return -1; d = PyModule_GetDict(m); v = PyRun_StringFlags(command, Py_file_input, d, d, flags); if (v == NULL) { PyErr_Print(); return -1; } Py_DECREF(v); if (Py_FlushLine()) PyErr_Clear(); return 0; #endif return 0; }
int PyRun_SimpleFileEx(FILE *fp, char *filename, int closeit) { PyObject *m, *d, *v; char *ext; m = PyImport_AddModule("__main__"); if (m == NULL) return -1; d = PyModule_GetDict(m); ext = filename + strlen(filename) - 4; if (strcmp(ext, ".pyc") == 0 || strcmp(ext, ".pyo") == 0 #ifdef macintosh /* On a mac, we also assume a pyc file for types 'PYC ' and 'APPL' */ || PyMac_getfiletype(filename) == 'PYC ' || PyMac_getfiletype(filename) == 'APPL' #endif /* macintosh */ ) { /* Try to run a pyc file. First, re-open in binary */ if (closeit) fclose(fp); if( (fp = fopen(filename, "rb")) == NULL ) { fprintf(stderr, "python: Can't reopen .pyc file\n"); return -1; } /* Turn on optimization if a .pyo file is given */ if (strcmp(ext, ".pyo") == 0) Py_OptimizeFlag = 1; v = run_pyc_file(fp, filename, d, d); } else { v = PyRun_FileEx(fp, filename, Py_file_input, d, d, closeit); } if (v == NULL) { PyErr_Print(); return -1; } Py_DECREF(v); if (Py_FlushLine()) PyErr_Clear(); return 0; }
static void call_sys_exitfunc(void) { PyObject *exitfunc = PySys_GetObject("exitfunc"); if (exitfunc) { PyObject *res, *f; Py_INCREF(exitfunc); PySys_SetObject("exitfunc", (PyObject *)NULL); f = PySys_GetObject("stderr"); res = PyEval_CallObject(exitfunc, (PyObject *)NULL); if (res == NULL) { if (f) PyFile_WriteString("Error in sys.exitfunc:\n", f); PyErr_Print(); } Py_DECREF(exitfunc); } if (Py_FlushLine()) PyErr_Clear(); }
static void call_sys_exitfunc(void) { PyObject *exitfunc = PySys_GetObject("exitfunc"); if (exitfunc) { PyObject *res; Py_INCREF(exitfunc); PySys_SetObject("exitfunc", (PyObject *)NULL); res = PyEval_CallObject(exitfunc, (PyObject *)NULL); if (res == NULL) { if (!PyErr_ExceptionMatches(PyExc_SystemExit)) { PySys_WriteStderr("Error in sys.exitfunc:\n"); } PyErr_Print(); } Py_DECREF(exitfunc); } if (Py_FlushLine()) PyErr_Clear(); }
rpmRC rpmpythonRun(rpmpython python, const char * str, const char ** resultp) { rpmRC rc = RPMRC_FAIL; if (_rpmpython_debug) fprintf(stderr, "==> %s(%p,%s,%p)\n", __FUNCTION__, python, str, resultp); if (python == NULL) python = rpmpythonI(); if (str != NULL) { const char * val = rpmpythonSlurp(str); #if defined(WITH_PYTHONEMBED) PyCompilerFlags cf = { .cf_flags = 0 }; PyObject * m = PyImport_AddModule("__main__"); PyObject * d = (m ? PyModule_GetDict(m) : NULL); PyObject * v = (m ? PyRun_StringFlags(val, Py_file_input, d, d, &cf) : NULL); if (v == NULL) { PyErr_Print(); } else { if (resultp != NULL) { PyObject * sys_stdout = PySys_GetObject("stdout"); if (sys_stdout != NULL && PycStringIO_OutputCheck(sys_stdout)) { PyObject * o = (*PycStringIO->cgetvalue)(sys_stdout); *resultp = (PyString_Check(o) ? PyString_AsString(o) : ""); } else *resultp = ""; } Py_DECREF(v); if (Py_FlushLine()) PyErr_Clear(); rc = RPMRC_OK; } #endif val = _free(val); } return rc; }
// This function is expanded out from the Python library function // PyRun_SimpleStringFlags(). We do this so we can tell the difference, // and fail in the case of a parse error in the code text. The unit tests // do contain code which should fail, but never any code that fails because // it won't parse. int CyPyRun_SimpleString(const char * command, PyObject * exception) { PyCompilerFlags *flags = NULL; PyObject * m = PyImport_AddModule("__main__"); if (m == NULL) return -1; PyObject * d = PyModule_GetDict(m); // v = PyRun_StringFlags(command, Py_file_input, d, d, flags); PyArena *arena = PyArena_New(); if (arena == NULL) return -1; mod_ty mod = PyParser_ASTFromString(command, "<string>", Py_file_input, flags, arena); if (mod == NULL) { PyArena_Free(arena); PyErr_Print(); return -2; } PyObject *ret = run_mod(mod, "<string>", d, d, flags, arena); PyArena_Free(arena); if (ret == NULL) { int errcode = -1; if (exception != 0) { if (PyErr_ExceptionMatches(exception)) { errcode = -3; } } PyErr_Print(); return errcode; } Py_DECREF(ret); if (Py_FlushLine()) PyErr_Clear(); return 0; }
static int eval_python_command (const char *command) { PyObject *m, *d, *v; m = PyImport_AddModule ("__main__"); if (m == NULL) return -1; d = PyModule_GetDict (m); if (d == NULL) return -1; v = PyRun_StringFlags (command, Py_single_input, d, d, NULL); if (v == NULL) return -1; Py_DECREF (v); #ifndef IS_PY3K if (Py_FlushLine ()) PyErr_Clear (); #endif return 0; }
void PyErr_PrintEx(int set_sys_last_vars) { PyObject *exception, *v, *tb, *hook; if (PyErr_ExceptionMatches(PyExc_SystemExit)) { handle_system_exit(); } PyErr_Fetch(&exception, &v, &tb); if (exception == NULL) return; PyErr_NormalizeException(&exception, &v, &tb); if (exception == NULL) return; /* Now we know v != NULL too */ if (set_sys_last_vars) { PySys_SetObject("last_type", exception); PySys_SetObject("last_value", v); PySys_SetObject("last_traceback", tb); } hook = PySys_GetObject("excepthook"); if (hook) { PyObject *args = PyTuple_Pack(3, exception, v, tb ? tb : Py_None); PyObject *result = PyEval_CallObject(hook, args); if (result == NULL) { PyObject *exception2, *v2, *tb2; if (PyErr_ExceptionMatches(PyExc_SystemExit)) { handle_system_exit(); } PyErr_Fetch(&exception2, &v2, &tb2); PyErr_NormalizeException(&exception2, &v2, &tb2); /* It should not be possible for exception2 or v2 to be NULL. However PyErr_Display() can't tolerate NULLs, so just be safe. */ if (exception2 == NULL) { exception2 = Py_None; Py_INCREF(exception2); } if (v2 == NULL) { v2 = Py_None; Py_INCREF(v2); } if (Py_FlushLine()) PyErr_Clear(); fflush(stdout); PySys_WriteStderr("Error in sys.excepthook:\n"); PyErr_Display(exception2, v2, tb2); PySys_WriteStderr("\nOriginal exception was:\n"); PyErr_Display(exception, v, tb); Py_DECREF(exception2); Py_DECREF(v2); Py_XDECREF(tb2); } Py_XDECREF(result); Py_XDECREF(args); } else { PySys_WriteStderr("sys.excepthook is missing\n"); PyErr_Display(exception, v, tb); } Py_XDECREF(exception); Py_XDECREF(v); Py_XDECREF(tb); }
void PyErr_PrintEx(int set_sys_last_vars) { int err = 0; PyObject *exception, *v, *tb, *f; PyErr_Fetch(&exception, &v, &tb); PyErr_NormalizeException(&exception, &v, &tb); if (exception == NULL) return; if (PyErr_GivenExceptionMatches(exception, PyExc_SystemExit)) { if (Py_FlushLine()) PyErr_Clear(); fflush(stdout); if (v == NULL || v == Py_None) Py_Exit(0); if (PyInstance_Check(v)) { /* we expect the error code to be store in the `code' attribute */ PyObject *code = PyObject_GetAttrString(v, "code"); if (code) { Py_DECREF(v); v = code; if (v == Py_None) Py_Exit(0); } /* if we failed to dig out the "code" attribute, then just let the else clause below print the error */ } if (PyInt_Check(v)) Py_Exit((int)PyInt_AsLong(v)); else { /* OK to use real stderr here */ PyObject_Print(v, stderr, Py_PRINT_RAW); fprintf(stderr, "\n"); Py_Exit(1); } } if (set_sys_last_vars) { PySys_SetObject("last_type", exception); PySys_SetObject("last_value", v); PySys_SetObject("last_traceback", tb); } f = PySys_GetObject("stderr"); if (f == NULL) fprintf(stderr, "lost sys.stderr\n"); else { if (Py_FlushLine()) PyErr_Clear(); fflush(stdout); err = PyTraceBack_Print(tb, f); if (err == 0 && PyErr_GivenExceptionMatches(exception, PyExc_SyntaxError)) { PyObject *message; char *filename, *text; int lineno, offset; if (!parse_syntax_error(v, &message, &filename, &lineno, &offset, &text)) PyErr_Clear(); else { char buf[10]; PyFile_WriteString(" File \"", f); if (filename == NULL) PyFile_WriteString("<string>", f); else PyFile_WriteString(filename, f); PyFile_WriteString("\", line ", f); sprintf(buf, "%d", lineno); PyFile_WriteString(buf, f); PyFile_WriteString("\n", f); if (text != NULL) { char *nl; if (offset > 0 && offset == (int)strlen(text)) offset--; for (;;) { nl = strchr(text, '\n'); if (nl == NULL || nl-text >= offset) break; offset -= (nl+1-text); text = nl+1; } while (*text == ' ' || *text == '\t') { text++; offset--; } PyFile_WriteString(" ", f); PyFile_WriteString(text, f); if (*text == '\0' || text[strlen(text)-1] != '\n') PyFile_WriteString("\n", f); PyFile_WriteString(" ", f); offset--; while (offset > 0) { PyFile_WriteString(" ", f); offset--; } PyFile_WriteString("^\n", f); } Py_INCREF(message); Py_DECREF(v); v = message; /* Can't be bothered to check all those PyFile_WriteString() calls */ if (PyErr_Occurred()) err = -1; } } if (err) { /* Don't do anything else */ } else if (PyClass_Check(exception)) { PyClassObject* exc = (PyClassObject*)exception; PyObject* className = exc->cl_name; PyObject* moduleName = PyDict_GetItemString(exc->cl_dict, "__module__"); if (moduleName == NULL) err = PyFile_WriteString("<unknown>", f); else { char* modstr = PyString_AsString(moduleName); if (modstr && strcmp(modstr, "exceptions")) { err = PyFile_WriteString(modstr, f); err += PyFile_WriteString(".", f); } } if (err == 0) { if (className == NULL) err = PyFile_WriteString("<unknown>", f); else err = PyFile_WriteObject(className, f, Py_PRINT_RAW); } } else err = PyFile_WriteObject(exception, f, Py_PRINT_RAW); if (err == 0) { if (v != NULL && v != Py_None) { PyObject *s = PyObject_Str(v); /* only print colon if the str() of the object is not the empty string */ if (s == NULL) err = -1; else if (!PyString_Check(s) || PyString_GET_SIZE(s) != 0) err = PyFile_WriteString(": ", f); if (err == 0) err = PyFile_WriteObject(s, f, Py_PRINT_RAW); Py_XDECREF(s); } } if (err == 0) err = PyFile_WriteString("\n", f); } Py_XDECREF(exception); Py_XDECREF(v); Py_XDECREF(tb); /* If an error happened here, don't show it. XXX This is wrong, but too many callers rely on this behavior. */ if (err != 0) PyErr_Clear(); }
k3d::bool_t execute(const k3d::string_t& ScriptName, const k3d::string_t& Script, context& Context, output_t* Stdout, output_t* Stderr) { k3d::bool_t succeeded = true; try { boost::scoped_ptr<k3d::python::file_signal> stdout_signal; boost::scoped_ptr<k3d::python::file_signal> stderr_signal; if(Stdout) { stdout_signal.reset(new k3d::python::file_signal()); stdout_signal->connect_output_signal(*Stdout); PySys_SetObject(const_cast<char*>("stdout"), boost::python::object(*stdout_signal).ptr()); } if(Stderr) { stderr_signal.reset(new k3d::python::file_signal()); stderr_signal->connect_output_signal(*Stderr); PySys_SetObject(const_cast<char*>("stderr"), boost::python::object(*stderr_signal).ptr()); } m_local_dict["context"] = Context; // The embedded python interpreter cannot handle DOS line-endings, see http://sourceforge.net/tracker/?group_id=5470&atid=105470&func=detail&aid=1167922 k3d::string_t script = Script; script.erase(std::remove(script.begin(), script.end(), '\r'), script.end()); PyDict_Update(m_local_dict.ptr(), PyObject_GetAttrString(PyImport_AddModule("__main__"), "__dict__")); PyObject* const result = PyRun_String(const_cast<char*>(script.c_str()), Py_file_input, m_local_dict.ptr(), m_local_dict.ptr()); if(result) { Py_DECREF(result); if(Py_FlushLine()) PyErr_Clear(); } else { PyErr_Print(); } Context = boost::python::extract<k3d::iscript_engine::context>(m_local_dict["context"])(); succeeded = result ? true : false; } catch(std::exception& e) { k3d::log() << error << k3d_file_reference << ": " << e.what() << std::endl; succeeded = false; } catch(...) { k3d::log() << error << k3d_file_reference << ": " << "Unknown exception" << std::endl; succeeded = false; } if(Stdout) PySys_SetObject(const_cast<char*>("stdout"), PySys_GetObject(const_cast<char*>("__stdout__"))); if(Stderr) PySys_SetObject(const_cast<char*>("stderr"), PySys_GetObject(const_cast<char*>("__stderr__"))); return succeeded; }
void PyErr_Display(PyObject *exception, PyObject *value, PyObject *tb) { int err = 0; PyObject *f = PySys_GetObject("stderr"); Py_INCREF(value); if (f == NULL) fprintf(stderr, "lost sys.stderr\n"); else { if (Py_FlushLine()) PyErr_Clear(); fflush(stdout); if (tb && tb != Py_None) err = PyTraceBack_Print(tb, f); if (err == 0 && PyObject_HasAttrString(value, "print_file_and_line")) { PyObject *message; const char *filename, *text; int lineno, offset; if (!parse_syntax_error(value, &message, &filename, &lineno, &offset, &text)) PyErr_Clear(); else { char buf[10]; PyFile_WriteString(" File \"", f); if (filename == NULL) PyFile_WriteString("<string>", f); else PyFile_WriteString(filename, f); PyFile_WriteString("\", line ", f); PyOS_snprintf(buf, sizeof(buf), "%d", lineno); PyFile_WriteString(buf, f); PyFile_WriteString("\n", f); if (text != NULL) print_error_text(f, offset, text); Py_DECREF(value); value = message; /* Can't be bothered to check all those PyFile_WriteString() calls */ if (PyErr_Occurred()) err = -1; } } if (err) { /* Don't do anything else */ } else if (PyExceptionClass_Check(exception)) { PyObject* moduleName; char* className = PyExceptionClass_Name(exception); if (className != NULL) { char *dot = strrchr(className, '.'); if (dot != NULL) className = dot+1; } moduleName = PyObject_GetAttrString(exception, "__module__"); if (moduleName == NULL) err = PyFile_WriteString("<unknown>", f); else { char* modstr = PyString_AsString(moduleName); if (modstr && strcmp(modstr, "exceptions")) { err = PyFile_WriteString(modstr, f); err += PyFile_WriteString(".", f); } Py_DECREF(moduleName); } if (err == 0) { if (className == NULL) err = PyFile_WriteString("<unknown>", f); else err = PyFile_WriteString(className, f); } } else err = PyFile_WriteObject(exception, f, Py_PRINT_RAW); if (err == 0 && (value != Py_None)) { PyObject *s = PyObject_Str(value); /* only print colon if the str() of the object is not the empty string */ if (s == NULL) err = -1; else if (!PyString_Check(s) || PyString_GET_SIZE(s) != 0) err = PyFile_WriteString(": ", f); if (err == 0) err = PyFile_WriteObject(s, f, Py_PRINT_RAW); Py_XDECREF(s); } if (err == 0) err = PyFile_WriteString("\n", f); } Py_DECREF(value); /* If an error happened here, don't show it. XXX This is wrong, but too many callers rely on this behavior. */ if (err != 0) PyErr_Clear(); }
int PyRun_InteractiveOneFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) { PyObject *m, *d, *v, *w; mod_ty mod; PyArena *arena; char *ps1 = "", *ps2 = ""; int errcode = 0; v = PySys_GetObject("ps1"); if (v != NULL) { v = PyObject_Str(v); if (v == NULL) PyErr_Clear(); else if (PyString_Check(v)) ps1 = PyString_AsString(v); } w = PySys_GetObject("ps2"); if (w != NULL) { w = PyObject_Str(w); if (w == NULL) PyErr_Clear(); else if (PyString_Check(w)) ps2 = PyString_AsString(w); } arena = PyArena_New(); if (arena == NULL) { Py_XDECREF(v); Py_XDECREF(w); return -1; } mod = PyParser_ASTFromFile(fp, filename, Py_single_input, ps1, ps2, flags, &errcode, arena); Py_XDECREF(v); Py_XDECREF(w); if (mod == NULL) { PyArena_Free(arena); if (errcode == E_EOF) { PyErr_Clear(); return E_EOF; } PyErr_Print(); return -1; } m = PyImport_AddModule("__main__"); if (m == NULL) { PyArena_Free(arena); return -1; } d = PyModule_GetDict(m); v = run_mod(mod, filename, d, d, flags, arena); PyArena_Free(arena); if (v == NULL) { PyErr_Print(); return -1; } Py_DECREF(v); if (Py_FlushLine()) PyErr_Clear(); return 0; }