/* -*- tab-width: 8; c-basic-offset: 4 -*- */

/* Wine internal debugger
 * Interface to Windows debugger API
 * Copyright 2000 Eric Pouech
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include "debugger.h"

#include "wincon.h"
#include "winreg.h"
#include "wingdi.h"
#include "winuser.h"
#include "winternl.h"
#include "excpt.h"
#include "wine/library.h"
#include "winnls.h"

DBG_PROCESS*	DEBUG_CurrProcess = NULL;
DBG_THREAD*	DEBUG_CurrThread = NULL;
DWORD		DEBUG_CurrTid;
DWORD		DEBUG_CurrPid;
CONTEXT         DEBUG_context;
BOOL		DEBUG_InteractiveP = FALSE;
static BOOL     DEBUG_InException = FALSE;
int 		curr_frame = 0;
static char*	DEBUG_LastCmdLine = NULL;

static DBG_PROCESS* DEBUG_ProcessList = NULL;
static enum {none_mode = 0, winedbg_mode, automatic_mode, gdb_mode} local_mode;

DBG_INTVAR DEBUG_IntVars[DBG_IV_LAST];

void	DEBUG_OutputA(int chn, const char* buffer, int len)
{
    if (DBG_IVAR(ConChannelMask) & chn)
	WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buffer, len, NULL, NULL);
    if (DBG_IVAR(StdChannelMask) & chn)
	fwrite(buffer, len, 1, stderr);
}

void	DEBUG_OutputW(int chn, const WCHAR* buffer, int len)
{
	char* ansi = NULL;
	int newlen;
	
	/* do a serious Unicode to ANSI conversion
	   FIXME: should CP_ACP be GetConsoleCP()? */
	newlen = WideCharToMultiByte(CP_ACP, 0, buffer, len, NULL, 0, NULL, NULL);
	if(newlen)
	{
		ansi = (char*)DBG_alloc(newlen);
		if(ansi)
		{
			WideCharToMultiByte(CP_ACP, 0, buffer, len, ansi, newlen, NULL, NULL);
		}
	}
	
	/* fall back to a simple Unicode to ANSI conversion in case WC2MB failed */
	if(!ansi)
	{
		ansi = DBG_alloc(len);
		if(ansi)
		{
			int i;
			for(i = 0; i < len; i++)
			{
				ansi[i] = (char)buffer[i];
			}
			
			newlen = len;
		}
		/* else we are having REALLY bad luck today */
	}	
	
	if(ansi)
	{
		DEBUG_OutputA(chn, ansi, newlen);
		DBG_free(ansi);
	}
}

int	DEBUG_Printf(int chn, const char* format, ...)
{
static    char	buf[4*1024];
    va_list 	valist;
    int		len;

    va_start(valist, format);
    len = vsnprintf(buf, sizeof(buf), format, valist);
    va_end(valist);

    if (len <= -1 || len >= sizeof(buf)) {
	len = sizeof(buf) - 1;
	buf[len] = 0;
	buf[len - 1] = buf[len - 2] = buf[len - 3] = '.';
    }
    DEBUG_OutputA(chn, buf, len);
    return len;
}

static	BOOL DEBUG_IntVarsRW(int read)
{
    HKEY	hkey;
    DWORD 	type = REG_DWORD;
    DWORD	val;
    DWORD 	count = sizeof(val);
    int		i;
    DBG_INTVAR* div = DEBUG_IntVars;

    if (read) {
/* initializes internal vars table */
#define  INTERNAL_VAR(_var,_val,_ref,_typ) 			\
        div->val = _val; div->name = #_var; div->pval = _ref;	\
        div->type = DEBUG_GetBasicType(_typ); div++;
#include "intvar.h"
#undef   INTERNAL_VAR
    }

    if (RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\WineDbg", &hkey)) {
	/* since the IVars are not yet setup, DEBUG_Printf doesn't work,
	 * so don't use it */
	fprintf(stderr, "Cannot create WineDbg key in registry\n");
	return FALSE;
    }

    for (i = 0; i < DBG_IV_LAST; i++) {
	if (read) {
	    if (!DEBUG_IntVars[i].pval) {
		if (!RegQueryValueEx(hkey, DEBUG_IntVars[i].name, 0,
				     &type, (LPSTR)&val, &count))
		    DEBUG_IntVars[i].val = val;
		DEBUG_IntVars[i].pval = &DEBUG_IntVars[i].val;
	    } else {
		*DEBUG_IntVars[i].pval = 0;
	    }
	} else {
	    /* FIXME: type should be infered from basic type -if any- of intvar */
	    if (DEBUG_IntVars[i].pval == &DEBUG_IntVars[i].val)
		RegSetValueEx(hkey, DEBUG_IntVars[i].name, 0,
			      type, (LPCVOID)DEBUG_IntVars[i].pval, count);
	}
    }
    RegCloseKey(hkey);
    return TRUE;
}

DBG_INTVAR*	DEBUG_GetIntVar(const char* name)
{
    int		i;

    for (i = 0; i < DBG_IV_LAST; i++) {
	if (!strcmp(DEBUG_IntVars[i].name, name))
	    return &DEBUG_IntVars[i];
    }
    return NULL;
}

DBG_PROCESS*	DEBUG_GetProcess(DWORD pid)
{
    DBG_PROCESS*	p;

    for (p = DEBUG_ProcessList; p; p = p->next)
	if (p->pid == pid) break;
    return p;
}

DBG_PROCESS*	DEBUG_AddProcess(DWORD pid, HANDLE h, const char* imageName)
{
    DBG_PROCESS*	p;

    if ((p = DEBUG_GetProcess(pid)))
    {
        if (p->handle != 0)
        {
            DEBUG_Printf(DBG_CHN_ERR, "Process (%lu) is already defined\n", pid);
        }
        else
        {
            p->handle = h;
            p->imageName = imageName ? DBG_strdup(imageName) : NULL;
        }
        return p;
    }

    if (!(p = DBG_alloc(sizeof(DBG_PROCESS)))) return NULL;
    p->handle = h;
    p->pid = pid;
    p->imageName = imageName ? DBG_strdup(imageName) : NULL;
    p->threads = NULL;
    p->num_threads = 0;
    p->continue_on_first_exception = FALSE;
    p->modules = NULL;
    p->num_modules = 0;
    p->next_index = 0;
    p->dbg_hdr_addr = 0;
    p->delayed_bp = NULL;
    p->num_delayed_bp = 0;

    p->next = DEBUG_ProcessList;
    p->prev = NULL;
    if (DEBUG_ProcessList) DEBUG_ProcessList->prev = p;
    DEBUG_ProcessList = p;
    return p;
}

void DEBUG_DelProcess(DBG_PROCESS* p)
{
    int	i;

    while (p->threads) DEBUG_DelThread(p->threads);

    for (i = 0; i < p->num_delayed_bp; i++)
        if (p->delayed_bp[i].is_symbol)
            DBG_free(p->delayed_bp[i].u.symbol.name);

    DBG_free(p->delayed_bp);
    if (p->prev) p->prev->next = p->next;
    if (p->next) p->next->prev = p->prev;
    if (p == DEBUG_ProcessList) DEBUG_ProcessList = p->next;
    if (p == DEBUG_CurrProcess) DEBUG_CurrProcess = NULL;
    DBG_free((char*)p->imageName);
    DBG_free(p);
}

static	void			DEBUG_InitCurrProcess(void)
{
}

BOOL DEBUG_ProcessGetString(char* buffer, int size, HANDLE hp, LPSTR addr)
{
    DWORD sz;
    *(WCHAR*)buffer = 0;
    return (addr && ReadProcessMemory(hp, addr, buffer, size, &sz));
}

BOOL DEBUG_ProcessGetStringIndirect(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;
}

DBG_THREAD*	DEBUG_GetThread(DBG_PROCESS* p, DWORD tid)
{
    DBG_THREAD*	t;

    if (!p) return NULL;
    for (t = p->threads; t; t = t->next)
	if (t->tid == tid) break;
    return t;
}

DBG_THREAD*	DEBUG_AddThread(DBG_PROCESS* p, DWORD tid,
                                HANDLE h, LPVOID start, LPVOID teb)
{
    DBG_THREAD*	t = DBG_alloc(sizeof(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->exec_mode = EXEC_CONT;
    t->exec_count = 0;

    snprintf(t->name, sizeof(t->name), "%08lx", tid);

    p->num_threads++;
    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 (DEBUG_CurrThread->start) {
	if (DEBUG_CurrThread->process->num_threads == 1 ||
	    DBG_IVAR(BreakAllThreadsStartup)) {
	    DBG_VALUE	value;

	    DEBUG_SetBreakpoints(FALSE);
	    value.type = NULL;
	    value.cookie = DV_TARGET;
	    value.addr.seg = 0;
	    value.addr.off = (DWORD)DEBUG_CurrThread->start;
	    DEBUG_AddBreakpointFromValue(&value);
	    DEBUG_SetBreakpoints(TRUE);
	}
    } else {
	DEBUG_CurrThread->wait_for_first_exception = 1;
    }
}

void			DEBUG_DelThread(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;
    t->process->num_threads--;
    if (t == DEBUG_CurrThread) DEBUG_CurrThread = NULL;
    DBG_free(t);
}

static	BOOL	DEBUG_HandleDebugEvent(DEBUG_EVENT* de);

/******************************************************************
 *		DEBUG_Attach
 *
 * Sets the debuggee to <pid>
 * cofe instructs winedbg what to do when first exception is received 
 * (break=FALSE, continue=TRUE)
 * wfe is set to TRUE if DEBUG_Attach should also proceed with all debug events
 * until the first exception is received (aka: attach to an already running process)
 */
BOOL				DEBUG_Attach(DWORD pid, BOOL cofe, BOOL wfe)
{
    DEBUG_EVENT         de;

    if (!(DEBUG_CurrProcess = DEBUG_AddProcess(pid, 0, NULL))) return FALSE;

    if (!DebugActiveProcess(pid)) {
        DEBUG_Printf(DBG_CHN_MESG, "Can't attach process %lx: error %ld\n", pid, GetLastError());
        DEBUG_DelProcess(DEBUG_CurrProcess);
	return FALSE;
    }
    DEBUG_CurrProcess->continue_on_first_exception = cofe;

    if (wfe) /* shall we proceed all debug events until we get an exception ? */
    {
        DEBUG_InteractiveP = FALSE;
        while (DEBUG_CurrProcess && WaitForDebugEvent(&de, INFINITE))
        {
            if (DEBUG_HandleDebugEvent(&de)) break;
        }
        if (DEBUG_CurrProcess) DEBUG_InteractiveP = TRUE;
    }
    return TRUE;
}

BOOL				DEBUG_Detach(void)
{
    /* remove all set breakpoints in debuggee code */
    DEBUG_SetBreakpoints(FALSE);
    /* needed for single stepping (ugly).
     * should this be handled inside the server ??? */
#ifdef __i386__
    DEBUG_context.EFlags &= ~STEP_FLAG;
#endif
    SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context);
    DebugActiveProcessStop(DEBUG_CurrProcess->pid);
    DEBUG_DelProcess(DEBUG_CurrProcess);
    /* FIXME: should zero out the symbol table too */
    return TRUE;
}

static BOOL                     DEBUG_FetchContext(void)
{
    DEBUG_context.ContextFlags = CONTEXT_CONTROL
                               | CONTEXT_INTEGER
#ifdef CONTEXT_SEGMENTS
                               | CONTEXT_SEGMENTS
#endif
#ifdef CONTEXT_DEBUG_REGISTERS
	                       | CONTEXT_DEBUG_REGISTERS
#endif
                               ;
    if (!GetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context))
    {
        DEBUG_Printf(DBG_CHN_WARN, "Can't get thread's context\n");
        return FALSE;
    }
    return TRUE;
}

static  BOOL	DEBUG_ExceptionProlog(BOOL is_debug, BOOL force, DWORD code)
{
    DBG_ADDR	addr;
    int		newmode;

    DEBUG_InException = TRUE;
    DEBUG_GetCurrentAddress(&addr);
    DEBUG_SuspendExecution();

    if (!is_debug)
    {
        if (!addr.seg)
            DEBUG_Printf(DBG_CHN_MESG, " in 32-bit code (0x%08lx)", addr.off);
        else
            switch(DEBUG_GetSelectorType(addr.seg))
            {
            case MODE_32:
                DEBUG_Printf(DBG_CHN_MESG, " in 32-bit code (%04lx:%08lx)", addr.seg, addr.off);
                break;
            case MODE_16:
                DEBUG_Printf(DBG_CHN_MESG, " in 16-bit code (%04lx:%04lx)", addr.seg, addr.off);
                break;
            case MODE_VM86:
                DEBUG_Printf(DBG_CHN_MESG, " in vm86 code (%04lx:%04lx)", addr.seg, addr.off);
                break;
            case MODE_INVALID:
                DEBUG_Printf(DBG_CHN_MESG, " bad CS (%lx)", addr.seg);
                break;
        }
	DEBUG_Printf(DBG_CHN_MESG, ".\n");
    }

    DEBUG_LoadEntryPoints("Loading new modules symbols:\n");

    if (!force && is_debug &&
	DEBUG_ShouldContinue(&addr, code,
			     &DEBUG_CurrThread->exec_count))
	return FALSE;

    if ((newmode = DEBUG_GetSelectorType(addr.seg)) == MODE_INVALID) newmode = MODE_32;
    if (newmode != DEBUG_CurrThread->dbg_mode)
    {
        static const char * const names[] = { "???", "16-bit", "32-bit", "vm86" };
        DEBUG_Printf(DBG_CHN_MESG,"In %s mode.\n", names[newmode] );
        DEBUG_CurrThread->dbg_mode = newmode;
    }

    DEBUG_DoDisplay();

    if (is_debug || force) {
	/*
	 * Do a quiet backtrace so that we have an idea of what the situation
	 * is WRT the source files.
	 */
	DEBUG_BackTrace(DEBUG_CurrTid, FALSE);
    } else {
	/* This is a real crash, dump some info */
	DEBUG_InfoRegisters(&DEBUG_context);
	DEBUG_InfoStack();
#ifdef __i386__
	if (DEBUG_CurrThread->dbg_mode == MODE_16) {
	    DEBUG_InfoSegments(DEBUG_context.SegDs >> 3, 1);
	    if (DEBUG_context.SegEs != DEBUG_context.SegDs)
		DEBUG_InfoSegments(DEBUG_context.SegEs >> 3, 1);
	}
	DEBUG_InfoSegments(DEBUG_context.SegFs >> 3, 1);
#endif
	DEBUG_BackTrace(DEBUG_CurrTid, TRUE);
    }

    if (!is_debug ||
	(DEBUG_CurrThread->exec_mode == EXEC_STEPI_OVER) ||
	(DEBUG_CurrThread->exec_mode == EXEC_STEPI_INSTR)) {

	struct list_id list;

	/* Show where we crashed */
	curr_frame = 0;
	DEBUG_DisassembleInstruction(&addr);

	/* resets list internal arguments so we can look at source code when needed */
	DEBUG_FindNearestSymbol(&addr, TRUE, NULL, 0, &list);
	if (list.sourcefile) DEBUG_List(&list, NULL, 0);
    }
    return TRUE;
}

static  void	DEBUG_ExceptionEpilog(void)
{
    DEBUG_RestartExecution(DEBUG_CurrThread->exec_count);
    /*
     * This will have gotten absorbed into the breakpoint info
     * if it was used.  Otherwise it would have been ignored.
     * In any case, we don't mess with it any more.
     */
    if (DEBUG_CurrThread->exec_mode == EXEC_CONT)
	DEBUG_CurrThread->exec_count = 0;
    DEBUG_InException = FALSE;
}

static DWORD DEBUG_HandleException(EXCEPTION_RECORD *rec, BOOL first_chance, BOOL force)
{
    BOOL             is_debug = FALSE;
    THREADNAME_INFO *pThreadName;
    DBG_THREAD      *pThread;

    assert(DEBUG_CurrThread);

    switch (rec->ExceptionCode)
    {
    case EXCEPTION_BREAKPOINT:
    case EXCEPTION_SINGLE_STEP:
        is_debug = TRUE;
        break;
    case EXCEPTION_NAME_THREAD:
        pThreadName = (THREADNAME_INFO*)(rec->ExceptionInformation);
        if (pThreadName->dwThreadID == -1)
            pThread = DEBUG_CurrThread;
        else
            pThread = DEBUG_GetThread(DEBUG_CurrProcess, pThreadName->dwThreadID);

        if (ReadProcessMemory(DEBUG_CurrThread->process->handle, pThreadName->szName,
                              pThread->name, 9, NULL))
            DEBUG_Printf (DBG_CHN_MESG,
                          "Thread ID=0x%lx renamed using MS VC6 extension (name==\"%s\")\n",
                          pThread->tid, pThread->name);
        return DBG_CONTINUE;
    }

    if (first_chance && !is_debug && !force && !DBG_IVAR(BreakOnFirstChance))
    {
        /* pass exception to program except for debug exceptions */
        return DBG_EXCEPTION_NOT_HANDLED;
    }

    if (!is_debug)
    {
        /* print some infos */
        DEBUG_Printf(DBG_CHN_MESG, "%s: ",
		      first_chance ? "First chance exception" : "Unhandled exception");
        switch (rec->ExceptionCode)
        {
        case EXCEPTION_INT_DIVIDE_BY_ZERO:
            DEBUG_Printf(DBG_CHN_MESG, "divide by zero");
            break;
        case EXCEPTION_INT_OVERFLOW:
            DEBUG_Printf(DBG_CHN_MESG, "overflow");
            break;
        case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
            DEBUG_Printf(DBG_CHN_MESG, "array bounds ");
            break;
        case EXCEPTION_ILLEGAL_INSTRUCTION:
            DEBUG_Printf(DBG_CHN_MESG, "illegal instruction");
            break;
        case EXCEPTION_STACK_OVERFLOW:
            DEBUG_Printf(DBG_CHN_MESG, "stack overflow");
            break;
        case EXCEPTION_PRIV_INSTRUCTION:
            DEBUG_Printf(DBG_CHN_MESG, "privileged instruction");
            break;
        case EXCEPTION_ACCESS_VIOLATION:
            if (rec->NumberParameters == 2)
                DEBUG_Printf(DBG_CHN_MESG, "page fault on %s access to 0x%08lx",
			      rec->ExceptionInformation[0] ? "write" : "read",
			      rec->ExceptionInformation[1]);
            else
                DEBUG_Printf(DBG_CHN_MESG, "page fault");
            break;
        case EXCEPTION_DATATYPE_MISALIGNMENT:
            DEBUG_Printf(DBG_CHN_MESG, "Alignment");
            break;
	case DBG_CONTROL_C:
            DEBUG_Printf(DBG_CHN_MESG, "^C");
            break;
        case CONTROL_C_EXIT:
            DEBUG_Printf(DBG_CHN_MESG, "^C");
            break;
        case STATUS_POSSIBLE_DEADLOCK:
	    {
		DBG_ADDR	addr;

		addr.seg = 0;
		addr.off = rec->ExceptionInformation[0];

		DEBUG_Printf(DBG_CHN_MESG, "wait failed on critical section ");
		DEBUG_PrintAddress(&addr, DEBUG_CurrThread->dbg_mode, FALSE);
	    }
	    if (!DBG_IVAR(BreakOnCritSectTimeOut))
	    {
		DEBUG_Printf(DBG_CHN_MESG, "\n");
		return DBG_EXCEPTION_NOT_HANDLED;
	    }
            break;
        case EXCEPTION_WINE_STUB:
            {
                char dll[32], name[64];
                DEBUG_ProcessGetString( dll, sizeof(dll), DEBUG_CurrThread->process->handle,
                                        (char *)rec->ExceptionInformation[0] );
                DEBUG_ProcessGetString( name, sizeof(name), DEBUG_CurrThread->process->handle,
                                        (char *)rec->ExceptionInformation[1] );
                DEBUG_Printf(DBG_CHN_MESG, "unimplemented function %s.%s called", dll, name );
            }
            break;
        case EXCEPTION_WINE_ASSERTION:
            DEBUG_Printf(DBG_CHN_MESG, "assertion failed");
            break;
        case EXCEPTION_VM86_INTx:
            DEBUG_Printf(DBG_CHN_MESG, "interrupt %02lx in vm86 mode",
                         rec->ExceptionInformation[0]);
            break;
        case EXCEPTION_VM86_STI:
            DEBUG_Printf(DBG_CHN_MESG, "sti in vm86 mode");
            break;
        case EXCEPTION_VM86_PICRETURN:
            DEBUG_Printf(DBG_CHN_MESG, "PIC return in vm86 mode");
            break;
	case EXCEPTION_FLT_DENORMAL_OPERAND:
            DEBUG_Printf(DBG_CHN_MESG, "denormal float operand");
            break;
	case EXCEPTION_FLT_DIVIDE_BY_ZERO:
            DEBUG_Printf(DBG_CHN_MESG, "divide by zero");
            break;
	case EXCEPTION_FLT_INEXACT_RESULT:
            DEBUG_Printf(DBG_CHN_MESG, "inexact float result");
            break;
	case EXCEPTION_FLT_INVALID_OPERATION:
            DEBUG_Printf(DBG_CHN_MESG, "invalid float operation");
            break;
	case EXCEPTION_FLT_OVERFLOW:
            DEBUG_Printf(DBG_CHN_MESG, "floating pointer overflow");
            break;
	case EXCEPTION_FLT_UNDERFLOW:
            DEBUG_Printf(DBG_CHN_MESG, "floating pointer underflow");
            break;
	case EXCEPTION_FLT_STACK_CHECK:
            DEBUG_Printf(DBG_CHN_MESG, "floating point stack check");
            break;
        default:
            DEBUG_Printf(DBG_CHN_MESG, "%08lx", rec->ExceptionCode);
            break;
        }
    }

    if (local_mode == automatic_mode)
    {
        DEBUG_ExceptionProlog(is_debug, FALSE, rec->ExceptionCode);
        DEBUG_ExceptionEpilog();
        return 0;  /* terminate execution */
    }

    if (DEBUG_ExceptionProlog(is_debug, force, rec->ExceptionCode))
    {
	DEBUG_InteractiveP = TRUE;
        return 0;
    }
    DEBUG_ExceptionEpilog();

    return DBG_CONTINUE;
}

static	BOOL	DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
{
    char		buffer[256];
    DWORD cont = DBG_CONTINUE;

    DEBUG_CurrPid = de->dwProcessId;
    DEBUG_CurrTid = de->dwThreadId;

    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)
        {
            DEBUG_Printf(DBG_CHN_ERR, "%08lx:%08lx: not a registered process or thread (perhaps a 16 bit one ?)\n",
                         de->dwProcessId, de->dwThreadId);
            break;
        }

        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exception code=%08lx\n",
                     de->dwProcessId, de->dwThreadId,
                     de->u.Exception.ExceptionRecord.ExceptionCode);

        if (DEBUG_CurrProcess->continue_on_first_exception)
        {
            DEBUG_CurrProcess->continue_on_first_exception = FALSE;
            if (!DBG_IVAR(BreakOnAttach)) break;
        }

        if (DEBUG_FetchContext())
        {
            cont = DEBUG_HandleException(&de->u.Exception.ExceptionRecord,
                                        de->u.Exception.dwFirstChance,
                                        DEBUG_CurrThread->wait_for_first_exception);
            if (cont && DEBUG_CurrThread)
            {
                DEBUG_CurrThread->wait_for_first_exception = 0;
                SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context);
            }
        }
        break;

    case CREATE_THREAD_DEBUG_EVENT:
        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create thread D @%08lx\n", de->dwProcessId, de->dwThreadId,
                     (unsigned long)(LPVOID)de->u.CreateThread.lpStartAddress);

        if (DEBUG_CurrProcess == NULL)
        {
            DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
            break;
        }
        if (DEBUG_GetThread(DEBUG_CurrProcess, de->dwThreadId) != NULL)
        {
            DEBUG_Printf(DBG_CHN_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)
        {
            DEBUG_Printf(DBG_CHN_ERR, "Couldn't create thread\n");
            break;
        }
        DEBUG_InitCurrThread();
        break;

    case CREATE_PROCESS_DEBUG_EVENT:
        DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
                                       de->u.CreateProcessInfo.hProcess,
                                       de->u.CreateProcessInfo.lpImageName);

        /* FIXME unicode ? de->u.CreateProcessInfo.fUnicode */
        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create process '%s'/%p @%08lx (%ld<%ld>)\n",
                     de->dwProcessId, de->dwThreadId,
                     buffer, de->u.CreateProcessInfo.lpImageName,
                     (unsigned long)(LPVOID)de->u.CreateProcessInfo.lpStartAddress,
                     de->u.CreateProcessInfo.dwDebugInfoFileOffset,
                     de->u.CreateProcessInfo.nDebugInfoSize);

        DEBUG_CurrProcess = DEBUG_AddProcess(de->dwProcessId,
                                             de->u.CreateProcessInfo.hProcess,
                                             buffer[0] ? buffer : "<Debugged Process>");
        if (DEBUG_CurrProcess == NULL)
        {
            DEBUG_Printf(DBG_CHN_ERR, "Couldn't create process\n");
            break;
        }

        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: create thread I @%08lx\n",
                     de->dwProcessId, de->dwThreadId,
                     (unsigned long)(LPVOID)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)
        {
            DEBUG_Printf(DBG_CHN_ERR, "Couldn't create thread\n");
            break;
        }

        DEBUG_InitCurrProcess();
        DEBUG_InitCurrThread();

        /* module is either PE, NE or ELF module (for WineLib), but all
         * are loaded with wine, so load its symbols, then the main module
         */
        do
        {
            char*   ptr = getenv("WINELOADER");

            if (!ptr || DEBUG_ReadExecutableDbgInfo( ptr ) == DIL_ERROR)
                DEBUG_ReadExecutableDbgInfo( "wine" );
        } while (0);

        DEBUG_LoadModule32(DEBUG_CurrProcess->imageName, de->u.CreateProcessInfo.hFile,
                           de->u.CreateProcessInfo.lpBaseOfImage);

        break;

    case EXIT_THREAD_DEBUG_EVENT:
        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exit thread (%ld)\n",
                     de->dwProcessId, de->dwThreadId, de->u.ExitThread.dwExitCode);

        if (DEBUG_CurrThread == NULL)
        {
            DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
            break;
        }
        /* FIXME: remove break point set on thread startup */
        DEBUG_DelThread(DEBUG_CurrThread);
        break;

    case EXIT_PROCESS_DEBUG_EVENT:
        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: exit process (%ld)\n",
                     de->dwProcessId, de->dwThreadId, de->u.ExitProcess.dwExitCode);

        if (DEBUG_CurrProcess == NULL)
        {
            DEBUG_Printf(DBG_CHN_ERR, "Unknown process\n");
            break;
        }
        /* just in case */
        DEBUG_SetBreakpoints(FALSE);
        /* kill last thread */
        DEBUG_DelThread(DEBUG_CurrProcess->threads);
        DEBUG_DelProcess(DEBUG_CurrProcess);

        DEBUG_Printf(DBG_CHN_MESG, "Process of pid=%08lx has terminated\n", DEBUG_CurrPid);
        break;

    case LOAD_DLL_DEBUG_EVENT:
        if (DEBUG_CurrThread == NULL)
        {
            DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
            break;
        }
        DEBUG_ProcessGetStringIndirect(buffer, sizeof(buffer),
                                       DEBUG_CurrThread->process->handle,
                                       de->u.LoadDll.lpImageName);

        /* FIXME unicode: de->u.LoadDll.fUnicode */
        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: loads DLL %s @%08lx (%ld<%ld>)\n",
                     de->dwProcessId, de->dwThreadId,
                     buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll,
                     de->u.LoadDll.dwDebugInfoFileOffset,
                     de->u.LoadDll.nDebugInfoSize);
        _strupr(buffer);
        DEBUG_LoadModule32(buffer, de->u.LoadDll.hFile, de->u.LoadDll.lpBaseOfDll);
        DEBUG_CheckDelayedBP();
        if (DBG_IVAR(BreakOnDllLoad))
        {
            DEBUG_Printf(DBG_CHN_MESG, "Stopping on DLL %s loading at %08lx\n",
                         buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll);
            if (DEBUG_FetchContext()) cont = 0;
        }
        break;

    case UNLOAD_DLL_DEBUG_EVENT:
        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: unload DLL @%08lx\n", de->dwProcessId, de->dwThreadId,
                     (unsigned long)de->u.UnloadDll.lpBaseOfDll);
        break;

    case OUTPUT_DEBUG_STRING_EVENT:
        if (DEBUG_CurrThread == NULL)
        {
            DEBUG_Printf(DBG_CHN_ERR, "Unknown thread\n");
            break;
        }

        DEBUG_ProcessGetString(buffer, sizeof(buffer),
                               DEBUG_CurrThread->process->handle,
                               de->u.DebugString.lpDebugStringData);

        /* FIXME unicode de->u.DebugString.fUnicode ? */
        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: output debug string (%s)\n",
                     de->dwProcessId, de->dwThreadId, buffer);
        break;

    case RIP_EVENT:
        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: rip error=%ld type=%ld\n",
                     de->dwProcessId, de->dwThreadId, de->u.RipInfo.dwError,
                     de->u.RipInfo.dwType);
        break;

    default:
        DEBUG_Printf(DBG_CHN_TRACE, "%08lx:%08lx: unknown event (%ld)\n",
                     de->dwProcessId, de->dwThreadId, de->dwDebugEventCode);
    }
    if (!cont) return TRUE;  /* stop execution */
    ContinueDebugEvent(de->dwProcessId, de->dwThreadId, cont);
    return FALSE;  /* continue execution */
}

static void                     DEBUG_ResumeDebuggee(DWORD cont)
{
    if (DEBUG_InException)
    {
        DEBUG_ExceptionEpilog();
#if 1
        DEBUG_Printf(DBG_CHN_TRACE,
                     "Exiting debugger      PC=%lx EFL=%08lx mode=%d count=%d\n",
#ifdef __i386__
                     DEBUG_context.Eip, DEBUG_context.EFlags,
#else
                     0L, 0L,
#endif
                     DEBUG_CurrThread->exec_mode, DEBUG_CurrThread->exec_count);
#endif
        if (DEBUG_CurrThread)
        {
            if (!SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context))
                DEBUG_Printf(DBG_CHN_MESG, "Cannot set ctx on %lu\n", DEBUG_CurrTid);
            DEBUG_CurrThread->wait_for_first_exception = 0;
        }
    }
    DEBUG_InteractiveP = FALSE;
    if (!ContinueDebugEvent(DEBUG_CurrPid, DEBUG_CurrTid, cont))
        DEBUG_Printf(DBG_CHN_MESG, "Cannot continue on %lu (%lu)\n",
                     DEBUG_CurrTid, cont);
}

void                            DEBUG_WaitNextException(DWORD cont, int count, int mode)
{
    DEBUG_EVENT         de;

    if (cont == DBG_CONTINUE)
    {
        DEBUG_CurrThread->exec_count = count;
        DEBUG_CurrThread->exec_mode = mode;
    }
    DEBUG_ResumeDebuggee(cont);

    while (DEBUG_CurrProcess && WaitForDebugEvent(&de, INFINITE))
    {
        if (DEBUG_HandleDebugEvent(&de)) break;
    }
    if (!DEBUG_CurrProcess) return;
    DEBUG_InteractiveP = TRUE;
#if 1
    DEBUG_Printf(DBG_CHN_TRACE,
                 "Entering debugger     PC=%lx EFL=%08lx mode=%d count=%d\n",
#ifdef __i386__
                 DEBUG_context.Eip, DEBUG_context.EFlags,
#else
                 0L, 0L,
#endif
                 DEBUG_CurrThread->exec_mode, DEBUG_CurrThread->exec_count);
#endif
}

static	DWORD	DEBUG_MainLoop(void)
{
    DEBUG_EVENT		de;

    DEBUG_Printf(DBG_CHN_MESG, "WineDbg starting on pid %lx\n", DEBUG_CurrPid);

    /* wait for first exception */
    while (WaitForDebugEvent(&de, INFINITE))
    {
        if (DEBUG_HandleDebugEvent(&de)) break;
    }
    if (local_mode == automatic_mode)
    {
        /* print some extra information */
        DEBUG_Printf(DBG_CHN_MESG, "Modules:\n");
        DEBUG_WalkModules();
        DEBUG_Printf(DBG_CHN_MESG, "Threads:\n");
        DEBUG_WalkThreads();
    }
    else
    {
        DEBUG_InteractiveP = TRUE;
        DEBUG_Parser(NULL);
    }
    DEBUG_Printf(DBG_CHN_MESG, "WineDbg terminated on pid %lx\n", DEBUG_CurrPid);

    return 0;
}

static	BOOL	DEBUG_Start(LPSTR cmdLine)
{
    PROCESS_INFORMATION	info;
    STARTUPINFOA	startup;

    memset(&startup, 0, sizeof(startup));
    startup.cb = sizeof(startup);
    startup.dwFlags = STARTF_USESHOWWINDOW;
    startup.wShowWindow = SW_SHOWNORMAL;

    /* FIXME: shouldn't need the CREATE_NEW_CONSOLE, but as usual CUI:s need it
     * while GUI:s don't
     */
    if (!CreateProcess(NULL, cmdLine, NULL, NULL,
		       FALSE, DEBUG_PROCESS|DEBUG_ONLY_THIS_PROCESS|CREATE_NEW_CONSOLE,
                       NULL, NULL, &startup, &info))
    {
	DEBUG_Printf(DBG_CHN_MESG, "Couldn't start process '%s'\n", cmdLine);
	return FALSE;
    }
    DEBUG_CurrPid = info.dwProcessId;
    if (!(DEBUG_CurrProcess = DEBUG_AddProcess(DEBUG_CurrPid, 0, NULL))) return FALSE;

    return TRUE;
}

void	DEBUG_Run(const char* args)
{
    DBG_MODULE*	wmod = DEBUG_GetProcessMainModule(DEBUG_CurrProcess);
    const char* pgm = (wmod) ? wmod->module_name : "none";

    if (args) {
	DEBUG_Printf(DBG_CHN_MESG, "Run (%s) with '%s'\n", pgm, args);
    } else {
	if (!DEBUG_LastCmdLine) {
	    DEBUG_Printf(DBG_CHN_MESG, "Cannot find previously used command line.\n");
	    return;
	}
	DEBUG_Start(DEBUG_LastCmdLine);
    }
}

BOOL DEBUG_InterruptDebuggee(void)
{
    DEBUG_Printf(DBG_CHN_MESG, "Ctrl-C: stopping debuggee\n");
    /* FIXME: since we likely have a single process, signal the first process
     * in list
     */
    return DEBUG_ProcessList && DebugBreakProcess(DEBUG_ProcessList->handle);
}

static BOOL WINAPI DEBUG_CtrlCHandler(DWORD dwCtrlType)
{
    if (dwCtrlType == CTRL_C_EVENT)
    {
        return DEBUG_InterruptDebuggee();
    }
    return FALSE;
}

static void DEBUG_InitConsole(void)
{
    /* set our control-C handler */
    SetConsoleCtrlHandler(DEBUG_CtrlCHandler, TRUE);

    /* set our own title */
    SetConsoleTitle("Wine Debugger");
}

static int DEBUG_Usage(void)
{
    DEBUG_Printf(DBG_CHN_MESG, "Usage: winedbg [--debugmsg dbgoptions] [--auto] [--gdb] cmdline\n" );
    return 1;
}

int main(int argc, char** argv)
{
    DWORD	retv = 0;
    unsigned    gdb_flags = 0;

    /* Initialize the type handling stuff. */
    DEBUG_InitTypes();
    DEBUG_InitCVDataTypes();

    /* Initialize internal vars (types must have been initialized before) */
    if (!DEBUG_IntVarsRW(TRUE)) return -1;

    /* parse options */
    while (argc > 1 && argv[1][0] == '-')
    {
        if (!strcmp( argv[1], "--auto" ))
        {
            if (local_mode != none_mode) return DEBUG_Usage();
            local_mode = automatic_mode;
            /* force some internal variables */
            DBG_IVAR(BreakOnDllLoad) = 0;
            DBG_IVAR(ConChannelMask) = 0;
            DBG_IVAR(StdChannelMask) = DBG_CHN_MESG;
            argc--; argv++;
            continue;
        }
        if (!strcmp( argv[1], "--gdb" ))
        {
            if (local_mode != none_mode) return DEBUG_Usage();
            local_mode = gdb_mode;
            argc--; argv++;
            continue;
        }
        if (strcmp( argv[1], "--no-start") == 0 && local_mode == gdb_mode)
        {
            gdb_flags |= 1;
            argc--; argv++; /* as we don't use argv[0] */
            continue;
        }
        if (strcmp(argv[1], "--with-xterm") == 0 && local_mode == gdb_mode)
        {
            gdb_flags |= 2;
            argc--; argv++; /* as we don't use argv[0] */
            continue;
        }
        if (!strcmp( argv[1], "--debugmsg" ) && argv[2])
        {
            wine_dbg_parse_options( argv[2] );
            argc -= 2;
            argv += 2;
            continue;
        }
        return DEBUG_Usage();
    }

    if (local_mode == none_mode) local_mode = winedbg_mode;

    /* try the form <myself> pid */
    if (DEBUG_CurrPid == 0 && argc == 2)
    {
        char*   ptr;

        DEBUG_CurrPid = strtol(argv[1], &ptr, 10);
        if (DEBUG_CurrPid == 0 || ptr == NULL ||
            !DEBUG_Attach(DEBUG_CurrPid, local_mode != gdb_mode, FALSE))
            DEBUG_CurrPid = 0;
    }

    /* try the form <myself> pid evt (Win32 JIT debugger) */
    if (DEBUG_CurrPid == 0 && argc == 3)
    {
	HANDLE	hEvent;
	DWORD	pid;
        char*   ptr;

	if ((pid = strtol(argv[1], &ptr, 10)) != 0 && ptr != NULL &&
            (hEvent = (HANDLE)strtol(argv[2], &ptr, 10)) != 0 && ptr != NULL)
        {
	    if (!DEBUG_Attach(pid, TRUE, FALSE))
            {
		/* don't care about result */
		SetEvent(hEvent);
		goto leave;
	    }
	    if (!SetEvent(hEvent))
            {
		DEBUG_Printf(DBG_CHN_ERR, "Invalid event handle: %p\n", hEvent);
		goto leave;
	    }
            CloseHandle(hEvent);
	    DEBUG_CurrPid = pid;
	}
    }

    if (DEBUG_CurrPid == 0 && argc > 1)
    {
	int	i, len;
	LPSTR	cmdLine;

	if (!(cmdLine = DBG_alloc(len = 1))) goto oom_leave;
	cmdLine[0] = '\0';

	for (i = 1; i < argc; i++)
        {
	    len += strlen(argv[i]) + 1;
	    if (!(cmdLine = DBG_realloc(cmdLine, len))) goto oom_leave;
	    strcat(cmdLine, argv[i]);
	    cmdLine[len - 2] = ' ';
	    cmdLine[len - 1] = '\0';
	}

	if (!DEBUG_Start(cmdLine))
        {
	    DEBUG_Printf(DBG_CHN_MESG, "Couldn't start process '%s'\n", cmdLine);
	    goto leave;
	}
	DBG_free(DEBUG_LastCmdLine);
	DEBUG_LastCmdLine = cmdLine;
    }
    /* don't save local vars in gdb mode */
    if (local_mode == gdb_mode && DEBUG_CurrPid)
        return DEBUG_GdbRemote(gdb_flags);

    DEBUG_InitConsole();

    retv = DEBUG_MainLoop();
    /* don't save modified variables in auto mode */
    if (local_mode != automatic_mode) DEBUG_IntVarsRW(FALSE);

 leave:
    return retv;

 oom_leave:
    DEBUG_Printf(DBG_CHN_MESG, "Out of memory\n");
    goto leave;
}