diff --git a/debugger/winedbg.c b/debugger/winedbg.c
new file mode 100644
index 0000000..c5fe7d4
--- /dev/null
+++ b/debugger/winedbg.c
@@ -0,0 +1,479 @@
+/* -*- tab-width: 8; c-basic-offset: 4 -*- */
+
+/* Wine internal debugger
+ * Interface to Windows debugger API
+ * Eric Pouech (c) 2000
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include "debugger.h"
+#include "winbase.h"
+#include "winreg.h"
+#include "debugtools.h"
+#include "options.h"
+
+#ifdef DBG_need_heap
+HANDLE dbg_heap = 0;
+#endif
+
+DEFAULT_DEBUG_CHANNEL(winedbg);
+    
+WINE_DBG_PROCESS* DEBUG_CurrProcess = NULL;
+WINE_DBG_THREAD*  DEBUG_CurrThread = NULL;
+CONTEXT		  DEBUG_context;
+
+static WINE_DBG_PROCESS* proc = NULL;
+
+static	WINE_DBG_PROCESS*	DEBUG_GetProcess(DWORD pid)
+{
+    WINE_DBG_PROCESS*	p;
+    
+    for (p = proc; p; p = p->next)
+	if (p->pid == pid) break;
+    return p;
+}
+
+static	WINE_DBG_PROCESS*	DEBUG_AddProcess(DWORD pid, HANDLE h)
+{
+    WINE_DBG_PROCESS*	p = DBG_alloc(sizeof(WINE_DBG_PROCESS));
+    if (!p)
+	return NULL;
+    p->handle = h;
+    p->pid = pid;
+    p->threads = NULL;
+
+    p->next = proc;
+    p->prev = NULL;
+    if (proc) proc->prev = p;
+    proc = p;
+    return p;
+}
+
+static	void			DEBUG_DelThread(WINE_DBG_THREAD* p);
+
+static	void			DEBUG_DelProcess(WINE_DBG_PROCESS* p)
+{
+    if (p->threads != NULL) {
+	ERR("Shouldn't happen\n");
+	while (p->threads) DEBUG_DelThread(p->threads);
+    }
+    if (p->prev) p->prev->next = p->next;
+    if (p->next) p->next->prev = p->prev;
+    if (p == proc) proc = p->next;
+    DBG_free(p);
+}
+
+static	void			DEBUG_InitCurrProcess(void)
+{
+#ifdef DBG_need_heap
+    /*
+     * Initialize the debugger heap.
+     */
+    dbg_heap = HeapCreate(HEAP_NO_SERIALIZE, 0x1000, 0x8000000); /* 128MB */
+#endif
+    
+    /*
+     * Initialize the type handling stuff.
+     */
+    DEBUG_InitTypes();
+    DEBUG_InitCVDataTypes();
+    
+    /*
+     * In some cases we can read the stabs information directly
+     * from the executable.  If this is the case, we don't need
+     * to bother with trying to read a symbol file, as the stabs
+     * also have line number and local variable information.
+     * As long as gcc is used for the compiler, stabs will
+     * be the default.  On SVr4, DWARF could be used, but we
+     * don't grok that yet, and in this case we fall back to using
+     * the wine.sym file.
+     */
+    if( DEBUG_ReadExecutableDbgInfo() == FALSE )
+    {
+	char*		symfilename = "wine.sym";
+	struct stat	statbuf;
+	HKEY 		hWineConf, hkey;
+	DWORD 		count;
+	char 		symbolTableFile[256];
+	
+	if (-1 == stat(symfilename, &statbuf) )
+	    symfilename = LIBDIR "wine.sym";
+	
+	strcpy(symbolTableFile, symfilename);
+	if (!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config", &hWineConf)) {
+	    if (!RegOpenKeyA(hWineConf, "wine", &hkey)) {
+		count = sizeof(symbolTableFile);
+		RegQueryValueA(hkey, "SymbolTableFile", symbolTableFile, &count);
+		RegCloseKey(hkey);
+	    }
+	    RegCloseKey(hWineConf);
+	}
+	DEBUG_ReadSymbolTable(symbolTableFile);
+    }
+    DEBUG_LoadEntryPoints(NULL);
+    DEBUG_ProcessDeferredDebug();
+}
+
+static	BOOL			DEBUG_ProcessGetString(char* buffer, int size, 
+						       HANDLE hp, LPVOID addr)
+{
+    LPVOID	ad;
+    DWORD	sz;
+    
+    if (   addr 
+	&& ReadProcessMemory(hp, addr, &ad, sizeof(ad), &sz) 
+	&& sz == sizeof(ad) 
+        && ad 
+        && ReadProcessMemory(hp, ad, buffer, size, &sz))
+	return TRUE;
+    *(WCHAR*)buffer = 0;
+    return FALSE;
+}
+
+static	WINE_DBG_THREAD*	DEBUG_GetThread(WINE_DBG_PROCESS* p, DWORD tid)
+{
+    WINE_DBG_THREAD*	t;
+    
+    for (t = p->threads; t; t = t->next)
+	if (t->tid == tid) break;
+    return t;
+}
+
+static	WINE_DBG_THREAD*	DEBUG_AddThread(WINE_DBG_PROCESS* p, DWORD tid, 
+						HANDLE h, LPVOID start, LPVOID teb)
+{
+    WINE_DBG_THREAD*	t = DBG_alloc(sizeof(WINE_DBG_THREAD));
+    if (!t)
+	return NULL;
+    
+    t->handle = h;
+    t->tid = tid;
+    t->start = start;
+    t->teb = teb;
+    t->process = p;
+    t->wait_for_first_exception = 0;
+    t->dbg_exec_mode = EXEC_CONT;
+    t->dbg_exec_count = 0;
+    
+    t->next = p->threads;
+    t->prev = NULL;
+    if (p->threads) p->threads->prev = t;
+    p->threads = t;
+
+    return t;
+}
+
+static	void			DEBUG_InitCurrThread(void)
+{
+    if (!Options.debug) return;
+
+    if (DEBUG_CurrThread->start) {
+	DBG_ADDR	addr;
+	
+	DEBUG_SetBreakpoints(FALSE);
+	addr.seg = 0;
+	addr.off = (DWORD)DEBUG_CurrThread->start;
+	DEBUG_AddBreakpoint(&addr);
+	DEBUG_SetBreakpoints(TRUE);
+    } else {
+	DEBUG_CurrThread->wait_for_first_exception = 1;
+    }
+}
+
+static	void			DEBUG_DelThread(WINE_DBG_THREAD* t)
+{
+    if (t->prev) t->prev->next = t->next;
+    if (t->next) t->next->prev = t->prev;
+    if (t == t->process->threads) t->process->threads = t->next;
+    DBG_free(t);
+}
+
+static	BOOL	DEBUG_HandleException( EXCEPTION_RECORD *rec, BOOL first_chance, BOOL force )
+{
+    BOOL	is_debug = FALSE;
+    BOOL	ret;
+
+    if (first_chance && !Options.debug && !force ) return 0;  /* pass to app first */
+
+    switch (rec->ExceptionCode)
+    {
+    case EXCEPTION_BREAKPOINT:
+    case EXCEPTION_SINGLE_STEP:
+        is_debug = TRUE;
+        break;
+    case CONTROL_C_EXIT:
+        if (!Options.debug) DEBUG_Exit(0);
+        break;
+    }
+
+    if (!is_debug)
+    {
+        /* print some infos */
+        fprintf( stderr, "%s: ",
+                 first_chance ? "First chance exception" : "Unhandled exception" );
+        switch(rec->ExceptionCode)
+        {
+        case EXCEPTION_INT_DIVIDE_BY_ZERO:
+            fprintf( stderr, "divide by zero" );
+            break;
+        case EXCEPTION_INT_OVERFLOW:
+            fprintf( stderr, "overflow" );
+            break;
+        case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
+            fprintf( stderr, "array bounds " );
+            break;
+        case EXCEPTION_ILLEGAL_INSTRUCTION:
+            fprintf( stderr, "illegal instruction" );
+            break;
+        case EXCEPTION_STACK_OVERFLOW:
+            fprintf( stderr, "stack overflow" );
+            break;
+        case EXCEPTION_PRIV_INSTRUCTION:
+            fprintf( stderr, "priviledged instruction" );
+            break;
+        case EXCEPTION_ACCESS_VIOLATION:
+            if (rec->NumberParameters == 2)
+                fprintf( stderr, "page fault on %s access to 0x%08lx", 
+                         rec->ExceptionInformation[0] ? "write" : "read",
+                         rec->ExceptionInformation[1] );
+            else
+                fprintf( stderr, "page fault" );
+            break;
+        case EXCEPTION_DATATYPE_MISALIGNMENT:
+            fprintf( stderr, "Alignment" );
+            break;
+        case CONTROL_C_EXIT:
+            fprintf( stderr, "^C" );
+            break;
+        case EXCEPTION_CRITICAL_SECTION_WAIT:
+            fprintf( stderr, "critical section %08lx wait failed", 
+		     rec->ExceptionInformation[0] );
+            break;
+        default:
+            fprintf( stderr, "%08lx", rec->ExceptionCode );
+            break;
+        }
+    }
+
+#if 1
+    fprintf(stderr, "Entering debugger 	PC=%lx EFL=%08lx mode=%d count=%d\n",
+	    DEBUG_context.Eip, DEBUG_context.EFlags, 
+	    DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
+#endif
+
+    ret = DEBUG_Main( is_debug, force );
+#if 1
+    fprintf(stderr, "Exiting debugger 	PC=%lx EFL=%08lx mode=%d count=%d\n",
+	    DEBUG_context.Eip, DEBUG_context.EFlags, 
+	    DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
+#endif
+
+    return ret;
+}
+
+
+static	DWORD	CALLBACK	DEBUG_MainLoop(LPVOID pid)
+{
+    DEBUG_EVENT		de;
+    char		buffer[256];
+    DWORD		cont;
+
+    TRACE("WineDbg started on pid %ld\n", (DWORD)pid);
+    
+    if (!DebugActiveProcess((DWORD)pid))
+	TRACE("Can't debug process %ld: %ld\n", (DWORD)pid, GetLastError());
+    
+    while (WaitForDebugEvent(&de, INFINITE)) {
+	cont = 0L;
+
+	if ((DEBUG_CurrProcess = DEBUG_GetProcess(de.dwProcessId)) != NULL)
+	    DEBUG_CurrThread = DEBUG_GetThread(DEBUG_CurrProcess, de.dwThreadId);
+	else 
+	    DEBUG_CurrThread = NULL;
+
+	switch (de.dwDebugEventCode) {
+	case EXCEPTION_DEBUG_EVENT:
+	    if (!DEBUG_CurrThread) break;
+
+	    TRACE("%08lx:%08lx: exception code=%08lx %d\n", 
+		  de.dwProcessId, de.dwThreadId, 
+		  de.u.Exception.ExceptionRecord.ExceptionCode,
+		  DEBUG_CurrThread->wait_for_first_exception);
+
+	    DEBUG_context.ContextFlags = CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS|CONTEXT_DEBUG_REGISTERS;
+	    if (!GetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context)) {
+		WARN("Can't get thread's context\n");
+		break;
+	    }
+
+	    TRACE("%p:%p\n", de.u.Exception.ExceptionRecord.ExceptionAddress, 
+		  (void*)DEBUG_context.Eip);
+
+	    cont = DEBUG_HandleException(&de.u.Exception.ExceptionRecord, 
+					 de.u.Exception.dwFirstChance, 
+					 DEBUG_CurrThread->wait_for_first_exception);
+
+	    if (DEBUG_CurrThread->wait_for_first_exception) {
+		DEBUG_CurrThread->wait_for_first_exception = 0;
+#ifdef __i386__
+		DEBUG_context.Eip--;
+#endif
+	    }
+	    SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context);
+	    break;
+	    
+	case CREATE_THREAD_DEBUG_EVENT:
+	    TRACE("%08lx:%08lx: create thread D @%p\n", de.dwProcessId, de.dwThreadId, 
+		  de.u.CreateThread.lpStartAddress);
+	    
+	    if (DEBUG_CurrProcess == NULL) {
+		ERR("Unknown process\n");
+		break;
+	    }
+	    if (DEBUG_GetThread(DEBUG_CurrProcess, de.dwThreadId) != NULL) {
+		TRACE("Thread already listed, skipping\n");
+		break;
+	    }
+
+	    DEBUG_CurrThread = DEBUG_AddThread(DEBUG_CurrProcess, 
+					       de.dwThreadId, 
+					       de.u.CreateThread.hThread, 
+					       de.u.CreateThread.lpStartAddress, 
+					       de.u.CreateThread.lpThreadLocalBase);
+	    if (!DEBUG_CurrThread) {
+		ERR("Couldn't create thread\n");
+		break;
+	    }
+	    DEBUG_InitCurrThread();
+	    break;
+	    
+	case CREATE_PROCESS_DEBUG_EVENT:
+	    DEBUG_ProcessGetString(buffer, sizeof(buffer), 
+				   de.u.CreateProcessInfo.hProcess, 
+				   de.u.LoadDll.lpImageName);
+	    
+	    /* FIXME unicode ? de.u.CreateProcessInfo.fUnicode */
+	    TRACE("%08lx:%08lx: create process %s @%p\n", 
+		  de.dwProcessId, de.dwThreadId, 
+		  buffer,
+		  de.u.CreateProcessInfo.lpStartAddress);
+	    
+	    if (DEBUG_GetProcess(de.dwProcessId) != NULL) {
+		TRACE("Skipping already defined process\n");
+		break;
+	    }
+	    DEBUG_CurrProcess = DEBUG_AddProcess(de.dwProcessId,
+						 de.u.CreateProcessInfo.hProcess);
+	    if (DEBUG_CurrProcess == NULL) {
+		ERR("Unknown process\n");
+		break;
+	    }
+	    
+	    TRACE("%08lx:%08lx: create thread I @%p\n", de.dwProcessId, de.dwThreadId, 
+		  de.u.CreateProcessInfo.lpStartAddress);
+	    
+	    DEBUG_CurrThread = DEBUG_AddThread(DEBUG_CurrProcess, 	
+					       de.dwThreadId, 
+					       de.u.CreateProcessInfo.hThread, 
+					       de.u.CreateProcessInfo.lpStartAddress, 
+					       de.u.CreateProcessInfo.lpThreadLocalBase);
+	    if (!DEBUG_CurrThread) {
+		ERR("Couldn't create thread\n");
+		break;
+	    }
+	    
+	    DEBUG_InitCurrProcess();
+	    DEBUG_InitCurrThread();
+	    break;
+	    
+	case EXIT_THREAD_DEBUG_EVENT:
+	    TRACE("%08lx:%08lx: exit thread (%ld)\n", 
+		  de.dwProcessId, de.dwThreadId, de.u.ExitThread.dwExitCode);
+
+	    if (DEBUG_CurrThread == NULL) {
+		ERR("Unknown thread\n");
+		break;
+	    }
+	    /* FIXME: remove break point set on thread startup */
+	    DEBUG_DelThread(DEBUG_CurrThread);
+	    break;
+	    
+	case EXIT_PROCESS_DEBUG_EVENT:
+	    TRACE("%08lx:%08lx: exit process (%ld)\n", 
+		  de.dwProcessId, de.dwThreadId, de.u.ExitProcess.dwExitCode);
+
+	    if (DEBUG_CurrProcess == NULL) {
+		ERR("Unknown process\n");
+		break;
+	    }
+	    /* kill last thread */
+	    DEBUG_DelThread(DEBUG_CurrProcess->threads);
+	    /* FIXME: remove break point set on thread startup */
+	    DEBUG_DelProcess(DEBUG_CurrProcess);
+	    break;
+	    
+	case LOAD_DLL_DEBUG_EVENT:
+	    if (DEBUG_CurrThread == NULL) {
+		ERR("Unknown thread\n");
+		break;
+	    }
+	    DEBUG_ProcessGetString(buffer, sizeof(buffer), 
+				   DEBUG_CurrThread->process->handle, 
+				   de.u.LoadDll.lpImageName);
+	    
+	    /* FIXME unicode: de.u.LoadDll.fUnicode */
+	    TRACE("%08lx:%08lx: loads DLL %s @%p\n", de.dwProcessId, de.dwThreadId, 
+		  buffer, de.u.LoadDll.lpBaseOfDll);
+	    break;
+	    
+	case UNLOAD_DLL_DEBUG_EVENT:
+	    TRACE("%08lx:%08lx: unload DLL @%p\n", de.dwProcessId, de.dwThreadId, 
+		  de.u.UnloadDll.lpBaseOfDll);
+	    break;
+	    
+	case OUTPUT_DEBUG_STRING_EVENT:
+	    if (DEBUG_CurrThread == NULL) {
+		ERR("Unknown thread\n");
+		break;
+	    }
+
+	    DEBUG_ProcessGetString(buffer, sizeof(buffer), 
+				   DEBUG_CurrThread->process->handle, 
+				   de.u.DebugString.lpDebugStringData);
+	    
+	    
+	    /* fixme unicode de.u.DebugString.fUnicode ? */
+	    TRACE("%08lx:%08lx: output debug string (%s)\n", 
+		  de.dwProcessId, de.dwThreadId, 
+		  buffer);
+	    break;
+	    
+	case RIP_EVENT:
+	    TRACE("%08lx:%08lx: rip error=%ld type=%ld\n", 
+		  de.dwProcessId, de.dwThreadId, de.u.RipInfo.dwError, 
+		  de.u.RipInfo.dwType);
+	    break;
+	    
+	default:
+	    TRACE("%08lx:%08lx: unknown event (%ld)\n", 
+		  de.dwProcessId, de.dwThreadId, de.dwDebugEventCode);
+	}
+	ContinueDebugEvent(de.dwProcessId, de.dwThreadId, cont);
+    }
+    
+    TRACE("WineDbg terminated on pid %ld\n", (DWORD)pid);
+    
+    return 0L;
+}
+
+#include "thread.h"
+#include "process.h"
+
+void	DEBUG_StartDebugger(DWORD pid)
+{
+    if (Options.debug)
+	CreateThread(NULL, 0, DEBUG_MainLoop, (LPVOID)pid, 0, NULL);
+}
+