Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Windows2000/private/windbg64/windbg/cmdexec0.c
Microsoft 45f4a58588 First commit
2020-09-30 17:12:32 +02:00

4051 lines
92 KiB
C
Raw Permalink Blame History

/*++
Copyright (c) 1992 Microsoft Corporation
Module Name:
Cmdexec0.c
Abstract:
This file contains the front end code for parsing the various commands for the command window, and the code for the debugger control commands.
Author:
David J. Gilman (davegi) 21-Apr-92
Environment:
Win32, User Mode
--*/
#include "precomp.h"
#pragma hdrstop
/************ Data declaration ***********/
/****** Publics ********/
// M00TODO a-kentf put these defaults in (windbg.h? cmdexec.h?)
ULONG ulRipBreakLevel = 1;
ULONG ulRipNotifyLevel = 3;
ULONG ulPseudo[10]={0,0,0,0,0,0,0,0,0,0};
LPPD LppdCommand;
LPTD LptdCommand;
BOOL FSetLptd; // Was thread specified
BOOL FSetLppd; // Was process specified
INT BpCmdPid;
INT BpCmdTid;
BOOL fWaitForDebugString;
LPSTR lpCmdString;
CHAR szLoggerBuf[MAX_USER_LINE+2];
/****** Locals ********/
char szPrompt[ PROMPT_SIZE ] = "> ";
BOOL
StringLogger(
LPCSTR szStr,
BOOL fFileLog,
BOOL fSendRemote,
BOOL fPrintLocal
);
LOGERR
LogOpenDoc(
LPSTR lpsz,
DWORD dwUnused
);
DOT_COMMAND DotTable[] = {
"attach", LogAttach, 0,
"<pid> Debug an existing process.",
"break", LogBreak, 0,
" Stop the current process.",
"connect", LogConnect, 0,
" Connect WinDbg to a remote session.",
"crash", LogCrash, 0,
"<filename> Generate a user-mode dump of the application.",
"disconnect",LogDisconnect, 0,
" Disconnect WinDbg from a remote session.",
"kill", LogKill, 0,
"<pnumber> Terminate a process being debugged.",
"list", LogList, 0,
"<address> Display source or assembly code for an address.",
"logappend", LogFileOpen, TRUE,
"[filename] Append to the log file.",
"logclose", LogFileClose, 0,
" Close the log file.",
"logopen", LogFileOpen, FALSE,
"[filename] Append to the log file and truncate any existing log.",
"open", LogOpenDoc, 0,
" Open a source file.",
"opt", LogOptions, 0,
"[args] Type .opt ? for a complete description.",
"refresh", LogRefresh, 0,
" Refresh the debugger state.",
"reload", LogReload, 0,
"[filename] Reload the symbol files.",
"sleep", LogSleep, 0,
"<seconds> Delay execution of debugger script.",
"source", LogSource, 0,
"<scriptfile> Run a debugger script.",
"start", LogStart, 0,
"<program> Debug an application.",
"title", LogTitle, 0,
"<window title> Set the debugger window title.",
"unload", LogUnload, 0,
"<dll name> Unload the specified extension DLL.",
"waitforstr", LogWaitForString, 0,
" Wait for a debug string.",
};
#define NDOTS (sizeof(DotTable)/sizeof(DOT_COMMAND))
const DWORD dwSizeofDotTable = NDOTS;
BOOL OnOffBOOLHandler(LPVOID, int, LPSTR, BOOL);
BOOL OnOffKDHandler(LPVOID, int, LPSTR, BOOL);
BOOL OnOffByteHandler(LPVOID, int, LPSTR, BOOL);
BOOL AsmOptHandler(LPVOID, int, LPSTR, BOOL);
BOOL DllSetHandler(LPVOID, int, LPSTR, BOOL);
BOOL DllPathSetHandler(LPVOID, int, LPSTR, BOOL);
BOOL HelpHandler(LPVOID, int, LPSTR, BOOL);
BOOL KdBaudHandler(LPVOID, int, LPSTR, BOOL);
BOOL KdPortHandler(LPVOID, int, LPSTR, BOOL);
BOOL KdCacheHandler(LPVOID, int, LPSTR, BOOL);
BOOL KdPlatformHandler(LPVOID, int, LPSTR, BOOL);
BOOL BackgroundSymHandler(LPVOID, int, LPSTR, BOOL);
typedef BOOL (*OPTHANDLER)(LPVOID lpData, int cbSize, LPSTR lpVal, BOOL fSet);
typedef struct tagOPTIONSTRUCT {
LPSTR lpName; // name for user to use
LPVOID lpData; // actual data
int cbSize; // for string fields or whatever
OPTHANDLER lpfnHandler; // work function
LPSTR lpDesc; // help text
} OPTIONSTRUCT, *LPOPTIONSTRUCT;
//static BOOL fFakeFlag = FALSE;
static OPTIONSTRUCT OptionTable[] =
{
// The help entry must be the first entry in this table
"?", 0,0, HelpHandler,
" Displays this list",
"AsmSymbols", (LPVOID) dopSym, 0, AsmOptHandler,
"{on/off} Show symbols in disassembly",
"AsmRaw", (LPVOID) dopRaw, 0, AsmOptHandler,
"{on/off} Show raw data in disassembly",
"AttachGo",&g_contWorkspace_WkSp.m_bAttachGo, 0, OnOffBOOLHandler,
"{on/off} Do not break into newly attached processes",
"AutoReloadSrcFiles",&g_contWorkspace_WkSp.m_bAutoReloadSrcFiles, 0, OnOffBOOLHandler,
"{on/off} Automatically reload changed source files",
"BackgroundSym", &g_contWorkspace_WkSp.m_bShBackground, 0, BackgroundSymHandler,
"{on/off} Load symbols in the background",
"BrowseOnSymError", &g_contWorkspace_WkSp.m_bBrowseForSymsOnSymLoadErrors, 0, OnOffBOOLHandler,
"{on/off} Prompts user on errors in symbol loading if IgnoreAll is off",
"CaseSensitive", &fCaseSensitive, 0, OnOffBOOLHandler,
"{on/off} Sets case sensitivity",
"ChildGo",&g_contWorkspace_WkSp.m_bChildGo, 0, OnOffBOOLHandler,
"{on/off} Do not break into new child processes",
"CommandRepeat", &g_contGlobalPreferences_WkSp.m_bCommandRepeat, 0, OnOffBOOLHandler,
"{on/off} Repeat last command with Enter key",
"DllEE", 0, DLL_EXPR_EVAL, DllSetHandler,
"<filename> Set the expression evaluator DLL",
"DllEm", 0, DLL_EXEC_MODEL, DllSetHandler,
"<filename> Set the execution model DLL",
"DllSh", 0, DLL_SYMBOL_HANDLER, DllSetHandler,
"<filename> Set the symbol handler DLL",
"DllTl", 0, DLL_TRANSPORT, DllSetHandler,
"<filename [args]> Set the transport layer DLL",
"DllPath",0,0, DllPathSetHandler,
"< path | \"path1;path2...\" > Set the search path for symbols",
"EPStep", &g_contWorkspace_WkSp.m_bEPIsFirstStep, 0, OnOffBOOLHandler,
"{on/off} First step goes to the entry point, not main",
"ExitGo", &g_contWorkspace_WkSp.m_bGoOnThreadTerm, 0, OnOffBOOLHandler,
"{on/off} Do not stop on thread termination",
"IgnoreAll", &g_contWorkspace_WkSp.m_bIgnoreAllSymbolErrors, 0, OnOffBOOLHandler,
"{on/off} Load all symbol files, even ones with errors",
"InheritHandles", &g_contWorkspace_WkSp.m_bInheritHandles, 0, OnOffBOOLHandler,
"{on/off} Debuggee inherits handles (for debugging debuggers)",
"KdInitialBp", &g_contKernelDbgPreferences_WkSp.m_bInitialBp, 0, OnOffBOOLHandler,
"{on/off} Stop at initial breakpoint (kernel debugger)",
"KdEnable", &g_contWorkspace_WkSp.m_bKernelDebugger, 0, OnOffKDHandler,
"{on/off} Enable the kernel debugger",
"KdGoExit", &g_contKernelDbgPreferences_WkSp.m_bGoExit, 0, OnOffBOOLHandler,
"{on/off} Go on exit",
"KdUseModem", &g_contKernelDbgPreferences_WkSp.m_bUseModem, 0, OnOffBOOLHandler,
"{on/off} Use modem controls (kernel debugger)",
"KdBaudRate", &g_contKernelDbgPreferences_WkSp.m_dwBaudRate, 0, KdBaudHandler,
"{on/off} Set baud rate (kernel debugger -\n"
" 1200, 2400, 4800, 9600, 38400, 56000)",
"KdPort", &g_contKernelDbgPreferences_WkSp.m_dwPort, 0, KdPortHandler,
"{on/off} Set communication port (kernel debugger - COM1, COM2, ...)",
"KdCacheSize", &g_contKernelDbgPreferences_WkSp.m_dwCache, 0, KdCacheHandler,
"{on/off} Set memory cache size (kernel debugger)",
"KdPlatform", &g_contKernelDbgPreferences_WkSp.m_mptPlatform, 0, KdPlatformHandler,
"{on/off} Set target system type (kernel debugger - x86, alpha, ia64)",
"LoadGo", &g_contWorkspace_WkSp.m_bGoOnModLoad, 0, OnOffBOOLHandler,
"{on/off} Go on module load",
"MasmEval", &g_contWorkspace_WkSp.m_bMasmEval, 0, OnOffBOOLHandler,
"{on/off} Use MASM-style expression evaluation",
"NotifyExit",&g_contWorkspace_WkSp.m_bNotifyThreadTerm, 0, OnOffBOOLHandler,
"{on/off} Print a message upon thread termination",
"NotifyNew",&g_contWorkspace_WkSp.m_bNotifyThreadCreate, 0, OnOffBOOLHandler,
"{on/off} Print a message upon thread creation",
"ShortContext", &g_contWorkspace_WkSp.m_bShortContext, 0, OnOffBOOLHandler,
"{on/off} Display abbreviated context information",
"UnicodeIsDefault", &g_contWorkspace_WkSp.m_bUnicodeIsDefault, 0, OnOffBOOLHandler,
"{on/off} Attempt to evaluate all UINT pointers as Unicode strings",
"Verbose", &g_contWorkspace_WkSp.m_bVerbose, 0, OnOffBOOLHandler,
"{on/off} Display verbose output",
};
#define NOPTS (sizeof(OptionTable) / sizeof(OPTIONSTRUCT))
HANDLE hFileLog = INVALID_HANDLE_VALUE;
extern CRITICAL_SECTION csLog;
static FILE * fpAutoRun = (FILE *)NULL;
static int XNew = 0;
static int YNew = 0;
static BOOL FDebugString = FALSE;
static int XNewDebug;
static int YNewDebug;
static BOOL (*lpfnLineProc)(LPSTR lpsz) = CmdExecuteLine;
static void (*lpfnPromptProc)(BOOL,BOOL) = CmdExecutePrompt;
static char * LpszCmdPtr = (char *)NULL; //
static char * LpszCmdBuff = (char *)NULL; //
/****** Externs from ??? *******/
extern LPSHF Lpshf; // vector table for symbol handler
extern CXF CxfIp;
LOGERR LogExtension(LPSTR lpsz);
LOGERR LogVersion(LPSTR lpsz);
BOOL NotifyDmOfProcessorChange(DWORD);
/************ Code ***********/
/** Option handler functions ***/
/*
* These return TRUE when they succeed, false when they don't.
*/
BOOL
HelpHandler(
LPVOID lpData,
int cbSize,
LPSTR lpVal,
BOOL fSet
)
{
int i;
if (!fSet) {
*lpVal = 0;
} else {
for (i = 0; i < NOPTS; i++) {
CmdLogFmt("%s %s\r\n",
OptionTable[i].lpName,
OptionTable[i].lpDesc);
}
}
return TRUE;
}
BOOL
OnOffBOOLHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
/*++
Routine Description:
Handle boolean switches, with a native BOOL for the data item.
Arguments:
lpData - Supplies pointer to data
cb - Supplies more data
lpVal - Supplies pointer to user input or string to format into
fSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
int n;
BOOL fOK = FALSE;
char szToken[MAX_USER_LINE];
Unreferenced( cb );
if (!fSet) {
sprintf(lpVal, (*(BOOL *)lpData) ? "on" : "off");
return TRUE;
}
n = CPCopyToken(&lpVal, szToken);
if (*CPSkipWhitespace(lpVal)) {
CmdLogVar(ERR_Command_Error);
} else if (_stricmp(szToken, "yes") == 0
|| _stricmp(szToken, "y") == 0
|| _stricmp(szToken, "true") == 0
|| _stricmp(szToken, "1") == 0
|| _stricmp(szToken, "on") == 0 ) {
*(BOOL *)lpData = TRUE;
fOK = TRUE;
} else if (_stricmp(szToken, "no") == 0
|| _stricmp(szToken, "n") == 0
|| _stricmp(szToken, "false") == 0
|| _stricmp(szToken, "0") == 0
|| _stricmp(szToken, "off") == 0 ) {
*(BOOL *)lpData = FALSE;
fOK = TRUE;
} else {
CmdLogVar(ERR_True_False);
}
return fOK;
}
BOOL
OnOffKDHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
/*++
Routine Description:
Handle KD enable switch, with a native BOOL for the data item.
Arguments:
lpData - Supplies pointer to data
cb - Supplies more data
lpVal - Supplies pointer to user input or string to format into
fSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
BOOL WasSet = g_contWorkspace_WkSp.m_bKernelDebugger;
BOOL fOK = OnOffBOOLHandler(lpData, cb, lpVal, fSet);
if (fOK) {
if (fSet) {
g_Windbg_WkSp.SetCurrentProgramName(NT_KERNEL_NAME);
} else if (WasSet) {
g_Windbg_WkSp.SetCurrentProgramName(g_Windbg_WkSp.m_pszNoProgramLoaded);
}
}
return fOK;
}
BOOL
OnOffByteHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
/*++
Routine Description:
Handle boolean switches, with a byte for the data item.
Arguments:
lpData - Supplies pointer to data
cb - Supplies more data
lpVal - Supplies pointer to user input or string to format into
fSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
BOOL flag;
BOOL fOK;
flag = (BOOL)*((BYTE *)lpData);
fOK = OnOffBOOLHandler((LPVOID)&flag, cb, lpVal, fSet);
if (fOK) {
*((BYTE *)lpData) = (BYTE)flag;
}
return fOK;
}
BOOL
AsmOptHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
/*++
Routine Description:
Handle boolean switches, with a native BOOL for the data item.
Arguments:
lpData - Supplies pointer to data
cb - Supplies more data
lpVal - Supplies pointer to user input or string to format into
fSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
BOOL fOK;
BOOL flag;
int dops = PtrToInt(lpData);
flag = (g_contWorkspace_WkSp.m_dopDisAsmOpts & dops) ? 1 : 0;
fOK = OnOffBOOLHandler((LPVOID)&flag, cb, lpVal, fSet);
if (fOK) {
if (fSet) {
if (flag) {
g_contWorkspace_WkSp.m_dopDisAsmOpts |= dops;
} else {
g_contWorkspace_WkSp.m_dopDisAsmOpts &= ~dops;
}
}
}
return fOK;
}
BOOL
DllSetHandler(
LPVOID /*lpData*/,
int nDll,
LPSTR pszVal,
BOOL bSet
)
/*++
Routine Description:
This routine is used to change the set of DLLs used by windbg.
This is for use with scripting only.
Arguments:
lpData - Supplies pointer to data
nDll - Supplies data size
pszVal - Supplies pointer to user input or string to format into
bSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
PTSTR pszToken = pszVal;
switch (nDll) {
case DLL_EXPR_EVAL:
// DllEE: Expression evaluator dll
if (bSet) {
return FALSE;
}
strcpy(pszVal, g_pszDLL_EXPR_EVAL);
break;
case DLL_EXEC_MODEL:
// DllEm: Execution model dll
if (bSet) {
return FALSE;
}
strcpy(pszVal, g_pszDLL_EXEC_MODEL);
break;
case DLL_SYMBOL_HANDLER:
// DllSh: Symbol handler dll
if (bSet) {
return FALSE;
}
strcpy(pszVal, g_pszDLL_SYMBOL_HANDLER);
break;
case DLL_TRANSPORT:
// DllTl: Transport layer dll
if (!bSet) {
// Query TL settings
if (!g_contWorkspace_WkSp.m_pszSelectedTL) {
// No TL is currently selected!
// Warn the user.
PTSTR psz = WKSP_DynaLoadString(g_hInst, ERR_No_TL_Selected);
if (!psz) {
_tcsncpy(pszVal, "none", MAX_USER_LINE);
} else {
_tcsncpy(pszVal, psz, MAX_USER_LINE);
FREE_STR(psz);
}
return TRUE;
} else {
// Find the currently selected TL
TListEntry<CIndiv_TL_WKSP *> * pContEntry = g_dynacontAll_TLs_WkSp.m_listConts.Find(
g_contWorkspace_WkSp.m_pszSelectedTL,
WKSP_Generic_CmpRegName);
CIndiv_TL_WKSP * pIndTl = NULL;
if (pContEntry) {
pIndTl = pContEntry->m_tData;
AssertType(*pIndTl, CIndiv_TL_WKSP);
}
if (pIndTl) {
// We found the currently selected TL
_snprintf(pszVal,
MAX_USER_LINE,
_T("%s %s"),
pIndTl->m_pszDll,
pIndTl->m_pszParams
);
return TRUE;
} else {
// Error: A TL is specified but it does not exist.
// Warn the user that the spcified TL doesn't exist
CmdLogVar(ERR_Transport_Doesnt_Exist, g_contWorkspace_WkSp.m_pszSelectedTL);
// Tell the user the name of the currently selected TL, completing our task
_tcsncpy(pszVal, g_contWorkspace_WkSp.m_pszSelectedTL, MAX_USER_LINE);
return TRUE;
}
}
} else {
// Set new TL params from the command window
PTSTR pszTmp = NULL;
PCTSTR pszTLNameCreatedFromCmdWindow = _T("Command window TL");
TCHAR szBuffer[MAX_USER_LINE] = {0};
TListEntry<CIndiv_TL_WKSP *> * pContEntry = g_dynacontAll_TLs_WkSp.m_listConts.Find(
pszTLNameCreatedFromCmdWindow,
WKSP_Generic_CmpRegName);
CIndiv_TL_WKSP * pIndTl = NULL;
if (pContEntry) {
pIndTl = pContEntry->m_tData;
AssertType(*pIndTl, CIndiv_TL_WKSP);
}
if (pIndTl) {
// We found a previous instance of a TL created from the command window.
// Replace the current values with the new ones.
// Set the new default TL
FREE_STR(g_contWorkspace_WkSp.m_pszSelectedTL);
g_contWorkspace_WkSp.m_pszSelectedTL = _tcsdup(pszTLNameCreatedFromCmdWindow);
pIndTl->m_pszDescription = WKSP_DynaLoadString(g_hInst,
SYS_Desc_For_TL_Created_From_Cmd_Wnd);
pszToken = CPSzToken(&pszToken, szBuffer);
pIndTl->m_pszDll = _tcsdup(szBuffer);
CPSzToken(&pszToken, szBuffer);
pIndTl->m_pszParams = _tcsdup(szBuffer);
pszTmp = WKSP_DynaLoadStringWithArgs(g_hInst,
SYS_New_TL_Settings,
pIndTl->m_pszRegistryName,
pIndTl->m_pszDll,
pIndTl->m_pszParams
);
if (pszTmp) {
_tcsncpy(pszVal, pszTmp, MAX_USER_LINE);
} else {
*pszVal = 0;
}
FREE_STR(pszTmp);
return TRUE;
} else {
// A TL has not been previously created from the command window. If it
// has it has been erased. Let's create a new one.
CIndiv_TL_WKSP * pIndTl = new CIndiv_TL_WKSP();
if (!pIndTl) {
CmdLogFmt(LowMemoryMsg);
CmdLogFmt("\r\n");
*pszVal = 0;
return FALSE;
}
CIndiv_TL_WKSP * pCont = new CIndiv_TL_WKSP();
Assert(pCont);
pCont->Init(&g_dynacontAll_TLs_WkSp,
pszTLNameCreatedFromCmdWindow,
FALSE,
FALSE
);
pIndTl->m_pszDescription = _tcsdup(_T("TL created from within the command window"));
pszToken = CPSzToken(&pszToken, szBuffer);
pIndTl->m_pszDll = _tcsdup(szBuffer);
CPSzToken(&pszToken, szBuffer);
pIndTl->m_pszParams = _tcsdup(szBuffer);
pszTmp = WKSP_DynaLoadStringWithArgs(g_hInst,
SYS_New_TL_Settings,
pIndTl->m_pszRegistryName,
pIndTl->m_pszDll,
pIndTl->m_pszParams
);
if (pszTmp) {
_tcsncpy(pszVal, pszTmp, MAX_USER_LINE);
} else {
*pszVal = 0;
}
FREE_STR(pszTmp);
return TRUE;
}
}
break;
default:
Assert(0);
}
return TRUE;
}
BOOL
DllPathSetHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
{
int len;
LPSTR lpsz;
char sz[2000];
PIOCTLGENERIC pig;
DWORD dw;
if (!fSet) {
len = ModListGetSearchPath( NULL, 0 );
if (!len) {
*lpVal = 0;
} else {
lpsz = (PSTR) malloc(len);
Assert(lpsz);
ModListGetSearchPath( lpsz, len );
// BUGBUG kentf this is sleazy, but I don't have time to change it
strncpy(lpVal, lpsz, MAX_USER_LINE);
lpVal[MAX_USER_LINE-1] = 0;
free(lpsz);
}
} else {
lpVal = CPSkipWhitespace(lpVal);
CPCopyString(&lpVal, sz, '\0', *lpVal == '"' || *lpVal == '\'');
ModListSetSearchPath( sz );
if ( g_contWorkspace_WkSp.m_bKernelDebugger && LptdCur && DebuggeeAlive()) {
FormatKdParams( sz );
pig = (PIOCTLGENERIC)malloc(strlen(sz) + 1 + sizeof(IOCTLGENERIC));
if (!pig) {
return FALSE;
}
pig->ioctlSubType = IG_DM_PARAMS;
pig->length = strlen(sz) + 1;
strcpy((LPSTR)pig->data,sz);
OSDSystemService( LppdCur->hpid,
LptdCur->htid,
(SSVC) ssvcGeneric,
(LPV)pig,
strlen(sz) + 1 + sizeof(IOCTLGENERIC),
&dw
);
free( pig );
}
}
return TRUE;
}
BOOL
KdBaudHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
/*++
Routine Description:
Handle boolean switches, with a native BOOL for the data item.
Arguments:
lpData - Supplies pointer to data
cb - Supplies more data
lpVal - Supplies pointer to user input or string to format into
fSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
DWORD i;
char szToken[MAX_USER_LINE];
if (!fSet) {
sprintf(lpVal, "%d", g_contKernelDbgPreferences_WkSp.m_dwBaudRate );
return TRUE;
}
i = CPCopyToken(&lpVal, szToken);
if (*CPSkipWhitespace(lpVal)) {
CmdLogVar(ERR_Command_Error);
return FALSE;
}
for (i=0; i<strlen(szToken); i++) {
if (!isdigit(szToken[i])) {
CmdLogVar(ERR_Command_Error);
return FALSE;
}
}
g_contKernelDbgPreferences_WkSp.m_dwBaudRate = atol( szToken );
return TRUE;
}
BOOL
KdPortHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
/*++
Routine Description:
Handle boolean switches, with a native BOOL for the data item.
Arguments:
lpData - Supplies pointer to data
cb - Supplies more data
lpVal - Supplies pointer to user input or string to format into
fSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
DWORD i;
char szToken[MAX_USER_LINE];
LPSTR p = szToken;
if (!fSet) {
sprintf(lpVal, "COM%d", g_contKernelDbgPreferences_WkSp.m_dwPort );
return TRUE;
}
i = CPCopyToken(&lpVal, szToken);
if (*CPSkipWhitespace(lpVal)) {
CmdLogVar(ERR_Command_Error);
return FALSE;
}
if (_strnicmp(p, "com", 3) == 0) {
p += 3;
if (strlen(p) == 1 && isdigit(*p)) {
g_contKernelDbgPreferences_WkSp.m_dwPort = *p - '0';
} else {
CmdLogVar(ERR_Command_Error);
return FALSE;
}
} else {
CmdLogVar(ERR_Command_Error);
return FALSE;
}
return TRUE;
}
BOOL
KdCacheHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
/*++
Routine Description:
Handle boolean switches, with a native BOOL for the data item.
Arguments:
lpData - Supplies pointer to data
cb - Supplies more data
lpVal - Supplies pointer to user input or string to format into
fSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
DWORD i;
char szToken[MAX_USER_LINE];
if (!fSet) {
sprintf(lpVal, "%d", g_contKernelDbgPreferences_WkSp.m_dwCache );
return TRUE;
}
i = CPCopyToken(&lpVal, szToken);
if (*CPSkipWhitespace(lpVal)) {
CmdLogVar(ERR_Command_Error);
return FALSE;
}
for (i=0; i<strlen(szToken); i++) {
if (!isdigit(szToken[i])) {
CmdLogVar(ERR_Command_Error);
return FALSE;
}
}
g_contKernelDbgPreferences_WkSp.m_dwCache = atol( szToken );
return TRUE;
}
BOOL
KdPlatformHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
/*++
Routine Description:
Handle boolean switches, with a native BOOL for the data item.
Arguments:
lpData - Supplies pointer to data
cb - Supplies more data
lpVal - Supplies pointer to user input or string to format into
fSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
DWORD i;
char szToken[MAX_USER_LINE];
if (!fSet) {
strcpy(lpVal, GetPlatformNameFromId(g_contKernelDbgPreferences_WkSp.m_mptPlatform));
return TRUE;
}
i = CPCopyToken(&lpVal, szToken);
if (*CPSkipWhitespace(lpVal)) {
CmdLogVar(ERR_Command_Error);
return FALSE;
}
if (!GetPlatformIdFromName(szToken, &g_contKernelDbgPreferences_WkSp.m_mptPlatform)) {
CmdLogVar(ERR_Command_Error);
return FALSE;
}
return TRUE;
}
BOOL
BackgroundSymHandler(
LPVOID lpData,
int cb,
LPSTR lpVal,
BOOL fSet
)
/*++
Routine Description:
Handle boolean switches, with a native BOOL for the data item.
Arguments:
lpData - Supplies pointer to data
cb - Supplies more data
lpVal - Supplies pointer to user input or string to format into
fSet - Supplies TRUE for set, FALSE for read/format
Return Value:
TRUE when successful, FALSE if something is wrong.
--*/
{
int n;
BOOL fOK;
char szToken[MAX_USER_LINE];
Unreferenced( cb );
fOK = OnOffBOOLHandler(lpData, cb, lpVal, fSet);
if (!fSet) {
return fOK;
}
if (fOK) {
if (*(BOOL *)lpData) {
LPFNSHSTARTBACKGROUND lpfn;
lpfn = (LPFNSHSTARTBACKGROUND) GetProcAddress( (HINSTANCE) HModSH, "SHStartBackground" );
if (lpfn) {
lpfn();
}
} else {
LPFNSHSTOPBACKGROUND lpfn;
lpfn = (LPFNSHSTOPBACKGROUND) GetProcAddress( (HINSTANCE) HModSH, "SHStopBackground" );
if (lpfn) {
lpfn();
}
}
}
return fOK;
}
/************ ***********/
void
CmdSetDefaultCmdProc(
void
)
/*++
Routine Description:
Set input and prompt procs to the default (CmdExecuteLine)
Arguments:
None
Return Value:
None
--*/
{
CmdSetCmdProc(CmdExecuteLine, CmdExecutePrompt);
CmdSetAutoHistOK(TRUE);
CmdSetEatEOLWhitespace(TRUE);
}
void
CmdSetCmdProc(
BOOL (*lpfnLP)(LPSTR lpsz),
void (*lpfnPP)(BOOL,BOOL)
)
/*++
Routine Description:
Set the input and prompt procs for the command window.
Arguments:
lpfnLP - pointer to the line input function
lpfnPP - pointer to the prompt printer function
Return Value:
none
--*/
{
lpfnLineProc = lpfnLP;
lpfnPromptProc = lpfnPP;
}
void
CmdDoPrompt(
BOOL fRemote,
BOOL fLocal
)
/*++
Routine Description:
Calls the current prompt printer function, then sets the line to the left
of the cursor readonly.
Arguments:
None
Return Value:
None
--*/
{
int XOld = 0;
int YOld;
int XPos = Views[cmdView].X;
int YPos = Views[cmdView].Y;
if (fLocal) {
CmdInsertInit();
FDebugString = FALSE;
// is there already a prompt here?
GetRORegion(cmdView, &XOld, &YOld);
if (YOld == YNew && XOld > 0) {
XNew = XOld;
StringLogger("\r\n", FALSE, FALSE, TRUE);
if (YPos > YOld) {
YPos++;
} else if (YPos == YOld && XPos >= XOld) {
YPos++;
XPos -= XOld;
}
}
XOld = XNew;
YOld = YNew;
}
(*lpfnPromptProc)(fRemote, fLocal);
if (fLocal) {
SetRORegion(cmdView, XNew, YNew);
if (YPos > YOld) {
PosXY(cmdView, XPos, YPos + YNew - YOld, FALSE);
} else if (YPos == YOld) {
PosXY(cmdView, XPos+XNew, YNew, FALSE);
} else {
PosXY(cmdView, XPos, YPos, FALSE);
}
}
}
BOOL
CmdDoLine(
LPSTR lpsz
)
/*++
Routine Description:
Calls the current line input function
Arguments:
lpsz - Supplies a line to be handled by the line input function
Return Value:
BOOL value from line input function: TRUE for synchronous, FALSE for asynch
--*/
{
__try {
return (*lpfnLineProc)(lpsz);
} __except(GenericExceptionFilter(GetExceptionInformation())) {
//DAssert(FALSE);
}
}
VOID
CmdPrependCommands(
LPTD lptd,
LPSTR lpsz
)
/*++
Routine Description:
This function will take the argument lpsz and prepend any
commands in this string to the command line on the thread.
Arguments:
lptd - Supplies pointer to thread to add commands to
lpsz - Supplies commands to add to the threads context
Return Value:
None
--*/
{
// NOTENOTE a-kentf something calls with an empty string - beta2
if (!lpsz || *lpsz == '\0') {
return;
}
if (lptd == (LPTD)NULL) {
if ( LpszCmdBuff == (char *)NULL ) {
LpszCmdBuff = LpszCmdPtr = _strdup(lpsz);
} else {
LPSTR lpszT;
lpszT = (PSTR) malloc( strlen(LpszCmdPtr) + strlen(lpsz) + 2);
Assert(lpszT);
strcpy(lpszT, lpsz);
strcat(lpszT, ";");
strcat(lpszT, LpszCmdPtr);
free( LpszCmdBuff );
LpszCmdPtr = LpszCmdBuff = lpszT;
}
} else if (lptd->lpszCmdBuffer == (LPSTR)NULL) {
lptd->lpszCmdBuffer = lptd->lpszCmdPtr = _strdup( lpsz );
} else {
LPSTR lpszT;
lpszT = (PSTR) malloc( strlen(lptd->lpszCmdPtr) + strlen(lpsz) + 2);
Assert(lpszT);
strcpy(lpszT, lpsz);
strcat(lpszT, ";");
strcat(lpszT, lptd->lpszCmdPtr);
free(lptd->lpszCmdBuffer);
lptd->lpszCmdBuffer = lptd->lpszCmdPtr = lpszT;
}
return;
} /* CmdPrependCommands() */
void
CmdExecutePrompt(
BOOL fRemote,
BOOL fLocal
)
/*++
Routine Description:
Print the command prompt and position the cursor after it
Arguments:
none
Return Value:
none
--*/
{
if (fLocal) {
CmdInsertInit();
}
StringLogger( szPrompt, TRUE, fRemote, fLocal );
}
void
CmdSetDefaultPrompt(
LPSTR lpPrompt
)
{
if (!lpPrompt) {
strcpy(szPrompt, "> ");
} else {
strcpy(szPrompt, lpPrompt);
}
}
LPSTR
CmdGetDefaultPrompt(
LPSTR lpPrompt
)
{
if (!lpPrompt) {
return szPrompt;
} else {
return strcpy(lpPrompt, szPrompt);
}
}
BOOL
CmdExecuteLine(
LPSTR lpszArg
)
/*++
Routine Description:
This function will parse up any existing strings for the current
thread and execute commands. If lpsz is non-null then the
commands represented by this string will be placed first on
the threads command list.
Arguments:
lpsz - Supplies pointer to string containing commands to be executed
Return Value:
TRUE if the command is synchronous and FALSE if it is asynchronous
--*/
{
LPSTR lpsz1;
LPSTR lpsz2;
int iSrc;
int cmdRet;
char ch;
LPTD lptd;
char rgchT[256];
BOOL fQuote;
char localArg[1024];
// in case the caller passes in a read only string
if (lpszArg) {
strcpy( localArg, lpszArg );
lpszArg = &localArg[0];
}
if (lpszArg && (lpszArg[0] == '*')) {
lpszArg = NULL;
}
if ((LptdCur == NULL) && (lpszArg == NULL) && (LpszCmdBuff == NULL)) {
return TRUE;
}
/*
* If there are any steps left to be executed from a previous command
* these take precedence over any new commands to be executed
*/
if ((LptdCur != NULL) && (LptdCur->cStepsLeft != 0)) {
if (lpszArg != 0) {
CmdPrependCommands(LptdCur, lpszArg);
}
LptdCur->cStepsLeft -= 1;
if (ExecDebuggee((LptdCur->flags & tfStepOver) ? EXEC_STEPOVER : EXEC_TRACEINTO)) {
return FALSE;
}
LptdCur->cStepsLeft = 0;
return TRUE;
}
do {
/*
** Setup for parsing and executing from the current thread
*/
lptd = LptdCur;
if (lpszArg) {
lpsz1 = lpszArg;
iSrc = 1;
lpszArg = NULL;
} else if ((lptd != NULL) && (lptd->lpszCmdBuffer != NULL)) {
lpsz1 = lptd->lpszCmdPtr;
iSrc = 0;
} else {
lpsz1 = LpszCmdPtr;
iSrc = 2;
}
if (lpsz1 == NULL) {
return TRUE;
}
lpsz2 = lpsz1;
/*
** Scan across the command looking for either the end of the command
** This is denoted by either a semi-colon or the end of the string.
*/
fQuote = FALSE;
while (*lpsz1) {
if (*lpsz1 == '\"') {
fQuote = !fQuote;
} else if (!fQuote && (*lpsz1 == ';')) {
break;
}
lpsz1 = CharNext(lpsz1);
}
ch = *lpsz1;
*lpsz1 = 0;
/*
** Update the thread state information to deal with the possiblity
** of a thread switch while executing the command
*/
if (ch == 0) {
switch( iSrc ) {
/*
** We are about to execute the last command from the
** threads buffer. Copy it locally and free
** the thread state buffer
*/
case 0: // Input from thread buffer
Assert( lptd != NULL );
Assert(lptd->lpszCmdBuffer != NULL);
strcpy(rgchT, lptd->lpszCmdPtr);
lpsz2 = &rgchT[0];
free( lptd->lpszCmdBuffer);
lptd->lpszCmdBuffer = lptd->lpszCmdPtr = NULL;
break;
/*
** No updates are needed -- We just executed a single
** command from the input argument and no modifications
** of the thread state are needed.
*/
case 1: // Input from argument buffer
break;
/*
** We are about to execute the last command from
** the global buffer. Copy it locally and free
** the global command buffer.
*/
case 2: // Input from global buffer
Assert( LpszCmdBuff != NULL );
strcpy(rgchT, LpszCmdPtr);
lpsz2 = &rgchT[0];
free( LpszCmdBuff );
LpszCmdBuff = LpszCmdPtr = NULL;
break;
default:
Assert(FALSE);
break;
}
} else {
lpsz1++;
switch (iSrc) {
/*
** Just need to update the state information for
** this thread
*/
case 0:
Assert(lptd);
lptd->lpszCmdPtr = lpsz1;
break;
/*
** Need to prepend the rest of this command line onto
** the thread command buffer
*/
case 1:
CmdPrependCommands( lptd, lpsz1 );
break;
/*
** Just update the pointer state on the global
** command buffer
*/
case 2:
LpszCmdPtr = lpsz1;
break;
default:
Assert(FALSE);
break;
}
}
/*
** Execute this command and grab the return code. It will tell use if
** this specific command was syncronous or not.
*/
cmdRet = CmdExecuteCmd(lpsz2);
/*
** Loop while the last command was successful and
** synchronous. Plus there is either a command in the
** current thread buffer or the global buffer.
*/
} while ((cmdRet == CMD_RET_SYNC) &&
(((LptdCur != NULL) && (LptdCur->lpszCmdPtr != NULL)) ||
(LpszCmdPtr != NULL)));
if (cmdRet == CMD_RET_ERROR) {
// clear remaining commands on this thread and globally.
if (LptdCur && LptdCur->lpszCmdBuffer) {
free(LptdCur->lpszCmdBuffer);
LptdCur->lpszCmdPtr = LptdCur->lpszCmdBuffer = NULL;
}
if (LpszCmdBuff) {
free( LpszCmdBuff );
LpszCmdBuff = LpszCmdPtr = NULL;
}
}
return ((cmdRet == CMD_RET_SYNC) || (cmdRet == CMD_RET_ERROR));
} /* CmdExecLine() */
int
CmdExecuteCmd(
LPSTR lpsz
)
/*++
Routine Description:
This function will parse up and attempt to execute a command string
this command string is equivalent to a return terminated string
rather than a single command. The return is optional as zero
termination will work equally well.
Arguments:
lpsz - Supplies pointer to the string containning command to be executed
Return Value:
CMD_RET_SYNC - command is syncronous
CMD_RET_ASYNC - command is async
CMD_RET_ERROR - command was in error
--*/
{
int retCmd = CMD_RET_SYNC;
LOGERR logerror = LOGERROR_NOERROR;
UINT i;
BOOL err;
int cb;
LPSTR lpszSave = lpsz;
LPSTR lpszT;
LPSTR lpszX;
char ch;
static char chLastDump = 0;
// Skip over any preceeding white space
lpsz = CPSkipWhitespace(lpsz);
if (*lpsz == 0) {
return(CMD_RET_SYNC);
}
// Strip off any trailing white space
for (lpszX = lpsz-1, lpszT = lpsz; *lpszT; lpszT++) {
if (IsDBCSLeadByte(*lpszT) && *(lpszT+1)) {
lpszX = lpszT + 1;
lpszT++;
} else
if (!isspace(*lpszT)) {
lpszX = lpszT;
}
}
if (lpszX+1 != lpszT) {
*(lpszX + 1) = 0;
}
// Strip off anything relative to threads or processes which
// may preceed the command
// Possible starting strings are:
// lead := processID | threadID | processID threadID | <blank>
// processID := '|' Number | '|' '.'
// threadID := '~' Number | '~' '.'
LppdCommand = LppdCur;
LptdCommand = LptdCur;
FSetLptd = FALSE;
FSetLppd = FALSE;
BpCmdPid = LppdCommand? LppdCommand->ipid : 0;
BpCmdTid = LptdCommand? LptdCommand->itid : -1;
if (*lpsz == '|') {
FSetLppd = TRUE;
lpsz = CPSkipWhitespace(lpsz+1);
if (*lpsz == 0) {
logerror = LogProcess();
goto done;
} else if (*lpsz == '.') {
lpsz++;
} else if (*lpsz == '*') {
BpCmdPid = -1;
LppdCommand = (LPPD) -1;
lpsz++;
} else {
i = (int) CPGetInt(lpsz, &err, &cb);
if (err) {
logerror = LOGERROR_UNKNOWN;
goto done;
} else {
BpCmdPid = i;
lpsz += cb;
LppdCommand = ValidLppdOfIpid(i);
if ( LppdCommand == NULL ) {
LptdCommand = NULL;
} else {
LptdCommand = LppdCommand->lptdList;
}
}
}
}
lpsz = CPSkipWhitespace(lpsz);
if (*lpsz == '~') {
FSetLptd = TRUE;
lpsz = CPSkipWhitespace(lpsz+1);
if (*lpsz == 0) {
logerror = LogThread();
goto done;
} else if (*lpsz == '.') {
BpCmdTid = LptdCommand? LptdCommand->itid : 0;
lpsz++;
} else if (*lpsz == '*') {
BpCmdTid = -1;
LptdCommand = (LPTD) -1;
lpsz++;
} else {
i = (int) CPGetInt(lpsz, &err, &cb);
if (err) {
logerror = LOGERROR_UNKNOWN;
goto done;
} else if (LppdCommand == (LPPD) -1) {
CmdInsertInit();
CmdLogVar(ERR_No_Thread_With_Wildproc);
logerror = LOGERROR_QUIET;
goto done;
} else {
BpCmdTid = i;
lpsz += cb;
if ( LppdCommand == NULL ) {
LptdCommand = NULL;
} else {
LptdCommand = LptdOfLppdItid(LppdCommand, i);
NotifyDmOfProcessorChange( i );
}
}
}
}
/*
** Skip across any leading white space.
*/
lpsz = CPSkipWhitespace(lpsz);
// For Breakpoint set, we accept nonexistend Process/Thread. For
// all other commands, Process/Thread must be valid if specified.
if ( !( (*lpsz == 'B' || *lpsz == 'b') &&
(*(lpsz+1) == 'P' || *(lpsz+1) == 'p') ) ) {
if ( FSetLppd ) {
if ( LppdCur == NULL ) {
CmdInsertInit();
CmdLogVar(ERR_Process_Not_Exist);
logerror = LOGERROR_QUIET;
goto done;
} else if ( LppdCommand == NULL ) {
logerror = LOGERROR_UNKNOWN;
goto done;
}
}
if ( FSetLptd ) {
if ( LptdCur == NULL ) {
CmdInsertInit();
CmdLogVar(ERR_No_Threads);
logerror = LOGERROR_QUIET;
goto done;
} else if ( LptdCommand == NULL ) {
logerror = LOGERROR_UNKNOWN;
goto done;
}
}
}
/*
** Now run through a big switch statement so that we can breakup
** the command
*/
switch ( *lpsz++ ) {
case 0:
if (FSetLptd || FSetLppd) {
if (LppdCommand == NULL || LppdCommand == (LPPD)-1
|| LptdCommand == NULL || LptdCommand == (LPTD)-1)
{
logerror = LOGERROR_UNKNOWN;
} else {
LppdCur = LppdCommand;
LptdCur = LptdCommand;
SetPidTid_StatusBar(LppdCur, LptdCur);
UpdateDebuggerState(UPDATE_WINDOWS);
}
}
break;
case '.':
logerror = LogDotCommand(lpsz);
if (logerror == LOGERROR_ASYNC) {
retCmd = CMD_RET_ASYNC;
}
break;
case '*': // Comments
retCmd = CMD_RET_SYNC;
break;
case '+': // Pause
if (AutoRun != arSource && AutoRun != arCmdline) {
logerror = LOGERROR_UNKNOWN;
}
retCmd = CMD_RET_ASYNC;
break;
case '-': // Continue
if (AutoRun == arSource || AutoRun == arCmdline) {
PostMessage(Views[cmdView].hwndClient, WU_AUTORUN, 0, 0);
} else {
logerror = LOGERROR_UNKNOWN;
}
break;
case '?':
logerror = LogEvaluate(lpsz, g_contWorkspace_WkSp.m_bMasmEval);
break;
case '%':
logerror = LogFrameChange(lpsz);
break;
#ifdef MICHE
case 'a':
case 'A':
logerror = LogAssemble(lpsz);
break;
#endif
case 'b':
case 'B':
switch( *lpsz++ ) {
case 'c':
case 'C':
logerror = LogBPChange(lpsz, LOG_BP_CLEAR);
break;
case 'd':
case 'D':
logerror = LogBPChange(lpsz, LOG_BP_DISABLE);
break;
case 'e':
case 'E':
logerror = LogBPChange(lpsz, LOG_BP_ENABLE);
break;
case 'l':
case 'L':
if (*CPSkipWhitespace(lpsz) != 0) {
logerror = LOGERROR_UNKNOWN;
} else {
logerror = LogBPList();
}
break;
case 'p':
case 'P':
logerror = LogBPSet(FALSE, lpsz);
break;
case 'a':
case 'A':
logerror = LogBPSet(TRUE, lpsz);
break;
default:
logerror = LOGERROR_UNKNOWN;
}
break;
case 'c':
case 'C':
logerror = LogCompare(lpsz);
break;
case 'd':
#ifdef MS_INTERNAL_DONT_COMPILE_THIS_DAMMIT
if ( lpsz[0] == 'C'
&& lpsz[1] == 'R'
&& lpsz[2] == 'E'
&& lpsz[3] == 'D'
&& lpsz[4] == 'I'
&& lpsz[5] == 'T'
&& lpsz[6] == 'S'
&& lpsz[7] == 0)
{
logerror = LOGERROR_NOERROR;
Egg();
break;
}
#endif
case 'D':
if (*CPSkipWhitespace(lpsz) == 0) {
ch = chLastDump;
} else {
ch = *lpsz++;
}
if (ch == 'c' || ch == 'C') {
logerror = LogDisasm(lpsz,FALSE);
} else {
logerror = LogDumpMem(ch, lpsz);
}
chLastDump = ch;
break;
case 'e':
case 'E':
logerror = LogEnterMem(lpsz);
break;
case 'f':
case 'F':
if (*lpsz == 'i' || *lpsz == 'I') {
logerror = LogFill(++lpsz);
} else if (*lpsz == 'r' || *lpsz == 'R') {
logerror = LogRegisters(++lpsz, TRUE);
} else {
logerror = LogFreeze(lpsz, TRUE);
}
break;
case 'h':
case 'H':
logerror = LogHelp(lpsz);
break;
case 'g':
case 'G':
if (*lpsz == 'h' || *lpsz == 'H') {
logerror = LogGoException(++lpsz, TRUE);
} else if (*lpsz == 'n' || *lpsz == 'N') {
logerror = LogGoException(++lpsz, FALSE);
} else {
logerror = LogGoUntil(lpsz);
}
retCmd = CMD_RET_ASYNC;
break;
case 'k':
case 'K':
logerror = LogCallStack(lpsz);
break;
case 'l':
case 'L':
if (*lpsz == 'n' || *lpsz == 'N') {
logerror = LogListNear(++lpsz);
} else if (*lpsz == 'm' || *lpsz == 'M') {
BOOL fExtendedLoadInfo = 'x' == tolower(lpsz[1]);
if (fExtendedLoadInfo) {
// skip over'x', else windbg will think we mean lm x.
// Where 'x' is a module name
lpsz++;
}
logerror = LogListModules(
++lpsz,
fExtendedLoadInfo
);
} else if (*lpsz == 'd' || *lpsz == 'D') {
logerror = LogLoadDefered(++lpsz);
} else if (*lpsz == '\0' || *lpsz == ' ' || *lpsz == '\t') {
logerror = LogRestart(lpsz);
} else {
logerror = LOGERROR_UNKNOWN;
}
break;
case 'm':
case 'M':
logerror = LogMovemem(lpsz);
break;
case 'n':
case 'N':
logerror = LogRadix(lpsz);
break;
case 'p':
case 'P':
logerror = LogStep(lpsz, TRUE);
retCmd = CMD_RET_ASYNC;
break;
case 'q':
case 'Q':
lpsz = CPSkipWhitespace(lpsz);
if (*lpsz == 0) {
PostMessage(hwndFrame, WM_COMMAND, IDM_FILE_EXIT, 0L);
} else {
logerror = LOGERROR_UNKNOWN;
}
retCmd = CMD_RET_ASYNC;
break;
case 'r':
case 'R':
if (*lpsz == 'e' && _strnicmp(lpsz,"emote",5)==0) {
lpsz += 5;
logerror = LogRemote(lpsz);
} else {
logerror = LogRegisters(lpsz, FALSE);
}
break;
case 's':
case 'S':
switch (*lpsz) {
case 'e':
case 'E':
LogSetErrorLevel(++lpsz);
break;
case 'x':
case 'X':
logerror = LogException(++lpsz);
break;
case '-':
SetSrcMode_StatusBar(FALSE);
break;
case '+':
SetSrcMode_StatusBar(TRUE);
break;
default:
logerror = LogSearch(lpsz);
break;
}
break;
case 't':
case 'T':
logerror = LogStep(lpsz, FALSE);
retCmd = CMD_RET_ASYNC;
break;
case 'u':
case 'U':
logerror = LogDisasm(lpsz,FALSE);
break;
case '#':
logerror = LogSearchDisasm(lpsz);
break;
case 'w':
case 'W':
if (*lpsz == 't' || *lpsz == 'T') {
logerror = LogWatchTime(lpsz+1);
} else {
logerror = LOGERROR_UNKNOWN;
}
break;
case 'x':
case 'X':
logerror = LogExamine(lpsz);
break;
case 'v':
case 'V':
if (*lpsz == 'e' && _strnicmp(lpsz,"ersion",6)==0) {
logerror = LogVersion(lpsz);
} else {
logerror = LOGERROR_UNKNOWN;
}
break;
case 'z':
case 'Z':
logerror = LogFreeze(lpsz, FALSE);
break;
case '!':
logerror = LogExtension(lpsz);
break;
default:
logerror = LOGERROR_UNKNOWN;
break;
}
/*
*/
done:
switch (logerror) {
case LOGERROR_CP:
// get CP error string...
default:
case LOGERROR_UNKNOWN:
CmdInsertInit();
CmdLogVar(ERR_Command_Error);
// fall thru
case LOGERROR_QUIET:
retCmd = CMD_RET_ERROR;
break;
case LOGERROR_ASYNC:
case LOGERROR_NOERROR:
break;
}
return( retCmd );
} /* CmdExecuteCmd() */
VOID
CmdInsertInit(
void
)
/*++
Routine Description:
Set the insertion point to the beginning of the last
line in the window.
Arguments:
None
Return Value:
None
--*/
{
#if !defined( NEW_WINDOWING_CODE )
if (cmdView == -1) {
OpenDebugWindow(COMMAND_WIN, FALSE); // Not user activated
}
XNew = 0;
YNew = max(Docs[Views[cmdView].Doc].NbLines-1, 0);
return;
#endif
} /* CmdInsertInit() */
DWORD
LogFileWrite(
LPBYTE lpb,
DWORD cb
)
{
if (hFileLog == INVALID_HANDLE_VALUE) {
return 0;
}
EnterCriticalSection( &csLog );
WriteFile( hFileLog, lpb, cb, &cb, NULL );
LeaveCriticalSection( &csLog );
return cb;
}
VOID
RichEditControl_InsertCR(
HWND hwnd
)
/*++
Routine Description:
This function is used to insert a CR into a command window history.
Only inserts a CR into the the history section of the command window.
Arguments:
Return Value:
TRUE if sucessful and FALSE otherwise
--*/
{
CHARRANGE chrgOld;
CHARRANGE chrgNew;
TEXTRANGE TextRange;
// Ensure that the command window exists
Assert(hwnd);
// Store the currently selected text
SendMessage(hwnd,
EM_EXGETSEL,
0,
(LPARAM) &chrgOld
);
// Append the text
chrgNew.cpMin = INT_MAX -1;
chrgNew.cpMax = INT_MAX;
SendMessage(hwnd,
EM_EXSETSEL,
0,
(LPARAM) &chrgNew
);
SendMessage(hwnd,
EM_REPLACESEL,
FALSE,
(LPARAM) _T("\r\n")
);
// Restore the previous selection
SendMessage(hwnd,
EM_EXSETSEL,
0,
(LPARAM) &chrgOld
);
}
#if defined( NEW_WINDOWING_CODE )
BOOL
StringLogger(
const TCHAR const *pszStr,
BOOL fFileLog,
BOOL fSendRemote,
BOOL fPrintLocal
)
/*++
Routine Description:
This function is used to record data into the command window. It
will take care of checking for overflow in the current command line.
It is used in association with CmdInsertInit.
Additionally this function will log the string in the log file if
logging to file is currently enabled.
Arguments:
pszStr - Supplies the string to be logged in the command window.
fFileLog - If TRUE, the string is logged to the log file.
fSendRemote - If TRUE, the string is sent to the command window.
fPrintLocal - if TRUE, the string is logged to MDI command window.
Return Value:
TRUE if sucessful and FALSE otherwise
--*/
{
PCSTR pszStart;
PCSTR pszEnd;
BOOL fUpdateScreen = FALSE;
TCHAR szLoggerBuf[MAX_USER_LINE+2];
CHARRANGE chrgOld;
TEXTRANGE TextRange;
PCMDWIN_DATA pCmdWinData;
// Ensure that the command window exists
if ( !g_DebuggerWindows.hwndCmd ) {
if ( !NewCmd_CreateWindow(g_hwndMDIClient) ) {
fPrintLocal = FALSE; // No window to log to.
}
}
AuxPrintf(1, "### %s", pszStr);
if (!fPrintLocal) {
if (fFileLog) {
LogFileWrite( (LPBYTE) pszStr, strlen(pszStr) );
}
if (fSendRemote) {
SendClientOutput( pszStr, strlen(pszStr) );
}
return TRUE;
}
pCmdWinData = GetCmdWinData(g_DebuggerWindows.hwndCmd);
if (!pCmdWinData) {
return FALSE;
}
SendMessage(pCmdWinData->hwndHistory,
EM_EXGETSEL,
0,
(LPARAM) &chrgOld
);
// are there too many lines in the buffer?
if (MAX_CMDWIN_LINES < SendMessage(pCmdWinData->hwndHistory,
EM_GETLINECOUNT,
0,
0
)) {
// delete more than we need to so it doesn't happen
// every time a line is printed.
TextRange.chrg.cpMin = 0;
// Get the character index of the 50th line
TextRange.chrg.cpMax = SendMessage(pCmdWinData->hwndHistory,
EM_LINEINDEX,
50,
0
);
SendMessage(pCmdWinData->hwndHistory,
EM_EXSETSEL,
0,
(LPARAM) &TextRange.chrg
);
SendMessage(pCmdWinData->hwndHistory,
EM_REPLACESEL,
FALSE,
(LPARAM) ""
);
}
// Append the text to the command windows history.
// Set the selection to the very end, so that
// text will be appended.
TextRange.chrg.cpMin = INT_MAX -1;
TextRange.chrg.cpMax = INT_MAX;
SendMessage(pCmdWinData->hwndHistory,
EM_EXSETSEL,
0,
(LPARAM) &TextRange.chrg
);
// Output the text to the cmd window
pszStart = pszEnd = pszStr;
for ( ; *pszEnd; pszStart = pszEnd) {
size_t uNumCharOut; // Number of characters to send to the cmd window.
BOOL fDoCR = FALSE;
// Find the carriage and line feeds
pszEnd = pszStart + _tcscspn(pszStart, "\r\n");
if (!*pszEnd) {
// The text does not contain a line feed or carriage return
// simply output the text.
uNumCharOut = _tcslen(pszStr);
} else {
// The text DOES contain line braks and carriage returns.
uNumCharOut = pszEnd - pszStart;
// skip over the line feeds and carriage returns
if (*pszEnd == '\r') {
pszEnd++;
}
if (*pszEnd == '\n') {
pszEnd++;
}
fDoCR = TRUE;
fUpdateScreen = TRUE;
}
// Output the text to the window
while (uNumCharOut) {
size_t uOut = min( uNumCharOut, _tsizeof(szLoggerBuf) -1 );
memmove(szLoggerBuf, pszStart, uOut);
szLoggerBuf[uOut] = 0;
SendMessage(pCmdWinData->hwndHistory,
EM_REPLACESEL,
FALSE,
(LPARAM) szLoggerBuf
);
uNumCharOut -= uOut;
}
if (fDoCR) {
SendMessage(pCmdWinData->hwndHistory,
EM_REPLACESEL,
FALSE,
(LPARAM) _T("\r\n")
);
}
}
// Reset the currently selected text
SendMessage(pCmdWinData->hwndHistory,
EM_EXSETSEL,
0,
(LPARAM) &chrgOld
);
if (fUpdateScreen) {
//UpdateWindow(pCmdWinData->hwndHistory);
}
return TRUE;
} /* StringLogger() */
#else //NEW_WINDOWING_CODE
BOOL
StringLogger(
LPCSTR szStr,
BOOL fFileLog,
BOOL fSendRemote,
BOOL fPrintLocal
)
/*++
Routine Description:
This function is used to record data into the command window. It
will take care of checking for overflow in the current command line.
It is used in association with CmdInsertInit.
Additionally this function will log the string in the log file if
logging to file is currently enabled.
Arguments:
buf - Supplies the string to be logged in the command window.
fFileLog - Supplies TRUE if logging to a log file is desired.
Return Value:
TRUE if sucessful and FALSE otherwise
--*/
{
LPLINEREC pLine;
LPBLOCKDEF pBlock;
int cWide;
int doc = Views[cmdView].Doc;
int PosXold = Views[cmdView].X;
int PosYold = Views[cmdView].Y;
int XOld = XNew; // remember original insertion point
int YOld = YNew;
int XNext; // IP after pending insert
int YNext;
int Xro;
int Yro;
long ytmp;
LPCSTR lpsz;
int cch;
LPSTR lpPut;
BOOL fDidCR = FALSE;
BOOL fRet = TRUE;
CHAR szLoggerBuf[MAX_USER_LINE+2];
AuxPrintf(1, "### %s", szStr);
/*
* Ensure that the command window exists
*/
Assert(cmdView != -1);
/*
* We are going to insert at XNew,YNew.
* We need to know where we ended up...
*/
YNext = YNew;
XNext = XNew;
lpsz = szStr;
lpPut = szLoggerBuf;
if (!fPrintLocal) {
if (fFileLog) {
LogFileWrite( (LPBYTE) lpsz, strlen(lpsz) );
}
if (fSendRemote) {
SendClientOutput( lpsz, strlen(lpsz) );
}
return fRet;
}
for ( ; *lpsz; lpPut = szLoggerBuf) {
ytmp = YNew; // FirstLine modifies the lineNo!!!!
// find how much line we have to work with:
Dbg (FirstLine(doc, &pLine, &ytmp, &pBlock));
cWide = AlignToTabs(pLine->Length - LHD,
pLine->Length - LHD,
(LPSTR)pLine->Text);
while (*lpsz) {
int cx = 1;
if (IsDBCSLeadByte(*lpsz) && *(lpsz+1)) {
if (XNext + 2 < (MAX_USER_LINE - cWide)) {
*lpPut++ = *lpsz++;
*lpPut++ = *lpsz++;
XNext += 2;
continue;
} else {
goto DoNewline;
}
}
if (*lpsz == '\r') {
// if there is a newline, eat it:
if (*++lpsz == '\n') {
lpsz++;
}
goto DoNewline;
} else if (*lpsz == '\n') {
lpsz++;
goto DoNewline;
} else {
cx = 1;
if (*lpsz == '\t') {
cx = g_contGlobalPreferences_WkSp.m_nTabSize - (XNext % g_contGlobalPreferences_WkSp.m_nTabSize);
}
if (XNext + cx < (MAX_USER_LINE - cWide)) {
*lpPut++ = *lpsz++;
XNext += cx;
} else {
DoNewline:
*lpPut++ = '\r';
*lpPut++ = '\n';
YNext++;
XNext = 0;
fDidCR = TRUE;
break;
}
}
}
*lpPut = '\0';
// remember readonly info, clear it:
GetRORegion(cmdView, &Xro, &Yro);
SetRORegion(cmdView, 0, 0);
// spew buffer
cch = (int) (lpPut - szLoggerBuf);
fRet = InsertBlock(doc, XNew, YNew, cch, szLoggerBuf);
// fix read only marker
if (fRet) {
if (YNew < Yro) {
Yro += YNext - YNew;
} else if (YNew == Yro && XNew < Xro) {
Yro += YNext - YNew;
Xro += XNext - XNew;
}
}
SetRORegion(cmdView, Xro, Yro);
if (!fRet) {
break;
}
// remember new insertion point
XNew = XNext;
YNew = YNext;
if (fFileLog) {
LogFileWrite( (PBYTE) szLoggerBuf, cch );
}
if (fSendRemote) {
SendClientOutput( szLoggerBuf, cch );
}
}
// are there too many lines in the buffer?
ytmp = max(Docs[doc].NbLines, 1) - MAX_CMDWIN_LINES;
if (ytmp > 0) {
// delete more than we need to so it doesn't happen
// every time a line is printed.
ytmp += 20;
GetRORegion(cmdView, &Xro, &Yro);
SetRORegion(cmdView, 0, 0);
// This means delete full lines
DeleteBlock(doc, 0, 0, 0, ytmp);
YNew -= ytmp;
YOld -= ytmp;
PosYold -= ytmp;
Yro -= ytmp;
YNewDebug -= ytmp;
SetRORegion(cmdView, Xro, Yro);
InvalidateRect(Views[cmdView].hwndClient, NULL, FALSE);
}
SetVerticalScrollBar(cmdView, FALSE);
InvalidateLines(cmdView, YOld, YNew, TRUE);
if (YOld <= PosYold) {
// insert was on or before cursor line:
PosYold += YNew - YOld;
}
PosXY(cmdView, PosXold, PosYold, FALSE);
if (fDidCR) {
UpdateWindow(Views[cmdView].hwndClient);
}
return fRet;
} /* StringLogger() */
#endif
int
CDECL
CmdLogVar(
WORD wFormat,
...
)
/*++
Routine Description:
Format arguments with vsprintf, print with stringlogger
Arguments:
wFormat - Supplies resource ID for format string
.... - Optional args supply values to be formatted by vsprintf
Return Value:
Return value from StringLogger
--*/
{
char szFormat[MAX_MSG_TXT];
char szText[MAX_VAR_MSG_TXT];
va_list vargs;
// load format string from resource file
Dbg(LoadString(g_hInst, wFormat, (LPSTR)szFormat, MAX_MSG_TXT));
va_start(vargs, wFormat);
vsprintf(szText, szFormat, vargs);
va_end(vargs);
if (cmdView == -1) {
#if defined( NEW_WINDOWING_CODE )
New_OpenDebugWindow(CMD_WINDOW, FALSE); // Not user activated
#else
OpenDebugWindow(COMMAND_WIN, FALSE); // Not user activated
#endif
}
/*
* If we just change from doing a debug string to doing something else
* then we need to insert a return in the command string.
*/
FDebugString = FALSE;
return StringLogger(szText, TRUE, TRUE, TRUE) &&
StringLogger("\r\n", TRUE, TRUE, TRUE);
} /* CmdLogVar() */
void
WDBGAPIV
CmdLogFmt(
LPCSTR lpFmt,
...
)
/*++
Routine Description:
Format arguments with vsprintf and print result with StringLogger
Arguments:
lpFmt - Supplies pointer to format string
... - Optional args supply values to be formatted
Return Value:
Return value from StringLogger
--*/
{
char szText[MAX_VAR_MSG_TXT];
va_list vargs;
va_start(vargs, lpFmt);
_vsnprintf(szText, MAX_VAR_MSG_TXT-1, lpFmt, vargs);
va_end(vargs);
if (cmdView == -1 ) {
#if defined( NEW_WINDOWING_CODE )
New_OpenDebugWindow(CMD_WINDOW, FALSE); // Not user activated
#else
OpenDebugWindow(COMMAND_WIN, FALSE); // Not user activated
#endif
}
/*
* If we just change from doing a debug string to doing something else
* then we need to insert a return in the command string.
*/
FDebugString = FALSE;
StringLogger(szText, TRUE, TRUE, TRUE);
} /* CmdLogFmt() */
void
WDBGAPIV
CmdLogFmtEx(
BOOL fFileLog,
BOOL fSendRemote,
BOOL fPrintLocal,
LPCSTR lpFmt,
...
)
/*++
Routine Description:
Format arguments with vsprintf and print result with StringLogger
Arguments:
lpFmt - Supplies pointer to format string
... - Optional args supply values to be formatted
Return Value:
Return value from StringLogger
--*/
{
char szText[MAX_VAR_MSG_TXT];
va_list vargs;
va_start(vargs, lpFmt);
_vsnprintf(szText, MAX_VAR_MSG_TXT-1, lpFmt, vargs);
va_end(vargs);
if (cmdView == -1 ) {
#if defined( NEW_WINDOWING_CODE )
New_OpenDebugWindow(CMD_WINDOW, FALSE); // Not user activated
#else
OpenDebugWindow(COMMAND_WIN, FALSE); // Not user activated
#endif
}
/*
* If we just change from doing a debug string to doing something else
* then we need to insert a return in the command string.
*/
FDebugString = FALSE;
StringLogger(szText,
fFileLog,
fSendRemote,
fPrintLocal
);
} /* CmdLogFmt() */
BOOL
CmdNoLogString(
LPCSTR buf
)
/*++
Routine Description:
This function is used to record data into the command window. It
will take care of checking for overflow in the current command line.
It is used in association with CmdInsertInit.
Arguments:
buf - Supplies the string to be logged in the command window
Return Value:
TRUE if successful and FALSE otherwise.
--*/
{
/*
* If we just change from doing a debug string to doing something else
* then we need to insert a return in the command string.
*/
if (cmdView == -1) {
#if defined( NEW_WINDOWING_CODE )
New_OpenDebugWindow(CMD_WINDOW, FALSE); // Not user activated
#else
OpenDebugWindow(COMMAND_WIN, FALSE); // Not user activated
#endif
}
FDebugString = FALSE;
return StringLogger(buf, FALSE, TRUE, TRUE);
} /* CmdNoLogString() */
VOID
CmdLogDebugString(
LPSTR lpStr,
BOOL fSendRemote
)
/*++
Routine Description:
This function is used to put out debug strings into the command
window. This needs to deal with the possiblity of not having
returns on the end of a string.
Arguments:
lpStr - Supplies pointer to characters to be displayed
Return Value:
None
--*/
{
static int fDebugNewline;
static int XNewSave;
LPSTR lpszOriginal;
LPSTR lpszDuplicate;
LPSTR lpszTmp;
XNewSave = XNew;
if (!FDebugString) {
CmdInsertInit();
fDebugNewline = TRUE;
} else {
XNew = XNewDebug;
YNew = YNewDebug;
}
// don't modify src string!!
lpszTmp = lpszDuplicate = lpszOriginal = _strdup(lpStr);
for (;;) {
if (*lpszTmp == 0) {
if (lpszTmp > lpszDuplicate) {
StringLogger(lpszDuplicate, TRUE, fSendRemote, TRUE);
}
break;
} else if (fDebugNewline) {
StringLogger("\r\n", FALSE, FALSE, TRUE);
--YNew;
fDebugNewline = FALSE;
} else if (*lpszTmp == '\n') {
*lpszTmp++ = 0;
StringLogger(lpszDuplicate, TRUE, fSendRemote, TRUE);
lpszDuplicate = lpszTmp;
fDebugNewline = TRUE;
StringLogger("\r\n", TRUE, fSendRemote, FALSE);
CmdInsertInit();
} else if (*lpszTmp == '\r') {
*lpszTmp++ = 0;
if (*lpszTmp == '\n') {
lpszTmp++;
}
StringLogger(lpszDuplicate, TRUE, fSendRemote, TRUE);
lpszDuplicate = lpszTmp;
fDebugNewline = TRUE;
StringLogger("\r\n", TRUE, fSendRemote, FALSE);
CmdInsertInit();
} else {
lpszTmp = CharNext( lpszTmp );
}
}
FDebugString = TRUE;
XNewDebug = XNew;
YNewDebug = YNew;
CmdInsertInit();
XNew = XNewSave;
free(lpszOriginal);
} /* CmdLogDebugString() */
VOID
CmdFileString(
LPSTR lpsz
)
/*++
Routine Description:
This function is used to dump a string only to the log file.
Arguments:
lpsz - Supplies string to be dumped to the file
Return Value:
None
--*/
{
LogFileWrite( (LPBYTE) lpsz, strlen(lpsz) );
return;
} /* CmdFileString() */
BOOL
CmdAutoRunInit(
void
)
/*++
Routine Description:
This routine is called to set up the internal AutoRun variables
to read command from a file and get them processed
Arguments:
None
Return Value:
None
--*/
{
Assert( AutoRun == arSource || AutoRun == arCmdline );
if ((fpAutoRun = fopen(PszAutoRun, "rb")) == NULL) {
return FALSE;
}
PostMessage(Views[cmdView].hwndClient, WU_AUTORUN, 0, 0);
return TRUE;
} /* CmdAutoRunInit() */
void
CmdAutoRunNext(
void
)
/*++
Routine Description:
Get the next line from the auto run file and cause it to be processed
Arguments:
None
Return Value:
None
--*/
{
char rgchCmd[300];
char * ptr;
Assert(AutoRun != arNone);
if (AutoRun == arQuit || fpAutoRun == NULL) {
return;
}
while (fgets(rgchCmd, sizeof(rgchCmd), fpAutoRun) != NULL) {
/*
** Sanitize
*/
ptr = rgchCmd + strlen(rgchCmd);
while (ptr > rgchCmd) {
ptr = CharPrev(rgchCmd, ptr);
if ( *ptr != '\n' && *ptr != '\r') {
break;
}
*ptr = '\0';
}
/*
** Log the command into the command window
*/
if (cmdView != -1) {
Views[cmdView].X = 0;
}
CmdDoPrompt(TRUE, TRUE);
CmdLogFmt("%s\r\n", rgchCmd);
/*
** Do it, and return on asynch commands
*/
if (CmdDoLine(rgchCmd) == FALSE) {
return;
}
}
AutoRun = arNone;
return;
} /* CmdAutoRunNext() */
LOGERR
LogSource(
LPSTR lpsz,
DWORD dwUnused
)
{
AutoRun = arSource;
lpsz = CPSkipWhitespace(lpsz);
PszAutoRun = _strdup(lpsz);
if (CmdAutoRunInit()) {
return LOGERROR_NOERROR;
} else {
CmdLogVar( ERR_File_Open, PszAutoRun );
free(PszAutoRun);
PszAutoRun = NULL;
return LOGERROR_QUIET;
}
}
LOGERR
LogFileOpen(
LPSTR lpsz,
DWORD fAppend
)
/*++
Routine Description:
This function will open up a log file name. By default if no
name is specified we will use "QCWIN.LOG" as the default name.
If fAppend is TRUE then we append to the end if the specified
file, else we create the requested file.
Arguments:
lpsz - Supplies string containning the log file name
fAppend - Supplies TRUE if append to the specified file
Return Value:
log error code
--*/
{
char rgch[256];
CmdInsertInit();
/*
** Skip over any leading whitespace
*/
lpsz = CPSkipWhitespace(lpsz);
/*
** Setup a default name if none was specified
*/
if (*lpsz == 0) {
MakeFileNameFromProg(".LOG", rgch);
lpsz = rgch;
}
/*
** If a handle is already open then we will close that file
*/
if (hFileLog != INVALID_HANDLE_VALUE) {
CloseHandle( hFileLog );
}
/*
** Open a handle onto the requested file
*/
hFileLog = CreateFile( lpsz,
GENERIC_WRITE | GENERIC_READ,
FILE_SHARE_READ,
NULL,
fAppend ? OPEN_ALWAYS : CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, // | FILE_FLAG_WRITE_THROUGH,
NULL
);
if (fAppend) {
SetFilePointer(hFileLog, 0, NULL, FILE_END);
}
if (hFileLog == INVALID_HANDLE_VALUE) {
CmdLogVar(ERR_File_Open, lpsz);
return LOGERROR_QUIET;
}
/*
** All done -- return
*/
return LOGERROR_NOERROR;
} /* LogFileOpen() */
LOGERR
LogFileClose(
LPSTR lpUnused,
DWORD dwUnused
)
/*++
Routine Description:
Close the log file
Arguments:
None
Return Value:
log error code
--*/
{
LOGERR lerr = LOGERROR_NOERROR;
CmdInsertInit();
EnterCriticalSection( &csLog );
if (hFileLog != INVALID_HANDLE_VALUE) {
CloseHandle(hFileLog);
hFileLog = INVALID_HANDLE_VALUE;
} else {
CmdLogVar(ERR_File_Not_Open);
lerr = LOGERROR_QUIET;
}
LeaveCriticalSection( &csLog );
return lerr;
} /* LogFileClose() */
LOGERR
LogOpenDoc(
LPSTR lpsz,
DWORD dwUnused
)
{
int ret;
CmdInsertInit();
// Skip over any leading whitespace
lpsz = CPSkipWhitespace(lpsz);
// Require a name
if (*lpsz == 0) {
return LOGERROR_UNKNOWN;
}
if (hFileLog != INVALID_HANDLE_VALUE) {
CloseHandle( hFileLog );
}
ret = AddFile(MODE_OPENCREATE,
DOC_WIN,
lpsz,
NULL,
NULL,
TRUE,
-1,
-1,
TRUE
);
return ret == -1 ? LOGERROR_UNKNOWN : LOGERROR_NOERROR;
} /* LogOpenDoc */
LOGERR
LogWaitForString(
LPSTR lpsz,
DWORD dwUnused
)
/*++
Routine Description:
Waits for a debug string
Arguments:
lpsz - Supplies string containning the log file name
fAppend - not used
Return Value:
log error code
--*/
{
CmdInsertInit();
/*
** Skip over any leading whitespace
*/
lpsz = CPSkipWhitespace(lpsz);
if (*lpsz == 0) {
return LOGERROR_QUIET;
}
lpCmdString = _strdup(lpsz);
fWaitForDebugString = TRUE;
/*
** All done -- return
*/
return LOGERROR_ASYNC;
} /* LogWaitForString() */
LOGERR LogSleep(LPSTR lpsz, DWORD dwUnused)
/*++
Routine Description:
Waits for n seconds.
Arguments:
lpsz - seconds to sleep
fAppend - not used
Return Value:
log error code
--*/
{
CmdInsertInit();
/*
** Skip over any leading whitespace
*/
lpsz = CPSkipWhitespace(lpsz);
if (*lpsz == 0) {
return LOGERROR_QUIET;
}
Sleep( atol(lpsz) * 1000 );
/*
** All done -- return
*/
return LOGERROR_NOERROR;
} /* LogSleep() */
LOGERR LogBreak(LPSTR lpsz, DWORD dwUnused)
/*++
Routine Description:
Call AsyncStop() to halt debuggee.
Arguments:
lpsz - not used
fAppend - not used
Return Value:
log error code
--*/
{
CmdInsertInit();
AsyncStop();
return LOGERROR_NOERROR;
} /* LogBreak() */
LOGERR
LogDotHelp(
LPSTR lpsz
)
{
int i;
CmdInsertInit();
for (i = 0; i < NDOTS; i++) {
CmdLogFmt("%s %s\r\n", DotTable[i].lpName, DotTable[i].lpDesc);
}
return LOGERROR_NOERROR;
}
LOGERR
LogDotCommand(
LPSTR lpsz
)
{
int i;
int l;
LPPD lppd;
LPTD lptd;
BOOL fNoError = FALSE;
XOSD xosd = xosdUnknown;
DWORD dw;
lpsz = CPSkipWhitespace(lpsz);
if (!*lpsz) {
return LOGERROR_UNKNOWN;
}
if (*lpsz == '?') {
LogDotHelp(lpsz + 1);
fNoError = TRUE;
} else if (_strnicmp(lpsz, "help", (size_t) 4) == 0) {
LogDotHelp(lpsz + 4);
fNoError = TRUE;
} else if (!(g_contWorkspace_WkSp.m_bKernelDebugger && !_strnicmp(lpsz, "crash", (size_t) 5)) ) {
// If we are kernel debugging, the .crash should be passed to the EM,
// else try to find the appropiate handler
for (i = 0; i < NDOTS; i++) {
l = strlen(DotTable[i].lpName);
if (_strnicmp(lpsz, DotTable[i].lpName, l) == 0)
{
break;
}
}
if (i < NDOTS) {
return (*DotTable[i].lpfnHandler)(lpsz+l, DotTable[i].dwArg);
}
}
// Pass unrecognized commands and "?" or "help" to the EM:
lppd = LppdCur;
lptd = LptdCur;
if (!lppd || !lppd->hpid) {
lppd = LppdFirst;
lptd = NULL;
}
if (lppd && lppd->hpid) {
xosd = OSDSystemService(lppd->hpid,
lptd? lptd->htid : 0,
(SSVC) ssvcCustomCommand,
(LPVOID)lpsz,
strlen(lpsz)+1,
&dw
);
}
return (fNoError || xosd == xosdNone)? LOGERROR_NOERROR : LOGERROR_UNKNOWN;
}
LOGERR
LogOptions(
LPSTR lpsz,
DWORD dwUnused
)
/*++
Routine Description:
.opt command
Arguments:
lpsz - Supplies command line tail
Return Value:
LOGERROR code
--*/
{
int i;
int n;
char szToken[MAX_USER_LINE];
CmdInsertInit();
lpsz = CPSkipWhitespace(lpsz);
if (!*lpsz) {
for (i = 0; i < NOPTS; i++) {
(*OptionTable[i].lpfnHandler)(OptionTable[i].lpData,
OptionTable[i].cbSize,
szToken,
FALSE);
CmdLogFmt("%-21s %s\r\n", OptionTable[i].lpName, szToken);
}
return LOGERROR_NOERROR;
}
n = CPCopyToken(&lpsz, szToken);
lpsz = CPSkipWhitespace(lpsz);
for (i = 0; i < NOPTS; i++) {
if (_stricmp(OptionTable[i].lpName, szToken) == 0) {
break;
}
}
if (i >= NOPTS) {
CmdLogVar(ERR_Invalid_Option);
return LOGERROR_QUIET;
}
// special for help:
if (i == 0) {
(*OptionTable[i].lpfnHandler)(OptionTable[i].lpData,
OptionTable[i].cbSize,
lpsz,
TRUE);
return LOGERROR_NOERROR;
} else if (!*lpsz) {
(*OptionTable[i].lpfnHandler)(OptionTable[i].lpData,
OptionTable[i].cbSize,
szToken,
FALSE);
CmdLogFmt("%-21s %s\r\n", OptionTable[i].lpName, szToken);
return LOGERROR_NOERROR;
} else if ((*OptionTable[i].lpfnHandler)(OptionTable[i].lpData,
OptionTable[i].cbSize,
lpsz,
TRUE)) {
return LOGERROR_NOERROR;
} else {
return LOGERROR_QUIET;
}
}
LOGERR
LogRadix(
LPSTR lpsz
)
/*++
Routine Description:
This function is used to change the display and input radix for
the system.
Arguments:
lpsz - String with the command
Return Value:
log error code
--*/
{
int err;
int cch;
int i;
CmdInsertInit();
/*
** Check for no arguement
*/
lpsz = CPSkipWhitespace(lpsz);
if (*lpsz == 0) {
CmdLogFmt("%d\r\n", radix);
return LOGERROR_NOERROR;
}
/*
** An argument -- must be a number in base 10
*/
i = (int) CPGetInt(lpsz, &err, &cch);
if (err) {
return LOGERROR_UNKNOWN;
}
if (i != 8 && i != 10 && i != 16) {
CmdLogVar(ERR_Radix_Invalid);
return LOGERROR_QUIET;
}
UpdateRadix(i);
return LOGERROR_NOERROR;
} /* LogRadix() */
LOGERR
LogSetErrorLevel(
LPSTR lpsz
)
/*++
Routine Description:
Set error reporting and break levels for RIPs.
Arguments:
lpsz - Supplies tail of command, after "se"
Return Value:
LOGERROR code
--*/
{
int i;
char chCmd;
int err, cch;
CmdInsertInit();
chCmd = *lpsz++;
if (!strchr( (PBYTE) "bBwW", chCmd)) {
return LOGERROR_UNKNOWN;
}
/*
** Check for no argument
*/
lpsz = CPSkipWhitespace(lpsz);
if (*lpsz == 0) {
CmdLogVar(DBG_Notify_Break_Levels, ulRipNotifyLevel, ulRipBreakLevel);
return LOGERROR_NOERROR;
}
/*
** An argument -- must be a number in base 10
*/
i = (int) CPGetInt(lpsz, &err, &cch);
if (err) {
return LOGERROR_UNKNOWN;
}
if (i < 0 || i > 3) {
CmdLogVar(ERR_Error_Level_Invalid);
return LOGERROR_QUIET;
}
if (chCmd == 'w' || chCmd == 'W') {
ulRipNotifyLevel = (ULONG)i;
} else {
ulRipBreakLevel = (ULONG)i;
if ((ULONG)i > ulRipNotifyLevel) {
ulRipNotifyLevel = (ULONG)i;
}
}
return LOGERROR_NOERROR;
} /* LogSetErrorLevel() */
LOGERR
LogReload(
LPSTR lpsz,
DWORD dwUnused
)
{
LPPD lppd = NULL;
LPTD lptd = NULL;
XOSD xosd = xosdUnknown;
MSG msg;
PIOCTLGENERIC pig;
DWORD dw;
IsKdCmdAllowed();
if (DebuggeeActive()) {
lppd = LppdCur;
lptd = LptdCur;
if (!lppd || !lppd->hpid) {
Assert(LppdFirst);
lppd = LppdFirst;
lptd = lppd->lptdList;
}
lpsz = CPSkipWhitespace(lpsz);
if (lppd && lppd->hpid) {
pig = (PIOCTLGENERIC)malloc(strlen(lpsz) + 1 + sizeof(IOCTLGENERIC));
if (!pig) {
return FALSE;
}
pig->ioctlSubType = IG_RELOAD;
pig->length = strlen(lpsz) + 1;
strcpy((LPSTR)pig->data, lpsz);
xosd = OSDSystemService( lppd->hpid,
lptd->htid,
(SSVC) ssvcGeneric,
(LPV)pig,
strlen(lpsz) + 1 + sizeof(IOCTLGENERIC),
&dw
);
free( pig );
}
}
if (xosd == xosdNone) {
while (GetMessage( &msg, NULL, 0, 0 )) {
ProcessQCQPMessage( &msg );
if (WaitForSingleObject( hEventIoctl, 0 ) == WAIT_OBJECT_0) {
// Let's add this in so that we don't confuse anyone.
if (g_contWorkspace_WkSp.m_bKernelDebugger) {
CmdLogFmt( "Finished re-loading kernel modules\n" );
} else {
CmdLogFmt( "Finished re-loading user modules\n" );
}
ResetEvent( hEventIoctl );
// Notify the back-end that new symbols have been loaded
OSDNewSymbolsLoaded( lppd->hpid );
break;
}
}
UpdateDebuggerState( UPDATE_CONTEXT );
}
return (xosd == xosdNone) ? LOGERROR_NOERROR : LOGERROR_UNKNOWN;
}
LOGERR
LogList(
LPSTR lpsz,
DWORD dwUnused
)
/*++
Routine Description:
This routine prints mixed mode source & disassembly for a
address that is computed from the expression in the string
passed in. If the string is null then the list starts where
the last one left off.
Wesley Witt (wesw) - 29-May-1994
Arguments:
lpsz - Supplies the expression
dwUnused - as it says its unused
Return Value:
Log error code.
--*/
{
#define MAX_LINES 10
INT cch;
static ADDR addr = {0};
ADDR addrT;
ADDR addrN;
SDI sds;
LPSTR p;
CHAR buf[256];
LPSTR lpch;
INT cb;
DWORD i;
BOOL SourceFound;
CHAR SrcFname[MAX_PATH];
CHAR SrcFnameN[MAX_PATH];
DWORD lineno;
DWORD dwLineno = 0;
DWORD lastLineno = 0;
INT doc = 0;
LPLINEREC lr;
LPBLOCKDEF bd;
SHOFF cbLn = 0;
SHOFF dbLn;
CmdInsertInit();
IsKdCmdAllowed();
if ( !DebuggeeActive() ) {
// No debuggee - nothing to do.
CmdLogVar(ERR_Debuggee_Not_Alive);
return LOGERROR_QUIET;
}
// get the address for the user's expression
lpsz = CPSkipWhitespace(lpsz);
if (*lpsz) {
if (CPGetAddress( lpsz,
&cch,
&addr,
radix,
&CxfIp,
fCaseSensitive,
g_contWorkspace_WkSp.m_bMasmEval ) != CPNOERROR) {
CmdLogVar( ERR_AddrExpr_Invalid );
return LOGERROR_QUIET;
}
} else if (addr.addr.off == 0) {
addr = CxfIp.cxt.addr;
}
for (i=0; i<MAX_LINES; i++) {
// create a fixedup and unfixedup address
addrT = addr;
SYUnFixupAddr(&addr);
SYFixupAddr(&addrT);
// assume we cannot find any source
SourceFound = FALSE;
// locate the source file and line number for this address
if (!GetSourceFromAddress( &addr, SrcFname, sizeof(SrcFname), &lineno )) {
goto disasm;
}
// locate the document for the found source file name
if (!FindDoc( SrcFname, &doc, TRUE )) {
// the document was not found so lets map it in and
// create a document record
// Not user activated.
if (SrcMapSourceFilename( SrcFname, sizeof(SrcFname),
SRC_MAP_OPEN, FindDoc1,
// Not user activated
FALSE) < 0) {
goto disasm;
}
// locate the document for the found source file name
if (!FindDoc( SrcFname, &doc, TRUE )) {
goto disasm;
}
}
// adjust the line number and save it away in a dword
lineno = min(max(1, (int)lineno), (int)Docs[doc].NbLines) - 1;
dwLineno = lineno;
// kcarlos - BUGBUG -> BUGCAST
//if (!FirstLine( doc, &lr, &dwLineno, &bd )) {
if (!FirstLine( doc, &lr, (PLONG) &dwLineno, &bd )) {
goto disasm;
}
// this call is used only to get the code size for the
// current line number
if (!SLLineFromAddr ( &addr, &lineno, &cbLn, &dbLn )) {
goto disasm;
}
// print the source text
CmdLogFmt( "%4d: %s\n", dwLineno, lr->Text );
// set the source found flag to success
SourceFound = TRUE;
disasm:
// this is where the code is unassembled
// if there was no source found the this loop will
// unassemble one instrustion and move on to the next address
// set the disasm options to the user's settings
sds.dop = (g_contWorkspace_WkSp.m_dopDisAsmOpts & ~(0x800)) | dopAddr | dopOpcode | dopOperands;
// use the current source address
sds.addr = addrT;
do {
// call the disassm routine in the EM
if (OSDUnassemble( LppdCur->hpid, LptdCur->htid, &sds ) != xosdNone) {
CmdLogFmt( "Could not unassemble code for address 0x%08x\n", sds.addr.addr.off );
return LOGERROR_QUIET;
}
// format the assm code
p = &buf[0];
*p = 0;
if (sds.ichAddr != -1) {
sprintf(p, "%s ", &sds.lpch[sds.ichAddr]);
p += strlen(p);
}
cb = strlen(&sds.lpch[sds.ichAddr]) + 2;
if (sds.ichBytes != -1) {
lpch = sds.lpch + sds.ichBytes;
//v-vadimp - this breaks bundle byte string display on IA64
if (LppdCur->mptProcessorType != mptia64) {
while (strlen(lpch) > 16) {
sprintf(p, "%16.16s\r\n%*s", lpch, cb, " ");
p += strlen(p);
lpch += 16;
}
}
cb = 17 - strlen(lpch);
sprintf(p, "%-17s", lpch);
p += strlen(p);
}
if (LppdCur->mptProcessorType == mptia64 && sds.ichPreg != -1) {
sprintf(p, "%-5s", &sds.lpch[sds.ichPreg]);
p += strlen(p);
}
sprintf(p, "%-12s ", &sds.lpch[sds.ichOpcode]);
p += strlen(p);
if (sds.ichOperands != -1) {
sprintf(p, "%-25s ", &sds.lpch[sds.ichOperands]);
p += strlen(p);
} else if (sds.ichComment != -1) {
sprintf(p, "%25s ", " ");
p += strlen(p);
}
if (sds.ichComment != -1) {
sprintf(p, "%s", &sds.lpch[sds.ichComment]);
p += strlen(p);
}
// print the formatted code
CmdLogFmt( "%s\r\n", buf );
// if there was no source found then bail out
if (!SourceFound) {
break;
}
} while (sds.addr.addr.off <= addrT.addr.off + cbLn);
// setup for the next source line
addr = sds.addr;
// this causes the dead source, ie source that did not generate
// any code, to be printed.
if (i < MAX_LINES-1) {
// start at the last ending address
addrN = addr;
// the dead source is printed when the source file name for the
// next address is the same as the last address and ...
if ((GetSourceFromAddress( &addrN, SrcFnameN, sizeof(SrcFnameN), &lineno )) &&
(_stricmp(SrcFname, SrcFnameN) == 0)) {
// the line number is more that one greater
lineno = min(max(1, (int)lineno), (int)Docs[doc].NbLines) - 1;
if (lineno > dwLineno + 1) {
// enumerate all the dead source lines and print them
while (lineno > dwLineno) {
// kcarlos - BUGBUG -> BUGCAST
//if (NextLine( doc, &lr, &dwLineno, &bd )) {
if (NextLine( doc, &lr, (PLONG) &dwLineno, &bd )) {
CmdLogFmt( "%4d: %s\n", dwLineno, lr->Text );
}
}
}
}
}
}
// return success
return LOGERROR_NOERROR;
}
BOOL
NotifyDmOfProcessorChange(
DWORD Processor
)
{
XOSD xosd = xosdUnknown;
PIOCTLGENERIC pig;
DWORD dw;
if (!g_contWorkspace_WkSp.m_bKernelDebugger) {
return FALSE;
}
pig = (PIOCTLGENERIC)malloc(sizeof(ULONG) + sizeof(IOCTLGENERIC));
if (!pig) {
return FALSE;
}
pig->ioctlSubType = IG_CHANGE_PROC;
pig->length = sizeof(ULONG);
((PULONG)pig->data)[0] = Processor;
xosd = OSDSystemService( LppdCur->hpid,
NULL,
(SSVC) ssvcGeneric,
(LPV)pig,
pig->length + sizeof(IOCTLGENERIC),
&dw
);
free( pig );
return xosd == xosdNone;
}
Reference in New Issue View Git Blame Copy Permalink