#include "stdafx.h"
#include "pyinterpret.h"

#include <memory>
#include <sstream>
#include <map>

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

    PyObject* PyType_Type;
    PyObject* Py_None;
    PyObject* PyExc_SystemExit;

    void(__stdcall *Py_Initialize)();
    void(__stdcall *Py_Finalize)();

    PyThreadState* (__stdcall *Py_NewInterpreter)();
    void(__stdcall *Py_EndInterpreter)(PyThreadState *tstate);
    PyObject* (__stdcall *PyEval_GetGlobals)();
    PyObject* (__stdcall *PyImport_Import)(PyObject *name);
    PyObject* (__stdcall *PyImport_ImportModule)(const char *name);
    void(__stdcall *PyEval_InitThreads)();
    PyThreadState* (__stdcall *PyEval_SaveThread)();
    void(__stdcall *PyEval_RestoreThread)(PyThreadState *tstate);
    PyThreadState* (__stdcall *PyThreadState_Swap)(PyThreadState *tstate);
    PyObject* (__stdcall *PyRun_String)(const char *str, int start, PyObject *globals, PyObject *locals);
    int(__stdcall *PyRun_SimpleString)(const char*  str);
    PyObject* (__stdcall *PyRun_File)(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals);
    PyObject* (__stdcall *PyDict_New)();
    int(__stdcall *PyDict_SetItemString)(PyObject *p, const char *key, PyObject *val);
    PyObject*(__stdcall *PyDict_GetItemString)(PyObject *p, const char* key);
    void(__stdcall *Py_IncRef)(PyObject* object);
    void(__stdcall *Py_DecRef)(PyObject* object);
    PyObject* (__stdcall *PyObject_Call)(PyObject *callable_object, PyObject *args, PyObject *kw);
    PyObject* (__stdcall *PyObject_GetAttr)(PyObject *object, PyObject *attr_name);
    PyObject* (__stdcall *PyObject_GetAttrString)(PyObject *object, const char *attr_name);
    int(__stdcall *PyObject_SetAttr)(PyObject *object, PyObject *attr_name, PyObject *value);
    PyObject* (__stdcall *PyObject_CallObject)(PyObject *callable_object, PyObject *args);
    PyObject* (__stdcall *PyTuple_New)(size_t len);
    int(__stdcall *PyTuple_SetItem)(PyObject *p, size_t pos, PyObject *o);
    PyObject* (__stdcall *PyTuple_GetItem)(PyObject *p, size_t pos);
    size_t(__stdcall *PyTuple_Size)(PyObject *p);
    PyObject* (__stdcall *PyCFunction_NewEx)(PyMethodDef *, PyObject *, PyObject *);
    PyObject* (__stdcall *PySys_GetObject)(char *name);
    int(__stdcall *PySys_SetObject)(char *name, PyObject *v);
    void(__stdcall *PySys_SetArgv)(int argc, char **argv);
    void(__stdcall *PySys_SetArgv_Py3)(int argc, wchar_t **argv);
    PyObject* (__stdcall *PyString_FromString)(const char *v);
    char* (__stdcall *PyString_AsString)(PyObject *string);
    void(__stdcall *PyErr_Fetch)(PyObject **ptype, PyObject **pvalue, PyObject **ptraceback);
    void(__stdcall *PyErr_NormalizeException)(PyObject**exc, PyObject**val, PyObject**tb);
    void (__stdcall *PyErr_SetString)(PyObject *type, const char *message);
    PyObject* (__stdcall *PyImport_AddModule)(const char *name);
    PyObject* (__stdcall *PyClass_New)(PyObject* className, PyObject* classBases, PyObject* classDict);
    PyObject* (__stdcall *PyInstance_New)(PyObject *classobj, PyObject *arg, PyObject *kw);
    PyObject* (__stdcall *PyMethod_New)(PyObject *func, PyObject *self, PyObject *classobj);
    PyObject* (__stdcall *PyCapsule_New)(void *pointer, const char *name, PyCapsule_Destructor destructor);
    void* (__stdcall *PyCapsule_GetPointer)(PyObject *capsule, const char *name);
    int(__stdcall *PyObject_SetAttrString)(PyObject *o, const char *attr_name, PyObject *v);
    PyObject* (__stdcall *PyUnicode_FromWideChar)(const wchar_t *w, size_t size);
    PyObject* (__stdcall *PyBool_FromLong)(long v);
    size_t(__stdcall *PyList_Size)(PyObject* list);
    PyObject* (__stdcall *PyList_GetItem)(PyObject *list, size_t index);
    PyObject* (__stdcall *PyFile_FromString)(char *filename, char *mode);
    FILE* (__stdcall *PyFile_AsFile)(PyObject *pyfile);
    PyObject* (__stdcall *PyUnicode_FromString)(const char *u);
    PyObject* (__stdcall *PyInstanceMethod_New)(PyObject *func);
    size_t(__stdcall *PyUnicode_AsWideChar)(PyObject *unicode, wchar_t *w, size_t size);
    FILE* ( __stdcall *_Py_fopen)(const char* filename, const char* mode);
    int(__stdcall *Py_AddPendingCall)(int(*func)(void *), void *arg);
    PyGILState_STATE(__stdcall *PyGILState_Ensure)();
    void(__stdcall *PyGILState_Release)(PyGILState_STATE state);

    HMODULE  m_handlePython;
    PyThreadState*  m_globalState;
    PythonInterpreter*  m_globalInterpreter;
};

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->Py_EndInterpreter(m_state);
    }

    PyModule*  m_module;

    PyThreadState*  m_state;
};




class PythonSingleton
{
public:


    static PythonInterpreter* getInterpreter(int majorVersion, int minorVersion, bool global)
    {
        return getSingleton()->_getInterpreter(majorVersion, minorVersion, global);
    }

    static void releaseInterpretor(PythonInterpreter* interpret)
    {
        return getSingleton()->_releaseInterpretor(interpret);
    }

    static PythonInterpreter* currentInterpreter()
    {
        return getSingleton()->m_currentInterpter;
    }

private:

    static std::auto_ptr<PythonSingleton>  m_singleton;

    static  PythonSingleton*  getSingleton()
    {
        if (m_singleton.get() == 0)
            m_singleton.reset(new PythonSingleton());
        return m_singleton.get();
    }

    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_currentInterpter = module->m_globalInterpreter;
            m_currentIsGlobal = true;
        }
        else
        {
            module->PyEval_RestoreThread(module->m_globalState);
            m_currentInterpter = new PythonInterpreter(module);
            m_currentIsGlobal = false;
        }

        m_currentInterpter->m_module->PyEval_RestoreThread(m_currentInterpter->m_state);

        return m_currentInterpter;
    }

    void _releaseInterpretor(PythonInterpreter* interpret)
    {
        PyModule*  module = m_currentInterpter->m_module;

        m_currentInterpter->m_state = module->PyEval_SaveThread();

        if (!m_currentIsGlobal)
        {
            delete m_currentInterpter;

            module->PyThreadState_Swap(module->m_globalState);
            module->m_globalState = module->PyEval_SaveThread();
        }

        m_currentInterpter = 0;
    }

public:

    std::map<std::pair<int,int>, PyModule*>  m_modules;
   
    PythonInterpreter*  m_currentInterpter;
    bool  m_currentIsGlobal;
};

std::auto_ptr<PythonSingleton>  PythonSingleton::m_singleton; 


HMODULE LoadPythonLibrary(int majorVesion, 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;
            installPathStr << majorVesion << '.' << minorVersion << "\\InstallPath";

            if (ERROR_SUCCESS == RegOpenKeyA(pythonCoreKey, installPathStr.str().c_str(), installPathKey))
            {
                char  installPath[1000];
                DWORD  installPathSize = sizeof(installPath);

                if (ERROR_SUCCESS == RegQueryValueExA(installPathKey, NULL, NULL, NULL, (LPBYTE)installPath, &installPathSize))
                {
                    std::stringstream  dllName;
                    dllName << "python" << majorVesion << minorVersion << ".dll";

                    HMODULE  hmodule = LoadLibraryA(dllName.str().c_str());
                    if (hmodule)
                        return hmodule;

                    std::stringstream  imagePath;
                    imagePath << installPath << dllName.str();

                    hmodule = LoadLibraryExA(imagePath.str().c_str(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
                    if (hmodule)
                        return hmodule;
                }
            }
        }
    }

    return NULL;
}

std::list<InterpreterDesc>  getInstalledInterpreter()
{
    std::list<InterpreterDesc>  lst;

    for (auto rootKey : 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, minorVersion;

            sscanf_s(versionStr, "%d.%d", &majorVersion, &minorVersion);

            HMODULE  hmodule = LoadPythonLibrary(majorVersion, minorVersion);

            if (hmodule)
            {
                char  fullPath[1000];

                if (GetModuleFileNameA(hmodule, fullPath, sizeof(fullPath)))
                    lst.push_back({ majorVersion, minorVersion, fullPath });

                FreeLibrary(hmodule);
            }
        }
    }

    return lst;
}

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*>(&Py_None) = GetProcAddress(m_handlePython, "_Py_NoneStruct");
    PyExc_SystemExit = *reinterpret_cast<PyObject**>(GetProcAddress(m_handlePython, "PyExc_SystemExit"));

    *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*>(&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*>(&PyImport_AddModule) = GetProcAddress(m_handlePython, "PyImport_AddModule");
    *reinterpret_cast<FARPROC*>(&PyImport_ImportModule) = GetProcAddress(m_handlePython, "PyImport_ImportModule");    
    *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*>(&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");
    
    Py_Initialize();
    PyEval_InitThreads();
    m_globalState = PyEval_SaveThread();
}


PyModule::~PyModule()
{
    PyEval_RestoreThread(m_globalState);

    Py_Finalize();

    FreeLibrary(m_handlePython);
}


PythonInterpreter* activateInterpreter(bool global, int majorVersion, int minorVersion)
{
    return PythonSingleton::getInterpreter(majorVersion, minorVersion, global);
}

void releaseInterpretor(PythonInterpreter* interpret)
{
    PythonSingleton::releaseInterpretor(interpret);
}


void __stdcall Py_IncRef(PyObject* object)
{
    PythonSingleton::currentInterpreter()->m_module->Py_IncRef(object);
}

void __stdcall Py_DecRef(PyObject* object)
{
    PythonSingleton::currentInterpreter()->m_module->Py_DecRef(object);
}

PyObject* __stdcall PyString_FromString(const char *v)
{
    return PythonSingleton::currentInterpreter()->m_module->PyString_FromString(v);
}

PyObject* __stdcall  PyDict_New()
{
    return PythonSingleton::currentInterpreter()->m_module->PyDict_New();
}

PyObject* __stdcall PyDict_GetItemString(PyObject *p, const char *key)
{
    return PythonSingleton::currentInterpreter()->m_module->PyDict_GetItemString(p, key);
}

int __stdcall PyDict_SetItemString(PyObject *p, const char *key, PyObject *val)
{
    return PythonSingleton::currentInterpreter()->m_module->PyDict_SetItemString(p, key, val);
}

PyObject* __stdcall PyCFunction_NewEx(PyMethodDef* pydef, PyObject *p1, PyObject *p2)
{
    return PythonSingleton::currentInterpreter()->m_module->PyCFunction_NewEx(pydef, p1, p2);
}

PyObject* __stdcall PyClass_New(PyObject* className, PyObject* classBases, PyObject* classDict)
{
    return PythonSingleton::currentInterpreter()->m_module->PyClass_New(className, classBases, classDict);
}

PyObject* __stdcall PyMethod_New(PyObject *func, PyObject *self, PyObject *classobj)
{
    return PythonSingleton::currentInterpreter()->m_module->PyMethod_New(func, self, classobj);
}

int __stdcall PySys_SetObject(char *name, PyObject *v)
{
    return PythonSingleton::currentInterpreter()->m_module->PySys_SetObject(name, v);
}

void __stdcall PySys_SetArgv(int argc, char **argv)
{
    PythonSingleton::currentInterpreter()->m_module->PySys_SetArgv(argc, argv);
}

void __stdcall PySys_SetArgv_Py3(int argc, wchar_t **argv)
{
    PythonSingleton::currentInterpreter()->m_module->PySys_SetArgv_Py3(argc, argv);
}

PyObject* __stdcall PySys_GetObject(char *name)
{
    return PythonSingleton::currentInterpreter()->m_module->PySys_GetObject(name);
}

PyObject* __stdcall PyInstance_New(PyObject *classobj, PyObject *arg, PyObject *kw)
{
    return PythonSingleton::currentInterpreter()->m_module->PyInstance_New(classobj, arg, kw);
}

int __stdcall PyRun_SimpleString(const char* str)
{
    return PythonSingleton::currentInterpreter()->m_module->PyRun_SimpleString(str);
}

PyObject* __stdcall PyRun_String(const char *str, int start, PyObject *globals, PyObject *locals)
{
    return PythonSingleton::currentInterpreter()->m_module->PyRun_String(str, start, globals, locals);
}

PyObject* PyCapsule_New(void *pointer, const char *name, PyCapsule_Destructor destructor)
{
    return PythonSingleton::currentInterpreter()->m_module->PyCapsule_New(pointer, name, destructor);
}

void* PyCapsule_GetPointer(PyObject *capsule, const char *name)
{
    return PythonSingleton::currentInterpreter()->m_module->PyCapsule_GetPointer(capsule, name);
}

int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v)
{
    return PythonSingleton::currentInterpreter()->m_module->PyObject_SetAttrString(o, attr_name, v);
}

PyObject* PyObject_GetAttrString(PyObject *o, const char *attr_name)
{
    return PythonSingleton::currentInterpreter()->m_module->PyObject_GetAttrString(o, attr_name);
}

PyObject* PyObject_CallObject(PyObject *callable_object, PyObject *args)
{
    return PythonSingleton::currentInterpreter()->m_module->PyObject_CallObject(callable_object, args);
}

PyObject* PyObject_Call(PyObject *callable_object, PyObject *args, PyObject *kw)
{
    return PythonSingleton::currentInterpreter()->m_module->PyObject_Call(callable_object, args, kw);
}

PyObject* __stdcall PyTuple_New(size_t len)
{
    return PythonSingleton::currentInterpreter()->m_module->PyTuple_New(len);
}

PyObject* __stdcall PyTuple_GetItem(PyObject *p, size_t pos)
{
    return PythonSingleton::currentInterpreter()->m_module->PyTuple_GetItem(p, pos);
}

int __stdcall PyTuple_SetItem(PyObject *p, size_t pos, PyObject *obj)
{
    return PythonSingleton::currentInterpreter()->m_module->PyTuple_SetItem(p, pos, obj);
}

size_t __stdcall PyTuple_Size(PyObject *p)
{
    return PythonSingleton::currentInterpreter()->m_module->PyTuple_Size(p);
}

char* PyString_AsString(PyObject *string)
{
    return PythonSingleton::currentInterpreter()->m_module->PyString_AsString(string);
}

PyObject* PyUnicode_FromWideChar(const wchar_t *w, size_t size)
{
    return PythonSingleton::currentInterpreter()->m_module->PyUnicode_FromWideChar(w, size);
}

PyObject* PyImport_Import(PyObject *name)
{
    return PythonSingleton::currentInterpreter()->m_module->PyImport_Import(name);
}

PyObject* PyBool_FromLong(long v)
{
    return PythonSingleton::currentInterpreter()->m_module->PyBool_FromLong(v);
}

PyObject* Py_None()
{
    return PythonSingleton::currentInterpreter()->m_module->Py_None;
}

PyObject* PyExc_SystemExit()
{
    return PythonSingleton::currentInterpreter()->m_module->PyExc_SystemExit;
}

PyObject* PyType_Type()
{
    return  PythonSingleton::currentInterpreter()->m_module->PyType_Type;
}

void PyErr_Fetch(PyObject **ptype, PyObject **pvalue, PyObject **ptraceback)
{
    PythonSingleton::currentInterpreter()->m_module->PyErr_Fetch(ptype, pvalue, ptraceback);
}


void PyErr_NormalizeException(PyObject**exc, PyObject**val, PyObject**tb)
{
    PythonSingleton::currentInterpreter()->m_module->PyErr_NormalizeException(exc, val, tb);
}

void PyErr_SetString(PyObject *type, const char *message)
{
    PythonSingleton::currentInterpreter()->m_module->PyErr_SetString(type, message);
}

size_t PyList_Size(PyObject* list)
{
    return PythonSingleton::currentInterpreter()->m_module->PyList_Size(list);
}

PyObject* PyList_GetItem(PyObject *list, size_t index)
{
    return PythonSingleton::currentInterpreter()->m_module->PyList_GetItem(list, index);
}

PyObject* PyFile_FromString(char *filename, char *mode)
{
    return PythonSingleton::currentInterpreter()->m_module->PyFile_FromString(filename, mode);
}

FILE* PyFile_AsFile(PyObject *pyfile)
{
    return PythonSingleton::currentInterpreter()->m_module->PyFile_AsFile(pyfile);
}

PyObject* PyRun_File(FILE *fp, const char *filename, int start, PyObject *globals, PyObject *locals)
{
    return PythonSingleton::currentInterpreter()->m_module->PyRun_File(fp, filename, start, globals, locals);
}

PyObject* __stdcall PyUnicode_FromString(const char*  str)
{
    return PythonSingleton::currentInterpreter()->m_module->PyUnicode_FromString(str);
}

PyObject* __stdcall PyInstanceMethod_New(PyObject *func)
{
    return PythonSingleton::currentInterpreter()->m_module->PyInstanceMethod_New(func);
}

size_t __stdcall PyUnicode_AsWideChar(PyObject *unicode, wchar_t *w, size_t size)
{
    return PythonSingleton::currentInterpreter()->m_module->PyUnicode_AsWideChar(unicode, w, size);
}

PyObject* __stdcall PyImport_ImportModule(const char *name)
{
    return PythonSingleton::currentInterpreter()->m_module->PyImport_ImportModule(name);
}

PyThreadState* __stdcall PyEval_SaveThread()
{
    return PythonSingleton::currentInterpreter()->m_module->PyEval_SaveThread();
}

void __stdcall PyEval_RestoreThread(PyThreadState *tstate)
{
    PythonSingleton::currentInterpreter()->m_module->PyEval_RestoreThread(tstate);
}

FILE* _Py_fopen(const char* filename, const char* mode)
{
    return PythonSingleton::currentInterpreter()->m_module->_Py_fopen(filename, mode);
}

int __stdcall Py_AddPendingCall(int(*func)(void *), void *arg)
{
    return PythonSingleton::currentInterpreter()->m_module->Py_AddPendingCall(func, arg);
}

PyGILState_STATE __stdcall PyGILState_Ensure()
{
    return PythonSingleton::currentInterpreter()->m_module->PyGILState_Ensure();
}

void __stdcall PyGILState_Release(PyGILState_STATE state)
{
    PythonSingleton::currentInterpreter()->m_module->PyGILState_Release(state);
}

bool IsPy3()
{
    return PythonSingleton::currentInterpreter()->m_module->isPy3;
}