int PyRun_InteractiveLoop(FILE *fp, char *filename) { PyObject *v; int ret; v = PySys_GetObject("ps1"); if (v == NULL) { PySys_SetObject("ps1", v = PyString_FromString(">>> ")); Py_XDECREF(v); } v = PySys_GetObject("ps2"); if (v == NULL) { PySys_SetObject("ps2", v = PyString_FromString("... ")); Py_XDECREF(v); } for (;;) { ret = PyRun_InteractiveOne(fp, filename); #ifdef Py_REF_DEBUG fprintf(stderr, "[%ld refs]\n", _Py_RefTotal); #endif if (ret == E_EOF) return 0; /* if (ret == E_NOMEM) return -1; */ } }
void PyMPI_UnrestrictedOutput(int stream) { PyObject* pyOutput = 0; PyObject* pyErrput = 0; if(stream & 0x01) { PYCHECK( pyOutput = PySys_GetObject("__stdout__")); Py_INCREF(pyOutput); PYCHECK( PySys_SetObject("stdout",pyOutput)); Py_INCREF(Py_None); PYCHECK( PyDict_SetItemString(PyMPI_dictionary,"outputQueueFile",Py_None)); } if(stream & 0x02) { PYCHECK( pyErrput = PySys_GetObject("__stderr__")); Py_INCREF(pyErrput); PYCHECK( PySys_SetObject("stderr",pyErrput)); Py_INCREF(Py_None); PYCHECK( PyDict_SetItemString(PyMPI_dictionary,"errputQueueFile",Py_None)); } /* Fall through */ pythonError: return; }
static void handle_python_admin(admin_handle h, const char * const *args, void *userdata) { char *text; PyObject *old_stdout, *old_stderr; AdminOutputObject *admin_stdout; if (args[1] == NULL) { /* Silently ignore */ return; } text = g_strjoinv(" ", (char **)args+1); old_stdout = PySys_GetObject("stdout"); old_stderr = PySys_GetObject("stderr"); admin_stdout = PyObject_New(AdminOutputObject, &AdminOutputType); admin_stdout->h = h; admin_stdout->buffer = NULL; PySys_SetObject("stdout", (PyObject *)admin_stdout); PySys_SetObject("stderr", (PyObject *)admin_stdout); PyRun_SimpleString(text); g_free(text); PySys_SetObject("stdout", old_stdout); PySys_SetObject("stderr", old_stderr); Py_DECREF(admin_stdout); }
int PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags) { PyObject *v; int ret; PyCompilerFlags local_flags; if (flags == NULL) { flags = &local_flags; local_flags.cf_flags = 0; } v = PySys_GetObject("ps1"); if (v == NULL) { PySys_SetObject("ps1", v = PyString_FromString(">>> ")); Py_XDECREF(v); } v = PySys_GetObject("ps2"); if (v == NULL) { PySys_SetObject("ps2", v = PyString_FromString("... ")); Py_XDECREF(v); } for (;;) { ret = PyRun_InteractiveOneFlags(fp, filename, flags); PRINT_TOTAL_REFS(); if (ret == E_EOF) return 0; /* if (ret == E_NOMEM) return -1; */ } }
int CPython::ExecCmds(const std::wstring &cmds, std::wstring &err, HANDLE hfile) { int id = 0; FILE *pfile = nullptr; DWORD count = 0; PyObject *poldout, *polderr, *pnewout, *pnewerr; if (cmds.length() <= 0) { err = text("No python command found"); return 1; } if (DuplicateHandle ( GetCurrentProcess(), hfile, GetCurrentProcess(), &hfile, 0, false, DUPLICATE_SAME_ACCESS )) { id = open_osfhandle((intptr_t)hfile, _O_WRONLY); pfile = fdopen(id,"w"); setvbuf(pfile,nullptr,_IONBF,1024); poldout = PySys_GetObject("stdout"); polderr = PySys_GetObject("stderr"); pnewout = PyFile_FromFile(pfile, "logger", "w", nullptr); pnewerr = PyFile_FromFile(pfile, "logger", "w", nullptr); PySys_SetObject("stdout", pnewout); PySys_SetObject("stderr", pnewerr); } else poldout = polderr = pnewout = pnewerr = nullptr; std::wstring_convert<std::codecvt_utf8_utf16<wchar>> cvt; std::string str = cvt.to_bytes(cmds); int irslt = PyRun_SimpleString(str.c_str()); if (irslt != 0) err = text("Internal error that PyRun_SimpleString fail"); else err = text("Execute python commands successfully .."); if (pnewout != nullptr) PySys_SetObject("stdout", poldout); if (pnewerr != nullptr) PySys_SetObject("stderr", polderr); if (pfile != nullptr) fclose(pfile); return irslt; }
PyMODINIT_FUNC TS3init(void) { PyObject *m; printf("Init TS3 module\n"); m = Py_InitModule("TS3", TS3Methods); PySys_SetObject("stdout", m); PySys_SetObject("stderr", m); }
static void initMatpyPrint(void) { PyObject *matpyPrintModule = Py_InitModule("print", matpyPrintMethods); if (NULL != matpyPrintModule) { PySys_SetObject((char*)"stdout", matpyPrintModule); PySys_SetObject((char*)"stderr", matpyPrintModule); } }
void ResetStdOut() { if (gStdOutSaved) PySys_SetObject("stdout", gStdOutSaved); if (gStdErrSaved) PySys_SetObject("stderr", gStdErrSaved); Py_XDECREF(gStdOut); gStdOut = 0; }
PyObject* ada_py_initialize_and_module(char* program_name, char* name) { PyObject* module; PyObject* imported; user_module_name = strdup(name); #if PY_MAJOR_VERSION >= 3 user_module.m_name = user_module_name; Py_SetProgramName ((wchar_t*)program_name); #else Py_SetProgramName (program_name); #endif PyImport_AppendInittab(user_module_name, init_user_module); Py_InitializeEx(0); // Initialize the prompt if needed PyObject* prompt = PySys_GetObject ("ps1"); if (prompt == NULL) { prompt = PyUnicode_FromString (">>> "); PySys_SetObject ("ps1", prompt); Py_DECREF (prompt); } prompt = PySys_GetObject ("ps2"); if (prompt == NULL) { prompt = PyUnicode_FromString ("... "); PySys_SetObject ("ps2", prompt); Py_DECREF (prompt); } // Make the user's module visible to scripts. We cannot use // PyImport_ImportModule, which imports the module but doesn't add // it to the global dictionary and as such it is not visible to // user scripts. imported = PyImport_ImportModule(name); if (imported == NULL) { printf ("Could not import module %s", name); return NULL; } // Import 'sys', which is needed for instance in Set_Default_Console // to get access to the default value PyRun_SimpleString("import sys\n"); char* command = (char*)malloc(9 + strlen(name)); strcpy (command, "import "); strcat (command, name); strcat (command, "\n"); PyRun_SimpleString(command); free (command); return imported; };
int CPython::ExecFile(const std::vector<std::wstring> &argv, std::wstring &err, HANDLE hfile) { int id = 0; FILE *pfile = nullptr; DWORD count = 0; PyObject *poldout, *polderr, *pnewout, *pnewerr; if (argv.size() <= 0) { err = text("No python script file found"); return 1; } if (DuplicateHandle ( GetCurrentProcess(), hfile, GetCurrentProcess(), &hfile, 0, false, DUPLICATE_SAME_ACCESS )) { id = open_osfhandle((intptr_t)hfile, _O_WRONLY); pfile = fdopen(id,"w"); setvbuf(pfile,nullptr,_IONBF,1024); poldout = PySys_GetObject("stdout"); polderr = PySys_GetObject("stderr"); pnewout = PyFile_FromFile(pfile, "logger", "w", nullptr); pnewerr = PyFile_FromFile(pfile, "logger", "w", nullptr); PySys_SetObject("stdout", pnewout); PySys_SetObject("stderr", pnewerr); } else poldout = polderr = pnewout = pnewerr = nullptr; // Pack up the arguments .. std::vector<char*> args; int irslt = 0; std::vector<std::wstring>::const_iterator itr, eitr; std::wstring_convert<std::codecvt_utf8_utf16<wchar>> cvt; itr = argv.cbegin(); eitr = argv.cend(); for (size_t len = 0; itr != eitr; ++itr) { // Allocate buffer each time, not good .. std::string str = cvt.to_bytes(*itr); len = str.length(); char *arg = new char[len+1]; strncpy_s(arg,len+1,str.data(),len); arg[len] = '\0'; args.push_back(arg); } PySys_SetArgv(args.size(), args.data()); // pass args . PyObject *pobj = PyFile_FromString(args.at(0), "r"); if (pobj == nullptr) { err = text("Internal error that PyFile_FromString fail"); irslt = -1; } else { PyRun_SimpleFileEx(PyFile_AsFile(pobj), args.at(0), true); err = text("Execute python script file successfully .."); irslt = 00; } // Free resource ... std::vector<char*>::iterator sitr, seitr; sitr = args.begin(); seitr = args.end(); for (sitr; sitr != seitr; ++sitr) { if (*sitr) delete [] *sitr; } args.clear(); if (pnewout != nullptr) PySys_SetObject("stdout", poldout); if (pnewerr != nullptr) PySys_SetObject("stderr", polderr); if (pfile != nullptr) fclose(pfile); return irslt; }
void SetStdout(StdOutWriteType write) { if (!gStdOut) { gStdOutSaved = PySys_GetObject("stdout"); gStdErrSaved = PySys_GetObject("stderr"); gStdOut = StdoutType.tp_new(&StdoutType, 0, 0); } StdOut *impl = reinterpret_cast<StdOut *>(gStdOut); impl->write = write; PySys_SetObject("stdout", gStdOut); PySys_SetObject("stderr", gStdOut); }
int CPython::ExecFunc(const std::vector<std::wstring> &argv, std::wstring &err, HANDLE hfile) { std::vector<std::wstring>::const_iterator itr, eitr; itr = argv.cbegin(); eitr = argv.cend(); err = *itr; if (argv.size() <= 0) { err = text("No python command function found"); return 1; } err.push_back(text('(')); for (++itr; itr != eitr; ++itr) { err.append(*itr); err.push_back(text(',')); } if (err.back() == text(',')) err.pop_back(); err.push_back(text(')')); Addtolist(1,1,text("Execute Function: %s"),err.c_str()); int id = 0; FILE *pfile = nullptr; DWORD count = 0; PyObject *poldout, *polderr, *pnewout, *pnewerr; if (DuplicateHandle ( GetCurrentProcess(), hfile, GetCurrentProcess(), &hfile, 0, false, DUPLICATE_SAME_ACCESS )) { id = open_osfhandle((intptr_t)hfile, _O_WRONLY); pfile = fdopen(id,"w"); setvbuf(pfile,nullptr,_IONBF,1024); poldout = PySys_GetObject("stdout"); polderr = PySys_GetObject("stderr"); pnewout = PyFile_FromFile(pfile, "logger", "w", nullptr); pnewerr = PyFile_FromFile(pfile, "logger", "w", nullptr); PySys_SetObject("stdout", pnewout); PySys_SetObject("stderr", pnewerr); } else poldout = polderr = pnewout = pnewerr = nullptr; std::wstring_convert<std::codecvt_utf8_utf16<wchar>> cvt; std::string str = cvt.to_bytes(err); std::size_t pos = str.find(text('.')); if (pos != std::string::npos) { std::string mod = str.substr(0, pos); PyObject* dest = PyImport_ImportModule(mod.c_str()); PyObject* main = PyImport_AddModule("__main__"); PyObject_SetAttrString(main, mod.c_str(), dest); } str.insert(0, "print "); int irslt = PyRun_SimpleString(str.c_str()); if (irslt != 0) err = text("Internal error that PyRun_SimpleString fail"); else err = text("Execute python function successfully .."); if (pnewout != nullptr) PySys_SetObject("stdout", poldout); if (pnewerr != nullptr) PySys_SetObject("stderr", polderr); if (pfile != nullptr) fclose(pfile); return irslt; }
PyObject *set_stdstream(std::string name, PyObject *pystream) { PyObject *old_pystream = PySys_GetObject(const_cast<char*>(name.c_str())); // borrowed Py_XINCREF(pystream); PySys_SetObject(const_cast<char*>(name.c_str()), pystream); Py_XDECREF(old_pystream); return old_pystream; }
bool bpy_text_compile(Text *text) { char fn_dummy[FILE_MAX]; PyObject *fn_dummy_py; char *buf; bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text); /* if previously compiled, free the object */ free_compiled_text(text); fn_dummy_py = PyC_UnicodeFromByte(fn_dummy); buf = txt_to_buf(text); text->compiled = Py_CompileStringObject(buf, fn_dummy_py, Py_file_input, NULL, -1); MEM_freeN(buf); Py_DECREF(fn_dummy_py); if (PyErr_Occurred()) { PyErr_Print(); PyErr_Clear(); PySys_SetObject("last_traceback", NULL); free_compiled_text(text); return false; } else { return true; } }
PyObject *bpy_text_import(Text *text) { char *buf = NULL; char modulename[MAX_ID_NAME + 2]; int len; if (!text->compiled) { char fn_dummy[256]; bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text); buf = txt_to_buf(text); text->compiled = Py_CompileString(buf, fn_dummy, Py_file_input); MEM_freeN(buf); if (PyErr_Occurred()) { PyErr_Print(); PyErr_Clear(); PySys_SetObject("last_traceback", NULL); free_compiled_text(text); return NULL; } } len = strlen(text->id.name + 2); BLI_strncpy(modulename, text->id.name + 2, len); modulename[len - 3] = '\0'; /* remove .py */ return PyImport_ExecCodeModule(modulename, text->compiled); }
void PyXPCOM_DLLAddRef(void) { // Must be thread-safe, although cant have the Python lock! CEnterLeaveXPCOMFramework _celf; PRInt32 cnt = PR_AtomicIncrement(&g_cLockCount); if (cnt==1) { // First call if (!Py_IsInitialized()) { Py_Initialize(); // Make sure our Windows framework is all setup. PyXPCOM_Globals_Ensure(); // Make sure we have _something_ as sys.argv. if (PySys_GetObject((char*)"argv")==NULL) { PyObject *path = PyList_New(0); #if PY_MAJOR_VERSION <= 2 PyObject *str = PyString_FromString(""); #else PyObject *str = PyUnicode_FromString(""); #endif PyList_Append(path, str); PySys_SetObject((char*)"argv", path); Py_XDECREF(path); Py_XDECREF(str); } // Must force Python to start using thread locks, as // we are free-threaded (maybe, I think, sometimes :-) PyEval_InitThreads(); #ifndef PYXPCOM_USE_PYGILSTATE // Release Python lock, as first thing we do is re-get it. ptsGlobal = PyEval_SaveThread(); #endif // NOTE: We never finalize Python!! } } }
void ssipylog_stdout_reset() { if (ssipylog_g_stdout_saved) PySys_SetObject("stdout", ssipylog_g_stdout_saved); Py_XDECREF(ssipylog_g_stdout); ssipylog_g_stdout = 0; }
PythonRedirector(const char* type, PyObject* obj) : std_out(type), out(obj), old(0) { if (out) { Base::PyGILStateLocker lock; old = PySys_GetObject(const_cast<char*>(std_out)); PySys_SetObject(const_cast<char*>(std_out), out); } }
~PythonRedirector() { if (out) { Base::PyGILStateLocker lock; PySys_SetObject(const_cast<char*>(std_out), old); Py_DECREF(out); } }
void Redirector::reset_stdout() { if (m_stdout_saved) PySys_SetObject(const_cast<char*>("stdout"), m_stdout_saved); Py_XDECREF(m_stdout); m_stdout = 0; }
/*! Starts the python interpreter */ void startPython( int argc, char* argv[] ) { Py_SetProgramName( argv[0] ); Py_NoSiteFlag = 1; // No import because we need to set the search path first Py_Initialize(); PySys_SetArgv( argc, argv ); // Modify our search-path PyObject* searchpath = PySys_GetObject( "path" ); QStringList elements = QStringList::split( ";", Config::instance()->getString( "General", "Python Searchpath", "./scripts;.", true ) ); // Prepend our items to the searchpath for ( int i = elements.count() - 1; i >= 0; --i ) { PyList_Insert( searchpath, 0, PyString_FromString( elements[i].latin1() ) ); } // Import site now PyObject* m = PyImport_ImportModule( "site" ); Py_XDECREF( m ); // Try changing the stderr + stdout pointers PyObject* file = PyFile_FromString( "python.log", "w" ); if ( file ) { Py_INCREF( file ); PySys_SetObject( "stderr", file ); Py_INCREF( file ); PySys_SetObject( "stdout", file ); Py_DECREF( file ); } try { init_wolfpack_globals(); } catch ( ... ) { Console::instance()->send( "Failed to initialize the python extension modules\n" ); } }
PyObject *bpy_text_reimport(PyObject *module, int *found) { Text *text; const char *name; char *filepath; char *buf = NULL; //XXX Main *maggie = bpy_import_main ? bpy_import_main:G.main; Main *maggie = bpy_import_main; if (!maggie) { printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n"); return NULL; } *found = 0; /* get name, filename from the module itself */ if ((name = PyModule_GetName(module)) == NULL) return NULL; if ((filepath = (char *)PyModule_GetFilename(module)) == NULL) return NULL; /* look up the text object */ text = BLI_findstring(&maggie->text, BLI_path_basename(filepath), offsetof(ID, name) + 2); /* uh-oh.... didn't find it */ if (!text) return NULL; else *found = 1; /* if previously compiled, free the object */ /* (can't see how could be NULL, but check just in case) */ if (text->compiled) { Py_DECREF((PyObject *)text->compiled); } /* compile the buffer */ buf = txt_to_buf(text); text->compiled = Py_CompileString(buf, text->id.name + 2, Py_file_input); MEM_freeN(buf); /* if compile failed.... return this error */ if (PyErr_Occurred()) { PyErr_Print(); PyErr_Clear(); PySys_SetObject("last_traceback", NULL); free_compiled_text(text); return NULL; } /* make into a module */ return PyImport_ExecCodeModule((char *)name, text->compiled); }
void AddPath(const char * path) { PyObject * pName = PyUnicode_FromString(path), *syspath; // reference to Python search path syspath = PySys_GetObject("path"); // add path to syspath if (PyList_Insert(syspath, 0, pName)) printf("Error inserting extra path into sys.path list\n"); // reset sys.path object if (PySys_SetObject("path", syspath)) printf("Error setting sys.path object\n"); }
void Redirector::set_stdout(stdout_write_type write) { if (!m_stdout) { m_stdout_saved = PySys_GetObject(const_cast<char*>("stdout")); // borrowed m_stdout = StdoutType.tp_new(&StdoutType, 0, 0); } Stdout* impl = reinterpret_cast<Stdout*>(m_stdout); impl->write = write; PySys_SetObject(const_cast<char*>("stdout"), m_stdout); }
void ssipylog_stdout_set(ssipylog_stdout_write_type write) { if (!ssipylog_g_stdout) { ssipylog_g_stdout_saved = PySys_GetObject("stdout"); // borrowed ssipylog_g_stdout = ssipylog_stdout_Type.tp_new(&ssipylog_stdout_Type, 0, 0); } ssipylog_stdout *impl = (ssipylog_stdout *)ssipylog_g_stdout; impl->write = write; PySys_SetObject("stdout", ssipylog_g_stdout); }
PythonInterpreter::PythonInterpreter(PythonOutputStream* pyStdOut, PythonOutputStream* pyStdErr) { std::lock_guard<std::mutex> lock(globalMutex); // Acquire the global interpreter lock. if (pythonInitialised) PyEval_AcquireLock(); else { PyEval_InitThreads(); Py_Initialize(); pythonInitialised = true; } // Create the new interpreter. state = Py_NewInterpreter(); // Record the main module. mainModule = PyImport_AddModule("__main__"); // Borrowed ref. mainNamespace = PyModule_GetDict(mainModule); // Borrowed ref. // Redirect stdout and stderr if appropriate. if (pyStdOut || pyStdErr) { boost::python::class_<PythonOutputStream, boost::noncopyable> ("PythonOutputStream", boost::python::no_init) .def("write", &PythonOutputStream::write) .def("flush", &PythonOutputStream::flush); boost::python::reference_existing_object:: apply<PythonOutputStream*>::type conv; if (pyStdOut) PySys_SetObject(const_cast<char*>("stdout"), conv(pyStdOut)); if (pyStdErr) PySys_SetObject(const_cast<char*>("stderr"), conv(pyStdErr)); } // Release the global interpreter lock. PyEval_SaveThread(); }
void pybase::AddToPath(const char *dir) { if(dir && *dir) { PyObject *pobj = PySys_GetObject(const_cast<char *>("path")); if(pobj && PyList_Check(pobj)) { PyObject *ps = PyString_FromString(dir); if(!PySequence_Contains(pobj,ps)) PyList_Append(pobj,ps); // makes new reference Py_DECREF(ps); } PySys_SetObject(const_cast<char *>("path"),pobj); // steals reference to pobj } }
int CPython::ExecEcho(const std::wstring &cmds, std::wstring &err, HANDLE hfile) { int id = 0; FILE *pfile = nullptr; DWORD count = 0; PyObject *poldout, *polderr, *pnewout, *pnewerr; if (cmds.length() <= 0) { err = text("No python command found"); return 1; } if (DuplicateHandle ( GetCurrentProcess(), hfile, GetCurrentProcess(), &hfile, 0, false, DUPLICATE_SAME_ACCESS )) { id = open_osfhandle((intptr_t)hfile, _O_WRONLY); pfile = fdopen(id,"w"); setvbuf(pfile,nullptr,_IONBF,1024); poldout = PySys_GetObject("stdout"); polderr = PySys_GetObject("stderr"); pnewout = PyFile_FromFile(pfile, "logger", "w", nullptr); pnewerr = PyFile_FromFile(pfile, "logger", "w", nullptr); PySys_SetObject("stdout", pnewout); PySys_SetObject("stderr", pnewerr); } else poldout = polderr = pnewout = pnewerr = nullptr; std::wstring_convert<std::codecvt_utf8_utf16<wchar>> cvt; std::string str = cvt.to_bytes(cmds); std::size_t pos = str.find(text('.')); if (pos != std::string::npos) { std::string mod = str.substr(0, pos); PyObject* dest = PyImport_ImportModule(mod.c_str()); PyObject* main = PyImport_AddModule("__main__"); PyObject_SetAttrString(main, mod.c_str(), dest); } str.insert(0, "print "); int irslt = PyRun_SimpleString(str.c_str()); if (irslt != 0) err = text("Internal error that PyRun_SimpleString fail"); else err = text("Execute python expression successfully .."); if (pnewout != nullptr) PySys_SetObject("stdout", poldout); if (pnewerr != nullptr) PySys_SetObject("stderr", polderr); if (pfile != nullptr) fclose(pfile); return irslt; }
void initialize_interpreter(const char **ENV_VARS, const char **ENV_VAR_VALS, char *PROGRAM, const char *MODULE, const char *FUNCTION, const char *PYVER, int IS_GUI, const char* exe_path, const char *rpath, int argc, const char **argv) { PyObject *pargv, *v; int i; Py_OptimizeFlag = 2; Py_NoSiteFlag = 1; Py_DontWriteBytecodeFlag = 1; Py_IgnoreEnvironmentFlag = 1; Py_NoUserSiteDirectory = 1; Py_HashRandomizationFlag = 1; //Py_VerboseFlag = 1; //Py_DebugFlag = 1; Py_SetProgramName(PROGRAM); char pyhome[1000]; snprintf(pyhome, 1000, "%s/Python", rpath); Py_SetPythonHome(pyhome); set_env_vars(ENV_VARS, ENV_VAR_VALS, exe_path); //printf("Path before Py_Initialize(): %s\r\n\n", Py_GetPath()); Py_Initialize(); char *dummy_argv[1] = {""}; PySys_SetArgv(1, dummy_argv); //printf("Path after Py_Initialize(): %s\r\n\n", Py_GetPath()); char path[3000]; snprintf(path, 3000, "%s/lib/python%s:%s/lib/python%s/lib-dynload:%s/site-packages", pyhome, PYVER, pyhome, PYVER, pyhome); PySys_SetPath(path); //printf("Path set by me: %s\r\n\n", path); PySys_SetObject("calibre_basename", PyBytes_FromString(PROGRAM)); PySys_SetObject("calibre_module", PyBytes_FromString(MODULE)); PySys_SetObject("calibre_function", PyBytes_FromString(FUNCTION)); PySys_SetObject("calibre_is_gui_app", ((IS_GUI) ? Py_True : Py_False)); PySys_SetObject("resourcepath", PyBytes_FromString(rpath)); snprintf(path, 3000, "%s/site-packages", pyhome); PySys_SetObject("site_packages", PyBytes_FromString(pyhome)); pargv = PyList_New(argc); if (pargv == NULL) exit(report_error(ERR_OOM)); for (i = 0; i < argc; i++) { v = PyBytes_FromString(argv[i]); if (v == NULL) exit(report_error(ERR_OOM)); PyList_SetItem(pargv, i, v); } PySys_SetObject("argv", pargv); }
void CContextItemAddonInvoker::onPythonModuleInitialization(void* moduleDict) { CAddonPythonInvoker::onPythonModuleInitialization(moduleDict); if (m_item) { XBMCAddon::xbmcgui::ListItem* arg = new XBMCAddon::xbmcgui::ListItem(m_item); PyObject* pyItem = PythonBindings::makePythonInstance(arg, true); if (pyItem == Py_None || PySys_SetObject((char*)"listitem", pyItem) == -1) { CLog::Log(LOGERROR, "CPythonInvoker(%d, %s): Failed to set sys parameter", GetId(), m_sourceFile.c_str()); //FIXME: we should really abort execution } } }