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

}

Oracle::Oracle(int argc, char* argv[], const std::string& model_name) : pModule(NULL){
	PySys_SetArgv(argc, argv);
	PyRun_SimpleString("import sys");
	PyRun_SimpleString("sys.path.append('./')");

	pModule = PyImport_ImportModule(model_name.c_str());
	if (!pModule){
		PyErr_Print();
		std::cout << "Oracle::Oracle() ERROR : get module failed!" << std::endl;
		assert(0);
	}
}

void txt_test(int argc, char* argv[])
{
  Py_Initialize();
  PySys_SetArgv(argc, argv);
  PyRun_SimpleString( "from Tkinter import *" );
  PyRun_SimpleString( "root=Tk()" );
  PyRun_SimpleString( "w = Label(root,text = 'hello world')");
  PyRun_SimpleString( "w.pack()" );
  PyRun_SimpleString( "root.mainloop()" );

  Py_Finalize();
}

void pythonExchangeValuesNoModelica(const char * moduleName,
                          const char * functionName,
                          const double * dblValWri, size_t nDblWri,
                          double * dblValRea, size_t nDblRea,
                          const int * intValWri, size_t nIntWri,
                          int * intValRea, size_t nIntRea,
                          const char ** strValWri, size_t nStrWri,
                          void (*ModelicaFormatError)(const char *string,...))
{
  PyObject *pName, *pModule, *pFunc;
  PyObject *pArgsDbl, *pArgsInt, *pArgsStr;
  PyObject *pArgs, *pValue;
  Py_ssize_t pIndVal;
  PyObject *pItemDbl, *pItemInt;
  char* arg="";
  Py_ssize_t i;
  Py_ssize_t iArg = 0;
  Py_ssize_t nArg = 0;
  Py_ssize_t iRet = 0;
  Py_ssize_t nRet = 0;
  ////////////////////////////////////////////////////////////////////////////
  // Initialize Python interpreter
  Py_Initialize();
  // Set the entries for sys.argv.
  // This is required if a script uses sys.argv, such as bacpypes.
  // See also http://stackoverflow.com/questions/19381441/python-modelica-connection-fails-due-to-import-error
  PySys_SetArgv(0, &arg);

  ////////////////////////////////////////////////////////////////////////////
  // Load Python module
  pName = PyString_FromString(moduleName);
  if (!pName) {
    (*ModelicaFormatError)("Failed to convert moduleName '%s' to Python object.\n", moduleName);
  }

  pModule = PyImport_Import(pName);
  Py_DECREF(pName);
  if (!pModule) {
    //    PyErr_Print();
    PyObject *pValue, *pType, *pTraceBack;
    PyErr_Fetch(&pType, &pValue, &pTraceBack);
    if (pType != NULL)
      Py_DECREF(pType);
    if (pTraceBack != NULL)
      Py_DECREF(pTraceBack);
    // Py_Finalize(); // removed, see note at other Py_Finalize() statement
    (*ModelicaFormatError)("Failed to load \"%s\".\n\
This may occur if you did not set the PYTHONPATH environment variable\n\
or if the Python module contains a syntax error.\n\
The error message is \"%s\"",
                        moduleName,
                        PyString_AsString(PyObject_Repr(pValue)));
  }

int main( int argc, char* argv[] ) {

    /** Must call pre_init before python initializes */
    PyQBind::pre_init();

    /** Initialize Python using either chars (Python 2) or whcars (Python 3)*/
#if PY_MAJOR_VERSION < 3
    Py_SetProgramName(argv[0]);
    Py_Initialize();
    PySys_SetArgv(1, argv);
#else
    wchar_t *wprogname = new wchar_t[255];
    mbstowcs(wprogname, argv[0], 255);
    Py_SetProgramName(wprogname);
    Py_Initialize();
    PySys_SetArgv(1, &wprogname);
#endif

    /** If we expect to need python threads, we can initialize them now */
    //PyEval_InitThreads();

    /** Finish PyQBind initialization */
    PyQBind::post_init();

    /** Now we can create our application and export it */
    QCoreApplication q(argc, argv);
    PyQBind::exportObject( &q );
    PyQBind::addToGlobalNamespace( &q, "app" );

    try {
        boost::python::object main = boost::python::import("__main__");
        boost::python::object dict = main.attr("__dict__");
        boost::python::exec("print dir(app)", dict, dict);
        boost::python::exec("print app.applicationName", dict, dict);
    } catch( boost::python::error_already_set& ) {
        PyErr_Print();
    }

}

/*
 * Start trace script
 */
static int python_start_script(const char *script, int argc, const char **argv)
{
	const char **command_line;
	char buf[PATH_MAX];
	int i, err = 0;
	FILE *fp;

	command_line = malloc((argc + 1) * sizeof(const char *));
	command_line[0] = script;
	for (i = 1; i < argc + 1; i++)
		command_line[i] = argv[i - 1];

	Py_Initialize();

	initperf_trace_context();

	PySys_SetArgv(argc + 1, (char **)command_line);

	fp = fopen(script, "r");
	if (!fp) {
		sprintf(buf, "Can't open python script \"%s\"", script);
		perror(buf);
		err = -1;
		goto error;
	}

	err = PyRun_SimpleFile(fp, script);
	if (err) {
		fprintf(stderr, "Error running python script %s\n", script);
		goto error;
	}

	err = run_start_sub();
	if (err) {
		fprintf(stderr, "Error starting python script %s\n", script);
		goto error;
	}

	free(command_line);
	fprintf(stderr, "perf trace started with Python script %s\n\n",
		script);

	return err;
error:
	Py_Finalize();
	free(command_line);

	return err;
}