static void fillThreadInfo( HWND hwnd, ProcStats *info ) {
HWND lb;
int index;
char buf[100];
DWORD threadid;
ThreadStats thdinfo;
#ifndef CHICAGO
char *str1;
#endif
lb = GetDlgItem( hwnd, THREAD_LIST );
index = (int)SendMessage( lb, LB_GETCURSEL, 0, 0L );
if( index == LB_ERR ) {
SetDlgItemText( hwnd, THREAD_TID, "" );
SetDlgItemText( hwnd, THREAD_SUSPEND_CNT, "" );
SetDlgItemText( hwnd, THREAD_PRIORITY, "" );
} else {
enableChoices( hwnd, TRUE );
SendMessage( lb, LB_GETTEXT, index, (LPARAM)(LPSTR)buf );
threadid = getThreadId( buf );
sprintf( buf, "tid = %08lX", threadid );
SetDlgItemText( hwnd, THREAD_TID, buf );
if( GetThreadInfo( info->pid, threadid, &thdinfo ) ) {
#ifndef CHICAGO
if( thdinfo.state == 5 ) { /* the thread is in a wait state */
str1 = SrchMsg( thdinfo.wait_reason, ThreadWaitMsgs, NULL );
if( str1 == NULL ) {
str1 = AllocRCString( STR_WAIT_4_UNKNOWN );
RCsprintf( buf, STR_STATE, str1 );
FreeRCString( str1 );
} else {
RCsprintf( buf, STR_STATE, str1 );
}
} else {
str1 = SrchMsg( thdinfo.state, ThreadStateMsgs, NULL );
if( str1 == NULL ) {
str1 = AllocRCString( STR_BRACED_UNKNOWN );
RCsprintf( buf, STR_STATE, str1 );
FreeRCString( str1 );
} else {
RCsprintf( buf, STR_STATE, str1 );
}
}
SetDlgItemText( hwnd, THREAD_SUSPEND_CNT, buf );
#endif
/* get priority */
RCsprintf( buf, STR_PRIORITY_X, thdinfo.cur_pri,
thdinfo.base_pri );
SetDlgItemText( hwnd, THREAD_PRIORITY, buf );
}
}
}
/*
* AppDebuggerErrMsg
*/
void AppDebuggerErrMsg( void *_info ) {
ProcAttatchInfo *info = _info;
char buf[100];
ProcStats stats;
if( GetProcessInfo( info->info.pid, &stats ) ) {
RCsprintf( buf, STR_CANT_DEBUG_PROC_X_NAME, info->info.pid,
stats.name );
} else {
RCsprintf( buf, STR_CANT_DEBUG_PROC_X, info->info.pid );
}
MessageBox( MainHwnd, buf, AppName,
MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND );
}
/*
* ProcessIncomingMessage - get a string associated with a message id
*/
void ProcessIncomingMessage( int msgid, char *class_name, char *res )
{
message *msg;
char *fmtstr;
char buf[256];
res[0] = 0;
msg = GetMessageDataFromID( msgid, class_name );
if( msg != NULL ) {
if( msg->bits[M_WATCH] ) {
strcpy( res, msg->str );
}
if( msg->bits[M_STOPON] ) {
SetSpyState( OFF );
RCsprintf( buf, STR_SPYING_STOPPED, msg->str );
MessageBox( SpyMainWindow, buf, SpyName,
MB_OK | MB_ICONINFORMATION );
}
msg->count++;
} else if( msgid > WM_USER ) {
userMsg->count++;
if( userMsg->bits[M_WATCH] ) {
fmtstr = GetRCString( STR_WM_USER_PLUS );
sprintf( res, fmtstr, msgid - WM_USER );
}
if( userMsg->bits[M_STOPON] ) {
SetSpyState( OFF );
fmtstr = GetRCString( STR_WM_USER_PLUS );
sprintf( res, fmtstr, msgid - WM_USER );
RCsprintf( buf, STR_SPYING_STOPPED, res );
MessageBox( SpyMainWindow, buf, SpyName,
MB_OK | MB_ICONINFORMATION );
}
} else {
if( Filters[MC_UNKNOWN].flag[M_WATCH] ) {
fmtstr = GetRCString( STR_UNKNOWN_MSG );
sprintf( res, fmtstr, msgid );
}
if( Filters[MC_UNKNOWN].flag[M_STOPON] ) {
SetSpyState( OFF );
fmtstr = GetRCString( STR_UNKNOWN_MSG );
RCsprintf( buf, STR_SPYING_STOPPED, res );
MessageBox( SpyMainWindow, buf, SpyName,
MB_OK | MB_ICONINFORMATION );
}
}
} /* ProcessIncomingMessage */
/*
* MakeLog - make the log file
*/
void MakeLog( ExceptDlgInfo *faultinfo )
{
bool wasfault;
wasfault = ( faultinfo != NULL );
RefreshCostlyInfo();
if( startLogFile() ) {
char err_buf[ _MAX_PATH + 100 ];
RCsprintf( err_buf, STR_CANT_OPEN_LOG, LogData.logname );
MessageBox( NULL, err_buf, AppName, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND );
return;
}
logSysInfo( wasfault );
notesAdded = FALSE;
if( LogData.query_notes ) {
AnotateLog( MainHwnd, Instance, NotePrint );
}
if( wasfault ) {
logFaultInfo( faultinfo );
}
if( LogData.log_process ) {
logProcessList();
}
logStrPrintf( logLine );
finishLogFile();
}
void BeginMonitor( heap_list *item ) {
HWND hwnd;
char title[50];
int width;
int hight;
LocalMonInfo *info;
WORD i;
char *msgtitle;
if( !LabelsInitialized ) {
MonitorLabels[ STATIC_SIZE ] = HWGetRCString( STR_STATIC_DATA );
MonitorLabels[ STACK_SIZE ] = HWGetRCString( STR_STACK_ALLOCATED );
MonitorLabels[ FIXED_SIZE ] = HWGetRCString( STR_FIXED_HEAP );
MonitorLabels[ MOVE_SIZE ] = HWGetRCString( STR_MOVEABLE_HEAP );
MonitorLabels[ FREE_SIZE ] = HWGetRCString( STR_FREE_HEAP );
MonitorLabels[ OTHER_SIZE ] = HWGetRCString( STR_MONITOR_UNKNOWN );
LabelsInitialized = TRUE;
}
if( Brushes.use_cnt == 0 ) {
for( i=0; i < SIZE_CNT; i++ ) {
Brushes.brush[i] = CreateSolidBrush( BarColors[i] );
}
}
Brushes.use_cnt++;
width = GetSystemMetrics( SM_CXSCREEN );
hight = GetSystemMetrics( SM_CYSCREEN );
RCsprintf( title, STR_LCL_MONITOR_TITLE, item->szModule );
info = MemAlloc( sizeof( LocalMonInfo ) );
memset( info, 0, sizeof( LocalMonInfo ) );
info->instance = item->info.ge.hBlock;
info->task_hdl = GetTaskHdl( info->instance );
info->total_size = item->info.ge.dwBlockSize;
info->handle = item->info.ge.hBlock;
hwnd = CreateWindow(
LOCAL_MONITOR_CLASS, /* Window class name */
title, /* Window caption */
WS_OVERLAPPED|WS_CAPTION
|WS_SYSMENU|WS_THICKFRAME
|WS_MAXIMIZEBOX, /* Window style */
width/12, /* Initial X position */
hight/4, /* Initial Y position */
5*width/6, /* Initial X size */
hight/2, /* Initial Y size */
HeapWalkMainWindow, /* Parent window handle */
NULL, /* Window menu handle */
Instance, /* Program instance handle */
info ); /* Create parameters */
if( hwnd == NULL ) {
msgtitle = HWAllocRCString( STR_MONITOR_LCL_HEAP );
RCMessageBox( NULL, STR_CANT_OPEN_LCL_MONITOR, HeapWalkName,
MB_OK | MB_TASKMODAL | MB_ICONINFORMATION );
HWFreeRCString( msgtitle );
}
ShowWindow( hwnd, SW_SHOWNORMAL );
UpdateWindow( hwnd );
}
/*
* ThreadCtlProc
*/
INT_PTR CALLBACK RetCodeDlgProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
RetCodeInfo *info;
WORD cmd;
char buf[BUF_SIZE];
char *title;
msg_id info_str_id;
bool ret;
ret = false;
info = (RetCodeInfo *)GET_DLGDATA( hwnd );
switch( msg ) {
case WM_INITDIALOG:
info = (RetCodeInfo *)lparam;
info->really_kill = FALSE;
SET_DLGDATA( hwnd, lparam );
if( info->type == RETCD_THREAD ) {
title = AllocRCString( STR_THREAD_RETURN_CODE );
info_str_id = STR_THREAD_X;
} else {
title = AllocRCString( STR_PROCESS_RETURN_CODE );
info_str_id = STR_PROCESS_X;
}
SetWindowText( hwnd, title );
FreeRCString( title );
RCsprintf( buf, info_str_id, info->type, info->id );
SetDlgItemText( hwnd, RET_PROC_INFO, buf );
SetDlgItemText( hwnd, RET_VALUE, "-1" );
ret = true;
break;
case WM_COMMAND:
cmd = LOWORD( wparam );
switch( cmd ) {
case IDOK:
GetDlgItemText( hwnd, RET_VALUE, buf, BUF_SIZE );
if( !ParseNumeric( buf, TRUE, &info->rc ) ) {
RCMessageBox( hwnd, STR_INVALID_RETURN_CODE,
AppName, MB_OK | MB_ICONEXCLAMATION );
break;
}
info->really_kill = TRUE;
SendMessage( hwnd, WM_CLOSE, 0, 0L );
break;
case IDCANCEL:
SendMessage( hwnd, WM_CLOSE, 0, 0L );
break;
}
ret = true;
break;
case WM_CLOSE:
EndDialog( hwnd, 0 );
ret = true;
break;
}
return( ret );
}
/*
* ViewLog
*/
void ViewLog( void ) {
char buf[ MAX_CMDLINE + _MAX_PATH ];
BOOL ret;
STARTUPINFO startinfo;
PROCESS_INFORMATION procinfo;
if( access( LogData.logname, R_OK ) ) {
RCsprintf( buf, STR_CANT_OPEN_LOG_FILE, LogData.logname );
MessageBox( MainHwnd, buf, AppName,
MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND );
return;
}
memset( &startinfo, 0, sizeof( STARTUPINFO ) );
startinfo.cb = sizeof( STARTUPINFO );
strcpy( buf, LogData.editor );
strcat( buf, " " );
strcat( buf, LogData.editor_cmdline );
strcat( buf, " " );
strcat( buf, LogData.logname );
ret = CreateProcess( NULL, /* application path */
buf, /* command line */
NULL, /* process security
attributes */
NULL, /* main thread security
attributes */
FALSE, /* inherits parent handles */
NORMAL_PRIORITY_CLASS, /* create parameters */
NULL, /* environment block */
NULL, /* current directory */
&startinfo, /* other startup info */
&procinfo ); /* structure to get process
info */
if( ret ) return;
strcpy( buf, "notepad.exe" );
strcat( buf, " " );
strcat( buf, LogData.logname );
ret = CreateProcess( NULL, /* application path */
buf, /* command line */
NULL, /* process security
attributes */
NULL, /* main thread security
attributes */
FALSE, /* inherits parent handles */
NORMAL_PRIORITY_CLASS, /* create parameters */
NULL, /* environment block */
NULL, /* current directory */
&startinfo, /* other startup info */
&procinfo ); /* structure to get process
info */
if( !ret ) {
RCMessageBox( MainHwnd, STR_CANT_START_EDITOR,
AppName, MB_OK | MB_ICONEXCLAMATION );
}
}
/*
* EraseLog
*/
void EraseLog( void ) {
char buf[500];
int ret;
RCsprintf( buf, STR_ERASE_LOG_FILE, LogData.logname );
ret = MessageBox( NULL, buf, AppName, MB_YESNO | MB_ICONQUESTION );
if( ret == IDYES ) {
remove( LogData.logname );
ignoreLogChecks = FALSE;
}
}
/*
* FormatException
*/
void FormatException( char *buf, DWORD code ) {
char *str;
str = SrchMsg( code, ExceptionMsgs, NULL );
if( str == NULL ) {
str = buf;
RCsprintf( buf, STR_UNKNOWN_EXCEPTION_X, code );
} else {
strcpy( buf, str );
}
}
static BOOL readLogOptions( HWND hwnd, char *buf ) {
DWORD asm_lines;
DWORD asm_bkup;
DWORD max_fsize;
char numhelp[NUM_HELP_SIZE];
CopyRCString( STR_FIELD_MUST_BE_NUMERIC, numhelp, NUM_HELP_SIZE );
GetDlgItemText( hwnd, LOG_MAXFL, buf, BUF_SIZE );
if( !ParseNumeric( buf, FALSE, &max_fsize ) ) {
RCsprintf( buf, STR_MAX_LOG_FILE_SIZE_INV, numhelp );
MessageBox( hwnd, buf, AppName, MB_OK | MB_ICONEXCLAMATION );
return( FALSE );
}
GetDlgItemText( hwnd, LOG_DISASM_LINES, buf, BUF_SIZE );
if( !ParseNumeric( buf, FALSE, &asm_lines ) ) {
RCsprintf( buf, STR_DISASM_LINES_INVALID, numhelp );
MessageBox( hwnd, buf, AppName, MB_OK | MB_ICONEXCLAMATION );
return( FALSE );
}
GetDlgItemText( hwnd, LOG_DISASM_BACKUP, buf, BUF_SIZE );
if( !ParseNumeric( buf, FALSE, &asm_bkup ) ) {
RCsprintf( buf, STR_DISASM_BKUP_INVALID, numhelp );
MessageBox( hwnd, buf, AppName, MB_OK | MB_ICONEXCLAMATION );
return( FALSE );
}
GetDlgItemText( hwnd, LOG_FILE_NAME, LogData.logname, BUF_SIZE );
GetDlgItemText( hwnd, LOG_VIEWER, LogData.editor, BUF_SIZE );
LogData.asm_cnt = asm_lines;
LogData.asm_bkup = asm_bkup;
LogData.max_flen = max_fsize;
LogData.log_process = IsDlgButtonChecked( hwnd, LOG_TASKS );
LogData.log_stacktrace = IsDlgButtonChecked( hwnd, LOG_STACK_TRACE );
LogData.log_mem_manager = IsDlgButtonChecked( hwnd, LOG_MEM );
LogData.log_mem_dmp = IsDlgButtonChecked( hwnd, LOG_MEM_DMP );
LogData.query_notes = IsDlgButtonChecked( hwnd, LOG_QUERY_NOTES );
LogData.autolog = IsDlgButtonChecked( hwnd, LOG_AUTOLOG );
LogData.log_modules = IsDlgButtonChecked( hwnd, LOG_LOADED_MODULES );
return( TRUE );
}
BOOL CALLBACK QueryEndDlgProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
WORD cmd;
char buf[100];
HWND lb;
ProcNode *procinfo;
ProcStats procstat;
lparam = lparam;
switch( msg ) {
case WM_INITDIALOG:
lb = GetDlgItem( hwnd, END_LIST );
procinfo = GetNextOwnedProc( NULL );
while( procinfo != NULL ) {
if( GetProcessInfo( procinfo->procid, &procstat ) ) {
RCsprintf( buf, STR_PROCESS_X_NAME, procinfo->procid,
procstat.name );
} else {
RCsprintf( buf, STR_PROCESS_X, procinfo->procid );
}
SendMessage( lb, LB_ADDSTRING, 0, (LPARAM)buf );
procinfo = GetNextOwnedProc( procinfo );
}
break;
case WM_COMMAND:
cmd = LOWORD( wparam );
switch( cmd ) {
case END_YES:
case END_NO:
EndDialog( hwnd, cmd );
break;
}
break;
default:
return( FALSE );
}
return( TRUE );
}
/*
* ReportSave
*/
void ReportSave( HWND parent, char *fname, char *appname, BOOL save_ok )
{
char ful_fname[_MAX_PATH];
char buf[_MAX_PATH + 20];
if( save_ok ) {
relToAbs( fname, ful_fname );
RCsprintf( buf, SLB_DATA_SAVED_TO, ful_fname );
MessageBox( parent, buf, appname, MB_OK | MB_TASKMODAL );
} else {
RCMessageBox( parent, SLB_CANT_SAVE_DATA, appname,
MB_OK | MB_TASKMODAL | MB_ICONEXCLAMATION );
}
} /* ReportSave */
/*
* CheckLogSize
*/
void CheckLogSize( void ) {
struct stat st;
char buf[100];
int ret;
/* if the user has already said they don't want to delete a large log
* file don't keep asking */
if( ignoreLogChecks ) return;
if( stat( LogData.logname, &st ) == -1 ) return;
if( st.st_size > LogData.max_flen ) {
RCsprintf( buf, STR_DEL_BIG_LOG_FILE, st.st_size );
ret = MessageBox( NULL, buf, AppName,
MB_YESNO | MB_SETFOREGROUND | MB_ICONQUESTION );
if( ret == IDYES ) {
remove( LogData.logname );
} else {
ignoreLogChecks = TRUE;
}
}
}
/*
* LogHeader
*/
void LogHeader( int f )
{
char buf[100];
unsigned i;
time_t tm;
tm = time( NULL );
for( i = 0; i < 80; i++ ) {
buf[i] = '-';
}
buf[i] = '\0';
write( f, buf, strlen( buf ) );
write( f, "\r\n", 2 );
RCsprintf( buf, STR_LOG_HEADER, asctime( localtime( &tm ) ) );
write( f, buf, strlen( buf ) );
write( f, "\r\n", 2 );
for( i = 0; i < 80; i++ ) {
buf[i] = '-';
}
buf[i] = '\0';
write( f, buf, strlen( buf ) );
write( f, "\r\n", 2 );
} /* LogHeader */
static void fillExceptionDlg( HWND hwnd, ExceptDlgInfo *info ) {
char buf[BUF_SIZE];
char fname[ FNAME_BUFLEN ];
DWORD line;
ProcStats stats;
HWND ctl;
address addr;
GetCurrAddr(&addr,info->regs);
SetDlgCourierFont( hwnd, INT_TASK_NAME );
SetDlgCourierFont( hwnd, INT_TASK_PATH );
SetDlgCourierFont( hwnd, INT_FAULT_TYPE );
SetDlgCourierFont( hwnd, INT_CS_IP );
SetDlgCourierFont( hwnd, INT_SOURCE_INFO );
SetDlgCourierFont( hwnd, INT_SOURCE_INFO2 );
RCsprintf( buf, STR_EXCEPTION_ENCOUNTERED, AppName );
SetWindowText( hwnd, buf );
CopyRCString( STR_PROCESS_NAME, buf, BUF_SIZE );
SetDlgItemText( hwnd, INT_TASK_NAME_TEXT, buf );
if( !info->dbinfo->u.Exception.dwFirstChance ) {
if( ConfigData.exception_action == INT_CHAIN_TO_NEXT ) {
ConfigData.exception_action = INT_TERMINATE;
}
ctl = GetDlgItem( hwnd, INT_CHAIN_TO_NEXT );
EnableWindow( ctl, FALSE );
}
CheckDlgButton( hwnd, ConfigData.exception_action, BST_CHECKED );
CopyRCString( STR_PROCESS_ID, buf, BUF_SIZE );
SetDlgItemText( hwnd, INT_TASK_PATH_TEXT, buf );
while( !GetProcessInfo( info->procinfo->procid, &stats ) ) {
Sleep( 100 );
RefreshInfo();
}
SetDlgItemText( hwnd, INT_TASK_NAME, stats.name );
sprintf( buf, "%08lX", info->procinfo->procid );
SetDlgItemText( hwnd, INT_TASK_PATH, buf );
FormatException( buf, info->dbinfo->u.Exception.ExceptionRecord.ExceptionCode );
SetDlgItemText( hwnd, INT_FAULT_TYPE, buf );
if( info->threadinfo != NULL ) {
strcpy( buf, "Fault " );
MADRegSpecialName( MSR_IP, info->regs, MAF_FULL, BUF_SIZE - 7, buf+6 );
SetDlgItemText( hwnd, INT_IP_NAME, buf );
SetIp( hwnd, &addr );
}
if( info->got_dbginfo && GetLineNum( &addr,fname, FNAME_BUFLEN, &line ) ) {
RCsprintf( buf, STR_LINE_X_OF, line );
SetDlgItemText( hwnd, INT_SOURCE_INFO, buf );
SetDlgItemText( hwnd, INT_SOURCE_INFO2, fname );
} else {
CopyRCString( STR_N_A, buf, BUF_SIZE );
SetDlgItemText( hwnd, INT_SOURCE_INFO, buf );
SetDlgItemText( hwnd, INT_SOURCE_INFO2, "" );
}
}
/*
* AliasDlgProc - alias list dialog procedure
*/
INT_PTR CALLBACK AliasDlgProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
AnAlias *cur;
size_t len;
char buf[CONST_LEN];
char msgbuf[256];
int sel;
char *endptr;
char *realend;
char *alias;
long id;
WORD cmd;
switch( msg ) {
case WM_INITDIALOG:
if( (char *)lparam != NULL ) {
SetWindowText( hwnd, (char *)lparam );
}
SendDlgItemMessage( hwnd, ALIAS_TEXT, EM_LIMITTEXT, 20, 0 );
for( cur = CurHdl->data; cur != NULL; cur = cur->next ) {
sprintf( buf, "0x%08lX", cur->id );
SendDlgItemMessage( hwnd, ALIAS_ID_LIST, LB_ADDSTRING, 0, (LPARAM)buf );
}
break;
#ifndef NOUSE3D
case WM_SYSCOLORCHANGE:
CvrCtl3dColorChange();
break;
#endif
case WM_COMMAND:
cmd = LOWORD( wparam );
switch( cmd ) {
case IDOK:
case ALIAS_DO_MORE:
SendDlgItemMessage( hwnd, ALIAS_CUR_ID, WM_GETTEXT, CONST_LEN, (LPARAM)buf );
realend = buf;
while( *realend != '\0' ) {
realend++;
}
realend--;
while( isspace( *realend ) ) {
realend--;
}
realend++;
id = strtol( buf, &endptr, 0 );
if( endptr != realend || *buf == '\0' ) {
RCMessageBox( hwnd, ALIAS_VALUE_MUST_BE_INT, "", MB_OK );
break;
}
len = SendDlgItemMessage( hwnd, ALIAS_TEXT, WM_GETTEXTLENGTH, 0, 0 );
alias = MemAlloc( len + 1 );
len = SendDlgItemMessage( hwnd, ALIAS_TEXT, WM_GETTEXT, len + 1, (LPARAM)alias );
/* check for spaces */
endptr = alias;
while( !isspace( *endptr ) && *endptr != '\0' ) {
endptr++;
}
realend = endptr;
while( isspace( *endptr ) ) {
endptr++;
}
if( *endptr != '\0' ) {
RCMessageBox( hwnd, ALIAS_NO_SPACES_ALLOWED, "", MB_OK );
MemFree( alias );
break;
}
realend = '\0'; /* truncate trailing spaces */
cur = findAliasFromText( CurHdl, alias );
if( cur == NULL ) {
AddAlias( CurHdl, alias, id );
} else {
RCsprintf( msgbuf, ALIAS_NO_DUPLICATES_ALLOWED, alias, cur->id );
MessageBox( hwnd, msgbuf, "", MB_OK );
MemFree( alias );
break;
}
MemFree( alias );
EndDialog( hwnd, cmd );
break;
case IDCANCEL:
EndDialog( hwnd, cmd );
break;
case ALIAS_ID_LIST:
if( GET_WM_COMMAND_CMD( wparam, lparam ) == LBN_SELCHANGE ) {
sel = (int)SendDlgItemMessage( hwnd, ALIAS_ID_LIST, LB_GETCURSEL, 0, 0L );
SendDlgItemMessage( hwnd, ALIAS_ID_LIST, LB_GETTEXT, sel, (LPARAM)buf );
SendDlgItemMessage( hwnd, ALIAS_CUR_ID, WM_SETTEXT, 0, (LPARAM)buf );
cur = getIthAlias( CurHdl, sel );
SendDlgItemMessage( hwnd, ALIAS_TEXT, WM_SETTEXT, 0, (LPARAM)cur->name );
}
break;
default:
return( FALSE );
}
default:
return( FALSE );
}
return( TRUE );
}
/*
* GetProfileInfo - read log info from profile
*/
void GetProfileInfo( void )
{
char tmp[256];
char buf[10];
struct stat st;
int rc;
GetWindowsDirectory( tmp, sizeof( tmp ) );
strcat( tmp,"\\drwatcom.log" );
strlwr( tmp );
GetPrivateProfileString( profID, FILENAME, tmp, LogInfo.filename,
MAX_FNAME, iniFile );
GetPrivateProfileString( profID, PLOG_STACK_TRACE,"1", buf,
sizeof( buf ), iniFile );
LogInfo.flags[ LOGFL_STACK_TRACE ] = buf[0];
GetPrivateProfileString( profID, PLOG_TASKS, "1", buf,
sizeof( buf ), iniFile );
LogInfo.flags[ LOGFL_TASKS ] = buf[0];
GetPrivateProfileString( profID, PLOG_MODULES, "1", buf,
sizeof( buf ), iniFile );
LogInfo.flags[ LOGFL_MODULES ] = buf[0];
GetPrivateProfileString( profID, PLOG_GDI, "1", buf,
sizeof( buf ), iniFile );
LogInfo.flags[ LOGFL_GDI ] = buf[0];
GetPrivateProfileString( profID, PLOG_USER, "1", buf,
sizeof( buf ), iniFile );
LogInfo.flags[ LOGFL_USER ] = buf[0];
GetPrivateProfileString( profID, PLOG_MEM, "1", buf,
sizeof( buf ), iniFile );
LogInfo.flags[ LOGFL_MEM ] = buf[0];
GetPrivateProfileString( profID, PLOG_MOD_SEGMENTS, "1", buf,
sizeof( buf ), iniFile );
LogInfo.flags[ LOGFL_MOD_SEGMENTS ] = buf[0];
GetPrivateProfileString( profID, PLOG_AUTOLOG, "0", buf,
sizeof( buf ), iniFile );
LogInfo.flags[ LOGFL_AUTOLOG ] = buf[0];
GetPrivateProfileString( profID, PLOG_NOTE, "1", buf,
sizeof( buf ), iniFile );
LogInfo.flags[ LOGFL_NOTE ] = buf[0];
LogInfo.disasmbackup = getProfileLong( DISASM_BACKUP, 2 );
LogInfo.disasmlines = getProfileLong( DISASM_LINES, 8 );
LogInfo.maxlogsize = getProfileLong( MAX_LOG_SIZE, 100000L );
if( stat( LogInfo.filename, &st ) != -1 ) {
if( st.st_size > LogInfo.maxlogsize ) {
RCsprintf( tmp, STR_LOG_BIG_ERASE, st.st_size );
rc = MessageBox( MainWindow, tmp, AppName, MB_YESNO );
if( rc == IDYES ) {
remove( LogInfo.filename );
}
}
}
DumpHow = getProfileLong( DUMP_HOW, DUMP_ALL );
AlertOnWarnings = ( getProfileLong( ALERT_ON_WARNINGS, 1 ) != 0 );
ExceptionAction = getProfileLong( EXCPT_ACTION, INT_TERMINATE );
GetPrivateProfileString( profID, DEBUG_OPTS, "/swap", DebuggerOpts,
sizeof( DebuggerOpts ), iniFile );
InitMonoFont( profID, iniFile, SYSTEM_FIXED_FONT, Instance );
} /* GetProfileInfo */
/*
* InitStatDialog
*/
static void InitStatDialog( HWND hwnd )
{
int i;
char buff[256];
syminfo si;
ADDRESS addr;
SetDWORDEditField( hwnd, STAT_AX, IntData.EAX );
SetDWORDEditField( hwnd, STAT_BX, IntData.EBX );
SetDWORDEditField( hwnd, STAT_CX, IntData.ECX );
SetDWORDEditField( hwnd, STAT_DX, IntData.EDX );
SetDWORDEditField( hwnd, STAT_SI, IntData.ESI );
SetDWORDEditField( hwnd, STAT_DI, IntData.EDI );
SetDWORDEditField( hwnd, STAT_BP, IntData.EBP );
SetWORDEditField( hwnd, STAT_DS, IntData.DS );
SetWORDEditField( hwnd, STAT_ES, IntData.ES );
SetWORDEditField( hwnd, STAT_FS, IntData.FS );
SetWORDEditField( hwnd, STAT_GS, IntData.GS );
SetWORDEditField( hwnd, STAT_CS, IntData.CS );
SetDWORDEditField( hwnd, STAT_IP, IntData.EIP );
SetWORDEditField( hwnd, STAT_SS, IntData.SS );
SetDWORDEditField( hwnd, STAT_SP, IntData.ESP );
CheckDlgButton( hwnd, STAT_FLAG_A, ( IntData.EFlags & FLAG_A_MASK ) ? BST_CHECKED : BST_UNCHECKED );
CheckDlgButton( hwnd, STAT_FLAG_C, ( IntData.EFlags & FLAG_C_MASK ) ? BST_CHECKED : BST_UNCHECKED );
CheckDlgButton( hwnd, STAT_FLAG_D, ( IntData.EFlags & FLAG_D_MASK ) ? BST_CHECKED : BST_UNCHECKED );
CheckDlgButton( hwnd, STAT_FLAG_I, ( IntData.EFlags & FLAG_I_MASK ) ? BST_CHECKED : BST_UNCHECKED );
CheckDlgButton( hwnd, STAT_FLAG_Z, ( IntData.EFlags & FLAG_Z_MASK ) ? BST_CHECKED : BST_UNCHECKED );
CheckDlgButton( hwnd, STAT_FLAG_S, ( IntData.EFlags & FLAG_S_MASK ) ? BST_CHECKED : BST_UNCHECKED );
CheckDlgButton( hwnd, STAT_FLAG_P, ( IntData.EFlags & FLAG_P_MASK ) ? BST_CHECKED : BST_UNCHECKED );
CheckDlgButton( hwnd, STAT_FLAG_O, ( IntData.EFlags & FLAG_O_MASK ) ? BST_CHECKED : BST_UNCHECKED );
CheckDlgButton( hwnd, STAT_SYMBOLS, ( StatShowSymbols ) ? BST_CHECKED : BST_UNCHECKED );
/*
* fill in source information
*/
addr.seg = IntData.CS;
addr.offset = IntData.EIP;
if( FindWatSymbol( &addr, &si, TRUE ) == FOUND ) {
RCsprintf( buff, STR_SRC_INFO_FMT, si.linenum, si.filename );
} else {
RCsprintf( buff, STR_N_A );
}
SetDlgMonoFont( hwnd, STAT_SRC_INFO );
SetDlgItemText( hwnd, STAT_SRC_INFO, buff );
#ifdef __NT__
{
ProcStats procinfo;
HWND button;
if( GetProcessInfo( processID, &procinfo ) ) {
RCsprintf( buff, STR_STATUS_4_PROC_X, processID, procinfo.name );
SetWindowText( hwnd, buff );
}
CopyRCString( STR_VIEW_MEM_HT_KEY, buff, sizeof( buff ) );
SetDlgItemText( hwnd, STAT_SEG_MAP, buff );
button = GetDlgItem( hwnd, STAT_STACK_TRACE );
ShowWindow( button, SW_HIDE );
}
#endif
/*
* display code, starting 2 instructions before hand
*/
currAddr.seg = IntData.CS;
currAddr.offset = IntData.EIP;
firstAddr = currAddr;
InstructionBackup( 2, &currAddr );
for( i=STAT_DISASM_1;i<=STAT_DISASM_8;i++ ) {
SetDlgCourierFont( hwnd, i );
}
DisplayAsmLines( hwnd, &currAddr, &firstAddr, STAT_DISASM_1,
STAT_DISASM_8, STAT_SCROLL );
} /* InitStatDialog */
/*
* AboutProc - callback routine for settings dialog
*/
WINEXPORT INT_PTR CALLBACK AboutProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
char buff[256];
LPABOUTINFO pai;
lparam = lparam;
switch( msg ) {
case WM_INITDIALOG:
pai = (LPABOUTINFO)lparam;
if( pai->title != NULL ) {
SetWindowText( hwnd, pai->title );
}
if( pai->name != NULL ) {
sprintf( buff, banner1p1( "%s" ), pai->name );
SetDlgItemText( hwnd, ABOUT_NAME, buff );
}
if( pai->version != NULL ) {
SetDlgItemText( hwnd, ABOUT_VERSION, pai->version );
}
if( pai->first_cr_year != NULL ) {
#if defined( __WATCOMC__) && !defined( __ALPHA__ )
if( _fstrcmp( pai->first_cr_year, CURR_YEAR ) ) {
#else
if( strcmp( pai->first_cr_year, CURR_YEAR ) ) {
#endif
sprintf( buff, banner2a( "%s" ), pai->first_cr_year );
} else {
strcpy( buff, banner2a( "1984" ) );
}
SetDlgItemText( hwnd, ABOUT_COPYRIGHT, buff );
}
#if defined( __WINDOWS__ ) || defined( __WINDOWS_386__ )
{
DWORD flags;
DWORD kfree;
WORD pcfree;
SYSHEAPINFO shi;
char work[16];
char info[50];
flags = GetWinFlags();
if( flags & WF_ENHANCED ) {
CopyRCString( ABT_386_ENH, info, sizeof( info ) );
} else {
CopyRCString( ABT_STD_MODE, info, sizeof( info ) );
}
SetDlgItemText( hwnd, ABOUT_INFO1, info );
kfree = GetFreeSpace( 0 ) / 1024L;
ltoa( kfree, work, 10 );
RCsprintf( buff, ABT_MEM_X_KB_FREE, (LPSTR)work );
SetDlgItemText( hwnd, ABOUT_INFO2, buff );
shi.dwSize = sizeof( shi );
if( SystemHeapInfo( &shi ) ) {
pcfree = shi.wGDIFreePercent;
if( pcfree > shi.wUserFreePercent )
pcfree = shi.wUserFreePercent;
RCsprintf( buff, ABT_SYS_RESOURCES_FREE, pcfree );
} else {
CopyRCString( ABT_SYS_RESOURCES_N_A, buff, sizeof( buff ) );
}
SetDlgItemText( hwnd, ABOUT_INFO3, buff );
}
#else
{
SYSTEM_INFO si;
MEMORYSTATUS ms;
GetSystemInfo( &si );
switch( si.dwProcessorType ) {
case PROCESSOR_INTEL_386:
CopyRCString( ABT_RUNNING_ON_386, buff, sizeof( buff ) );
break;
case PROCESSOR_INTEL_486:
CopyRCString( ABT_RUNNING_ON_486, buff, sizeof( buff ) );
break;
case PROCESSOR_INTEL_PENTIUM:
CopyRCString( ABT_RUNNING_ON_586, buff, sizeof( buff ) );
break;
case PROCESSOR_MIPS_R4000:
case PROCESSOR_ALPHA_21064:
default:
buff[0] = '\0';
break;
}
SetDlgItemText( hwnd, ABOUT_INFO1, buff );
ms.dwLength = sizeof( ms );
GlobalMemoryStatus( &ms );
RCsprintf( buff, ABT_VIRT_MEM,
(ms.dwAvailPhys + ms.dwAvailPageFile) / 1024L );
SetDlgItemText( hwnd, ABOUT_INFO2, buff );
RCsprintf( buff, ABT_MEM_LOAD, ms.dwMemoryLoad );
SetDlgItemText( hwnd, ABOUT_INFO3, buff );
}
#endif
return( TRUE );
#ifndef NOUSE3D
case WM_SYSCOLORCHANGE:
CvrCtl3dColorChange();
break;
#endif
case WM_CLOSE:
EndDialog( hwnd, 0 );
break;
case WM_COMMAND:
switch( LOWORD( wparam ) ) {
case IDOK:
case IDCANCEL:
EndDialog( hwnd, 0 );
break;
}
}
return( FALSE );
} /* AboutProc */
/*
* DoAbout - show the startup dialog
*/
void DoAbout( LPABOUTINFO ai )
{
FARPROC proc;
proc = MakeDlgProcInstance( AboutProc, ai->inst );
DialogBoxParam( ai->inst, "About", ai->owner, (DLGPROC)proc, (LPARAM)ai );
FreeProcInstance( proc );
} /* DoAbout */
/*
* memDumpHeader - put summary information at the top of a memory dump
*/
static void memDumpHeader( int hdl, MemWndInfo *info )
{
time_t tm;
char buf[80];
unsigned len;
unsigned type_index;
char *rcstr;
#ifndef __NT__
GLOBALENTRY ge;
descriptor desc;
char access[20];
#endif
tm = time( NULL );
RCsprintf( buf, MWND_MEM_DMP_CREATED, asctime( localtime( &tm ) ), &len );
write( hdl, buf, len );
#ifndef __NT__
if( info->isdpmi ) {
rcstr = AllocRCString( MWND_DPMI_ITEM );
len = strlen( rcstr );
write( hdl, rcstr, len );
FreeRCString( rcstr );
GetADescriptor( info->sel, &desc );
RCsprintf( buf, MWND_SELECTOR, info->sel, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_BASE, GET_DESC_BASE( desc ), &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_LIMIT, GET_DESC_LIMIT( desc), &len );
write( hdl, buf, len );
if( desc.type == 2 ) {
RCsprintf( buf, MWND_TYPE_DATA, &len );
} else {
RCsprintf( buf, MWND_TYPE_CODE, &len );
}
write( hdl, buf, len );
sprintf( buf, "DPL: \t%1d\n%n", desc.dpl, &len );
write( hdl, buf, len );
if( desc.granularity ) {
RCsprintf( buf, MWND_GRANULARITY_PAGE, &len );
} else {
RCsprintf( buf, MWND_GRANULARITY_BYTE, &len );
}
write( hdl, buf, len );
createAccessString( access, &desc );
RCsprintf( buf, MWND_ACCESS, access, &len );
write( hdl, buf, len );
} else {
ge.dwSize = sizeof( GLOBALENTRY );
GlobalEntryHandle( &ge, (HGLOBAL)info->sel );
RCsprintf( buf, MWND_BLOCK_ADDR, ge.dwAddress, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_BLOCK_HDL, ge.hBlock, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_BLOCK_SIZE, ge.dwBlockSize, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_LOCK_CNT, ge.wcLock, &len );
write( hdl, buf, len );
RCsprintf( buf, MWND_PAGE_LOCK_CNT, ge.wcPageLock, &len );
write( hdl, buf, len );
}
#endif
type_index = info->disp_type - MEMINFO_BYTE;
rcstr = AllocRCString( Disp_Types[type_index] );
sprintf( buf, "%s\n\n%n", rcstr, &len );
FreeRCString( rcstr );
write( hdl, buf, len );
} /* MemDumpHeader */
/*
* ProcessIncomingMessage - get a string associated with a message id
*/
void ProcessIncomingMessage( UINT msgid, char *class_name, char *res )
{
message *msg;
const char *fmtstr;
char buf[256];
char hexstr[20];
res[0] = '\0';
msg = GetMessageDataFromID( msgid, class_name );
if( msg != NULL ) {
if( msg->watch ) {
strcpy( res, msg->str );
}
if( msg->stopon ) {
SetSpyState( OFF );
RCsprintf( buf, STR_SPYING_STOPPED, msg->str );
MessageBox( SpyMainWindow, buf, SpyName, MB_OK | MB_ICONINFORMATION );
}
msg->count++;
} else if( msgid >= WM_USER && msgid < WM_APP ) {
userMsg->count++;
if( userMsg->watch ) {
fmtstr = GetRCString( STR_WM_USER_PLUS );
sprintf( res, fmtstr, msgid - WM_USER );
}
if( userMsg->stopon ) {
SetSpyState( OFF );
fmtstr = GetRCString( STR_WM_USER_PLUS );
sprintf( res, fmtstr, msgid - WM_USER );
RCsprintf( buf, STR_SPYING_STOPPED, res );
MessageBox( SpyMainWindow, buf, SpyName, MB_OK | MB_ICONINFORMATION );
}
} else if( msgid >= WM_APP && msgid < 0xC000 ) {
appMsg->count++;
if( appMsg->watch ) {
fmtstr = GetRCString( STR_WM_APP_PLUS );
sprintf( res, fmtstr, msgid - WM_APP );
}
if( appMsg->stopon ) {
SetSpyState( OFF );
fmtstr = GetRCString( STR_WM_APP_PLUS );
sprintf( res, fmtstr, msgid - WM_APP );
RCsprintf( buf, STR_SPYING_STOPPED, res );
MessageBox( SpyMainWindow, buf, SpyName, MB_OK | MB_ICONINFORMATION );
}
} else {
if( Filters[MC_UNKNOWN].watch ) {
GetHexStr( hexstr, msgid, 0 );
fmtstr = GetRCString( STR_UNKNOWN_MSG );
sprintf( res, fmtstr, hexstr );
}
if( Filters[MC_UNKNOWN].stopon ) {
SetSpyState( OFF );
GetHexStr( hexstr, msgid, 0 );
fmtstr = GetRCString( STR_UNKNOWN_MSG );
sprintf( res, fmtstr, hexstr );
RCsprintf( buf, STR_SPYING_STOPPED, res );
MessageBox( SpyMainWindow, buf, SpyName, MB_OK | MB_ICONINFORMATION );
}
}
} /* ProcessIncomingMessage */
/*
* ThreadCtlProc
*/
BOOL CALLBACK ThreadCtlProc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
WORD cmd;
ThreadCtlInfo *info;
LRESULT index;
char buf[200];
DWORD threadid;
ThreadNode *thread;
ProcNode *process;
DWORD susp_cnt;
DWORD rc;
char *action;
info = (ThreadCtlInfo *)GET_DLGDATA( hwnd );
switch( msg ) {
case WM_INITDIALOG:
info = MemAlloc( sizeof( ThreadCtlInfo ) );
if( !GetProcessInfo( lparam, &info->procinfo ) ) {
RCsprintf( buf, STR_CANT_GET_PROC_INFO, info->procid );
MessageBox( hwnd, buf, AppName, MB_OK | MB_ICONEXCLAMATION );
SendMessage( hwnd, WM_CLOSE, 0, 0 );
}
info->procid = lparam;
ThreadDlg = hwnd;
SET_DLGDATA( hwnd, info );
fillThreadCtl( hwnd, &info->procinfo, buf );
RCsprintf( buf, STR_THREAD_4_PROC_X, lparam );
SetDlgItemText( hwnd, THREAD_PROC_NAME, buf );
sprintf( buf, "(%s)", info->procinfo.name );
SetDlgItemText( hwnd, THREAD_PROC_PATH, buf );
SendDlgItemMessage( hwnd, THREAD_LIST, LB_SETCURSEL, 0, 0L );
index = SendDlgItemMessage( hwnd, THREAD_LIST, LB_GETCURSEL, 0, 0L );
if( index != LB_ERR ) {
enableChoices( hwnd, TRUE );
}
fillThreadInfo( hwnd, &info->procinfo );
break;
case WM_COMMAND:
cmd = LOWORD( wparam );
if( cmd == THREAD_SUSPEND || cmd == THREAD_RESUME ||
cmd == THREAD_KILL || cmd == THREAD_SET_PRIORITY ) {
index = SendDlgItemMessage( hwnd, THREAD_LIST, LB_GETCURSEL, 0, 0L );
if( index == LB_ERR ) {
RCMessageBox( hwnd, STR_NO_SELECTED_THREAD, AppName, MB_OK | MB_ICONEXCLAMATION );
break;
}
SendDlgItemMessage( hwnd, THREAD_LIST, LB_GETTEXT, (WPARAM)index, (LPARAM)(LPSTR)buf );
threadid = getThreadId( buf );
process = FindProcess( info->procinfo.pid );
thread = FindThread( process, threadid );
}
switch( cmd ) {
case IDOK:
SendMessage( hwnd, WM_CLOSE, 0, 0L );
break;
case THREAD_REFRESH:
RefreshInfo();
if( GetProcessInfo( info->procid, &info->procinfo ) ) {
fillThreadCtl( hwnd, &info->procinfo, buf );
fillThreadInfo( hwnd, &info->procinfo );
} else {
action = AllocRCString( STR_REFRESH );
RCMessageBox( hwnd, STR_CANT_REFRESH_THRD, action,
MB_OK | MB_ICONEXCLAMATION );
FreeRCString( action );
}
break;
case THREAD_SUSPEND:
action = AllocRCString( STR_THREAD_SUSPEND );
if( thread == NULL ) {
RCsprintf( buf, STR_CANT_GET_HDL_4_THD_X, threadid );
MessageBox( hwnd, buf, action, MB_OK | MB_ICONEXCLAMATION );
} else {
susp_cnt = SuspendThread( thread->threadhdl );
if( susp_cnt == -1 ) {
RCsprintf( buf, STR_CANT_SUSPEND_THRD_X, threadid );
MessageBox( hwnd, buf, action, MB_ICONQUESTION | MB_OK );
} else if( susp_cnt > 0 ) {
RCsprintf( buf, STR_THREAD_ALREADY_SUSP, threadid, susp_cnt );
index = MessageBox( hwnd, buf, action, MB_ICONQUESTION | MB_YESNO );
if( index == IDNO ) {
ResumeThread( thread->threadhdl );
}
}
SendMessage( hwnd, WM_COMMAND, THREAD_REFRESH, 0L );
}
FreeRCString( action );
break;
case THREAD_RESUME:
action = AllocRCString( STR_RESUME );
if( thread == NULL ) {
RCsprintf( buf, STR_THREAD_NOT_RESUMED , threadid );
MessageBox( hwnd, buf, action, MB_OK | MB_ICONEXCLAMATION );
} else {
susp_cnt = ResumeThread( thread->threadhdl );
if( susp_cnt == -1 ) {
RCsprintf( buf, STR_CANT_RESUME_THRD_X, threadid );
MessageBox( hwnd, buf, action,
MB_ICONEXCLAMATION | MB_OK );
} else if( susp_cnt == 0 ) {
RCsprintf( buf, STR_THRD_IS_NOT_SUSP, threadid );
MessageBox( hwnd, buf, action,
MB_ICONEXCLAMATION | MB_OK );
} else if( susp_cnt > 1 ) {
RCsprintf( buf, STR_SUSP_COUNT_DECREMENTED,
threadid, susp_cnt );
MessageBox( hwnd, buf, action,
MB_ICONEXCLAMATION | MB_OK );
}
SendMessage( hwnd, WM_COMMAND, THREAD_REFRESH, 0L );
}
FreeRCString( action );
break;
case THREAD_KILL:
action = AllocRCString( STR_KILL );
if( thread == NULL ) {
RCsprintf( buf, STR_THRD_NOT_TERMINATED, threadid );
MessageBox( hwnd, buf, action, MB_OK | MB_ICONEXCLAMATION );
} else if( GetRetCode( hwnd, RETCD_THREAD, thread->threadid, &rc ) ) {
if( !TerminateThread( thread->threadhdl, rc ) ) {
RCsprintf( buf, STR_CANT_KILL_THRD_X, threadid );
MessageBox( hwnd, buf, action,
MB_OK | MB_ICONEXCLAMATION );
}
SendMessage( hwnd, WM_COMMAND, THREAD_REFRESH, 0L );
}
FreeRCString( action );
break;
case THREAD_SET_PRIORITY:
// {
// ThreadPriorityInfo prinfo;
//
// if( thread == NULL ) {
// sprintf( buf, "Unable to get a handle for thread %08X.\n",
// threadid );
// MessageBox( hwnd, buf, "Set Priority",
// MB_OK | MB_ICONEXCLAMATION );
// } else {
// prinfo.procid = info->procid;
// prinfo.thread = thread;
// prinfo.priority = GetThreadPriority( thread->threadhdl );
// prinfo.procinfo = &info->procinfo;
// DialogBoxParam( Instance, "THREAD_PRIORITY_DLG", hwnd,
// ThreadPriorityDlgProc, (DWORD)&prinfo );
// fillThreadInfo( hwnd, &info->procinfo );
// }
// }
// break;
case THREAD_LIST:
if( HIWORD( wparam ) == LBN_SELCHANGE ) {
fillThreadInfo( hwnd, &info->procinfo );
}
break;
}
break;
case DR_TASK_LIST_CHANGE:
/* make sure this process still exists */
//here if( FindProcess( info->procid ) == NULL ) {
//here SendDlgItemMessage( hwnd, THREAD_LIST, LB_RESETCONTENT, 0, 0L );
//here enableChoices( hwnd, FALSE );
//here info->proc = NULL;
//here } else {
//here fillThreadCtl( hwnd, info->proc, buf );
//here }
break;
case WM_CLOSE:
EndDialog( hwnd, 0 );
break;
case WM_DESTROY:
MemFree( info );
ThreadDlg = NULL;
break;
default:
return( FALSE );
}
return( TRUE );
}
/*
* InitStatDialog
*/
static void InitStatDialog( HWND hwnd )
{
int i;
char buff[256];
ExceptDlgInfo *info;
syminfo si;
CreateRegListData data;
StatData *statdata;
RECT c_rect;
HWND combo;
info = StatGetExceptDlgInfo( hwnd );
StatHdl = hwnd;
statdata = MemAlloc( sizeof( StatData ) );
/*
* fill in source information
*/
GetCurrAddr( &( statdata->curr_addr ), info->regs );
if( FindWatSymbol( &( statdata->curr_addr ), &si, TRUE ) == FOUND ) {
RCsprintf( buff, STR_SRC_INFO_FMT, si.linenum, si.filename );
StatShowSymbols = TRUE;
CheckDlgButton( hwnd, STAT_SYMBOLS, ( StatShowSymbols ) ? BST_CHECKED : BST_UNCHECKED );
} else {
RCsprintf( buff, STR_N_A );
StatShowSymbols = FALSE;
EnableWindow( GetDlgItem( hwnd, STAT_SYMBOLS ), FALSE );
}
SetDlgMonoFont( hwnd, STAT_SRC_INFO );
SetDlgItemText( hwnd, STAT_SRC_INFO, buff );
#ifdef __NT__
{
ProcStats procinfo;
HWND button;
if( GetProcessInfo( info->procinfo->procid, &procinfo ) ) {
RCsprintf( buff, STR_STATUS_4_PROC_X, info->procinfo->procid, procinfo.name );
SetWindowText( hwnd, buff );
}
CopyRCString( STR_VIEW_MEM_HT_KEY, buff, sizeof( buff ) );
SetDlgItemText( hwnd, STAT_SEG_MAP, buff );
button = GetDlgItem( hwnd, STAT_STACK_TRACE );
ShowWindow( button, SW_HIDE );
}
#endif
InstructionBackward( 2, &( statdata->curr_addr ) );
for( i = STAT_DISASM_1;i <= STAT_DISASM_8; i++ ) {
SetDlgCourierFont( hwnd, i );
}
DisplayAsmLines( hwnd, &( statdata->curr_addr ) );
data.index = 0;
data.parent = hwnd;
data.max_len = 0;
combo = GetDlgItem( hwnd, STAT_REGISTER_COMBO );
MADRegSetWalk( MTK_ALL, CreateAllRegLists, &data );
if( data.index == 1 ) {
SendMessage( combo, CB_GETLBTEXT, (WPARAM)0, (LPARAM)buff );
SetDlgItemText( hwnd, STAT_REGISTER_SET, buff );
DestroyWindow( combo );
} else {
GetChildPos( hwnd, combo, &c_rect );
SendMessage( combo, CB_SETCURSEL, (WPARAM)0, (LPARAM)0 );
c_rect.right += data.max_len;
c_rect.bottom += SendMessage( combo, CB_GETITEMHEIGHT, 0, 0 ) * ( data.index + 1);
MoveWindow( combo, c_rect.left, c_rect.top, c_rect.right, c_rect.bottom, FALSE );
}
SetFocus( GetDlgItem( hwnd, IDOK ) );
statdata->reg_set_index = 0;
SetWindowLong(hwnd,DWL_USER,(LONG)statdata);
} /* InitStatDialog */
