C++ PySys_SetObject函数代码示例

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