PythonModules::PythonModules(QString name, Pip3lineCallback *callback) : ModulesManagement(name, PYTHON_EXTENSION, BASE_SCRIPTS_DIR, callback) { pyGetValFunc = nullptr; pyStringIO = nullptr; pyTruncateFunc = nullptr; pySeekFunc = nullptr; Py_SetProgramName(PROG_NAME); Py_DontWriteBytecodeFlag++; #if defined(Q_OS_WIN) && !defined(BUILD_PYTHON_3) pythonPath = PythonModules::initPythonPath(); Py_SetPythonHome(pythonPath); #endif //Q_OS_WIN && !BUILD_PYTHON_3 // initialize the Python interpreter without signal handler Py_InitializeEx(0); // initialize thread support PyEval_InitThreads(); // saving thread state pymainstate = PyEval_SaveThread(); connect(this, &PythonModules::pathsUpdated, this, &PythonModules::updatePath); qDebug() << "Created " << this; }
bool CmdSrvHosts::processArguments( int argc, char** argv, af::Msg &msg) { Py_InitializeEx(0); std::string command( argv[1]); std::list<std::string> hosts; for( int a = 2; a < argc; a++) hosts.push_back( argv[a]); std::string wdir; int capacity = -1; std::string files; af::Service service( argv[0], wdir, command, files, capacity, hosts); if( service.isInitialized() == false) { AFERRAR("Service '%s' initialization failed.\n", argv[0]); return false; } command = service.getCommand(); std::cout << "Result Command:"; std::cout << std::endl; std::cout << command; std::cout << std::endl; Py_Finalize(); return true; }
void PyInviwo::initPythonCInterface() { if (isInit_) return; isInit_ = true; LogInfo("Python version: " + toString(Py_GetVersion())); wchar_t programName[] = L"PyInviwo"; Py_SetProgramName(programName); #ifdef WIN32 Py_NoSiteFlag = 1; #endif Py_InitializeEx(false); if (!Py_IsInitialized()) { LogError("Python is not Initialized"); return; } PyEval_InitThreads(); mainDict_ = PyDict_New(); modulesDict_ = PyImport_GetModuleDict(); importModule("builtins"); importModule("sys"); importModule("os"); importModule("glob"); importModule("random"); addModulePath(InviwoApplication::getPtr()->getBasePath() + "/modules/python3/scripts"); initDefaultInterfaces(); initOutputRedirector(); }
/* Initialize Python interpreter */ static void python_system_init(lua_State *L) { char *python_home = luaL_check_string(L, 1); if (!Py_IsInitialized()) { python_setnumber(L, PY_API_IS_EMBEDDED, 1); // If python is inside Lua if (PyType_Ready(&LuaObject_Type) == 0) { Py_INCREF(&LuaObject_Type); } else { lua_error(L, "failure initializing lua object type"); } PyObject *luam, *mainm, *maind; #if PY_MAJOR_VERSION >= 3 wchar_t *argv[] = {L"<lua_bootstrap>", 0}; #else char *argv[] = {"<lua_bootstrap>", 0}; #endif Py_SetProgramName(argv[0]); Py_SetPythonHome(python_home); Py_InitializeEx(0); PySys_SetArgv(1, argv); /* Import 'lua' automatically. */ luam = PyImport_ImportModule("lua_bootstrap"); if (!luam) { lua_error(L, "Can't import lua_bootstrap module"); } else { mainm = PyImport_AddModule("__main__"); if (!mainm) { lua_error(L, "Can't get __main__ module"); } else { maind = PyModule_GetDict(mainm); PyDict_SetItemString(maind, "lua_bootstrap", luam); Py_DECREF(luam); } } } }
void PyInviwo::initPythonCInterface(Python3Module* module) { if (isInit_) return; isInit_ = true; LogInfo("Python version: " + toString(Py_GetVersion())); wchar_t programName[] = L"PyInviwo"; Py_SetProgramName(programName); Py_InitializeEx(false); if (!Py_IsInitialized()) { LogError("Python is not Initialized"); return; } PyEval_InitThreads(); importModule("builtins"); importModule("sys"); dict_ = PyImport_GetModuleDict(); registerPyModule(&Inviwo_Internals_Module_Def, "inviwo_internal"); registerPyModule(&Inviwo_Module_Def, "inviwo"); addModulePath(module->getPath() + "/scripts"); initOutputRedirector(module); }
static int mod_init(rlm_python_t *inst) { int i; static char name[] = "radiusd"; if (radiusd_module) return 0; /* * Explicitly load libpython, so symbols will be available to lib-dynload modules */ inst->libpython = dlopen("libpython" STRINGIFY(PY_MAJOR_VERSION) "." STRINGIFY(PY_MINOR_VERSION) ".so", RTLD_NOW | RTLD_GLOBAL); if (!inst->libpython) { WARN("Failed loading libpython symbols into global symbol table: %s", dlerror()); } Py_SetProgramName(name); #ifdef HAVE_PTHREAD_H Py_InitializeEx(0); /* Don't override signal handlers */ PyEval_InitThreads(); /* This also grabs a lock */ inst->main_thread_state = PyThreadState_Get(); /* We need this for setting up thread local stuff */ #endif if (inst->python_path) { PySys_SetPath(inst->python_path); } if ((radiusd_module = Py_InitModule3("radiusd", radiusd_methods, "FreeRADIUS Module.")) == NULL) goto failed; for (i = 0; radiusd_constants[i].name; i++) { if ((PyModule_AddIntConstant(radiusd_module, radiusd_constants[i].name, radiusd_constants[i].value)) < 0) { goto failed; } } #ifdef HAVE_PTHREAD_H PyThreadState_Swap(NULL); /* We have to swap out the current thread else we get deadlocks */ PyEval_ReleaseLock(); /* Drop lock grabbed by InitThreads */ #endif DEBUG("mod_init done"); return 0; failed: Py_XDECREF(radiusd_module); #ifdef HAVE_PTHREAD_H PyEval_ReleaseLock(); #endif Pyx_BLOCK_THREADS mod_error(); Pyx_UNBLOCK_THREADS radiusd_module = NULL; Py_Finalize(); return -1; }
void python_init(void) { Py_InitializeEx(0); pysignals_init(); pystatusbar_init(); if (!pyloader_init() || !pymodule_init() || !factory_init() || !pythemes_init()) { printtext(NULL, NULL, MSGLEVEL_CLIENTERROR, "Failed to load Python"); return; } pyconstants_init(); /*PyImport_ImportModule("irssi_startup");*/ /* Install the custom output handlers, import hook and reload function */ /* XXX: handle import error */ PyRun_SimpleString( "import irssi_startup\n" ); pyloader_auto_load(); /* assert(signal(SIGINT, intr_catch) != SIG_ERR); */ command_bind("py", NULL, (SIGNAL_FUNC) cmd_default); command_bind("py load", NULL, (SIGNAL_FUNC) cmd_load); command_bind("py unload", NULL, (SIGNAL_FUNC) cmd_unload); command_bind("py list", NULL, (SIGNAL_FUNC) cmd_list); command_bind("py exec", NULL, (SIGNAL_FUNC) cmd_exec); module_register(MODULE_NAME, "core"); }
//! Initializes Python VM int script_init() { Py_InitializeEx(0); // Initialize exceptions PyExc_COMAR_Internal = PyErr_NewException("Comar.Internal", NULL, NULL); PyExc_COMAR_Invalid = PyErr_NewException("Comar.Invalid", NULL, NULL); PyExc_COMAR_Script = PyErr_NewException("Comar.Script", NULL, NULL); PyExc_COMAR_Missing = PyErr_NewException("Comar.Missing", NULL, NULL); PyExc_DBus = PyErr_NewException("Comar.DBus", NULL, NULL); PyExc_PolicyKit = PyErr_NewException("Comar.PolicyKit", NULL, NULL); // Load model definitions PyObject *py_models; if (db_load_models(&py_models) != 0) { return -1; } if (PyDict_Size(py_models) == 0) { log_error("No models present in data/models directory.\n"); return -1; } // Build core dictionary py_core = PyDict_New(); PyDict_SetItemString(py_core, "models", py_models); PyDict_SetItemString(py_core, "locales", PyDict_New()); log_debug("Models defined : %d\n", PyDict_Size(py_models)); log_debug("\n"); return 0; }
bool EmbedPython::init() { if(initialized) return true; /** Setting Python folder */ QDir dir(qApp->applicationDirPath()); // QString p = QString("python27"); py_progname = p.toLocal8Bit(); #if __APPLE__ dir.cdUp(); dir.cd("Resources"); dir.cd("site-packages"); #endif p = dir.absolutePath();// + dir.separator() + QString("embed"); py_pythonhome = p.toLocal8Bit(); //QMessageBox::warning(NULL, "", p); #if !__APPLE__ Py_SetProgramName(py_progname.data()); // qDebug()<<"program path:"<<Py_GetProgramFullPath(); // qDebug()<<"program name:"<<Py_GetProgramName(); // qDebug()<<"python path:"<<Py_GetPath() ; Py_SetPythonHome(py_pythonhome.data()); #endif // qDebug()<<"program home:"<<Py_GetPythonHome(); // qDebug()<<"program path:"<<Py_GetProgramFullPath(); // qDebug()<<"program name:"<<Py_GetProgramName(); // qDebug()<<"python path:"<<Py_GetPath() ; // QMessageBox::warning(NULL, "", Py_GetPath()); /** Initialize Python */ Py_InitializeEx(0); //Py_Initialize(); if(Py_IsInitialized() != 0) { initialized = true; //globals = PyList_New(0); //locals = PyList_New(0); // PyObject* fromlist = PyList_New(1); // PyList_SET_ITEM(fromlist, 0, PyString_FromString("*")); /** Import main module */ // char mname[512]; // memset(mname, 0, 512); // memcpy(mname, "__main__", sizeof("__main__")); // mainmodel = PyImport_ImportModuleEx(mname, globals, locals, fromlist); // checkError(); /** Import modeltool module */ // memset(mname, 0, 512); // memcpy(mname, MODELTOOL, sizeof(MODELTOOL)); //modeltool = PyImport_ImportModuleEx(mname, globals, locals, fromlist); QString cmd = QString("import sys; import os; sys.path.append(os.path.abspath('%1'))") #if __APPLE__ .arg(dir.absolutePath()); #else .arg(qApp->applicationDirPath());
void initialize() { if(!Py_IsInitialized()) { Py_InitializeEx(0); // 0 -> do not handle signals SLM_ASSERT( "python initialization failed ", isInitialized() ); } }
void PythonModule::subscribe() { if(subscribers==0) { // Initialize Python without signal handlers Py_InitializeEx(1); PyEval_InitThreads(); unblock_threads(); } subscribers++; }
void ModuleLoader::init() { Py_InitializeEx(0); PyEval_InitThreads(); //note, this implicitly acquires the lock! g_pymaintstate = PyThreadState_Get(); PyEval_ReleaseLock(); }
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; };
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); } }
python_persistency() { // changed to skip installation of signal handlers [PS] // Py_InitializeEx(0); // Py_Initialize(); // char string_main[]="__main__"; boost::python::object main_module((boost::python::handle<>(boost::python::borrowed(PyImport_AddModule(string_main))))); main_namespace = main_module.attr("__dict__"); };
static void python_init (void) { if (Py_IsInitialized ()) return; Py_InitializeEx (0); /* if argc is 0 an empty string is prepended to sys.path */ PySys_SetArgvEx (0, NULL, 0); }
static int python_init(void) { if (initialized) return TCL_OK; DEBUG_TCL_TURBINE("python: initializing..."); Py_InitializeEx(1); main_module = PyImport_AddModule("__main__"); if (main_module == NULL) return handle_python_exception(); main_dict = PyModule_GetDict(main_module); if (main_dict == NULL) return handle_python_exception(); initialized = true; return TCL_OK; }
void PyManager::initialize(const wchar_t *wszProgram, int siginit) { if (!Py_IsInitialized()) { if(g_program) Py_SetProgramName(const_cast<decltype(g_program)>(wszProgram)); Py_InitializeEx(siginit); // Create default events createEvent("register_event"); // Triggered when someone registers handler for an event } }
static void real_init(void) { #ifdef VS_TARGET_OS_WINDOWS // portable const std::wstring pythonDllName = L"python37.dll"; HMODULE module; GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCWSTR)&real_init, &module); std::vector<wchar_t> pathBuf(65536); GetModuleFileNameW(module, pathBuf.data(), (DWORD)pathBuf.size()); std::wstring dllPath = pathBuf.data(); dllPath.resize(dllPath.find_last_of('\\') + 1); std::wstring portableFilePath = dllPath + L"portable.vs"; FILE *portableFile = _wfopen(portableFilePath.c_str(), L"rb"); bool isPortable = !!portableFile; if (portableFile) fclose(portableFile); HMODULE pythonDll = nullptr; if (isPortable) { std::wstring pyPath = dllPath + L"\\" + pythonDllName; pythonDll = LoadLibraryExW(pyPath.c_str(), nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR); } else { DWORD dwType = REG_SZ; HKEY hKey = 0; wchar_t value[1024]; DWORD valueLength = 1000; if (RegOpenKeyW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\VapourSynth", &hKey) != ERROR_SUCCESS) return; LSTATUS status = RegQueryValueExW(hKey, L"PythonPath", nullptr, &dwType, (LPBYTE)&value, &valueLength); RegCloseKey(hKey); if (status != ERROR_SUCCESS) return; std::wstring pyPath = value; pyPath += L"\\" + pythonDllName; pythonDll = LoadLibraryExW(pyPath.c_str(), nullptr, LOAD_LIBRARY_SEARCH_DEFAULT_DIRS | LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR); } if (!pythonDll) return; #endif int preInitialized = Py_IsInitialized(); if (!preInitialized) Py_InitializeEx(0); s = PyGILState_Ensure(); if (import_vapoursynth()) return; if (vpy_initVSScript()) return; ts = PyEval_SaveThread(); initialized = true; }
static int mod_init(rlm_python_t *inst) { int i; static char name[] = "radiusd"; if (radiusd_module) return 0; Py_SetProgramName(name); #ifdef HAVE_PTHREAD_H Py_InitializeEx(0); /* Don't override signal handlers */ PyEval_InitThreads(); /* This also grabs a lock */ inst->main_thread_state = PyThreadState_Get(); /* We need this for setting up thread local stuff */ #endif if (inst->python_path) { PySys_SetPath(inst->python_path); } if ((radiusd_module = Py_InitModule3("radiusd", radiusd_methods, "FreeRADIUS Module.")) == NULL) goto failed; for (i = 0; radiusd_constants[i].name; i++) { if ((PyModule_AddIntConstant(radiusd_module, radiusd_constants[i].name, radiusd_constants[i].value)) < 0) { goto failed; } } #ifdef HAVE_PTHREAD_H PyThreadState_Swap(NULL); /* We have to swap out the current thread else we get deadlocks */ PyEval_ReleaseLock(); /* Drop lock grabbed by InitThreads */ #endif DEBUG("mod_init done"); return 0; failed: Py_XDECREF(radiusd_module); #ifdef HAVE_PTHREAD_H PyEval_ReleaseLock(); #endif Pyx_BLOCK_THREADS mod_error(); Pyx_UNBLOCK_THREADS radiusd_module = NULL; Py_Finalize(); return -1; }
VS_API(int) vseval_init(void) { if (initializationCount == 0) { preInitialized = Py_IsInitialized(); if (!preInitialized) Py_InitializeEx(0); PyGILState_STATE s = PyGILState_Ensure(); int result = import_vapoursynth(); if (result) return 0; vpy_initVSScript(); ts = PyEval_SaveThread(); } initializationCount++; return initializationCount; }
PythonEngine( wchar_t *pypath ) : m_global_dict( nullptr ) { assert__( pypath ); Py_SetPythonHome( pypath ); Py_InitializeEx( 0 ); // Get a reference to the main module and global dictionary // PyObject *main_module = PyImport_AddModule("__main__"); if (main_module) m_global_dict = PyModule_GetDict( main_module ); }
static void _cffi_py_initialize(void) { /* XXX use initsigs=0, which "skips initialization registration of signal handlers, which might be useful when Python is embedded" according to the Python docs. But review and think if it should be a user-controllable setting. XXX we should also give a way to write errors to a buffer instead of to stderr. XXX if importing 'site' fails, CPython (any version) calls exit(). Should we try to work around this behavior here? */ Py_InitializeEx(0); }
/*@C PetscPythonInitialize - Initialize Python and import petsc4py. Input Parameter: + pyexe - path to the Python interpreter executable, or PETSC_NULL. - pylib - full path to the Python dynamic library, or PETSC_NULL. Level: intermediate .keywords: Python @*/ PetscErrorCode PETSC_DLLEXPORT PetscPythonInitialize(const char pyexe[],const char pylib[]) { int argc = 0; char **argv = 0; PyObject *module = 0; static PetscTruth registered = PETSC_FALSE; 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()) { /* call below does not install signal handlers */ Py_InitializeEx(0); /* call below required to build 'sys.argv' list */ ierr = PetscGetArgs(&argc,&argv);CHKERRQ(ierr); if (argc && argv && argv[0]) PySys_SetArgv(argc,argv); /* 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 { SETERRQ(PETSC_ERR_PLIB,"Python: could not import module 'petsc4py.PETSc', perhaps your PYTHONPATH does not contain it\n"); } PetscFunctionReturn(0); }
mraa_init() { /** Once more board definitions have been added, * A method for detecting them will need to be devised. */ if (plat != NULL) { return MRAA_ERROR_PLATFORM_ALREADY_INITIALISED; } #ifdef SWIGPYTHON // Initialise python threads, this allows use to grab the GIL when we are // required to do so Py_InitializeEx(0); PyEval_InitThreads(); #endif // detect a galileo gen2 board char *line = NULL; // let getline allocate memory for *line size_t len = 0; FILE *fh = fopen("/sys/devices/virtual/dmi/id/board_name", "r"); if (fh != NULL) { if (getline(&line, &len, fh) != -1) { if (strncmp(line, "GalileoGen2", 10) == 0) { platform_type = MRAA_INTEL_GALILEO_GEN2; } else { platform_type = MRAA_INTEL_GALILEO_GEN1; } free(line); } fclose(fh); } advance_func = (mraa_adv_func_t*) malloc(sizeof(mraa_adv_func_t)); memset(advance_func, 0, sizeof(mraa_adv_func_t)); switch(platform_type) { case MRAA_INTEL_GALILEO_GEN2: plat = mraa_intel_galileo_gen2(); break; case MRAA_INTEL_GALILEO_GEN1: plat = mraa_intel_galileo_rev_d(); break; default: plat = mraa_intel_galileo_rev_d(); fprintf(stderr, "Platform not found, initialising MRAA_INTEL_GALILEO_GEN1\n"); } return MRAA_SUCCESS; }
/// initializes the python bridge /// only does the initialization on the first call, subsequent calls are ignored static void initPythonBridgeOnce() { static bool alreadyInitialized = false; if( alreadyInitialized) return; alreadyInitialized = true; dlopen("libpython2.7.so", RTLD_LAZY | RTLD_GLOBAL); Py_InitializeEx( 0); // make ctrl-c work? // try to enable ctrl-c... enableCtrlC(); // call cython generated code (pluginBridge.pyx) initpluginBridge(); }
mraa_init() { if (plat != NULL) { return MRAA_ERROR_PLATFORM_ALREADY_INITIALISED; } uid_t proc_euid = geteuid(); struct passwd* proc_user = getpwuid(proc_euid); #ifdef DEBUG setlogmask(LOG_UPTO(LOG_DEBUG)); #else setlogmask(LOG_UPTO(LOG_NOTICE)); #endif openlog("libmraa", LOG_CONS | LOG_PID | LOG_NDELAY, LOG_LOCAL1); syslog(LOG_NOTICE, "libmraa version %s initialised by user '%s' with EUID %d", mraa_get_version(), (proc_user != NULL) ? proc_user->pw_name : "<unknown>", proc_euid); #ifdef SWIGPYTHON // Initialise python threads, this allows use to grab the GIL when we are // required to do so Py_InitializeEx(0); PyEval_InitThreads(); #endif advance_func = (mraa_adv_func_t*) malloc(sizeof(mraa_adv_func_t)); memset(advance_func, 0, sizeof(mraa_adv_func_t)); #if defined(X86PLAT) // Use runtime x86 platform detection platform_type = mraa_x86_platform(); #elif defined(ARMPLAT) // Use runtime ARM platform detection platform_type = mraa_arm_platform(); #else #error mraa_ARCH NOTHING #endif if (plat == NULL) { printf("mraa: FATAL error, failed to initialise platform\n"); return MRAA_ERROR_PLATFORM_NOT_INITIALISED; } syslog(LOG_INFO, "libmraa initialised for platform '%s' of type %d", mraa_get_platform_name(), platform_type); return MRAA_SUCCESS; }
void cu5_pennpy_initialize(void) { FILE *main_py_fp; assert(cu5_pennpy_main == NULL); do_rawlog(LT_ERR, T("PennPy: Initializing")); /* Initialize Python without installing signal handlers. */ Py_InitializeEx(0); /* Borrow a reference to __main__. */ if (!(cu5_pennpy_main = PyImport_AddModule("__main__"))) { /* This shouldn't happen, but you never know. */ mush_panic(T("PennPy: Can't get reference to __main__")); } cu5_pennpy_main_dict = PyModule_GetDict(cu5_pennpy_main); /* Initialize __pennmush__ internal module. */ if (!cu5_pennpy_initialize_module()) { /* Can't initialize module. */ mush_panic(T("PennPy: Can't initialize __pennmush__ module")); } /* Execute game/python/main.py. */ if (!(main_py_fp = fopen(MAIN_PY, "r"))) { /* Can't run main.py. */ do_rawlog(LT_ERR, T("PennPy: Can't open %s"), MAIN_PY); return; } if (PyRun_SimpleFile(main_py_fp, MAIN_PY) != 0) { /* Something wrong with main.py. */ do_rawlog(LT_ERR, T("PennPy: Failed to execute %s"), MAIN_PY); fclose(main_py_fp); return; } fclose(main_py_fp); /* Ready. */ cu5_pennpy_enabled = 1; }