mirror of
https://github.com/ivellioscolin/pykd.git
synced 2025-04-20 03:23:23 +08:00
900 lines
32 KiB
C++
900 lines
32 KiB
C++
#include "stdafx.h"
|
|
#include "pyinterpret.h"
|
|
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <map>
|
|
#include <set>
|
|
#include <algorithm>
|
|
|
|
#include "pymodule.h"
|
|
#include "pyclass.h"
|
|
#include "dbgout.h"
|
|
|
|
class PyModule;
|
|
class PythonInterpreter;
|
|
|
|
class HKey
|
|
{
|
|
|
|
public:
|
|
|
|
HKey() : m_key(NULL)
|
|
{}
|
|
|
|
~HKey()
|
|
{
|
|
if (m_key)
|
|
RegCloseKey(m_key);
|
|
}
|
|
|
|
operator HKEY*()
|
|
{
|
|
return &m_key;
|
|
}
|
|
|
|
operator HKEY() const
|
|
{
|
|
return m_key;
|
|
}
|
|
|
|
private:
|
|
|
|
HKEY m_key;
|
|
};
|
|
|
|
|
|
class PyModule
|
|
{
|
|
public:
|
|
|
|
PyModule(int majorVesion, int minorVersion);
|
|
|
|
~PyModule();
|
|
|
|
bool isPy3;
|
|
|
|
void checkPykd();
|
|
void deactivate();
|
|
|
|
PyObject* PyType_Type;
|
|
PyObject* PyProperty_Type;
|
|
PyObject* Py_None;
|
|
PyObject* PyExc_SystemExit;
|
|
|
|
PyThreadState* PyThreadState_Current;
|
|
|
|
void( *Py_Initialize)();
|
|
void( *Py_Finalize)();
|
|
|
|
PyThreadState* ( *Py_NewInterpreter)();
|
|
void( *Py_EndInterpreter)(PyThreadState *tstate);
|
|
PyObject* ( *PyEval_GetGlobals)();
|
|
PyObject* ( *PyImport_Import)(PyObject *name);
|
|
PyObject* ( *PyImport_ImportModule)(const char *name);
|
|
void( *PyEval_InitThreads)();
|
|
PyThreadState* ( *PyEval_SaveThread)();
|
|
void( *PyEval_RestoreThread)(PyThreadState *tstate);
|
|
PyThreadState* ( *PyThreadState_Swap)(PyThreadState *tstate);
|
|
PyObject* ( *PyRun_String)(const char *str, int start, PyObject *globals, PyObject *locals);
|
|
int( *PyRun_SimpleString)(const char* str);
|
|
PyObject* ( *PyRun_File)(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals);
|
|
PyObject* ( *PyDict_New)();
|
|
int( *PyDict_SetItemString)(PyObject *p, const char *key, PyObject *val);
|
|
PyObject*( *PyDict_GetItemString)(PyObject *p, const char* key);
|
|
void ( *PyDict_Clear)(PyObject *p);
|
|
void( *Py_IncRef)(PyObject* object);
|
|
void( *Py_DecRef)(PyObject* object);
|
|
PyObject* ( *PyObject_Call)(PyObject *callable_object, PyObject *args, PyObject *kw);
|
|
PyObject* ( *PyObject_GetAttr)(PyObject *object, PyObject *attr_name);
|
|
PyObject* ( *PyObject_GetAttrString)(PyObject *object, const char *attr_name);
|
|
int( *PyObject_SetAttr)(PyObject *object, PyObject *attr_name, PyObject *value);
|
|
PyObject* ( *PyObject_CallObject)(PyObject *callable_object, PyObject *args);
|
|
PyObject* ( *PyTuple_New)(size_t len);
|
|
int( *PyTuple_SetItem)(PyObject *p, size_t pos, PyObject *o);
|
|
PyObject* ( *PyTuple_GetItem)(PyObject *p, size_t pos);
|
|
size_t( *PyTuple_Size)(PyObject *p);
|
|
PyObject* ( *PyCFunction_NewEx)(PyMethodDef *, PyObject *, PyObject *);
|
|
PyObject* ( *PySys_GetObject)(char *name);
|
|
int( *PySys_SetObject)(char *name, PyObject *v);
|
|
void( *PySys_SetArgv)(int argc, char **argv);
|
|
void( *PySys_SetArgv_Py3)(int argc, wchar_t **argv);
|
|
PyObject* ( *PyString_FromString)(const char *v);
|
|
char* ( *PyString_AsString)(PyObject *string);
|
|
void( *PyErr_Fetch)(PyObject **ptype, PyObject **pvalue, PyObject **ptraceback);
|
|
void( *PyErr_NormalizeException)(PyObject**exc, PyObject**val, PyObject**tb);
|
|
void( *PyErr_SetString)(PyObject *type, const char *message);
|
|
void( *PyErr_Clear)();
|
|
PyObject* ( *PyImport_AddModule)(const char *name);
|
|
PyObject* ( *PyClass_New)(PyObject* className, PyObject* classBases, PyObject* classDict);
|
|
PyObject* ( *PyInstance_New)(PyObject *classobj, PyObject *arg, PyObject *kw);
|
|
PyObject* ( *PyMethod_New)(PyObject *func, PyObject *self, PyObject *classobj);
|
|
PyObject* ( *PyCapsule_New)(void *pointer, const char *name, PyCapsule_Destructor destructor);
|
|
void* ( *PyCapsule_GetPointer)(PyObject *capsule, const char *name);
|
|
int( *PyObject_SetAttrString)(PyObject *o, const char *attr_name, PyObject *v);
|
|
PyObject* ( *PyUnicode_FromWideChar)(const wchar_t *w, size_t size);
|
|
PyObject* ( *PyBool_FromLong)(long v);
|
|
size_t( *PyList_Size)(PyObject* list);
|
|
PyObject* ( *PyList_GetItem)(PyObject *list, size_t index);
|
|
PyObject* ( *PyFile_FromString)(char *filename, char *mode);
|
|
FILE* ( *PyFile_AsFile)(PyObject *pyfile);
|
|
PyObject* ( *PyUnicode_FromString)(const char *u);
|
|
PyObject* ( *PyInstanceMethod_New)(PyObject *func);
|
|
size_t( *PyUnicode_AsWideChar)(PyObject *unicode, wchar_t *w, size_t size);
|
|
FILE* ( *_Py_fopen)(const char* filename, const char* mode);
|
|
int( *Py_AddPendingCall)(int(*func)(void *), void *arg);
|
|
PyGILState_STATE( *PyGILState_Ensure)();
|
|
void( *PyGILState_Release)(PyGILState_STATE state);
|
|
PyObject* ( *PyDescr_NewMethod)(PyObject* type, struct PyMethodDef *meth);
|
|
size_t (*PyGC_Collect)(void);
|
|
void(*PyImport_Cleanup)(void);
|
|
|
|
HMODULE m_handlePython;
|
|
PyThreadState* m_globalState;
|
|
PythonInterpreter* m_globalInterpreter;
|
|
bool m_pykdInit;
|
|
};
|
|
|
|
|
|
|
|
class PythonInterpreter
|
|
{
|
|
public:
|
|
|
|
PythonInterpreter(PyModule* mod) :
|
|
m_module(mod)
|
|
{
|
|
PyThreadState* state = mod->Py_NewInterpreter();
|
|
|
|
m_module->PyThreadState_Swap(state);
|
|
|
|
m_state = m_module->PyEval_SaveThread();
|
|
}
|
|
|
|
~PythonInterpreter()
|
|
{
|
|
m_module->PyEval_RestoreThread(m_state);
|
|
|
|
m_module->PyImport_Cleanup();
|
|
|
|
while (PyGC_Collect() > 0);
|
|
|
|
m_module->Py_EndInterpreter(m_state);
|
|
|
|
}
|
|
|
|
PyModule* m_module;
|
|
|
|
PyThreadState* m_state;
|
|
};
|
|
|
|
|
|
class PythonSingleton
|
|
{
|
|
public:
|
|
|
|
|
|
static PythonSingleton* get()
|
|
{
|
|
if (m_singleton.get() == 0)
|
|
m_singleton.reset(new PythonSingleton());
|
|
return m_singleton.get();
|
|
}
|
|
|
|
|
|
PythonInterpreter* currentInterpreter()
|
|
{
|
|
if ( m_currentInterpreter )
|
|
return m_currentInterpreter;
|
|
|
|
for ( auto mod : m_modules)
|
|
{
|
|
if ( mod.second->PyThreadState_Current != 0 )
|
|
{
|
|
return mod.second->m_globalInterpreter;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
PythonInterpreter* getInterpreter(int majorVersion, int minorVersion, bool global)
|
|
{
|
|
PyModule* module = 0;
|
|
|
|
if (m_modules.find(std::make_pair(majorVersion, minorVersion)) == m_modules.end())
|
|
{
|
|
module = new PyModule(majorVersion, minorVersion);
|
|
m_modules.insert(std::make_pair(std::make_pair(majorVersion, minorVersion), module));
|
|
}
|
|
else
|
|
{
|
|
module = m_modules[std::make_pair(majorVersion, minorVersion)];
|
|
}
|
|
|
|
if (global)
|
|
{
|
|
if (module->m_globalInterpreter == 0)
|
|
{
|
|
module->PyEval_RestoreThread(module->m_globalState);
|
|
module->m_globalInterpreter = new PythonInterpreter(module);
|
|
}
|
|
|
|
m_currentInterpreter = module->m_globalInterpreter;
|
|
m_currentIsGlobal = true;
|
|
}
|
|
else
|
|
{
|
|
module->PyEval_RestoreThread(module->m_globalState);
|
|
m_currentInterpreter = new PythonInterpreter(module);
|
|
m_currentIsGlobal = false;
|
|
}
|
|
|
|
m_currentInterpreter->m_module->PyEval_RestoreThread(m_currentInterpreter->m_state);
|
|
m_currentInterpreter->m_module->checkPykd();
|
|
|
|
return m_currentInterpreter;
|
|
}
|
|
|
|
void releaseInterpretor(PythonInterpreter* interpret)
|
|
{
|
|
PyModule* module = m_currentInterpreter->m_module;
|
|
|
|
m_currentInterpreter->m_state = module->PyEval_SaveThread();
|
|
|
|
if (!m_currentIsGlobal)
|
|
{
|
|
delete m_currentInterpreter;
|
|
|
|
module->PyThreadState_Swap(module->m_globalState);
|
|
module->m_globalState = module->PyEval_SaveThread();
|
|
}
|
|
|
|
m_currentInterpreter = 0;
|
|
}
|
|
|
|
bool isInterpreterLoaded(int majorVersion, int minorVersion)
|
|
{
|
|
return m_modules.find(std::make_pair(majorVersion, minorVersion)) != m_modules.end();
|
|
}
|
|
|
|
void checkPykd()
|
|
{
|
|
m_currentInterpreter->m_module->checkPykd();
|
|
}
|
|
|
|
void stopAllInterpreter()
|
|
{
|
|
for (auto m : m_modules)
|
|
{
|
|
m_currentInterpreter = m.second->m_globalInterpreter;
|
|
m.second->deactivate();
|
|
}
|
|
m_currentInterpreter = 0;
|
|
}
|
|
|
|
private:
|
|
|
|
static std::auto_ptr<PythonSingleton> m_singleton;
|
|
|
|
std::map<std::pair<int,int>, PyModule*> m_modules;
|
|
|
|
PythonInterpreter* m_currentInterpreter;
|
|
bool m_currentIsGlobal;
|
|
};
|
|
|
|
std::auto_ptr<PythonSingleton> PythonSingleton::m_singleton;
|
|
|
|
HMODULE LoadPythonForKey(HKEY installPathKey, int majorVersion, int minorVersion)
|
|
{
|
|
|
|
HMODULE hmodule = NULL;
|
|
|
|
char installPath[1000];
|
|
DWORD installPathSize = sizeof(installPath);
|
|
|
|
if (ERROR_SUCCESS == RegQueryValueExA(installPathKey, NULL, NULL, NULL, (LPBYTE)installPath, &installPathSize))
|
|
{
|
|
std::stringstream dllName;
|
|
dllName << "python" << majorVersion << minorVersion << ".dll";
|
|
|
|
std::stringstream imagePath;
|
|
imagePath << installPath << dllName.str();
|
|
|
|
hmodule = LoadLibraryExA(imagePath.str().c_str(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
|
|
if (hmodule)
|
|
return hmodule;
|
|
|
|
hmodule = LoadLibraryA(dllName.str().c_str());
|
|
if (hmodule)
|
|
return hmodule;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
HMODULE LoadPythonLibrary(int majorVersion, int minorVersion)
|
|
{
|
|
|
|
HKey pythonCoreKey;
|
|
|
|
for (auto rootKey : std::list<HKEY>({ HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER }))
|
|
{
|
|
if (ERROR_SUCCESS == RegOpenKeyA(rootKey, "SOFTWARE\\Python\\PythonCore", pythonCoreKey))
|
|
{
|
|
HKey installPathKey;
|
|
|
|
std::stringstream installPathStr;
|
|
|
|
if (majorVersion == 2 || (majorVersion == 3 && minorVersion <= 4))
|
|
{
|
|
installPathStr << majorVersion << '.' << minorVersion << "\\InstallPath";
|
|
}
|
|
else
|
|
if (majorVersion == 3 && minorVersion >= 5)
|
|
{
|
|
#ifdef _M_X64
|
|
installPathStr << majorVersion << '.' << minorVersion << "\\InstallPath";
|
|
#else
|
|
installPathStr << majorVersion << '.' << minorVersion << "-32" << "\\InstallPath";
|
|
#endif
|
|
}
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyA(pythonCoreKey, installPathStr.str().c_str(), installPathKey))
|
|
{
|
|
HMODULE hmodule = LoadPythonForKey(installPathKey, majorVersion, minorVersion);
|
|
if (hmodule)
|
|
return hmodule;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
std::list<InterpreterDesc> getInstalledInterpreter()
|
|
{
|
|
std::set<InterpreterDesc> interpretSet;
|
|
|
|
for (auto rootKey : const std::list<HKEY>({ HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER }))
|
|
{
|
|
HKey pythonCoreKey;
|
|
|
|
if (ERROR_SUCCESS != RegOpenKeyA(rootKey, "SOFTWARE\\Python\\PythonCore", pythonCoreKey))
|
|
continue;
|
|
|
|
for (DWORD i = 0;; ++i)
|
|
{
|
|
char versionStr[20];
|
|
if (ERROR_SUCCESS != RegEnumKeyA(pythonCoreKey, i, versionStr, sizeof(versionStr)))
|
|
break;
|
|
|
|
int majorVersion = -1, minorVersion = -1;
|
|
sscanf_s(versionStr, "%d.%d", &majorVersion, &minorVersion);
|
|
|
|
HKey installPathKey;
|
|
std::string installPathStr(versionStr);
|
|
installPathStr += "\\InstallPath";
|
|
|
|
if (ERROR_SUCCESS != RegOpenKeyA(pythonCoreKey, installPathStr.c_str(), installPathKey))
|
|
continue;
|
|
|
|
HMODULE hmodule = LoadPythonForKey(installPathKey, majorVersion, minorVersion);
|
|
|
|
if (hmodule)
|
|
{
|
|
char fullPath[1000];
|
|
|
|
if (GetModuleFileNameA(hmodule, fullPath, sizeof(fullPath)))
|
|
{
|
|
interpretSet.insert({ majorVersion, minorVersion, fullPath });
|
|
}
|
|
|
|
FreeLibrary(hmodule);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::list<InterpreterDesc> interpretLst;
|
|
|
|
std::copy(interpretSet.begin(), interpretSet.end(), std::inserter(interpretLst, interpretLst.begin()));
|
|
|
|
interpretLst.sort();
|
|
|
|
return interpretLst;
|
|
}
|
|
|
|
PyModule::PyModule(int majorVesion, int minorVersion)
|
|
{
|
|
m_handlePython = LoadPythonLibrary(majorVesion, minorVersion);
|
|
|
|
if (!m_handlePython)
|
|
throw std::exception("failed to load python module");
|
|
|
|
isPy3 = majorVesion == 3;
|
|
|
|
*reinterpret_cast<FARPROC*>(&PyType_Type) = GetProcAddress(m_handlePython, "PyType_Type");
|
|
*reinterpret_cast<FARPROC*>(&PyProperty_Type) = GetProcAddress(m_handlePython, "PyProperty_Type");
|
|
*reinterpret_cast<FARPROC*>(&Py_None) = GetProcAddress(m_handlePython, "_Py_NoneStruct");
|
|
PyExc_SystemExit = *reinterpret_cast<PyObject**>(GetProcAddress(m_handlePython, "PyExc_SystemExit"));
|
|
PyThreadState_Current = reinterpret_cast<PyThreadState*>(GetProcAddress(m_handlePython, "_PyThreadState_Current"));
|
|
|
|
*reinterpret_cast<FARPROC*>(&Py_Initialize) = GetProcAddress(m_handlePython, "Py_Initialize");
|
|
*reinterpret_cast<FARPROC*>(&Py_Finalize) = GetProcAddress(m_handlePython, "Py_Finalize");
|
|
*reinterpret_cast<FARPROC*>(&Py_NewInterpreter) = GetProcAddress(m_handlePython, "Py_NewInterpreter");
|
|
*reinterpret_cast<FARPROC*>(&Py_EndInterpreter) = GetProcAddress(m_handlePython, "Py_EndInterpreter");
|
|
*reinterpret_cast<FARPROC*>(&Py_DecRef) = GetProcAddress(m_handlePython, "Py_DecRef");
|
|
*reinterpret_cast<FARPROC*>(&Py_IncRef) = GetProcAddress(m_handlePython, "Py_IncRef");
|
|
*reinterpret_cast<FARPROC*>(&PyEval_GetGlobals) = GetProcAddress(m_handlePython, "PyEval_GetGlobals");
|
|
*reinterpret_cast<FARPROC*>(&PyEval_InitThreads) = GetProcAddress(m_handlePython, "PyEval_InitThreads");
|
|
*reinterpret_cast<FARPROC*>(&PyEval_SaveThread) = GetProcAddress(m_handlePython, "PyEval_SaveThread");
|
|
*reinterpret_cast<FARPROC*>(&PyEval_RestoreThread) = GetProcAddress(m_handlePython, "PyEval_RestoreThread");
|
|
*reinterpret_cast<FARPROC*>(&PyThreadState_Swap) = GetProcAddress(m_handlePython, "PyThreadState_Swap");
|
|
*reinterpret_cast<FARPROC*>(&PyRun_String) = GetProcAddress(m_handlePython, "PyRun_String");
|
|
*reinterpret_cast<FARPROC*>(&PyRun_SimpleString) = GetProcAddress(m_handlePython, "PyRun_SimpleString");
|
|
*reinterpret_cast<FARPROC*>(&PyRun_File) = GetProcAddress(m_handlePython, "PyRun_File");
|
|
*reinterpret_cast<FARPROC*>(&PyDict_New) = GetProcAddress(m_handlePython, "PyDict_New");
|
|
*reinterpret_cast<FARPROC*>(&PyDict_SetItemString) = GetProcAddress(m_handlePython, "PyDict_SetItemString");
|
|
*reinterpret_cast<FARPROC*>(&PyDict_GetItemString) = GetProcAddress(m_handlePython, "PyDict_GetItemString");
|
|
*reinterpret_cast<FARPROC*>(&PyDict_Clear) = GetProcAddress(m_handlePython, "PyDict_Clear");
|
|
*reinterpret_cast<FARPROC*>(&PyObject_Call) = GetProcAddress(m_handlePython, "PyObject_Call");
|
|
*reinterpret_cast<FARPROC*>(&PyObject_GetAttr) = GetProcAddress(m_handlePython, "PyObject_GetAttr");
|
|
*reinterpret_cast<FARPROC*>(&PyObject_GetAttrString) = GetProcAddress(m_handlePython, "PyObject_GetAttrString");
|
|
*reinterpret_cast<FARPROC*>(&PyObject_SetAttr) = GetProcAddress(m_handlePython, "PyObject_SetAttr");
|
|
*reinterpret_cast<FARPROC*>(&PyObject_CallObject) = GetProcAddress(m_handlePython, "PyObject_CallObject");
|
|
*reinterpret_cast<FARPROC*>(&PyTuple_New) = GetProcAddress(m_handlePython, "PyTuple_New");
|
|
*reinterpret_cast<FARPROC*>(&PyTuple_SetItem) = GetProcAddress(m_handlePython, "PyTuple_SetItem");
|
|
*reinterpret_cast<FARPROC*>(&PyTuple_GetItem) = GetProcAddress(m_handlePython, "PyTuple_GetItem");
|
|
*reinterpret_cast<FARPROC*>(&PyTuple_Size) = GetProcAddress(m_handlePython, "PyTuple_Size");
|
|
*reinterpret_cast<FARPROC*>(&PyString_FromString) = GetProcAddress(m_handlePython, "PyString_FromString");
|
|
*reinterpret_cast<FARPROC*>(&PyCFunction_NewEx) = GetProcAddress(m_handlePython, "PyCFunction_NewEx");
|
|
*reinterpret_cast<FARPROC*>(&PySys_GetObject) = GetProcAddress(m_handlePython, "PySys_GetObject");
|
|
*reinterpret_cast<FARPROC*>(&PySys_SetObject) = GetProcAddress(m_handlePython, "PySys_SetObject");
|
|
*reinterpret_cast<FARPROC*>(&PySys_SetArgv) = !isPy3 ? GetProcAddress(m_handlePython, "PySys_SetArgv") : 0 ;
|
|
*reinterpret_cast<FARPROC*>(&PySys_SetArgv_Py3) = isPy3 ? GetProcAddress(m_handlePython, "PySys_SetArgv") : 0;
|
|
*reinterpret_cast<FARPROC*>(&PyString_FromString) = GetProcAddress(m_handlePython, "PyString_FromString");
|
|
*reinterpret_cast<FARPROC*>(&PyString_AsString) = GetProcAddress(m_handlePython, "PyString_AsString");
|
|
*reinterpret_cast<FARPROC*>(&PyErr_Fetch) = GetProcAddress(m_handlePython, "PyErr_Fetch");
|
|
*reinterpret_cast<FARPROC*>(&PyErr_NormalizeException) = GetProcAddress(m_handlePython, "PyErr_NormalizeException");
|
|
*reinterpret_cast<FARPROC*>(&PyErr_SetString) = GetProcAddress(m_handlePython, "PyErr_SetString");
|
|
*reinterpret_cast<FARPROC*>(&PyErr_Clear) = GetProcAddress(m_handlePython, "PyErr_Clear");
|
|
*reinterpret_cast<FARPROC*>(&PyImport_AddModule) = GetProcAddress(m_handlePython, "PyImport_AddModule");
|
|
*reinterpret_cast<FARPROC*>(&PyImport_ImportModule) = GetProcAddress(m_handlePython, "PyImport_ImportModule");
|
|
*reinterpret_cast<FARPROC*>(&PyImport_Cleanup) = GetProcAddress(m_handlePython, "PyImport_Cleanup");
|
|
*reinterpret_cast<FARPROC*>(&PyClass_New) = GetProcAddress(m_handlePython, "PyClass_New");
|
|
*reinterpret_cast<FARPROC*>(&PyInstance_New) = GetProcAddress(m_handlePython, "PyInstance_New");
|
|
*reinterpret_cast<FARPROC*>(&PyMethod_New) = GetProcAddress(m_handlePython, "PyMethod_New");
|
|
*reinterpret_cast<FARPROC*>(&PyCapsule_New) = GetProcAddress(m_handlePython, "PyCapsule_New");
|
|
*reinterpret_cast<FARPROC*>(&PyCapsule_GetPointer) = GetProcAddress(m_handlePython, "PyCapsule_GetPointer");
|
|
*reinterpret_cast<FARPROC*>(&PyObject_SetAttrString) = GetProcAddress(m_handlePython, "PyObject_SetAttrString");
|
|
*reinterpret_cast<FARPROC*>(&PyUnicode_FromWideChar) = isPy3 ? GetProcAddress(m_handlePython, "PyUnicode_FromWideChar") :
|
|
GetProcAddress(m_handlePython, "PyUnicodeUCS2_FromWideChar");
|
|
*reinterpret_cast<FARPROC*>(&PyImport_Import) = GetProcAddress(m_handlePython, "PyImport_Import");
|
|
*reinterpret_cast<FARPROC*>(&PyImport_AddModule) = GetProcAddress(m_handlePython, "PyImport_AddModule");
|
|
*reinterpret_cast<FARPROC*>(&PyBool_FromLong) = GetProcAddress(m_handlePython, "PyBool_FromLong");
|
|
*reinterpret_cast<FARPROC*>(&PyList_Size) = GetProcAddress(m_handlePython, "PyList_Size");
|
|
*reinterpret_cast<FARPROC*>(&PyList_GetItem) = GetProcAddress(m_handlePython, "PyList_GetItem");
|
|
*reinterpret_cast<FARPROC*>(&PyFile_FromString) = GetProcAddress(m_handlePython, "PyFile_FromString");
|
|
*reinterpret_cast<FARPROC*>(&PyFile_AsFile) = GetProcAddress(m_handlePython, "PyFile_AsFile");
|
|
*reinterpret_cast<FARPROC*>(&PyUnicode_FromString) = GetProcAddress(m_handlePython, "PyUnicode_FromString");
|
|
*reinterpret_cast<FARPROC*>(&PyInstanceMethod_New) = GetProcAddress(m_handlePython, "PyInstanceMethod_New");
|
|
*reinterpret_cast<FARPROC*>(&PyUnicode_AsWideChar) = GetProcAddress(m_handlePython, "PyUnicode_AsWideChar");
|
|
*reinterpret_cast<FARPROC*>(&_Py_fopen) = GetProcAddress(m_handlePython, "_Py_fopen");
|
|
*reinterpret_cast<FARPROC*>(&Py_AddPendingCall) = GetProcAddress(m_handlePython, "Py_AddPendingCall");
|
|
*reinterpret_cast<FARPROC*>(&PyGILState_Ensure) = GetProcAddress(m_handlePython, "PyGILState_Ensure");
|
|
*reinterpret_cast<FARPROC*>(&PyGILState_Release) = GetProcAddress(m_handlePython, "PyGILState_Release");
|
|
*reinterpret_cast<FARPROC*>(&PyDescr_NewMethod) = GetProcAddress(m_handlePython, "PyDescr_NewMethod");
|
|
*reinterpret_cast<FARPROC*>(&PyGC_Collect) = GetProcAddress(m_handlePython, "PyGC_Collect");
|
|
|
|
|
|
Py_Initialize();
|
|
PyEval_InitThreads();
|
|
|
|
m_globalState = PyEval_SaveThread();
|
|
}
|
|
|
|
|
|
PyModule::~PyModule()
|
|
{
|
|
assert(0);
|
|
|
|
//if (m_globalInterpreter)
|
|
//{
|
|
// delete m_globalInterpreter;
|
|
// m_globalInterpreter = 0;
|
|
//}
|
|
|
|
//PyThreadState_Swap(m_globalState);
|
|
|
|
//Py_Finalize();
|
|
|
|
//FreeLibrary(m_handlePython);
|
|
}
|
|
|
|
|
|
void PyModule::deactivate()
|
|
{
|
|
if (m_globalInterpreter)
|
|
{
|
|
delete m_globalInterpreter;
|
|
m_globalInterpreter = 0;
|
|
}
|
|
|
|
PyThreadState_Swap(m_globalState);
|
|
|
|
if (m_pykdInit)
|
|
{
|
|
PyObject* mainName = isPy3 ? PyUnicode_FromString("__main__") : PyString_FromString("__main__");
|
|
PyObject* mainMod = PyImport_Import(mainName);
|
|
PyObject* globals = PyObject_GetAttrString(mainMod, "__dict__");
|
|
PyObject* result = PyRun_String("__import__('pykd').deinitialize()\n", Py_file_input, globals, globals);
|
|
|
|
if (mainName) Py_DecRef(mainName);
|
|
if (mainMod) Py_DecRef(mainMod);
|
|
if (globals) Py_DecRef(globals);
|
|
if (result) Py_DecRef(result);
|
|
|
|
m_pykdInit = false;
|
|
}
|
|
|
|
m_globalState = PyEval_SaveThread();
|
|
}
|
|
|
|
void PyModule::checkPykd()
|
|
{
|
|
|
|
PyObject *mainName = 0, *mainMod = 0, *globals = 0, *result = 0;
|
|
|
|
do {
|
|
if (m_pykdInit)
|
|
break;
|
|
|
|
mainName = isPy3 ? PyUnicode_FromString("__main__") : PyString_FromString("__main__");
|
|
if (!mainName)
|
|
break;
|
|
|
|
mainMod = PyImport_Import(mainName);
|
|
if (!mainMod)
|
|
break;
|
|
|
|
globals = PyObject_GetAttrString(mainMod, "__dict__");
|
|
if (!globals)
|
|
break;
|
|
|
|
result = PyRun_String("__import__('pykd').initialize()\n", Py_file_input, globals, globals);
|
|
if (!result)
|
|
break;
|
|
|
|
m_pykdInit = true;
|
|
|
|
} while( false);
|
|
|
|
PyErr_Clear();
|
|
|
|
if (mainName) Py_DecRef(mainName);
|
|
if (mainMod) Py_DecRef(mainMod);
|
|
if (globals) Py_DecRef(globals);
|
|
if (result) Py_DecRef(result);
|
|
}
|
|
|
|
PythonInterpreter* activateInterpreter(bool global, int majorVersion, int minorVersion)
|
|
{
|
|
return PythonSingleton::get()->getInterpreter(majorVersion, minorVersion, global);
|
|
}
|
|
|
|
void releaseInterpretor(PythonInterpreter* interpret)
|
|
{
|
|
PythonSingleton::get()->releaseInterpretor(interpret);
|
|
}
|
|
|
|
bool isInterpreterLoaded(int majorVersion, int minorVersion)
|
|
{
|
|
return PythonSingleton::get()->isInterpreterLoaded(majorVersion, minorVersion);
|
|
}
|
|
|
|
void stopAllInterpreter()
|
|
{
|
|
PythonSingleton::get()->stopAllInterpreter();
|
|
}
|
|
|
|
void checkPykd()
|
|
{
|
|
PythonSingleton::get()->checkPykd();
|
|
}
|
|
|
|
void __stdcall Py_IncRef(PyObject* object)
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->Py_IncRef(object);
|
|
}
|
|
|
|
void __stdcall Py_DecRef(PyObject* object)
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->Py_DecRef(object);
|
|
}
|
|
|
|
PyObject* __stdcall PyString_FromString(const char *v)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyString_FromString(v);
|
|
}
|
|
|
|
PyObject* __stdcall PyDict_New()
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyDict_New();
|
|
}
|
|
|
|
PyObject* __stdcall PyDict_GetItemString(PyObject *p, const char *key)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyDict_GetItemString(p, key);
|
|
}
|
|
|
|
int __stdcall PyDict_SetItemString(PyObject *p, const char *key, PyObject *val)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyDict_SetItemString(p, key, val);
|
|
}
|
|
|
|
void __stdcall PyDict_Clear(PyObject *p)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyDict_Clear(p);
|
|
}
|
|
|
|
PyObject* __stdcall PyCFunction_NewEx(PyMethodDef* pydef, PyObject *p1, PyObject *p2)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyCFunction_NewEx(pydef, p1, p2);
|
|
}
|
|
|
|
PyObject* __stdcall PyClass_New(PyObject* className, PyObject* classBases, PyObject* classDict)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyClass_New(className, classBases, classDict);
|
|
}
|
|
|
|
PyObject* __stdcall PyMethod_New(PyObject *func, PyObject *self, PyObject *classobj)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyMethod_New(func, self, classobj);
|
|
}
|
|
|
|
int __stdcall PySys_SetObject(char *name, PyObject *v)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PySys_SetObject(name, v);
|
|
}
|
|
|
|
void __stdcall PySys_SetArgv(int argc, char **argv)
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->PySys_SetArgv(argc, argv);
|
|
}
|
|
|
|
void __stdcall PySys_SetArgv_Py3(int argc, wchar_t **argv)
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->PySys_SetArgv_Py3(argc, argv);
|
|
}
|
|
|
|
PyObject* __stdcall PySys_GetObject(char *name)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PySys_GetObject(name);
|
|
}
|
|
|
|
PyObject* __stdcall PyInstance_New(PyObject *classobj, PyObject *arg, PyObject *kw)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyInstance_New(classobj, arg, kw);
|
|
}
|
|
|
|
int __stdcall PyRun_SimpleString(const char* str)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyRun_SimpleString(str);
|
|
}
|
|
|
|
PyObject* __stdcall PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyRun_String(str, start, globals, locals);
|
|
}
|
|
|
|
PyObject* PyCapsule_New(void *pointer, const char *name, PyCapsule_Destructor destructor)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyCapsule_New(pointer, name, destructor);
|
|
}
|
|
|
|
void* PyCapsule_GetPointer(PyObject *capsule, const char *name)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyCapsule_GetPointer(capsule, name);
|
|
}
|
|
|
|
int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyObject_SetAttrString(o, attr_name, v);
|
|
}
|
|
|
|
PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyObject_GetAttrString(o, attr_name);
|
|
}
|
|
|
|
PyObject* PyObject_CallObject(PyObject *callable_object, PyObject *args)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyObject_CallObject(callable_object, args);
|
|
}
|
|
|
|
PyObject* PyObject_Call(PyObject *callable_object, PyObject *args, PyObject *kw)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyObject_Call(callable_object, args, kw);
|
|
}
|
|
|
|
PyObject* __stdcall PyTuple_New(size_t len)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyTuple_New(len);
|
|
}
|
|
|
|
PyObject* __stdcall PyTuple_GetItem(PyObject *p, size_t pos)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyTuple_GetItem(p, pos);
|
|
}
|
|
|
|
int __stdcall PyTuple_SetItem(PyObject *p, size_t pos, PyObject *obj)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyTuple_SetItem(p, pos, obj);
|
|
}
|
|
|
|
size_t __stdcall PyTuple_Size(PyObject *p)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyTuple_Size(p);
|
|
}
|
|
|
|
char* PyString_AsString(PyObject *string)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyString_AsString(string);
|
|
}
|
|
|
|
PyObject* PyUnicode_FromWideChar(const wchar_t *w, size_t size)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyUnicode_FromWideChar(w, size);
|
|
}
|
|
|
|
PyObject* PyImport_Import(PyObject *name)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyImport_Import(name);
|
|
}
|
|
|
|
PyObject* PyBool_FromLong(long v)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyBool_FromLong(v);
|
|
}
|
|
|
|
PyObject* Py_None()
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->Py_None;
|
|
}
|
|
|
|
PyObject* PyExc_SystemExit()
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyExc_SystemExit;
|
|
}
|
|
|
|
PyObject* PyType_Type()
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyType_Type;
|
|
}
|
|
|
|
PyObject* PyProperty_Type()
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyProperty_Type;
|
|
}
|
|
|
|
void PyErr_Fetch(PyObject **ptype, PyObject **pvalue, PyObject **ptraceback)
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->PyErr_Fetch(ptype, pvalue, ptraceback);
|
|
}
|
|
|
|
|
|
void PyErr_NormalizeException(PyObject**exc, PyObject**val, PyObject**tb)
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->PyErr_NormalizeException(exc, val, tb);
|
|
}
|
|
|
|
void PyErr_Clear()
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->PyErr_Clear();
|
|
}
|
|
|
|
void PyErr_SetString(PyObject *type, const char *message)
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->PyErr_SetString(type, message);
|
|
}
|
|
|
|
size_t PyList_Size(PyObject* list)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyList_Size(list);
|
|
}
|
|
|
|
PyObject* PyList_GetItem(PyObject *list, size_t index)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyList_GetItem(list, index);
|
|
}
|
|
|
|
PyObject* PyFile_FromString(char *filename, char *mode)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyFile_FromString(filename, mode);
|
|
}
|
|
|
|
FILE* PyFile_AsFile(PyObject *pyfile)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyFile_AsFile(pyfile);
|
|
}
|
|
|
|
PyObject* PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyRun_File(fp, filename, start, globals, locals);
|
|
}
|
|
|
|
PyObject* __stdcall PyUnicode_FromString(const char* str)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyUnicode_FromString(str);
|
|
}
|
|
|
|
PyObject* __stdcall PyInstanceMethod_New(PyObject *func)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyInstanceMethod_New(func);
|
|
}
|
|
|
|
size_t __stdcall PyUnicode_AsWideChar(PyObject *unicode, wchar_t *w, size_t size)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyUnicode_AsWideChar(unicode, w, size);
|
|
}
|
|
|
|
PyObject* __stdcall PyImport_ImportModule(const char *name)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyImport_ImportModule(name);
|
|
}
|
|
|
|
PyObject* __stdcall PyImport_AddModule(const char *name)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyImport_AddModule(name);
|
|
}
|
|
|
|
PyThreadState* __stdcall PyEval_SaveThread()
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyEval_SaveThread();
|
|
}
|
|
|
|
void __stdcall PyEval_RestoreThread(PyThreadState *tstate)
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->PyEval_RestoreThread(tstate);
|
|
}
|
|
|
|
FILE* _Py_fopen(const char* filename, const char* mode)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->_Py_fopen(filename, mode);
|
|
}
|
|
|
|
int __stdcall Py_AddPendingCall(int(*func)(void *), void *arg)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->Py_AddPendingCall(func, arg);
|
|
}
|
|
|
|
PyGILState_STATE __stdcall PyGILState_Ensure()
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyGILState_Ensure();
|
|
}
|
|
|
|
void __stdcall PyGILState_Release(PyGILState_STATE state)
|
|
{
|
|
PythonSingleton::get()->currentInterpreter()->m_module->PyGILState_Release(state);
|
|
}
|
|
|
|
PyObject* __stdcall PyDescr_NewMethod(PyObject* type, struct PyMethodDef *meth)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyDescr_NewMethod(type, meth);
|
|
}
|
|
|
|
size_t __stdcall PyGC_Collect(void)
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->PyGC_Collect();
|
|
}
|
|
|
|
bool IsPy3()
|
|
{
|
|
return PythonSingleton::get()->currentInterpreter()->m_module->isPy3;
|
|
}
|
|
|
|
|