Eclipse PythonDev插件

/* **************************************************************************** * * Copyright (c) Microsoft Corporation. * * This source code is subject to terms and conditions of the Apache License, Version 2.0. A * copy of the license can be found in the License.html file at the root of this distribution. If * you cannot locate the Apache License, Version 2.0, please send an email to * vspython@microsoft.com. By using this source code in any fashion, you are agreeing to be bound * by the terms of the Apache License, Version 2.0. * * You must not remove this notice, or any other, from this software. * * Contributor: Fabio Zadrozny * * Based on PyDebugAttach.cpp from PVTS. Windows only. * Initially we did an attach completely based on shellcode which got the * GIL called PyRun_SimpleString with the needed code and was done with it * (so, none of this code was needed). * Now, newer version of Python don't initialize threading by default, so, * most of this code is done only to overcome this limitation (and as a plus, * if there's no code running, we also pause the threads to make our code run). * * On Linux the approach is still the simpler one (using gdb), so, on newer * versions of Python it may not work unless the user has some code running * and threads are initialized. * I.e.: * * The user may have to add the code below in the start of its script for * a successful attach (if he doesn't already use threads). * * from threading import Thread * Thread(target=str).start() * * -- this is the workaround for the fact that we can't get the gil * if there aren't any threads (PyGILState_Ensure gives an error). * ***************************************************************************/ // Access to std::cout and std::endl #include <iostream> // DECLDIR will perform an export for us #define DLL_EXPORT #include "attach.h" #include "stdafx.h" #include "python.h" #pragma comment(lib, "kernel32.lib") #pragma comment(lib, "user32.lib") #pragma comment(lib, "advapi32.lib") #pragma comment(lib, "psapi.lib") // _Always_ is not defined for all versions, so make it a no-op if missing. #ifndef _Always_ #define _Always_(x) x #endif using namespace std; typedef int (Py_IsInitialized)(); typedef void (PyEval_Lock)(); // Acquire/Release lock typedef void (PyThreadState_API)(PyThreadState *); // Acquire/Release lock typedef PyInterpreterState* (PyInterpreterState_Head)(); typedef PyThreadState* (PyInterpreterState_ThreadHead)(PyInterpreterState* interp); typedef PyThreadState* (PyThreadState_Next)(PyThreadState *tstate); typedef PyThreadState* (PyThreadState_Swap)(PyThreadState *tstate); typedef int (PyRun_SimpleString)(const char *command); typedef PyObject* (PyDict_New)(); typedef PyObject* (PyModule_New)(const char *name); typedef PyObject* (PyModule_GetDict)(PyObject *module); typedef PyObject* (Py_CompileString)(const char *str, const char *filename, int start); typedef PyObject* (PyEval_EvalCode)(PyObject *co, PyObject *globals, PyObject *locals); typedef PyObject* (PyDict_GetItemString)(PyObject *p, const char *key); typedef PyObject* (PyObject_CallFunctionObjArgs)(PyObject *callable, ...); // call w/ varargs, last arg should be NULL typedef void (PyErr_Fetch)(PyObject **, PyObject **, PyObject **); typedef PyObject* (PyEval_GetBuiltins)(); typedef int (PyDict_SetItemString)(PyObject *dp, const char *key, PyObject *item); typedef int (PyEval_ThreadsInitialized)(); typedef void (Py_AddPendingCall)(int (*func)(void *), void*); typedef PyObject* (PyInt_FromLong)(long); typedef PyObject* (PyString_FromString)(const char* s); typedef void PyEval_SetTrace(Py_tracefunc func, PyObject *obj); typedef void (PyErr_Restore)(PyObject *type, PyObject *value, PyObject *traceback); typedef void (PyErr_Fetch)(PyObject **ptype, PyObject **pvalue, PyObject **ptraceback); typedef PyObject* (PyErr_Occurred)(); typedef PyObject* (PyErr_Print)(); typedef PyObject* (PyImport_ImportModule) (const char *name); typedef PyObject* (PyObject_GetAttrString)(PyObject *o, const char *attr_name); typedef PyObject* (PyObject_HasAttrString)(PyObject *o, const char *attr_name); typedef PyObject* (PyObject_SetAttrString)(PyObject *o, const char *attr_name, PyObject* value); typedef PyObject* (PyBool_FromLong)(long v); typedef enum { PyGILState_LOCKED, PyGILState_UNLOCKED } PyGILState_STATE; typedef PyGILState_STATE(PyGILState_Ensure)(); typedef void (PyGILState_Release)(PyGILState_STATE); typedef unsigned long (_PyEval_GetSwitchInterval)(void); typedef void (_PyEval_SetSwitchInterval)(unsigned long microseconds); typedef void* (PyThread_get_key_value)(int); typedef int (PyThread_set_key_value)(int, void*); typedef void (PyThread_delete_key_value)(int); typedef PyGILState_STATE PyGILState_EnsureFunc(void); typedef void PyGILState_ReleaseFunc(PyGILState_STATE); typedef PyObject* PyInt_FromSize_t(size_t ival); typedef PyThreadState *PyThreadState_NewFunc(PyInterpreterState *interp); class PyObjectHolder; PyObject* GetPyObjectPointerNoDebugInfo(bool isDebug, PyObject* object); void DecRef(PyObject* object, bool isDebug); void IncRef(PyObject* object, bool isDebug); #define MAX_INTERPRETERS 10 // Helper class so we can use RAII for freeing python objects when they go out of scope class PyObjectHolder { private: PyObject* _object; public: bool _isDebug; PyObjectHolder(bool isDebug) { _object = nullptr; _isDebug = isDebug; } PyObjectHolder(bool isDebug, PyObject *object) { _object = object; _isDebug = isDebug; }; PyObjectHolder(bool isDebug, PyObject *object, bool addRef) { _object = object; _isDebug = isDebug; if (_object != nullptr && addRef) { GetPyObjectPointerNoDebugInfo(_isDebug, _object)->ob_refcnt++; } }; PyObject* ToPython() { return _object; } ~PyObjectHolder() { DecRef(_object, _isDebug); } PyObject* operator* () { return GetPyObjectPointerNoDebugInfo(_isDebug, _object); } }; class InterpreterInfo { public: InterpreterInfo(HMODULE module, bool debug) : Interpreter(module), CurrentThread(nullptr), NewThreadFunction(nullptr), PyGILState_Ensure(nullptr), Version(PythonVersion_Unknown), Call(nullptr), IsDebug(debug), SetTrace(nullptr), PyThreadState_New(nullptr), ThreadState_Swap(nullptr) { } ~InterpreterInfo() { if (NewThreadFunction != nullptr) { delete NewThreadFunction; } } PyObjectHolder* NewThreadFunction; PyThreadState** CurrentThread; HMODULE Interpreter; PyGILState_EnsureFunc* PyGILState_Ensure; PyEval_SetTrace* SetTrace; PyThreadState_NewFunc* PyThreadState_New; PyThreadState_Swap* ThreadState_Swap; PythonVersion GetVersion() { if (Version == PythonVersion_Unknown) { Version = ::GetPythonVersion(Interpreter); } return Version; } PyObject_CallFunctionObjArgs* GetCall() { if (Call == nullptr) { Call = (PyObject_CallFunctionObjArgs*)GetProcAddress(Interpreter, "PyObject_CallFunctionObjArgs"); } return Call; } bool EnsureSetTrace() { if (SetTrace == nullptr) { auto setTrace = (PyEval_SetTrace*)(void*)GetProcAddress(Interpreter, "PyEval_SetTrace"); SetTrace = setTrace; } return SetTrace != nullptr; } bool EnsureThreadStateSwap() { if (ThreadState_Swap == nullptr) { auto swap = (PyThreadState_Swap*)(void*)GetProcAddress(Interpreter, "PyThreadState_Swap"); ThreadState_Swap = swap; } return ThreadState_Swap != nullptr; } bool EnsureCurrentThread() { if (CurrentThread == nullptr) { auto curPythonThread = (PyThreadState**)(void*)GetProcAddress( Interpreter, "_PyThreadState_Current"); CurrentThread = curPythonThread;