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
}
}
}
