able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/debuggers/ntsd64/ntsrc.cpp

1453 lines
30 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//----------------------------------------------------------------------------
//
// Source file searching and loading.
//
// Copyright (C) Microsoft Corporation, 1997-2001.
//
//----------------------------------------------------------------------------
#include "ntsdp.hpp"
// #define DBG_SRC
// #define VERBOSE_SRC
ULONG g_SrcOptions;
LPSTR g_SrcPath;
PSRCFILE g_SrcFiles;
PSRCFILE g_CurSrcFile;
ULONG g_CurSrcLine;
ULONG g_OciSrcBefore;
ULONG g_OciSrcAfter = 1;
PSRCFILE
LoadSrcFile(
LPSTR FileName,
LPSTR RecordFileName
)
{
PathFile* File;
PSRCFILE SrcFile, Realloc;
ULONG Avail;
ULONG BaseLen, Len, Done;
LPSTR Cur, End;
ULONG Lines;
LPSTR *CurLine, LineStart;
ULONG ReadLen;
if (OpenPathFile(FileName, g_SymOptions, &File) != S_OK)
{
return NULL;
}
BaseLen = sizeof(SRCFILE) + strlen(RecordFileName) + 1;
Len = BaseLen;
SrcFile = NULL;
for (;;)
{
if (File->QueryDataAvailable(&Avail) != S_OK)
{
goto EH_CloseFile;
}
if (Avail == 0)
{
if (SrcFile == NULL)
{
goto EH_CloseFile;
}
break;
}
Realloc = (SRCFILE *)realloc(SrcFile, Len + Avail);
if (Realloc == NULL)
{
goto EH_CloseFile;
}
SrcFile = Realloc;
if (File->Read((LPSTR)SrcFile + Len, Avail, &Done) != S_OK ||
Done < Avail)
{
goto EH_CloseFile;
}
Len += Avail;
}
SrcFile->File = (LPSTR)(SrcFile + 1);
strcpy(SrcFile->File, RecordFileName);
SrcFile->RawText = (LPSTR)SrcFile + BaseLen;
Len -= BaseLen;
// Count lines in the source file. Stop before the last character
// to handle the case where there's a newline at the end of the
// file in the same way as where there isn't one.
Lines = 0;
Cur = SrcFile->RawText;
End = SrcFile->RawText + Len;
while (Cur < End - 1)
{
if (*Cur++ == '\n')
{
Lines++;
}
}
Lines++;
SrcFile->LineText = (char **)malloc(sizeof(LPSTR) * Lines);
if (SrcFile->LineText == NULL)
{
goto EH_CloseFile;
}
SrcFile->Lines = Lines;
Cur = SrcFile->RawText;
CurLine = SrcFile->LineText;
LineStart = Cur;
while (Cur < End - 1)
{
if (*Cur == '\n')
{
*CurLine++ = LineStart;
*Cur = 0;
LineStart = Cur+1;
}
else if (*Cur == '\r')
{
*Cur = 0;
}
Cur++;
}
*CurLine++ = LineStart;
delete File;
SrcFile->Next = g_SrcFiles;
g_SrcFiles = SrcFile;
#ifdef VERBOSE_SRC
dprintf("Loaded '%s' '%s' %d lines\n", FileName, RecordFileName, Lines);
#endif
return SrcFile;
EH_CloseFile:
free(SrcFile);
delete File;
return NULL;
}
void
DeleteSrcFile(
PSRCFILE SrcFile
)
{
if (g_CurSrcFile == SrcFile)
{
g_CurSrcFile = NULL;
g_CurSrcLine = 0;
}
free(SrcFile->LineText);
free(SrcFile);
}
BOOL
MatchSrcFileName(
PSRCFILE SrcFile,
LPSTR File
)
{
LPSTR FileStop, MatchStop;
//
// SRCFILE filenames are saved as the partial path that
// matched a source path component rather than the full path
// of the file as loaded. When matching against potentially full
// path information in debug info it's useful to use the incoming
// string as the filename and the SRCFILE filename as the match
// string. A full match indicates that the partial path matches
// completely and so should be used.
//
// This doesn't work so well for human input where the filename is
// likely to be just a filename with no path. In this case there
// won't be a full match of the match string, nor is just flipping
// the order of strings useful because that would allow submatches
// such as "foo.c" matching "barfoo.c". Instead this code tests
// two conditions:
// 1. Full match string match.
// 2. Full file string match (implies partial match string match)
// and the mismatch character is a path separator.
// This forces filenames to match completely.
//
if (SymMatchFileName(File, SrcFile->File, &FileStop, &MatchStop) ||
(FileStop < File && IS_PATH_DELIM(*MatchStop)))
{
#ifdef DBG_SRC
dprintf("'%s' matches '%s'\n", SrcFile->File, File);
#endif
return TRUE;
}
else
{
#ifdef DBG_SRC
dprintf("'%s' doesn't match '%s'\n", SrcFile->File, File);
#endif
return FALSE;
}
}
BOOL
UnloadSrcFile(
LPSTR File
)
{
PSRCFILE SrcFile, Prev;
Prev = NULL;
for (SrcFile = g_SrcFiles; SrcFile != NULL; SrcFile = SrcFile->Next)
{
if (MatchSrcFileName(SrcFile, File))
{
break;
}
Prev = SrcFile;
}
if (SrcFile == NULL)
{
return FALSE;
}
if (Prev != NULL)
{
Prev->Next = SrcFile->Next;
}
else
{
g_SrcFiles = SrcFile->Next;
}
DeleteSrcFile(SrcFile);
return TRUE;
}
void
UnloadSrcFiles(
void
)
{
PSRCFILE Cur, Next;
for (Cur = g_SrcFiles; Cur != NULL; Cur = Next)
{
Next = Cur->Next;
DeleteSrcFile(Cur);
}
g_SrcFiles = NULL;
}
PSRCFILE
FindLoadedSrcFile(
LPSTR File
)
{
PSRCFILE SrcFile;
for (SrcFile = g_SrcFiles; SrcFile != NULL; SrcFile = SrcFile->Next)
{
if (MatchSrcFileName(SrcFile, File))
{
#ifdef DBG_SRC
dprintf("Found loaded file '%s'\n", SrcFile->File);
#endif
return SrcFile;
}
}
return NULL;
}
void
ConcatPathComponents(
LPSTR Path,
LPSTR PathEnd,
LPSTR* PathOut,
LPSTR FilePath,
LPSTR Buffer
)
{
if (PathEnd == NULL)
{
PathEnd = strchr(Path, ';');
if (PathEnd != NULL)
{
if (PathOut != NULL)
{
*PathOut = PathEnd + 1;
}
}
else
{
PathEnd = Path + strlen(Path);
if (PathOut != NULL)
{
*PathOut = NULL;
}
}
}
if (PathEnd > Path)
{
memcpy(Buffer, Path, (int)(PathEnd - Path));
PathEnd = Buffer + (PathEnd - Path - 1);
// Attempt to avoid duplicating separators while forcing separation.
if ((*PathEnd == ':' && *FilePath == ':') ||
(IS_SLASH(*PathEnd) && IS_SLASH(*FilePath)))
{
FilePath++;
}
else if (!IS_PATH_DELIM(*PathEnd) && !IS_PATH_DELIM(*FilePath))
{
*(++PathEnd) = '\\';
}
strcpy(PathEnd + 1, FilePath);
}
else
{
strcpy(Buffer, FilePath);
}
}
void
EditPathSlashes(
LPSTR Path
)
{
if (!IsUrlPathComponent(Path))
{
return;
}
PSTR Scan = Path;
// Flip all backslashes forwards.
while (*Scan)
{
if (*Scan == '\\')
{
*Scan = '/';
}
Scan++;
}
}
BOOL
SrcFileExists(
LPSTR Path,
LPSTR PathEnd,
LPSTR* PathOut,
LPSTR FilePath,
LPSTR File
)
{
char Buffer[MAX_SOURCE_PATH];
ConcatPathComponents(Path, PathEnd, PathOut, FilePath, Buffer);
if (File != NULL)
{
ULONG Len = strlen(Buffer);
Buffer[Len] = '\\';
strcpy(Buffer + Len + 1, File);
}
EditPathSlashes(Buffer);
#ifdef DBG_SRC
dprintf("Check for existence of '%s'\n", Buffer);
#endif
FILE_IO_TYPE IoType;
return PathFileExists(Buffer, g_SymOptions, &IoType);
}
BOOL
FindSrcFileOnPath(
ULONG StartElement,
LPSTR File,
ULONG Flags,
PSTR Found,
PSTR* MatchPart,
PULONG FoundElement
)
{
LPSTR PathSuff;
LPSTR Path;
LPSTR PathStart;
LPSTR PathSep;
LPSTR PathCharPtr;
char PathChar;
ULONG Elt;
// Find the element of the path to start at.
PathStart = FindPathElement(g_SrcPath, StartElement, &PathSep);
if (PathStart == NULL)
{
goto CheckPlainFile;
}
// Split the given filename into a path prefix and a path
// suffix. Initially the path prefix is any path components
// and the path suffix is just the filename. If there
// are path components attempt to match them against the source
// path. Keep backing up the path one component at a time
// until a match is found or the prefix is emptied. At
// that point just do a plain file search along the source path.
PathSuff = File + strlen(File);
for (;;)
{
while (--PathSuff >= File)
{
if (IS_SLASH(*PathSuff) ||
(*PathSuff == ':' && !IS_SLASH(*(PathSuff + 1))))
{
break;
}
}
PathSuff++;
// If we've run out of path prefix we're done with this
// part of the search.
if (PathSuff == File)
{
break;
}
char Save;
LPSTR BestPathStart;
LPSTR BestPathEnd;
LPSTR BestFile;
ULONG BestElement;
LPSTR MatchPath;
LPSTR MatchFile;
Save = *(PathSuff - 1);
*(PathSuff - 1) = 0;
#ifdef DBG_SRC
dprintf("Check path pre '%s' suff '%s'\n",
File, PathSuff);
#endif
Path = PathStart;
Elt = StartElement;
BestPathStart = NULL;
BestFile = PathSuff - 2;
while (*Path != 0)
{
PathSep = strchr(Path, ';');
if (PathSep == NULL)
{
PathSep = Path + strlen(Path);
}
// Trim trailing slashes on path components as
// the file components have them trimmed so
// leaving them would confuse the matching.
PathCharPtr = PathSep;
if (PathCharPtr > Path && IS_SLASH(PathCharPtr[-1]))
{
PathCharPtr--;
}
PathChar = *PathCharPtr;
if (PathChar != 0)
{
*PathCharPtr = 0;
}
else
{
// Back up off the terminator so that PathSep
// can be advanced the same way for both
// ';' and end-of-string cases.
PathSep--;
}
SymMatchFileName(Path, File, &MatchPath, &MatchFile);
#ifdef DBG_SRC
dprintf("Match '%s' against '%s': %d (match '%s')\n",
Path, File, MatchFile - File, MatchFile + 1);
#endif
*PathCharPtr = PathChar;
if (MatchFile < BestFile &&
SrcFileExists(Path, MatchPath + 1, NULL,
MatchFile + 1, PathSuff))
{
BestPathStart = Path;
BestPathEnd = MatchPath + 1;
BestFile = MatchFile + 1;
BestElement = Elt;
// Check for complete match or first-match mode.
if (MatchPath < Path || MatchFile < File ||
(Flags & DEBUG_FIND_SOURCE_BEST_MATCH) == 0)
{
break;
}
}
Path = PathSep + 1;
Elt++;
}
*(PathSuff - 1) = Save;
if (BestPathStart != NULL)
{
#ifdef DBG_SRC
dprintf("Found partial file '%.*s' on path '%.*s'\n",
PathSuff - BestFile, BestFile,
BestPathEnd - BestPathStart, BestPathStart);
#endif
// Return the match found.
ConcatPathComponents(BestPathStart, BestPathEnd, NULL,
BestFile, Found);
EditPathSlashes(Found);
*MatchPart = BestFile;
*FoundElement = BestElement;
#ifdef DBG_SRC
dprintf("Found partial file '%s' at %d\n",
Found, *FoundElement);
#endif
return TRUE;
}
// Skip past separator.
PathSuff--;
}
// Traverse all directories in the source path and try them with the
// filename given. Start with the given filename
// to make the most restrictive check. If
// no match is found keep trimming components off and
// checking again.
PathSuff = File;
for (;;)
{
#ifdef DBG_SRC
dprintf("Scan all paths for '%s'\n", PathSuff);
#endif
Path = PathStart;
Elt = StartElement;
while (Path != NULL && *Path != 0)
{
if (SrcFileExists(Path, NULL, &PathSep, PathSuff, NULL))
{
// SrcFileExists leaves PathSep set to the
// path element after the separator so back up
// one when forming the return path.
if (PathSep != NULL)
{
PathSep--;
}
#ifdef DBG_SRC
dprintf("Found file suffix '%s' on path '%.*s'\n",
PathSuff, PathSep != NULL ?
PathSep - Path : strlen(Path), Path);
#endif
ConcatPathComponents(Path, PathSep, NULL, PathSuff, Found);
EditPathSlashes(Found);
*MatchPart = PathSuff;
*FoundElement = Elt;
#ifdef DBG_SRC
dprintf("Found file suffix '%s' at %d\n",
Found, *FoundElement);
#endif
return TRUE;
}
Path = PathSep;
Elt++;
}
// Trim a component from the front of the path suffix.
PathSep = PathSuff;
while (*PathSep != 0 &&
!IS_SLASH(*PathSep) &&
(*PathSep != ':' || IS_SLASH(*(PathSep + 1))))
{
PathSep++;
}
if (*PathSep == 0)
{
// Nothing left to trim.
break;
}
PathSuff = PathSep + 1;
}
CheckPlainFile:
#ifdef DBG_SRC
dprintf("Check plain file '%s'\n", File);
#endif
if (GetFileAttributes(File) != -1)
{
strcpy(Found, File);
*MatchPart = File;
*FoundElement = -1;
#ifdef DBG_SRC
dprintf("Found plain file '%s' at %d\n", Found, *FoundElement);
#endif
return TRUE;
}
return FALSE;
}
PSRCFILE
LoadSrcFileOnPath(
LPSTR File
)
{
if (g_SrcPath == NULL)
{
return LoadSrcFile(File, File);
}
char Found[MAX_SOURCE_PATH];
PSTR MatchPart;
ULONG Elt;
if (FindSrcFileOnPath(0, File, DEBUG_FIND_SOURCE_BEST_MATCH,
Found, &MatchPart, &Elt))
{
return LoadSrcFile(Found, MatchPart);
}
dprintf("No source found for '%s'\n", File);
return NULL;
}
PSRCFILE
FindSrcFile(
LPSTR File
)
{
PSRCFILE SrcFile;
#ifdef DBG_SRC
dprintf("Find '%s'\n", File);
#endif
SrcFile = FindLoadedSrcFile(File);
if (SrcFile == NULL)
{
SrcFile = LoadSrcFileOnPath(File);
}
return SrcFile;
}
void
OutputLineAddr(
ULONG64 Offset
)
{
IMAGEHLP_LINE64 Line;
ULONG Disp;
Line.SizeOfStruct = sizeof(Line);
if (SymGetLineFromAddr64(g_CurrentProcess->Handle,
Offset,
&Disp,
&Line))
{
dprintf("%s(%d)", Line.FileName, Line.LineNumber);
if (Disp != 0)
{
dprintf("+0x%x", Disp);
}
dprintf("\n");
}
}
void
OutputSrcLines(
PSRCFILE File,
ULONG First,
ULONG Last,
ULONG Mark
)
{
ULONG i;
LPSTR *Text;
if (First < 1)
{
First = 1;
}
if (Last > File->Lines)
{
Last = File->Lines;
}
Text = &File->LineText[First-1];
for (i = First; i <= Last; i++)
{
if (i == Mark)
{
dprintf(">");
}
else
{
dprintf(" ");
}
dprintf("%5d: %s\n", i, *Text++);
}
}
BOOL
OutputSrcLinesAroundAddr(
ULONG64 Offset,
ULONG Before,
ULONG After
)
{
IMAGEHLP_LINE64 Line;
ULONG Disp;
PSRCFILE SrcFile;
Line.SizeOfStruct = sizeof(Line);
if (!SymGetLineFromAddr64(g_CurrentProcess->Handle,
Offset,
&Disp,
&Line))
{
return FALSE;
}
SrcFile = FindSrcFile(Line.FileName);
if (SrcFile == NULL)
{
return FALSE;
}
OutputSrcLines(SrcFile,
Line.LineNumber-Before, Line.LineNumber+After-1,
Line.LineNumber);
return TRUE;
}
ULONG
GetOffsetFromLine(
PSTR FileLine,
PULONG64 Offset
)
{
IMAGEHLP_LINE64 Line;
LPSTR Mod;
LPSTR File;
LPSTR LineStr;
LPSTR SlashF, SlashB;
ULONG LineNum;
ULONG Disp;
ULONG OldSym;
ULONG NewSym;
BOOL AllowDisp;
BOOL Ret;
PDEBUG_IMAGE_INFO Image = NULL;
if ((g_SymOptions & SYMOPT_LOAD_LINES) == 0)
{
WarnOut("WARNING: Line information loading disabled\n");
}
OldSym = g_SymOptions;
NewSym = g_SymOptions;
// Symbol directives can prefix the source expression.
// These can be given by sufficiently knowledgeable users
// but they're primarily a back-channel communication
// mechanism for windbg's source management.
if (*FileLine == '<')
{
FileLine++;
while (*FileLine != '>')
{
switch(*FileLine)
{
case 'U':
// Restrict the search to just loaded modules.
NewSym |= SYMOPT_NO_UNQUALIFIED_LOADS;
break;
default:
error(SYNTAX);
}
FileLine++;
}
FileLine++;
}
// Crack string of the form [module!][file][:line] into its
// components. Note that ! is a valid filename character so
// it's possible for ambiguity to occur between module references
// and filenames. This code assumes that ! is uncommon and
// handles it as a module separator unless there's a : or \ or /
// before it. : can also occur in paths and is filtered
// in a similar manner.
File = strchr(FileLine, '!');
LineStr = strchr(FileLine, ':');
SlashF = strchr(FileLine, '/');
SlashB = strchr(FileLine, '\\');
if (File != NULL &&
(LineStr != NULL && File > LineStr) ||
(SlashF != NULL && File > SlashF) ||
(SlashB != NULL && File > SlashB))
{
File = NULL;
}
if (File != NULL)
{
if (File == FileLine)
{
error(SYNTAX);
}
Mod = FileLine;
*File++ = 0;
}
else
{
Mod = NULL;
File = FileLine;
}
// If a module was specified check and see if it's
// a module that's currently present as that
// will affect which error code is returned.
if (Mod != NULL)
{
Image = GetImageByName(g_CurrentProcess, Mod, INAME_MODULE);
}
// Look for the first colon after path components.
while (LineStr != NULL &&
(LineStr < File || LineStr < SlashF || LineStr < SlashB))
{
LineStr = strchr(LineStr + 1, ':');
}
LineNum = 1;
if (LineStr != NULL)
{
PSTR NumEnd;
// A specific line was given so don't allow a displacement.
AllowDisp = FALSE;
*LineStr = 0;
LineNum = strtoul(LineStr + 1, &NumEnd, 0);
if (*NumEnd == '+')
{
// Setting the high bit of the line number
// tells dbghelp to search in at-or-greater mode.
// This may produce displacements so allow them.
LineNum |= 0x80000000;
AllowDisp = TRUE;
}
else if (*NumEnd == '~')
{
// Find the closest line number.
AllowDisp = TRUE;
}
else if (*NumEnd && *NumEnd != ' ' && *NumEnd != '\t')
{
error(SYNTAX);
}
}
else
{
AllowDisp = TRUE;
}
Line.SizeOfStruct = sizeof(Line);
Ret = FALSE;
// If this is a pure linenumber reference then we need to fill in
// the line information with a current location before doing
// the line-relative query.
if (*File == 0)
{
ADDR Pc;
if (Mod != NULL)
{
goto EH_Ret;
}
g_Machine->GetPC(&Pc);
if (!SymGetLineFromAddr64(g_CurrentProcess->Handle,
Flat(Pc),
&Disp,
&Line))
{
goto EH_Ret;
}
File = NULL;
}
// Establish any special symbol options requested.
SymSetOptions(NewSym);
Ret = SymGetLineFromName64(g_CurrentProcess->Handle, Mod,
File, LineNum, (PLONG)&Disp, &Line);
SymSetOptions(OldSym);
EH_Ret:
if (Mod != NULL)
{
*(File-1) = '!';
}
if (LineStr != NULL)
{
*LineStr = ':';
}
// Only return a match if it's exact or no line number was specified.
if (Ret && (Disp == 0 || AllowDisp))
{
*Offset = Line.Address;
return LINE_FOUND;
}
else if (Image != NULL)
{
return LINE_NOT_FOUND_IN_MODULE;
}
else
{
return LINE_NOT_FOUND;
}
}
void
ParseSrcOptCmd(
CHAR Cmd
)
{
char Cmd2;
DWORD Opt;
Cmd2 = PeekChar();
if (Cmd2 == 'l')
{
g_CurCmd++;
Opt = SRCOPT_LIST_LINE;
}
else if (Cmd2 == 'o')
{
g_CurCmd++;
Opt = SRCOPT_LIST_SOURCE_ONLY;
}
else if (Cmd2 == 's')
{
g_CurCmd++;
Opt = SRCOPT_LIST_SOURCE;
}
else if (Cmd2 == 't')
{
g_CurCmd++;
Opt = SRCOPT_STEP_SOURCE;
}
else if (Cmd2 == '0')
{
// Numeric options.
if (*(++g_CurCmd) != 'x')
{
error(SYNTAX);
}
else
{
g_CurCmd++;
Opt = (DWORD)HexValue(4);
}
}
else if (Cmd2 == '*')
{
g_CurCmd++;
// All.
Opt = 0xffffffff;
}
else if (Cmd2 != 0 && Cmd2 != ';')
{
error(SYNTAX);
}
else
{
// No character means display current settings.
Opt = 0;
}
ULONG OldSrcOpt = g_SrcOptions;
if (Cmd == '+')
{
g_SrcOptions |= Opt;
if ((SymGetOptions() & SYMOPT_LOAD_LINES) == 0)
{
WarnOut(" WARNING: Line information loading disabled\n");
}
}
else
{
g_SrcOptions &= ~Opt;
}
if ((OldSrcOpt ^ g_SrcOptions) & SRCOPT_STEP_SOURCE)
{
NotifyChangeEngineState(DEBUG_CES_CODE_LEVEL,
(g_SrcOptions & SRCOPT_STEP_SOURCE) ?
DEBUG_LEVEL_SOURCE : DEBUG_LEVEL_ASSEMBLY,
TRUE);
}
dprintf("Source options are %x:\n", g_SrcOptions);
if (g_SrcOptions == 0)
{
dprintf(" None\n");
}
else
{
if (g_SrcOptions & SRCOPT_STEP_SOURCE)
{
dprintf(" %2x/t - Step/trace by source line\n",
SRCOPT_STEP_SOURCE);
}
if (g_SrcOptions & SRCOPT_LIST_LINE)
{
dprintf(" %2x/l - List source line for LN and prompt\n",
SRCOPT_LIST_LINE);
}
if (g_SrcOptions & SRCOPT_LIST_SOURCE)
{
dprintf(" %2x/s - List source code at prompt\n",
SRCOPT_LIST_SOURCE);
}
if (g_SrcOptions & SRCOPT_LIST_SOURCE_ONLY)
{
dprintf(" %2x/o - Only show source code at prompt\n",
SRCOPT_LIST_SOURCE_ONLY);
}
}
}
void
ParseSrcLoadCmd(
void
)
{
LPSTR Semi;
PSRCFILE SrcFile;
char Cur;
BOOL Unload;
// Check for an unload request.
Unload = FALSE;
if (*g_CurCmd == '-')
{
g_CurCmd++;
Unload = TRUE;
}
while ((Cur = *g_CurCmd) == ' ' || Cur == '\t')
{
g_CurCmd++;
}
if (Cur == 0 || Cur == ';')
{
error(SYNTAX);
}
// Look for a semicolon, otherwise assume the whole command
// line is the file path.
Semi = strchr(g_CurCmd, ';');
if (Semi != NULL)
{
*Semi = 0;
}
if (Unload)
{
if (UnloadSrcFile(g_CurCmd))
{
dprintf("Unloaded '%s'\n", g_CurCmd);
}
}
else
{
SrcFile = FindSrcFile(g_CurCmd);
if (SrcFile == NULL)
{
dprintf("Unable to load '%s'\n", g_CurCmd);
}
}
if (Semi != NULL)
{
*Semi = ';';
g_CurCmd = Semi;
}
else
{
g_CurCmd += strlen(g_CurCmd);
}
if (!Unload && SrcFile != NULL)
{
g_CurSrcFile = SrcFile;
g_CurSrcLine = 1;
}
}
void
ParseSrcListCmd(
CHAR Cmd
)
{
LONG First, Count;
char Cur;
ULONG OldBase;
ADDR Addr;
ULONG Mark;
if (Cmd == '.')
{
g_CurCmd++;
PDEBUG_SCOPE Scope = GetCurrentScope();
if (Scope->Frame.InstructionOffset)
{
// List current frame
ADDRFLAT(&Addr, Scope->Frame.InstructionOffset);
}
else
{
// List at PC.
g_Machine->GetPC(&Addr);
}
Cmd = 'a';
}
else if (Cmd == 'a')
{
g_CurCmd++;
// List at address, so get an address.
GetAddrExpression(SEGREG_CODE, &Addr);
// Search for and consume trailing ,
while ((Cur = *g_CurCmd) == ' ' || Cur == '\t')
{
g_CurCmd++;
}
if (Cur == ',')
{
Cur = *++g_CurCmd;
if (Cur == 0 || Cur == ';')
{
error(SYNTAX);
}
}
}
else if (Cmd == 'c')
{
g_CurCmd++;
if (g_CurSrcFile != NULL)
{
dprintf("Current: %s(%d)\n", g_CurSrcFile->File, g_CurSrcLine);
}
else
{
dprintf("No current source file\n");
}
return;
}
while ((Cur = *g_CurCmd) == ' ' || Cur == '\t')
{
g_CurCmd++;
}
// Force base 10 for linenumbers.
OldBase = g_DefaultRadix;
g_DefaultRadix = 10;
if (Cur == 0 || Cur == ';')
{
First = Cmd == 'a' ? -4 : g_CurSrcLine;
Count = 10;
}
else if (Cur == ',')
{
First = Cmd == 'a' ? -4 : g_CurSrcLine;
g_CurCmd++;
Count = (ULONG)GetExpression();
}
else
{
First = (ULONG)GetExpression();
if (*g_CurCmd == ',')
{
g_CurCmd++;
Count = (ULONG)GetExpression();
}
else
{
Count = 10;
}
}
g_DefaultRadix = OldBase;
if (Count < 1)
{
error(SYNTAX);
}
Mark = 0;
if (Cmd == 'a')
{
DWORD Disp;
IMAGEHLP_LINE64 Line;
PSRCFILE SrcFile;
// Listing from the source file that Addr is in.
Line.SizeOfStruct = sizeof(Line);
if (!SymGetLineFromAddr64(g_CurrentProcess->Handle,
Flat(Addr),
&Disp,
&Line))
{
return;
}
SrcFile = FindSrcFile(Line.FileName);
if (SrcFile == NULL)
{
return;
}
g_CurSrcFile = SrcFile;
g_CurSrcLine = Line.LineNumber;
Mark = Line.LineNumber;
}
if (g_CurSrcFile == NULL)
{
dprintf("No current source file\n");
return;
}
// Address list commands are always relative,
// as are negative starting positions.
if (Cmd == 'a' || First < 0)
{
g_CurSrcLine += First;
}
else
{
g_CurSrcLine = First;
}
OutputSrcLines(g_CurSrcFile, g_CurSrcLine, g_CurSrcLine+Count-1, Mark);
g_CurSrcLine += Count;
}
void
ParseOciSrcCmd(
void
)
{
if (PeekChar() != ';' && *g_CurCmd)
{
ULONG64 Val1 = GetExpression();
ULONG64 Val2 = 0;
if (PeekChar() != ';' && *g_CurCmd)
{
Val2 = GetExpression();
}
else
{
Val2 = (Val1 + 1) / 2;
Val1 -= Val2;
}
g_OciSrcBefore = (ULONG)Val1;
g_OciSrcAfter = (ULONG)Val2;
}
if ((g_SrcOptions & SRCOPT_LIST_SOURCE) == 0)
{
WarnOut("WARNING: Source line display is disabled\n");
}
dprintf("At the prompt, display %d source lines before and %d after\n",
g_OciSrcBefore, g_OciSrcAfter);
}
void
ParseLines(PSTR Args)
{
ULONG NewOpts = g_SymOptions ^ SYMOPT_LOAD_LINES;
while (Args && *Args)
{
while (*Args == ' ' || *Args == '\t')
{
Args++;
}
if (*Args == '-' || *Args == '/')
{
Args++;
switch(*Args++)
{
case 'd':
NewOpts &= ~SYMOPT_LOAD_LINES;
break;
case 'e':
NewOpts |= SYMOPT_LOAD_LINES;
break;
case 't':
// Toggle, already done.
break;
default:
error(SYNTAX);
}
}
else
{
break;
}
}
SetSymOptions(NewOpts);
if (g_SymOptions & SYMOPT_LOAD_LINES)
{
dprintf("Line number information will be loaded\n");
}
else
{
dprintf("Line number information will not be loaded\n");
}
}
void
ChangeSrcPath(
PSTR Args,
BOOL Append
)
{
while (*Args == ' ' || *Args == '\t')
{
Args++;
}
if (*Args != 0)
{
if (ChangePath(&g_SrcPath, Args, Append,
DEBUG_CSS_PATHS) != S_OK)
{
return;
}
}
if (g_SrcPath == NULL)
{
dprintf("No source search path\n");
}
else
{
dprintf("Source search path is: %s\n", g_SrcPath);
CheckPath(g_SrcPath);
}
}
void
ChangeExePath(
PSTR Args,
BOOL Append
)
{
while (*Args == ' ' || *Args == '\t')
{
Args++;
}
if (*Args != 0)
{
if (ChangePath(&g_ExecutableImageSearchPath, Args, Append,
DEBUG_CSS_PATHS) != S_OK)
{
return;
}
}
if (g_ExecutableImageSearchPath == NULL)
{
dprintf("No exectutable image search path\n");
}
else
{
dprintf("Executable image search path is: %s\n",
g_ExecutableImageSearchPath);
CheckPath(g_ExecutableImageSearchPath);
}
}
Reference in a new issue Copy permalink