int
PyRun_InteractiveLoop(FILE *fp, char *filename)
{
	PyObject *v;
	int ret;
	v = PySys_GetObject("ps1");
	if (v == NULL) {
		PySys_SetObject("ps1", v = PyString_FromString(">>> "));
		Py_XDECREF(v);
	}
	v = PySys_GetObject("ps2");
	if (v == NULL) {
		PySys_SetObject("ps2", v = PyString_FromString("... "));
		Py_XDECREF(v);
	}
	for (;;) {
		ret = PyRun_InteractiveOne(fp, filename);
#ifdef Py_REF_DEBUG
		fprintf(stderr, "[%ld refs]\n", _Py_RefTotal);
#endif
		if (ret == E_EOF)
			return 0;
		/*
		if (ret == E_NOMEM)
			return -1;
		*/
	}
}

void PyMPI_UnrestrictedOutput(int stream) {
    PyObject* pyOutput = 0;
    PyObject* pyErrput = 0;

    if(stream & 0x01)
    {
        PYCHECK( pyOutput = PySys_GetObject("__stdout__"));
        Py_INCREF(pyOutput);
        PYCHECK( PySys_SetObject("stdout",pyOutput));
        Py_INCREF(Py_None);
        PYCHECK( PyDict_SetItemString(PyMPI_dictionary,"outputQueueFile",Py_None));
    }

    if(stream & 0x02)
    {
        PYCHECK( pyErrput = PySys_GetObject("__stderr__"));
        Py_INCREF(pyErrput);
        PYCHECK( PySys_SetObject("stderr",pyErrput));
        Py_INCREF(Py_None);
        PYCHECK( PyDict_SetItemString(PyMPI_dictionary,"errputQueueFile",Py_None));
    }

    /* Fall through */
pythonError:
    return;
}

static void handle_python_admin(admin_handle h, const char * const *args, void *userdata)
{
	char *text;
	PyObject *old_stdout, *old_stderr;
	AdminOutputObject *admin_stdout;

	if (args[1] == NULL) {
		/* Silently ignore */
		return;
	}

	text = g_strjoinv(" ", (char **)args+1);

	old_stdout = PySys_GetObject("stdout");
	old_stderr = PySys_GetObject("stderr");
	admin_stdout = PyObject_New(AdminOutputObject, &AdminOutputType);
	admin_stdout->h = h;
	admin_stdout->buffer = NULL;
	PySys_SetObject("stdout", (PyObject *)admin_stdout);
	PySys_SetObject("stderr", (PyObject *)admin_stdout);
	PyRun_SimpleString(text);
	g_free(text);
	PySys_SetObject("stdout", old_stdout);
	PySys_SetObject("stderr", old_stderr);
	Py_DECREF(admin_stdout);
}

int
PyRun_InteractiveLoopFlags(FILE *fp, const char *filename, PyCompilerFlags *flags)
{
	PyObject *v;
	int ret;
	PyCompilerFlags local_flags;

	if (flags == NULL) {
		flags = &local_flags;
		local_flags.cf_flags = 0;
	}
	v = PySys_GetObject("ps1");
	if (v == NULL) {
		PySys_SetObject("ps1", v = PyString_FromString(">>> "));
		Py_XDECREF(v);
	}
	v = PySys_GetObject("ps2");
	if (v == NULL) {
		PySys_SetObject("ps2", v = PyString_FromString("... "));
		Py_XDECREF(v);
	}
	for (;;) {
		ret = PyRun_InteractiveOneFlags(fp, filename, flags);
		PRINT_TOTAL_REFS();
		if (ret == E_EOF)
			return 0;
		/*
		if (ret == E_NOMEM)
			return -1;
		*/
	}
}

int CPython::ExecCmds(const std::wstring &cmds, std::wstring &err, HANDLE hfile)
{
	int id = 0; FILE *pfile = nullptr; DWORD count = 0;
	PyObject *poldout, *polderr, *pnewout, *pnewerr; 
	if (cmds.length() <= 0) {
		err = text("No python command found"); return 1;
	}
	if (DuplicateHandle (
		GetCurrentProcess(), hfile, GetCurrentProcess(), &hfile, 
		0, false, DUPLICATE_SAME_ACCESS
	)) {
		id = open_osfhandle((intptr_t)hfile, _O_WRONLY);
		pfile = fdopen(id,"w"); setvbuf(pfile,nullptr,_IONBF,1024);
		poldout = PySys_GetObject("stdout"); 
		polderr = PySys_GetObject("stderr"); 
		pnewout = PyFile_FromFile(pfile, "logger", "w", nullptr);
		pnewerr = PyFile_FromFile(pfile, "logger", "w", nullptr);
		PySys_SetObject("stdout", pnewout);
		PySys_SetObject("stderr", pnewerr);
	} else poldout = polderr = pnewout = pnewerr = nullptr;

	std::wstring_convert<std::codecvt_utf8_utf16<wchar>> cvt; 
	std::string str = cvt.to_bytes(cmds); 
	int irslt = PyRun_SimpleString(str.c_str());
	if (irslt != 0) err = text("Internal error that PyRun_SimpleString fail"); 
	else err = text("Execute python commands successfully .."); 

	if (pnewout != nullptr) PySys_SetObject("stdout", poldout); 
	if (pnewerr != nullptr) PySys_SetObject("stderr", polderr); 
	if (pfile != nullptr) fclose(pfile); return irslt; 
}

PyMODINIT_FUNC TS3init(void)
{
	PyObject *m;
	printf("Init TS3 module\n");
	m = Py_InitModule("TS3", TS3Methods);	
	PySys_SetObject("stdout", m);
	PySys_SetObject("stderr", m);
}

static void initMatpyPrint(void)
{
    PyObject *matpyPrintModule = Py_InitModule("print", matpyPrintMethods);
    if (NULL != matpyPrintModule)
    {
        PySys_SetObject((char*)"stdout", matpyPrintModule);
        PySys_SetObject((char*)"stderr", matpyPrintModule);
    }
}

void ResetStdOut() {
  if (gStdOutSaved)
    PySys_SetObject("stdout", gStdOutSaved);
  if (gStdErrSaved)
    PySys_SetObject("stderr", gStdErrSaved);

  Py_XDECREF(gStdOut);
  gStdOut = 0;
}

PyObject*
ada_py_initialize_and_module(char* program_name, char* name) {
   PyObject* module;
   PyObject* imported;

   user_module_name = strdup(name);

#if PY_MAJOR_VERSION >= 3
   user_module.m_name = user_module_name;
   Py_SetProgramName ((wchar_t*)program_name);
#else
   Py_SetProgramName (program_name);
#endif

   PyImport_AppendInittab(user_module_name, init_user_module);
   Py_InitializeEx(0);

   // Initialize the prompt if needed

   PyObject* prompt = PySys_GetObject ("ps1");
   if (prompt == NULL) {
      prompt = PyUnicode_FromString (">>> ");
      PySys_SetObject ("ps1", prompt);
      Py_DECREF (prompt);
   }

   prompt = PySys_GetObject ("ps2");
   if (prompt == NULL) {
      prompt = PyUnicode_FromString ("... ");
      PySys_SetObject ("ps2", prompt);
      Py_DECREF (prompt);
   }

   // Make the user's module visible to scripts. We cannot use
   // PyImport_ImportModule, which imports the module but doesn't add
   // it to the global dictionary and as such it is not visible to
   // user scripts.

   imported = PyImport_ImportModule(name);
   if (imported == NULL) {
      printf ("Could not import module %s", name);
      return NULL;
   }

   // Import 'sys', which is needed for instance in Set_Default_Console
   // to get access to the default value
   PyRun_SimpleString("import sys\n");

   char* command = (char*)malloc(9 + strlen(name));
   strcpy (command, "import ");
   strcat (command, name);
   strcat (command, "\n");
   PyRun_SimpleString(command);
   free (command);

   return imported;
};

void SetStdout(StdOutWriteType write) {
  if (!gStdOut) {
    gStdOutSaved = PySys_GetObject("stdout");
    gStdErrSaved = PySys_GetObject("stderr");
    gStdOut = StdoutType.tp_new(&StdoutType, 0, 0);
  }
  StdOut *impl = reinterpret_cast<StdOut *>(gStdOut);
  impl->write = write;
  PySys_SetObject("stdout", gStdOut);
  PySys_SetObject("stderr", gStdOut);
}

PyObject *set_stdstream(std::string name, PyObject *pystream) {
  PyObject *old_pystream = PySys_GetObject(const_cast<char*>(name.c_str())); // borrowed
  Py_XINCREF(pystream);
  PySys_SetObject(const_cast<char*>(name.c_str()), pystream);
  Py_XDECREF(old_pystream);
  return old_pystream;
}

bool bpy_text_compile(Text *text)
{
	char fn_dummy[FILE_MAX];
	PyObject *fn_dummy_py;
	char *buf;

	bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);

	/* if previously compiled, free the object */
	free_compiled_text(text);

	fn_dummy_py = PyC_UnicodeFromByte(fn_dummy);

	buf = txt_to_buf(text);
	text->compiled = Py_CompileStringObject(buf, fn_dummy_py, Py_file_input, NULL, -1);
	MEM_freeN(buf);

	Py_DECREF(fn_dummy_py);

	if (PyErr_Occurred()) {
		PyErr_Print();
		PyErr_Clear();
		PySys_SetObject("last_traceback", NULL);
		free_compiled_text(text);
		return false;
	}
	else {
		return true;
	}
}

PyObject *bpy_text_import(Text *text)
{
	char *buf = NULL;
	char modulename[MAX_ID_NAME + 2];
	int len;

	if (!text->compiled) {
		char fn_dummy[256];
		bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);

		buf = txt_to_buf(text);
		text->compiled = Py_CompileString(buf, fn_dummy, Py_file_input);
		MEM_freeN(buf);

		if (PyErr_Occurred()) {
			PyErr_Print();
			PyErr_Clear();
			PySys_SetObject("last_traceback", NULL);
			free_compiled_text(text);
			return NULL;
		}
	}

	len = strlen(text->id.name + 2);
	BLI_strncpy(modulename, text->id.name + 2, len);
	modulename[len - 3] = '\0'; /* remove .py */
	return PyImport_ExecCodeModule(modulename, text->compiled);
}

void PyXPCOM_DLLAddRef(void)
{
	// Must be thread-safe, although cant have the Python lock!
	CEnterLeaveXPCOMFramework _celf;
	PRInt32 cnt = PR_AtomicIncrement(&g_cLockCount);
	if (cnt==1) { // First call
		if (!Py_IsInitialized()) {
			Py_Initialize();
			// Make sure our Windows framework is all setup.
			PyXPCOM_Globals_Ensure();
			// Make sure we have _something_ as sys.argv.
			if (PySys_GetObject((char*)"argv")==NULL) {
				PyObject *path = PyList_New(0);
#if PY_MAJOR_VERSION <= 2
				PyObject *str = PyString_FromString("");
#else
				PyObject *str = PyUnicode_FromString("");
#endif
				PyList_Append(path, str);
				PySys_SetObject((char*)"argv", path);
				Py_XDECREF(path);
				Py_XDECREF(str);
			}

			// Must force Python to start using thread locks, as
			// we are free-threaded (maybe, I think, sometimes :-)
			PyEval_InitThreads();
#ifndef PYXPCOM_USE_PYGILSTATE
			// Release Python lock, as first thing we do is re-get it.
			ptsGlobal = PyEval_SaveThread();
#endif
			// NOTE: We never finalize Python!!
		}
	}
}

void ssipylog_stdout_reset()
{
    if (ssipylog_g_stdout_saved)
        PySys_SetObject("stdout", ssipylog_g_stdout_saved);

    Py_XDECREF(ssipylog_g_stdout);
	ssipylog_g_stdout = 0;
}

 PythonRedirector(const char* type, PyObject* obj) : std_out(type), out(obj), old(0)
 {
     if (out) {
         Base::PyGILStateLocker lock;
         old = PySys_GetObject(const_cast<char*>(std_out));
         PySys_SetObject(const_cast<char*>(std_out), out);
     }
 }

 ~PythonRedirector()
 {
     if (out) {
         Base::PyGILStateLocker lock;
         PySys_SetObject(const_cast<char*>(std_out), old);
         Py_DECREF(out);
     }
 }

void Redirector::reset_stdout()
{
    if (m_stdout_saved)
        PySys_SetObject(const_cast<char*>("stdout"), m_stdout_saved);

    Py_XDECREF(m_stdout);
    m_stdout = 0;
}

/*!
	Starts the python interpreter
*/
void startPython( int argc, char* argv[] )
{
	Py_SetProgramName( argv[0] );

	Py_NoSiteFlag = 1; // No import because we need to set the search path first

	Py_Initialize();
	PySys_SetArgv( argc, argv );

	// Modify our search-path
	PyObject* searchpath = PySys_GetObject( "path" );

	QStringList elements = QStringList::split( ";", Config::instance()->getString( "General", "Python Searchpath", "./scripts;.", true ) );

	// Prepend our items to the searchpath
	for ( int i = elements.count() - 1; i >= 0; --i )
	{
		PyList_Insert( searchpath, 0, PyString_FromString( elements[i].latin1() ) );
	}

	// Import site now
	PyObject* m = PyImport_ImportModule( "site" );
	Py_XDECREF( m );

	// Try changing the stderr + stdout pointers
	PyObject* file = PyFile_FromString( "python.log", "w" );

	if ( file )
	{
		Py_INCREF( file );
		PySys_SetObject( "stderr", file );
		Py_INCREF( file );
		PySys_SetObject( "stdout", file );
		Py_DECREF( file );
	}

	try
	{
		init_wolfpack_globals();
	}
	catch ( ... )
	{
		Console::instance()->send( "Failed to initialize the python extension modules\n" );
	}
}

PyObject *bpy_text_reimport(PyObject *module, int *found)
{
	Text *text;
	const char *name;
	char *filepath;
	char *buf = NULL;
//XXX	Main *maggie = bpy_import_main ? bpy_import_main:G.main;
	Main *maggie = bpy_import_main;
	
	if (!maggie) {
		printf("ERROR: bpy_import_main_set() was not called before running python. this is a bug.\n");
		return NULL;
	}
	
	*found = 0;
	
	/* get name, filename from the module itself */
	if ((name = PyModule_GetName(module)) == NULL)
		return NULL;

	if ((filepath = (char *)PyModule_GetFilename(module)) == NULL)
		return NULL;

	/* look up the text object */
	text = BLI_findstring(&maggie->text, BLI_path_basename(filepath), offsetof(ID, name) + 2);

	/* uh-oh.... didn't find it */
	if (!text)
		return NULL;
	else
		*found = 1;

	/* if previously compiled, free the object */
	/* (can't see how could be NULL, but check just in case) */ 
	if (text->compiled) {
		Py_DECREF((PyObject *)text->compiled);
	}

	/* compile the buffer */
	buf = txt_to_buf(text);
	text->compiled = Py_CompileString(buf, text->id.name + 2, Py_file_input);
	MEM_freeN(buf);

	/* if compile failed.... return this error */
	if (PyErr_Occurred()) {
		PyErr_Print();
		PyErr_Clear();
		PySys_SetObject("last_traceback", NULL);
		free_compiled_text(text);
		return NULL;
	}

	/* make into a module */
	return PyImport_ExecCodeModule((char *)name, text->compiled);
}