static void init_python(void) { PyObject *py_bt2_py_plugin_mod = NULL; const char *dis_python_env; sighandler_t old_sigint = signal(SIGINT, SIG_DFL); if (python_state != PYTHON_STATE_NOT_INITED) { goto end; } /* * User can disable Python plugin support with the * BABELTRACE_DISABLE_PYTHON_PLUGINS environment variable set to * 1. */ dis_python_env = getenv("BABELTRACE_DISABLE_PYTHON_PLUGINS"); if (dis_python_env && strcmp(dis_python_env, "1") == 0) { BT_LOGI_STR("Python plugin support is disabled because `BABELTRACE_DISABLE_PYTHON_PLUGINS=1`."); python_state = PYTHON_STATE_CANNOT_INITIALIZE; goto end; } if (!Py_IsInitialized()) { Py_InitializeEx(0); BT_LOGI("Initialized Python interpreter: version=\"%s\"", Py_GetVersion()); } py_bt2_py_plugin_mod = PyImport_ImportModule("bt2.py_plugin"); if (!py_bt2_py_plugin_mod) { BT_LOGI_STR("Cannot import bt2.py_plugin Python module: Python plugin support is disabled."); python_state = PYTHON_STATE_CANNOT_INITIALIZE; goto end; } py_try_load_plugin_module_func = PyObject_GetAttrString(py_bt2_py_plugin_mod, "_try_load_plugin_module"); if (!py_try_load_plugin_module_func) { BT_LOGI_STR("Cannot get _try_load_plugin_module attribute from bt2.py_plugin Python module: Python plugin support is disabled."); python_state = PYTHON_STATE_CANNOT_INITIALIZE; goto end; } python_state = PYTHON_STATE_FULLY_INITIALIZED; end: if (old_sigint != SIG_ERR) { (void) signal(SIGINT, old_sigint); } print_python_traceback_warn(); pyerr_clear(); Py_XDECREF(py_bt2_py_plugin_mod); return; }
void PythonModule::initialize() throw (VoreenException) { VoreenModule::initialize(); // // Initialize Python interpreter // LINFO("Python version: " << Py_GetVersion()); // Pass program name to the Python interpreter char str_pyvoreen[] = "PyVoreen"; Py_SetProgramName(str_pyvoreen); // Initialize the Python interpreter. Required. Py_InitializeEx(false); if (!Py_IsInitialized()) throw VoreenException("Failed to initialize Python interpreter"); // required in order to use threads. PyEval_InitThreads(); // init ResourceManager search path addPath(""); addPath(VoreenApplication::app()->getScriptPath()); addPath(VoreenApplication::app()->getModulePath("python/scripts")); // init Python's internal module search path addModulePath(VoreenApplication::app()->getScriptPath()); addModulePath(VoreenApplication::app()->getModulePath("python/scripts")); // // Redirect script output from std::cout to voreen_print function (see above) // // import helper module if (!Py_InitModule("voreen_internal", internal_methods)) { LWARNING("Failed to init helper module 'voreen_internal'"); } // load output redirector script and run it once std::string filename = "outputcatcher.py"; LDEBUG("Loading Python init script '" << filename << "'"); PythonScript* initScript = load(filename); if (initScript) { if (!initScript->run()) LWARNING("Failed to run init script '" << filename << "': " << initScript->getLog()); dispose(initScript); } else { LWARNING("Failed to load init script '" << filename << "'"); } // // Create actual Voreen Python bindings // pyVoreen_ = new PyVoreen(); }
void python_init() { if (not Py_IsInitialized()) { //register signal handlers (kill, term, ...) to python? constexpr int init_signals = 1; Py_InitializeEx(init_signals); const char *py_version = Py_GetVersion(); log::msg("initialized python %s", py_version); } }
int Py_FrozenMain(int argc, char **argv) { char *p; int n, sts; int inspect = 0; int unbuffered = 0; Py_FrozenFlag = 1; /* Suppress errors from getpath.c */ if ((p = Py_GETENV("PYTHONINSPECT")) && *p != '\0') inspect = 1; if ((p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0') unbuffered = 1; if (unbuffered) { setbuf(stdin, (char *)NULL); setbuf(stdout, (char *)NULL); setbuf(stderr, (char *)NULL); } #ifdef MS_WINDOWS PyInitFrozenExtensions(); #endif /* MS_WINDOWS */ Py_SetProgramName(argv[0]); Py_Initialize(); #ifdef MS_WINDOWS PyWinFreeze_ExeInit(); #endif if (Py_VerboseFlag) fprintf(stderr, "Python %s\n%s\n", Py_GetVersion(), Py_GetCopyright()); PySys_SetArgv(argc, argv); n = PyImport_ImportFrozenModule("__main__"); if (n == 0) Py_FatalError("__main__ not frozen"); if (n < 0) { PyErr_Print(); sts = 1; } else sts = 0; if (inspect && isatty((int)fileno(stdin))) sts = PyRun_AnyFile(stdin, "<stdin>") != 0; #ifdef MS_WINDOWS PyWinFreeze_ExeTerm(); #endif Py_Finalize(); return sts; }
BOOL CALLBACK AboutDialog::run_dlgProc(HWND hWnd, UINT Message, WPARAM wParam, LPARAM /* lParam */) { switch (Message) { case WM_INITDIALOG : { std::string message("Python "); message.append(Py_GetVersion()); message.append("\n"); message.append(Py_GetCopyright()); for (size_t pos = 0;(pos = message.find("\n", pos + 1)) != std::string::npos;) { message.replace(pos, 1, "\r\n"); ++pos; } ::SetWindowTextA(GetDlgItem(hWnd, IDC_COPYRIGHT), message.c_str()); ::SetWindowText(GetDlgItem(hWnd, IDC_VERSION), _T(PYSCR_VERSION_STRING)); return TRUE; } case WM_CTLCOLORDLG: return (LONG)m_hbrBackground; case WM_CTLCOLORSTATIC: { HDC hdcStatic = (HDC)wParam; SetBkMode(hdcStatic, TRANSPARENT); return (LONG)m_hbrBackground; } case WM_COMMAND : switch (wParam) { case IDOK : case IDCANCEL : display(false); return TRUE; default : break; } return FALSE; default: return FALSE; } }
static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { char message[200]; PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); #if PY_VERSION_HEX < 0x02050000 return PyErr_Warn(NULL, message); #else return PyErr_WarnEx(NULL, message, 1); #endif } return 0; }
QString PythonTransform::help() const { QString help; help.append(tr("<p>%1</p>").arg(id)); help.append(tr("<p>The list of Python transforms is loaded automatically from differents default locations.</p><p>In addition modules are reloaded (refreshed) every time the input is refreshed, so you don't need to restart Pip3line to commit scripts changes</p><p>Using Python %1</p><p>Current Python module name: \"%2\"</p>").arg(QString(Py_GetVersion())).arg(moduleName)); return help; }
int Py_FrozenMain(int argc, char **argv) #endif { char *p; int n, sts = 1; int inspect = 0; int unbuffered = 0; #if PY_MAJOR_VERSION >= 3 && !defined(WIN_UNICODE) int i; char *oldloc; wchar_t **argv_copy = NULL; /* We need a second copies, as Python might modify the first one. */ wchar_t **argv_copy2 = NULL; if (argc > 0) { argv_copy = (wchar_t **)alloca(sizeof(wchar_t *) * argc); argv_copy2 = (wchar_t **)alloca(sizeof(wchar_t *) * argc); } #endif #if defined(MS_WINDOWS) && PY_VERSION_HEX >= 0x03040000 && PY_VERSION_HEX < 0x03060000 if (!supports_code_page(GetConsoleOutputCP()) || !supports_code_page(GetConsoleCP())) { /* Revert to the active codepage, and tell Python to use the 'mbcs' * encoding (which always uses the active codepage). In 99% of cases, * this will be the same thing anyway. */ UINT acp = GetACP(); SetConsoleCP(acp); SetConsoleOutputCP(acp); Py_SetStandardStreamEncoding("mbcs", NULL); } #endif Py_FrozenFlag = 1; /* Suppress errors from getpath.c */ Py_NoSiteFlag = 0; Py_NoUserSiteDirectory = 1; if ((p = Py_GETENV("PYTHONINSPECT")) && *p != '\0') inspect = 1; if ((p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0') unbuffered = 1; if (unbuffered) { setbuf(stdin, (char *)NULL); setbuf(stdout, (char *)NULL); setbuf(stderr, (char *)NULL); } #if PY_MAJOR_VERSION >= 3 && !defined(WIN_UNICODE) oldloc = setlocale(LC_ALL, NULL); setlocale(LC_ALL, ""); for (i = 0; i < argc; i++) { argv_copy[i] = Py_DecodeLocale(argv[i], NULL); argv_copy2[i] = argv_copy[i]; if (!argv_copy[i]) { fprintf(stderr, "Unable to decode the command line argument #%i\n", i + 1); argc = i; goto error; } } setlocale(LC_ALL, oldloc); #endif #ifdef MS_WINDOWS PyImport_ExtendInittab(extensions); #endif /* MS_WINDOWS */ if (argc >= 1) { #if PY_MAJOR_VERSION >= 3 && !defined(WIN_UNICODE) Py_SetProgramName(argv_copy[0]); #else Py_SetProgramName(argv[0]); #endif } Py_Initialize(); #ifdef MS_WINDOWS PyWinFreeze_ExeInit(); #endif #if defined(MS_WINDOWS) && PY_VERSION_HEX < 0x03040000 if (!supports_code_page(GetConsoleOutputCP()) || !supports_code_page(GetConsoleCP())) { /* Same hack as before except for Python 2.7, which doesn't seem to have * a way to set the encoding ahead of time, and setting PYTHONIOENCODING * doesn't seem to work. Fortunately, Python 2.7 doesn't usually start * causing codec errors until the first print statement. */ PyObject *sys_stream; UINT acp = GetACP(); SetConsoleCP(acp); SetConsoleOutputCP(acp); sys_stream = PySys_GetObject("stdin"); if (sys_stream && PyFile_Check(sys_stream)) { PyFile_SetEncodingAndErrors(sys_stream, "mbcs", NULL); } sys_stream = PySys_GetObject("stdout"); if (sys_stream && PyFile_Check(sys_stream)) { PyFile_SetEncodingAndErrors(sys_stream, "mbcs", NULL); } sys_stream = PySys_GetObject("stderr"); if (sys_stream && PyFile_Check(sys_stream)) { PyFile_SetEncodingAndErrors(sys_stream, "mbcs", NULL); } } #endif if (Py_VerboseFlag) fprintf(stderr, "Python %s\n%s\n", Py_GetVersion(), Py_GetCopyright()); #if PY_MAJOR_VERSION >= 3 && !defined(WIN_UNICODE) PySys_SetArgv(argc, argv_copy); #else PySys_SetArgv(argc, argv); #endif #ifdef MACOS_APP_BUNDLE // Add the Frameworks directory to sys.path. char buffer[PATH_MAX]; uint32_t bufsize = sizeof(buffer); if (_NSGetExecutablePath(buffer, &bufsize) != 0) { assert(false); return 1; } char resolved[PATH_MAX]; if (!realpath(buffer, resolved)) { perror("realpath"); return 1; } const char *dir = dirname(resolved); sprintf(buffer, "%s/../Frameworks", dir); PyObject *sys_path = PyList_New(1); #if PY_MAJOR_VERSION >= 3 PyList_SET_ITEM(sys_path, 0, PyUnicode_FromString(buffer)); #else PyList_SET_ITEM(sys_path, 0, PyString_FromString(buffer)); #endif PySys_SetObject("path", sys_path); Py_DECREF(sys_path); // Now, store a path to the Resources directory into the main_dir pointer, // for ConfigPageManager to read out and assign to MAIN_DIR. sprintf(buffer, "%s/../Resources", dir); set_main_dir(buffer); #endif n = PyImport_ImportFrozenModule("__main__"); if (n == 0) Py_FatalError("__main__ not frozen"); if (n < 0) { PyErr_Print(); sts = 1; } else sts = 0; if (inspect && isatty((int)fileno(stdin))) sts = PyRun_AnyFile(stdin, "<stdin>") != 0; #ifdef MS_WINDOWS PyWinFreeze_ExeTerm(); #endif Py_Finalize(); #if PY_MAJOR_VERSION >= 3 && !defined(WIN_UNICODE) error: if (argv_copy2) { for (i = 0; i < argc; i++) { #if PY_MINOR_VERSION >= 4 PyMem_RawFree(argv_copy2[i]); #else PyMem_Free(argv_copy2[i]); #endif } } #endif return sts; }
//------------------------------------------------------------------------------------- bool Script::install(const wchar_t* pythonHomeDir, std::wstring pyPaths, const char* moduleName, COMPONENT_TYPE componentType) { std::wstring pySysPaths = SCRIPT_PATH; wchar_t* pwpySysResPath = strutil::char2wchar(const_cast<char*>(Resmgr::getSingleton().getPySysResPath().c_str())); strutil::kbe_replace(pySysPaths, L"../../res/", pwpySysResPath); pyPaths += pySysPaths; free(pwpySysResPath); // 先设置python的环境变量 Py_SetPythonHome(const_cast<wchar_t*>(pythonHomeDir)); #if KBE_PLATFORM != PLATFORM_WIN32 std::wstring fs = L";"; std::wstring rs = L":"; size_t pos = 0; while(true) { pos = pyPaths.find(fs, pos); if (pos == std::wstring::npos) break; pyPaths.replace(pos, fs.length(), rs); } char* tmpchar = strutil::wchar2char(const_cast<wchar_t*>(pyPaths.c_str())); DEBUG_MSG(fmt::format("Script::install(): paths={}.\n", tmpchar)); free(tmpchar); #endif // Initialise python // Py_VerboseFlag = 2; Py_FrozenFlag = 1; // Warn if tab and spaces are mixed in indentation. // Py_TabcheckFlag = 1; Py_NoSiteFlag = 1; Py_IgnoreEnvironmentFlag = 1; Py_SetPath(pyPaths.c_str()); // python解释器的初始化 Py_Initialize(); if (!Py_IsInitialized()) { ERROR_MSG("Script::install(): Py_Initialize is failed!\n"); return false; } PyObject *m = PyImport_AddModule("__main__"); // 添加一个脚本基础模块 module_ = PyImport_AddModule(moduleName); if (module_ == NULL) return false; const char* componentName = COMPONENT_NAME_EX(componentType); if (PyModule_AddStringConstant(module_, "component", componentName)) { ERROR_MSG(fmt::format("Script::install(): Unable to set KBEngine.component to {}\n", componentName)); return false; } // 注册产生uuid方法到py APPEND_SCRIPT_MODULE_METHOD(module_, genUUID64, __py_genUUID64, METH_VARARGS, 0); if(!install_py_dlls()) { ERROR_MSG("Script::install(): install_py_dlls() is failed!\n"); return false; } // 安装py重定向模块 ScriptStdOut::installScript(NULL); ScriptStdErr::installScript(NULL); /* static struct PyModuleDef moduleDesc = { PyModuleDef_HEAD_INIT, moduleName, "This module is created by KBEngine!", -1, NULL }; // 初始化基础模块 PyModule_Create(&moduleDesc); */ // 将模块对象加入main PyObject_SetAttrString(m, moduleName, module_); PyObject_SetAttrString(module_, "__doc__", PyUnicode_FromString("This module is created by KBEngine!")); // 重定向python输出 pyStdouterr_ = new ScriptStdOutErr(); // 安装py重定向脚本模块 if(!pyStdouterr_->install()){ ERROR_MSG("Script::install::pyStdouterr_->install() is failed!\n"); delete pyStdouterr_; SCRIPT_ERROR_CHECK(); return false; } PyGC::initialize(); Pickler::initialize(); PyProfile::initialize(this); PyStruct::initialize(); Copy::initialize(); SCRIPT_ERROR_CHECK(); math::installModule("Math"); INFO_MSG(fmt::format("Script::install(): is successfully, Python=({})!\n", Py_GetVersion())); return installExtraModule("KBExtra"); }
int main(int argc, char *argv[]) { sys_argc = argc; sys_argv = argv; origPid = getpid(); #ifdef __APPLE__ extern void install_breakpoint_handlers(); install_breakpoint_handlers(); #endif forkExecProc = haveArg("--forkExecProc"); bool shell = haveArg("--shell"); bool pyShell = haveArg("--pyshell"); bool pyExec = haveArg("--pyexec"); bool noLog = haveArg("--nolog"); bool help = haveArg("--help") || haveArg("-h"); bool beingDebugged = AmIBeingDebugged(); const char* logDisabledReason = NULL; if(pyShell || pyExec || shell || forkExecProc || help) {} // be quiet else if(beingDebugged) { logDisabledReason = "debugger detected, not redirecting stdout/stderr"; } else if(noLog) { logDisabledReason = "not redirecting stdout/stderr"; } else { // current workaround to log stdout/stderr. see http://stackoverflow.com/questions/13104588/how-to-get-stdout-into-console-app logEnabled = true; printf("MusicPlayer: stdout/stderr goes to %s now\n", logFilename.c_str()); fflush(stdout); int newFd = open(getTildeExpandedPath(logFilename).c_str(), O_WRONLY|O_APPEND|O_CREAT); dup2(newFd, fileno(stdout)); dup2(newFd, fileno(stderr)); close(newFd); //freopen(logFilename.c_str(), "a", stdout); //freopen(logFilename.c_str(), "a", stderr); stderr = stdout; // well, hack, ... I don't like two seperate buffers. just messes up the output } if(!forkExecProc) { printf("%s", StartupStr); install_signal_handler(); } if(help) { printf( "Help: Available options:\n" " --nolog : don't redirect stdout/stderr to log. also implied when run in debugger\n" ); } if(!logEnabled && logDisabledReason) printf("%s\n", logDisabledReason); std::string mainPyFilename = getResourcePath() + "/Python/main.py"; Py_SetProgramName(argv[0]); if(!forkExecProc) printf("Python version: %s, prefix: %s, main: %s\n", Py_GetVersion(), Py_GetPrefix(), mainPyFilename.c_str()); Py_Initialize(); PyEval_InitThreads(); addPyPath(); if(logEnabled) { PySys_SetObject((char*)"stdout", PyFile_FromFile(stdout, (char*)"<stdout>", (char*)"w", fclose)); PySys_SetObject((char*)"stderr", PySys_GetObject((char*)"stdout")); } PySys_SetObject((char*)"MusicPlayerBin", PyString_FromString(argv[0])); // Preload imp and thread. I hope to fix this bug: https://github.com/albertz/music-player/issues/8 , there was a crash in initthread which itself has called initimp PyObject* m = NULL; m = PyImport_ImportModule("imp"); Py_XDECREF(m); m = PyImport_ImportModule("thread"); Py_XDECREF(m); PySys_SetArgvEx(argc, argv, 0); FILE* fp = fopen((char*)mainPyFilename.c_str(), "r"); if(fp) PyRun_SimpleFile(fp, "main.py"); else printf("Could not open main.py!\n"); if(!forkExecProc && !help && !pyShell && !pyExec && !shell) { bool successStartup = checkStartupSuccess(); if(!successStartup) { printf("Error at startup.\n"); handleFatalError("There was an error at startup."); } } return 0; }
//--------------------------------------------------------------------------------- // Initializes python. //--------------------------------------------------------------------------------- bool CPythonManager::Initialize( void ) { // Construct a path to the python engine directory. char szPythonHome[MAX_GAME_PATH]; V_snprintf(szPythonHome, MAX_GAME_PATH, "%s/Python3", g_GamePaths.GetSPDir()); V_FixSlashes(szPythonHome); DevMsg(1, "[SP] Python home path set to %s\n", szPythonHome); // Convert to wide char for python. wchar_t wszPythonHome[1024]; V_strtowcs(szPythonHome, -1, wszPythonHome, 1024); // Set that as the python home directory. Py_SetPythonHome(wszPythonHome); Py_SetProgramName(wszPythonHome); Py_SetPath(wszPythonHome); // Initialize python and its namespaces. Py_Initialize(); // Print some information DevMsg(1, "Python version %s initialized!\n", Py_GetVersion()); // Make sure sys is imported. PyRun_SimpleString("import sys"); // Add the Python API path. AddToSysPath("/packages/source-python"); // Add operating system specific paths. #if defined(WIN32) AddToSysPath("/Python3/plat-win"); #else AddToSysPath("/Python3/plat-linux"); // We've got a bunch of linux shared objects here we need to load. AddToSysPath("/Python3/lib-dynload"); #endif // Site packages for any extra packages... AddToSysPath("/packages/site-packages"); // Add the custom packages path. AddToSysPath("/packages/custom"); // And of course, the plugins directory for script imports. AddToSysPath("/plugins"); // Initialize all converters InitConverters(); // Initialize all submodules modulsp_init(); // Import the main module file. DevMsg(1, "[SP] Importing main module..\n"); BEGIN_BOOST_PY() python::import("__init__"); END_BOOST_PY_NORET(); // Noret because we have more stuff to do after this import. DevMsg(0, "[Source.Python] Loaded successfully.\n"); return true; }
std::string PySetup::get_version() { return Py_GetVersion(); }
const char* python_get_version(void) { return Py_GetVersion(); }
int uwsgi_python_init() { #ifndef UWSGI_PYPY char *pyversion = strchr(Py_GetVersion(), '\n'); if (!pyversion) { uwsgi_log_initial("Python version: %s\n", Py_GetVersion()); } else { uwsgi_log_initial("Python version: %.*s %s\n", pyversion-Py_GetVersion(), Py_GetVersion(), Py_GetCompiler()+1); } #else uwsgi_log_initial("PyPy version: %s\n", PYPY_VERSION); #endif if (up.home != NULL) { #ifdef PYTHREE wchar_t *wpyhome; wpyhome = malloc((sizeof(wchar_t) * strlen(up.home)) + sizeof(wchar_t) ); if (!wpyhome) { uwsgi_error("malloc()"); exit(1); } mbstowcs(wpyhome, up.home, strlen(up.home)); Py_SetPythonHome(wpyhome); // do not free this memory !!! //free(wpyhome); #else Py_SetPythonHome(up.home); #endif uwsgi_log("Set PythonHome to %s\n", up.home); } #ifdef PYTHREE wchar_t pname[6]; mbstowcs(pname, "uWSGI", 6); Py_SetProgramName(pname); #else Py_SetProgramName("uWSGI"); #endif #ifndef UWSGI_PYPY Py_OptimizeFlag = up.optimize; #endif Py_Initialize(); if (!uwsgi.has_threads) { uwsgi_log("*** Python threads support is disabled. You can enable it with --enable-threads ***\n"); } up.wsgi_spitout = PyCFunction_New(uwsgi_spit_method, NULL); up.wsgi_writeout = PyCFunction_New(uwsgi_write_method, NULL); up.main_thread = PyThreadState_Get(); // by default set a fake GIL (little impact on performance) up.gil_get = gil_fake_get; up.gil_release = gil_fake_release; up.swap_ts = simple_swap_ts; up.reset_ts = simple_reset_ts; uwsgi_log_initial("Python main interpreter initialized at %p\n", up.main_thread); return 1; }
//--------------------------------------------------------------------------------- // Initializes python. //--------------------------------------------------------------------------------- bool CPythonManager::Initialize( void ) { // Construct a path to the python engine directory. char szPythonHome[MAX_PATH_LENGTH]; V_snprintf(szPythonHome, MAX_PATH_LENGTH, "%s/Python3", GetSourcePythonDir()); V_FixSlashes(szPythonHome); DevMsg(1, MSG_PREFIX "Python home path set to %s\n", szPythonHome); // Convert to wide char for python. wchar_t wszPythonHome[MAX_PATH_LENGTH]; V_strtowcs(szPythonHome, -1, wszPythonHome, MAX_PATH_LENGTH); // Set that as the python home directory. Py_SetPythonHome(wszPythonHome); Py_SetProgramName(wszPythonHome); Py_SetPath(wszPythonHome); // Initialize python and its namespaces. Py_Initialize(); // Print some information DevMsg(1, MSG_PREFIX "Python version %s initialized!\n", Py_GetVersion()); // Set sys.argv and update sys.path DevMsg(1, MSG_PREFIX "Setting sys.argv...\n"); ICommandLine* pCommandLine = CommandLine(); int iParamCount = pCommandLine->ParmCount(); wchar_t** argv = new wchar_t*[iParamCount]; for (int i=0; i < iParamCount; i++) { const char* szParam = pCommandLine->GetParm(i); int iParamLength = strlen(szParam); wchar_t* wszParam = new wchar_t[iParamLength+1]; // Not sure what's wrong with V_strtowcs, but it seems like it // doesn't convert the string correctly on Linux mbstowcs(wszParam, szParam, iParamLength+1); argv[i] = wszParam; } PySys_SetArgv(iParamCount, argv); // Make sure sys is imported. PyRun_SimpleString("import sys"); // Add the Python API path. AddToSysPath("/packages/source-python"); // Add operating system specific paths. #if defined(WIN32) AddToSysPath("/Python3/plat-win"); #else AddToSysPath("/Python3/plat-linux"); // We've got a bunch of linux shared objects here we need to load. AddToSysPath("/Python3/lib-dynload"); #endif // Site packages for any extra packages... AddToSysPath("/packages/site-packages"); // Add the custom packages path. AddToSysPath("/packages/custom"); // And of course, the plugins directory for script imports. AddToSysPath("/plugins"); // Initialize all converters InitConverters(); // Initialize all submodules if (!modulsp_init()) { Msg(MSG_PREFIX "Failed to initialize internal modules.\n"); return false; } // Import the main module file. DevMsg(1, MSG_PREFIX "Loading main module...\n"); try { python::import("__init__").attr("load")(); } catch( ... ) { PyErr_Print(); PyErr_Clear(); Msg(MSG_PREFIX "Failed to load the main module.\n"); return false; } return true; }
int Py_FrozenMain(int argc, char **argv) { char *p; int i, n, sts; int inspect = 0; int unbuffered = 0; char *oldloc; wchar_t **argv_copy = PyMem_Malloc(sizeof(wchar_t*)*argc); /* We need a second copies, as Python might modify the first one. */ wchar_t **argv_copy2 = PyMem_Malloc(sizeof(wchar_t*)*argc); Py_FrozenFlag = 1; /* Suppress errors from getpath.c */ if ((p = Py_GETENV("PYTHONINSPECT")) && *p != '\0') inspect = 1; if ((p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0') unbuffered = 1; if (unbuffered) { setbuf(stdin, (char *)NULL); setbuf(stdout, (char *)NULL); setbuf(stderr, (char *)NULL); } if (!argv_copy) { fprintf(stderr, "out of memory\n"); return 1; } oldloc = setlocale(LC_ALL, NULL); setlocale(LC_ALL, ""); for (i = 0; i < argc; i++) { #ifdef HAVE_BROKEN_MBSTOWCS size_t argsize = strlen(argv[i]); #else size_t argsize = mbstowcs(NULL, argv[i], 0); #endif size_t count; if (argsize == (size_t)-1) { fprintf(stderr, "Could not convert argument %d to string\n", i); return 1; } argv_copy[i] = PyMem_Malloc((argsize+1)*sizeof(wchar_t)); argv_copy2[i] = argv_copy[i]; if (!argv_copy[i]) { fprintf(stderr, "out of memory\n"); return 1; } count = mbstowcs(argv_copy[i], argv[i], argsize+1); if (count == (size_t)-1) { fprintf(stderr, "Could not convert argument %d to string\n", i); return 1; } } setlocale(LC_ALL, oldloc); #ifdef MS_WINDOWS PyInitFrozenExtensions(); #endif /* MS_WINDOWS */ Py_SetProgramName(argv_copy[0]); Py_Initialize(); #ifdef MS_WINDOWS PyWinFreeze_ExeInit(); #endif if (Py_VerboseFlag) fprintf(stderr, "Python %s\n%s\n", Py_GetVersion(), Py_GetCopyright()); PySys_SetArgv(argc, argv_copy); n = PyImport_ImportFrozenModule("__main__"); if (n == 0) Py_FatalError("__main__ not frozen"); if (n < 0) { PyErr_Print(); sts = 1; } else sts = 0; if (inspect && isatty((int)fileno(stdin))) sts = PyRun_AnyFile(stdin, "<stdin>") != 0; #ifdef MS_WINDOWS PyWinFreeze_ExeTerm(); #endif Py_Finalize(); for (i = 0; i < argc; i++) { PyMem_Free(argv_copy2[i]); } PyMem_Free(argv_copy); PyMem_Free(argv_copy2); return sts; }
void pbs_python_ext_quick_start_interpreter(void) { static char func_id[] = "pbs_python_ext_quick_start_interpreter"; #ifdef PYTHON /* -- BEGIN ONLY IF PYTHON IS CONFIGURED -- */ char pbs_python_home[MAXPATHLEN+1]; char pbs_python_destlib[MAXPATHLEN+1]; memset((char *)pbs_python_home, '\0', MAXPATHLEN+1); memset((char *)pbs_python_destlib, '\0', MAXPATHLEN+1); snprintf(pbs_python_home, MAXPATHLEN, "%s/python", pbs_conf.pbs_exec_path); snprintf(pbs_python_destlib, MAXPATHLEN, "%s/lib/python/altair", pbs_conf.pbs_exec_path); Py_NoSiteFlag = 1; Py_FrozenFlag = 1; Py_OptimizeFlag = 2; /* TODO make this a compile flag variable */ Py_IgnoreEnvironmentFlag = 1; /* ignore PYTHONPATH and PYTHONHOME */ if (file_exists(pbs_python_home)) Py_SetPythonHome(pbs_python_home); /* we make sure our top level module is initialized */ if ((PyImport_ExtendInittab(pbs_python_inittab_modules) != 0)) { log_err(-1, "PyImport_ExtendInittab", "--> Failed to initialize Python interpreter <--"); return; } Py_InitializeEx(0); /* SKIP initialization of signals */ if (Py_IsInitialized()) { snprintf(log_buffer, LOG_BUF_SIZE-1, "--> Python Interpreter quick started, compiled with version:'%.*s' <--", 5, Py_GetVersion()); log_buffer[LOG_BUF_SIZE-1] = '\0'; log_event(PBSEVENT_SYSTEM|PBSEVENT_ADMIN | PBSEVENT_DEBUG, PBS_EVENTCLASS_SERVER, LOG_INFO, func_id, log_buffer); } else { log_err(-1, "Py_InitializeEx", "--> Failed to quick initialize Python interpreter <--"); goto ERROR_EXIT; } /* * Add Altair python module directory to sys path. NOTE: * PBS_PYTHON_MODULE_DIR is a command line define, also insert * standard required python modules */ if (pbs_python_modify_syspath(pbs_python_destlib, -1) == -1) { snprintf(log_buffer, LOG_BUF_SIZE-1, "could not insert %s into sys.path shutting down", pbs_python_destlib); log_buffer[LOG_BUF_SIZE-1] = '\0'; log_err(-1, func_id, log_buffer); goto ERROR_EXIT; } snprintf(log_buffer, LOG_BUF_SIZE-1, "--> Inserted Altair PBS Python modules dir '%s' <--", pbs_python_destlib); log_buffer[LOG_BUF_SIZE-1] = '\0'; log_event(PBSEVENT_SYSTEM|PBSEVENT_ADMIN | PBSEVENT_DEBUG, PBS_EVENTCLASS_SERVER, LOG_INFO, func_id, log_buffer); return; ERROR_EXIT: pbs_python_ext_quick_shutdown_interpreter(); return; #else /* !PYTHON */ log_event(PBSEVENT_SYSTEM|PBSEVENT_ADMIN | PBSEVENT_DEBUG, PBS_EVENTCLASS_SERVER, LOG_INFO, "start_python", "--> Python interpreter not built in <--"); return; #endif /* PYTHON */ }
int Py_FrozenMain(int argc, char **argv) { char *p; int i, n, sts = 1; int inspect = 0; int unbuffered = 0; char *oldloc = NULL; wchar_t **argv_copy = NULL; /* We need a second copies, as Python might modify the first one. */ wchar_t **argv_copy2 = NULL; argv_copy = PyMem_RawMalloc(sizeof(wchar_t*) * argc); argv_copy2 = PyMem_RawMalloc(sizeof(wchar_t*) * argc); if (!argv_copy || !argv_copy2) { fprintf(stderr, "out of memory\n"); goto error; } Py_FrozenFlag = 1; /* Suppress errors from getpath.c */ if ((p = Py_GETENV("PYTHONINSPECT")) && *p != '\0') inspect = 1; if ((p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0') unbuffered = 1; if (unbuffered) { setbuf(stdin, (char *)NULL); setbuf(stdout, (char *)NULL); setbuf(stderr, (char *)NULL); } oldloc = _PyMem_RawStrdup(setlocale(LC_ALL, NULL)); if (!oldloc) { fprintf(stderr, "out of memory\n"); goto error; } setlocale(LC_ALL, ""); for (i = 0; i < argc; i++) { argv_copy[i] = _Py_char2wchar(argv[i], NULL); argv_copy2[i] = argv_copy[i]; if (!argv_copy[i]) { fprintf(stderr, "Unable to decode the command line argument #%i\n", i + 1); argc = i; goto error; } } setlocale(LC_ALL, oldloc); PyMem_RawFree(oldloc); oldloc = NULL; #ifdef MS_WINDOWS PyInitFrozenExtensions(); #endif /* MS_WINDOWS */ Py_SetProgramName(argv_copy[0]); Py_Initialize(); #ifdef MS_WINDOWS PyWinFreeze_ExeInit(); #endif if (Py_VerboseFlag) fprintf(stderr, "Python %s\n%s\n", Py_GetVersion(), Py_GetCopyright()); PySys_SetArgv(argc, argv_copy); n = PyImport_ImportFrozenModule("__main__"); if (n == 0) Py_FatalError("__main__ not frozen"); if (n < 0) { PyErr_Print(); sts = 1; } else sts = 0; if (inspect && isatty((int)fileno(stdin))) sts = PyRun_AnyFile(stdin, "<stdin>") != 0; #ifdef MS_WINDOWS PyWinFreeze_ExeTerm(); #endif Py_Finalize(); error: PyMem_RawFree(argv_copy); if (argv_copy2) { for (i = 0; i < argc; i++) PyMem_RawFree(argv_copy2[i]); PyMem_RawFree(argv_copy2); } PyMem_RawFree(oldloc); return sts; }
LRESULT CALLBACK AboutDialog( HWND hwnd, unsigned int msg, WPARAM wparam, LPARAM lparam ) { HWND richtext; switch ( msg ) { case WM_COMMAND: if ( HIWORD( wparam ) == BN_CLICKED && ( HWND ) lparam == GetDlgItem( hwnd, IDOK ) ) { EndDialog( hwnd, 0 ); } break; case WM_CLOSE: EndDialog( hwnd, 0 ); break; case WM_INITDIALOG: richtext = GetDlgItem( hwnd, IDC_RICHEDIT ); if ( richtext ) { HRSRC resource = FindResource( appInstance, MAKEINTRESOURCE( IDD_CREDITS ), RT_RCDATA ); HGLOBAL rData = LoadResource( appInstance, resource ); const char* data = ( const char* ) LockResource( rData ); QStringList creditList = QStringList::split( ",", data ); UnlockResource( rData ); FreeResource( rData ); CHARRANGE cr; CHARFORMAT2 cf; ZeroMemory( &cf, sizeof( cf ) ); cf.cbSize = sizeof( cf ); // Add a version information header (just like the console) QString version = QString( "%1 %2 %3\n" ).arg( productString(), productBeta(), productVersion() ); cf.dwMask = CFM_COLOR | CFM_WEIGHT | CFM_SIZE; cf.yHeight = 20 * 14; cf.wWeight = FW_BOLD; cf.crTextColor = RGB( 60, 140, 70 ); SendMessage( richtext, EM_SETCHARFORMAT, SCF_SELECTION, ( LPARAM ) & cf ); SendMessage( richtext, EM_REPLACESEL, FALSE, ( LPARAM ) version.latin1() ); cf.dwMask = CFM_COLOR | CFM_WEIGHT | CFM_SIZE; cf.yHeight = 20 * 8; cf.wWeight = FW_NORMAL; cf.crTextColor = RGB( 0, 0, 0 ); QString credits; credits += tr( "Compiled: %1 %2\n" ).arg( __DATE__, __TIME__ ); credits += tr( "Qt: %1 %2 (Compiled: %3)\n" ).arg( qVersion() ).arg( qSharedBuild() ? "Shared" : "Static" ).arg( QT_VERSION_STR ); QString pythonBuild = Py_GetVersion(); pythonBuild = pythonBuild.left( pythonBuild.find( ' ' ) ); #if defined(Py_ENABLE_SHARED) credits += tr( "Python: %1 Shared (Compiled: %2)\n" ).arg( pythonBuild ).arg( PY_VERSION ); #else credits += tr( "Python: %1 Static (Compiled: %2)\n" ).arg( pythonBuild ).arg( PY_VERSION ); #endif credits += tr( "Compiled with SQLite %1\n" ).arg( SQLITE_VERSION ); #if defined (MYSQL_DRIVER) credits += tr( "Compiled for MySQL %1 (Using: %2)\n" ).arg( MYSQL_SERVER_VERSION, mysql_get_client_info() ); #else credits += tr( "MySQL Support: disabled\n" ); #endif cr.cpMin = GetWindowTextLength( richtext ); cr.cpMax = cr.cpMin; SendMessage( richtext, EM_EXSETSEL, 0, ( LPARAM ) & cr ); SendMessage( richtext, EM_SETCHARFORMAT, SCF_SELECTION, ( LPARAM ) & cf ); SendMessage( richtext, EM_REPLACESEL, FALSE, ( LPARAM ) credits.latin1() ); credits = tr( "\nThis is an unsorted and not neccesarily complete list of people who contributed to Wolfpack:\n\n" ); cr.cpMin = GetWindowTextLength( richtext ); cr.cpMax = cr.cpMin; cf.wWeight = FW_BOLD; SendMessage( richtext, EM_EXSETSEL, 0, ( LPARAM ) & cr ); SendMessage( richtext, EM_SETCHARFORMAT, SCF_SELECTION, ( LPARAM ) & cf ); SendMessage( richtext, EM_REPLACESEL, FALSE, ( LPARAM ) credits.latin1() ); cf.wWeight = FW_NORMAL; credits = ""; for ( unsigned int i = 0; i < creditList.size(); ++i ) { credits.append( creditList[i] ); } cr.cpMin = GetWindowTextLength( richtext ); cr.cpMax = cr.cpMin; SendMessage( richtext, EM_EXSETSEL, 0, ( LPARAM ) & cr ); SendMessage( richtext, EM_SETCHARFORMAT, SCF_SELECTION, ( LPARAM ) & cf ); SendMessage( richtext, EM_REPLACESEL, FALSE, ( LPARAM ) credits.latin1() ); } } return FALSE; }
void SCRIPT_API CreateParser(){ Py_Initialize(); printf("python %s\n",Py_GetVersion()); }
int main( int argc, char ** argv ) { #if defined (FC_OS_LINUX) || defined(FC_OS_BSD) // Make sure to setup the Qt locale system before setting LANG and LC_ALL to C. // which is needed to use the system locale settings. (void)QLocale::system(); #if QT_VERSION < 0x050000 // http://www.freecadweb.org/tracker/view.php?id=399 // Because of setting LANG=C the Qt automagic to use the correct encoding // for file names is broken. This is a workaround to force the use of UTF-8 encoding QFile::setEncodingFunction(myEncoderFunc); QFile::setDecodingFunction(myDecoderFunc); #endif // See https://forum.freecadweb.org/viewtopic.php?f=18&t=20600 // See Gui::Application::runApplication() putenv("LC_NUMERIC=C"); putenv("PYTHONPATH="); #elif defined(FC_OS_MACOSX) (void)QLocale::system(); putenv("PYTHONPATH="); #else _putenv("PYTHONPATH="); // https://forum.freecadweb.org/viewtopic.php?f=4&t=18288 // https://forum.freecadweb.org/viewtopic.php?f=3&t=20515 const char* fc_py_home = getenv("FC_PYTHONHOME"); if (fc_py_home) _putenv_s("PYTHONHOME", fc_py_home); else _putenv("PYTHONHOME="); #endif #if defined (FC_OS_WIN32) int argc_ = argc; QVector<QByteArray> data; QVector<char *> argv_; // get the command line arguments as unicode string { QCoreApplication app(argc, argv); QStringList args = app.arguments(); for (QStringList::iterator it = args.begin(); it != args.end(); ++it) { data.push_back(it->toUtf8()); argv_.push_back(data.back().data()); } argv_.push_back(0); // 0-terminated string } #endif #if PY_MAJOR_VERSION >= 3 #if defined(_MSC_VER) && _MSC_VER <= 1800 // See InterpreterSingleton::init Redirection out(stdout), err(stderr), inp(stdin); #endif #endif // PY_MAJOR_VERSION // Name and Version of the Application App::Application::Config()["ExeName"] = "FreeCAD"; App::Application::Config()["ExeVendor"] = "FreeCAD"; App::Application::Config()["AppDataSkipVendor"] = "true"; App::Application::Config()["MaintainerUrl"] = "http://www.freecadweb.org/wiki/Main_Page"; // set the banner (for logging and console) App::Application::Config()["CopyrightInfo"] = sBanner; App::Application::Config()["AppIcon"] = "freecad"; App::Application::Config()["SplashScreen"] = "freecadsplash"; App::Application::Config()["StartWorkbench"] = "StartWorkbench"; //App::Application::Config()["HiddenDockWindow"] = "Property editor"; App::Application::Config()["SplashAlignment" ] = "Bottom|Left"; App::Application::Config()["SplashTextColor" ] = "#ffffff"; // white App::Application::Config()["SplashInfoColor" ] = "#c8c8c8"; // light grey try { // Init phase =========================================================== // sets the default run mode for FC, starts with gui if not overridden in InitConfig... App::Application::Config()["RunMode"] = "Gui"; App::Application::Config()["Console"] = "0"; // Inits the Application #if defined (FC_OS_WIN32) App::Application::init(argc_, argv_.data()); #else App::Application::init(argc, argv); #endif #if defined(_MSC_VER) // create a dump file when the application crashes std::string dmpfile = App::Application::getUserAppDataDir(); dmpfile += "crash.dmp"; InitMiniDumpWriter(dmpfile); #endif std::map<std::string, std::string>::iterator it = App::Application::Config().find("NavigationStyle"); if (it != App::Application::Config().end()) { ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/View"); // if not already defined do it now (for the very first start) std::string style = hGrp->GetASCII("NavigationStyle", it->second.c_str()); hGrp->SetASCII("NavigationStyle", style.c_str()); } Gui::Application::initApplication(); // Only if 'RunMode' is set to 'Gui' do the replacement if (App::Application::Config()["RunMode"] == "Gui") Base::Interpreter().replaceStdOutput(); } catch (const Base::UnknownProgramOption& e) { QApplication app(argc,argv); QString appName = QString::fromLatin1(App::Application::Config()["ExeName"].c_str()); QString msg = QString::fromLatin1(e.what()); QString s = QLatin1String("<pre>") + msg + QLatin1String("</pre>"); QMessageBox::critical(0, appName, s); exit(1); } catch (const Base::ProgramInformation& e) { QApplication app(argc,argv); QString appName = QString::fromLatin1(App::Application::Config()["ExeName"].c_str()); QString msg = QString::fromUtf8(e.what()); QString s = QLatin1String("<pre>") + msg + QLatin1String("</pre>"); QMessageBox msgBox; msgBox.setIcon(QMessageBox::Information); msgBox.setWindowTitle(appName); msgBox.setDetailedText(msg); msgBox.setText(s); msgBox.exec(); exit(0); } catch (const Base::Exception& e) { // Popup an own dialog box instead of that one of Windows QApplication app(argc,argv); QString appName = QString::fromLatin1(App::Application::Config()["ExeName"].c_str()); QString msg; msg = QObject::tr("While initializing %1 the following exception occurred: '%2'\n\n" "Python is searching for its files in the following directories:\n%3\n\n" "Python version information:\n%4\n") .arg(appName).arg(QString::fromUtf8(e.what())) #if PY_MAJOR_VERSION >= 3 #if PY_MINOR_VERSION >= 5 .arg(QString::fromUtf8(Py_EncodeLocale(Py_GetPath(),NULL))).arg(QString::fromLatin1(Py_GetVersion())); #else .arg(QString::fromUtf8(_Py_wchar2char(Py_GetPath(),NULL))).arg(QString::fromLatin1(Py_GetVersion())); #endif #else .arg(QString::fromUtf8(Py_GetPath())).arg(QString::fromLatin1(Py_GetVersion()));
/*@C PetscPythonInitialize - Initialize Python and import petsc4py. Input Parameter: + pyexe - path to the Python interpreter executable, or NULL. - pylib - full path to the Python dynamic library, or NULL. Level: intermediate .keywords: Python @*/ PetscErrorCode PetscPythonInitialize(const char pyexe[],const char pylib[]) { PyObject *module = 0; PetscErrorCode ierr; PetscFunctionBegin; if (PetscBeganPython) PetscFunctionReturn(0); /* Python executable */ if (pyexe && pyexe[0] != 0) { ierr = PetscStrncpy(PetscPythonExe,pyexe,sizeof(PetscPythonExe));CHKERRQ(ierr); } else { ierr = PetscPythonFindExecutable(PetscPythonExe);CHKERRQ(ierr); } /* Python dynamic library */ if (pylib && pylib[0] != 0) { ierr = PetscStrncpy(PetscPythonLib,pylib,sizeof(PetscPythonLib));CHKERRQ(ierr); } else { ierr = PetscPythonFindLibrary(PetscPythonExe,PetscPythonLib);CHKERRQ(ierr); } /* dynamically load Python library */ ierr = PetscPythonLoadLibrary(PetscPythonLib);CHKERRQ(ierr); /* initialize Python */ PetscBeganPython = PETSC_FALSE; if (!Py_IsInitialized()) { static PetscBool registered = PETSC_FALSE; const char *py_version; PyObject *sys_path; char path[PETSC_MAX_PATH_LEN] = { 0 }; /* initialize Python */ Py_InitializeEx(0); /* 0: do not install signal handlers */ /* build 'sys.argv' list */ py_version = Py_GetVersion(); if (py_version[0] == '2') { int argc = 0; char **argv = 0; ierr = PetscGetArgs(&argc,&argv);CHKERRQ(ierr); PySys_SetArgv(argc,argv); } if (py_version[0] == '3') { /* XXX 'argv' is type 'wchar_t**' */ PySys_SetArgv(0,NULL); } /* add PETSC_LIB_DIR in front of 'sys.path' */ sys_path = PySys_GetObject("path"); if (sys_path) { ierr = PetscStrreplace(PETSC_COMM_SELF,"${PETSC_LIB_DIR}",path,sizeof(path));CHKERRQ(ierr); Py_DecRef(PyObject_CallMethod(sys_path,"insert","is",(int)0,(char*)path)); } /* register finalizer */ if (!registered) { ierr = PetscRegisterFinalize(PetscPythonFinalize);CHKERRQ(ierr); registered = PETSC_TRUE; } PetscBeganPython = PETSC_TRUE; } /* import 'petsc4py.PETSc' module */ module = PyImport_ImportModule("petsc4py.PETSc"); if (module) { ierr = PetscInfo(0,"Python: successfully imported module 'petsc4py.PETSc'\n");CHKERRQ(ierr); Py_DecRef(module); module = 0; } else { PetscPythonPrintError(); SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Python: could not import module 'petsc4py.PETSc', perhaps your PYTHONPATH does not contain it\n"); } PetscFunctionReturn(0); }
void pbs_python_ext_start_interpreter( struct python_interpreter_data *interp_data) { static char func_id[] = "pbs_python_ext_start_interpreter"; #ifdef PYTHON /* -- BEGIN ONLY IF PYTHON IS CONFIGURED -- */ struct stat sbuf; char pbs_python_home[MAXPATHLEN+1]; char pbs_python_destlib[MAXPATHLEN+1]; int evtype; int rc; /* * initialize the convenience global pbs_python_daemon_name, as it is * used everywhere */ pbs_python_daemon_name = interp_data->daemon_name; /* Need to make logging less verbose if pbs_python command */ /* used, since it can get called many times in a pbs daemon, */ /* and it would litter that daemon's logs */ if (IS_PBS_PYTHON_CMD(pbs_python_daemon_name)) evtype = PBSEVENT_DEBUG3; else evtype = PBSEVENT_DEBUG2; memset((char *)pbs_python_home, '\0', MAXPATHLEN+1); memset((char *)pbs_python_destlib, '\0', MAXPATHLEN+1); snprintf(pbs_python_home, MAXPATHLEN, "%s/python", pbs_conf.pbs_exec_path); snprintf(pbs_python_destlib, MAXPATHLEN, "%s/lib64/python/altair", pbs_conf.pbs_exec_path); rc = stat(pbs_python_destlib, &sbuf); if (rc != 0) { snprintf(pbs_python_destlib, MAXPATHLEN, "%s/lib/python/altair", pbs_conf.pbs_exec_path); rc = stat(pbs_python_destlib, &sbuf); } if (rc != 0) { log_err(-1, func_id, "--> PBS Python library directory not found <--"); return; } if (!S_ISDIR(sbuf.st_mode)) { log_err(-1, func_id, "--> PBS Python library path is not a directory <--"); return; } if (interp_data) { interp_data->init_interpreter_data(interp_data); /* to be safe */ if (interp_data->interp_started) { log_event(evtype, PBS_EVENTCLASS_SERVER, LOG_INFO, interp_data->daemon_name, "--> Python interpreter already started <--"); return; } } else { /* we need to allocate memory */ log_err(-1, func_id, "--> Passed NULL for interpreter data <--"); return; } Py_NoSiteFlag = 1; Py_FrozenFlag = 1; Py_OptimizeFlag = 2; /* TODO make this a compile flag variable */ Py_IgnoreEnvironmentFlag = 1; /* ignore PYTHONPATH and PYTHONHOME */ if (file_exists(pbs_python_home)) Py_SetPythonHome(pbs_python_home); /* we make sure our top level module is initialized */ if ((PyImport_ExtendInittab(pbs_python_inittab_modules) != 0)) { log_err(-1, "PyImport_ExtendInittab", "--> Failed to initialize Python interpreter <--"); return; } Py_InitializeEx(1); /* arg '1' means to not skip init of signals - */ /* we want signals to propagate to the executing */ /* Python script to be able to interrupt it */ if (Py_IsInitialized()) { interp_data->interp_started = 1; /* mark python as initialized */ /* print only the first five characters, TODO check for NULL? */ snprintf(log_buffer, LOG_BUF_SIZE-1, "--> Python Interpreter started, compiled with version:'%.*s' <--", 5, Py_GetVersion()); log_buffer[LOG_BUF_SIZE-1] = '\0'; log_event(evtype, PBS_EVENTCLASS_SERVER, LOG_INFO, interp_data->daemon_name, log_buffer); } else { log_err(-1, "Py_InitializeEx", "--> Failed to initialize Python interpreter <--"); goto ERROR_EXIT; } /* * Add Altair python module directory to sys path. NOTE: * PBS_PYTHON_MODULE_DIR is a command line define, also insert * standard required python modules */ if (pbs_python_modify_syspath(pbs_python_destlib, -1) == -1) { snprintf(log_buffer, LOG_BUF_SIZE-1, "could not insert %s into sys.path shutting down", pbs_python_destlib); log_buffer[LOG_BUF_SIZE-1] = '\0'; log_err(-1, func_id, log_buffer); goto ERROR_EXIT; } /* * At this point it is safe to load the available server types from * the python modules. since the syspath is setup correctly */ if ((pbs_python_load_python_types(interp_data) == -1)) { log_err(-1, func_id, "could not load python types into the interpreter"); goto ERROR_EXIT; } interp_data->pbs_python_types_loaded = 1; /* just in case */ return; ERROR_EXIT: pbs_python_ext_shutdown_interpreter(interp_data); return; #else /* !PYTHON */ log_event(PBSEVENT_SYSTEM|PBSEVENT_ADMIN | PBSEVENT_DEBUG, PBS_EVENTCLASS_SERVER, LOG_INFO, "start_python", "--> Python interpreter not built in <--"); return; #endif /* PYTHON */ }
void pybase::lib_setup() { post(""); post("------------------------------------------------"); post("py/pyext %s - python script objects",PY__VERSION); post("(C)2002-2015 Thomas Grill - http://grrrr.org/ext"); post(""); post("using Python %s",Py_GetVersion()); #ifdef FLEXT_DEBUG post(""); post("DEBUG version compiled on %s %s",__DATE__,__TIME__); #endif // ------------------------------------------------------------- sym_response = flext::MakeSymbol("response"); #if FLEXT_SYS == FLEXT_SYS_PD sym_fint = sym_float; #else sym_fint = sym_int; #endif // ------------------------------------------------------------- Py_Initialize(); #ifdef FLEXT_DEBUG // Py_DebugFlag = 1; // Py_VerboseFlag = 1; #else Py_OptimizeFlag = 1; #endif #ifdef FLEXT_THREADS // enable thread support and acquire the global thread lock PyEval_InitThreads(); #ifndef PY_USE_GIL // get thread state pythrsys = PyThreadState_Get(); // get main interpreter state pymain = pythrsys->interp; // add thread state of main thread to map pythrmap[GetThreadId()] = pythrsys; #endif // PY_USE_GIL #endif // sys.argv must be set to empty tuple const char *nothing = ""; PySys_SetArgv(0,const_cast<char **>(¬hing)); // register/initialize pyext module only once! module_obj = Py_InitModule(const_cast<char *>(PYEXT_MODULE), func_tbl); module_dict = PyModule_GetDict(module_obj); // borrowed reference PyModule_AddStringConstant(module_obj,"__doc__",(char *)py_doc); // redirect stdout PyObject* py_out; py_out = Py_InitModule(const_cast<char *>("stdout"), StdOut_Methods); PySys_SetObject(const_cast<char *>("stdout"), py_out); py_out = Py_InitModule(const_cast<char *>("stderr"), StdOut_Methods); PySys_SetObject(const_cast<char *>("stderr"), py_out); // get garbage collector function PyObject *gcobj = PyImport_ImportModule("gc"); if(gcobj) { gcollect = PyObject_GetAttrString(gcobj,"collect"); Py_DECREF(gcobj); } builtins_obj = PyImport_ImportModule("__builtin__"); builtins_dict = PyModule_GetDict(builtins_obj); // borrowed reference // add symbol type initsymbol(); PyModule_AddObject(module_obj,"Symbol",(PyObject *)&pySymbol_Type); // pre-defined symbols PyModule_AddObject(module_obj,"_s_",(PyObject *)pySymbol__); PyModule_AddObject(module_obj,"_s_bang",(PyObject *)pySymbol_bang); PyModule_AddObject(module_obj,"_s_list",(PyObject *)pySymbol_list); PyModule_AddObject(module_obj,"_s_symbol",(PyObject *)pySymbol_symbol); PyModule_AddObject(module_obj,"_s_float",(PyObject *)pySymbol_float); PyModule_AddObject(module_obj,"_s_int",(PyObject *)pySymbol_int); // add samplebuffer type initsamplebuffer(); PyModule_AddObject(module_obj,"Buffer",(PyObject *)&pySamplebuffer_Type); // add message bundle type initbundle(); PyModule_AddObject(module_obj,"Bundle",(PyObject *)&pyBundle_Type); // ------------------------------------------------------------- #if FLEXT_SYS == FLEXT_SYS_PD && defined(PD_DEVEL_VERSION) && defined(PY_USE_INOFFICIAL) // add PD paths char *dir; for(int i = 0; (dir = namelist_get(sys_searchpath,i)) != NULL; ++i) { AddToPath(dir); } #endif // ------------------------------------------------------------- FLEXT_SETUP(pyobj); FLEXT_SETUP(pymeth); FLEXT_SETUP(pyext); #ifndef PY_NODSP FLEXT_DSP_SETUP(pydsp); #endif #ifdef FLEXT_THREADS // release global lock PyEval_ReleaseLock(); // launch thread worker LaunchThread(quworker,NULL); // launch python worker LaunchThread(pyworker,NULL); #endif post("------------------------------------------------"); post(""); }
int main( int argc, char ** argv ) { #if defined (FC_OS_LINUX) || defined(FC_OS_BSD) // Make sure to setup the Qt locale system before setting LANG and LC_ALL to C. // which is needed to use the system locale settings. (void)QLocale::system(); // http://www.freecadweb.org/tracker/view.php?id=399 // Because of setting LANG=C the Qt automagic to use the correct encoding // for file names is broken. This is a workaround to force the use of UTF-8 encoding QFile::setEncodingFunction(myEncoderFunc); QFile::setDecodingFunction(myDecoderFunc); // Make sure that we use '.' as decimal point. See also // http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=559846 putenv("LC_NUMERIC=C"); putenv("PYTHONPATH="); #elif defined(FC_OS_MACOSX) (void)QLocale::system(); putenv("LC_NUMERIC=C"); putenv("PYTHONPATH="); #else setlocale(LC_NUMERIC, "C"); _putenv("PYTHONPATH="); #endif #if defined (FC_OS_WIN32) int argc_ = argc; QVector<QByteArray> data; QVector<char *> argv_; // get the command line arguments as unicode string { QCoreApplication app(argc, argv); QStringList args = app.arguments(); for (QStringList::iterator it = args.begin(); it != args.end(); ++it) { data.push_back(it->toUtf8()); argv_.push_back(data.back().data()); } argv_.push_back(0); // 0-terminated string } #endif // Name and Version of the Application App::Application::Config()["ExeName"] = "FreeCAD"; App::Application::Config()["ExeVendor"] = "FreeCAD"; App::Application::Config()["AppDataSkipVendor"] = "true"; App::Application::Config()["MaintainerUrl"] = "http://www.freecadweb.org/wiki/index.php?title=Main_Page"; // set the banner (for logging and console) App::Application::Config()["CopyrightInfo"] = sBanner; App::Application::Config()["AppIcon"] = "freecad"; App::Application::Config()["SplashScreen"] = "freecadsplash"; App::Application::Config()["StartWorkbench"] = "StartWorkbench"; //App::Application::Config()["HiddenDockWindow"] = "Property editor"; App::Application::Config()["SplashAlignment" ] = "Bottom|Left"; App::Application::Config()["SplashTextColor" ] = "#ffffff"; // white App::Application::Config()["SplashInfoColor" ] = "#c8c8c8"; // light grey try { // Init phase =========================================================== // sets the default run mode for FC, starts with gui if not overridden in InitConfig... App::Application::Config()["RunMode"] = "Gui"; // Inits the Application #if defined (FC_OS_WIN32) App::Application::init(argc_, argv_.data()); #else App::Application::init(argc, argv); #endif #if defined(_MSC_VER) // create a dump file when the application crashes std::string dmpfile = App::Application::getUserAppDataDir(); dmpfile += "crash.dmp"; InitMiniDumpWriter(dmpfile); #endif std::map<std::string, std::string>::iterator it = App::Application::Config().find("NavigationStyle"); if (it != App::Application::Config().end()) { ParameterGrp::handle hGrp = App::GetApplication().GetParameterGroupByPath("User parameter:BaseApp/Preferences/View"); // if not already defined do it now (for the very first start) std::string style = hGrp->GetASCII("NavigationStyle", it->second.c_str()); hGrp->SetASCII("NavigationStyle", style.c_str()); } Gui::Application::initApplication(); // Only if 'RunMode' is set to 'Gui' do the replacement if (App::Application::Config()["RunMode"] == "Gui") Base::Interpreter().replaceStdOutput(); } catch (const Base::UnknownProgramOption& e) { QApplication app(argc,argv); QString appName = QString::fromAscii(App::Application::Config()["ExeName"].c_str()); QString msg = QString::fromAscii(e.what()); QString s = QLatin1String("<pre>") + msg + QLatin1String("</pre>"); QMessageBox::critical(0, appName, s); exit(1); } catch (const Base::ProgramInformation& e) { QApplication app(argc,argv); QString appName = QString::fromAscii(App::Application::Config()["ExeName"].c_str()); QString msg = QString::fromAscii(e.what()); QString s = QLatin1String("<pre>") + msg + QLatin1String("</pre>"); QMessageBox::information(0, appName, s); exit(0); } catch (const Base::Exception& e) { // Popup an own dialog box instead of that one of Windows QApplication app(argc,argv); QString appName = QString::fromAscii(App::Application::Config()["ExeName"].c_str()); QString msg; msg = QObject::tr("While initializing %1 the following exception occurred: '%2'\n\n" "Python is searching for its files in the following directories:\n%3\n\n" "Python version information:\n%4\n") .arg(appName).arg(QString::fromUtf8(e.what())) .arg(QString::fromUtf8(Py_GetPath())).arg(QString::fromAscii(Py_GetVersion())); const char* pythonhome = getenv("PYTHONHOME"); if (pythonhome) { msg += QObject::tr("\nThe environment variable PYTHONHOME is set to '%1'.") .arg(QString::fromUtf8(pythonhome)); msg += QObject::tr("\nSetting this environment variable might cause Python to fail. " "Please contact your administrator to unset it on your system.\n\n"); } else { msg += QObject::tr("\nPlease contact the application's support team for more information.\n\n"); } QMessageBox::critical(0, QObject::tr("Initialization of %1 failed").arg(appName), msg); exit(100); } catch (...) { // Popup an own dialog box instead of that one of Windows QApplication app(argc,argv); QString appName = QString::fromAscii(App::Application::Config()["ExeName"].c_str()); QString msg = QObject::tr("Unknown runtime error occurred while initializing %1.\n\n" "Please contact the application's support team for more information.\n\n").arg(appName); QMessageBox::critical(0, QObject::tr("Initialization of %1 failed").arg(appName), msg); exit(101); } // Run phase =========================================================== Base::RedirectStdOutput stdcout; Base::RedirectStdLog stdclog; Base::RedirectStdError stdcerr; std::streambuf* oldcout = std::cout.rdbuf(&stdcout); std::streambuf* oldclog = std::clog.rdbuf(&stdclog); std::streambuf* oldcerr = std::cerr.rdbuf(&stdcerr); try { if (App::Application::Config()["RunMode"] == "Gui") Gui::Application::runApplication(); else App::Application::runApplication(); } catch (const Base::SystemExitException&) { exit(0); } catch (const Base::Exception& e) { Base::Console().Error("%s\n", e.what()); } catch (...) { Base::Console().Error("Application unexpectedly terminated\n"); } std::cout.rdbuf(oldcout); std::clog.rdbuf(oldclog); std::cerr.rdbuf(oldcerr); // Destruction phase =========================================================== Base::Console().Log("%s terminating...\n",App::Application::Config()["ExeName"].c_str()); // cleans up App::Application::destruct(); Base::Console().Log("%s completely terminated\n",App::Application::Config()["ExeName"].c_str()); return 0; }
/* * Class: org_jpy_PyLib * Method: startPython0 * Signature: ([Ljava/lang/String;)Z */ JNIEXPORT jboolean JNICALL Java_org_jpy_PyLib_startPython0 (JNIEnv* jenv, jclass jLibClass, jobjectArray jPathArray) { int pyInit = Py_IsInitialized(); JPy_DIAG_PRINT(JPy_DIAG_F_ALL, "PyLib_startPython: entered: jenv=%p, pyInit=%d, JPy_Module=%p\n", jenv, pyInit, JPy_Module); if (!pyInit) { Py_Initialize(); PyLib_RedirectStdOut(); pyInit = Py_IsInitialized(); } if (pyInit) { if (JPy_DiagFlags != 0) { printf("PyLib_startPython: global Python interpreter information:\n"); #if defined(JPY_COMPAT_33P) printf(" Py_GetProgramName() = \"%ls\"\n", Py_GetProgramName()); printf(" Py_GetPrefix() = \"%ls\"\n", Py_GetPrefix()); printf(" Py_GetExecPrefix() = \"%ls\"\n", Py_GetExecPrefix()); printf(" Py_GetProgramFullPath() = \"%ls\"\n", Py_GetProgramFullPath()); printf(" Py_GetPath() = \"%ls\"\n", Py_GetPath()); printf(" Py_GetPythonHome() = \"%ls\"\n", Py_GetPythonHome()); #elif defined(JPY_COMPAT_27) printf(" Py_GetProgramName() = \"%s\"\n", Py_GetProgramName()); printf(" Py_GetPrefix() = \"%s\"\n", Py_GetPrefix()); printf(" Py_GetExecPrefix() = \"%s\"\n", Py_GetExecPrefix()); printf(" Py_GetProgramFullPath() = \"%s\"\n", Py_GetProgramFullPath()); printf(" Py_GetPath() = \"%s\"\n", Py_GetPath()); printf(" Py_GetPythonHome() = \"%s\"\n", Py_GetPythonHome()); #endif printf(" Py_GetVersion() = \"%s\"\n", Py_GetVersion()); printf(" Py_GetPlatform() = \"%s\"\n", Py_GetPlatform()); printf(" Py_GetCompiler() = \"%s\"\n", Py_GetCompiler()); printf(" Py_GetBuildInfo() = \"%s\"\n", Py_GetBuildInfo()); } // If we've got jPathArray, add all entries to Python's "sys.path" // if (jPathArray != NULL) { PyObject* pyPathList; PyObject* pyPath; jstring jPath; jsize i, pathCount; pathCount = (*jenv)->GetArrayLength(jenv, jPathArray); //printf(">> pathCount=%d\n", pathCount); if (pathCount > 0) { JPy_BEGIN_GIL_STATE pyPathList = PySys_GetObject("path"); //printf(">> pyPathList=%p, len=%ld\n", pyPathList, PyList_Size(pyPathList)); if (pyPathList != NULL) { Py_INCREF(pyPathList); for (i = pathCount - 1; i >= 0; i--) { jPath = (*jenv)->GetObjectArrayElement(jenv, jPathArray, i); //printf(">> i=%d, jPath=%p\n", i, jPath); if (jPath != NULL) { pyPath = JPy_FromJString(jenv, jPath); //printf(">> i=%d, pyPath=%p\n", i, pyPath); if (pyPath != NULL) { PyList_Insert(pyPathList, 0, pyPath); } } } Py_DECREF(pyPathList); } //printf(">> pyPathList=%p, len=%ld\n", pyPathList, PyList_Size(pyPathList)); //printf(">> pyPathList=%p, len=%ld (check)\n", PySys_GetObject("path"), PyList_Size(PySys_GetObject("path"))); JPy_END_GIL_STATE } }
int Py_FrozenMain(int argc, char **argv) { _PyInitError err = _PyRuntime_Initialize(); if (_Py_INIT_FAILED(err)) { fprintf(stderr, "Fatal Python error: %s\n", err.msg); fflush(stderr); exit(1); } const char *p; int i, n, sts = 1; int inspect = 0; int unbuffered = 0; char *oldloc = NULL; wchar_t **argv_copy = NULL; /* We need a second copies, as Python might modify the first one. */ wchar_t **argv_copy2 = NULL; if (argc > 0) { argv_copy = PyMem_RawMalloc(sizeof(wchar_t*) * argc); argv_copy2 = PyMem_RawMalloc(sizeof(wchar_t*) * argc); if (!argv_copy || !argv_copy2) { fprintf(stderr, "out of memory\n"); goto error; } } _PyCoreConfig config = _PyCoreConfig_INIT; config._frozen = 1; /* Suppress errors from getpath.c */ if ((p = Py_GETENV("PYTHONINSPECT")) && *p != '\0') inspect = 1; if ((p = Py_GETENV("PYTHONUNBUFFERED")) && *p != '\0') unbuffered = 1; if (unbuffered) { setbuf(stdin, (char *)NULL); setbuf(stdout, (char *)NULL); setbuf(stderr, (char *)NULL); } oldloc = _PyMem_RawStrdup(setlocale(LC_ALL, NULL)); if (!oldloc) { fprintf(stderr, "out of memory\n"); goto error; } setlocale(LC_ALL, ""); for (i = 0; i < argc; i++) { argv_copy[i] = Py_DecodeLocale(argv[i], NULL); argv_copy2[i] = argv_copy[i]; if (!argv_copy[i]) { fprintf(stderr, "Unable to decode the command line argument #%i\n", i + 1); argc = i; goto error; } } setlocale(LC_ALL, oldloc); PyMem_RawFree(oldloc); oldloc = NULL; #ifdef MS_WINDOWS PyInitFrozenExtensions(); #endif /* MS_WINDOWS */ if (argc >= 1) Py_SetProgramName(argv_copy[0]); err = _Py_InitializeFromConfig(&config); /* No need to call _PyCoreConfig_Clear() since we didn't allocate any memory: program_name is a constant string. */ if (_Py_INIT_FAILED(err)) { _Py_FatalInitError(err); } #ifdef MS_WINDOWS PyWinFreeze_ExeInit(); #endif if (Py_VerboseFlag) fprintf(stderr, "Python %s\n%s\n", Py_GetVersion(), Py_GetCopyright()); PySys_SetArgv(argc, argv_copy); n = PyImport_ImportFrozenModule("__main__"); if (n == 0) Py_FatalError("__main__ not frozen"); if (n < 0) { PyErr_Print(); sts = 1; } else sts = 0; if (inspect && isatty((int)fileno(stdin))) sts = PyRun_AnyFile(stdin, "<stdin>") != 0; #ifdef MS_WINDOWS PyWinFreeze_ExeTerm(); #endif if (Py_FinalizeEx() < 0) { sts = 120; } error: PyMem_RawFree(argv_copy); if (argv_copy2) { for (i = 0; i < argc; i++) PyMem_RawFree(argv_copy2[i]); PyMem_RawFree(argv_copy2); } PyMem_RawFree(oldloc); return sts; }
static void smisk_crash_sighandler(int signum, siginfo_t* info, void*ptr) { FILE *out = NULL; char out_fn[PATH_MAX]; char cwd_buf[PATH_MAX]; char *cwd = NULL; struct tm *t; time_t timer; size_t i = 0; const char *found_gdb_path; char cmd[1024]; // Signal code table (from http://www.opengroup.org/onlinepubs/007908799/xsh/signal.h.html) static const char *si_codes[][9] = { {"", "", "", "", "", "", "", "", ""}, {"", "", "", "", "", "", "", "", ""}, {"", "", "", "", "", "", "", "", ""}, {"", "ILL_ILLOPC\tillegal opcode", "ILL_ILLOPN\tillegal operand", "ILL_ILLADR\tillegal addressing mode", "ILL_ILLTRP\tillegal trap", "ILL_PRVOPC\tprivileged opcode", "ILL_PRVREG\tprivileged register", "ILL_COPROC\tcoprocessor error", "ILL_BADSTK\tinternal stack error"}, // ILL {"", "", "", "", "", "", "", "", ""}, {"", "", "", "", "", "", "", "", ""}, {"", "", "", "", "", "", "", "", ""}, {"", "FPE_INTDIV\tinteger divide by zero", "FPE_INTOVF\tinteger overflow", "FPE_FLTDIV\tfloating point divide by zero", "FPE_FLTOVF\tfloating point overflow", "FPE_FLTUND\tfloating point underflow", "FPE_FLTRES\tfloating point inexact result", "FPE_FLTINV\tinvalid floating point operation", "FPE_FLTSUB\tsubscript out of range"}, // FPE {"", "", "", "", "", "", "", "", ""}, {"", "BUS_ADRALN\tinvalid address alignment", "BUS_ADRERR\tnon-existent physical address", "BUS_OBJERR\tobject specific hardware error", "", "", "", ""}, // BUS {"", "SEGV_MAPERR\taddress not mapped to object", "SEGV_ACCERR\tinvalid permissions for mapped object", "", "", "", "", "", ""} // SEGV }; // Possible paths to GDB static const char *gdb_path[] = { "/usr/bin/gdb", "/usr/local/bin/gdb", "/opt/local/bin/gdb", "/opt/bin/gdb", "/local/bin/gdb", NULL }; // Header fputs("FATAL: smisk died from ", stderr); switch(signum) { case SIGILL: fputs("Illegal instruction ", stderr); break; case SIGFPE: fputs("Floating-point exception ", stderr); break; case SIGBUS: fputs("Bus error ", stderr); break; case SIGSEGV: fputs("Segmentation violation ", stderr); break; } fprintf(stderr, "[%d] ", signum); fflush(stderr); // Construct filename smisk-YYYYMMDD-HHMMSS.PID.crash timer = time(NULL); t = localtime(&timer); cwd = getcwd(cwd_buf, PATH_MAX); sprintf(out_fn, "%s/smisk-%04d%02d%02d-%02d%02d%02d.%d.crash", (access(cwd ? cwd : ".", W_OK) == 0) ? (cwd ? cwd : ".") : "/tmp", 1900+t->tm_year, t->tm_mon+1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, getpid()); // Open file fprintf(stderr, "Writing crash dump to %s...\n", out_fn); out = fopen(out_fn, "w"); if (!out) out = stderr; // Basic info fprintf(out, "Time: %04d-%02d-%02d %02d:%02d:%02d\n", 1900+t->tm_year, t->tm_mon+1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); fprintf(out, "Process: %d\n", getpid()); fprintf(out, "Working directory: %s\n", cwd ? cwd : "?"); fprintf(out, "Python: %s %s\n", Py_GetProgramFullPath(), Py_GetVersion()); fprintf(out, "Smisk: %s (%s)\n", SMISK_VERSION, SMISK_BUILD_ID); #if HAVE_SYS_UTSNAME_H struct utsname un; if (uname(&un) == 0) { fprintf(out, "System: %s, %s, %s, %s\n", un.sysname, un.release, un.version, un.machine); fprintf(out, "Hostname: %s\n", un.nodename); } else #endif fprintf(out, "System: %s\n", Py_GetPlatform()); fprintf(out, "\n"); fprintf(out, "Signal: %d\n", signum); fprintf(out, "Errno: %d\n", info->si_errno); fprintf(out, "Code: %d\t%s\n", info->si_code, (signum > 0) ? si_codes[signum-1][info->si_code] : "?"); fprintf(out, "Address: %p\n", info->si_addr); // Find GDB i = 0; found_gdb_path = NULL; do { if (access(*(gdb_path+i), R_OK) == 0) { found_gdb_path = *(gdb_path+i); log_debug("found gdb at %s", found_gdb_path); break; } } while ( *(gdb_path + ++i) ); // Write backtrace fprintf(out, "\nBacktrace:\n"); if (found_gdb_path) { fclose(out); system("/bin/echo 'backtrace' > /tmp/smisk_gdb_args"); sprintf(cmd, "%s -batch -x /tmp/smisk_gdb_args %s %d >> %s", found_gdb_path, Py_GetProgramFullPath(), getpid(), out_fn); system(cmd); } else { log_error("Note: GDB not found. Install GDB to get a more detailed backtrace."); smisk_crash_write_backtrace(info, ptr, out); fclose(out); } //exit(-1); _exit(-1); }