debugger
Eric Pouech
eric.pouech at wanadoo.fr
Mon Apr 1 10:34:39 CST 2002
this patch fixes winedbg handling of first chance exception
before passing on a first chance exception was seen as a state of the
internal automaton... it's now seen as a return value from the
first chance exception
this allows:
- to fix buggy code in previous implementation (in some cases, passing
was understood as quitting the debuggee)
- it allows to keep the current operation (stepping, continueing) even
while receiving first chance exceptions
A+
-------------- next part --------------
Name: wdbg_pass
ChangeLog: fixed some bugs in first chance exception handling
License: X11
GenDate: 2002/04/01 15:37:07 UTC
ModifiedFiles: debugger/break.c debugger/dbg.y debugger/debugger.h debugger/winedbg.c
AddedFiles:
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/debugger/break.c,v
retrieving revision 1.30
diff -u -u -r1.30 break.c
--- debugger/break.c 9 Mar 2002 23:50:37 -0000 1.30
+++ debugger/break.c 22 Mar 2002 21:50:35 -0000
@@ -746,13 +746,14 @@
* Determine if we should continue execution after a SIGTRAP signal when
* executing in the given mode.
*/
-BOOL DEBUG_ShouldContinue( DBG_ADDR *addr, DWORD code, enum exec_mode mode, int * count )
+BOOL DEBUG_ShouldContinue( DBG_ADDR *addr, DWORD code, int * count )
{
- int bpnum;
- DWORD oldval;
- int wpnum;
- enum dbg_mode addr_mode;
- struct symbol_info syminfo;
+ int bpnum;
+ DWORD oldval;
+ int wpnum;
+ enum dbg_mode addr_mode;
+ struct symbol_info syminfo;
+ enum exec_mode mode = DEBUG_CurrThread->exec_mode;
#ifdef __i386__
/* If not single-stepping, back up over the int3 instruction */
@@ -833,7 +834,7 @@
* If we are about to stop, then print out the source line if we
* have it.
*/
- if (mode != EXEC_CONT && mode != EXEC_PASS && mode != EXEC_FINISH)
+ if (mode != EXEC_CONT && mode != EXEC_FINISH)
{
DEBUG_FindNearestSymbol( addr, TRUE, NULL, 0, &syminfo.list);
if( syminfo.list.sourcefile != NULL )
@@ -853,7 +854,7 @@
#endif
/* no breakpoint, continue if in continuous mode */
- return (mode == EXEC_CONT || mode == EXEC_PASS || mode == EXEC_FINISH);
+ return (mode == EXEC_CONT || mode == EXEC_FINISH);
}
/***********************************************************************
@@ -873,14 +874,14 @@
* Set the breakpoints to the correct state to restart execution
* in the given mode.
*/
-enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count )
+void DEBUG_RestartExecution( int count )
{
DBG_ADDR addr;
DBG_ADDR addr2;
int bp;
int delta;
int status;
- enum exec_mode ret_mode;
+ enum exec_mode mode, ret_mode;
DWORD instr;
unsigned char ch;
@@ -890,7 +891,7 @@
* This is the mode we will be running in after we finish. We would like
* to be able to modify this in certain cases.
*/
- ret_mode = mode;
+ ret_mode = mode = DEBUG_CurrThread->exec_mode;
bp = DEBUG_FindBreakpoint( &addr, DBG_BREAK );
if ( bp != -1 && bp != 0)
@@ -971,7 +972,6 @@
switch(mode)
{
case EXEC_CONT: /* Continuous execution */
- case EXEC_PASS: /* Continue, passing exception */
#ifdef __i386__
DEBUG_context.EFlags &= ~STEP_FLAG;
#endif
@@ -1030,7 +1030,7 @@
RaiseException(DEBUG_STATUS_INTERNAL_ERROR, 0, 0, NULL);
}
DEBUG_CurrThread->stepOverBP = breakpoints[0];
- return ret_mode;
+ DEBUG_CurrThread->exec_mode = ret_mode;
}
int
Index: debugger/dbg.y
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/debugger/dbg.y,v
retrieving revision 1.52
diff -u -u -r1.52 dbg.y
--- debugger/dbg.y 23 Mar 2002 18:43:55 -0000 1.52
+++ debugger/dbg.y 24 Mar 2002 21:35:29 -0000
@@ -103,31 +103,30 @@
| error tEOL { yyerrok; }
command:
- tQUIT tEOL { return EXIT_QUIT; }
+ tQUIT tEOL { DEBUG_ExitMode = EXIT_QUIT; return 1; }
| tHELP tEOL { DEBUG_Help(); }
| tHELP tINFO tEOL { DEBUG_HelpInfo(); }
- | tCONT tEOL { DEBUG_CurrThread->dbg_exec_count = 1;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_CONT; return EXIT_CONT; }
- | tPASS tEOL { DEBUG_CurrThread->dbg_exec_count = 1;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_PASS; return EXIT_CONT; }
- | tCONT tNUM tEOL { DEBUG_CurrThread->dbg_exec_count = $2;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_CONT; return EXIT_CONT; }
- | tSTEP tEOL { DEBUG_CurrThread->dbg_exec_count = 1;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_STEP_INSTR; return EXIT_CONT; }
- | tNEXT tEOL { DEBUG_CurrThread->dbg_exec_count = 1;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_STEP_OVER; return EXIT_CONT; }
- | tSTEP tNUM tEOL { DEBUG_CurrThread->dbg_exec_count = $2;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_STEP_INSTR; return EXIT_CONT; }
- | tNEXT tNUM tEOL { DEBUG_CurrThread->dbg_exec_count = $2;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_STEP_OVER; return EXIT_CONT; }
- | tSTEPI tEOL { DEBUG_CurrThread->dbg_exec_count = 1;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_STEPI_INSTR; return EXIT_CONT; }
- | tNEXTI tEOL { DEBUG_CurrThread->dbg_exec_count = 1;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_STEPI_OVER; return EXIT_CONT; }
- | tSTEPI tNUM tEOL { DEBUG_CurrThread->dbg_exec_count = $2;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_STEPI_INSTR; return EXIT_CONT; }
- | tNEXTI tNUM tEOL { DEBUG_CurrThread->dbg_exec_count = $2;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_STEPI_OVER; return EXIT_CONT; }
+ | tCONT tEOL { DEBUG_CurrThread->exec_count = 1;
+ DEBUG_CurrThread->exec_mode = EXEC_CONT; return 1; }
+ | tPASS tEOL { DEBUG_ExitMode = EXIT_PASS; return 1; }
+ | tCONT tNUM tEOL { DEBUG_CurrThread->exec_count = $2;
+ DEBUG_CurrThread->exec_mode = EXEC_CONT; return 1; }
+ | tSTEP tEOL { DEBUG_CurrThread->exec_count = 1;
+ DEBUG_CurrThread->exec_mode = EXEC_STEP_INSTR; return 1; }
+ | tNEXT tEOL { DEBUG_CurrThread->exec_count = 1;
+ DEBUG_CurrThread->exec_mode = EXEC_STEP_OVER; return 1; }
+ | tSTEP tNUM tEOL { DEBUG_CurrThread->exec_count = $2;
+ DEBUG_CurrThread->exec_mode = EXEC_STEP_INSTR; return 1; }
+ | tNEXT tNUM tEOL { DEBUG_CurrThread->exec_count = $2;
+ DEBUG_CurrThread->exec_mode = EXEC_STEP_OVER; return 1; }
+ | tSTEPI tEOL { DEBUG_CurrThread->exec_count = 1;
+ DEBUG_CurrThread->exec_mode = EXEC_STEPI_INSTR; return 1; }
+ | tNEXTI tEOL { DEBUG_CurrThread->exec_count = 1;
+ DEBUG_CurrThread->exec_mode = EXEC_STEPI_OVER; return 1; }
+ | tSTEPI tNUM tEOL { DEBUG_CurrThread->exec_count = $2;
+ DEBUG_CurrThread->exec_mode = EXEC_STEPI_INSTR; return 1; }
+ | tNEXTI tNUM tEOL { DEBUG_CurrThread->exec_count = $2;
+ DEBUG_CurrThread->exec_mode = EXEC_STEPI_OVER; return 1; }
| tABORT tEOL { kill(getpid(), SIGABRT); }
| tMODE tNUM tEOL { mode_command($2); }
| tMODE tVM86 tEOL { DEBUG_CurrThread->dbg_mode = MODE_VM86; }
@@ -141,8 +140,8 @@
| tDOWN tEOL { DEBUG_SetFrame( curr_frame - 1 ); }
| tDOWN tNUM tEOL { DEBUG_SetFrame( curr_frame - $2 ); }
| tFRAME tNUM tEOL { DEBUG_SetFrame( $2 ); }
- | tFINISH tEOL { DEBUG_CurrThread->dbg_exec_count = 0;
- DEBUG_CurrThread->dbg_exec_mode = EXEC_FINISH; return EXIT_CONT; }
+ | tFINISH tEOL { DEBUG_CurrThread->exec_count = 0;
+ DEBUG_CurrThread->exec_mode = EXEC_FINISH; return 1; }
| tSHOW tDIR tEOL { DEBUG_ShowDir(); }
| tDIR pathname tEOL { DEBUG_AddPath( $2 ); }
| tDIR tEOL { DEBUG_NukePath(); }
@@ -157,8 +156,8 @@
| tCOND tNUM expr tEOL { DEBUG_AddBPCondition($2, $3); }
| tSYMBOLFILE pathname tEOL { DEBUG_ReadSymbolTable($2); }
| tWHATIS expr_addr tEOL { DEBUG_PrintType(&$2); DEBUG_FreeExprMem(); }
- | tATTACH tNUM tEOL { if (DEBUG_Attach($2, FALSE)) return EXIT_CONT; }
- | tDETACH tEOL { return EXIT_DETACH; }
+ | tATTACH tNUM tEOL { if (DEBUG_Attach($2, FALSE)) return 1; }
+ | tDETACH tEOL { DEBUG_ExitMode = EXIT_DETACH; return 1; }
| list_command
| disassemble_command
| set_command
@@ -409,29 +408,27 @@
*
* Debugger editline parser
*/
-enum exit_mode DEBUG_Parser(void)
+void DEBUG_Parser(void)
{
BOOL ret_ok;
- enum exit_mode ret = EXIT_CONT;
#ifdef YYDEBUG
yydebug = 0;
#endif
yyin = stdin;
+ DEBUG_ExitMode = EXIT_CONTINUE;
+
ret_ok = FALSE;
do {
__TRY {
ret_ok = TRUE;
- if ((ret = yyparse())) {
- DEBUG_FlushSymbols();
- }
+ yyparse();
} __EXCEPT(wine_dbg_cmd) {
ret_ok = FALSE;
}
__ENDTRY;
-
+ DEBUG_FlushSymbols();
} while (!ret_ok);
- return ret;
}
int yyerror(char* s)
Index: debugger/debugger.h
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/debugger/debugger.h,v
retrieving revision 1.30
diff -u -u -r1.30 debugger.h
--- debugger/debugger.h 9 Mar 2002 23:50:37 -0000 1.30
+++ debugger/debugger.h 22 Mar 2002 21:50:55 -0000
@@ -126,7 +126,6 @@
enum exec_mode
{
EXEC_CONT, /* Continuous execution */
- EXEC_PASS, /* Continue, passing exception to app */
EXEC_STEP_OVER, /* Stepping over a call to next source line */
EXEC_STEP_INSTR, /* Step to next source line, stepping in if needed */
EXEC_STEPI_OVER, /* Stepping over a call */
@@ -139,6 +138,19 @@
*/
};
+enum dbg_mode
+{
+ MODE_INVALID, MODE_16, MODE_32, MODE_VM86
+};
+
+enum exit_mode /* of exception handling */
+{
+ EXIT_CONTINUE, /* continue execution */
+ EXIT_PASS, /* pass exception back to app (1st chance) */
+ EXIT_DETACH, /* detach debugger */
+ EXIT_QUIT, /* exit debugger and kill debuggee */
+};
+
#define DBG_BREAK 0
#define DBG_WATCH 1
@@ -165,17 +177,6 @@
struct expr * condition;
} DBG_BREAKPOINT;
-enum dbg_mode
-{
- MODE_INVALID, MODE_16, MODE_32, MODE_VM86
-};
-
-
-enum exit_mode
-{
- EXIT_CONT, EXIT_QUIT, EXIT_DETACH
-};
-
/* Wine extension; Windows doesn't have a name for this code. This is an
undocumented exception understood by MS VC debugger, allowing the program
to name a particular thread. Search google.com or deja.com for "0x406d1388"
@@ -198,9 +199,9 @@
LPVOID start;
LPVOID teb;
int wait_for_first_exception;
- enum dbg_mode dbg_mode;
- enum exec_mode dbg_exec_mode;
- int dbg_exec_count;
+ enum exec_mode exec_mode; /* mode the thread is run (step/run...) */
+ int exec_count; /* count of mode operations */
+ enum dbg_mode dbg_mode; /* mode (VM86, 32bit, 16bit) */
DBG_BREAKPOINT stepOverBP;
char name[9];
struct tagDBG_THREAD* next;
@@ -241,6 +242,7 @@
extern DWORD DEBUG_CurrPid;
extern CONTEXT DEBUG_context;
extern BOOL DEBUG_interactiveP;
+extern enum exit_mode DEBUG_ExitMode;
#define DEBUG_READ_MEM(addr, buf, len) \
(ReadProcessMemory(DEBUG_CurrProcess->handle, (addr), (buf), (len), NULL))
@@ -294,10 +296,9 @@
extern void DEBUG_EnableBreakpoint( int num, BOOL enable );
extern void DEBUG_InfoBreakpoints(void);
extern BOOL DEBUG_HandleTrap(void);
-extern BOOL DEBUG_ShouldContinue( DBG_ADDR *addr, DWORD code, enum exec_mode mode,
- int * count );
+extern BOOL DEBUG_ShouldContinue( DBG_ADDR* addr, DWORD code, int* count );
extern void DEBUG_SuspendExecution( void );
-extern enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count );
+extern void DEBUG_RestartExecution( int count );
extern BOOL DEBUG_IsFctReturn(void);
extern int DEBUG_AddBPCondition(int bpnum, struct expr * exp);
@@ -305,7 +306,7 @@
extern void DEBUG_Disasm( DBG_ADDR *addr, int display );
/* debugger/dbg.y */
-extern enum exit_mode DEBUG_Parser(void);
+extern void DEBUG_Parser(void);
extern void DEBUG_Exit( DWORD );
/* debugger/debug.l */
Index: debugger/winedbg.c
===================================================================
RCS file: /home/cvs/cvsroot/wine/wine/debugger/winedbg.c,v
retrieving revision 1.49
diff -u -u -r1.49 winedbg.c
--- debugger/winedbg.c 9 Mar 2002 23:50:37 -0000 1.49
+++ debugger/winedbg.c 1 Apr 2002 15:36:49 -0000
@@ -40,6 +40,7 @@
DWORD DEBUG_CurrPid;
CONTEXT DEBUG_context;
BOOL DEBUG_interactiveP = FALSE;
+enum exit_mode DEBUG_ExitMode = EXIT_CONTINUE;
int curr_frame = 0;
static char* DEBUG_LastCmdLine = NULL;
@@ -242,8 +253,9 @@
t->teb = teb;
t->process = p;
t->wait_for_first_exception = 0;
- t->dbg_exec_mode = EXEC_CONT;
- t->dbg_exec_count = 0;
+ t->exec_mode = EXEC_CONT;
+ t->exec_count = 0;
+
sprintf(t->name, "%08lx", tid);
p->num_threads++;
@@ -349,10 +361,8 @@
DEBUG_LoadEntryPoints("Loading new modules symbols:\n");
if (!force && is_debug &&
- DEBUG_ShouldContinue(&addr,
- code,
- DEBUG_CurrThread->dbg_exec_mode,
- &DEBUG_CurrThread->dbg_exec_count))
+ DEBUG_ShouldContinue(&addr, code,
+ &DEBUG_CurrThread->exec_count))
return FALSE;
if ((newmode = DEBUG_GetSelectorType(addr.seg)) == MODE_INVALID) newmode = MODE_32;
@@ -387,8 +397,8 @@
}
if (!is_debug ||
- (DEBUG_CurrThread->dbg_exec_mode == EXEC_STEPI_OVER) ||
- (DEBUG_CurrThread->dbg_exec_mode == EXEC_STEPI_INSTR)) {
+ (DEBUG_CurrThread->exec_mode == EXEC_STEPI_OVER) ||
+ (DEBUG_CurrThread->exec_mode == EXEC_STEPI_INSTR)) {
struct list_id list;
@@ -403,30 +413,27 @@
return TRUE;
}
-static DWORD DEBUG_ExceptionEpilog(void)
+static void DEBUG_ExceptionEpilog(void)
{
- DEBUG_CurrThread->dbg_exec_mode = DEBUG_RestartExecution(DEBUG_CurrThread->dbg_exec_mode,
- DEBUG_CurrThread->dbg_exec_count);
+ 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->dbg_exec_mode == EXEC_CONT || DEBUG_CurrThread->dbg_exec_mode == EXEC_PASS)
- DEBUG_CurrThread->dbg_exec_count = 0;
-
- return (DEBUG_CurrThread->dbg_exec_mode == EXEC_PASS) ? DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE;
+ if (DEBUG_CurrThread->exec_mode == EXEC_CONT)
+ DEBUG_CurrThread->exec_count = 0;
}
-static enum exit_mode DEBUG_HandleException(EXCEPTION_RECORD *rec, BOOL first_chance, BOOL force, LPDWORD cont)
+static void DEBUG_HandleException(EXCEPTION_RECORD *rec, BOOL first_chance, BOOL force)
{
BOOL is_debug = FALSE;
- enum exit_mode ret = EXIT_CONT;
THREADNAME_INFO *pThreadName;
DBG_THREAD *pThread;
+ assert(DEBUG_CurrThread);
- *cont = DBG_CONTINUE;
+ DEBUG_ExitMode = EXIT_CONTINUE;
switch (rec->ExceptionCode)
{
@@ -446,14 +453,14 @@
DEBUG_Printf (DBG_CHN_MESG,
"Thread ID=0x%lx renamed using MS VC6 extension (name==\"%s\")\n",
pThread->tid, pThread->name);
- return EXIT_CONT;
+ return;
}
if (first_chance && !is_debug && !force && !DBG_IVAR(BreakOnFirstChance))
{
/* pass exception to program except for debug exceptions */
- *cont = is_debug ? DBG_CONTINUE : DBG_EXCEPTION_NOT_HANDLED;
- return EXIT_CONT;
+ if (!is_debug) DEBUG_ExitMode = EXIT_PASS;
+ return;
}
if (!is_debug)
@@ -511,7 +518,7 @@
if (!DBG_IVAR(BreakOnCritSectTimeOut))
{
DEBUG_Printf(DBG_CHN_MESG, "\n");
- return EXIT_CONT;
+ return;
}
break;
case EXCEPTION_WINE_STUB:
@@ -548,27 +555,32 @@
#else
0L, 0L,
#endif
- DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
+ DEBUG_CurrThread->exec_mode, DEBUG_CurrThread->exec_count);
#endif
if (automatic_mode)
{
DEBUG_ExceptionProlog(is_debug, FALSE, rec->ExceptionCode);
- return EXIT_QUIT; /* terminate execution */
+ DEBUG_ExitMode = EXIT_QUIT;
+ return; /* terminate execution */
}
if (DEBUG_ExceptionProlog(is_debug, force, rec->ExceptionCode)) {
DEBUG_interactiveP = TRUE;
- while ((ret = DEBUG_Parser()) == EXIT_CONT) {
+ for (;;)
+ {
+ DEBUG_Parser();
+ if (DEBUG_ExitMode == EXIT_QUIT || DEBUG_ExitMode == EXIT_DETACH)
+ break;
if (DEBUG_ValidateRegisters()) {
- if (DEBUG_CurrThread->dbg_exec_mode != EXEC_PASS || first_chance)
+ if (DEBUG_ExitMode == EXIT_PASS || first_chance)
break;
DEBUG_Printf(DBG_CHN_MESG, "Cannot pass on last chance exception. You must use cont\n");
}
}
DEBUG_interactiveP = FALSE;
}
- *cont = DEBUG_ExceptionEpilog();
+ DEBUG_ExceptionEpilog();
#if 0
DEBUG_Printf(DBG_CHN_TRACE,
@@ -578,24 +590,19 @@
#else
0L, 0L,
#endif
- DEBUG_CurrThread->dbg_exec_mode, DEBUG_CurrThread->dbg_exec_count);
+ DEBUG_CurrThread->exec_mode, DEBUG_CurrThread->exec_count);
#endif
-
- return ret;
}
-static BOOL DEBUG_HandleDebugEvent(DEBUG_EVENT* de, LPDWORD cont)
+static void DEBUG_HandleDebugEvent(DEBUG_EVENT* de)
{
char buffer[256];
- enum exit_mode ret;
DEBUG_CurrPid = de->dwProcessId;
DEBUG_CurrTid = de->dwThreadId;
+ DEBUG_ExitMode = EXIT_CONTINUE;
__TRY {
- ret = EXIT_CONT;
- *cont = 0L;
-
if ((DEBUG_CurrProcess = DEBUG_GetProcess(de->dwProcessId)) != NULL)
DEBUG_CurrThread = DEBUG_GetThread(DEBUG_CurrProcess, de->dwThreadId);
else
@@ -616,7 +623,6 @@
if (DEBUG_CurrProcess->continue_on_first_exception) {
DEBUG_CurrProcess->continue_on_first_exception = FALSE;
if (!DBG_IVAR(BreakOnAttach)) {
- *cont = DBG_CONTINUE;
break;
}
}
@@ -636,10 +642,9 @@
break;
}
- ret = DEBUG_HandleException(&de->u.Exception.ExceptionRecord,
- de->u.Exception.dwFirstChance,
- DEBUG_CurrThread->wait_for_first_exception,
- cont);
+ DEBUG_HandleException(&de->u.Exception.ExceptionRecord,
+ de->u.Exception.dwFirstChance,
+ DEBUG_CurrThread->wait_for_first_exception);
if (DEBUG_CurrThread) {
DEBUG_CurrThread->wait_for_first_exception = 0;
SetThreadContext(DEBUG_CurrThread->handle, &DEBUG_context);
@@ -793,7 +798,7 @@
if (DBG_IVAR(BreakOnDllLoad)) {
DEBUG_Printf(DBG_CHN_MESG, "Stopping on DLL %s loading at %08lx\n",
buffer, (unsigned long)de->u.LoadDll.lpBaseOfDll);
- ret = DEBUG_Parser();
+ DEBUG_Parser();
}
break;
@@ -829,38 +834,42 @@
}
} __EXCEPT(wine_dbg) {
- *cont = 0;
- ret = EXIT_CONT;
+ DEBUG_ExitMode = EXIT_CONTINUE;
}
__ENDTRY;
- return ret;
}
static DWORD DEBUG_MainLoop(void)
{
DEBUG_EVENT de;
- DWORD cont;
- enum exit_mode ret = EXIT_CONT;
DEBUG_Printf(DBG_CHN_MESG, " on pid %lx\n", DEBUG_CurrPid);
- while (ret == EXIT_CONT)
+ while (DEBUG_ExitMode == EXIT_CONTINUE)
{
/* wait until we get at least one loaded process */
- while (!DEBUG_ProcessList && (ret = DEBUG_Parser()) == EXIT_CONT);
- if (ret != EXIT_CONT) break;
+ while (!DEBUG_ProcessList)
+ {
+ DEBUG_Parser();
+ if (DEBUG_ExitMode == EXIT_CONTINUE || DEBUG_ExitMode == EXIT_QUIT) break;
+ }
+ if (DEBUG_ExitMode != EXIT_CONTINUE) break;
- while (ret == EXIT_CONT && DEBUG_ProcessList && WaitForDebugEvent(&de, INFINITE)) {
- ret = DEBUG_HandleDebugEvent(&de, &cont);
- ContinueDebugEvent(de.dwProcessId, de.dwThreadId, cont);
+ while ((DEBUG_ExitMode == EXIT_CONTINUE || DEBUG_ExitMode == EXIT_PASS) &&
+ DEBUG_ProcessList &&
+ WaitForDebugEvent(&de, INFINITE))
+ {
+ DEBUG_HandleDebugEvent(&de);
+ ContinueDebugEvent(de.dwProcessId, de.dwThreadId,
+ (DEBUG_ExitMode == EXIT_PASS) ? DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE);
}
- if (ret == EXIT_DETACH && DEBUG_Detach())
+ if (DEBUG_ExitMode == EXIT_DETACH && DEBUG_Detach())
{
- /* ret = EXIT_CONT; */
+ /* DEBUG_ExitMode = EXIT_CONTINUE; */
/* FIXME: as we don't have a simple way to zero out the process symbol table
* we simply quit the debugger on detach...
*/
- ret = EXIT_QUIT;
+ DEBUG_ExitMode = EXIT_QUIT;
}
}
@@ -872,15 +881,16 @@
static DWORD DEBUG_AutoMode(void)
{
DEBUG_EVENT de;
- DWORD cont;
- enum exit_mode ret = EXIT_CONT;
DEBUG_Printf(DBG_CHN_MESG, " on pid %lx\n", DEBUG_CurrPid);
- while (ret == EXIT_CONT && DEBUG_ProcessList && WaitForDebugEvent(&de, INFINITE))
+ while ((DEBUG_ExitMode == EXIT_CONTINUE || DEBUG_ExitMode == EXIT_PASS) &&
+ DEBUG_ProcessList &&
+ WaitForDebugEvent(&de, INFINITE))
{
- ret = DEBUG_HandleDebugEvent(&de, &cont);
- ContinueDebugEvent(de.dwProcessId, de.dwThreadId, cont);
+ DEBUG_HandleDebugEvent(&de);
+ ContinueDebugEvent(de.dwProcessId, de.dwThreadId,
+ (DEBUG_ExitMode == EXIT_PASS) ? DBG_EXCEPTION_NOT_HANDLED : DBG_CONTINUE);
}
/* print some extra information */
DEBUG_Printf(DBG_CHN_MESG, "Modules:\n");
More information about the wine-patches
mailing list