void WndDebug( void ) { if( _IsOn( SW_MIGHT_HAVE_LOST_DISPLAY ) ) { if( ScrnState & DBG_SCRN_ACTIVE ) { if( !DebugScreenRecover() ) { ScrnState &= ~DBG_SCRN_ACTIVE; } } _SwitchOff( SW_MIGHT_HAVE_LOST_DISPLAY ); } if( !(ScrnState & DBG_SCRN_ACTIVE) ) { if( !(ScrnState & DBG_SCRN_VISIBLE) ) RemoteSetDebugScreen(); ScrnState |= DBG_SCRN_ACTIVE | DBG_SCRN_VISIBLE; if( DebugScreen() ) { ScrnState |= USR_SCRN_VISIBLE; } else { ScrnState &= ~USR_SCRN_VISIBLE; } GUIGMouseOn(); } ScrnState &= ~USR_SCRN_ACTIVE; }
static DWORD WINAPI ControlFunc( LPVOID parm ) { parm = parm; do { WaitForSingleObject( Requestsem, INFINITE ); // wait for Request switch( Req ) { case REQ_GO: Go( true ); break; case REQ_TRACE_OVER: ExecTrace( TRACE_OVER, DbgLevel ); break; case REQ_TRACE_INTO: ExecTrace( TRACE_INTO, DbgLevel ); break; } DoInput(); _SwitchOff( SW_TASK_RUNNING ); ReleaseSemaphore( Requestdonesem, 1, NULL ); // signal req done } while( Req != REQ_BYE ); return( 0 ); // thread over! }
void DUIInit( void ) { InitScreen(); CmdHistory = WndInitHistory(); SrchHistory = WndInitHistory(); InitToolBar(); InitMemWindow(); InitAboutMessage(); InitIOWindow(); InitMenus(); WndInit( LIT_DUI( The_WATCOM_Debugger ) ); _SwitchOff( SW_ERROR_STARTUP ); #if defined(__GUI__) TellWinHandle(); #endif if( WndMain != NULL ) WndSetIcon( WndMain, &MainIcon ); StartTimer(); InitHelp(); InitGadget(); InitPaint(); InitBrowse(); InitFont(); }
void ProcPendingPaint( void ) { gui_colour_set *set; a_window *wnd; if( _IsOff( SW_PENDING_REPAINT ) ) return; _SwitchOff( SW_PENDING_REPAINT ); for( wnd = WndNext( NULL ); wnd != NULL; wnd = WndNext( wnd ) ) { if( WndHasClass( wnd ) ) { set = WndClassColour[WndClass( wnd )]; } else { set = NULL; } if( set == NULL ) { set = WndClassColour[WND_ALL]; } if( set == NULL ) { set = WndColours; } WndSetFontInfo( wnd, GetWndFont( wnd ) ); WndSetColours( wnd, WndNumColours, set ); } }
bool ReportTrap( unsigned conditions, bool stack_cmds ) { bool cmds_pushed; char *p; if( conditions & COND_EXCEPTION ) { RecordMsgText( &conditions ); // get the 'access violation, etc' message p = StrCopy( LIT_ENG( Task_Exception ), TxtBuff ); if( MsgText != NULL ) StrCopy( MsgText, p ); MsgText = DbgRealloc( MsgText, strlen( TxtBuff ) + 1 ); StrCopy( TxtBuff, MsgText ); DUIMsgBox( MsgText ); } if( conditions & (COND_EXCEPTION|COND_TERMINATE) ) { RingBell(); } DisplayMsgText(); if( conditions & COND_USER ) { DUIInfoBox( LIT_ENG( User_Interupt ) ); PurgeInpStack(); RecordAsynchEvent(); } else if( conditions & COND_TERMINATE ) { DUIInfoBox( LIT_ENG( Task_Completed ) ); _SwitchOff( SW_HAVE_TASK ); } else if( conditions & COND_LIBRARIES ) { Format( TxtBuff, "%s '%s'", LIT_ENG( Break_on_DLL_Load ), GetLastImageName() ); DUIInfoBox( TxtBuff ); } else { DUIStatusText( LIT_ENG( Empty ) ); } cmds_pushed = DispBPMsg( stack_cmds ); DbgUpdate( UP_MEM_CHANGE | UP_CSIP_CHANGE | UP_REG_CHANGE | UP_CODE_EXECUTED | UP_THREAD_STATE ); return( cmds_pushed ); }
void ProcGo( void ) { address start; address stop; bool have_start; bool have_stop; bool have_keep; bool doflip; bool flip_on; bool until; unsigned conditions; int count; have_keep = FALSE; doflip = TRUE; until = FALSE; while( CurrToken == T_DIV ) { Scan(); switch( ScanCmd( GoOptionTab ) ) { case KEEP: have_keep = TRUE; break; case NOFLIP: doflip = FALSE; break; case UNTIL: until = TRUE; break; default: Error( ERR_LOC, LIT( ERR_BAD_OPTION ), GetCmdName( CMD_GO ) ); } } if( !have_keep ) TraceKill(); NullStatus( &DbgTmpBrk ); start = GetRegIP(); have_stop = FALSE; have_start = FALSE; if( !ScanEOC() ) { stop = start; ReqMemAddr( EXPR_GIVEN, &stop ); if( CurrToken == T_COMMA ) { start = stop; have_start = TRUE; Scan(); if( !ScanEOC() ) { ReqMemAddr( EXPR_GIVEN, &stop ); have_stop = TRUE; } } else { have_stop = TRUE; } } ReqEOC(); count = 0; do { if( have_stop ) { if( have_keep ) { if( UserTmpBrk.status.b.has_address ) { NullStatus( &UserTmpBrk ); UserTmpBrk.status.b.has_address = TRUE; } else { NullStatus( &UserTmpBrk ); } Error( ERR_NONE, LIT( ERR_INCONSISTENT_GO ) ); } SetTempBreak( stop ); } else if( have_keep ) { if( UserTmpBrk.status.b.has_address ) { UserTmpBrk.status.b.active = TRUE; } } else { NullStatus( &UserTmpBrk ); } if( have_start ) { RecordSetRegIP( start ); } flip_on = _IsOn( SW_FLIP ); if( !doflip ) { _SwitchOff( SW_FLIP ); } conditions = Go( doflip ); if( flip_on ) _SwitchOn( SW_FLIP ); if( UserTmpBrk.status.b.has_address ) { NullStatus( &UserTmpBrk ); UserTmpBrk.status.b.has_address = TRUE; } else { NullStatus( &UserTmpBrk ); } } while( until && (conditions & COND_BREAK) && AddrComp( stop, GetRegIP() ) != 0 && ++count < 100 ); }
static unsigned MechMisc( unsigned select, unsigned parm ) { long value; unsigned result = 0; mad_type_info mti; switch( select ) { case 0: ExprAddrDepth += parm; result = ExprAddrDepth; break; case 1: if( _IsOn( SW_EXPR_IS_CALL ) && ExprAddrDepth == 0 ) { result = TRUE; } else { result = FALSE; } break; case 2: SkipCount += parm; break; case 3: result = SkipCount; break; case 4: //never called break; case 5: if( ScanSavePtr >= MAX_SCANSAVE_PTRS ) Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANSAVE ) ); CurrScan[ScanSavePtr++] = ScanPos(); break; case 6: if( ScanSavePtr <= 0 ) Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANRESTORE ) ); ReScan( CurrScan[--ScanSavePtr] ); break; case 7: if( ScanSavePtr <= 0 ) Error( ERR_INTERNAL, LIT( ERR_TOO_MANY_SCANRESTORE ) ); --ScanSavePtr; break; case 8: if( parm ) { /* start scan string */ scan_string = TRUE; ReScan( ScanPos() ); } else { /* end scan string */ scan_string = FALSE; ReScan( ScanPos() ); } break; case 9: ReScan( ScanPos() + (int)parm ); break; case 10: AddChar(); break; case 11: AddCEscapeChar(); break; case 12: AddActualChar( '\0' ); break; case 13: ScanCCharNum = parm; break; case 14: if( NestedCallLevel == MAX_NESTED_CALL - 1 ) { Error( ERR_NONE, LIT( ERR_TOO_MANY_CALLS ) ); } else { PgmStackUsage[ ++NestedCallLevel ] = 0; } break; case 15: RValue( ExprSP ); ConvertTo( ExprSP, TK_INTEGER, TM_SIGNED, 4 ); value = U32FetchTrunc( ExprSP->v.uint ) - 1; PopEntry(); if( ExprSP->info.kind == TK_STRING ) { if( value < 0 || value >= ExprSP->info.size ) { Error( ERR_NONE, LIT( ERR_BAD_SUBSTRING_INDEX ) ); } LocationAdd( &ExprSP->v.string.loc, value*8 ); ExprSP->info.size -= value; ExprSP->v.string.ss_offset = value; } else { Error( ERR_NONE, LIT( ERR_ILL_TYPE ) ); } break; case 16: RValue( ExprSP ); ConvertTo( ExprSP, TK_INTEGER, TM_SIGNED, 4 ); value = U32FetchTrunc( ExprSP->v.sint ) - 1; PopEntry(); if( ExprSP->info.kind == TK_STRING ) { value -= ExprSP->v.string.ss_offset; if( value < 0 || value >= ExprSP->info.size ) { Error( ERR_NONE, LIT( ERR_BAD_SUBSTRING_INDEX ) ); } ExprSP->info.size = value; } else { Error( ERR_NONE, LIT( ERR_ILL_TYPE ) ); } break; case 17: EvalSubstring = parm; if( parm ) ExprSP->v.string.ss_offset = 0; break; case 18: result = EvalSubstring; break; case 19: FreePgmStack( TRUE ); break; case 20: switch( parm ) { // nyi - begin temp case SSL_CASE_SENSITIVE: _SwitchOn( SW_CASE_SENSITIVE ); break; case SSL_SIDE_EFFECT: _SwitchOn( SW_SIDE_EFFECT ); break; //case SSL_32_BIT: // _SwitchOn( SW_32_BIT ); // break; } break; case 21: switch( parm ) { case SSL_CASE_SENSITIVE: _SwitchOff( SW_CASE_SENSITIVE ); break; case SSL_SIDE_EFFECT: _SwitchOff( SW_SIDE_EFFECT ); break; //case SSL_32_BIT: // _SwitchOff( SW_32_BIT ); // break; } break; case 22: switch( parm ) { case SSL_CASE_SENSITIVE: result = _IsOn( SW_CASE_SENSITIVE ); break; case SSL_SIDE_EFFECT: result = _IsOn( SW_SIDE_EFFECT ); break; case SSL_32_BIT: GetMADTypeDefault( MTK_INTEGER, &mti ); result = (mti.b.bits >= 32); break; } break; case 23: // nyi - end temp MarkArrayOrder( parm ); break; case 24: StartSubscript(); break; case 25: AddSubscript(); break; case 26: EndSubscript(); break; } return( result ); }
static void ProcOptList( int pass ) { char buff[80]; char err_buff[CMD_LEN]; char *curr; unsigned long mem; SetupChar(); /* initialize scanner */ for( ;; ) { SkipSpaces(); if( !OptDelim( CurrChar ) ) break; NextChar(); curr = buff; #ifndef __GUI__ if( CurrChar == '?' ) { PrintUsage( MSG_USAGE_BASE ); StartupErr( "" ); } #endif while( isalnum( CurrChar ) ) { *curr++ = CurrChar; NextChar(); } if( curr == buff ) { if( OptDelim( CurrChar ) ) { NextChar(); SkipSpaces(); break; } OptError( LIT_ENG( STARTUP_No_Recog_Optn ) ); } switch( Lookup( OptNameTab, buff, curr - buff ) ) { case OPT_CONTINUE_UNEXPECTED_BREAK: _SwitchOn( SW_CONTINUE_UNEXPECTED_BREAK ); break; case OPT_DEFERSYM: _SwitchOn( SW_DEFER_SYM_LOAD ); break; case OPT_DOWNLOAD: DownLoadTask = true; break; case OPT_NOEXPORTS: _SwitchOn( SW_NO_EXPORT_SYMS ); break; case OPT_LOCALINFO: if( pass == 2 ) { char *symfile = GetFileName( pass ); FindLocalDebugInfo( symfile ); _Free( symfile ); } break; case OPT_INVOKE: if( pass == 2 ) _Free( InvokeFile ); InvokeFile = GetFileName( pass ); break; case OPT_NOINVOKE: if( pass == 2 ) _Free( InvokeFile ); InvokeFile = NULL; break; case OPT_NOSOURCECHECK: _SwitchOff( SW_CHECK_SOURCE_EXISTS ); break; case OPT_NOSYMBOLS: _SwitchOff( SW_LOAD_SYMS ); break; case OPT_NOMOUSE: _SwitchOff( SW_USE_MOUSE ); break; case OPT_DYNAMIC: mem = GetMemory(); if( pass == 1 ) { if( mem < MIN_MEM_SIZE ) mem = MIN_MEM_SIZE; MemSize = mem; } break; case OPT_DIP: { int i; for( i = 0; DipFiles[i] != NULL; ++i ) ; DipFiles[i] = GetFileName( pass ); } break; case OPT_TRAP: if( pass == 2 ) _Free( TrapParms ); TrapParms = GetFileName( pass ); SkipSpaces(); if( CurrChar == TRAP_PARM_SEPARATOR ) { NextChar(); GetTrapParm( pass ); } else if( CurrChar == '{' ) { GetTrapParm( pass ); } break; #ifdef ENABLE_TRAP_LOGGING case OPT_TRAP_DEBUG_FLUSH: if( pass == 2 ) _Free( TrapTraceFileName ); TrapTraceFileName = GetFileName( pass ); TrapTraceFileFlush = true; break; case OPT_TRAP_DEBUG: if( pass == 2 ) _Free( TrapTraceFileName ); TrapTraceFileName = GetFileName( pass ); TrapTraceFileFlush = false; break; #endif case OPT_REMOTE_FILES: _SwitchOn( SW_REMOTE_FILES ); break; case OPT_LINES: DUISetNumLines( GetValue() ); break; case OPT_COLUMNS: DUISetNumColumns( GetValue() ); break; #ifdef BACKWARDS case OPT_NO_FPU: case OPT_NO_ALTSYM: break; case OPT_REGISTERS: GetValue(); break; #endif case OPT_INITCMD: GetInitCmd( pass ); break; case OPT_POWERBUILDER: _SwitchOn( SW_POWERBUILDER ); break; case OPT_HELP: #ifndef __GUI__ PrintUsage( MSG_USAGE_BASE ); StartupErr( "" ); #endif break; default: if( !ProcSysOption( buff, curr - buff, pass ) && !DUIScreenOption( buff, curr - buff, pass ) ) { Format( err_buff, LIT_ENG( STARTUP_Invalid_Option ), buff, curr - buff ); StartupErr( err_buff ); } break; } } }
unsigned ExecProg( bool tracing, bool do_flip, bool want_wps ) { bool have_brk_at_ip; bool act_wps; bool first_time; mad_trace_how how; execute_state es; unsigned conditions; unsigned run_conditions; bool already_stopping; bool force_stop; if( !want_wps ) ++InCall; tracing = TraceStart( tracing ); WriteDbgRegs(); first_time = true; es = ES_NORMAL; run_conditions = 0; if( !HaveRemoteAsync() ) { DUIPlayDead( true ); } how = MTRH_STOP; for( ;; ) { switch( es ) { case ES_FORCE_BREAK: case ES_NORMAL: if( tracing ) { how = TraceHow( false ); } else { _SwitchOn( SW_EXECUTE_LONG ); how = MTRH_BREAK; } break; case ES_STEP_ONE: how = TraceHow( true ); break; } if( how == MTRH_STOP ) break; switch( how ) { case MTRH_BREAK: DbgUpdate( UP_CSIP_JUMPED ); _SwitchOn( SW_TOUCH_SCREEN_BUFF ); /* fall through */ case MTRH_SIMULATE: case MTRH_STEP: case MTRH_STEPBREAK: if( _IsOff( SW_TOUCH_SCREEN_BUFF ) ) break; /* fall through */ default: if( !(ScrnState & USR_SCRN_ACTIVE) && do_flip ) { DUIStop(); } _SwitchOff( SW_TOUCH_SCREEN_BUFF ); break; } if( first_time ) { /* got to be down here so that SW_EXECUTE_LONG is properly set */ SetThreadStates(); first_time = false; } have_brk_at_ip = InsertBPs( (es == ES_FORCE_BREAK) ); act_wps = UpdateWPs(); if( how == MTRH_BREAK ) { if( have_brk_at_ip ) { es = ES_STEP_ONE; RemoveBPs(); continue; /* back to top */ } if( act_wps && want_wps ) { InsertWPs(); } } SetMemBefore( tracing ); switch( how ) { case MTRH_SIMULATE: if( TraceSimulate() ) { conditions = COND_TRACE; break; } /* fall through */ case MTRH_STEP: /* only updates stack/execution */ conditions = DoRun( true ); break; default: /* only updates stack/execution */ conditions = DoRun( false ); break; } if( _IsOn( SW_EXECUTE_LONG ) ) { if( ScrnState & DBG_SCRN_ACTIVE ) { _SwitchOn( SW_MIGHT_HAVE_LOST_DISPLAY ); } _SwitchOff( SW_EXECUTE_LONG ); } SetMemAfter( tracing ); run_conditions &= ~COND_WATCH; run_conditions |= conditions; RemoveBPs(); if( conditions & COND_MESSAGE ) { if( !RecordMsgText( &conditions ) ) { conditions &= ~COND_MESSAGE; } } conditions = CheckBPs( conditions, run_conditions ); if( _IsOn( SW_BREAK_ON_DEBUG_MESSAGE ) && ( conditions & COND_MESSAGE ) ) { conditions |= COND_STOP; } if( HaveRemoteAsync() && (conditions & COND_THREAD ) ) { conditions |= COND_STOP; } if( how == MTRH_STEPBREAK && (conditions & COND_BREAK) && DbgTmpBrk.status.b.hit ) { conditions &= ~COND_BREAK; conditions |= COND_TRACE; } if( conditions & COND_LIBRARIES ) { already_stopping = ( conditions & COND_STOPPERS ) != 0; conditions &= ~COND_LIBRARIES; force_stop = false; if( AddLibInfo( already_stopping, &force_stop ) ) { if( force_stop || DLLMatch() ) { conditions |= COND_STOP | COND_LIBRARIES; } } ReMapPoints( NULL ); } if( conditions & COND_SECTIONS ) { SectTblRead( DbgRegs ); InvalidateTblCache(); } if( (es == ES_STEP_ONE) && (conditions & COND_TRACE) ) { conditions &= ~COND_TRACE; } if( tracing ) { conditions = TraceCheck( conditions ); } if( !(conditions & COND_STOPPERS) && TBreak() ) { conditions |= COND_USER; break; } if( conditions & COND_STOPPERS ) break; switch( es ) { case ES_STEP_ONE: es = ES_FORCE_BREAK; break; case ES_FORCE_BREAK: es = ES_NORMAL; break; } if( (run_conditions & COND_WATCH) && es == ES_NORMAL ) { /* We got a spurious watch point indication. Make the next instruction single step since we might be dealing with a control flow opcode on a machine without a T-bit (e.g. Alpha). */ es = ES_STEP_ONE; } } TraceStop( tracing ); DUIPlayDead( false ); SetProgState( run_conditions ); _SwitchOff( SW_KNOW_EMULATOR ); if( !want_wps ) --InCall; return( conditions ); }
void DoProcPending( void ) { while( ProcPending() ) ; _SwitchOn( SW_CMD_INTERACTIVE ); _SwitchOff( SW_IN_REPLAY_MODE ); }
void Error( dbg_err_flags flg, char *fmt, ... ) { char buff[TXT_LEN]; va_list args; char *ptr; invokes *inv; input_stack *inp; char *where; bool cmderror; va_start( args, fmt ); ptr = buff; if( flg & ERR_INTERNAL ) { ptr = StrCopy( LIT_ENG( Internal_Error ), ptr ); } ptr = FmtStr( ptr, fmt, args ); ptr = StrCopy( ".", ptr ); if( flg & ERR_LOC ) { ptr = StrCopy( "\n ", ptr ); switch( CurrToken ) { case T_CMD_SEPARATOR: ptr = StrCopy( LIT_ENG( ERR_NEAR_END_OF_COMMAND ), ptr ); break; case T_LINE_SEPARATOR: ptr = StrCopy( LIT_ENG( ERR_NEAR_END_OF_LINE ), ptr ); break; default: if( ScanLen() == 0 ) Scan(); ptr = Format( ptr, LIT_ENG( ERR_NEAR_TOKEN ), ScanPos(), ScanLen() ); break; } } SetProgStartHook( TRUE ); UnFreezeRegs(); ScanExpr( NULL ); ExprPurge(); PurgeSymHandles(); /* must be done after ExprPurge */ DIPCancel(); ScanSavePtr = 0; /* clean up previous ScanSave locations */ if( _IsOff( SW_ERROR_PRESERVES_RADIX ) ) { RestoreRadix(); } _SwitchOff( SW_CALL_FATAL ); if( _IsOn( SW_ERROR_STARTUP ) ) { StartupErr( buff ); } if( _IsOn( SW_ERR_IN_TXTBUFF ) ) { PurgeInpStack(); StrCopy( buff, TxtBuff ); DUIArrowCursor(); Suicide(); } if( (flg & ERR_SILENT) == 0 ) { where = LIT_ENG( ERR_EXECUTING_AT ); for( inp = InpStack; inp != NULL; inp = inp->link ) { if( inp->type & INP_CMD_FILE ) { inv = inp->handle; ptr = StrCopy( "\n ", ptr ); ptr = Format( ptr, where, inv->line, inv->name ); where = LIT_ENG( ERR_CALLED_FROM ); } } DUIFlushKeys(); DUIWndDebug(); RingBell(); DUIErrorBox( buff ); } cmderror = FALSE; for( inp = InpStack; inp != NULL; inp = inp->link ) { if( inp->type & INP_BREAK_POINT ) { BrkCmdError(); } if( inp->type & INP_CAPTURED ) { CaptureError(); } if( inp->type & INP_DLG_CMD ) { cmderror = TRUE; } } PurgeInpStack(); if( cmderror && fmt != LIT_ENG( ERR_DBG_INTERRUPT ) ) { DlgCmd(); ProcInput(); } if( _IsOn( SW_ERROR_RETURNS ) ) return; DUIArrowCursor(); Suicide(); }
unsigned CheckBPs( unsigned conditions, unsigned run_conditions ) { brkp *bp; item_mach item; bool hit, bphit, wphit; bool state_set; mad_type_info mti; wphit = false; state_set = false; bphit = false; for( bp = BrkList; bp != NULL; bp = bp->next ) { if( !bp->status.b.active ) continue; hit = false; if( IS_BP_EXECUTE( bp->th ) ) { if( HaveHitBP( bp ) ) { hit = true; } } else { if( SectIsLoaded( bp->loc.addr.sect_id, OVL_MAP_EXE ) ) { MADTypeInfo( bp->th, &mti ); if( ItemGetMAD( &bp->loc.addr, &item, IT_NIL, bp->th ) ) { /* * If the breakpoint fires here because of a write, but the value hasn't changed then * the breakpoint does not fire off!!!! The SupportsExactBreakpoints actually enables * break on write, not break on change and allocates the exact data space - not plus * or minus a few bytes... * */ if( _IsOn( SW_BREAK_ON_WRITE ) && IsExactBreakpointsSupported() ) { bool drop_hit = false; if( ( UserTmpBrk.status.b.active ) || ( DbgTmpBrk.status.b.active ) ) { if( HaveHitBP( &UserTmpBrk ) ) { drop_hit = true; } if( HaveHitBP( &DbgTmpBrk ) ) { drop_hit = true; } if( ! ( conditions & ( COND_BREAK | COND_WATCH | COND_TRACE | COND_USER | COND_EXCEPTION | COND_STOP ) ) ) { drop_hit = true; } } if( !drop_hit ) hit = true; } else { if( ( memcmp( &bp->item, &item, mti.b.bits / BITS_PER_BYTE ) != 0 ) || !bp->status.b.has_value ) { hit = true; } } } else if( bp->status.b.has_value ) { if( conditions & ( COND_BREAK | COND_WATCH | COND_TRACE | COND_USER | COND_EXCEPTION | COND_STOP ) ) { hit = true; } } } } if( hit ) { bp->total_hits++; } if( hit && bp->condition != NULL && bp->status.b.use_condition ) { _SwitchOn( SW_ERR_IN_TXTBUFF ); if( !state_set ) { /* gets all the registers updated */ SetProgState( run_conditions ); state_set = true; } if( SpawnP( TestExpression, bp ) == 0 ) { if( !bp->status.b.expr_true ) { hit = false; } else { bp->status.b.expr_true = false; } } else { bp->status.b.expr_error = true; bp->error = DupStr( TxtBuff ); hit = true; } _SwitchOff( SW_ERR_IN_TXTBUFF ); } if( hit && bp->status.b.use_countdown && bp->countdown != 0 && !bp->status.b.expr_error ) { if( --bp->countdown != 0 ) { hit = false; } } if( hit ) { if( IS_BP_EXECUTE( bp->th ) ) { bphit = true; } else { wphit = true; } bp->status.b.hit = true; } } if( state_set ) { /* we might have changed a register in eval'ing conditions */ WriteDbgRegs(); } if( HaveHitBP( &UserTmpBrk ) ) { bphit = true; UserTmpBrk.status.b.hit = true; } if( HaveHitBP( &DbgTmpBrk ) ) { bphit = true; DbgTmpBrk.status.b.hit = true; } if( bphit ) return( COND_BREAK | ( conditions & ~COND_STOPPERS ) ); if( wphit ) return( COND_WATCH | ( conditions & ~COND_STOPPERS ) ); if( conditions & COND_BREAK ) { unsigned max = TXT_LEN; ReadDbgRegs(); if( MADUnexpectedBreak( &DbgRegs->mr, TxtBuff, &max ) == MS_OK ) { WriteDbgRegs(); if( max == 0 ) { conditions &= ~COND_STOPPERS; if( _IsOff( SW_CONTINUE_UNEXPECTED_BREAK ) ) { conditions |= COND_TRACE; } return( conditions ); } else if( SetMsgText( TxtBuff, &conditions ) ) { DUIMsgBox( TxtBuff ); return( COND_TRACE | COND_MESSAGE | ( conditions & ~COND_STOPPERS ) ); } else { return( conditions & ~COND_STOPPERS ); } } else { return( conditions & ~COND_STOPPERS ); } } else if( conditions & COND_WATCH ) { return( conditions & ~COND_STOPPERS ); } return( conditions ); }
void InitTrap( char *trap_file ) { mx_entry in[1]; mx_entry out[2]; connect_req in_mx; connect_ret out_mx; char *error; trap_version ver; char buff[ TXT_LEN ]; #ifdef ENABLE_TRAP_LOGGING if( TrpDebugFile ) OpenTrapTraceFile( TrpDebugFile, TrpDebugFileFlush ); #endif /* Don't use TxtBuff except for error -- it may have a Finger message in it */ #if !defined( BUILD_RFX ) TrapSetFailCallBack( TrapFailed ); #endif InitTrapError = FALSE; RestoreHandlers(); ver.remote = FALSE; #if !defined( BUILD_RFX ) if( stricmp( trap_file, "dumb" ) == 0 ) { error = LoadDumbTrap( &ver ); } else { #endif error = LoadTrap( trap_file, buff, &ver ); #if !defined( BUILD_RFX ) } #endif GrabHandlers(); if( error != NULL ) { strcpy( buff, error ); InitTrapError = TRUE; StartupErr( buff ); } in_mx.req = REQ_CONNECT; in_mx.ver.major = TRAP_MAJOR_VERSION; in_mx.ver.minor = TRAP_MINOR_VERSION; in_mx.ver.remote = FALSE; in[0].ptr = &in_mx; in[0].len = sizeof( in_mx ); out[0].ptr = &out_mx; out[0].len = sizeof( out_mx ); buff[0] = '\0'; out[1].ptr = buff; out[1].len = MAX_ERR_MSG_SIZE; TrapAccess( 1, in, 2, out ); MaxPacketLen = out_mx.max_msg_size; if( buff[0] != '\0' ) { KillTrap(); InitTrapError = TRUE; StartupErr( buff ); } #if !defined( BUILD_RFX ) if( !InitTrapError ) { InitSuppServices(); } #endif if( ver.remote ) { _SwitchOn( SW_REMOTE_LINK ); } else { _SwitchOff( SW_REMOTE_LINK ); } }