C++ PySys_SetArgv函数代码示例

@@ -1468,7 +1468,7 @@ value pycaml_setargs(value argv) {
 
   PySys_SetArgv(1, cargv);
 
-  CAMLreturn0; 
+  CAMLreturn(Val_unit);
 }

/* 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 PySetup::set_argv(const std::vector<std::wstring>& argv)
{
	std::vector<const wchar_t*> argv_ptrs(argv.size());
	std::transform(argv.begin(), argv.end(), argv_ptrs.begin(), [](const std::wstring& s) { return s.c_str(); } );

	PySys_SetArgv(argv_ptrs.size(), const_cast<wchar_t**>(argv_ptrs.data()));
}

int main(int argc, char **argv)
{
#if (COW_MPI)
  {
    int rank;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    if (rank != 0) freopen("/dev/null", "w", stdout);
    printf("was compiled with MPI support\n");
  }
#endif
  Py_Initialize();
  PySys_SetArgv(argc, argv);
  Py_SetProgramName("/Users/jzrake/Work/cow/cowpy");
  init_cow();

  if (argc > 1) {
    FILE *fp = fopen(argv[1], "r");
    if (fp) {
      PyRun_SimpleFileExFlags(fp, argv[1], 1, NULL);
      fclose(fp);
    }
    else {
      printf("No such file %s\n", argv[1]);
    }
  }

  Py_Finalize();
  printf("finished...\n");
#if (COW_MPI)
  MPI_Finalize();
#endif
  return 0;
}

rpmpython rpmpythonNew(char ** av, uint32_t flags)
{
    static char * _av[] = { "rpmpython", NULL };
#if defined(WITH_PYTHONEMBED)
    int initialize = (!(flags & 0x80000000) || _rpmpythonI == NULL);
#endif
    rpmpython python = (flags & 0x80000000)
	? rpmpythonI() : rpmpythonGetPool(_rpmpythonPool);

if (_rpmpython_debug)
fprintf(stderr, "==> %s(%p, %d) python %p\n", __FUNCTION__, av, flags, python);

    if (av == NULL) av = _av;

#if defined(WITH_PYTHONEMBED)
    if (!Py_IsInitialized()) {
	Py_SetProgramName((char *)_av[0]);
	Py_Initialize();
    }
    if (PycStringIO == NULL)
	PycStringIO = PyCObject_Import("cStringIO", "cStringIO_CAPI");

    if (initialize) {
	int ac = argvCount((ARGV_t)av);
	(void) PySys_SetArgv(ac, (char **)av);
	(void) rpmpythonRun(python, rpmpythonInitStringIO, NULL);
    }
#endif

    return rpmpythonLink(python);
}

int main(int argc, char *argv[]) {
  // Set the python interpreter.
  setup_python(argc, argv);

  std::string filepath(argv[0]);

  // Get the path to the helper script.
  std::string helper_path;
  size_t path_end = filepath.find_last_of('\\');
  if (path_end != std::string::npos)
    helper_path = filepath.substr(0, path_end + 1);

  helper_path += "wbadminhelper.py";

  // Configures the execution of the script to take the same
  // parameters as this helper tool.
  Py_SetProgramName(argv[0]);

  PySys_SetArgv(argc, argv);

  // Executes the helper script.
  PyObject *pFileObject = PyFile_FromString(const_cast<char *>(helper_path.c_str()), "r");

  PyRun_SimpleFileEx(PyFile_AsFile(pFileObject), "wbadminhelper.py", 1);

  finalize_python();

  return 0;
}

int main()
{
	Py_Initialize();
	PySys_SetArgv(SIZEOF_STATIC_ARRAY(pythonArgv), pythonArgv);
	PyRun_SimpleStringFlags(pythonScript, NULL);
	Py_Finalize();
	return 0;
}

 bool LMF_PyInitialise(int argc, char* argv[]){
	bool returnb = false;
	if (LMF_PyInitialise()){
		PySys_SetArgv(argc, argv);
		returnb = true;
	}
	return returnb;
}

LUA_API int luaopen_python(lua_State *L)
{
    int rc;

    /* Register module */
    luaL_register(L, "python", py_lib);

    /* Register python object metatable */
    luaL_newmetatable(L, POBJECT);
    luaL_register(L, NULL, py_object_lib);
    lua_pop(L, 1);

    /* Initialize Lua state in Python territory */
    if (!LuaState) LuaState = L;

    /* Initialize Python interpreter */
    if (!Py_IsInitialized()) {
        PyObject *luam, *mainm, *maind;
#if PY_MAJOR_VERSION >= 3
        wchar_t *argv[] = {L"<lua>", 0};
#else
        char *argv[] = {"<lua>", 0};
#endif
        Py_SetProgramName(argv[0]);
        PyImport_AppendInittab("lua", PyInit_lua);
        Py_Initialize();
        PySys_SetArgv(1, argv);
        /* Import 'lua' automatically. */
        luam = PyImport_ImportModule("lua");
        if (!luam) {
            luaL_error(L, "Can't import lua module");
        } else {
            mainm = PyImport_AddModule("__main__");
            if (!mainm) {
                luaL_error(L, "Can't get __main__ module");
            } else {
                maind = PyModule_GetDict(mainm);
                PyDict_SetItemString(maind, "lua", luam);
                Py_DECREF(luam);
            }
        }
    }

    /* Register 'none' */
    lua_pushliteral(L, "Py_None");
    rc = py_convert_custom(L, Py_None, 0);
    if (rc) {
        lua_pushliteral(L, "none");
        lua_pushvalue(L, -2);
        lua_rawset(L, -5); /* python.none */
        lua_rawset(L, LUA_REGISTRYINDEX); /* registry.Py_None */
    } else {
        lua_pop(L, 1);
        luaL_error(L, "failed to convert none object");
    }

    return 0;
}

bool reservoirHandler::callReservoir(string fPython)
{
    //launch Xavier reservoir
    //string command = "cd " + pythonPath + " && python " + fPython;
    //bool bsys = system(command.c_str());
    //cout << "cd " << pythonPath << " && python " << fPython << endl;
    //return bsys;


    cout << "fPython : " << fPython << endl;
    FILE* file;
    int argc;
    char * argv[3];

    argc = 3;
    if (sCurrentActivity == "understanding")
    {
      argv[0] = "/mnt/data/Data/BuildLinux/Robot/RAD/src/iCub_language/action_performer.py";
      argv[1] = "/home/anne/.local/share/yarp/contexts/reservoirHandler/conf/AP_input_S.txt";
      Py_SetProgramName(argv[0]);
      Py_Initialize();
      PySys_SetArgv(argc, argv);
      file = fopen("/mnt/data/Data/BuildLinux/Robot/RAD/src/iCub_language/action_performer.py","r");

      PyRun_SimpleFile(file, "/mnt/data/Data/BuildLinux/Robot/RAD/src/iCub_language/action_performer.py");
    }
    else
    {
        argv[0] = "/mnt/data/Data/BuildLinux/Robot/RAD/src/iCub_language/spatial_relation.py";
        argv[1] = "/home/anne/.local/share/yarp/contexts/reservoirHandler/conf/SR_input_M.txt";
        Py_SetProgramName(argv[0]);
        Py_Initialize();
        PySys_SetArgv(argc, argv);
        file = fopen("/mnt/data/Data/BuildLinux/Robot/RAD/src/iCub_language/spatial_relation.py","r");

        PyRun_SimpleFile(file, "/mnt/data/Data/BuildLinux/Robot/RAD/src/iCub_language/spatial_relation.py");
    }


    //return Py_Finalize();
    return true;

}

void show(int argc, char* argv[])
{
  Py_Initialize();
  PySys_SetArgv(argc, argv);
  PyRun_SimpleString( "import Tkinter" );
  PyRun_SimpleString( "root = Tkinter.Tk()" );
  PyRun_SimpleString( "root.mainloop()" );
  Py_Finalize();

}

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

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

static void _PythonVM_init(JNIEnv *vm_env, jobject self,
                           jstring programName, jobjectArray args)
{
    const char *str = vm_env->GetStringUTFChars(programName, JNI_FALSE);
#ifdef linux
    char buf[32];

    // load python runtime for other .so modules to link (such as _time.so)
    sprintf(buf, "libpython%d.%d.so", PY_MAJOR_VERSION, PY_MINOR_VERSION);
    dlopen(buf, RTLD_NOW | RTLD_GLOBAL);
#endif

    Py_SetProgramName((char *) str);

    PyEval_InitThreads();
    Py_Initialize();

    if (args)
    {
        int argc = vm_env->GetArrayLength(args);
        char **argv = (char **) calloc(argc + 1, sizeof(char *));

        argv[0] = (char *) str;
        for (int i = 0; i < argc; i++) {
            jstring arg = (jstring) vm_env->GetObjectArrayElement(args, i);
            argv[i + 1] = (char *) vm_env->GetStringUTFChars(arg, JNI_FALSE);
        }

        PySys_SetArgv(argc + 1, argv);

        for (int i = 0; i < argc; i++) {
            jstring arg = (jstring) vm_env->GetObjectArrayElement(args, i);
            vm_env->ReleaseStringUTFChars(arg, argv[i + 1]);
        }
        free(argv);
    }
    else
        PySys_SetArgv(1, (char **) &str);

    vm_env->ReleaseStringUTFChars(programName, str);
    PyEval_ReleaseLock();
}

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);

}