forks
/
dlangide
mirror of https://github.com/buggins/dlangide.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fixes

This commit is contained in:
Vadim Lopatin 2016-09-12 09:17:35 +03:00
parent 1fb3bd9ec1
commit 21606da3e1
7 changed files with 2 additions and 6266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
dlangide_msvc.visualdproj
View File

@ -709,12 +709,6 @@
<File path="src\ddebug\gdb\gdbinterface.d" />
<File path="src\ddebug\gdb\gdbmiparser.d" />
</Folder>
<Folder name="windows">
<File path="src\ddebug\windows\debuginfo.d" />
<File path="src\ddebug\windows\mago.d" />
<File path="src\ddebug\windows\msdbg.d" />
<File path="src\ddebug\windows\windebug.d" />
</Folder>
</Folder>
<Folder name="dlangide">
<Folder name="builders">

161
src/ddebug/windows/debuginfo.d
View File

@ -1,161 +0,0 @@
module ddebug.windows.debuginfo;
version(Windows):
import dlangui.core.logger;
import std.file;
import std.algorithm;
import std.conv;
import std.exception;
class FileFormatException : Exception {
this(string msg, Exception baseException = null, string file = __FILE__, size_t line = __LINE__) {
super(msg, baseException, file, line);
}
this(Exception baseException = null, string file = __FILE__, size_t line = __LINE__) {
super("", baseException, file, line);
}
//this(string file = __FILE__, size_t line = __LINE__) {
// super("Exception while parsing file format", file, line);
//}
}
struct Buffer {
ubyte[] buf;
void skip(uint bytes) {
enforce(bytes <= buf.length, new FileFormatException("skip: index is outside file range"));
buf = buf[bytes .. $];
}
uint uintAt(uint pos) {
enforce(pos + 4 <= buf.length, new FileFormatException("uintAt: index is outside file range"));
return cast(uint)buf[pos] | (cast(uint)buf[pos + 1] << 8) | (cast(uint)buf[pos + 2] << 16) | (cast(uint)buf[pos + 3] << 24);
}
ushort ushortAt(uint pos) {
enforce(pos + 2 <= buf.length, new FileFormatException("ushortAt: index is outside file range"));
return cast(ushort)buf[pos] | (cast(ushort)buf[pos + 1] << 8);
}
ubyte ubyteAt(uint pos) {
enforce(pos + 1 <= buf.length, new FileFormatException("ubyteAt: index is outside file range"));
return buf[pos];
}
//void check(uint pos, string data) {
// enforce(pos + data.length <= buf.length, new FileFormatException("check: index is outside file range"));
// enforce(equal(buf[pos..pos + data.length], cast(ubyte[])data), new FileFormatException("pattern does not match"));
//}
void check(uint pos, ubyte[] data) {
enforce(pos + data.length <= buf.length, new FileFormatException("check: index is outside file range"));
enforce(equal(buf[pos..pos + data.length], data), new FileFormatException("pattern does not match"));
}
ubyte[] sectionAt(uint pos) {
uint rva = uintAt(pos);
uint sz = uintAt(pos + 4);
Log.d("section rva=", rva, " sz=", sz);
if (!sz)
return null;
enforce(pos + sz <= buf.length, new FileFormatException("sectionAt: index is outside file range"));
return buf[rva .. rva + sz];
}
string stringzAt(uint pos, uint maxSize) {
char[] res;
for (uint p = pos; maxSize == 0 || p < pos + maxSize; p++) {
ubyte ch = ubyteAt(p);
if (!ch)
break;
res ~= ch;
}
return cast(string)res;
}
ubyte[] rangeAt(uint pos, uint size) {
Log.d("rangeAt: pos=", pos, " size=", size, " pos+size=", pos+size, " buf.len=", buf.length);
uint endp = pos + size;
//if (endp > buf.length)
// endp = cast(uint)buf.length;
enforce(pos <= endp, new FileFormatException("rangeAt: index is outside file range"));
return buf[pos .. endp];
}
}
struct Section {
string name;
uint vsize;
uint rva;
uint sz;
uint offset;
uint flags;
this(ref Buffer buf, uint pos) {
name = buf.stringzAt(pos, 8);
vsize = buf.uintAt(pos + 0x08);
rva = buf.uintAt(pos + 0x0C);
sz = buf.uintAt(pos + 0x10);
offset = buf.uintAt(pos + 0x14);
flags = buf.uintAt(pos + 0x28);
}
}
class OMFDebugInfo {
Buffer data;
uint peoffset;
bool load(string filename) {
try {
data.buf = cast(ubyte[])std.file.read(filename);
data.check(0, ['M', 'Z']);
peoffset = data.uintAt(0x3c);
Buffer pe;
pe.buf = data.buf[peoffset .. $];
//data.skip(peoffset);
pe.check(0, ['P', 'E', 0, 0]);
ushort objectCount = pe.ushortAt(0x06);
ushort flags = pe.ushortAt(0x16);
ushort subsystem = pe.ushortAt(0x5c);
uint coffRva = pe.uintAt(0x0c);
uint coffSize = pe.uintAt(0x10);
Log.d("subsystem: ", subsystem, " flags: ", flags, " coffRva:", coffRva, " coffSize:", coffSize);
//ubyte[] debugInfo = data.sectionAt(peoffset + 0xA8);
//ubyte[] exportInfo = data.sectionAt(peoffset + 0x78);
//ubyte[] importInfo = data.sectionAt(peoffset + 0x7c);
//ubyte[] resInfo = data.sectionAt(peoffset + 0x88);
//Buffer debugHeader;
//debugHeader.buf = debugInfo;
//uint debugType = debugHeader.uintAt(0x0C);
//uint debugSize = debugHeader.uintAt(0x10);
//uint debugRva = debugHeader.uintAt(0x14);
//uint debugSeek = debugHeader.uintAt(0x18);
//Log.d("debugInfo[", debugInfo.length, "] type=", debugType, " debugSize=", debugSize, " rva=", debugRva, " seek=", debugSeek, " seek-rva=");
//ubyte[] debugRaw = data.rangeAt(debugSeek, debugSize);
//Log.d("debugRaw: ", debugRaw);
ubyte[] debugData;
for (int i = 0; i < objectCount; i++) {
Section section = Section(data, peoffset + 0xF8 + i * 0x28);
Log.d("section ", section.name, " rva=", section.rva, " sz=", section.sz, " offset=", section.offset);
if (section.name.equal(".debug"))
debugData = data.rangeAt(section.offset, section.sz);
}
if (debugData) {
string debugName = cast(string)debugData[1.. debugData[0] + 1];
Log.d("Found debug data: name=", debugName, " sz=", debugData.length);
}
return true;
} catch (Exception e) {
throw new FileFormatException(e);
}
}
}
debug(DebugInfo) {
void debugInfoTest(string filename) {
OMFDebugInfo omf = new OMFDebugInfo();
Log.d("Loading debug info from file ", filename);
try {
if (omf.load(filename)) {
Log.d("Loaded ok");
} else {
Log.d("Failed");
}
} catch (FileFormatException e) {
Log.e("FileFormatException: ", e);
}
}
}

210
src/ddebug/windows/mago.d
View File

@ -1,210 +0,0 @@
module ddebug.windows.mago;
version(Windows):
version(USE_MAGO):
import ddebug.windows.msdbg;
import dlangui.core.logger;
import core.atomic;
import std.string;
//const GUID CLSID_MAGO = {0xE348A53A, 0x470A, 0x4A70, [0x9B, 0x55, 0x1E, 0x02, 0xF3, 0x52, 0x79, 0x0D]};
const GUID IID_MAGO_NATIVE_ENGINE = {0x97348AC0, 0x2B6B, 0x4B99, [0xA2, 0x45, 0x4C, 0x7E, 0x2C, 0x09, 0xD4, 0x03]};
//const GUID CLSID_PORT_SUPPLIER = {0x3484EFB2, 0x0A52, 0x4EB2, [0x86, 0x9C, 0x1F, 0x7E, 0x66, 0x8E, 0x1B, 0x87]};
//const GUID CLSID_PORT_SUPPLIER = {0x3B476D38, 0xA401, 0x11D2, [0xAA, 0xD4, 0x00, 0xC0, 0x4F, 0x99, 0x01, 0x71]}; //3B476D38-A401-11D2-AAD4-00C04F990171
const GUID CLSID_PORT_SUPPLIER = {0x708C1ECA, 0xFF48, 0x11D2, [0x90, 0x4F, 0x00, 0xC0, 0x4F, 0xA3, 0x02, 0xA1]}; //{708C1ECA-FF48-11D2-904F-00C04FA302A1}
//const GUID CLSID_PORT_SUPPLIER = {0xF561BF8D, 0xBFBA, 0x4FC6, [0xAE, 0xA7, 0x24, 0x45, 0xD0, 0xEA, 0xC1, 0xC5]};
//const GUID CLSID_PORT_SUPPLIER = {0x708C1ECA, 0xFF48, 0x11D2, [0x90, 0x4F, 0x00, 0x04, 0xA3, 0x2, 0xA1]};
class ComObject : IUnknown
{
extern (Windows):
HRESULT QueryInterface(GUID* riid, void** ppv)
{
if (*riid == IID_IUnknown)
{
*ppv = cast(void*)cast(IUnknown)this;
AddRef();
return S_OK;
}
else
{ *ppv = null;
return E_NOINTERFACE;
}
}
ULONG AddRef()
{
return atomicOp!"+="(*cast(shared)&count, 1);
}
ULONG Release()
{
LONG lRef = atomicOp!"-="(*cast(shared)&count, 1);
if (lRef == 0)
{
// free object
// If we delete this object, then the postinvariant called upon
// return from Release() will fail.
// Just let the GC reap it.
//delete this;
return 0;
}
return cast(ULONG)lRef;
}
LONG count = 0; // object reference count
}
class DebugCallback : ComObject, IDebugEventCallback2 {
override HRESULT Event(
/+[in]+/ IDebugEngine2 pEngine,
/+[in]+/ IDebugProcess2 pProcess,
/+[in]+/ IDebugProgram2 pProgram,
/+[in]+/ IDebugThread2 pThread,
/+[in]+/ IDebugEvent2 pEvent,
in IID* riidEvent,
in DWORD dwAttrib) {
//
Log.d("debug event");
return 0;
}
}
string formatHResult(HRESULT hr) {
switch(hr) {
case S_OK: return "S_OK";
case S_FALSE: return "S_FALSE";
case E_NOTIMPL: return "E_NOTIMPL";
case E_NOINTERFACE: return "E_NOINTERFACE";
case E_FAIL: return "E_FAIL";
case E_HANDLE: return "E_HANDLE";
case 0x80040154: return "REGDB_E_CLASSNOTREG";
default:
return format("%08x", hr);
}
}
IDebugPortSupplier2 createPortSupplier() {
HRESULT hr;
IDebugPortSupplier2 portSupplier = null;
LPOLESTR str;
StringFromCLSID(&CLSID_PORT_SUPPLIER, &str);
hr = CoCreateInstance(&CLSID_PORT_SUPPLIER, //CLSID_MAGO,
null,
CLSCTX_INPROC, //CLSCTX_ALL,
&IID_IDebugPortSupplier2, //IID_MAGO_NATIVE_ENGINE,
cast(void**)&portSupplier); //piUnknown);
if (FAILED(hr) || !portSupplier) {
Log.e("Failed to create port supplier ", formatHResult(hr));
return null;
}
Log.i("Port supplier is created");
return portSupplier;
}
class DebugPortRequest : ComObject, IDebugPortRequest2 {
static const wchar[] portName = "magoDebuggerPort\0";
HRESULT GetPortName(/+[out]+/ BSTR* pbstrPortName) {
pbstrPortName = cast(BSTR*)portName.ptr;
return S_OK;
}
}
void testMago() {
HRESULT hr;
IUnknown* piUnknown;
IDebugEngine2 debugEngine = null;
IDebugEngineLaunch2 debugEngineLaunch = null;
hr=CoInitialize(null); // Initialize OLE
if (FAILED(hr)) {
Log.e("OLE 2 failed to initialize", formatHResult(hr));
return;
}
IDebugPortSupplier2 portSupplier = createPortSupplier();
if (!portSupplier) {
Log.e("Failed to create port supplier");
return;
}
if (portSupplier.CanAddPort() != S_OK) {
Log.e("Cannot add debug port ", portSupplier.CanAddPort());
return;
}
IDebugPort2 debugPort = null;
DebugPortRequest debugPortRequest = new DebugPortRequest();
// Add a port
hr = portSupplier.AddPort(
/+[in]+/ debugPortRequest,
/+[out]+/ &debugPort);
if (FAILED(hr) || !debugPort) {
Log.e("Failed to create debub port ", formatHResult(hr));
return;
}
//hr = CoCreateInstance(&CLSID_MAGO, null, CLSCTX_ALL, &IID_IDebugEngine2, cast(void**)&piUnknown);
hr = CoCreateInstance(&IID_MAGO_NATIVE_ENGINE, //CLSID_MAGO,
null,
CLSCTX_INPROC, //CLSCTX_ALL,
&IID_IDebugEngine2, //IID_MAGO_NATIVE_ENGINE,
cast(void**)&debugEngine); //piUnknown);
if (debugEngine) {
Log.d("Debug interface is not null");
}
if (FAILED(hr) || !debugEngine) {
Log.e("Failed to create MAGO interface instance ", formatHResult(hr));
return;
}
Log.d("Debug interface initialized ok");
GUID eid;
debugEngine.GetEngineId(&eid);
Log.d("Engine id: ", eid);
hr = debugEngine.QueryInterface(cast(GUID*)&IID_IDebugEngineLaunch2, cast(void**)&debugEngineLaunch);
if (FAILED(hr) || !debugEngineLaunch) {
Log.e("Failed to get IID_IDebugEngineLaunch2 interface ", formatHResult(hr));
return;
}
IDebugProcess2 process = null;
DebugCallback callback = new DebugCallback();
wchar[] exe = `D:\projects\d\dlangide\workspaces\tetris\bin\tetris.exe`w.dup;
wchar[] args;
wchar[] dir = `D:\projects\d\dlangide\workspaces\tetris\bin`w.dup;
wchar[] envblock;
wchar[] opts;
exe ~= 0;
args ~= 0;
dir ~= 0;
envblock ~= 0;
opts ~= 0;
IDebugPort2 port;
hr = debugEngineLaunch.LaunchSuspended (
null,
port,
exe.ptr,//LPCOLESTR
args.ptr,
dir.ptr,
envblock.ptr,
opts.ptr,
LAUNCH_DEBUG, //LAUNCH_NODEBUG
0,
0,
0,
callback,
&process
);
if (FAILED(hr) || !process) {
Log.e("Failed to run process ", formatHResult(hr));
return;
}
Log.d("LaunchSuspended executed ok");
}

5457
src/ddebug/windows/msdbg.d
View File

File diff suppressed because it is too large Load Diff

430
src/ddebug/windows/windebug.d
View File

@ -1,430 +0,0 @@
// just an attempt to implement D debugger for win32
module ddebug.windows.windebug;
version(Windows):
version(USE_WIN_DEBUG):
import dlangui.core.logger;
import win32.psapi;
import win32.windows;
import std.utf;
import core.thread;
import std.format;
class ModuleInfo {
HANDLE hFile;
ulong baseOfImage;
ulong debugInfoFileOffset;
ulong debugInfoSize;
string imageFileName;
}
class DllInfo : ModuleInfo {
ProcessInfo process;
this(ProcessInfo baseProcess, ref DEBUG_EVENT di) {
process = baseProcess;
hFile = di.LoadDll.hFile;
baseOfImage = cast(ulong)di.LoadDll.lpBaseOfDll;
debugInfoFileOffset = di.LoadDll.dwDebugInfoFileOffset;
debugInfoSize = di.LoadDll.nDebugInfoSize;
ulong imageName = cast(ulong)di.LoadDll.lpImageName;
Log.d(format("imageName address: %x", imageName));
imageFileName = getFileNameFromHandle(hFile);
//imageFileName = decodeZString(di.LoadDll.lpImageName, di.LoadDll.fUnicode != 0);
//if (imageFileName.length == 0)
// imageFileName = getModuleFileName(process.hProcess, hFile);
}
}
class ProcessInfo : ModuleInfo {
HANDLE hProcess;
uint processId;
HANDLE hThread;
ulong threadLocalBase;
ulong startAddress; //LPTHREAD_START_ROUTINE
this(ref DEBUG_EVENT di) {
hFile = di.CreateProcessInfo.hFile;
hProcess = di.CreateProcessInfo.hProcess;
processId = di.dwProcessId;
hThread = di.CreateProcessInfo.hThread;
LPVOID lpBaseOfImage;
baseOfImage = cast(ulong)di.CreateProcessInfo.lpBaseOfImage;
debugInfoFileOffset = di.CreateProcessInfo.dwDebugInfoFileOffset;
debugInfoSize = di.CreateProcessInfo.nDebugInfoSize;
threadLocalBase = cast(ulong)di.CreateProcessInfo.lpThreadLocalBase;
startAddress = cast(ulong)di.CreateProcessInfo.lpStartAddress;
//imageFileName = decodeZString(di.CreateProcessInfo.lpImageName, di.CreateProcessInfo.fUnicode != 0);
//if (imageFileName.length == 0)
imageFileName = getFileNameFromHandle(hFile);
// imageFileName = getModuleFileName(hProcess, hFile);
}
}
private string decodeZString(void * pstr, bool isUnicode) {
if (!pstr)
return null;
if (isUnicode) {
wchar * ptr = cast(wchar*)pstr;
wchar[] buf;
for(; *ptr; ptr++)
buf ~= *ptr;
return toUTF8(buf);
} else {
char * ptr = cast(char*)pstr;
char[] buf;
for(; *ptr; ptr++)
buf ~= *ptr;
return buf.dup;
}
}
private string getModuleFileName(HANDLE hProcess, HANDLE hFile) {
//wchar[4096] buf;
//uint chars = GetModuleFileNameExW(hProcess, hFile, buf.ptr, 4096);
//return toUTF8(buf[0..chars]);
return null;
}
// based on sample from MSDN https://msdn.microsoft.com/ru-ru/library/windows/desktop/aa366789(v=vs.85).aspx
string getFileNameFromHandle(HANDLE hFile)
{
string res = null;
bool bSuccess = false;
const int BUFSIZE = 4096;
wchar[BUFSIZE + 1] pszFilename;
HANDLE hFileMap;
// Get the file size.
DWORD dwFileSizeHi = 0;
DWORD dwFileSizeLo = GetFileSize(hFile, &dwFileSizeHi);
if( dwFileSizeLo == 0 && dwFileSizeHi == 0 ) {
return null;
}
// Create a file mapping object.
hFileMap = CreateFileMapping(hFile,
null,
PAGE_READONLY,
0,
1,
null);
if (hFileMap) {
// Create a file mapping to get the file name.
void* pMem = MapViewOfFile(hFileMap, FILE_MAP_READ, 0, 0, 1);
if (pMem) {
if (win32.psapi.GetMappedFileNameW(GetCurrentProcess(),
pMem,
pszFilename.ptr,
MAX_PATH))
{
// Translate path with device name to drive letters.
TCHAR[BUFSIZE] szTemp;
szTemp[0] = '\0';
size_t uFilenameLen = 0;
for (int i = 0; i < MAX_PATH && pszFilename[i]; i++)
uFilenameLen++;
if (GetLogicalDriveStrings(BUFSIZE-1, szTemp.ptr)) {
wchar[MAX_PATH] szName;
wchar[3] szDrive = [' ', ':', 0];
bool bFound = false;
wchar* p = szTemp.ptr;
do {
// Copy the drive letter to the template string
szDrive[0] = *p;
// Look up each device name
if (QueryDosDevice(szDrive.ptr, szName.ptr, MAX_PATH)) {
size_t uNameLen = 0;
for (int i = 0; i < MAX_PATH && szName[i]; i++)
uNameLen++;
//_tcslen(szName);
if (uNameLen < MAX_PATH) {
bFound = false; //_tcsnicmp(pszFilename, szName, uNameLen) == 0
//&& *(pszFilename + uNameLen) == _T('\\');
for (int i = 0; pszFilename[i] && i <= uNameLen; i++) {
wchar c1 = pszFilename[i];
wchar c2 = szName[i];
if (c1 >= 'a' && c1 <= 'z')
c1 = cast(wchar)(c1 - 'a' + 'A');
if (c2 >= 'a' && c2 <= 'z')
c2 = cast(wchar)(c2 - 'a' + 'A');
if (c1 != c2) {
if (c1 == '\\' && c2 == 0)
bFound = true;
break;
}
}
if (bFound) {
// Reconstruct pszFilename using szTempFile
// Replace device path with DOS path
res = toUTF8(szDrive[0..2] ~ pszFilename[uNameLen .. uFilenameLen]);
}
}
}
// Go to the next NULL character.
while (*p++) {
}
} while (!bFound && *p); // end of string
}
}
UnmapViewOfFile(pMem);
}
CloseHandle(hFileMap);
}
return res;
}
class WinDebugger : Thread {
string _exefile;
string _args;
DllInfo[] _dlls;
ProcessInfo[] _processes;
this(string exefile, string args) {
super(&run);
_exefile = exefile;
_args = args;
}
private void run() {
Log.i("Debugger thread started");
if (startDebugging())
enterDebugLoop();
Log.i("Debugger thread finished");
_finished = true;
}
private shared bool _finished;
STARTUPINFOW _si;
PROCESS_INFORMATION _pi;
bool startDebugging() {
Log.i("starting debug for '" ~ _exefile ~ "' args: " ~ _args);
_stopRequested = false;
_si = STARTUPINFOW.init;
_si.cb = _si.sizeof;
_pi = PROCESS_INFORMATION.init;
string cmdline = "\"" ~ _exefile ~ "\"";
if (_args.length > 0)
cmdline = cmdline ~ " " ~ _args;
wchar[] exefilew = cast(wchar[])toUTF16(_exefile);
exefilew ~= cast(dchar)0;
wchar[] cmdlinew = cast(wchar[])toUTF16(cmdline);
cmdlinew ~= cast(dchar)0;
if (!CreateProcessW(cast(const wchar*)exefilew.ptr,
cmdlinew.ptr,
cast(SECURITY_ATTRIBUTES*)NULL, cast(SECURITY_ATTRIBUTES*)NULL,
FALSE,
DEBUG_ONLY_THIS_PROCESS,
NULL,
cast(const wchar*)NULL, &_si, &_pi)) {
return false;
}
Log.i("Executable '" ~ _exefile ~ "' started successfully");
return true;
}
uint onCreateThreadDebugEvent(ref DEBUG_EVENT debug_event) {
Log.d("onCreateThreadDebugEvent");
return DBG_CONTINUE;
}
uint onCreateProcessDebugEvent(ref DEBUG_EVENT debug_event) {
ProcessInfo pi = new ProcessInfo(debug_event);
_processes ~= pi;
Log.d("onCreateProcessDebugEvent " ~ pi.imageFileName ~ " debugInfoSize=" ~ format("%d", pi.debugInfoSize));
return DBG_CONTINUE;
}
uint onExitThreadDebugEvent(ref DEBUG_EVENT debug_event) {
Log.d("onExitThreadDebugEvent");
return DBG_CONTINUE;
}
uint onExitProcessDebugEvent(ref DEBUG_EVENT debug_event) {
Log.d("onExitProcessDebugEvent");
return DBG_CONTINUE;
}
ProcessInfo findProcess(uint id) {
foreach(p; _processes) {
if (p.processId == id)
return p;
}
return null;
}
uint onLoadDllDebugEvent(ref DEBUG_EVENT debug_event) {
ProcessInfo pi = findProcess(debug_event.dwProcessId);
if (pi !is null) {
DllInfo dll = new DllInfo(pi, debug_event);
_dlls ~= dll;
Log.d("onLoadDllDebugEvent " ~ dll.imageFileName ~ " debugInfoSize=" ~ format("%d", dll.debugInfoSize));
} else {
Log.d("onLoadDllDebugEvent : process not found");
}
return DBG_CONTINUE;
}
uint onUnloadDllDebugEvent(ref DEBUG_EVENT debug_event) {
Log.d("onUnloadDllDebugEvent");
return DBG_CONTINUE;
}
uint onOutputDebugStringEvent(ref DEBUG_EVENT debug_event) {
Log.d("onOutputDebugStringEvent");
return DBG_CONTINUE;
}
uint onRipEvent(ref DEBUG_EVENT debug_event) {
Log.d("onRipEvent");
return DBG_TERMINATE_PROCESS;
}
void processDebugEvent(ref DEBUG_EVENT debug_event) {
switch (debug_event.dwDebugEventCode)
{
case EXCEPTION_DEBUG_EVENT:
// Process the exception code. When handling
// exceptions, remember to set the continuation
// status parameter (dwContinueStatus). This value
// is used by the ContinueDebugEvent function.
switch(debug_event.Exception.ExceptionRecord.ExceptionCode)
{
case EXCEPTION_ACCESS_VIOLATION:
// First chance: Pass this on to the system.
// Last chance: Display an appropriate error.
break;
case EXCEPTION_BREAKPOINT:
// First chance: Display the current
// instruction and register values.
break;
case EXCEPTION_DATATYPE_MISALIGNMENT:
// First chance: Pass this on to the system.
// Last chance: Display an appropriate error.
break;
case EXCEPTION_SINGLE_STEP:
// First chance: Update the display of the
// current instruction and register values.
break;
case DBG_CONTROL_C:
// First chance: Pass this on to the system.
// Last chance: Display an appropriate error.
break;
default:
// Handle other exceptions.
break;
}
break;
case CREATE_THREAD_DEBUG_EVENT:
// As needed, examine or change the thread's registers
// with the GetThreadContext and SetThreadContext functions;
// and suspend and resume thread execution with the
// SuspendThread and ResumeThread functions.
_continueStatus = onCreateThreadDebugEvent(debug_event);
break;
case CREATE_PROCESS_DEBUG_EVENT:
// As needed, examine or change the registers of the
// process's initial thread with the GetThreadContext and
// SetThreadContext functions; read from and write to the
// process's virtual memory with the ReadProcessMemory and
// WriteProcessMemory functions; and suspend and resume
// thread execution with the SuspendThread and ResumeThread
// functions. Be sure to close the handle to the process image
// file with CloseHandle.
_continueStatus = onCreateProcessDebugEvent(debug_event);
break;
case EXIT_THREAD_DEBUG_EVENT:
// Display the thread's exit code.
_continueStatus = onExitThreadDebugEvent(debug_event);
break;
case EXIT_PROCESS_DEBUG_EVENT:
// Display the process's exit code.
_continueStatus = onExitProcessDebugEvent(debug_event);
break;
case LOAD_DLL_DEBUG_EVENT:
// Read the debugging information included in the newly
// loaded DLL. Be sure to close the handle to the loaded DLL
// with CloseHandle.
_continueStatus = onLoadDllDebugEvent(debug_event);
break;
case UNLOAD_DLL_DEBUG_EVENT:
// Display a message that the DLL has been unloaded.
_continueStatus = onUnloadDllDebugEvent(debug_event);
break;
case OUTPUT_DEBUG_STRING_EVENT:
// Display the output debugging string.
_continueStatus = onOutputDebugStringEvent(debug_event);
break;
case RIP_EVENT:
_continueStatus = onRipEvent(debug_event);
break;
default:
// UNKNOWN EVENT
break;
}
}
uint _continueStatus;
bool _stopRequested;
bool enterDebugLoop() {
Log.i("entering debug loop");
_continueStatus = DBG_CONTINUE;
DEBUG_EVENT debug_event;
debug_event = DEBUG_EVENT.init;
for(;;)
{
if (!WaitForDebugEvent(&debug_event, INFINITE)) {
uint err = GetLastError();
Log.e("WaitForDebugEvent returned false. Error=" ~ format("%08x", err));
return false;
}
//Log.i("processDebugEvent");
processDebugEvent(debug_event);
if (_continueStatus == DBG_TERMINATE_PROCESS)
break;
ContinueDebugEvent(debug_event.dwProcessId,
debug_event.dwThreadId,
_continueStatus);
}
Log.i("exiting debug loop");
return true;
}
}

2
src/dlangide/builders/extprocess.d
View File

@ -188,7 +188,7 @@ class BackgroundReaderBase : Thread {
// read file by bytes
try {
version (Windows) {
import win32.windows;
import core.sys.windows.windows;
// separate version for windows as workaround for hanging rawRead
HANDLE h = _file.windowsHandle;
DWORD bytesRead = 0;

2
src/dlangide/ui/terminal.d
View File

@ -845,7 +845,7 @@ interface TerminalInputHandler {
class TerminalDevice : Thread {
Signal!TerminalInputHandler onBytesRead;
version (Windows) {
import win32.windows;
import core.sys.windows.windows;
HANDLE hpipe;
} else {
int masterfd;